You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
951 lines
27 KiB
951 lines
27 KiB
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
query.cxx
|
|
|
|
Abstract:
|
|
|
|
This file contains the implementation of the HttpQueryInfoA API.
|
|
|
|
Contents:
|
|
HttpQueryInfoA
|
|
HttpQueryInfoW
|
|
HTTP_REQUEST_HANDLE_OBJECT::QueryInfo
|
|
|
|
Author:
|
|
|
|
Keith Moore (keithmo) 16-Nov-1994
|
|
|
|
Revision History:
|
|
|
|
Modified to make HttpQueryInfoA remotable. madana (2/8/95)
|
|
|
|
--*/
|
|
|
|
#include <wininetp.h>
|
|
#include "httpp.h"
|
|
|
|
//
|
|
// private prototypes
|
|
//
|
|
|
|
//
|
|
// private data
|
|
//
|
|
|
|
#define NUM_HEADERS ARRAY_ELEMENTS(GlobalKnownHeaders)
|
|
|
|
//
|
|
// functions
|
|
//
|
|
|
|
|
|
INTERNETAPI_(BOOL) HttpQueryInfoA(
|
|
IN HINTERNET hRequest,
|
|
IN DWORD dwInfoLevel,
|
|
IN OUT LPVOID lpBuffer OPTIONAL,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
IN OUT LPDWORD lpdwIndex OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queries a request or response header from the HTTP request handle
|
|
|
|
Arguments:
|
|
|
|
hRequest - an open HTTP request handle returned by
|
|
HttpOpenRequest()
|
|
|
|
dwInfoLevel - one of the HTTP_QUERY_* values indicating the
|
|
attribute to query. In addition, the following flags
|
|
can be set:
|
|
|
|
HTTP_QUERY_FLAG_REQUEST_HEADERS
|
|
- Causes the request headers to be queried. The
|
|
default is to check the response headers
|
|
|
|
HTTP_QUERY_FLAG_SYSTEMTIME
|
|
- Causes headers that contain date & time
|
|
information to be returned as SYSTEMTIME
|
|
structures
|
|
|
|
HTTP_QUERY_FLAG_NUMBER
|
|
- Causes header value to be returned as a number.
|
|
Useful for when the app knows it is expecting
|
|
a numeric value, e.g. status code
|
|
|
|
HTTP_QUERY_FLAG_COALESCE
|
|
- Combine several headers of the same name into
|
|
one output buffer
|
|
|
|
lpBuffer - pointer to the buffer to receive the information.
|
|
If dwInfoLevel is HTTP_QUERY_CUSTOM then buffer
|
|
contains the header to query.
|
|
|
|
If NULL then we just return the required buffer length
|
|
to hold the header specified by dwInfoLevel
|
|
|
|
lpdwBufferLength - IN: contains the length (in BYTEs) of lpBuffer
|
|
OUT: size of data written to lpBuffer, or required
|
|
buffer length if ERROR_INSUFFICIENT_BUFFER
|
|
returned
|
|
|
|
lpdwIndex - IN: 0-based header index
|
|
OUT: next index to query, if success returned
|
|
|
|
Return Value:
|
|
|
|
TRUE - The query succeeded. lpBuffer contains the query information, and
|
|
*lpdwBufferLength contains the size (in BYTEs) of the information
|
|
|
|
FALSE - The operation failed. Error status is available by calling
|
|
GetLastError().
|
|
|
|
--*/
|
|
|
|
{
|
|
DEBUG_ENTER_API((DBG_API,
|
|
Bool,
|
|
"HttpQueryInfoA",
|
|
"%#x, %s (%#x), %#x [%q], %#x [%d], %#x [%d]",
|
|
hRequest,
|
|
InternetMapHttpOption(dwInfoLevel & HTTP_QUERY_HEADER_MASK),
|
|
dwInfoLevel,
|
|
lpBuffer,
|
|
((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
|
|
? lpBuffer
|
|
: "",
|
|
lpdwBufferLength,
|
|
lpdwBufferLength ? *lpdwBufferLength : 0,
|
|
lpdwIndex,
|
|
lpdwIndex ? *lpdwIndex : 0
|
|
));
|
|
|
|
DWORD defaultIndex = 0;
|
|
DWORD error;
|
|
HINTERNET hRequestMapped = NULL;
|
|
|
|
if (!GlobalDataInitialized) {
|
|
error = ERROR_INTERNET_NOT_INITIALIZED;
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
// get the thread info
|
|
//
|
|
|
|
LPINTERNET_THREAD_INFO lpThreadInfo;
|
|
|
|
lpThreadInfo = InternetGetThreadInfo();
|
|
if (lpThreadInfo == NULL) {
|
|
error = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto done;
|
|
}
|
|
|
|
_InternetIncNestingCount();
|
|
|
|
//
|
|
// map the handle
|
|
//
|
|
|
|
error = MapHandleToAddress(hRequest, (LPVOID *)&hRequestMapped, FALSE);
|
|
if (error != ERROR_SUCCESS) {
|
|
goto quit;
|
|
}
|
|
|
|
|
|
//
|
|
// find path from Internet handle
|
|
//
|
|
|
|
BOOL isLocal;
|
|
BOOL isAsync;
|
|
|
|
error = RIsHandleLocal(hRequestMapped,
|
|
&isLocal,
|
|
&isAsync,
|
|
TypeHttpRequestHandle
|
|
);
|
|
if (error != ERROR_SUCCESS) {
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// validate parameters
|
|
//
|
|
|
|
DWORD queryModifiers;
|
|
DWORD infoLevel;
|
|
|
|
queryModifiers = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
|
|
infoLevel = dwInfoLevel & HTTP_QUERY_HEADER_MASK;
|
|
|
|
if (((infoLevel > HTTP_QUERY_MAX) && (infoLevel != HTTP_QUERY_CUSTOM))
|
|
|| (lpdwBufferLength == NULL)
|
|
|
|
//
|
|
// nip in the bud apps that want SYSTEMTIME AND NUMBER for same header(!)
|
|
//
|
|
|
|
#define EXCLUSIVE_MODIFIERS (HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_FLAG_SYSTEMTIME)
|
|
|
|
|| ((dwInfoLevel & EXCLUSIVE_MODIFIERS) == EXCLUSIVE_MODIFIERS)) {
|
|
|
|
error = ERROR_INVALID_PARAMETER;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// if the app passed in a NULL lpdwIndex then it is asking for index 0
|
|
//
|
|
|
|
if (!ARGUMENT_PRESENT(lpdwIndex)) {
|
|
lpdwIndex = &defaultIndex;
|
|
}
|
|
|
|
//
|
|
// if the app is asking for one of the special query items - status code,
|
|
// status text, HTTP version, or one of the raw header variants, then make
|
|
// sure the index is 0. These pseudo-header types cannot be enumerated
|
|
//
|
|
|
|
if ((*lpdwIndex != 0)
|
|
&& ((infoLevel == HTTP_QUERY_VERSION)
|
|
|| (infoLevel == HTTP_QUERY_STATUS_CODE)
|
|
|| (infoLevel == HTTP_QUERY_STATUS_TEXT)
|
|
|| (infoLevel == HTTP_QUERY_RAW_HEADERS)
|
|
|| (infoLevel == HTTP_QUERY_RAW_HEADERS_CRLF))) {
|
|
|
|
error = ERROR_HTTP_HEADER_NOT_FOUND;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// ensure that we can use any flags passed in
|
|
//
|
|
|
|
if (infoLevel == HTTP_QUERY_CUSTOM) {
|
|
|
|
//
|
|
// lpBuffer MUST be present if we were asked to find a custom header
|
|
//
|
|
|
|
if (!ARGUMENT_PRESENT(lpBuffer)) {
|
|
error = ERROR_INVALID_PARAMETER;
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// the app has given us a string to locate. We only accept strings in
|
|
// the following format:
|
|
//
|
|
// <header-to-find>[:][CR][LF]<EOS>
|
|
//
|
|
// The header cannot contain any spaces
|
|
//
|
|
|
|
INET_ASSERT(error == ERROR_SUCCESS);
|
|
|
|
__try {
|
|
|
|
LPSTR lpszBuffer = (LPSTR)lpBuffer;
|
|
int queryLength = 0;
|
|
int headerLength = 0;
|
|
|
|
for (; lpszBuffer[queryLength] != '\0'; ++queryLength) {
|
|
if ((lpszBuffer[queryLength] == ':')
|
|
|| (lpszBuffer[queryLength] == '\r')
|
|
|| (lpszBuffer[queryLength] == '\n')) {
|
|
break;
|
|
}
|
|
if (iscntrl(lpszBuffer[queryLength])
|
|
|| isspace(lpszBuffer[queryLength])) {
|
|
error = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
}
|
|
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
|
error = ERROR_INVALID_PARAMETER;
|
|
}
|
|
ENDEXCEPT
|
|
} else if ((queryModifiers & ~GlobalKnownHeaders[infoLevel].Flags) != 0) {
|
|
error = ERROR_HTTP_INVALID_QUERY_REQUEST;
|
|
}
|
|
if (error != ERROR_SUCCESS) {
|
|
goto quit;
|
|
}
|
|
|
|
//
|
|
// if NULL buffer pointer then app wants length of option: set buffer length
|
|
// to zero
|
|
//
|
|
|
|
if (!ARGUMENT_PRESENT(lpBuffer)) {
|
|
*lpdwBufferLength = 0;
|
|
} else {
|
|
|
|
//
|
|
// ensure app buffer is writeable
|
|
//
|
|
|
|
error = ProbeWriteBuffer(lpBuffer, *lpdwBufferLength);
|
|
if (error != ERROR_SUCCESS) {
|
|
goto quit;
|
|
}
|
|
}
|
|
|
|
INET_ASSERT(error == ERROR_SUCCESS);
|
|
|
|
HTTP_REQUEST_HANDLE_OBJECT * pRequest;
|
|
|
|
pRequest = (HTTP_REQUEST_HANDLE_OBJECT *)hRequestMapped;
|
|
if (dwInfoLevel & HTTP_QUERY_FLAG_REQUEST_HEADERS) {
|
|
if (!IS_VALID_HTTP_STATE(pRequest, QUERY_REQUEST, TRUE)) {
|
|
error = ERROR_INTERNET_INCORRECT_HANDLE_STATE;
|
|
}
|
|
} else {
|
|
if (!IS_VALID_HTTP_STATE(pRequest, QUERY_RESPONSE, TRUE)) {
|
|
error = ERROR_INTERNET_INCORRECT_HANDLE_STATE;
|
|
}
|
|
}
|
|
if (error == ERROR_SUCCESS) {
|
|
error = pRequest->QueryInfo(dwInfoLevel,
|
|
lpBuffer,
|
|
lpdwBufferLength,
|
|
lpdwIndex
|
|
);
|
|
}
|
|
|
|
quit:
|
|
|
|
_InternetDecNestingCount(1);
|
|
|
|
done:
|
|
|
|
BOOL success;
|
|
|
|
if (error != ERROR_SUCCESS) {
|
|
|
|
DEBUG_ERROR(HTTP, error);
|
|
|
|
SetLastError(error);
|
|
success = FALSE;
|
|
} else {
|
|
|
|
DEBUG_PRINT_API(API,
|
|
INFO,
|
|
("*lpdwBufferLength = %d\n",
|
|
*lpdwBufferLength
|
|
));
|
|
|
|
DEBUG_DUMP_API(DUMP_API_DATA,
|
|
"Query data:\n",
|
|
lpBuffer,
|
|
*lpdwBufferLength
|
|
);
|
|
|
|
success = TRUE;
|
|
}
|
|
|
|
if (hRequestMapped != NULL) {
|
|
DereferenceObject((LPVOID)hRequestMapped);
|
|
}
|
|
|
|
DEBUG_LEAVE_API(success);
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
INTERNETAPI_(BOOL) HttpQueryInfoW(
|
|
IN HINTERNET hRequest,
|
|
IN DWORD dwInfoLevel,
|
|
IN OUT LPVOID lpBuffer OPTIONAL,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
IN OUT LPDWORD lpdwIndex OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queries information from the HTTP request handle.
|
|
|
|
Arguments:
|
|
|
|
hHttpRequest - An open HTTP request handle returned by HttpOpenRequest().
|
|
|
|
dwInfoLevel - One of the HTTP_QUERY_* values indicating the attribute
|
|
to query.
|
|
|
|
lpBuffer - Pointer to the buffer to receive the information.
|
|
|
|
dwBufferLength - On entry, contains the length (in BYTEs) of the data
|
|
buffer. On exit, contains the size (in BYTEs) of the data written
|
|
to lpBuffer.
|
|
|
|
Return Value:
|
|
|
|
TRUE - The query succeeded. lpBuffer contains the query information,
|
|
and lpBufferLength contains the size (in BYTEs) of the information.
|
|
|
|
FALSE - The operation failed. Error status is available by calling
|
|
GetLastError().
|
|
|
|
Comments:
|
|
|
|
--*/
|
|
|
|
{
|
|
DEBUG_ENTER_API((DBG_API,
|
|
Bool,
|
|
"HttpQueryInfoW",
|
|
"%#x, %s (%#x), %#x [%wq], %#x [%d], %#x [%d]",
|
|
hRequest,
|
|
InternetMapHttpOption(dwInfoLevel & HTTP_QUERY_HEADER_MASK),
|
|
dwInfoLevel,
|
|
lpBuffer,
|
|
((dwInfoLevel & HTTP_QUERY_HEADER_MASK) == HTTP_QUERY_CUSTOM)
|
|
? lpBuffer
|
|
: L"",
|
|
lpdwBufferLength,
|
|
lpdwBufferLength ? *lpdwBufferLength : 0,
|
|
lpdwIndex,
|
|
lpdwIndex ? *lpdwIndex : 0
|
|
));
|
|
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
BOOL fResult=FALSE;
|
|
INET_ASSERT(hRequest);
|
|
MEMORYPACKET mpBuffer;
|
|
|
|
if (!lpdwBufferLength
|
|
|| IsBadWritePtr(lpdwBufferLength, sizeof(*lpdwBufferLength))
|
|
|| (lpBuffer && IsBadWritePtr(lpBuffer, *lpdwBufferLength))
|
|
|| (lpdwIndex && IsBadWritePtr(lpdwIndex, sizeof(*lpdwIndex))))
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
goto cleanup;
|
|
}
|
|
|
|
if (lpBuffer)
|
|
{
|
|
mpBuffer.dwAlloc = mpBuffer.dwSize = *lpdwBufferLength;
|
|
if (dwInfoLevel==HTTP_QUERY_CUSTOM)
|
|
{
|
|
DWORD dwTemp = WideCharToMultiByte(CP_ACP,0,(LPWSTR)lpBuffer,-1,NULL,0,NULL,NULL);
|
|
if (dwTemp>mpBuffer.dwAlloc)
|
|
{
|
|
mpBuffer.dwAlloc = dwTemp;
|
|
}
|
|
}
|
|
mpBuffer.psStr = (LPSTR)ALLOC_BYTES(mpBuffer.dwAlloc*sizeof(CHAR));
|
|
if (!mpBuffer.psStr)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (dwInfoLevel==HTTP_QUERY_CUSTOM)
|
|
{
|
|
if (!lpBuffer)
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
goto cleanup;
|
|
}
|
|
WideCharToMultiByte(CP_ACP,0,(LPWSTR)lpBuffer,-1,mpBuffer.psStr,mpBuffer.dwAlloc,NULL,NULL);
|
|
}
|
|
|
|
fResult = HttpQueryInfoA(hRequest,dwInfoLevel,(LPVOID)mpBuffer.psStr,&mpBuffer.dwSize,lpdwIndex);
|
|
|
|
if (!((dwInfoLevel & HTTP_QUERY_FLAG_NUMBER) ||
|
|
(dwInfoLevel & HTTP_QUERY_FLAG_SYSTEMTIME)))
|
|
{
|
|
// This is the default, we've been handed back a string.
|
|
if (fResult)
|
|
{
|
|
*lpdwBufferLength = MultiByteToWideChar(CP_ACP, 0, mpBuffer.psStr, mpBuffer.dwSize + 1,
|
|
NULL, 0);
|
|
*lpdwBufferLength *= sizeof(WCHAR);
|
|
if (*lpdwBufferLength<=mpBuffer.dwAlloc)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, mpBuffer.psStr, mpBuffer.dwSize+1,
|
|
(LPWSTR)lpBuffer, mpBuffer.dwAlloc/sizeof(WCHAR));
|
|
*lpdwBufferLength -= sizeof(WCHAR);
|
|
}
|
|
else
|
|
{
|
|
fResult = FALSE;
|
|
dwErr = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GetLastError()==ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
*lpdwBufferLength = mpBuffer.dwSize*sizeof(WCHAR);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fResult)
|
|
{
|
|
memcpy(lpBuffer, (LPVOID)mpBuffer.psStr, mpBuffer.dwSize);
|
|
}
|
|
*lpdwBufferLength = mpBuffer.dwSize;
|
|
}
|
|
|
|
cleanup:
|
|
if (dwErr!=ERROR_SUCCESS)
|
|
{
|
|
SetLastError(dwErr);
|
|
DEBUG_ERROR(HTTP, dwErr);
|
|
}
|
|
DEBUG_LEAVE_API(fResult);
|
|
return fResult;
|
|
}
|
|
|
|
//
|
|
// object methods
|
|
//
|
|
|
|
|
|
DWORD
|
|
HTTP_REQUEST_HANDLE_OBJECT::QueryInfo(
|
|
IN DWORD dwInfoLevel,
|
|
OUT LPVOID lpBuffer OPTIONAL,
|
|
IN OUT LPDWORD lpdwBufferLength,
|
|
IN OUT LPDWORD lpdwIndex
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Header query method for HTTP_REQUEST_HANDLE_OBJECT class
|
|
|
|
Arguments:
|
|
|
|
dwInfoLevel - level of info (header) to get
|
|
|
|
lpBuffer - pointer to user's buffer
|
|
|
|
lpdwBufferLength - IN: length of user's buffer
|
|
OUT: length of returned information or required buffer
|
|
length if insufficient
|
|
|
|
lpdwIndex - IN: 0-based index of named header to return
|
|
OUT: index of next header if success returned
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure - ERROR_HTTP_DOWNLEVEL_SERVER
|
|
Response came from a down-level (<= HTTP 0.9) server. There
|
|
are no headers to query
|
|
|
|
ERROR_HTTP_HEADER_NOT_FOUND
|
|
Couldn't find the requested header
|
|
|
|
ERROR_HTTP_INVALID_QUERY_REQUEST
|
|
The caller asked for e.g. the Accept: header to be returned
|
|
as a SYSTEMTIME structure, or for e.g. a request header that
|
|
only exists for response headers (status code, for example)
|
|
|
|
ERROR_INSUFFICIENT_BUFFER
|
|
User's buffer not large enough to hold requested data
|
|
|
|
--*/
|
|
|
|
{
|
|
INET_ASSERT(lpdwBufferLength != NULL);
|
|
INET_ASSERT(lpdwIndex != NULL);
|
|
|
|
DWORD error;
|
|
LPSTR headerName;
|
|
DWORD headerNameLength;
|
|
DWORD modifiers;
|
|
|
|
modifiers = dwInfoLevel & HTTP_QUERY_MODIFIER_FLAGS_MASK;
|
|
dwInfoLevel &= HTTP_QUERY_HEADER_MASK;
|
|
|
|
if (dwInfoLevel == HTTP_QUERY_CUSTOM) {
|
|
headerName = (LPSTR)lpBuffer;
|
|
for (headerNameLength = 0; ; ++headerNameLength) {
|
|
if ((headerName[headerNameLength] == '\0')
|
|
|| (headerName[headerNameLength] == ':')
|
|
|| (headerName[headerNameLength] == '\r')
|
|
|| (headerName[headerNameLength] == '\n')) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (dwInfoLevel == HTTP_QUERY_REQUEST_METHOD) {
|
|
|
|
LPSTR lpszVerb;
|
|
DWORD dwVerbLength;
|
|
|
|
lpszVerb = _RequestHeaders.GetVerb(&dwVerbLength);
|
|
if ((lpszVerb != NULL) && (dwVerbLength != 0)) {
|
|
|
|
//
|
|
// the verb is (usually) space terminated
|
|
//
|
|
|
|
while ((dwVerbLength > 0) && (lpszVerb[dwVerbLength - 1] == ' ')) {
|
|
--dwVerbLength;
|
|
}
|
|
|
|
//
|
|
// *lpdwBufferLength will be 0 if lpBuffer is NULL
|
|
//
|
|
|
|
if (*lpdwBufferLength > dwVerbLength) {
|
|
memcpy(lpBuffer, lpszVerb, dwVerbLength);
|
|
((LPBYTE)lpBuffer)[dwVerbLength] = '\0';
|
|
error = ERROR_SUCCESS;
|
|
} else {
|
|
++dwVerbLength;
|
|
error = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
*lpdwBufferLength = dwVerbLength;
|
|
} else {
|
|
error = ERROR_HTTP_HEADER_NOT_FOUND;
|
|
}
|
|
goto quit;
|
|
} else {
|
|
headerName = GlobalKnownHeaders[dwInfoLevel].Text;
|
|
headerNameLength = GlobalKnownHeaders[dwInfoLevel].Length;
|
|
}
|
|
|
|
if (modifiers & HTTP_QUERY_FLAG_REQUEST_HEADERS) {
|
|
|
|
//
|
|
// we can always query request headers, even if the server is down
|
|
// level
|
|
//
|
|
|
|
switch (dwInfoLevel) {
|
|
case HTTP_QUERY_VERSION:
|
|
|
|
error = _RequestHeaders.QueryRequestVersion(
|
|
lpBuffer,
|
|
lpdwBufferLength
|
|
);
|
|
break;
|
|
case HTTP_QUERY_STATUS_CODE:
|
|
case HTTP_QUERY_STATUS_TEXT:
|
|
|
|
//
|
|
// can't query these sub-header values from the request headers
|
|
//
|
|
|
|
error = ERROR_HTTP_INVALID_QUERY_REQUEST;
|
|
break;
|
|
|
|
case HTTP_QUERY_RAW_HEADERS:
|
|
case HTTP_QUERY_RAW_HEADERS_CRLF:
|
|
error = _RequestHeaders.QueryRawHeaders(
|
|
NULL,
|
|
dwInfoLevel == HTTP_QUERY_RAW_HEADERS_CRLF,
|
|
lpBuffer,
|
|
lpdwBufferLength
|
|
);
|
|
break;
|
|
|
|
case HTTP_QUERY_ECHO_HEADERS:
|
|
case HTTP_QUERY_ECHO_HEADERS_CRLF:
|
|
error = QueryRequestHeadersWithEcho(
|
|
dwInfoLevel == HTTP_QUERY_ECHO_HEADERS_CRLF,
|
|
lpBuffer,
|
|
lpdwBufferLength
|
|
);
|
|
break;
|
|
|
|
case HTTP_QUERY_CUSTOM:
|
|
|
|
_RequestHeaders.LockHeaders();
|
|
|
|
error = QueryRequestHeader(headerName,
|
|
headerNameLength,
|
|
lpBuffer,
|
|
lpdwBufferLength,
|
|
modifiers,
|
|
lpdwIndex
|
|
);
|
|
|
|
_RequestHeaders.UnlockHeaders();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
_RequestHeaders.LockHeaders();
|
|
|
|
error = QueryRequestHeader( dwInfoLevel,
|
|
lpBuffer,
|
|
lpdwBufferLength,
|
|
modifiers,
|
|
lpdwIndex
|
|
);
|
|
|
|
_RequestHeaders.UnlockHeaders();
|
|
|
|
break;
|
|
|
|
}
|
|
} else if (!IsDownLevel()) {
|
|
switch (dwInfoLevel) {
|
|
case HTTP_QUERY_VERSION:
|
|
error = QueryResponseVersion(lpBuffer, lpdwBufferLength);
|
|
break;
|
|
|
|
case HTTP_QUERY_STATUS_CODE:
|
|
error = QueryStatusCode(lpBuffer, lpdwBufferLength, modifiers);
|
|
break;
|
|
|
|
case HTTP_QUERY_STATUS_TEXT:
|
|
error = QueryStatusText(lpBuffer, lpdwBufferLength);
|
|
break;
|
|
|
|
case HTTP_QUERY_RAW_HEADERS:
|
|
case HTTP_QUERY_RAW_HEADERS_CRLF:
|
|
error = _ResponseHeaders.QueryRawHeaders(
|
|
(LPSTR)_ResponseBuffer,
|
|
dwInfoLevel == HTTP_QUERY_RAW_HEADERS_CRLF,
|
|
lpBuffer,
|
|
lpdwBufferLength
|
|
);
|
|
break;
|
|
|
|
case HTTP_QUERY_ECHO_HEADERS:
|
|
case HTTP_QUERY_ECHO_HEADERS_CRLF:
|
|
error = ERROR_HTTP_INVALID_QUERY_REQUEST;
|
|
break;
|
|
|
|
case HTTP_QUERY_CUSTOM:
|
|
|
|
_ResponseHeaders.LockHeaders();
|
|
|
|
error = QueryResponseHeader(
|
|
headerName,
|
|
headerNameLength,
|
|
lpBuffer,
|
|
lpdwBufferLength,
|
|
modifiers,
|
|
lpdwIndex
|
|
);
|
|
|
|
_ResponseHeaders.UnlockHeaders();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
_ResponseHeaders.LockHeaders();
|
|
|
|
error = QueryResponseHeader(
|
|
dwInfoLevel,
|
|
lpBuffer,
|
|
lpdwBufferLength,
|
|
modifiers,
|
|
lpdwIndex
|
|
);
|
|
|
|
_ResponseHeaders.UnlockHeaders();
|
|
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
// there are no response headers from down-level servers
|
|
//
|
|
|
|
error = ERROR_HTTP_DOWNLEVEL_SERVER;
|
|
}
|
|
|
|
quit:
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
DWORD
|
|
HTTP_REQUEST_HANDLE_OBJECT::QueryRequestHeadersWithEcho(
|
|
IN BOOL bCrlfTerminated,
|
|
OUT LPVOID lpBuffer OPTIONAL,
|
|
IN OUT LPDWORD lpdwBufferLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Header query for request headers with echo headers added if any..
|
|
|
|
Arguments:
|
|
|
|
bCrlfTerminated - should the headers be seperated by CRLF's
|
|
lpBuffer - pointer to user's buffer
|
|
|
|
lpdwBufferLength - IN: length of user's buffer
|
|
OUT: length of returned information or required buffer
|
|
length if insufficient
|
|
|
|
Return Value:
|
|
|
|
DWORD
|
|
Success - ERROR_SUCCESS
|
|
|
|
Failure -
|
|
|
|
ERROR_INSUFFICIENT_BUFFER
|
|
User's buffer not large enough to hold requested data
|
|
|
|
--*/
|
|
{
|
|
INET_ASSERT(lpdwBufferLength != NULL);
|
|
|
|
DWORD error;
|
|
LPSTR lpszEchoHeaderIn = NULL ;
|
|
LPSTR lpszEchoHeaderOut = NULL;
|
|
DWORD cbHeaderIn = 0;
|
|
DWORD cbHeaderOut = 0;
|
|
BOOL bEchoPresent = FALSE;
|
|
|
|
// List of headers to filter out of the Request headers
|
|
|
|
LPSTR rglpFilter [ ] =
|
|
{
|
|
GlobalKnownHeaders[HTTP_QUERY_AUTHORIZATION].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_CONNECTION].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_CONTENT_LENGTH].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_COOKIE].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_ECHO_REPLY].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_HOST].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_IF_MODIFIED_SINCE].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_IF_MATCH].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_IF_NONE_MATCH].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_IF_RANGE].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_IF_UNMODIFIED_SINCE].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_PROXY_AUTHORIZATION].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_PROXY_CONNECTION].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_RANGE].Text,
|
|
GlobalKnownHeaders[HTTP_QUERY_UNLESS_MODIFIED_SINCE].Text,
|
|
};
|
|
|
|
_ResponseHeaders.LockHeaders();
|
|
|
|
error = FastQueryResponseHeader(HTTP_QUERY_ECHO_REQUEST,
|
|
(LPVOID *)&lpszEchoHeaderIn,
|
|
&cbHeaderIn,
|
|
0);
|
|
|
|
if (error == ERROR_SUCCESS)
|
|
{
|
|
DWORD cbEchoRequest = GlobalKnownHeaders[HTTP_QUERY_ECHO_REQUEST].Length;
|
|
DWORD cbEchoReply = GlobalKnownHeaders[HTTP_QUERY_ECHO_REPLY].Length;
|
|
|
|
bEchoPresent = TRUE;
|
|
|
|
// Add echo-reply: to the begining of the header.
|
|
cbHeaderOut = cbEchoReply + 1 // For echo-reply:
|
|
+ cbHeaderIn // Send back the stuff from the header.
|
|
+ (bCrlfTerminated ? 2 : 1) // 2 for CRLF
|
|
+ 1; // 1 for NULL terminator
|
|
|
|
lpszEchoHeaderOut = (LPSTR) _alloca(cbHeaderOut); // Add 1 for null terminator.
|
|
|
|
if ( lpszEchoHeaderOut == NULL)
|
|
{
|
|
error = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto done;
|
|
}
|
|
|
|
LPSTR lpsz = lpszEchoHeaderOut;
|
|
|
|
memcpy(lpszEchoHeaderOut, GlobalKnownHeaders[HTTP_QUERY_ECHO_REPLY].Text, cbEchoReply);
|
|
lpsz += cbEchoReply;
|
|
|
|
lpsz[0] = ':';
|
|
lpsz++;
|
|
|
|
|
|
memcpy(lpsz, lpszEchoHeaderIn, cbHeaderIn );
|
|
lpsz += cbHeaderIn;
|
|
|
|
|
|
if ( bCrlfTerminated)
|
|
{
|
|
lpsz[0] = '\r';
|
|
lpsz[1] = '\n';
|
|
lpsz += 2;
|
|
}
|
|
else
|
|
{
|
|
lpsz[0] = '\0';
|
|
lpsz++;
|
|
}
|
|
|
|
*lpsz = '\0';
|
|
}
|
|
|
|
DWORD dwBufferLength;
|
|
dwBufferLength = *lpdwBufferLength;
|
|
|
|
|
|
error = _RequestHeaders.QueryFilteredRawHeaders(
|
|
NULL,
|
|
rglpFilter,
|
|
sizeof(rglpFilter)/sizeof(rglpFilter[0]),
|
|
TRUE,
|
|
TRUE,
|
|
bCrlfTerminated,
|
|
lpBuffer,
|
|
lpdwBufferLength
|
|
);
|
|
|
|
if ( !bEchoPresent )
|
|
{
|
|
// Nothing more to do in this case.
|
|
}
|
|
else if ( error == ERROR_SUCCESS )
|
|
{
|
|
DWORD dwBufferReqd = *lpdwBufferLength + cbHeaderOut;
|
|
// Check if we have space to add extra headers.
|
|
if (dwBufferReqd <= dwBufferLength)
|
|
{
|
|
memcpy((LPSTR)lpBuffer + *lpdwBufferLength, lpszEchoHeaderOut, cbHeaderOut);
|
|
*lpdwBufferLength += cbHeaderOut - 1; // -1 to exclude terminating '\0'
|
|
}
|
|
else
|
|
{
|
|
error = ERROR_INSUFFICIENT_BUFFER;
|
|
// There is a NULL termination count included both in cbHeaderOut and *lpdwBufferLength
|
|
// hence the -1.
|
|
*lpdwBufferLength += cbHeaderOut - 1 ;
|
|
}
|
|
}
|
|
else if ( error == ERROR_INSUFFICIENT_BUFFER )
|
|
{
|
|
*lpdwBufferLength += cbHeaderOut - 1 ;
|
|
}
|
|
else
|
|
{
|
|
// For other errors just return the original error from QueryRawHeaders.
|
|
}
|
|
|
|
done:
|
|
_ResponseHeaders.UnlockHeaders();
|
|
|
|
return error;
|
|
}
|