libcurl 的初步使用

最新推荐文章于 2024-06-24 11:54:49 发布
最新推荐文章于 2024-06-24 11:54:49 发布
阅读量763 收藏
点赞数
分类专栏： 开源库使用 文章标签： curl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010311952/article/details/52554393
版权
一、libcurl的http使用
1.libcurl全局初始化与反初始化
初始化：
CURL_EXTERN CURLcode curl_global_init(long flags);
反初始化：
CURL_EXTERN void curl_global_cleanup(void);

curl_global_init(CURL_GLOBAL_ALL);
curl_global_cleanup( );

这是全局初始化函数，并不是线程安全的，只能全局调用一次。

2.libcurl初始化与反初始化
CURL_EXTERN CURL *curl_easy_init(void);
CURL_EXTERN void curl_easy_cleanup(CURL *curl);

局部初始化，可以多次调用。

3.设置CURL指针的属性
CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);

4.执行CURL请求
CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);


5.具体的调用流程：
        (1)全局初始化(仅一次)：curl_global_init(CURL_GLOBAL_ALL);
        (2)局部初始化：curl_easy_init( );
        (3)设置CURL属性：curl_easy_setopt( m_lpCurl, CURLOPT_URL, lpUrl );
        (4)执行请求： curl_easy_perform(m_lpCurl) ;
        (5)局部反初始化：curl_easy_cleanup(m_lpCurl);
        (6)全局反初始化：curl_global_cleanup( );


6.基本的http属性字段的设置:

   (1).设置本次连接的等待时间,仅仅是HTTP连接   
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

   (2)设置URL地址
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

   (3)设置http的头回调函数
    crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERFUNCTION, HeadCallBack );

   (4)设置头回调函数的上下文指针
    crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERDATA, this );

   (5)设置请求方式为post
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POST, 1L);

   (6)设置post所携带的数据
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDS, lpInBuffer);

   (7)设置post数据的大小
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDSIZE, u32InSize);

   (8))设置http请求的返回数据的回调函数的上下文指针
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEDATA, (void*)m_lpBody);

   (9)设置http请求的返回数据的回调函数，body数据的回调
    crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEFUNCTION, BodyCallBack); //回调http的响应数据

7.https相关属性设置
(1)设置SSL证书的路径
   crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CAINFO, s8KeyPathString);

(2)设置是否验证SSL证书
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYPEER, TRUE);

(3)设置SSL证书版本
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSLVERSION , CURL_SSLVERSION_TLSv1_1);

(4)设置是否验证host的证书
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYHOST, FALSE);

(5)设置用户名密码
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_USERPWD, s8Param);

(6)设置认证方式为DIGEST
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPAUTH, (long)CURLAUTH_DIGEST);

(7)设置验证方式BASIC
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);

(8)加入curl的标示头
crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_USERAGENT, "curl/7.47.1");

(9)设置XHASH,CHASH,XHASH等属性值
lpCurlList = curl_slist_append(lpCurlList, GetSHash( ));
lpCurlList = curl_slist_append(lpCurlList, GetCHash( ));
lpCurlList = curl_slist_append(lpCurlList, GetXHash( ));
curl_easy_setopt(m_lpCurl, CURLOPT_HTTPHEADER, lpCurlList);

8.上传文件相关设置
(1)设置上传的文件路径
struct curl_httppost *post = NULL;
struct curl_httppost *last = NULL;
eFormRet = curl_formadd(&post, &last, CURLFORM_COPYNAME, "file", CURLFORM_FILE, lpInBuffer, CURLFORM_END) ;

9.代码示例:
头文件(头文件还需要包含CURL的头文件这里不列举): 
#ifndef _I8H_HTTP_H
#define _I8H_HTTP_H

#include <string.h>
#include "curl.h"

#ifndef VOID
typedef void VOID;
#endif

#ifndef U64
typedef unsigned long long U64 ;
#endif

#ifndef U32
typedef unsigned int U32;
#endif

#ifndef U16
typedef unsigned short U16 ;
#endif

#ifndef U8
typedef unsigned char U8 ;
#endif

#ifndef S32
typedef int S32;
#endif

#ifndef S16
typedef short S16 ;
#endif

#ifndef S8
typedef char S8 ;
#endif

#ifndef TRUE
#define TRUE  1
#endif

#ifndef FALSE
#define FALSE  0
#endif

#define MAX_HASH_CODE_LEN 64

