windows mobile下的wininet的使用2(整理后)

 

#pragma once


#include < vector >
#include < WinInet.h >
#include " NetDefine.h "

#define T_ACCEPT_ENCODING "Accept-Encoding"
#define T_CLIENTAGENT "Client-Agent"
#define T_CALLINGLINEID "x-up-calling-line-id"
#define T_APIVERSION "APIVersion"
#define T_USERID "user-id"
#define T_ACTION "Action"
#define T_COOKIE "Cookie"
#define T_CONTENTTYPE "Content-Type"
#define T_CLIENTTYPE "X-ClientType"
#define T_CONTENTLEN "Content-Length"
#define T_HOST "Host"


#define T_RESULT_CODE "result-code"

// 一个CHttpSession为一个会话，只负责数据部分
class CHttpSession
{
public :
CHttpSession( CRequestBase & aRequest );
~ CHttpSession();

public :
void SetHWnd( HWND aWnd );

HWND GetHWnd()
{
return m_hWnd;
}

// 在调用Get函数时，需要网络返回完成消息才行
inline const char * GetRecvHead();

// 获取返回的数据体
const char * GetRecvieData( )
{
return m_pRecvBuf;
}

// 获取返回数据的长度
DWORD GetReceivedDataLen()
{
return m_dwRecvBodySize;
}

// 获取返回码
int GetRetCode();

// 获取返回数据头中的字段的值,返回字符串的指针需要自己删除
char * GetRetHeadValue( const char * aKey );

int GetResultCode()
{
char * szResultCode = GetRetHeadValue( T_RESULT_CODE );

if ( ! szResultCode )
{
return - 1 ;
}

int nResultCode = atoi( szResultCode );
FREEARRAYIF( szResultCode );
return nResultCode;
}

EM_RequestID GetRequestID()
{
return m_RequestID ;
}

// aRecvHead在函数内分配空间，调用者必须释放
BOOL RetrievingHeaders(HINTERNET hHttp);

// 重置状态，在发起新的请求之前调用
// void Reset();

const char * GetHost()
{
return m_pHost;
}

int GetPort()
{
return m_pPort;
}

char * GetRequestBody()
{
return m_pRequestBody ;
}

int GetRequestBodyLen()
{
return m_dwRequestBodyLen;
}

const char * GetRequestUrl()
{
return m_pRequestUrl;
}

std::vector < char *>& GetRequestHeadVector()
{
return m_vtRequestHead;
}

protected :
// 返回不包含http: // 和域名的
char * SetRequestUrl( const char * aUrl );

// 添加请求头字符串
bool SetHeadValue( const char * aKey, const char * aValue );

// 设置服务器地址
bool SetServer( const char * aServer );

// 设置端口
bool SetPort( int aPort );

// 设置请求数据，仅用于POST请求，GET请求无需使用
bool SetRequestData( const char * aData );

// 设置请求头
bool SetRequestHead( NetMsgHead * pHead );

public :
HANDLE m_hThread; // 下载子线程句柄
DWORD m_dwThreadID; // 线程ID

HINTERNET hInstance;
HINTERNET hConnect;
HINTERNET hRequest;

HANDLE hEvent[ 3 ]; // 0:句柄被创建事件或者读数据请求成功完成事件,1: // 句柄被关闭事件,2:用户要求终止子线程事件或者发生错误事件

char * m_pRecvHead; // 接收到的数据头
char * m_pRecvBuf; // 接收的缓存
DWORD m_dwRecvBodySize; // 收到数据的总大小
DWORD m_dwMaxBuf; // 接收数据缓存的总容器大小
DWORD m_dwStartPos; // 当前缓存的偏移，已存放在缓存中的数据长度

protected :
std::vector < char *> m_vtRequestHead; // 请求消息头的字符串
char * m_pRequestBody; // 请求的消息体
DWORD m_dwRequestBodyLen; // 请求消息体的长度
char * m_pHost; // 服务器地址
int m_pPort; // 端口
char * m_pRequestUrl; // 请求URL地址
HWND m_hWnd; // 用于接收网络通知的窗口句柄
EM_RequestID m_RequestID; // 保留当前网络会话ID
};

