自学教程：C++ HttpQueryInfo函数代码示例

STDMETHODIMP CBHttpRequest::getResponseHeader(BSTR strName, BSTR *retVal){    if(m_nReadyState < 2)        return S_OK;    CBStringA str(strName);    LPSTR pstr = str.GetBuffer();    DWORD dwLen = str.GetLength();    if(!HttpQueryInfo(m_hFile, HTTP_QUERY_CUSTOM, pstr, &dwLen, 0))    {        if (GetLastError()==ERROR_INSUFFICIENT_BUFFER)        {            pstr = str.GetBufferSetLength(dwLen);            HttpQueryInfo(m_hFile, HTTP_QUERY_CUSTOM, pstr, &dwLen, NULL);        }        else            dwLen = 0;    }    str.ReleaseBuffer(dwLen);    *retVal = str.AllocSysString();    return S_OK;}

fsInternetResult fsHttpFile::ProcessRangesResponse(){	CHAR sz [10000];	DWORD dw = sizeof (sz);			BOOL bAcceptRanges = FALSE;	if (HttpQueryInfo (m_hFile, HTTP_QUERY_ACCEPT_RANGES, sz, &dw, NULL))	{		if (stricmp (sz, "bytes") == 0)			bAcceptRanges = TRUE;	}	m_enRST = RST_NONE;	dw = sizeof (sz);			if (!HttpQueryInfo (m_hFile, HTTP_QUERY_CONTENT_RANGE, sz, &dw, NULL))		return bAcceptRanges ? IR_DOUBTFUL_RANGESRESPONSE : IR_RANGESNOTAVAIL;		if (strncmp (sz, "bytes", 5))		return bAcceptRanges ? IR_DOUBTFUL_RANGESRESPONSE : IR_RANGESNOTAVAIL;	int pos = 0;	while (sz [pos++] != ' '); 	if (isdigit (sz [pos]) == false)		return IR_RANGESNOTAVAIL;		UINT64 first = (UINT64) _atoi64 (sz + pos);		while (sz [pos] >= '0' && sz [pos] <= '9')			pos++;	pos++;	UINT64 last = (UINT64) _atoi64 (sz + pos);		if (last < first)			return IR_RANGESNOTAVAIL;		while (sz [pos] >= '0' && sz [pos] <= '9') 		pos++;	pos++;		m_uFileSize = (UINT64) _atoi64 (sz + pos);		if (m_uFileSize < last)			return IR_RANGESNOTAVAIL;	m_enRST = RST_PRESENT;	return IR_SUCCESS;}

