libcurl一般用法

#pragma once

#include <string>

#include "libcurl/include/curl/curl.h" 

class HTTPClient
{
    /**
    *
    * http操作
    *
    */
    enum class ACTION : uint8_t
    {
        GET,
        POST,
    };

public:
    /**
    *
    * 析构函数
    *
    */
    ~HTTPClient()
    {
        Clear();
    }

    /**
    *
    * get操作
    *
    * @return 是否处理成功
    *
    */
    bool Get()
    {
        return Launch(ACTION::GET);
    }

    /**
    *
    * post操作
    *
    * @return 是否处理成功
    *
    */
    bool Post()
    {
        return Launch(ACTION::POST);
    }

    /**
    *
    * 端口
    *
    * @return 端口
    *
    */
    const uint16_t Port() const
    {
        return _port;
    }

    /**
    *
    * 最后一次错误信息
    *
    * @return 最后一次错误信息
    *
    */
    const char * LastError() const
    {
        return curl_easy_strerror(_code);
    }

    /**
    *
    * 域名
    *
    * @return 域名
    *
    */
    const std::string & Url() const
    {
        return _url;
    }

    /**
    *
    * 帐号
    *
    * @return 帐号
    *
    */
    const std::string & User() const
    {
        return _user;
    }

    /**
    *
    * 密码
    *
    * @return 密码
    *
    */
    const std::string & Pass() const
    {
        return _pass;
    }

    /**
    *
    * 登陆信息
    *
    * @return 登陆信息
    *
    */
    const std::string & Login() const
    {
        return _login;
    }

    /**
    *
    * 参数
    *
    * @return 参数
    *
    */
    const std::string & Params() const
    {
        return _params;
    }

    /**
    *
    * 响应数据
    *
    * @return 响应数据
    *
    */
    const std::string & Response() const
    {
        return _response;
    }

    /**
    *
    * 设置端口
    *
    * @param port 端口
    *
    */
    void SetPort(const uint16_t port)
    {
        _port = port;
    }

    /**
    *
    * 设置域名
    *
    * @param url 域名
    *
    */
    void SetUrl(const std::string & url)
    {
        _url = url;
    }

    /**
    *
    * 设置帐号
    *
    * @param user 帐号
    *
    */
    void SetUser(const std::string & user)
    {
        _user = user;
    }

    /**
    *
    * 设置密码
    *
    * @param pass 密码
    *
    */
    void SetPass(const std::string & pass)
    {
        _pass = pass;
    }

    /**
    *
    * 设置登陆信息
    *
    * @param user 帐号
    * @param pass 密码
    *
    */
    void SetLogin(const std::string & user, const std::string & pass)
    {
        SetUser(user);
        SetPass(pass);

        _login += user;
        _login += ":";
        _login += pass;
    }

    /**
    *
    * 设置参数
    *
    * @param param 参数
    *
    */
    void SetParam(const std::string & param)
    {
        _params = param;
    }

    /**
    *
    * 添加头部信息
    *
    * @param header 头部信息
    *
    */
    void AddHeader(const char * header)
    {
        _headers = curl_slist_append(_headers, header);
    }

    /**
    * 添加参数
    *
    * @param param 参数
    *
    */
    void AddParam(const std::string & param)
    {
        _params += param;
    }

    /**
    *
    * 添加参数
    *
    * @param key 关键字
    * @param value 数值
    *
    */
    void AddParam(const std::string & key, const std::string & value)
    {
        if (!_params.empty())
        {
            _params += "&";
        }

        _params += key;
        _params += "=";
        _params += value;
    }

    /**
    *
    * 清空数据
    *
    */
    void Clear()
    {
        ClearPort();
        ClearLogin();
        ClearError();
        ClearParams();
        ClearHeader();
        ClearResponse();
    }

    /**
    *
    * 清空端口
    *
    */
    void ClearPort()
    {
        _port = 0;
    }

    /**
    *
    * 清空登陆信息
    *
    */
    void ClearLogin()
    {
        _user.clear();
        _pass.clear();
        _login.clear();
    }