class CAsyncWinINet
{
public :
static DWORD download( CHttpSession & aHttpSession );
protected :
static BOOL WaitExitEvent(CHttpSession * p);
static DWORD WINAPI AsyncThread(LPVOID lpParameter);

static VOID CALLBACK AsyncInternetCallback(HINTERNET hInternet,
DWORD dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength);

};

 

#include " stdafx.h "
#include " HttpSession.h "
#include " Util.h "


#pragma comment(lib, "Wininet.lib")

HWND g_hWnd ;

#define CONNECTION_CONTEXT 1
#define REQUEST_CONTEXT 2

#define MAX_BODY_SIZE 10*1024
#define RECV_STEP 1024

DWORD CAsyncWinINet::download( CHttpSession & aHttpSession )
{
aHttpSession.m_hThread = CreateThread(NULL,
0 ,
CAsyncWinINet::AsyncThread,
& aHttpSession,
NULL,
& aHttpSession.m_dwThreadID);

if ( aHttpSession.m_hThread )
{
TraceLog( L " Create DownloadThread sucess, ThreadHandle = %d!\r\n " , aHttpSession.m_dwThreadID );
}

// 等待子线程安全退出
WaitForSingleObject(aHttpSession.m_hThread, INFINITE);
TraceLog( L " download Thread:%d exit!\r\n " ,aHttpSession.m_dwThreadID );

// 关闭线程句柄
CloseHandle(aHttpSession.m_hThread);

return TRUE;
}