void HttpConnection::readResponseHeaders() {    WCHAR *wbuffer = new WCHAR[1024];    DWORD  ddsize = 1024;	StringBuffer headerString;    responseHeaders.clear();    BOOL reqDone = HttpQueryInfo(req, HTTP_QUERY_RAW_HEADERS_CRLF ,(LPVOID)wbuffer, &ddsize, NULL);    if (reqDone == false) {        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {            // Allocate the necessary buffer.            delete [] wbuffer;            wbuffer = new WCHAR[ddsize];            reqDone = HttpQueryInfo(req, HTTP_QUERY_RAW_HEADERS_CRLF ,(LPVOID)wbuffer, &ddsize, NULL);        }    }    if (reqDone) {		headerString.convert(wbuffer);		LOG.debug("Response Headers:", headerString.c_str());		ArrayList headers;		headerString.split(headers, "/r/n");		StringBuffer *prop;		for(ArrayElement* e=headers.front(); e; e=headers.next()) {			prop = dynamic_cast<StringBuffer *>(e);			if(prop->empty()) continue;			size_t colon = prop->find(":");			if (colon != StringBuffer::npos) {				StringBuffer key = prop->substr(0, colon);				StringBuffer value = prop->substr(colon+1);				responseHeaders.put(key.trim(),value.trim());                                              if (canBeLogged(key)) {				    LOG.debug("/t%s : %s", key.c_str(), value.c_str());                } else {                    LOG.debug("/t%s : *****", key.c_str());                }			}			else {				LOG.debug("/t%s", prop->c_str());			}		}    } else {        DWORD err = GetLastError();        const char* msg = createHttpErrorMessage(err);        LOG.error("[HttpConnection] Error reading response headers - code %d: %s", err, msg);        delete [] msg;    }}

void FHttpResponseWinInet::ProcessResponseHeaders(){	::DWORD HeaderSize = 0;	TArray<FString> Result;	if (!HttpQueryInfo(Request.RequestHandle, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &HeaderSize, NULL))	{		uint32 ErrorCode = GetLastError();		if (ErrorCode != ERROR_INSUFFICIENT_BUFFER)		{			UE_LOG(LogHttp, Warning, TEXT("HttpQueryInfo to get header length for all headers failed: %s. %p"), 				*InternetTranslateError(GetLastError()), &Request);		}		if (HeaderSize == 0)		{			UE_LOG(LogHttp, Warning, TEXT("HttpQueryInfo for all headers returned zero header size. %p"), this);		}		TArray<TCHAR> HeaderBuffer;		HeaderBuffer.AddUninitialized(HeaderSize/sizeof(TCHAR));		if (!HttpQueryInfo(Request.RequestHandle, HTTP_QUERY_RAW_HEADERS_CRLF, HeaderBuffer.GetTypedData(), &HeaderSize, NULL))		{			UE_LOG(LogHttp, Warning, TEXT("HttpQueryInfo for all headers failed: %s. %p"), 				*InternetTranslateError(GetLastError()), &Request);		}		// parse all the key/value pairs		const TCHAR* HeaderPtr = HeaderBuffer.GetTypedData();		// don't count the terminating NULL character as one to search.		const TCHAR* EndPtr = HeaderPtr + HeaderBuffer.Num()-1;		while (HeaderPtr < EndPtr)		{			const TCHAR* DelimiterPtr = FCString::Strstr(HeaderPtr, TEXT("/r/n"));			if (DelimiterPtr == NULL)			{				DelimiterPtr = EndPtr;			}			FString HeaderLine(DelimiterPtr-HeaderPtr, HeaderPtr);			FString HeaderKey,HeaderValue;			if (HeaderLine.Split(TEXT(":"), &HeaderKey, &HeaderValue))			{				if (!HeaderKey.IsEmpty())				{					ResponseHeaders.Add(HeaderKey, HeaderValue.Trim());				}			}			HeaderPtr = DelimiterPtr + 2;		}	}	else	{		UE_LOG(LogHttp, Warning, TEXT("HttpQueryInfo for all headers failed when trying to determine the size for the header buffer. %p"), 			&Request);	}}

    WebInputStream (const String& address_, bool isPost_, const MemoryBlock& postData_,                    URL::OpenStreamProgressCallback* progressCallback, void* progressCallbackContext,                    const String& headers_, int timeOutMs_, StringPairArray* responseHeaders)      : statusCode (0), connection (0), request (0),        address (address_), headers (headers_), postData (postData_), position (0),        finished (false), isPost (isPost_), timeOutMs (timeOutMs_)    {        createConnection (progressCallback, progressCallbackContext);        if (! isError())        {            if (responseHeaders != nullptr)            {                DWORD bufferSizeBytes = 4096;                for (;;)                {                    HeapBlock<char> buffer ((size_t) bufferSizeBytes);                    if (HttpQueryInfo (request, HTTP_QUERY_RAW_HEADERS_CRLF, buffer.getData(), &bufferSizeBytes, 0))                    {                        StringArray headersArray;                        headersArray.addLines (String (reinterpret_cast<const WCHAR*> (buffer.getData())));                        for (int i = 0; i < headersArray.size(); ++i)                        {                            const String& header = headersArray[i];                            const String key (header.upToFirstOccurrenceOf (": ", false, false));                            const String value (header.fromFirstOccurrenceOf (": ", false, false));                            const String previousValue ((*responseHeaders) [key]);                            responseHeaders->set (key, previousValue.isEmpty() ? value : (previousValue + "," + value));                        }                        break;                    }                    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)                        break;                }            }            DWORD status = 0;            DWORD statusSize = sizeof (status);            if (HttpQueryInfo (request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &statusSize, 0))                statusCode = (int) status;        }    }

void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp){    DWORD dwLen = 10;    wchar_t szHttpRes[10];    DWORD nIndex = 0;    if( !HttpQueryInfo( hRequest, HTTP_QUERY_STATUS_CODE, szHttpRes, &dwLen, &nIndex) )    {        pszErrFunction = L"HttpSendRequest";        return;    }    int nCode = _wtoi(szHttpRes);    pNetResp->setResponseCode(nCode);    if ( nCode != 200 )    {        LOG(ERROR) + "An error occured connecting to the sync source: " + szHttpRes + " returned.";        // If we're unauthorized, delete any cookies that might have been        // stored so we don't reuse them later        if ( nCode == 401 )         {            CAtlStringA strUrlA;            int nQuest = strReqUrlW.Find('?');             if ( nQuest > 0 )                strUrlA = strReqUrlW.Mid(0,nQuest-1);            else                strUrlA = strReqUrlW;            ::InternetSetCookieA(strUrlA, NULL, "");        }	}}

	//download file from WWW in a buffer	bool WWWFileBuffer(char *host, char *path, char *outBuffer, int outBufferSize)	{		bool retval = false;		LPTSTR AcceptTypes[2] = { TEXT("*/*"), NULL };		DWORD dwSize = outBufferSize - 1, dwFlags = INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE;		HINTERNET opn = NULL, con = NULL, req = NULL;		opn = InternetOpen(TEXT("Evilzone.org"), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);		if (!opn)			return retval;		con = InternetConnect(opn, host, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);		if (!con)			return retval;		req = HttpOpenRequest(con, TEXT("GET"), path, HTTP_VERSION, NULL, (LPCTSTR*)AcceptTypes, dwFlags, 0);		if (!req)			return retval;		if (HttpSendRequest(req, NULL, 0, NULL, 0))		{			DWORD statCodeLen = sizeof(DWORD);			DWORD statCode;			if (HttpQueryInfo(req,				HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,				&statCode, &statCodeLen, NULL))			{				if (statCode == 200 && InternetReadFile(req, (LPVOID)outBuffer, outBufferSize - 1, &dwSize))				{					retval = TRUE;				}			}		}		InternetCloseHandle(req);		InternetCloseHandle(con);		InternetCloseHandle(opn);		return retval;	}

void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp){    DWORD dwLen = 10;    wchar_t szHttpRes[10];    DWORD nIndex = 0;    if( !HttpQueryInfo( hRequest, HTTP_QUERY_STATUS_CODE, szHttpRes, &dwLen, &nIndex) )    {        pszErrFunction = L"HttpQueryInfo";        return;    }    int nCode = _wtoi(szHttpRes);    pNetResp->setResponseCode(nCode);    if ( m_pHeaders )    {        if ( !readHeaders(*m_pHeaders) )            return;    }    if ( nCode != 200 )    {        LOG(ERROR) + "An error occured connecting to the sync source: " + szHttpRes + " returned.";        // If we're unauthorized, delete any cookies that might have been        // stored so we don't reuse them later        if ( nCode == 401 && m_pSession )         {            m_pSession->logout();        }	}    if (pNetResp->isOK())        pNetResp->setCookies(makeClientCookie());}

static char *http_receive(HINTERNET h_req, u_long *d_size){	u_long bytes  = sizeof(u_long);	u_long qsize  = 0;	u_long readed = 0;	char  *data   = NULL;	char   buff[4096];	if (HttpQueryInfo(h_req, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &qsize, &bytes, NULL) != 0) {		data = malloc(qsize + 1);	}	do	{		if (InternetReadFile(h_req, buff, sizeof(buff), &bytes) == 0) {			break;		}		if ( (readed + bytes) > qsize) {			data = realloc(data, readed + bytes + 1);			if (data == NULL) break;			qsize += bytes;		}		memcpy(data + readed, buff, bytes); readed += bytes;	} while (bytes != 0);	if ( (data != NULL) && (readed != qsize) ) {		free(data); data = NULL;	} else {		if (d_size != NULL) *d_size = readed;		data[readed] = 0;	}		return data;}

unsigned long BuscarActualizaciones::ThreadBuscarActualizacion(void *phWnd) {//	try {		HINTERNET		Sesion				= InternetOpen(TEXT("BubaTronik"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, INTERNET_INVALID_PORT_NUMBER, 0);		HINTERNET		Peticion			= InternetOpenUrl(Sesion, TEXT("http://www.devildrey33.es/BubaTronik/VERSION_BUBATRONIK.txt"), NULL, 0, INTERNET_FLAG_RELOAD, 0);		char			Txt[32]				= "";		DWORD			BytesLeidos			= 0;		DWORD			TotalBytesLeidos	= 0;		DWORD			MaxBuffer			= sizeof(Txt) -1;		DWL::DWLString	Ret;		// No se ha encontrado la version :/		if (Peticion == NULL) {    		InternetCloseHandle(Sesion);			return 0;		}		BOOL Leido = InternetReadFile(Peticion, Txt, MaxBuffer, &BytesLeidos);		if (BytesLeidos != 0) {			Txt[BytesLeidos] = 0;			Ret += Txt;	//		ZeroMemory(Txt, sizeof(Txt) * sizeof(char));		}		HWND hWndPlayer = reinterpret_cast<HWND>(phWnd);		if (Ret.Tam() == 0)	{			InternetCloseHandle(Peticion);			InternetCloseHandle(Sesion);			return 0; 		}		if (Ret[0] == TEXT('<')) {			InternetCloseHandle(Peticion);			InternetCloseHandle(Sesion);			return 0; // no se ha encontrado el documento		}		DWL::DWLString Version;		Version.sprintf(TEXT("%.02f"), static_cast<float>(APP_NUM_VER));		// La versión no es la misma, leemos las novedades		if (Ret.SubStr(0, Version.Tam()) != Version)	{    	    		HINTERNET PeticionNovedades	= InternetOpenUrl(Sesion, TEXT("http://www.devildrey33.es/BubaTronik/NOVEDADES_BUBATRONIK.txt"), NULL, 0, INTERNET_FLAG_RELOAD, 0);			DWORD	  TotalDatos        = 0;    		DWORD	  Descargado		= 64;			TCHAR	  TotalDatosStr[64];			BOOL bRet = HttpQueryInfo(PeticionNovedades, HTTP_QUERY_CONTENT_LENGTH, (LPVOID)TotalDatosStr, &Descargado, (LPDWORD)0);			if (bRet == TRUE) TotalDatos = _wtol(TotalDatosStr);			char     *TmpBuffer = new char[TotalDatos + 1];    		Leido = InternetReadFile(PeticionNovedades, TmpBuffer, TotalDatos, &BytesLeidos);    		if (BytesLeidos != 0 && BytesLeidos <= TotalDatos) TmpBuffer[BytesLeidos] = 0;			Sistema.App.PlayerEx.VentanaActualizacion.Novedades(TmpBuffer);			delete [] TmpBuffer;			PostMessage(hWndPlayer, MENSAJE_ACTUALIZACION_ENCONTRADA, 0, 0);		}		InternetCloseHandle(Peticion);		InternetCloseHandle(Sesion);//	}//	catch (...) {//	}	return 0;}

BOOL CFileDownloader::_CheckIfModifiedSince( LPCTSTR lpszURL, LPCTSTR lpszLastModifed, BOOL bUseProxyConfig, BOOL& modified ){	if(!lpszLastModifed)		return FALSE;		BOOL bRet = FALSE;	do	{		CString strHeaderIfModifiedSince;		strHeaderIfModifiedSince.Format(_T("If-Modified-Since:%s/r/n"), lpszLastModifed);				if(!_IssueRequest(m_strHostname, m_strHostPath, strHeaderIfModifiedSince, bUseProxyConfig))			break;				DWORD dwStatus = 0;		DWORD dwSize = sizeof(DWORD);		BOOL bStatusOK = HttpQueryInfo(m_hRequest, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwSize, NULL);		if( !bStatusOK)			break;				modified = dwStatus == HTTP_STATUS_NOT_MODIFIED;		return TRUE;	}while(FALSE);		return bRet;}

static gbooleangst_win_inet_src_get_header_value_as_int (GstWinInetSrc * self,    const gchar * header_name, gint * header_value, gboolean log_failure){  gchar buf[16] = { 0, };  DWORD buf_size = sizeof (buf);  gint *value = (gint *) buf;  strcpy (buf, header_name);  if (!HttpQueryInfo (self->url, HTTP_QUERY_CUSTOM | HTTP_QUERY_FLAG_NUMBER,          buf, &buf_size, NULL)) {    if (log_failure) {      DWORD error_code = GetLastError ();      const gchar *error_str = "unknown error";      if (error_code == ERROR_HTTP_HEADER_NOT_FOUND)        error_str = "ERROR_HTTP_HEADER_NOT_FOUND";      GST_WARNING_OBJECT (self, "HttpQueryInfo for header '%s' failed: %s "          "(0x%08lx)", header_name, error_str, error_code);    }    return FALSE;  }  *header_value = *value;  return TRUE;}

BOOL CFileDownloader::_GetHttpInfo( HINTERNET hRequest, DWORD dwInfoLevel, CString &str ){	DWORD dwBufLen = MAX_PATH;	DWORD dwIndex = 0;	BOOL bRet = HttpQueryInfo(hRequest, dwInfoLevel, str.GetBuffer(MAX_PATH), &dwBufLen, &dwIndex);	str.ReleaseBuffer();	return bRet;}

CBStringA CBHttpRequest::QueryInfo(DWORD i){    CBStringA str;    if(m_nReadyState < 2)return str;    DWORD dwLen = 0;    HttpQueryInfo(m_hFile, i, NULL, &dwLen, 0);    LPSTR pstr = str.GetBufferSetLength(dwLen);    if (HttpQueryInfo(m_hFile, i, pstr, &dwLen, NULL))        str.ReleaseBuffer(dwLen);    else        str.ReleaseBuffer(0);    return str;}

std::string HttpSnaffle::FetchStatusMessage(){    char* p = 0;    DWORD size = 0;    DWORD index = 0;    // First get size    HttpQueryInfo(myRequest, HTTP_QUERY_STATUS_TEXT, p, &size, &index);    // Then get actual data    p = new char[size];    std::string s;    if (HttpQueryInfo(myRequest, HTTP_QUERY_STATUS_TEXT, p, &size, &index))    {        s = p;        delete[] p;    }    return s;}

 DWORD getTotalBytes() const {     DWORD totalBytes;     DWORD sizeof_total_bytes = sizeof(totalBytes);     HttpQueryInfo(mDownload, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,                   &totalBytes, &sizeof_total_bytes, NULL);     return totalBytes; }

	int Request::getStatusCode() {		DWORD read = 10;		char buff [10];		if (HttpQueryInfo(_hRequest , HTTP_QUERY_STATUS_CODE , buff , &read , 0)) {			return atoi(buff);		}		return 0;	}

void CALLBACK my_InternetStatusCallback(HINTERNET hRequest, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength){	LPINTERNET_ASYNC_RESULT	AsyncResult = (LPINTERNET_ASYNC_RESULT) lpvStatusInformation;	INTERNET_STATUS_CALLBACK RealInetCallback;	PHANDLE_CONTEXT Ctx;	ENTER_HOOK();	if (Ctx = FindHandle(hRequest))	{		switch (dwInternetStatus)		{		case INTERNET_STATUS_HANDLE_CLOSING:			DelHandle(hRequest);			break;		case INTERNET_STATUS_REQUEST_COMPLETE:			if (Ctx->Status == DOWNLOADING)			{				if (!AsyncResult->dwResult)					Ctx->Status = ERROR_WHILE_LOADING;				SetEvent(Ctx->AsyncEvent);				ReleaseHandle(Ctx);				LEAVE_HOOK();				return;			}	// if (Ctx->Status == DOWNLOADING)			else			{				ULONG	HttpStatus, bSize = sizeof(ULONG);				if (HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_CODE, &HttpStatus, &bSize, &bSize))				{					if (HttpStatus == 1)					{						__debugbreak();					}									}				else					bSize = GetLastError();			}			break;		default:			break;		}	// switch (dwInternetStatus)				if (RealInetCallback = Ctx->Callback)		{			ASSERT((LONG_PTR)Ctx->Callback > 0);	// User-mode address			(RealInetCallback) (hRequest, dwContext, dwInternetStatus, lpvStatusInformation, dwStatusInformationLength);		}		ReleaseHandle(Ctx);	}	// if (Ctx = FindHandle(hInternet))	LEAVE_HOOK();}

	Date64 Request::getLastModificationTime() {		SYSTEMTIME time;		DWORD size = sizeof(time);		if (HttpQueryInfo(_hRequest , HTTP_QUERY_LAST_MODIFIED | HTTP_QUERY_FLAG_SYSTEMTIME , &time , &size , 0)) {			return Date64(time);		} else {			return Date64(false);		}	}

int HttpSnaffle::FetchStatusCode(){    int length = -1;    DWORD size = sizeof(length);    DWORD index = 0;    if (!HttpQueryInfo(myRequest, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &length, &size, &index))        return -1;    return length;}

	int Request::getInfoInt(int type) {		int value;		DWORD size = 4;		if (HttpQueryInfo(_hRequest , type | HTTP_QUERY_FLAG_NUMBER , &value , &size , 0)) {			return value;		} else {			return 0;		}	}

 FString   GetHeader(DWORD dwHeader) {     char szHeader[1024];     DWORD dwLen = 1024;      if (HttpQueryInfo(m_hReq, dwHeader, szHeader, &dwLen, 0))     {         return FString(szHeader);      }     return ""; }

boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders){    oHeaders.clear();    CAtlStringW strHeaders;    DWORD dwLen = 0;    DWORD nIndex = 0;    if( !HttpQueryInfo( hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, null, &dwLen, &nIndex) )    {           DWORD dwErr = ::GetLastError();        if ( dwErr != ERROR_INSUFFICIENT_BUFFER )        {            pszErrFunction = L"HttpQueryInfo";            return false;        }    }    if( !HttpQueryInfo( hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, strHeaders.GetBuffer(dwLen), &dwLen, &nIndex) )    {        pszErrFunction = L"HttpQueryInfo";        return false;    }    strHeaders.ReleaseBuffer();    int nStart = 0;    for(int nEnd = strHeaders.Find(L"/r/n", nStart); nEnd > 0; nStart = nEnd+2, nEnd = strHeaders.Find(L"/r/n", nStart) )    {        CAtlStringW strHeader = strHeaders.Mid(nStart, nEnd-nStart);        int nSep = strHeader.Find(':');        if (nSep < 0 )            continue;        CAtlStringW strName = strHeader.Mid(0, nSep);        strName.Trim();        strName.MakeLower();        CAtlStringW strValue = strHeader.Mid(nSep+1);        strValue.Trim();        oHeaders.put(common::convertToStringA(strName.GetString()),common::convertToStringA(strValue.GetString()));    }    return true;}

void FHttpResponseWinInet::ProcessResponseCode(){	// get the response code	ResponseCode = EHttpResponseCodes::Unknown;	::DWORD CodeSize = sizeof(ResponseCode);	if (!HttpQueryInfo(Request.RequestHandle, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &ResponseCode, &CodeSize, NULL))	{		UE_LOG(LogHttp, Warning, TEXT("HttpQueryInfo for response code failed: %s. %p"), 			*InternetTranslateError(GetLastError()), &Request);	}}

int HttpDownloadInet::_getStatusCode(HINTERNET hRemoteFile) const{		DWORD dwStatus;	DWORD dwStatusSize = sizeof(dwStatus);		if (HttpQueryInfo(hRemoteFile, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwStatusSize, NULL))	{		return dwStatus;	}		return ERROR_FILE_NOTFOUND;}

/* 	get the http respnse code 	return -1 if it fails*/DWORD get_http_status_code(HINTERNET requesthandle){	DWORD response_code = -1;	DWORD response_code_size = sizeof(DWORD);	BOOL ishttpqueryinfo = FALSE;	ishttpqueryinfo = HttpQueryInfo(requesthandle, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &response_code, &response_code_size, NULL);	if (!ishttpqueryinfo){		return response_code;	}	return response_code;}