基于libcurl的restfull接口 post posts get gets

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

头文件

#pragma once

#ifndef __HTTP_CURL_H__

#define __HTTP_CURL_H__

#include <string>

#include "curl.h"

#include "MqBase.h"

#include "Config.h"

class CHttpClient:public MqBase

{

public:

    CHttpClient(void);

    ~CHttpClient(void);

public:

    /**

    * @brief HTTP POST请求

    * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com

    * @param strPost 输入参数,使用如下格式para1=val1¶2=val2&…

    * @param strResponse 输出参数,返回的内容

    * @return 返回是否Post成功

    */

    int Post(const std::string & strUrl, const std::string & strPost, std::string & strResponse);

    /**

    * @brief HTTP GET请求

    * @param strUrl 输入参数,请求的Url地址,如:http://www.baidu.com

    * @param strResponse 输出参数,返回的内容

    * @return 返回是否Post成功

    */

    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 pCaPath 输入参数,为CA证书的路径.如果输入为NULL,则不验证服务器端证书的有效性.

    * @return 返回是否Post成功

    */

    int Posts(const std::string & strUrl, const std::string & strPost, std::string & strResponse, const char * pCaPath = NULL);

    /**

    * @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);

    HPR_INT32    Init();

    HPR_VOID    Fini();

    HPR_INT32    Connect();

    HPR_VOID    DoPublishAlarm();

    HPR_VOID    CheckMqStatus();

    HPR_INT32    CheckServerStatus( HPR_LONG lTimeOut);

    HPR_VOID    PushMq(char* chMqInfo);

    char*        PopMq();

    HPR_VOID    ClearMqList();

    HPR_INT32    AddToMqSendQueue(string strMsg);

public:

    void SetDebug(bool bDebug);

private:

    bool m_bDebug;

    HPR_HANDLE     m_hLoopPublishMq;

    HPR_BOOL     m_bExit;

    list<char*>    m_listRabbitMq;

};

#endif

源文件

#include "HttpClientCurl.h"

#include "curl.h"

static HPR_VOIDPTR CALLBACK DoPublishAlarmThread(HPR_VOIDPTR param)

{

    CHttpClient *p=(CHttpClient*)param;

    if (p==NULL)

    {

        FIRE_ERROR("input para is NULL");

        return NULL;

    }

    p->DoPublishAlarm();

    return NULL;

}

CHttpClient::CHttpClient(void) :

m_bDebug(false)

{

}

CHttpClient::~CHttpClient(void)

{

}

static int OnDebug(CURL *, curl_infotype itype, char * pData, size_t size, void *)

{

    if(itype == CURLINFO_TEXT)

    {

        //printf("[TEXT]%s\n", pData);

    }

    else if(itype == CURLINFO_HEADER_IN)

    {

        printf("[HEADER_IN]%s\n", pData);

    }

    else if(itype == CURLINFO_HEADER_OUT)

    {

        printf("[HEADER_OUT]%s\n", pData);

    }

    else if(itype == CURLINFO_DATA_IN)

    {

        printf("[DATA_IN]%s\n", pData);

    }

    else if(itype == CURLINFO_DATA_OUT)

    {

        printf("[DATA_OUT]%s\n", pData);

    }

    return ;

}

static size_t OnWriteData(void* buffer, size_t size, size_t nmemb, void* lpVoid)

{

    std::string* str = dynamic_cast<std::string*>((std::string *)lpVoid);

    if( NULL == str || NULL == buffer )

    {

        return -;

    }

    char* pData = (char*)buffer;

    str->append(pData, size * nmemb);

    return nmemb;

}

int CHttpClient::Post(const std::string & strUrl, const std::string & strPost, std::string & strResponse)

{

    CURLcode res;

    CURL* curl = curl_easy_init();

    if(NULL == curl)

    {

        return CURLE_FAILED_INIT;

    }

    if(m_bDebug)

    {

        curl_easy_setopt(curl, CURLOPT_VERBOSE, );

        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);

    }

    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());

    curl_easy_setopt(curl, CURLOPT_POST, );

    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, strPost.c_str());

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, );

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, );

    curl_easy_setopt(curl, CURLOPT_TIMEOUT, );

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);

    return res;

}

int CHttpClient::Get(const std::string & strUrl, std::string & strResponse)

{

    CURLcode res;

    CURL* curl = curl_easy_init();

    if(NULL == curl)

    {

        return CURLE_FAILED_INIT;

    }

    if(m_bDebug)

    {

        curl_easy_setopt(curl, CURLOPT_VERBOSE, );

        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);

    }

    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);

    /**

    * 当多个线程都使用超时处理的时候，同时主线程中有sleep或是wait等操作。

    * 如果不设置这个选项，libcurl将会发信号打断这个wait从而导致程序退出。

    */

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, );

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, );

    curl_easy_setopt(curl, CURLOPT_TIMEOUT, );

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);

    return res;

}