DWORD WINAPI CAsyncWinINet::AsyncThread(LPVOID lpParameter)
{
CHttpSession * pSession = (CHttpSession * )lpParameter;

pSession -> hInstance = InternetOpenA( ""
,INTERNET_OPEN_TYPE_PRECONFIG
,NULL
,NULL
,INTERNET_FLAG_ASYNC);

if ( ! pSession -> hInstance ) // 有些手机用上面的参数访问不了Internet
pSession -> hInstance = InternetOpenA( ""
,INTERNET_OPEN_TYPE_DIRECT
,NULL
,NULL
,INTERNET_FLAG_ASYNC);
if ( ! pSession -> hInstance )
{
TraceLog( L " InternetOpen failed, error : %d \r\n " ,GetLastError() );
return false ;
}
TraceLog( L " InternetOpen suceess !\r\n " );

// Setup callback function
// ResetEvent(p->hEvent[0]);
// p->hCallbackThread = CreateThread(NULL,
// 0,
// AsyncWinINet::AsyncCallbackThread,
// p,
// NULL,
// &p->dwCallbackThreadID);
// WaitForSingleObject(p->hEvent[0], INFINITE); // 等待回调函数设置成功事件
if ( InternetSetStatusCallbackA( pSession -> hInstance,CAsyncWinINet::AsyncInternetCallback )
== INTERNET_INVALID_STATUS_CALLBACK )
{
TraceLog( L " InternetSetStatusCallback failed, error : %d \r\n " ,GetLastError() );
return false ;
}
TraceLog( L " InternetSetStatusCallback suceess :%d \r\n " ,GetLastError() );

// First call that will actually complete asynchronously even though there is no network traffic
pSession -> hConnect = InternetConnectA( pSession -> hInstance
,pSession -> GetHost()
,pSession -> GetPort()
,NULL
,NULL
,INTERNET_SERVICE_HTTP
, 0
,(DWORD)pSession); // Connection handle's Context

if ( ! pSession -> hConnect )
{
TraceLog( L " hConnect == NULL, errno = %d \r\n " ,GetLastError() );

if (GetLastError() != ERROR_IO_PENDING)
{
// TODO:退出线程

return false ;
}
}

// Wait until we get the connection handle
// WaitForSingleObject( pSession->hEvent[0], INFINITE);
TraceLog( L " Ready To openRequest \r\n " );

char * pRequestBody = pSession -> GetRequestBody();
char * pVerb = ! pRequestBody ? " GET " : " POST " ;

// Open the request
ResetEvent( pSession -> hEvent[ 0 ] );
pSession -> hRequest = HttpOpenRequestA(pSession -> hConnect
,pVerb
,pSession -> GetRequestUrl()
,NULL // HTTP version ,If this parameter is NULL, the function uses HTTP/1.1 as the version
,NULL // Reference
,NULL // A pointer to a null-terminated array of strings that indicates media types accepted by the client.
,INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE
,(DWORD)pSession); // Request handle's context

// Wait until we get the request handle
// WaitForSingleObject( pSession->hEvent[0], INFINITE );

TraceLog( L " HttpOpenRequest Sucess\r\n " );

// Add Request HeadInfo
std::vector < char *> vtHead = pSession -> GetRequestHeadVector();
for ( unsigned int i = 0 ; i < vtHead.size(); i ++ )
{
char * pItem = vtHead[i];
HttpAddRequestHeadersA(pSession -> hRequest, pItem, - 1 , HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE );
}

int nRequestBodyLen = pSession -> GetRequestBodyLen();

// Sends the specified request to the HTTP server.
// ResetEvent( pSession->hEvent[0] );
if ( ! HttpSendRequestA( pSession -> hRequest
,NULL // Pointer to a null-terminated string that contains the additional headers to be appended to the request.
, 0 // Size of the additional headers
,pRequestBody // Pointer to a buffer containing any optional data to be sent immediately after the request headers.
,nRequestBodyLen )) // Size of the optional data, in bytes.
{
if (GetLastError() != ERROR_IO_PENDING)
{
TraceLog( L " HttpSendRequest failed, error = %d \r\n " , GetLastError() );
return false ;
}
}

TraceLog( L " HttpSendRequest Sucess \r\n " );
WaitForSingleObject( pSession -> hEvent[ 0 ], INFINITE );

// receive Head
pSession -> RetrievingHeaders( pSession -> hRequest );

// 网络错误处理:返回0为正常，非0为错误
int nResultCode = pSession -> GetResultCode();
if ( nResultCode > 0 )
{
PostMessage(pSession -> GetHWnd(), Event_NetError, nResultCode, NULL );
}
else
{
char lpReadBuff[RECV_STEP] ;
DWORD dwStartPos = 0 ;
while ( true )
{
memset(lpReadBuff, 0 , RECV_STEP);
INTERNET_BUFFERSA InetBuff;
FillMemory( & InetBuff, sizeof (InetBuff), 0 );
InetBuff.dwStructSize = sizeof (InetBuff);
InetBuff.lpvBuffer = (LPVOID)lpReadBuff;
InetBuff.dwBufferLength = RECV_STEP;

TraceLog( L " Calling InternetReadFileExA \r\n " );

ResetEvent( pSession -> hEvent[ 0 ] );
if ( ! InternetReadFileExA(pSession -> hRequest, & InetBuff,IRF_ASYNC, (DWORD)pSession) )
{
if (GetLastError() == ERROR_IO_PENDING)
{
TraceLog( L " Waiting for InternetReadFileEx to complete \r\n " );
if (WaitExitEvent(pSession)) break ;
// WaitForSingleObject(pSession->hRequestCompleteEvent, INFINITE);
}
else
{
TraceLog( L " InternetReadFileEx failed, error :%d \r\n " , GetLastError() );
return false ;
}
}
else
{
// 在网络传输速度快，步长较小的情况下，InternetReadFileEx 经常会直接返回成功，
// 因此要判断是否发生了用户要求终止子线程事件。
if (WAIT_OBJECT_0 == WaitForSingleObject(pSession -> hEvent[ 2 ], 0 ))
{
ResetEvent(pSession -> hEvent[ 2 ]);
break ;
}

}
TraceLog( L " InternetReadFileEx success! ReadBufLen = %d \r\n " , InetBuff.dwBufferLength );


if (InetBuff.dwBufferLength == 0 )
{
// TraceLog( L"RecvBuf Complete \r\n");
// bAllDone = TRUE;

// FILE *file;
// file = fopen( "\\a1.jpg", "wb" );
// int nwrite;
// if ( file )
// {
// nwrite = fwrite( m_pRecvBuf, 1, m_dwRecvBodySize, file);
// }
// fclose(file);
// Reset();
PostMessage(pSession -> GetHWnd(), Event_NetState, INTERNET_STATUS_REQUEST_COMPLETE, NULL );
break ; // 接收数据完成，跳出循环
}
else
{
pSession -> m_dwRecvBodySize += InetBuff.dwBufferLength;

if ( ! pSession -> m_pRecvBuf )
{
pSession -> m_pRecvBuf = new char [MAX_BODY_SIZE];
memset( pSession -> m_pRecvBuf, 0 , MAX_BODY_SIZE );
pSession -> m_dwMaxBuf = MAX_BODY_SIZE;
}

// 剩余空间不足,重新分配空间
if ( pSession -> m_dwMaxBuf - dwStartPos < InetBuff.dwBufferLength + 1 )
{
TraceLog( L " Memspace is not enough! " );
char * pTempBuf = pSession -> m_pRecvBuf;
pSession -> m_pRecvBuf = new char [pSession -> m_dwMaxBuf + MAX_BODY_SIZE];
memset( pSession -> m_pRecvBuf, 0 , pSession -> m_dwMaxBuf + MAX_BODY_SIZE);
pSession -> m_dwMaxBuf += MAX_BODY_SIZE;
memcpy( pSession -> m_pRecvBuf, pTempBuf, dwStartPos);
delete[] pTempBuf;
pTempBuf = NULL;
}

TraceLog( L " Memspace is enough! " );
memcpy( pSession -> m_pRecvBuf + dwStartPos, lpReadBuff, InetBuff.dwBufferLength );
TraceLog( L " InternetReadFileEx startPos = %d, curRecvLen = %d, totalSize = %d! \r\n " , dwStartPos, InetBuff.dwBufferLength , pSession -> m_dwRecvBodySize);
dwStartPos += InetBuff.dwBufferLength;
}
}
}

if ( pSession -> hRequest )
{
InternetCloseHandle( pSession -> hRequest ); // 关闭 m_hFile
while ( ! WaitExitEvent( pSession )) // 等待句柄被关闭事件或者要求子线程退出事件
{
ResetEvent( pSession -> hEvent[ 0 ] );
}
}

// 清理资源,结束子进程
// 设置子线程退出事件，通知回调线程退出
SetEvent( pSession -> hEvent[ 2 ] );

// 注销回调函数
InternetSetStatusCallback( pSession -> hInstance, NULL);
InternetCloseHandle( pSession -> hInstance );

return TRUE;
}