#define I8H_ERROR_CODE_NOERROR 							0	//!没有错误
#define I8H_ERROR_CODE_FAIL							1       //!失败
#define I8H_ERROR_CODE_PASSWORD_ERROR 						2	//!用户名密码错误
#define I8H_ERROR_CODE_NOENOUGHPRI 						3	//!权限不足
#define I8H_ERROR_CODE_NOINIT 							4	//!没有初始化
#define I8H_ERROR_CODE_HASINIT 	     						5	//!已经初始化
#define I8H_ERROR_CODE_ORDER_ERROR						6	//!调用次序错误
#define I8H_ERROR_CODE_PARAMETER_ERROR 						7        //!参数错误
#define I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR					8        //!资源分配错误
#define I8H_ERROR_CODE_CALL3THAPI_ERROR						9	//!调用第三方接口错误
#define I8H_ERROR_CODE_CHAN_ERROR	 					10	//!通道号错误
#define I8H_ERROR_CODE_CHAN_NOTSUPPORT             			  <span style="white-space:pre">	</span>11 	//!通道不支持该操作
#define I8H_ERROR_CODE_OVER_MAXLINK 						12	//!连接到DVR的客户端个数超过最大
#define I8H_ERROR_CODE_VERSIONNOMATCH						13	//!版本不匹配
#define I8H_ERROR_CODE_NETWORK_FAIL						14      //!网络错误(包括连接 发送 接收等错误)
#define I8H_ERROR_CODE_OPENFILE_FAIL						15      //!打开文件出错
#define I8H_ERROR_CODE_UPGRADE_FAIL						16      //!DVR升级失败
#define I8H_ERROR_CODE_DATASERIALIZE_FAIL					17	//!数据序列化错误
#define I8H_ERROR_CODE_DATADESERIALIZE_FAIL					18	//!数据反序列化错误
#define I8H_ERROR_CODE_NOENOUGH_BUF						19	//!缓冲区太小
#define I8H_ERROR_CODE_USERNOTEXIST						20	//!用户不存在
#define I8H_ERROR_CODE_COMMAND_UNSUPPORT					21	//!命令不支持
#define I8H_ERROR_CODE_INVALID_HANDLE						22      //!无效句柄
#define I8H_ERROR_CODE_SERVER_FORBIDDEN						23     //!服务禁止
#define I8H_ERROR_CODE_CONNECT_SSL_ERROR					24     //!SSL连接错误



#define UTILITY_FREE_POINT(x)			\
{									\
	if (NULL != x)					\
{								\
	delete x;					\
	x = NULL;					\
}								\
}

//!检查并释放数组
#define UTILITY_FREE_ARRAY(x)			\
{									\
	if (NULL != x)					\
{								\
	delete[] x;					\
	x = NULL;					\
}								\
}

#define UTILITY_CLEAN_ARRAY(x, size)	\
{									\
	if(NULL != x)					\
{								\
	memset(x, 0, size) ;		\
}								\
}

#define UTILITY_COPY_ARRAY(x, y, size)	\
{									\
	if(NULL != (x) && NULL != (y))	\
{								\
	memcpy((x), (y), size) ;	\
}								\
}

typedef struct _tagHttpHead
{
	U16 u16ResultCode ;
	U16 u16DataType ;
}HttpHead ;


typedef struct _tagHttpBody
{
	S8* lpBuffer;
	U8  u8Full;
	U32 u32Offset;
	U32 u32TotalSize;
}HttpBody;

namespace HTTPSDK
{

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

	S8 *GetUserName( ) ;
	S8 *GetPassword( ) ;

	S8 *GetSHash( );
	S8 *GetCHash( );
	S8 *GetXHash( );

	VOID SetUser(S8 *lpUserName, S8 *lpPassword) ;
	VOID SetHashCode(const S8* lpSHash, const S8* lpCHash, const S8* lpXHash);


	S32 OnGetRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time);
	
	S32 OnPostRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time);

	S32 OnRequest4Https(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time, VOID* lpUser, U32 u32Type);

	S32 OnHeartBeatRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time);

	S32 OnUpload(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time);

	S32 OnUpload4Https(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time);

	static size_t BodyCallBack(void *buffer, size_t size, size_t nmemb, void *stream);

	static size_t HeadCallBack(void *buffer, size_t size, size_t nmemb, void *stream);

	static VOID SafeCopyString(const S8 *lpSrc, S8 *lpDest, S32 DestLen) ;

private:
	CHttpSession(const CHttpSession&){ }
	CHttpSession& operator=(const CHttpSession&){return (*this);}

private:
	CURL* m_lpCurl ;
	HttpHead *m_lpHead ;
	HttpBody *m_lpBody ;
	S8  m_s8UserName[32] ;
	S8  m_s8Password[16] ;
	S8 m_s8SHash[MAX_HASH_CODE_LEN];
	S8 m_s8XHash[MAX_HASH_CODE_LEN];
	S8 m_s8CHash[MAX_HASH_CODE_LEN];

};

}


#endif

源文件: 
#include "I8H_Http.h"
extern S8 s8KeyPathString[256];

