libcurl 下载上传

近来一个新的项目需要使用到http。

本来用socket来写一个的，后来发现功能实在太简单，有点捉襟见肘。

于是改用libcur来做。

首先下载libcur的源码，然后配置：

./configure --prefix=$HOME/csource/linux/ CFLAGS='-O2 -m32 -fPIC' --enable-optimize  --enable-static=libcurl.a --enable-ftp --without-zlib --disable-gopher --disable-rtsp --disable-dict --enable-proxy --disable-telnet  --enable-tftp   --disable-pop3   --disable-imap   --enable-smtp  --enable-ipv6  --enable-http -enable-crypto-auth  --without-gnutls --without-nss --without-ca-bundle --with-random=/dev/urandom

然后编译

make && make install

代码如下，使用一个c++类来管理

重点代码是DownloadFile和UploadFile

#ifndef __MY_HTTP_CURL_H
#define __MY_HTTP_CURL_H

#include <string>

typedef long long LongSize;

typedef int (*pCallBack)(double dtotal, double dnow);

class CMYHttpClient
{
public:
        CMYHttpClient();
        ~CMYHttpClient();

public:
        /**
        * @brief 下载请求, 支持断点续传
        * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
        * @param strFile 输入参数，本地存储的文件名
        * @param timeout 输入参数，超时限制，0为永久等待
        * @return 返回是否下载成功:true成功，false失败
        */
        bool DownloadFile(const char *strUrl, const char *strFile, pCallBack cb = NULL, int timeout = 0);
        /**
        * @brief 获取将要下载的文件的大小，失败返回-1，成功返回非负
        * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
        * @return 返回文件的大小，失败返回-1
        */
        LongSize GetDownloadFileSize(const char *strUrl);
        /**
        * @brief 上载请求, 支持断点续传
        * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
        * @param strFile 输入参数，请求上载的文件名
        * @param timeout 输入参数，超时限制，0为永久等待
        * @return 返回是否下载成功:true成功，false失败
        */
        bool UploadFile(const char *strUrl, const char *strFile, pCallBack cb = NULL, int timeout = 0);

public:
        /**
        * @brief HTTP POST请求
        * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
        * @param strPost 输入参数,使用如下格式para1=val1¶2=val2&…
        * @param strResponse 输出参数,返回的内容
        * @param nResponse 输入输出参数,输入缓冲区大小，返回读入缓冲区的内容大小
        * @param strFile 输入文件参数,返回的内容保存在这个文件中
        * @param strHeader 输入参数,需要额外指定的http头,如果输入为NULL，则忽略
        * @return 返回是否Post成功:0成功，非0失败
        */
        int Post(const char *strUrl, const char* strPost, size_t nPost,
                        const char *strFile, const char* strHeader);
        int Post(const char *strUrl, const char* strPost, size_t nPost,
                 char *strResponse, size_t &nResponse, const char *strHeader);
        int Post(const std::string &strUrl, const std::string &strPost,
                        const char *strFile, const char* strHeader);
        int Post(const std::string &strUrl, const std::string &strPost,
                std::string &strResponse, const char *strHeader);

        /**
        * @brief HTTP GET请求
        * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com
        * @param strFile 输入文件参数,返回的内容保存在这个文件中
        * @param strResponse 输出参数,返回的内容
        * @param nResponse 输入输出参数,输入缓冲区大小，返回读入缓冲区的内容大小
        * @return 返回是否Get成功:0成功，非0失败
        */
        int Get(const char *strUrl, const char *strFile);
        int Get(const char *strUrl, std::string &strResponse);
        int Get(const char *strUrl, char *strResponse, size_t &nResponse);
        int Get(const std::string &strUrl, char *strResponse, size_t &nResponse);
        int Get(const std::string &strUrl, std::string &strResponse);

        /**
        * @brief HTTPS POST请求,无证书版本
        * @param strUrl 输入参数,请求的Url地址,如:https://www.alipay.com
        * @param strPost 输入参数,使用如下格式para1=val1¶2=val2&…
        * @param strResponse 输出参数,返回的内容
        * @param strHeader 输入参数,需要额外指定的http头,如果输入为NULL，则忽略
        * @param pCaPath 输入参数,为CA证书的路径.如果输入为NULL,则不验证服务器端证书的有效性.
        * @return 返回是否Post成功:0成功，非0失败
        */
        int Posts(const char *strUrl, const char *strPost, size_t nPost,
                        const char *strFile, const char *strHeader, const char *pCaPath);
        int Posts(const std::string &strUrl, const std::string &strPost,
                        const char *strFile, const char *strHeader, const char *pCaPath);
        int Posts(const char *strUrl, const char *strPost, size_t nPost,
                char *strResponse, size_t &nResponse, const char *strHeader,
                const char *pCaPath);
        int Posts(const std::string &strUrl, const std::string &strPost,
                        std::string &strResponse, const char *strHeader, const char *pCaPath);