BOOL CAsyncWinINet::WaitExitEvent(CHttpSession * aSession)
{
DWORD dwRet = WaitForMultipleObjects( 3 , aSession -> hEvent, FALSE, INFINITE);

switch (dwRet)
{
case WAIT_OBJECT_0: // 句柄被创建事件或者读数据请求成功完成事件
case WAIT_OBJECT_0 + 1 : // 句柄被关闭事件
case WAIT_OBJECT_0 + 2 : // 用户要求终止子线程事件或者发生错误事件
break ;
}

return WAIT_OBJECT_0 != dwRet;
}

VOID CALLBACK CAsyncWinINet::AsyncInternetCallback(HINTERNET hInternet,
DWORD dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength)
{
CHttpSession * pSession = (CHttpSession * )dwContext;

// 在我们的应用中，我们只关心下面三个状态
switch (dwInternetStatus)
{
// 句柄被创建
case INTERNET_STATUS_HANDLE_CREATED:
{
INTERNET_ASYNC_RESULT * pRes = (INTERNET_ASYNC_RESULT * )lpvStatusInformation;
pSession -> hConnect = (HINTERNET)pRes -> dwResult;
TraceLog( L " Connect handle created \r\n " );
SetEvent( pSession -> hConnect );
break ;
}

// 句柄被关闭
case INTERNET_STATUS_HANDLE_CLOSING:
SetEvent( pSession -> hEvent[ 1 ] );
break ;

// 一个请求完成，比如一次句柄创建的请求，或者一次读数据的请求
case INTERNET_STATUS_REQUEST_COMPLETE:
if (ERROR_SUCCESS == ((LPINTERNET_ASYNC_RESULT)
(lpvStatusInformation)) -> dwError)
{
// 设置句柄被创建事件或者读数据成功完成事件
SetEvent( pSession -> hEvent[ 0 ] );
}
else
{
// 如果发生错误，则设置子线程退出事件 这里也是一个陷阱，经常会忽视处理这个错误，
SetEvent( pSession -> hEvent[ 2 ] );
}
break ;

case INTERNET_STATUS_CONNECTION_CLOSED:
SetEvent( pSession -> hEvent[ 2 ] );
break ;
}

};