namespace HTTPSDK
{


CHttpSession::CHttpSession( )
	:m_lpCurl(NULL)
	,m_lpHead(NULL)
	,m_lpBody(NULL)
{
	UTILITY_CLEAN_ARRAY(m_s8UserName, sizeof(m_s8UserName));
	UTILITY_CLEAN_ARRAY(m_s8Password, sizeof(m_s8Password));
	UTILITY_CLEAN_ARRAY(m_s8SHash, sizeof(m_s8SHash));
	UTILITY_CLEAN_ARRAY(m_s8XHash, sizeof(m_s8XHash));
	UTILITY_CLEAN_ARRAY(m_s8CHash, sizeof(m_s8CHash));
}



CHttpSession::~CHttpSession( )
{
	UTILITY_FREE_POINT(m_lpHead);

	if(m_lpBody != NULL)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);
	}

	UTILITY_FREE_POINT(m_lpBody) ;

}

S8 *CHttpSession::GetUserName( )
{
	return m_s8UserName ;
}


S8 *CHttpSession::GetPassword( )
{
	return m_s8Password ;
}

VOID CHttpSession::SetUser(S8 *lpUserName, S8 *lpPassword)
{
	CHttpSession::SafeCopyString(lpUserName, m_s8UserName, sizeof(m_s8UserName)) ;

	CHttpSession::SafeCopyString(lpPassword, m_s8Password, sizeof(m_s8Password)) ;

}

S8 * CHttpSession::GetSHash()
{
	return m_s8SHash;
}


S8 * CHttpSession::GetCHash()
{
	return m_s8CHash;
}


S8 * CHttpSession::GetXHash()
{
	return m_s8XHash;
}


VOID CHttpSession::SetHashCode(const S8* lpSHash, const S8* lpCHash, const S8* lpXHash)
{
	if(lpSHash != NULL)
	{
		CHttpSession::SafeCopyString(lpSHash, m_s8SHash, sizeof(m_s8SHash));
	}

	if(lpCHash != NULL)
	{
		CHttpSession::SafeCopyString(lpCHash, m_s8CHash, sizeof(m_s8CHash));
	}

	if(lpXHash != NULL)
	{
		CHttpSession::SafeCopyString(lpXHash, m_s8XHash, sizeof(m_s8XHash));
	}
}


VOID CHttpSession::SafeCopyString(const S8 *lpSrc, S8 *lpDest, S32 DestLen)
{
	S32 SrcLen = 0 ;

	if(lpSrc == NULL || lpDest == NULL)
	{
		return ;
	}

	SrcLen = (S32)strlen(lpSrc) ;

	if(SrcLen >= DestLen)
	{
		memcpy(lpDest, lpSrc, DestLen - 1) ;

		lpDest[DestLen - 1] = '\0' ;
	}
	else
	{
		if(SrcLen >= 1)
		{
			strcpy(lpDest, lpSrc) ;
		}
		else
		{
			memset(lpDest, 0, DestLen) ;
		}
	}

}


S32 CHttpSession::OnGetRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time)
{
	U32 u32WaitTime = 0;
	U32 u32TryTimes = 0;
	CURLcode crulCode = CURLE_OK;

	if(lpUrl == NULL || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize <= 0 || u32Time <= 0 || u32OutSize == NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	m_lpHead = new HttpHead;

	m_lpBody = new HttpBody;

	if(m_lpHead == NULL || m_lpBody == NULL)
	{
		UTILITY_FREE_POINT(m_lpHead);
		UTILITY_FREE_POINT(m_lpBody);
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpHead, 0, sizeof(HttpHead));

	memset(m_lpBody, 0, sizeof(HttpBody));

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	u32TryTimes = u32Time & 0xFFFF;

	m_lpBody->u32TotalSize = 1024*1024;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	m_lpBody->lpBuffer = new S8[m_lpBody->u32TotalSize];

	if(m_lpBody->lpBuffer == NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpBody->lpBuffer, 0, m_lpBody->u32TotalSize* sizeof(S8));

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_FRESH_CONNECT, TRUE);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERFUNCTION, HeadCallBack );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERDATA, this );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEDATA, (void*)m_lpBody);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEFUNCTION, BodyCallBack); //回调http的响应数据

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	while(u32TryTimes)
	{
		crulCode = curl_easy_perform(m_lpCurl);

		if(crulCode == CURLE_OK)
		{
			break;
		}
		else
		{
			u32TryTimes--;
		}
	}

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if(m_lpBody->u8Full == 1)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_NOENOUGH_BUF;
	}

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(m_lpHead->u16ResultCode == 404)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_COMMAND_UNSUPPORT;
	}
	else
	{
		*lpOutBuffer = m_lpBody->lpBuffer;

		*u32OutSize = m_lpBody->u32Offset;

		if (m_lpHead->u16ResultCode == 200)
		{
			return I8H_ERROR_CODE_NOERROR;
		}

		return I8H_ERROR_CODE_COMMAND_UNSUPPORT;

	}

}

