使用 libcurl 进行上传、下载图片

#if defined(GNUC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored “-Wdeprecated-declarations”
#elif defined(_MSC_VER)
#pragma warning(disable : 4996)
#endif

/*******************************************************************************************
        vic.MINg        2019- 07-06
        VS中定位当前工程项目的根目录
        只在window下使用
********************************************************************************************/


#pragma once


#include <windows.h>
#include <string>
using namespace std;




class DirectoryManager
{
public:
    static string GetRootDirectory();


    static string GetExeDirectory();


private:
    //构造函数
    DirectoryManager() {};


    //获取当前项目根目录
    static void loadRootDir();


    //获取exe文件目录
    static void loadExeDir();


    //静态数组
    static char rootPath[MAX_PATH];    //根目录
    static char exePath[MAX_PATH];    //执行文件目录


};

/*******************************************************************************************
        vic.MINg        2019- 07-06
********************************************************************************************/


#include "../include/DirectoryManager.h"




//类的静态数组 初始化
char DirectoryManager::rootPath[MAX_PATH] = "";
char DirectoryManager::exePath[MAX_PATH] = "";




string DirectoryManager::GetRootDirectory()
{
    loadRootDir();
    string root = rootPath;
    /*
    for (char &c : root)
    {
    if (c == '\\')
    c = '\/';
    }*/
    for (auto iter = root.begin(); iter != root.end(); iter++)
    {
        if (*iter == '\\')
            *iter = '\/';
    }
    return root;
}


string DirectoryManager::GetExeDirectory()
{
    loadExeDir();
    string exe = exePath;
    exe = exe.substr(0, exe.find_last_of('\\')+1);
    /*
    for (char &c : exe)
    {
    if (c == '\\')
    c = '\/';
    }*/
    for (auto iter = exe.begin(); iter != exe.end(); iter++)
    {
        if (*iter == '\\')
            *iter = '\/';
    }
    return exe;
}


//获取当前项目根目录
void DirectoryManager::loadRootDir()
{
    GetCurrentDirectory(MAX_PATH, rootPath);
}


//获取exe文件目录
void DirectoryManager::loadExeDir()
{
    GetModuleFileName(NULL, exePath, MAX_PATH);
}

/** 
 * 任务池模型，TaskPool.h
 */


#pragma once


#include <thread>
#include <mutex>
#include <condition_variable>
#include <list>
#include <vector>
#include <memory>
#include <iostream>


class Task
{
public:
    virtual void doIt()
    {
        std::cout << "handle a task..." << std::endl;
    }


    virtual ~Task()
    {
        //为了看到一个task的销毁，这里刻意补上其析构函数
        std::cout << "a task destructed..." << std::endl;
    }
};


class TaskPool final
{
    friend class HttpDownloader;
public:
    TaskPool();
    ~TaskPool();
    TaskPool(const TaskPool& rhs) = delete;
    TaskPool& operator=(const TaskPool& rhs) = delete;


public:
    void init(int threadNum = 4);
    void stop();


    void addTask(Task* task);
    void removeAllTasks();
    void runTaskPool() { m_bRunning = true; }
    bool isEmptyTask() { return m_taskList.empty(); }


private:
    void threadFunc();


private:
    std::list<std::shared_ptr<Task>>            m_taskList;
    std::mutex                                  m_mutexList;
    std::condition_variable                     m_cv;
    bool                                        m_bRunning;
    std::vector<std::shared_ptr<std::thread>>   m_threads;




    std::condition_variable               m_finish_cv;
    std::mutex                                  m_finish_mutex;
};

#include "../include/TaskPool.h"


TaskPool::TaskPool() : m_bRunning(false)
{


}


TaskPool::~TaskPool()
{
    removeAllTasks();
}


void TaskPool::init(int threadNum/* = 5*/)
{
    if (threadNum <= 0)
        threadNum = 5;


    m_bRunning = true;


    for (int i = 0; i < threadNum; ++i)
    {
        std::shared_ptr<std::thread> spThread;
        spThread.reset(new std::thread(std::bind(&TaskPool::threadFunc, this)));
        m_threads.push_back(spThread);
    }
}