CHttpSession::CHttpSession( CRequestBase & aRequest )
:m_pRequestBody(NULL),m_pHost(NULL), m_pRequestUrl( NULL ),m_pRecvBuf(NULL),m_pRecvHead(NULL)
,m_dwRecvBodySize( 0 ), m_dwMaxBuf( 0 ) ,m_dwStartPos( 0 ),m_dwRequestBodyLen( 0 ), m_hWnd( 0 ),m_RequestID(EM_Req_Start)
,m_dwThreadID( 0 ),m_hThread( 0 )
{
m_vtRequestHead.clear();

for ( int i = 0 ; i < 3 ; ++ i)
{
hEvent[i] = CreateEvent(NULL,TRUE,FALSE,NULL);
}

NetMsgHead * pHead = aRequest.GetRequestHead();
if ( ! SetRequestHead(pHead) )
return ;

const char * pHost = pHead -> GetHost();
SetServer( pHost );

int port = pHead -> GetPort();
SetPort( port );

const char * pRequestURL = aRequest.GetUrl();
m_pRequestUrl = SetRequestUrl( pRequestURL );

m_RequestID = aRequest.GetRequestID();

bool bPost = aRequest.GetIsPostMsg();
if ( bPost )
{
const char * pData = (( CPostRsqBase * ) & aRequest) -> GetRequestBody();
SetRequestData( pData );
}
else
{
SetRequestData( NULL );
}
}

CHttpSession:: ~ CHttpSession()
{
FREEARRAYIF( m_pRequestBody );
FREEARRAYIF( m_pHost );
FREEARRAYIF( m_pRequestUrl );
FREEARRAYIF( m_pRecvBuf );
FREEARRAYIF( m_pRecvHead );

if (hConnect)
{
InternetCloseHandle(hConnect);
hConnect = NULL;
}

if (hInstance)
{
// 卸载回调
InternetSetStatusCallback(hInstance,NULL);
InternetCloseHandle(hInstance);
hInstance = NULL;
}

if (hRequest)
{
InternetCloseHandle(hRequest);
hRequest = NULL;
}

for ( int i = 0 ; i < 3 ; i ++ )
{
if ( hEvent[i] )
{
CloseHandle(hEvent[i]);
hEvent[i] = NULL;
}
}
}