S32 CHttpSession::OnPostRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time)
{
	U32 u32WaitTime = 0;
	U32 u32TryTimes = 0;
	CURLcode crulCode = CURLE_OK;

	if(lpUrl == NULL || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize <= 0 || u32Time <= 0 || u32OutSize == NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	m_lpHead = new HttpHead;

	m_lpBody = new HttpBody;

	if(m_lpHead == NULL || m_lpBody == NULL)
	{
		UTILITY_FREE_POINT(m_lpHead);
		UTILITY_FREE_POINT(m_lpBody);
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpHead, 0, sizeof(HttpHead));

	memset(m_lpBody, 0, sizeof(HttpBody));

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	u32TryTimes = u32Time & 0xFFFF;

	m_lpBody->u32TotalSize = 1024*1024;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	m_lpBody->lpBuffer = new S8[m_lpBody->u32TotalSize];

	if(m_lpBody->lpBuffer == NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpBody->lpBuffer, 0, m_lpBody->u32TotalSize* sizeof(S8));

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_FRESH_CONNECT, TRUE);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERFUNCTION, HeadCallBack );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERDATA, this );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POST, 1L);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDS, lpInBuffer);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDSIZE, u32InSize);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEDATA, (void*)m_lpBody);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEFUNCTION, BodyCallBack); //回调http的响应数据

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	while(u32TryTimes)
	{
		crulCode = curl_easy_perform(m_lpCurl);

		if(crulCode == CURLE_OK)
		{
			break;
		}
		else
		{
			u32TryTimes--;
		}
	}

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if(m_lpBody->u8Full == 1)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_NOENOUGH_BUF;
	}

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(m_lpHead->u16ResultCode == 404)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_COMMAND_UNSUPPORT;
	}
	else
	{
		*lpOutBuffer = m_lpBody->lpBuffer;

		*u32OutSize = m_lpBody->u32Offset;

		if (m_lpHead->u16ResultCode == 200)
		{
			return I8H_ERROR_CODE_NOERROR;
		}

		return I8H_ERROR_CODE_COMMAND_UNSUPPORT;

	}

}

S32 CHttpSession::OnRequest4Https(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time, VOID* lpUser, U32 u32Type)
{
	U32 u32WaitTime = 0;
	U32 u32TryTimes = 0;
	S8 	s8Param[128]={0};
	char* lpDigest = strstr(lpUrl,"/digest/");
	char* lpBasic = strstr(lpUrl,"/basic/");
	CURLcode crulCode = CURLE_OK;
	struct curl_slist *lpCurlList = NULL;

	if(lpUrl == NULL  || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize < 0 || u32Time <= 0 || u32OutSize == NULL )
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	if(lpDigest != NULL && lpBasic != NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	m_lpHead = new HttpHead;

	m_lpBody = new HttpBody;

	if(m_lpHead == NULL || m_lpBody == NULL)
	{
		UTILITY_FREE_POINT(m_lpHead);
		UTILITY_FREE_POINT(m_lpBody);
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpHead, 0, sizeof(HttpHead));

	memset(m_lpBody, 0, sizeof(HttpBody));

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	u32TryTimes = u32Time & 0xFFFF;

	m_lpBody->u32TotalSize = 1024*1024;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	m_lpBody->lpBuffer = new S8[m_lpBody->u32TotalSize];

	if(m_lpBody->lpBuffer == NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpBody->lpBuffer, 0, m_lpBody->u32TotalSize* sizeof(S8));

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_FRESH_CONNECT, TRUE);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERFUNCTION, HeadCallBack );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERDATA, this);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if(u32Type != 0)
	{
		crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POST, 1L);

		if(crulCode != CURLE_OK)
		{
			UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

			UTILITY_FREE_POINT(m_lpHead);

			UTILITY_FREE_POINT(m_lpBody);

			if(m_lpCurl != NULL)
			{
				curl_easy_cleanup(m_lpCurl);

				m_lpCurl = NULL;
			}

			return I8H_ERROR_CODE_CALL3THAPI_ERROR;
		}

		crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDS, lpInBuffer);

		if(crulCode != CURLE_OK)
		{
			UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

			UTILITY_FREE_POINT(m_lpHead);

			UTILITY_FREE_POINT(m_lpBody);

			if(m_lpCurl != NULL)
			{
				curl_easy_cleanup(m_lpCurl);

				m_lpCurl = NULL;
			}

			return I8H_ERROR_CODE_CALL3THAPI_ERROR;
		}

		crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_POSTFIELDSIZE, u32InSize);

		if(crulCode != CURLE_OK)
		{
			UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

			UTILITY_FREE_POINT(m_lpHead);

			UTILITY_FREE_POINT(m_lpBody);

			if(m_lpCurl != NULL)
			{
				curl_easy_cleanup(m_lpCurl);

				m_lpCurl = NULL;
			}

			return I8H_ERROR_CODE_CALL3THAPI_ERROR;
		}
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEDATA, (void*)m_lpBody);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEFUNCTION, BodyCallBack); //回调http的响应数据

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CAINFO, s8KeyPathString);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYPEER, TRUE);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSLVERSION , CURL_SSLVERSION_TLSv1_1);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYHOST, FALSE);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	sprintf(s8Param, "%s:%s", GetUserName(), GetPassword());

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_USERPWD, s8Param);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if(lpDigest != NULL)
	{
		crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPAUTH, (long)CURLAUTH_DIGEST);

		if(crulCode != CURLE_OK)
		{
			UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

			UTILITY_FREE_POINT(m_lpHead);

			UTILITY_FREE_POINT(m_lpBody);

			if(m_lpCurl != NULL)
			{
				curl_easy_cleanup(m_lpCurl);

				m_lpCurl = NULL;
			}

			return I8H_ERROR_CODE_CALL3THAPI_ERROR;
		}
	}

	if(lpBasic!= NULL)
	{
		crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPAUTH, (long)CURLAUTH_BASIC);

		if(crulCode != CURLE_OK)
		{
			UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

			UTILITY_FREE_POINT(m_lpHead);

			UTILITY_FREE_POINT(m_lpBody);

			if(m_lpCurl != NULL)
			{
				curl_easy_cleanup(m_lpCurl);

				m_lpCurl = NULL;
			}

			return I8H_ERROR_CODE_CALL3THAPI_ERROR;
		}
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_USERAGENT, "curl/7.47.1");

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if((strlen(GetSHash( )) != 0) && (strlen(GetCHash( )) != 0) && (strlen(GetXHash( )) != 0))
	{
		lpCurlList = curl_slist_append(lpCurlList, GetSHash( ));

		lpCurlList = curl_slist_append(lpCurlList, GetCHash( ));

		lpCurlList = curl_slist_append(lpCurlList, GetXHash( ));

		curl_easy_setopt(m_lpCurl, CURLOPT_HTTPHEADER, lpCurlList);
	}


	while(u32TryTimes)
	{
		crulCode = curl_easy_perform(m_lpCurl);

		if(crulCode == CURLE_OK)
		{
			break;
		}
		else
		{
			u32TryTimes--;
		}

	}

	if(lpCurlList != NULL)
	{
		curl_slist_free_all(lpCurlList);
	}

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(crulCode  == CURLE_SSL_CONNECT_ERROR)
		{
			return I8H_ERROR_CODE_CONNECT_SSL_ERROR;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	if(m_lpBody->u8Full == 1)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_NOENOUGH_BUF;
	}

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(m_lpHead->u16ResultCode == 404)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_COMMAND_UNSUPPORT;
	}
	else if(m_lpHead->u16ResultCode == 403)
	{
		UTILITY_FREE_ARRAY(m_lpBody->lpBuffer);

		UTILITY_FREE_POINT(m_lpHead);

		UTILITY_FREE_POINT(m_lpBody);

		return I8H_ERROR_CODE_SERVER_FORBIDDEN;
	}
	else
	{
		if(m_lpHead->u16ResultCode == 200)
		{

		}

		*lpOutBuffer = m_lpBody->lpBuffer;

		*u32OutSize = m_lpBody->u32Offset;

		return I8H_ERROR_CODE_NOERROR;
	}

}