        /**
        * @brief HTTPS GET请求,无证书版本
        * @param strUrl 输入参数,请求的Url地址,如:https://www.alipay.com
        * @param strResponse 输出参数,返回的内容
        * @param pCaPath 输入参数,为CA证书的路径.如果输入为NULL,则不验证服务器端证书的有效性.
        * @return 返回是否Post成功
        */
        int Gets(const std::string &strUrl, std::string &strResponse,
                        const char *pCaPath = NULL);

public:
        void SetDebug(bool bDebug);
        void AbortOperation(bool bAbort = true) { m_bAbort = bAbort; }

private:
        bool m_bDebug;          //是否打开debug
        bool m_bAbort;          //是否放弃操作

        std::string m_strFile;  //需要下载的文件或者上传的文件

        pCallBack       m_fCB;  //上传或者下载时的进度回调函数
        LongSize        m_lUploadPos;   //上传文件的进度

        static int OnProgress(void *pClient, curl_off_t dltotal, curl_off_t dlnow,
                        curl_off_t ultotal, curl_off_t ulnow);
        static size_t OnWriteBuffer2File(char* buffer, size_t size, size_t nmemb, void* arg);
        static size_t OnReadFile2Buffer(char *buffer, size_t size, size_t nmemb, void* arg);
};

#endif

几个主要方法，其中https的编译需要openssl，所以我没做支持。

#include "curl/curl.h"
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>

#include "HttpClient.h"


using namespace std;

CMYHttpClient::CMYHttpClient() :
#ifdef _DEBUG
        m_bDebug(true),
#else
        m_bDebug(false),
#endif
        m_bAbort(false),
        m_fCB(NULL),
        m_lUploadPos(0)
{

}

CMYHttpClient::~CMYHttpClient()
{

}