// void CHttpSession::Reset()
// {
// FREEARRAYIF( m_pRequestBody );
// FREEARRAYIF( m_pHost );
// FREEARRAYIF( m_pRequestUrl );
// FREEARRAYIF( m_pRecvBuf );
// FREEARRAYIF( m_pRecvHead );
//
// m_dwRecvBodySize = 0;
// m_dwMaxBuf = 0;
// m_dwStartPos = 0;
// m_dwRequestBodyLen = 0;
// m_RequestID = EM_Req_Start;
// m_pPort = 0;
//
// if(hConnect)
// {
// InternetCloseHandle(hConnect);
// hConnect = NULL;
// }
//
// if(hInstance)
// {
// // 卸载回调
// InternetSetStatusCallback(hInstance,NULL);
// InternetCloseHandle(hInstance);
// hInstance=NULL;
// }
//
// if(hRequest)
// {
// InternetCloseHandle(hRequest);
// hRequest = NULL;
// }
//
// for ( int i = 0 ; i < 3; i++ )
// {
// if ( hEvent[i] )
// {
// CloseHandle(hEvent[i]);
// hEvent[i] = NULL;
// }
// }
//
// // if(hRequestCompleteEvent)
// // {
// // CloseHandle(hRequestCompleteEvent);
// // hRequestCompleteEvent = NULL;
// // }
// //
// // if(hConnectedEvent)
// // {
// // CloseHandle(hConnectedEvent);
// // hConnectedEvent = NULL;
// // }
// //
// // if(hRequestOpenedEvent)
// // {
// // CloseHandle(hRequestOpenedEvent);
// // hRequestOpenedEvent = NULL;
// // }
//
// for ( unsigned int i = 0 ; i < m_vtRequestHead.size(); i++ )
// {
// char* pItem = m_vtRequestHead[i];
// FREEARRAYIF( pItem );
// }
// m_vtRequestHead.clear();
// }
//
void CHttpSession::SetHWnd( HWND aWnd )
{
m_hWnd = aWnd;
g_hWnd = aWnd;
}

bool CHttpSession::SetHeadValue( const char * aKey, const char * aValue )
{
if ( ! aKey )
return false ;

char * buf = new char [ 256 ];
memset( buf, 0 , 256 );
sprintf( buf, " %s: %s\r\n " , aKey, aValue );

m_vtRequestHead.push_back( buf );
return true ;
}

bool CHttpSession::SetRequestData( const char * aData )
{
if ( ! aData )
return false ;

m_pRequestBody = new char [strlen( aData ) + 1 ];
memset( m_pRequestBody, 0 , strlen( aData ) + 1 );
memcpy( m_pRequestBody, aData, strlen( aData ) );

m_dwRequestBodyLen = strlen( aData );

return true ;
}

bool CHttpSession::SetServer( const char * aServer )
{
if ( ! aServer )
return false ;

m_pHost = new char [strlen( aServer ) + 1 ];
memset( m_pHost, 0 , strlen( aServer ) + 1 );
memcpy( m_pHost, aServer, strlen( aServer ) );

return true ;
}

char * CHttpSession::SetRequestUrl( const char * aUrl )
{
if ( ! aUrl )
return false ;

const char * pUrl = aUrl;

// 检查是否存在http: //
const char * pUrlHead = " http:// " ;
char * pTemp = strstr( pUrl, pUrlHead );

char * pResult = NULL;

// 在开始处
if ( pTemp )
{
if ( pTemp == pUrl )
{
pTemp += strlen( pUrlHead );

// 查找第一个 "/",去掉域名
pTemp = strstr( pTemp, " / " );

if ( ! pTemp )
{
return NULL;
}

pResult = new char [ strlen( pTemp ) + 1 ] ;
memset( pResult, 0 , strlen( pTemp ) + 1 );
memcpy( pResult, pTemp, strlen( pTemp ) );
return pResult;
}
}
else
{
// 没有找到
pResult = new char [ strlen( pUrl ) + 1 ] ;
memset( pResult, 0 , strlen( pUrl ) + 1 );
memcpy( pResult, pUrl, strlen( pUrl ) );
return pResult;
}

return pResult;
}

bool CHttpSession::SetPort( int aPort )
{
if ( aPort < 0 )
{
return false ;
}
m_pPort = aPort;
return true ;
}