S32 CHttpSession::OnHeartBeatRequest(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time)
{
	U32 u32WaitTime = 0;
	CURLcode crulCode = CURLE_OK;

	if(lpUrl == NULL || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize <= 0 || u32Time <= 0 || u32OutSize == NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	m_lpHead = new HttpHead;

	if(m_lpHead == NULL)
	{
		UTILITY_FREE_POINT(m_lpHead);

		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	memset(m_lpHead, 0, sizeof(HttpHead));

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{

		UTILITY_FREE_POINT(m_lpHead);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_POINT(m_lpHead);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERFUNCTION, HeadCallBack );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_POINT(m_lpHead);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt( m_lpCurl, CURLOPT_HEADERDATA, this );

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_POINT(m_lpHead);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_WRITEFUNCTION, BodyCallBack); //回调http的响应数据

	if(crulCode != CURLE_OK)
	{
		UTILITY_FREE_POINT(m_lpHead);

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_perform(m_lpCurl);

	UTILITY_FREE_POINT(m_lpHead);

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(crulCode != CURLE_OK)
	{
		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}
	else
	{
		return I8H_ERROR_CODE_NOERROR;
	}

}


S32 CHttpSession::OnUpload4Https(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time)
{
	U32 u32WaitTime = 0;
	CURLcode crulCode = CURLE_OK;
	CURLFORMcode eFormRet = CURL_FORMADD_OK;
	struct curl_httppost *post = NULL;
	struct curl_httppost *last = NULL;
	struct curl_slist *headers = NULL;

	if(lpUrl == NULL || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize <= 0 || u32Time <= 0 || u32OutSize == NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}


	headers = curl_slist_append(headers, "Expect:");

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPHEADER, headers);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_VERBOSE, 1);

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CAINFO, s8KeyPathString);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYPEER, TRUE);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_SSL_VERIFYHOST, FALSE);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	eFormRet = curl_formadd(&post, &last, CURLFORM_COPYNAME, "file", CURLFORM_FILE, lpInBuffer, CURLFORM_END) ;

	if(eFormRet != CURL_FORMADD_OK)
	{

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;

	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPPOST, post);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_perform(m_lpCurl);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;

	}

	*lpOutBuffer = NULL;

	*u32OutSize = 0;

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(post != NULL)
	{
		curl_formfree(post);
	}

	if(headers != NULL)
	{
		curl_slist_free_all(headers);
	}

	return I8H_ERROR_CODE_NOERROR;

}