int CHttpClient::Posts(const std::string & strUrl, const std::string & strPost, std::string & strResponse, const char * pCaPath)

{

    CURLcode res;

    CURL* curl = curl_easy_init();

    if(NULL == curl)

    {

        return CURLE_FAILED_INIT;

    }

    if(m_bDebug)

    {

        curl_easy_setopt(curl, CURLOPT_VERBOSE, );

        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);

    }

    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());

    curl_easy_setopt(curl, CURLOPT_POST, );

    if (strPost!="")

    {

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, strPost.c_str());

        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strPost.size());

    }

    //curl_easy_setopt(curl, CURLOPT_, headerlist);

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, );

    if(NULL == pCaPath)

    {

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);

    }

    else

    {

        //缺省情况就是PEM，所以无需设置，另外支持DER

        //curl_easy_setopt(curl,CURLOPT_SSLCERTTYPE,"PEM");

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, true);

        curl_easy_setopt(curl, CURLOPT_CAINFO, pCaPath);

    }

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, );

    curl_easy_setopt(curl, CURLOPT_TIMEOUT, );

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);

    return res;

}

int CHttpClient::Gets(const std::string & strUrl, std::string & strResponse, const char * pCaPath)

{

    CURLcode res;

    CURL* curl = curl_easy_init();

    if(NULL == curl)

    {

        return CURLE_FAILED_INIT;

    }

    if(m_bDebug)

    {

        curl_easy_setopt(curl, CURLOPT_VERBOSE, );

        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);

    }

    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, );

    if(NULL == pCaPath)

    {

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);

    }

    else

    {

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, true);

        curl_easy_setopt(curl, CURLOPT_CAINFO, pCaPath);

    }

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, );

    curl_easy_setopt(curl, CURLOPT_TIMEOUT, );

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);

    return res;

}

///////////////////////////////////////////////////////////////////////////////////////////////

void CHttpClient::SetDebug(bool bDebug)

{

    m_bDebug = bDebug;

}

HPR_INT32 CHttpClient::AddToMqSendQueue(string strMsg)

{

    if (strMsg == "")

    {

        return HPR_ERROR;

    }

    char* chMq = g_MemPool.MemAlloc(strMsg.length());

    if (chMq == NULL)

    {

        FIRE_ERROR("char* chActiveMq = MallocBuff(LARGE_LEN) fail");

        return HPR_ERROR;

    }

    HPR_Strncpy(chMq, strMsg.c_str(), strMsg.length());

    PushMq(chMq);

    return HPR_OK;

}

HPR_INT32    CHttpClient::Init()

{

    HPR_INT32    iRetVal = HPR_ERROR;

    m_strMqIp="";

    m_bExit=HPR_FALSE;

    do

    {

        if (HPR_SemCreate(&m_iSendMqSem, ) != HPR_OK)

        {

            LOG_ERROR("LoopSendMq list semaphore create failed!");

#if defined(OS_WINDOWS)

            m_iSendMqSem = HPR_INVALID_HANDLE;

#endif

            break;

        }

        m_hLoopPublishMq = HPR_Thread_Create(DoPublishAlarmThread, this, );

        if (m_hLoopPublishMq == HPR_INVALID_THREAD)

        {

            FIRE_ERROR("Create publish alarm thread failed!");

            break;

        }

        iRetVal = HPR_OK;

    } while ();

    return iRetVal;

}

HPR_VOID    CHttpClient::Fini()