bool CHttpSession::SetRequestHead( NetMsgHead * pHead )
{
if ( ! pHead )
return false ;

const char * pszBuf = pHead -> GetAcceptEncoding();
SetHeadValue( T_ACCEPT_ENCODING, pszBuf );

pszBuf = pHead -> GetClientAgent();
SetHeadValue( T_CLIENTAGENT, pszBuf );

pszBuf = pHead -> GetCallingLineID();
SetHeadValue( T_CALLINGLINEID, pszBuf );

pszBuf = pHead -> GetApiVersion();
SetHeadValue( T_APIVERSION, pszBuf );

pszBuf = pHead -> GetContentType();
SetHeadValue( T_CONTENTTYPE, pszBuf );

pszBuf = pHead -> GetXClientType();
SetHeadValue( T_CLIENTTYPE, pszBuf );

pszBuf = pHead -> GetUserid();
SetHeadValue( T_USERID, pszBuf );

pszBuf = pHead -> GetCookie();
SetHeadValue( T_COOKIE, pszBuf );

pszBuf = pHead -> GetAction();
SetHeadValue( T_ACTION, pszBuf );

return true ;
}

BOOL CHttpSession::RetrievingHeaders( HINTERNET hHttp )
{
// LPVOID lpOutBuffer=NULL;
DWORD dwSize = 0 ;

retry:

// This call will fail on the first pass, because no buffer is allocated.
if ( ! HttpQueryInfoA(
hHttp,
HTTP_QUERY_RAW_HEADERS_CRLF,
(LPVOID)m_pRecvHead,
& dwSize,
NULL))
{
if (GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND)
{
TraceLog( L " HttpQueryInfo error : ERROR_HTTP_HEADER_NOT_FOUND \r\n " );
// Code to handle the case where the header isn't available.
return TRUE;
}
else
{
// Check for an insufficient buffer.
if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
{
TraceLog( L " HttpQueryInfo error : ERROR_HTTP_HEADER_NOT_FOUND \r\n " );
m_pRecvHead = new char [dwSize];

// Retry the call.
goto retry;
}
else
{
TraceLog( L " HttpQueryInfo error : %d \r\n " , GetLastError() );

// Error handling code.
if (m_pRecvHead)
{
delete [] m_pRecvHead;
}
return FALSE;
}
}
}

TraceLog( L " HttpQueryInfo sucess lpOutBuffer = %s\r\n " , m_pRecvHead );

return TRUE;
}

int CHttpSession::GetRetCode()
{
if ( ! m_pRecvHead )
{
return - 1 ;
}

// 寻找第一个空格
char * pRet1 = strstr( m_pRecvHead, " " );
if ( ! pRet1 )
{
return - 1 ;
}

char * pStart = pRet1 + 1 ;
char * pRet2 = strstr( pStart, " " );
if ( ! pRet2 )
{
return - 1 ;
}

int nLen = pRet2 - pStart;

char * pRetCode = new char [nLen + 1 ];
memset( pRetCode, 0 , nLen + 1 );
memcpy( pRetCode, pStart, nLen );

int nRet = atoi( pRetCode );
FREEARRAYIF( pRetCode );
return nRet;
}


char * CHttpSession::GetRetHeadValue( const char * aKey )
{
if ( ! m_pRecvHead )
{
return NULL;
}

// 寻找key
char * pResult1 = strstr( m_pRecvHead, aKey );
if ( ! pResult1 )
{
return NULL;
}

pResult1 = strstr( pResult1, " : " );
if ( ! pResult1 )
{
return NULL;
}

pResult1 += strlen( " : " );

char * pResult2 = strstr( pResult1, " \r\n " );

int nValueLen = pResult2 - pResult1 ;
char * pRet = new char [nValueLen + 1 ];
memset( pRet, 0 , nValueLen + 1 );
memcpy( pRet, pResult1, nValueLen );

return pRet;
}


const char * CHttpSession::GetRecvHead()
{
return m_pRecvHead;
}

 

 

 

 

转载于:https://www.cnblogs.com/deagle/articles/1917940.html