S32 CHttpSession::OnUpload(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time)
{
	U32 u32WaitTime = 0;
	CURLcode crulCode = CURLE_OK;
	CURLFORMcode eFormRet = CURL_FORMADD_OK;
	struct curl_httppost *post = NULL;
	struct curl_httppost *last = NULL;
	struct curl_slist *headers = NULL;

	if(lpUrl == NULL || lpHeader == NULL || lpInBuffer == NULL || lpOutBuffer == NULL || u32InSize <= 0 || u32Time <= 0 || u32OutSize == NULL)
	{
		return I8H_ERROR_CODE_PARAMETER_ERROR;
	}

	u32WaitTime  = (u32Time >> 16) & 0xFFFF;

	m_lpCurl = curl_easy_init( );

	if(m_lpCurl == NULL )
	{
		return I8H_ERROR_CODE_ALLOC_RESOURCE_ERROR;
	}

	headers = curl_slist_append(headers, "Expect:");

	headers = curl_slist_append(headers,"Cookie:s_browsertype=1;");

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPHEADER, headers);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);

		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_VERBOSE, 1);

	eFormRet = curl_formadd(&post, &last, CURLFORM_COPYNAME, "file", CURLFORM_FILE, lpInBuffer, CURLFORM_END) ;

	if(eFormRet != CURL_FORMADD_OK)
	{

		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;

	}


	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_URL, lpUrl);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_HTTPPOST, post);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}


	crulCode = curl_easy_setopt(m_lpCurl, CURLOPT_CONNECTTIMEOUT, u32WaitTime);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;
	}

	crulCode = curl_easy_perform(m_lpCurl);

	if(crulCode != CURLE_OK)
	{
		if(m_lpCurl != NULL)
		{
			curl_easy_cleanup(m_lpCurl);

			m_lpCurl = NULL;
		}

		if(headers != NULL)
		{
			curl_slist_free_all(headers);
		}

		if(post != NULL)
		{
			curl_formfree(post);
		}

		return I8H_ERROR_CODE_CALL3THAPI_ERROR;

	}

	*lpOutBuffer = NULL;

	*u32OutSize = 0;

	if(m_lpCurl != NULL)
	{
		curl_easy_cleanup(m_lpCurl);

		m_lpCurl = NULL;
	}

	if(headers != NULL)
	{
		curl_slist_free_all(headers);
	}

	if(post != NULL)
	{
		curl_formfree(post);
	}

	return I8H_ERROR_CODE_NOERROR;

}



size_t CHttpSession::HeadCallBack(void *buffer, size_t size, size_t nmemb, void *userp)
{
    printf("\r\n HeadCallBack:buffer: %s\r\n", (char*)buffer);
	int retCode = 0 ;

	char* lpSrc = NULL;

	CHttpSession* lpHttp  = (CHttpSession*)userp;

	int ret = sscanf((char*)buffer,"HTTP/1.%*c %3d",&retCode);

	if(ret)
	{
		lpHttp->m_lpHead->u16ResultCode = retCode;
	}

	if((lpSrc = strstr((char*)buffer,"S-HASH")) != NULL)
	{
		CHttpSession::SafeCopyString(lpSrc, lpHttp->m_s8SHash, (S32)strlen(lpSrc) );
	}
	else if((lpSrc = strstr((char*)buffer,"C-HASH")) != NULL)
	{
		CHttpSession::SafeCopyString(lpSrc, lpHttp->m_s8CHash, (S32)strlen(lpSrc));
	}
	else if((lpSrc = strstr((char*)buffer,"X-HASH")) != NULL)
	{
		CHttpSession::SafeCopyString(lpSrc, lpHttp->m_s8XHash, (S32)strlen(lpSrc));
	}

	return size * nmemb;
}



size_t CHttpSession::BodyCallBack(void *ptr, size_t size, size_t nmemb, void *stream)
{
    printf("\r\n BodyCallBack:buffer: %s\r\n", (char*)ptr);
	size_t tSize = 0;

	HttpBody* lpWebParam = (HttpBody*)stream;

	if(lpWebParam->lpBuffer != NULL)
	{
		if(lpWebParam->u32Offset + size * nmemb > lpWebParam->u32TotalSize)
		{
			lpWebParam->u8Full = 1;
		}
		else
		{
			memcpy(lpWebParam->lpBuffer + lpWebParam->u32Offset, ptr, size * nmemb);

			tSize = size * nmemb;

			lpWebParam->u32Offset = (U32)tSize + lpWebParam->u32Offset ;
		}
	}

	return size * nmemb;

}


}




#include "I8H_Http.h"
#include <stdlib.h>