void TaskPool::threadFunc()
{
    std::shared_ptr<Task> spTask;
    while (true)
    {
        std::unique_lock<std::mutex> guard(m_mutexList);
        while (m_taskList.empty())
        {                 
            if (!m_bRunning)
                break;


            //如果获得了互斥锁，但是条件不合适的话，pthread_cond_wait会释放锁，不往下执行。
            //当发生变化后，条件合适，pthread_cond_wait将直接获得锁。
            m_cv.wait(guard);
        }


        if (!m_bRunning)
            break;


        spTask = m_taskList.front();
        m_taskList.pop_front();


        if (spTask == NULL)
            continue;


        spTask->doIt();
        spTask.reset();


        m_finish_cv.notify_one();                        // 线程下载完毕 通知完成
    }


    std::cout << "exit thread, threadID: " << std::this_thread::get_id() << std::endl;
}


void TaskPool::stop()
{
    m_bRunning = false;
    m_cv.notify_all();


    //等待所有线程退出
    for (auto& iter : m_threads)
    {
        if (iter->joinable())
            iter->join();
    }
}


void TaskPool::addTask(Task* task)
{
    std::shared_ptr<Task> spTask;
    spTask.reset(task);


    {
        std::lock_guard<std::mutex> guard(m_mutexList);       
        //m_taskList.push_back(std::make_shared<Task>(task));
        m_taskList.push_back(spTask);
        std::cout << "add a Task." << std::endl;
    }


    m_cv.notify_one();
}


void TaskPool::removeAllTasks()
{
    {
        std::lock_guard<std::mutex> guard(m_mutexList);
        for (auto& iter : m_taskList)
        {
            iter.reset();
        }
        m_taskList.clear();
    }
}

/*************************************************
        vic.MINg        2021/03/30
        原子锁
************************************************/


#pragma once


#include <atomic>
#include <memory>


// 原子锁
class HttpLock
{
public:
    HttpLock():m_flag_(false)            {  }


    void Lock() 
    {
        bool expect = false;
        while (!m_flag_.compare_exchange_weak(expect, true))
        {
            expect = false;        // 这里一定要将 expect 复原，执行失败时 expect 结果是未定的
        }
    }


    void UnLock() 
    {
        m_flag_.store(false);
    }


private:
    std::atomic<bool> m_flag_;
};




class DoHttpLock
{
public:
    DoHttpLock(std::shared_ptr<HttpLock> & lock)
        : m_lock(lock)
    {
        m_lock->Lock();
    }


    ~DoHttpLock()
    {
        m_lock->UnLock();
    }


private:
    std::shared_ptr<HttpLock> m_lock;
};

/*************************************************
        vic.MINg        2021/03/30
        HTTP 辅助类
************************************************/


#pragma once


#include <curl/curl.h>
#include <libgo.h>
#include <atomic>
#include <memory>
#include <list>


#include "HttpLock.h"
#include "HttpRequest.h"
#include "HttpDownloader.h"


class HttpHelper {
protected:
    HttpHelper();


public:
    ~HttpHelper();


    static HttpHelper& Instance()                                                    // 这里 Instance 只负责原子叠加
    {
        static HttpHelper the_single_instance;
        s_id++;
        return the_single_instance;
    }


    static void set_share_handle(CURL* curl_handle);                        // 如果 总是访问 同一个服务器 ，有必要设置 DNS共享


    static void RequestCoroutine(void* param);                                //  HTTP请求 协程
    static void RequestThread(void* param);                                    //  HTTP请求 线程
    static size_t RetriveHeaderFunction(char *buffer, size_t size, size_t nitems, void *userdata);                // 检索 头 函数
    static size_t RetriveContentFunction(char *ptr, size_t size, size_t nmemb, void *userdata);                    // 检索 内容 函数


    static void DownloadCoroutine(void* param);                        // 下载 协程
    static void DownloadThread(void* param);                            // 下载 线程
    static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata);
    static int progress_callback(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow);




    static std::list< std::shared_ptr<HttpRequest::RequestHelper> >                    s_async_requests;
    static std::list< std::shared_ptr<HttpDownloader::DownloadHelper> >        s_async_downloads;


    static std::atomic<int>                        s_id;                                    // 原子计数
    static std::shared_ptr<HttpLock>       s_request_lock;
    static std::shared_ptr<HttpLock>       s_download_lock;
    static CURLSH*                                    s_share_handle;


    static std::condition_variable                s_request_cv;
    static std::condition_variable                s_download_cv;
};

#include "../include/HttpHelper.h"


#include <thread>