{

    m_bExit = HPR_TRUE;

    if (m_hLoopPublishMq != HPR_INVALID_THREAD)

    {

        HPR_Thread_Wait(m_hLoopPublishMq);

        m_hLoopPublishMq = HPR_INVALID_THREAD;

    }

#if defined(OS_WINDOWS)

    if (m_iSendMqSem != HPR_INVALID_HANDLE)

    {

        HPR_SemDestroy(&m_iSendMqSem);

        m_iSendMqSem = HPR_INVALID_HANDLE;

    }

#else

    HPR_SemDestroy(&m_iSendMqSem);

#endif

    ClearMqList();

}

HPR_INT32    CHttpClient::Connect()

{

        return HPR_OK;

}

HPR_VOID CHttpClient::DoPublishAlarm()

{

    int iStatus = ;

    string strURL=CConfig::instance()->GetHttpURL();

    std::string strData= "hello Rabbit";

    string strResponse="";

    string strContent="";

    while (!m_bExit)

    {

        char* msg=PopMq();

        if (msg!=NULL)

        {

            strContent=string(msg);

            iStatus=Post(strURL,strContent,strResponse);

            if(iStatus!=CURLE_OK)

            {

                FIRE_ERROR("send data %s faild\n",msg);

                PushMq(msg);

                continue;

            }

            g_MemPool.MemRstore(msg);

            FIRE_INFO("send data sucess %s\n",msg);

        }

    }

}

HPR_VOID CHttpClient::CheckMqStatus()

{

}

HPR_VOID CHttpClient::PushMq(char* chMqInfo)

{

    HPR_Guard lock(&m_iMutex);

    FIRE_INFO("PushActiveMq %s",chMqInfo);

    m_listRabbitMq.push_back(chMqInfo);

    HPR_SemPost(&m_iSendMqSem);

}

char* CHttpClient::PopMq()

{

    char* chMqInfo = NULL;

    do

    {

        if (HPR_SemTimedWait(&m_iSendMqSem, ) != HPR_OK)

        {

            //FIRE_INFO("HPR_SemTimedWait(&m_iSendMqSem, 1000)");

            break;

        }

        HPR_Guard lock(&m_iMutex);

        if (m_listRabbitMq.size() == )

        {

            break;

        }

        else

        {

            chMqInfo = m_listRabbitMq.front();

            m_listRabbitMq.pop_front();

        }

        lock.Release();

    } while ();

    return chMqInfo;

}

HPR_VOID CHttpClient::ClearMqList()

{

    {

        HPR_Guard lock(&m_iMutex);

        while(!m_listRabbitMq.empty())

        {

            char* chMqInfo = m_listRabbitMq.front();

            m_listRabbitMq.pop_front();

            g_MemPool.MemRstore(chMqInfo);

        }

    }

}

HPR_INT32    CHttpClient::CheckServerStatus( HPR_LONG lTimeOut)

{

    return HPR_OK;

}

带有协议头的restfull接口

int CImageTransfer::Posts(const std::string & strUrl, const std::string & strPost, std::string & strResponse, const char * pCaPath)

{

    CURLcode res;

    CURL* curl = curl_easy_init();

    if(NULL == curl)

    {

        return CURLE_FAILED_INIT;

    }

    /*if(m_bDebug)

    {

        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);

        curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);

    }*/

    struct curl_slist *headers = NULL;

    //增加HTTP header

    headers = curl_slist_append(headers, "Accept:application/json");

    headers = curl_slist_append(headers, "Content-Type:application/json");

    headers = curl_slist_append(headers, "charset:utf-8");

    CBase64 pBase;

    string strCode="kqzhcg_hikvision :P3w6%kfm";

    strCode= pBase.Encode(strCode.c_str(),strCode.size());

    strCode="Authorization:"+strCode;

    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

    curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());

    curl_easy_setopt(curl, CURLOPT_POST, );

    if (strPost!="")

    {

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, strPost.c_str());

        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strPost.size());

    }

    //curl_easy_setopt(curl, CURLOPT_, headerlist);

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);

    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, );

    if(NULL == pCaPath)

    {

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);

    }

    else

    {

        //缺省情况就是PEM，所以无需设置，另外支持DER

        //curl_easy_setopt(curl,CURLOPT_SSLCERTTYPE,"PEM");

        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, true);

        curl_easy_setopt(curl, CURLOPT_CAINFO, pCaPath);

    }

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, );

    curl_easy_setopt(curl, CURLOPT_TIMEOUT, );

    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);

    return res;

}