#ifdef WIN32
#include <direct.h>
#else
#include<unistd.h>
#endif

using namespace std;

S8 s8KeyPathString[256] = {0};
S32 OnHttpReq(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time, U32 u32Type);

int main(int argc, char* argv[])
{
    CURLcode crulCode = CURLE_OK;
	char *lpKeyPath = NULL;
    S8* lpInBuffer = (S8*)"{\"type\":0,\"ch\":1,\"param\":{\"ip\":\"192.168.0.216\",\"username\":\"admin\",\"pwd\":\"\"},\"data\":{}}";
	S8* lpOutBuffer = NULL;
	S8 s8Url[256]="www.baidu.com" ;
	S8 s8Header[4] = {0};
	S32 s32Result = 0;
	U32 u32BufferSize = strlen(lpInBuffer) + 1;
	U32 u32OutSize = 0;


#ifdef WIN32
	lpKeyPath=_getcwd(NULL,0);

    strcpy((char*)s8KeyPathString, lpKeyPath);

    strcat((char*)s8KeyPathString, "\\self.pem");
#else
    lpKeyPath = getcwd(NULL,0);

    strcpy((char*)s8KeyPathString, lpKeyPath);

    strcat((char*)s8KeyPathString, "/self.pem");
#endif

	printf("%s\r\n", s8KeyPathString);

    crulCode = curl_global_init(CURL_GLOBAL_ALL);

    s32Result =  OnHttpReq(s8Url, s8Header, s8Header, u32BufferSize, &lpOutBuffer, &u32OutSize, (5 << 16)|1, 0);

	char c = getchar( );

    s32Result =  OnHttpReq((S8*)"http://192.168.0.216:80//goform//frmDevicePara", s8Header, lpInBuffer, u32BufferSize, &lpOutBuffer, &u32OutSize, (5 << 16)|1, 1);

	curl_global_cleanup();

    return 0;
}


S32 OnHttpReq(S8* lpUrl, S8* lpHeader, S8* lpInBuffer,U32 u32InSize, S8** lpOutBuffer, U32* u32OutSize, U32 u32Time, U32 u32Type)
{
    S32 s32Result = -1;

	HTTPSDK::CHttpSession* lpHttp = NULL;

	lpHttp = new HTTPSDK::CHttpSession;

	if(u32Type == 0)
    {
        s32Result = lpHttp->OnGetRequest(lpUrl, lpHeader, lpInBuffer, u32InSize, lpOutBuffer, u32OutSize, u32Time);
    }
    else if(u32Type == 1)
    {
        s32Result = lpHttp->OnPostRequest(lpUrl, lpHeader, lpInBuffer, u32InSize, lpOutBuffer, u32OutSize, u32Time);
    }

	if (s32Result != I8H_ERROR_CODE_NOERROR)
	{
		printf("http request error!\r\n");
	}

	UTILITY_FREE_POINT(lpHttp);

	return s32Result;
}

github源码:  https://github.com/JannyMon/CurlDemo