std::list< std::shared_ptr<HttpRequest::RequestHelper> >            HttpHelper::s_async_requests;
std::list< std::shared_ptr<HttpDownloader::DownloadHelper> > HttpHelper::s_async_downloads;
std::atomic<int> HttpHelper::s_id{0};
std::shared_ptr<HttpLock> HttpHelper::s_request_lock(new HttpLock);
std::shared_ptr<HttpLock> HttpHelper::s_download_lock(new HttpLock);
CURLSH* HttpHelper::s_share_handle = nullptr;


std::condition_variable HttpHelper::s_request_cv;
std::condition_variable HttpHelper::s_download_cv;


HttpHelper::HttpHelper()
{
    curl_global_init(CURL_GLOBAL_DEFAULT);


    s_share_handle = curl_share_init();
    curl_share_setopt(s_share_handle, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
}


HttpHelper::~HttpHelper()
{
    curl_share_cleanup(s_share_handle);
    curl_global_cleanup();


    s_async_requests.clear();
    s_async_downloads.clear();
}


void HttpHelper::set_share_handle(CURL* curl_handle)
{
    curl_easy_setopt(curl_handle, CURLOPT_SHARE, s_share_handle);
    curl_easy_setopt(curl_handle, CURLOPT_DNS_CACHE_TIMEOUT, 60 * 5);
}


void HttpHelper::RequestCoroutine(void* param)
{
    co_sleep(10);


    std::shared_ptr<HttpRequest::RequestHelper>* request = reinterpret_cast<std::shared_ptr<HttpRequest::RequestHelper>*>(param);


    if (request)
    {
        (*request)->Perform();
        co_yield;                                                        // 请求以后 可以交给其他 协程处理
        //if ((*request)->SelfClose())
        {
        //    DoHttpLock http_lock(s_request_lock);
        //    HttpHelper::s_async_requests.remove(*request);
        }
    }
}


void HttpHelper::RequestThread(void* param)
{
    std::shared_ptr<HttpRequest::RequestHelper>* request = reinterpret_cast<std::shared_ptr<HttpRequest::RequestHelper>*>(param);


    if (request)
    {
        (*request)->Perform();
        std::unique_lock < std::mutex > uniqlock((*request)->m_mutex);
        s_request_cv.wait(uniqlock, [request] {           // 这里的判断条件为lambda表达式，判断请求是否关闭，未关闭返回false，否则返回true
            if ((*request)->SelfClose())                            // 调用wait函数
                return true;
            return false;
        });


        // std::this_thread::sleep_for(std::chrono::milliseconds(100));
        DoHttpLock http_lock(s_request_lock);
        HttpHelper::s_async_requests.remove(*request);
        uniqlock.unlock();
    }
}




size_t HttpHelper::RetriveHeaderFunction(char *buffer, size_t size, size_t nitems, void *userdata)
{
    std::string* receive_header = reinterpret_cast<std::string*>(userdata);
    if (receive_header && buffer)
    {
        receive_header->append(reinterpret_cast<const char*>(buffer), size * nitems);
    }


    return nitems * size;
}


size_t HttpHelper::RetriveContentFunction(char *ptr, size_t size, size_t nmemb, void *userdata)
{
    std::string* receive_content = reinterpret_cast<std::string*>(userdata);
    if (receive_content && ptr)
    {
        receive_content->append(reinterpret_cast<const char*>(ptr), size * nmemb);
    }


    return nmemb * size;
}


void HttpHelper::DownloadCoroutine(void* param)
{
    co_sleep(10);
    std::shared_ptr<HttpDownloader::DownloadHelper>* request = reinterpret_cast<std::shared_ptr<HttpDownloader::DownloadHelper>*>(param);


    if (request)
    {
        (*request)->Perform();
        co_yield;
        if ((*request)->SelfClose())
        {
            DoHttpLock http_lock(s_download_lock);
            HttpHelper::s_async_downloads.remove(*request);
        }
    }
}


void HttpHelper::DownloadThread(void* param)
{
    std::shared_ptr<HttpDownloader::DownloadHelper>* request = reinterpret_cast<std::shared_ptr<HttpDownloader::DownloadHelper>*>(param);


    if (request)
    {
        (*request)->Perform();
        std::unique_lock < std::mutex > uniqlock((*request)->m_mutex);
        s_download_cv.wait(uniqlock, [request] {           // 这里的判断条件为lambda表达式，判断请求是否关闭，未关闭返回false，否则返回true
            if ((*request)->SelfClose())                            // 调用wait函数
                return true;
            return false;
        });


        //std::this_thread::sleep_for(std::chrono::milliseconds(100));
        DoHttpLock http_lock(s_download_lock);
        HttpHelper::s_async_downloads.remove(*request);
        uniqlock.unlock();
    }
}


size_t HttpHelper::write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
{
    HttpDownloader::DownloadHelper::ThreadChunk* thread_chunk = reinterpret_cast<HttpDownloader::DownloadHelper::ThreadChunk*>(userdata);


    if (thread_chunk->_download->m_is_cancel)
    {
        return 0;
    }


    DoHttpLock http_lock(thread_chunk->_download->m_httplock);
    size_t written = 0;
    int real_size = size * nmemb;
    if (thread_chunk->_endidx > 0)
    {
        if (thread_chunk->_startidx <= thread_chunk->_endidx)
        {
            if (thread_chunk->_startidx + real_size > thread_chunk->_endidx)
            {
                real_size = thread_chunk->_endidx - thread_chunk->_startidx + 1;
            }
        }
    }


    int seek_error = fseek(thread_chunk->_fp, thread_chunk->_startidx, SEEK_SET);
    if (seek_error != 0)
    {
        perror("fseek");
    }
    else
    {
        written = fwrite(ptr, 1, real_size, thread_chunk->_fp);
    }
    thread_chunk->_download->m_downloaded_size += written;
    thread_chunk->_startidx += written;


    return written;
}


int HttpHelper::progress_callback(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
    HttpDownloader::DownloadHelper::ThreadChunk* thread_chunk = reinterpret_cast<HttpDownloader::DownloadHelper::ThreadChunk*>(clientp);


    DoHttpLock http_lock(thread_chunk->_download->m_httplock);


    double total_size = thread_chunk->_download->m_total_size;
    double downloaded_size = thread_chunk->_download->m_downloaded_size;
    void* userdata = thread_chunk->_download->m_userdata;
    int callback_result = thread_chunk->_download->m_download_callback(total_size, downloaded_size, userdata);


    return callback_result;
}

/*************************************************
        vic.MINg        2021/03/30
        http 客户端请求   curl 实现
************************************************/


#pragma once


#include <string>
#include <functional>
#include <memory>
#include <map>
#include <curl/curl.h>
#include <mutex>


class HttpRequest
{
public:
    typedef enum {
        REQUEST_SYNC,                                                //  同步
        REQUEST_ASYNC,                                            //  异步
    }RequestType;


    typedef enum {
        REQUEST_OK,
        REQUEST_INVALID_OPT,
        REQUEST_PERFORM_ERROR,
        REQUEST_OPENFILE_ERROR,
        REQUEST_INIT_ERROR,
    }RequestResult;


    //int id, bool success, const std::string& data
    typedef std::function<void(int, bool, const std::string&)> ResultCallback;


    friend class HttpHelper;


    HttpRequest();
    ~HttpRequest() = default;




    int SetRetryTimes(int retry_times = s_kRetryCount);
    int SetRequestId(int id);
    int SetRequestTimeout(long time_out = 0);
    int SetRequestUrl(const std::string& url);


    int SetMovedUrl(bool get_moved_url);                                            // 重定向 url （true 表示 重定向）
    int SetPostData(const std::string& message);
    int SetPostData(const void* data, unsigned int size);
    int SetPostFile(const std::string& flag_name, const std::string& file_path);                // post 上传文件


    int SetRequestHeader(const std::map<std::string, std::string>& headers);                // 请求头信息
    int SetRequestHeader(const std::string& header);
    int SetRequestProxy(const std::string& proxy, long proxy_port);                                // 代理




    int SetResultCallback(ResultCallback rc);


    void* PerformRequest(RequestType request_type);
    static void Close(void* request_handle);


    static bool GetHttpCode(void* request_handle, long* http_code);
    static bool GetReceiveHeader(void* request_handle, std::string* header);
    static bool GetReceiveContent(void* request_handle, std::string* receive);
    static bool GetErrorString(void* request_handle, std::string* error_string);


protected:
    class RequestHelper {
    public:
        RequestHelper();
        ~RequestHelper();


        friend class HttpRequest;
        friend class HttpHelper;


        int      SetRetryTimes(int retry_times) { m_retry_times = retry_times; return REQUEST_OK; }


        int      SetRequestTimeout(long time_out = 0);
        int      SetRequestUrl(const std::string& url);
        int      SetMovedUrl(bool get_moved_url);
        int      SetPostData(const void* data, unsigned int size);
        int           SetPostFile(const std::string& flag_name, const std::string& file_path);
        int      SetRequestHeader(const std::string& header);
        int      SetRequestProxy(const std::string& proxy, long proxy_port);


        int      SetResultCallback(ResultCallback rc);


        int      Perform();


        long     GetHttpCode() { return m_http_code; }
        bool     GetHeader(std::string* header);
        bool     GetContent(std::string* receive);
        bool     GetErrorString(std::string* error_string);


        bool     SelfClose(void) { return m_close_self; }


    protected:
        void    ReqeustResultDefault(int id, bool success, const std::string& data);


    private:
        CURL*                m_curl_handle;
        curl_slist*            m_http_headers;
        curl_httppost* m_file_post;                    // 上传文件 指针 执行后需要 清理


        int                    m_retry_times;
        int                    m_id;
        bool        m_close_self;
        bool        m_is_running;
        long        m_http_code;


        std::string     m_receive_content;
        std::string     m_receive_header;
        std::string     m_error_string;
        char*               m_post_data;


        std::mutex        m_mutex;                        // 互斥锁 ，通知条件变量 使用


        ResultCallback  m_result_callback;
    };


private:
    std::shared_ptr<RequestHelper>  m_request_handle;
    static const int               s_kRetryCount = 3;                                        // 重试次数
};

#include "../include/HttpRequest.h"
#include "../include/HttpHelper.h"


HttpRequest::RequestHelper::RequestHelper()
    : m_curl_handle(nullptr)
    , m_http_headers(nullptr)
    , m_close_self(false)
    , m_is_running(false)
    , m_retry_times(HttpRequest::s_kRetryCount)
    , m_http_code(0)
    , m_post_data(nullptr)
    , m_file_post(nullptr)
{
    m_result_callback = std::bind(&RequestHelper::ReqeustResultDefault, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    m_id = HttpHelper::s_id;
    m_curl_handle = curl_easy_init();
    HttpHelper::set_share_handle(m_curl_handle);
}


HttpRequest::RequestHelper::~RequestHelper()
{
    if (m_curl_handle)
    {
        curl_easy_cleanup(m_curl_handle);
    }
    if (m_http_headers)
    {
        curl_slist_free_all(reinterpret_cast<curl_slist*>(m_http_headers));
    }
    if (m_post_data)
    {
        delete m_post_data;
        m_post_data = nullptr;
    }
}


int HttpRequest::RequestHelper::SetRequestTimeout(long time_out)
{
    if (m_curl_handle)
    {
        return curl_easy_setopt(m_curl_handle, CURLOPT_TIMEOUT, 0);
    }
    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetRequestUrl(const std::string& url)
{
    if (m_curl_handle)
    {
        if (url.substr(0, 5) == "https")                                    // 处理加密得 HTTPS 协议
        {
            curl_easy_setopt(m_curl_handle, CURLOPT_SSL_VERIFYPEER, 0L);
            curl_easy_setopt(m_curl_handle, CURLOPT_SSL_VERIFYHOST, 0L);
        }


        curl_easy_setopt(m_curl_handle, CURLOPT_VERBOSE, 1L);        //打开终端打印
        return curl_easy_setopt(m_curl_handle, CURLOPT_URL, url.c_str());
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetMovedUrl(bool get_moved_url)
{
    if (m_curl_handle)
    {
        if (get_moved_url)                                    // 是否重定向
        {
            curl_easy_setopt(m_curl_handle, CURLOPT_MAXREDIRS, 5);
            return curl_easy_setopt(m_curl_handle, CURLOPT_FOLLOWLOCATION, 1L);
        }
        else
        {
            return curl_easy_setopt(m_curl_handle, CURLOPT_FOLLOWLOCATION, 0L);
        }
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetPostData(const void* data, unsigned int size)
{
    if (m_curl_handle /*&& data && size > 0*/)
    {
        CURLcode curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_POST, 1);        //  设置 post 请求
        if (curl_code == CURLE_OK)
        {
            if (m_post_data)
            {
                delete m_post_data;
                m_post_data = nullptr;
            }


            if (size == 0)
            {
                curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_POSTFIELDS, "");
            }
            else
            {
                m_post_data = new char[size];
                memcpy(m_post_data, data, size);
                curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_POSTFIELDS, m_post_data);
            }
        }


        if (curl_code == CURLE_OK)
        {
            curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_POSTFIELDSIZE, size);
        }


        return curl_code;
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetPostFile(const std::string& flag_name, const std::string& file_path)
{
    if (m_curl_handle /*&& data && size > 0*/)
    {
        CURLcode curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_CUSTOMREQUEST, "POST");
        struct curl_httppost *FormPost = 0;
        struct curl_httppost *LastPost = 0;


        CURLFORMcode  form_code = curl_formadd(&FormPost, &LastPost, 
                                                                                CURLFORM_COPYNAME, flag_name.c_str(), 
                                                                                CURLFORM_FILE, file_path.c_str(), 
                                                                                CURLFORM_END);
        if (form_code != CURL_FORMADD_OK)    
            return CURLE_HTTP_POST_ERROR;


        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_HTTPPOST, FormPost);
        m_file_post = FormPost;
        return curl_code;
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetRequestHeader(const std::string& header)
{
    if (m_curl_handle && header.empty() == false)
    {
        m_http_headers = curl_slist_append(reinterpret_cast<curl_slist*>(m_http_headers), header.c_str());


        return m_http_headers ? CURLE_OK : CURLE_FAILED_INIT;
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetRequestProxy(const std::string& proxy, long proxy_port)
{
    //CURLOPT_PROXY
    if (m_curl_handle)
    {
        CURLcode curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_PROXYPORT, proxy_port);


        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_PROXY, proxy.c_str());


        return curl_code;
    }


    return CURLE_FAILED_INIT;
}


int HttpRequest::RequestHelper::SetResultCallback(ResultCallback rc)
{
    m_result_callback = rc;


    return CURLE_OK;
}


void HttpRequest::RequestHelper::ReqeustResultDefault(int id, bool success, const std::string& data)
{
    //default request callback do nothing
}


int HttpRequest::RequestHelper::Perform()
{
    if (m_curl_handle)
    {
        CURLcode curl_code;
        if (m_http_headers)
        {
            curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_HTTPHEADER, reinterpret_cast<curl_slist*>(m_http_headers));
            if (curl_code != CURLE_OK)
            {
                return curl_code;
            }
        }


        m_is_running = true;
        m_receive_header.clear();
        m_receive_content.clear();


        //set force http redirect
        SetMovedUrl(true);


        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_HEADERFUNCTION, HttpHelper::RetriveHeaderFunction);
        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_HEADERDATA, &m_receive_header);


        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_WRITEFUNCTION, HttpHelper::RetriveContentFunction);
        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_WRITEDATA, &m_receive_content);


        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_NOPROGRESS, 1);
        // 在多线程场景下应该设置CURLOPT_NOSIGNAL选项，因为在解析DNS出现超时的时候将会发生“糟糕”的情况。
        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_NOSIGNAL, 1);        
        curl_code = curl_easy_setopt(m_curl_handle, CURLOPT_CONNECTTIMEOUT_MS, 0);


        curl_code = curl_easy_perform(m_curl_handle);
        if (curl_code == CURLE_OPERATION_TIMEDOUT)
        {
            int retry_count = m_retry_times;
            while (retry_count > 0)
            {
                curl_code = curl_easy_perform(m_curl_handle);
                if (curl_code != CURLE_OPERATION_TIMEDOUT) break;
                retry_count--;
            }
        }


        curl_easy_getinfo(m_curl_handle, CURLINFO_RESPONSE_CODE, &m_http_code);
        if (curl_code == CURLE_OK && m_http_code == 200)
        {
            m_result_callback(m_id, true, m_receive_content);
        }
        else
        {
            const char* err_string = curl_easy_strerror(curl_code);
            m_error_string = err_string;
            curl_code = CURLE_HTTP_POST_ERROR;
            m_result_callback(m_id, false, m_error_string);
        }


        m_is_running = false;


        if (m_http_headers)
        {
            curl_slist_free_all(reinterpret_cast<curl_slist*>(m_http_headers));
            m_http_headers = nullptr;
        }


        if (m_file_post)
        {
            curl_formfree(m_file_post);
            m_file_post = nullptr;
        }


        return curl_code;
    }


    return CURLE_FAILED_INIT;
}


bool HttpRequest::RequestHelper::GetHeader(std::string* header)
{
    if (m_receive_header.empty()) return false;
    else if (header) *header = m_receive_header;


    return true;
}


bool HttpRequest::RequestHelper::GetContent(std::string* receive)
{
    if (m_receive_content.empty()) return false;
    else if (receive) *receive = m_receive_content;


    return true;
}


bool HttpRequest::RequestHelper::GetErrorString(std::string* error_string)
{
    if (m_error_string.empty()) return false;
    else if (error_string) *error_string = m_error_string;


    return true;
}