    /**
    *
    * 清空错误信息
    *
    */
    void ClearError()
    {
        _code = CURLE_OK;
    }

    /**
    *
    * 清空参数
    *
    */
    void ClearParams()
    {
        _params.clear();
    }

    /**
    *
    * 清空头部信息
    *
    */
    void ClearHeader()
    {
        if (_headers)
        {
            curl_slist_free_all(_headers);

            _headers = nullptr;
        }
    }

    /**
    *
    * 清空响应数据
    *
    */
    void ClearResponse()
    {
        _response.clear();
    }

protected:
    /**
    *
    * 处理http
    *
    * @param action http操作类型
    *
    * @return 是否处理成功
    *
    */
    bool Launch(ACTION action)
    {
        ClearError();
        ClearResponse();

        CURL * handle = curl_easy_init();

        if (handle == nullptr)
        {
            _code = CURLE_FAILED_INIT;

            return false;
        }

        if (action == ACTION::POST)
        {
            curl_easy_setopt(handle, CURLOPT_POST, 1);

            if (!_params.empty())
            {
                curl_easy_setopt(handle, CURLOPT_POSTFIELDS, _params.data());
                curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE, _params.size());
            }
        }

        if (_port > 0)
        {
            curl_easy_setopt(handle, CURLOPT_PORT, _port);
        }

        if (!_login.empty())
        {
            curl_easy_setopt(handle, CURLOPT_USERPWD, _login.c_str());
        }

        if (_headers)
        {
            curl_easy_setopt(handle, CURLOPT_HTTPHEADER, _headers);
        }

        curl_easy_setopt(handle, CURLOPT_VERBOSE, 0L);
        curl_easy_setopt(handle, CURLOPT_HTTPAUTH, CURLSSH_AUTH_ANY);
        curl_easy_setopt(handle, CURLOPT_URL, _url.data());

        curl_easy_setopt(handle, CURLOPT_WRITEDATA, &_response);
        curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, RespondFunction);

#if 0
        curl_easy_setopt(handle, CURLOPT_READDATA, NULL);
        curl_easy_setopt(handle, CURLOPT_READFUNCTION, NULL);

        curl_easy_setopt(handle, CURLOPT_HEADERDATA, NULL);
        curl_easy_setopt(handle, CURLOPT_HEADERFUNCTION, NULL);
#endif

        // https不验证证书
        curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);
        // https不验证HOST
        curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);

        // 当多个线程都使用超时处理的时候, 同时主线程中有sleep或是wait等操作. 如果不设置这个选项, libcurl将会发信号打断wait从而导致程序退出.
        curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1);
        // 查找次数，防止查找太深
        curl_easy_setopt(handle, CURLOPT_MAXREDIRS, 1);
        // 返回的头部中有Location(一般直接请求的url没找到), 则继续请求Location对应的数据
        curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1);

        //接收数据时超时设置
        curl_easy_setopt(handle, CURLOPT_TIMEOUT, 2);
        // 连接超时
        curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, 2);

        _code = curl_easy_perform(handle);

        curl_easy_cleanup(handle);

        return _code == CURLE_OK;
    }

    /**
    *
    * 响应回调函数
    *
    * @param buffer 响应数据缓冲区
    * @param size 响应数据块大小
    * @param nmemb 响应数据块个数
    * @param stream 存储响应数据地址
    *
    * @return 读取响应数据个数
    *
    */
    static size_t RespondFunction(void * buffer, size_t size, size_t nmemb, void * stream)
    {
        auto str = dynamic_cast<std::string *>((std::string *)stream);

        if (str == nullptr)
        {
            return 0;
        }

        auto realSize = nmemb * size;

        str->append((const char *)buffer, realSize);

        return realSize;
    }

protected:
    CURLcode _code{ CURLE_OK };

    uint16_t _port{ 0 };

    std::string _url{};
    std::string _user{};
    std::string _pass{};
    std::string _login{};
    std::string _params{};
    std::string _response{};

    struct curl_slist * _headers{ nullptr };
};