有生皆苦
关注
专栏目录
使用Windbg动态调试排查软件启动不了的问题
dvlinker的技术专栏
09-02 3万+
本文详细讲述如何使用Windbg动态调试去分析程序启动不了的问题。
libcurl的使用
烟消bug云散的专栏
03-11 468
项目中后面预计用到libcurl来做相关的Http的客户端。所以这边先学习下，作为一个技术储备。参考网址：1.官方网址：https://curl.haxx.se/libcurl/2.很详细的windows例子：(暂时只实现了部分功能，其他的只是看了)http://blog.csdn.net/kaitiren/article/details/393962372.使用libcurl进行http通讯网络...
libcurl 使用
weixin_30859423的博客
04-02 106
关于libcurl的文章网络上很多, 这里不再描述. 以下是如何使用libcurl的例子. 一、常用函数 1) libcurl的全局初始化及释放 CURLcode curl_global_init(long flags) flags:CURL_GLOBAL_ALL //初始化所有的可能的调用。 ...
CURL_EXTERN CURLcode curl_easy_perform(CURL *curl)；
最新发布
Edidaughter的博客
06-24 469
2. 枚举类型CURLcode的枚举值。
libcurl 简单使用
Scl_Diligent的博客
04-11 931
LibCurl是一个开源的免费的多协议数据传输开源库，该框架具备跨平台性，开源免费，并提供了包括HTTPFTPSMTPPOP3等协议的功能，使用libcurl可以方便地进行网络数据传输操作，如发送HTTP请求、下载文件、发送电子邮件等。它被广泛应用于各种网络应用开发中，特别是涉及到数据传输的场景。
libcurl库使用方法
深之JohnChen的专栏
08-20 1万+
一、ibcurl作为是一个多协议的便于客户端使用的URL传输库，基于C语言，提供C语言的API接口，支持DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP这些协议，同时支持使用SSL...
Libcurl简明使用指南
把握自己。
04-08 3065
Libcurl为一个免费开源的，客户端url传输库，支持FTP，FTPS，TFTP，HTTP，HTTPS，GOPHER，TELNET，DICT，FILE和LDAP，跨平台，支持Windows，Unix，Linux等，线程安全，支持Ipv6。并且易于使用。 http://curl.haxx.se/libcurl/ 从http://curl.haxx.se/libcurl/ 下载一个稳定的
libcurl 探索之旅：libcurl 分别在 Unix 环境和 Windows 环境下的编译与使用
(ÒωÓױ)
08-14 5305
一、引言 因为工作的原因，加上自己的一点点兴趣爱好，今天花了一整天的时间去探索和学习 libcurl。 libcurl 的文档是非常齐全的，并且在获取到了源代码之后，里面的代码、文档、工具等等都是非常完善的。可是对于新人来说，想要从这么复杂多样的文档中摸索出来适合自己入门的方向，实在是有些困难。这篇博客，就是想要给同样深陷于 libcurl 复杂的文档中不能自拔的程序员同僚们一条我自己走出来的...
ubuntu安装libcurl
09-02
引用: 初步怀疑是少了curl的库，去百度搜了一下，库的名字为libcurl。使用 apt-get install libcurl3 后编译，还是提示找不到头文件。经过搜索，在Ubuntu下是需要安装 libcurl4-openssl-dev 。安装完成后 查看是否有...
用libcurl和libjson实现人人网从APP key 获取access_token和session_key
10-20
用libcurl和libjson实现人人网从APP key 获取access_token和session_key，用于CPP SDK，http://wiki.dev.renren.com/wiki/Cpp-sdk-1.0，填入main.cpp中的session key here即可调用。
ipa在win10使用IDAPro如何检测该应用是否可以使用网络代理进行数据转发
06-08
需要注意的是，这只是初步的检测步骤，如果您想更加深入地分析和检测网络代理的使用情况，可能需要使用更加专业的安全工具和技术。同时，如果应用程序具有使用网络代理进行数据转发的功能，您需要及时报告给应用...
如何使用 C 语言进行网络编程
网络编程是指使用编程语言来实现计算机之间的通信和数据交换，实现不同计算机之间的数据传输和通信。 ## 1.2 C 语言与网络编程的关系 C 语言在网络编程中拥有广泛的应用，其底层的特性和丰富的系统调用使其成为网络...
libCurl使用指南
Kaitiren的专栏
12-13 1672
最近的项目中由于要在C++代码中调用PHP的URL，所以不得不借助libcurl这个库，由于第一次用，所以很多地方很是纠结，特此写在这里，方便给同样刚入门的朋友指引。 分两篇介绍，第一篇是理论知识，第二篇是实例。快速链接--libcurl的使用总结（一） 一.下载安装     1.到http://curl.haxx.se/download.html上下载最新版本，由于公司的机器安装rpm
Libcurl 简明使用指南
04-29 3万+
  Libcurl 简明使用指南 Libcurl为一个免费开源的，客户端url传输库，支持FTP，FTPS，TFTP，HTTP，HTTPS，GOPHER，TELNET，DICT，FILE和LDAP，跨平台，支持Windows，Unix，Linux等，线程安全，支持Ipv6。并且易于使用。http://curl.haxx.se/libcurl/ 从http://curl
libcurl简单介绍和使用
gangan
01-29 2万+
1.libcurl简介 libcurl是一个跨平台的网络协议库，支持http, https, ftp, gopher, telnet, dict, file, 和ldap 协议。libcurl同样支持HTTPS证书授权，HTTP POST, HTTP PUT, FTP 上传, HTTP基本表单上传，代理，cookies,和用户认证 libcurl的官网http://curl.haxx.se/ 库下载https://github.com/curl/curl/releases/tag/curl-7_7..
Libcurl使用入门教程
Maybe
03-29 458
原文地址：http://curl.haxx.se/libcurl/c/libcurl-tutorial.html译者：JGood(http://blog.csdn.net/JGood )转载自：http://blog.sina.com.cn/s/blog_72995dcc01014dr1.html译者注：这是一篇介绍如何使用libcurl的入门教程。文档不是逐字逐句按原文翻译，而是根据笔者对lib...
libcurl 使用方法简介
热门推荐
myvest的专栏
09-30 4万+
libcurl 使用方法简介背景简介使用方法1、easy interface使用方法2、multi interface使用方法 背景 最近想做一个简单的HLS拉流程序，HTTP的下载部分觉得采用libcurl来进行比较合适及方便，所以先介绍libcurl的基本用法，然后使用libcurl完成一个简单的下载小程序。 简介 libcurl是一个跨平台的开源网络协议库，支持http, https, rt...
Visual Studio中libcurl库的使用教程
"这篇文档是关于在Visual Studio环境下使用libcurl的教程，涵盖了从下载libcurl源码到编译库，再到在项目中实际应用libcurl的步骤。作者Rosso Salmanzadeh提供了详细的指南，包括创建示例应用程序和添加libcurl库的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值