static int OnDebug(CURL *, curl_infotype itype, char *pData, size_t size, void *)
{
        if(itype == CURLINFO_TEXT)
        {
                //printf("[TEXT]%s
", pData);
        }
        else if(itype == CURLINFO_HEADER_IN)
        {
                printf("[HEADER_IN]%s
", pData);
        }
        else if(itype == CURLINFO_HEADER_OUT)
        {
                printf("[HEADER_OUT]%s
", pData);
        }
        else if(itype == CURLINFO_DATA_IN)
        {
                printf("[DATA_IN]%s
", pData);
        }
        else if(itype == CURLINFO_DATA_OUT)
        {
                printf("[DATA_OUT]%s
", pData);
        }

        return 0;
}

int CRGHttpClient::OnProgress(void *pClient, curl_off_t dltotal, curl_off_t dlnow,
                curl_off_t ultotal, curl_off_t ulnow)
{
        CMYHttpClient* pThis = (CMYHttpClient *)pClient;
        if(NULL == pThis || pThis->m_bAbort)
        {
                //Returning a non-zero value from this callback will cause libcurl to abort
                //the transfer and return CURLE_ABORTED_BY_CALLBACK.
                return __LINE__;
        }
        else
        {
                if(pThis->m_fCB)
                {
                        pThis->m_fCB((double)dltotal, (double)dlnow);
                }
#ifdef _DEBUG
                if(dltotal)
                {
                        cout << "total bytes expects to download: " << dltotal
                                << " and downloaded: " << dlnow << "
";
                }
                else if(ultotal)
                {
                        cout << "total bytes expects to upload: " << ultotal
                                << " and uploaded: " << ulnow << "
";
                }
#endif

                return 0;
        }
}

size_t CMYHttpClient::OnWriteBuffer2File(char* buffer, size_t size, size_t nmemb, void* arg)
{
        CMYHttpClient* pThis = (CMYHttpClient *)arg;
        if(NULL == pThis || pThis->m_bAbort ||
                        NULL == buffer)
        {
                return 0;
        }

        const char* strFile = pThis->m_strFile.c_str();

        ofstream outfile(strFile, ofstream::binary | ofstream::app);
        if(outfile.good())
        {
                const char* pData = (const char *)buffer;
                outfile.write(pData, size * nmemb);

                return nmemb;
        }

        return 0;
}

size_t CMYHttpClient::OnReadFile2Buffer(char *buffer, size_t size, size_t nmemb, void* arg)
{
        CMYHttpClient* pThis = (CMYHttpClient *)arg;
        if(NULL == pThis || NULL == buffer)
        {
                return 0;
        }

        ifstream infile(pThis->m_strFile.c_str(), ifstream::binary);
        if(infile.good())
        {
                infile.seekg(pThis->m_lUploadPos, infile.beg);
                if(infile.eof() == false)
                {
                        infile.read(buffer, size * nmemb);
                        pThis->m_lUploadPos += infile.gcount();
                        return infile.gcount();
                }
        }

        return 0;
}

LongSize CMYHttpClient::GetDownloadFileSize(const char* strUrl)
{
        if(NULL == strUrl)
                return -1;

        CURL* curl = curl_easy_init();
        if(NULL == curl)
                return -1;

        curl_easy_setopt(curl, CURLOPT_URL, strUrl);
        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
        curl_easy_setopt(curl, CURLOPT_NOBODY, 1);
        CURLcode res = curl_easy_perform(curl);
        if(res == CURLE_OK) {
                double sz = 0;
                res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &sz);

                curl_easy_cleanup(curl);

                return (LongSize)sz;
        }
        else
        {
                cout << curl_easy_strerror(res) << endl;
        }

        curl_easy_cleanup(curl);

        return -1;
}

bool CMYHttpClient::DownloadFile(const char* strUrl, const char* strFile, pCallBack cb, int timeout)
{
        if(NULL == strUrl || NULL == strFile)
        {
                return false;
        }

        //初始化curl库句柄
        CURL* curl = curl_easy_init();
        if(NULL == curl)
        {
                return false;
        }

        m_strFile = string(strFile) + ".dl";
        m_fCB = cb;
        //支持断点续传，先获取文件大小，如果文件存在并且非空，则断点续传
        ifstream infile(m_strFile.c_str(), ifstream::binary);
        if(infile.good())
        {
                infile.seekg(0, infile.end);
                int length = infile.tellg();
                infile.seekg(0, infile.beg);
                if(length > 0)
                {
                        stringstream ss;
                        ss << length;
                        ss << "-";
                        LongSize ltotal = GetDownloadFileSize(strUrl);
                        if(ltotal > 0)
                                ss << ltotal;
                        string srange;
                        ss >> srange;
                        curl_easy_setopt(curl, CURLOPT_RANGE, srange.c_str());
                }
        }
        infile.close();

        CURLcode res;
        if(m_bDebug)
        {
                curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
                curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);
        }

        curl_easy_setopt(curl, CURLOPT_URL, strUrl);
        curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteBuffer2File);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);

        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
        curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, OnProgress);
        curl_easy_setopt(curl, CURLOPT_XFERINFODATA, this);

        /**
        * 当多个线程都使用超时处理的时候，同时主线程中有sleep或是wait等操作。
        * 如果不设置这个选项，libcurl将会发信号打断这个wait从而导致程序退出。
        */
        curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 4); //wait for 4 seconds to connect to server
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);       //0 means block always

        AbortOperation(false);  //reset abort flag
        res = curl_easy_perform(curl);

        curl_easy_cleanup(curl);

        if(res != CURLE_OK)
        {
                cout << curl_easy_strerror(res);
        }
        else
        {
#ifdef _WIN32
                DeleteFile(strFile);
                MoveFile(m_strFile.c_str(), strFile);
#else
                unlink(strFile);
                rename(m_strFile.c_str(), strFile);
#endif
        }


        m_strFile.clear();
        m_fCB = NULL;

        return res == CURLE_OK;
}

bool CMYHttpClient::UploadFile(const char *strUrl, const char *strFile, pCallBack cb, int timeout)
{
        if(NULL == strUrl || NULL == strFile)
        {
                return false;
        }

        //初始化curl库句柄
        CURL* curl = curl_easy_init();
        if(NULL == curl)
        {
                return false;
        }

        CURLcode res;
        m_fCB = cb;
        m_strFile = strFile;
        m_lUploadPos = 0;

        curl_easy_setopt(curl, CURLOPT_URL, strUrl);
        curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

        curl_easy_setopt(curl, CURLOPT_READFUNCTION, OnReadFile2Buffer);
        curl_easy_setopt(curl, CURLOPT_READDATA, this);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL);

        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
        curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, OnProgress);
        curl_easy_setopt(curl, CURLOPT_XFERINFODATA, this);

        curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 4); //wait for 4 seconds to connect to server
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);       //0 means block always

        AbortOperation(false);  //reset abort flag
        res = curl_easy_perform(curl);

        curl_easy_cleanup(curl);

        m_strFile.clear();
        m_fCB = NULL;

        if(res != CURLE_OK)
        {
                cout << curl_easy_strerror(res);
        }

        return res == CURLE_OK;
}