/*++
Copyright (c) 1999 Microsoft Corporation
Module Name :
w3request.cxx
Abstract:
Friendly wrapper for UL_HTTP_REQUEST
Author:
Bilal Alam (balam) 13-Dec-1999
Environment:
Win32 - User Mode
Project:
ULW3.DLL
--*/
#include "precomp.hxx"
//
// LocalHost address used to determining whether request is local/remote
//
#define LOCAL127 0x0100007F // 127.0.0.1
#define DEFAULT_PORT 80
#define DEFAULT_PORT_SECURE 443
PHOSTENT W3_REQUEST::sm_pHostEnt;
ALLOC_CACHE_HANDLER * W3_CLONE_REQUEST::sm_pachCloneRequests;
DWORD
W3_REQUEST::QueryLocalAddress(
VOID
) const
/*++
Routine Description:
Get the local IP address connected to (assumes IPV4)
Arguments:
None
Return Value:
Address
--*/
{
HTTP_NETWORK_ADDRESS_IPV4 * pAddress;
DBG_ASSERT( _pUlHttpRequest->Address.LocalAddressType == HTTP_NETWORK_ADDRESS_TYPE_IPV4 );
pAddress = (HTTP_NETWORK_ADDRESS_IPV4 *)_pUlHttpRequest->Address.pLocalAddress;
return pAddress->IpAddress;
}
VOID
W3_REQUEST::RemoveDav(
VOID
)
/*++
Routine Description:
Remove DAV'ness of request
Arguments:
None
Return Value:
None
--*/
{
//
// Remove translate header
//
DeleteHeader( "Translate" );
DeleteHeader( "If" );
DeleteHeader( "Lock-Token" );
}
BOOL
W3_REQUEST::IsSuspectUrl(
VOID
)
/*++
Routine Description:
Is the URL for this request look suspect?
Suspect means there is a ./ pattern in it which could cause a metabase
equivilency issue.
Arguments:
None
Return Value:
TRUE if the URL is suspect, else FALSE
--*/
{
WCHAR * pszDotSlash;
WCHAR * pszUrl;
WCHAR chTemp;
pszUrl = _pUlHttpRequest->CookedUrl.pAbsPath;
//
// URL UL gives us has backslashes flipped. But it is not 0 terminated
//
chTemp = pszUrl[ _pUlHttpRequest->CookedUrl.AbsPathLength / 2 ];
pszUrl[ _pUlHttpRequest->CookedUrl.AbsPathLength / 2 ] = L'\0';
pszDotSlash = wcsstr( pszUrl, L"./" );
pszUrl[ _pUlHttpRequest->CookedUrl.AbsPathLength / 2 ] = chTemp;
if ( pszDotSlash != NULL )
{
return TRUE;
}
//
// If the URL ends with a ., it is also suspect
//
if ( pszUrl[ _pUlHttpRequest->CookedUrl.AbsPathLength / 2 - 1 ] == L'.' )
{
return TRUE;
}
return FALSE;
}
BOOL
W3_REQUEST::QueryClientWantsDisconnect(
VOID
)
/*++
Routine Description:
Returns whether the client wants to disconnect, based on its version and
connection: headers
Arguments:
None
Return Value:
TRUE if client wants to disconnect
--*/
{
HTTP_VERSION version;
CHAR * pszConnection;
version = QueryVersion();
//
// If 0.9, then disconnect
//
if ( HTTP_EQUAL_VERSION( version, 0, 9 ) )
{
return TRUE;
}
//
// If 1.0 and Connection: keep-alive isn't present
//
if ( HTTP_EQUAL_VERSION( version, 1, 0 ) )
{
pszConnection = GetHeader( HttpHeaderConnection );
if ( pszConnection == NULL ||
_stricmp( pszConnection, "Keep-Alive" ) != 0 )
{
return TRUE;
}
}
//
// If 1.1 and Connection: Close is present
//
if ( HTTP_EQUAL_VERSION( version, 1, 1 ) )
{
pszConnection = GetHeader( HttpHeaderConnection );
if ( pszConnection != NULL &&
_stricmp( pszConnection, "Close" ) == 0 )
{
return TRUE;
}
}
return FALSE;
}
HRESULT
W3_REQUEST::SetHeadersByStream(
CHAR * pszStream
)
/*++
Routine Description:
Set request headers based on given stream
Arguments:
pszHeaderStream - Stream to parse and set headers off
Return Value:
HRESULT
--*/
{
CHAR * pszCursor;
CHAR * pszEnd;
CHAR * pszColon;
HRESULT hr = NO_ERROR;
STACK_STRA( strHeaderLine, 128 );
STACK_STRA( strHeaderName, 32 );
STACK_STRA( strHeaderValue, 64 );
if ( pszStream == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// \r\n delimited
//
pszCursor = pszStream;
while ( pszCursor != NULL && *pszCursor != '\0' )
{
if ( *pszCursor == '\r' && *(pszCursor + 1) == '\n' )
{
break;
}
pszEnd = strstr( pszCursor, "\r\n" );
if ( pszEnd == NULL )
{
break;
}
//
// Split out a line
//
hr = strHeaderLine.Copy( pszCursor,
DIFF(pszEnd - pszCursor) );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Advance the cursor the right after the \r\n
//
pszCursor = pszEnd + 2;
//
// Split the line above into header:value
//
pszColon = strchr( strHeaderLine.QueryStr(), ':' );
if ( pszColon == NULL )
{
//
// Expecting name:value. Just skip for now
//
continue;
}
hr = strHeaderName.Copy( strHeaderLine.QueryStr(),
DIFF(pszColon - strHeaderLine.QueryStr()) );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Skip the first space after the : if there is one
//
if ( pszColon[ 1 ] == ' ' )
{
pszColon++;
}
hr = strHeaderValue.Copy( pszColon + 1 );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Add the header to the response
//
hr = SetHeader( strHeaderName,
strHeaderValue,
FALSE );
if ( FAILED( hr ) )
{
goto Finished;
}
}
Finished:
return hr;
}
DWORD
W3_REQUEST::QueryRemoteAddress(
VOID
) const
/*++
Routine Description:
Get the remote IP address connecting to us (assumes IPV4)
Arguments:
None
Return Value:
Address
--*/
{
HTTP_NETWORK_ADDRESS_IPV4 * pAddress;
DBG_ASSERT( _pUlHttpRequest->Address.RemoteAddressType == HTTP_NETWORK_ADDRESS_TYPE_IPV4 );
pAddress = (HTTP_NETWORK_ADDRESS_IPV4*) _pUlHttpRequest->Address.pRemoteAddress;
return pAddress->IpAddress;
}
USHORT
W3_REQUEST::QueryLocalPort(
VOID
) const
{
HTTP_NETWORK_ADDRESS_IPV4 * pAddress;
DBG_ASSERT( _pUlHttpRequest->Address.LocalAddressType == HTTP_NETWORK_ADDRESS_TYPE_IPV4 );
pAddress = (HTTP_NETWORK_ADDRESS_IPV4*) _pUlHttpRequest->Address.pLocalAddress;
return pAddress->Port;
}
USHORT
W3_REQUEST::QueryRemotePort(
VOID
) const
{
HTTP_NETWORK_ADDRESS_IPV4 * pAddress;
DBG_ASSERT( _pUlHttpRequest->Address.RemoteAddressType == HTTP_NETWORK_ADDRESS_TYPE_IPV4 );
pAddress = (HTTP_NETWORK_ADDRESS_IPV4*) _pUlHttpRequest->Address.pRemoteAddress;
return pAddress->Port;
}
BOOL
W3_REQUEST::IsProxyRequest(
VOID
)
/*++
Description:
Check if request was issued by a proxy, as determined by following rules :
- "Via:" header is present (HTTP/1.1)
- "Forwarded:" header is present (some HTTP/1.0 implementations)
- "User-Agent:" contains "via ..." (CERN proxy)
Arguments:
None
Returns:
TRUE if client request was issued by proxy
--*/
{
CHAR * pUserAgent;
UINT cUserAgent;
CHAR * pEnd;
if ( GetHeader( HttpHeaderVia ) || GetHeader( "Forward" ) )
{
return TRUE;
}
if ( pUserAgent = GetHeader( HttpHeaderUserAgent ) )
{
cUserAgent = strlen( pUserAgent );
pEnd = pUserAgent + cUserAgent - 3;
//
// scan for "[Vv]ia[ :]" in User-Agent: header
//
while ( pUserAgent < pEnd )
{
if ( *pUserAgent == 'V' || *pUserAgent == 'v' )
{
if ( pUserAgent[1] == 'i' &&
pUserAgent[2] == 'a' &&
(pUserAgent[3] == ' ' || pUserAgent[3] == ':') )
{
return TRUE;
}
}
++pUserAgent;
}
}
return FALSE;
}
BOOL
W3_REQUEST::IsChunkedRequest(
VOID
)
/*++
Description:
Check if request is chunk transfer encoded.
Arguments:
None
Returns:
TRUE if client request has a "transfer-encoding: chunked"
header.
--*/
{
CHAR * pTransferEncoding;
UINT cTransferEncoding;
BOOL fRet = FALSE;
if ( pTransferEncoding = GetHeader( HttpHeaderTransferEncoding ) )
{
fRet = ( _stricmp( pTransferEncoding, "chunked" ) == 0 );
}
return fRet;
}
HRESULT
W3_REQUEST::GetAuthType(
STRA * pstrAuthType
)
/*++
Routine Description:
Determine the auth type for this request. Auth type is the string
after the authorization header (and before the space if there).
Eg. Authorization: Basic FOOBAR ==> AuthType is Basic
Authorization: NTLM ==> AuthType is NTLM
And of course if client cert mapping happened, type is "SSL/PCT"
Arguments:
pstrAuthType - Filled with auth type
Return Value:
HRESULT
--*/
{
CHAR * pszAuthType;
CHAR * pszSpace;
HRESULT hr;
if ( pstrAuthType == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// First check for client cert mapping
//
if ( QueryClientCertInfo() != NULL &&
QueryClientCertInfo()->Token != NULL )
{
return pstrAuthType->Copy( "SSL/PCT" );
}
//
// Now check for the Authorization: header
//
pszAuthType = GetHeader( HttpHeaderAuthorization );
if ( pszAuthType == NULL )
{
pstrAuthType->Reset();
hr = NO_ERROR;
}
else
{
pszSpace = strchr( pszAuthType, ' ' );
if ( pszSpace == NULL )
{
hr = pstrAuthType->Copy( pszAuthType );
}
else
{
hr = pstrAuthType->Copy( pszAuthType,
DIFF( pszSpace - pszAuthType ) );
}
}
return hr;
}
BOOL
W3_REQUEST::IsLocalRequest(
VOID
) const
/*++
Routine Description:
Determines whether current request is a local request. This is used
since certain vroot permissions can be specified for remote/local
Arguments:
None
Return Value:
TRUE if this is a local request
--*/
{
DWORD localAddress = QueryLocalAddress();
DWORD remoteAddress = QueryRemoteAddress();
CHAR** list;
PIN_ADDR p;
//
// Are the remote/local addresses the same?
//
if ( localAddress == remoteAddress )
{
return TRUE;
}
//
// Are either equal to 127.0.0.1
//
if ( localAddress == LOCAL127 ||
remoteAddress == LOCAL127 )
{
return TRUE;
}
//
// Is the remote address equal to one of the host addresses
//
list = sm_pHostEnt->h_addr_list;
while ( (p = (PIN_ADDR)*list++) != NULL )
{
if ( p->s_addr == remoteAddress )
{
return TRUE;
}
}
return FALSE;
}
HRESULT
W3_REQUEST::BuildFullUrl(
STRU& strPath,
STRU * pstrRedirect,
BOOL fIncludeParameters
)
/*++
Routine Description:
Create a new URL while maintaining host/port/protocol/query-string of
original request
Arguments:
strPath - New path portion of URL
pstrRedirect - String filled with new full URL
fIncludeParameters - TRUE if original query string should be copied too
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
if ( pstrRedirect == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
hr = pstrRedirect->Copy( IsSecureRequest() ? L"https://" : L"http://" );
if ( FAILED( hr ) )
{
return hr;
}
LPWSTR pszColon = wcschr( _pUlHttpRequest->CookedUrl.pHost, ':' );
if ((pszColon != NULL) &&
((IsSecureRequest() && _wtoi(pszColon + 1) == DEFAULT_PORT_SECURE) ||
(!IsSecureRequest() && _wtoi(pszColon + 1) == DEFAULT_PORT)))
{
hr = pstrRedirect->Append( _pUlHttpRequest->CookedUrl.pHost,
DIFF(pszColon - _pUlHttpRequest->CookedUrl.pHost) );
}
else
{
hr = pstrRedirect->Append( _pUlHttpRequest->CookedUrl.pHost,
_pUlHttpRequest->CookedUrl.HostLength / sizeof( WCHAR ) );
}
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrRedirect->Append( strPath );
if ( FAILED( hr ) )
{
return hr;
}
if ( fIncludeParameters &&
_pUlHttpRequest->CookedUrl.pQueryString != NULL )
{
//
// UL_HTTP_REQUEST::QueryString already contains the '?'
//
hr = pstrRedirect->Append(
_pUlHttpRequest->CookedUrl.pQueryString,
_pUlHttpRequest->CookedUrl.QueryStringLength / sizeof(WCHAR));
if ( FAILED( hr ) )
{
return hr;
}
}
return S_OK;
}
HRESULT
W3_REQUEST::BuildFullUrl(
STRA& strPath,
STRA * pstrRedirect,
BOOL fIncludeParameters
)
/*++
Routine Description:
Create a new URL while maintaining host/port/protocol/query-string of
original request
Arguments:
strPath - New path portion of URL
pstrRedirect - String filled with new full URL
fIncludeParameters - TRUE if original query string should be copied too
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
if ( pstrRedirect == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
hr = pstrRedirect->Copy( IsSecureRequest() ? "https://" : "http://" );
if ( FAILED( hr ) )
{
return hr;
}
LPWSTR pszColon = wcschr( _pUlHttpRequest->CookedUrl.pHost, ':' );
if ((pszColon != NULL) &&
((IsSecureRequest() && _wtoi(pszColon + 1) == DEFAULT_PORT_SECURE) ||
(!IsSecureRequest() && _wtoi(pszColon + 1) == DEFAULT_PORT)))
{
hr = pstrRedirect->AppendW( _pUlHttpRequest->CookedUrl.pHost,
DIFF(pszColon - _pUlHttpRequest->CookedUrl.pHost) );
}
else
{
hr = pstrRedirect->AppendW( _pUlHttpRequest->CookedUrl.pHost,
_pUlHttpRequest->CookedUrl.HostLength / sizeof( WCHAR ) );
}
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrRedirect->Append( strPath );
if ( FAILED( hr ) )
{
return hr;
}
if ( fIncludeParameters &&
_pUlHttpRequest->CookedUrl.pQueryString != NULL )
{
//
// UL_HTTP_REQUEST::QueryString already contains the '?'
//
hr = pstrRedirect->AppendW(
_pUlHttpRequest->CookedUrl.pQueryString,
_pUlHttpRequest->CookedUrl.QueryStringLength / sizeof(WCHAR));
if ( FAILED( hr ) )
{
return hr;
}
}
return S_OK;
}
CHAR *
W3_REQUEST::GetHeader(
CHAR * pszHeaderName
)
/*++
Routine Description:
Get a request header and copy it into supplied buffer
Arguments:
pszHeaderName - Name of header to get
Return Value:
WCHAR pointer pointed to the header, NULL if no such header
--*/
{
ULONG ulHeaderIndex = UNKNOWN_INDEX;
HTTP_REQUEST_HEADERS * pHeaders = &(_pUlHttpRequest->Headers);
HRESULT hr = HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
DBG_ASSERT( pszHeaderName != NULL );
//
// First check whether this header is a known header
//
ulHeaderIndex = REQUEST_HEADER_HASH::GetIndex( pszHeaderName );
if ( ulHeaderIndex == UNKNOWN_INDEX )
{
//
// Need to iterate thru unknown headers
//
for ( DWORD i = 0;
i < pHeaders->UnknownHeaderCount;
i++ )
{
if ( _stricmp( pszHeaderName,
pHeaders->pUnknownHeaders[ i ].pName ) == 0 )
{
return pHeaders->pUnknownHeaders[ i ].pRawValue;
}
}
return NULL;
}
else
{
//
// Known header
//
DBG_ASSERT( ulHeaderIndex < HttpHeaderRequestMaximum );
return pHeaders->pKnownHeaders[ ulHeaderIndex ].pRawValue;
}
}
HRESULT
W3_REQUEST::GetHeader(
CHAR * pszHeaderName,
DWORD cchHeaderName,
STRA * pstrHeaderValue,
BOOL fIsUnknownHeader
)
/*++
Routine Description:
Get a request header and copy it into supplied buffer
Arguments:
pszHeaderName - Header name
cchHeaderName - Length of header name
pstrHeaderValue - Filled with header value
fIsUnknownHeader - (optional) set to TRUE if header is unknown
and we can avoid doing header hash lookup
Return Value:
HRESULT
--*/
{
ULONG ulHeaderIndex = UNKNOWN_INDEX;
HTTP_REQUEST_HEADERS * pHeaders = &(_pUlHttpRequest->Headers);
HRESULT hr = HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
if ( pszHeaderName == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// First check whether this header is a known header
//
if ( !fIsUnknownHeader )
{
ulHeaderIndex = REQUEST_HEADER_HASH::GetIndex( pszHeaderName );
}
if ( ulHeaderIndex == UNKNOWN_INDEX )
{
//
// Need to iterate thru unknown headers
//
for ( DWORD i = 0;
i < pHeaders->UnknownHeaderCount;
i++ )
{
if ( cchHeaderName == pHeaders->pUnknownHeaders[ i ].NameLength &&
_stricmp( pszHeaderName,
pHeaders->pUnknownHeaders[ i ].pName ) == 0 )
{
hr = pstrHeaderValue->Copy(
pHeaders->pUnknownHeaders[ i ].pRawValue,
pHeaders->pUnknownHeaders[ i ].RawValueLength );
break;
}
}
}
else
{
//
// Known header
//
DBG_ASSERT( ulHeaderIndex < HttpHeaderRequestMaximum );
if ( pHeaders->pKnownHeaders[ ulHeaderIndex ].pRawValue != NULL )
{
hr = pstrHeaderValue->Copy(
pHeaders->pKnownHeaders[ ulHeaderIndex ].pRawValue,
pHeaders->pKnownHeaders[ ulHeaderIndex ].RawValueLength);
}
else
{
hr = HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
}
}
return hr;
}
HRESULT
W3_REQUEST::DeleteHeader(
CHAR * pszHeaderName
)
/*++
Routine Description:
Delete a request header
Arguments:
pszHeaderName - Header to delete
Return Value:
HRESULT
--*/
{
ULONG ulHeaderIndex;
HRESULT hr;
HTTP_UNKNOWN_HEADER * pUnknownHeader;
//
// Is this a known header? If so, we can just set by reference now
// since we have copied the header value
//
ulHeaderIndex = REQUEST_HEADER_HASH::GetIndex( pszHeaderName );
if ( ulHeaderIndex != UNKNOWN_INDEX &&
ulHeaderIndex < HttpHeaderResponseMaximum )
{
_pUlHttpRequest->Headers.pKnownHeaders[ ulHeaderIndex ].pRawValue = NULL;
_pUlHttpRequest->Headers.pKnownHeaders[ ulHeaderIndex ].RawValueLength = 0;
}
else
{
//
// Unknown header. First check if it exists
//
for ( DWORD i = 0;
i < _pUlHttpRequest->Headers.UnknownHeaderCount;
i++ )
{
pUnknownHeader = &(_pUlHttpRequest->Headers.pUnknownHeaders[ i ]);
DBG_ASSERT( pUnknownHeader != NULL );
if ( _stricmp( pUnknownHeader->pName, pszHeaderName ) == 0 )
{
break;
}
}
if ( i < _pUlHttpRequest->Headers.UnknownHeaderCount )
{
//
// Now shrink the array to remove the header
//
memmove( _pUlHttpRequest->Headers.pUnknownHeaders + i,
_pUlHttpRequest->Headers.pUnknownHeaders + i + 1,
( _pUlHttpRequest->Headers.UnknownHeaderCount - i - 1 ) *
sizeof( HTTP_UNKNOWN_HEADER ) );
_pUlHttpRequest->Headers.UnknownHeaderCount--;
}
}
return NO_ERROR;
}
HRESULT
W3_REQUEST::SetHeader(
STRA & strHeaderName,
STRA & strHeaderValue,
BOOL fAppend
)
/*++
Routine Description:
Set a request header
Arguments:
strHeaderName - Name of header to set
strHeaderValue - New header value to set
fAppend - If TRUE, the existing header value is appended to, else it is
replaced
Return Value:
HRESULT
--*/
{
CHAR * pszNewName = NULL;
CHAR * pszNewValue = NULL;
STACK_STRA( strOldHeaderValue, 256 );
STRA * pstrNewHeaderValue = NULL;
HRESULT hr;
ULONG index;
//
// If we're appending, then get the old header value (if any) and
// append the new value (with a comma delimiter)
//
if ( fAppend )
{
hr = GetHeader( strHeaderName, &strOldHeaderValue );
if ( FAILED( hr ) )
{
pstrNewHeaderValue = &strHeaderValue;
hr = NO_ERROR;
}
else
{
hr = strOldHeaderValue.Append( ",", 1 );
if ( FAILED( hr ) )
{
return hr;
}
hr = strOldHeaderValue.Append( strHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
pstrNewHeaderValue = &strOldHeaderValue;
}
}
else
{
pstrNewHeaderValue = &strHeaderValue;
}
DBG_ASSERT( pstrNewHeaderValue != NULL );
//
// pstrNewHeaderValue will point to either "old,new" or "new"
//
hr = _HeaderBuffer.AllocateSpace( pstrNewHeaderValue->QueryStr(),
pstrNewHeaderValue->QueryCCH(),
&pszNewValue );
if ( FAILED( hr ) )
{
return hr;
}
//
// Is this a known header?
//
index = REQUEST_HEADER_HASH::GetIndex( strHeaderName.QueryStr() );
if ( index == UNKNOWN_INDEX )
{
hr = _HeaderBuffer.AllocateSpace( strHeaderName.QueryStr(),
strHeaderName.QueryCCH(),
&pszNewName );
if ( FAILED( hr ) )
{
return hr;
}
//
// Find the header in the unknown list
//
for ( DWORD i = 0;
i < _pUlHttpRequest->Headers.UnknownHeaderCount;
i++ )
{
if ( _strnicmp( strHeaderName.QueryStr(),
_pUlHttpRequest->Headers.pUnknownHeaders[ i ].pName,
strHeaderName.QueryCCH() ) == 0 )
{
break;
}
}
//
// If we found the unknown header, then this is much simpler
//
if ( i < _pUlHttpRequest->Headers.UnknownHeaderCount )
{
_pUlHttpRequest->Headers.pUnknownHeaders[i].pRawValue =
pszNewValue;
_pUlHttpRequest->Headers.pUnknownHeaders[i].RawValueLength =
(USHORT) pstrNewHeaderValue->QueryCB();
}
else
{
HTTP_UNKNOWN_HEADER *pUnknownHeaders;
DWORD cCount;
//
// Fun. Need to add a new unknown header
//
cCount = _pUlHttpRequest->Headers.UnknownHeaderCount;
//
// BUGBUG: are we leaking this memory?
//
pUnknownHeaders = (HTTP_UNKNOWN_HEADER *) LocalAlloc(
LPTR,
sizeof( HTTP_UNKNOWN_HEADER ) *
( cCount+1 ) );
if ( pUnknownHeaders == NULL )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
memcpy( pUnknownHeaders,
_pUlHttpRequest->Headers.pUnknownHeaders,
sizeof( HTTP_UNKNOWN_HEADER ) * (cCount) );
pUnknownHeaders[ cCount ].pName = pszNewName;
pUnknownHeaders[ cCount ].NameLength = (USHORT)strHeaderName.QueryCB();
pUnknownHeaders[ cCount ].pRawValue = pszNewValue;
pUnknownHeaders[ cCount ].RawValueLength = (USHORT) pstrNewHeaderValue->QueryCB();
//
// Patch in the new array
//
if ( _pExtraUnknown != NULL )
{
LocalFree( _pExtraUnknown );
}
_pExtraUnknown = pUnknownHeaders;
_pUlHttpRequest->Headers.pUnknownHeaders = pUnknownHeaders;
_pUlHttpRequest->Headers.UnknownHeaderCount++;
}
}
else
{
//
// The easy case. Known header
//
_pUlHttpRequest->Headers.pKnownHeaders[ index ].pRawValue = pszNewValue;
_pUlHttpRequest->Headers.pKnownHeaders[ index ].RawValueLength = (USHORT) pstrNewHeaderValue->QueryCB();
}
return S_OK;
}
HRESULT
W3_REQUEST::GetVersionString(
STRA * pstrVersion
)
/*++
Routine Description:
Get version string of request (like "HTTP/1.1")
Arguments:
pstrVersion - Filled in with version
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR pszMajorVersion[6];
CHAR pszMinorVersion[6];
_itoa(_pUlHttpRequest->Version.MajorVersion, pszMajorVersion, 10);
_itoa(_pUlHttpRequest->Version.MinorVersion, pszMinorVersion, 10);
if (FAILED(hr = pstrVersion->Copy("HTTP/", 5)) ||
FAILED(hr = pstrVersion->Append(pszMajorVersion)) ||
FAILED(hr = pstrVersion->Append(".", 1)) ||
FAILED(hr = pstrVersion->Append(pszMinorVersion)))
{
return hr;
}
return S_OK;
}
HRESULT
W3_REQUEST::GetVerbString(
STRA * pstrVerb
)
/*++
Routine Description:
Get the HTTP verb from the request
Arguments:
pstrVerb - Filled in with verb
Return Value:
HRESULT
--*/
{
USHORT cchVerb;
CHAR *pszVerb = METHOD_HASH::GetString(_pUlHttpRequest->Verb, &cchVerb);
if (pszVerb != NULL)
{
return pstrVerb->Copy(pszVerb, cchVerb);
}
else
{
return pstrVerb->Copy(_pUlHttpRequest->pUnknownVerb,
_pUlHttpRequest->UnknownVerbLength);
}
}
VOID
W3_REQUEST::QueryVerb(
CHAR **ppszVerb,
USHORT *pcchVerb)
/*++
Get the HTTP verb from the request
--*/
{
*ppszVerb = METHOD_HASH::GetString(_pUlHttpRequest->Verb, pcchVerb);
if (*ppszVerb == NULL)
{
*ppszVerb = _pUlHttpRequest->pUnknownVerb;
*pcchVerb = _pUlHttpRequest->UnknownVerbLength;
}
}
HRESULT
W3_REQUEST::SetVerb(
STRA & strVerb
)
/*++
Routine Description:
Change the request verb (done in PREPROC_HEADER ISAPI filters)
Arguments:
strVerb - New verb
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR *pszNewVerb;
HTTP_VERB Verb = (HTTP_VERB)METHOD_HASH::GetIndex(strVerb.QueryStr());
_pUlHttpRequest->Verb = Verb;
if ( Verb == HttpVerbUnknown )
{
//
// Handle unknown verbs
//
hr = _HeaderBuffer.AllocateSpace( strVerb.QueryStr(),
strVerb.QueryCCH(),
&pszNewVerb );
if ( FAILED( hr ) )
{
return hr;
}
_pUlHttpRequest->pUnknownVerb = pszNewVerb;
_pUlHttpRequest->UnknownVerbLength = (USHORT) strVerb.QueryCCH();
}
else
{
_pUlHttpRequest->pUnknownVerb = NULL;
_pUlHttpRequest->UnknownVerbLength = 0;
}
return S_OK;
}
HRESULT
W3_REQUEST::SetVersion(
STRA& strVersion
)
/*++
Routine Description:
strVersion - Set the request version (done by PREPROC_HEADER filters)
Arguments:
strVersion - Version string
Return Value:
HRESULT
--*/
{
HRESULT hr = S_OK;
//
// BUGBUG: Probably not the fastest way to do this
//
if ( strcmp( strVersion.QueryStr(), "HTTP/1.1" ) == 0 )
{
_pUlHttpRequest->Version.MajorVersion = 1;
_pUlHttpRequest->Version.MinorVersion = 1;
}
else if ( strcmp( strVersion.QueryStr(), "HTTP/1.0" ) == 0 )
{
_pUlHttpRequest->Version.MajorVersion = 1;
_pUlHttpRequest->Version.MinorVersion = 0;
}
else if ( strcmp( strVersion.QueryStr(), "HTTP/0.9" ) == 0 )
{
_pUlHttpRequest->Version.MajorVersion = 0;
_pUlHttpRequest->Version.MinorVersion = 9;
}
else
{
hr = HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
}
return hr;
}
HRESULT
W3_REQUEST::SetNewPreloadedEntityBody(
VOID * pvBuffer,
DWORD cbBuffer
)
/*++
Routine Description:
Change the preloaded entity body for this request
Arguments:
pvBuffer - the buffer
cbBuffer - the size of the buffer
Return Value:
HRESULT
--*/
{
_InsertedEntityBodyChunk.DataChunkType = HttpDataChunkFromMemory;
_InsertedEntityBodyChunk.FromMemory.pBuffer = pvBuffer;
_InsertedEntityBodyChunk.FromMemory.BufferLength = cbBuffer;
_pUlHttpRequest->EntityChunkCount = 1;
_pUlHttpRequest->pEntityChunks = &_InsertedEntityBodyChunk;
return NO_ERROR;
}
HRESULT
W3_REQUEST::AppendEntityBody(
VOID * pvBuffer,
DWORD cbBuffer
)
/*
Description
Add the given entity to (any) entity already present
Arguments
pvBuffer - the buffer
cbBuffer - the size of the buffer
Return Value
HRESULT
*/
{
DWORD cbAlreadyPresent = QueryAvailableBytes();
if ( cbAlreadyPresent == 0 )
{
return SetNewPreloadedEntityBody(pvBuffer, cbBuffer);
}
else
{
PVOID pbAlreadyPresent = QueryEntityBody();
if (!_buffEntityBodyPreload.Resize(cbBuffer + cbAlreadyPresent))
{
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
memcpy(_buffEntityBodyPreload.QueryPtr(),
pbAlreadyPresent,
cbAlreadyPresent);
memcpy((PBYTE)_buffEntityBodyPreload.QueryPtr() + cbAlreadyPresent,
pvBuffer,
cbBuffer);
}
return S_OK;
}
HRESULT
W3_REQUEST::SetUrl(
STRU & strNewUrl,
BOOL fResetQueryString // = TRUE
)
/*++
Routine Description:
Change the URL of the request
Arguments:
strNewUrl - New URL
fResetQueryString - TRUE if we should expect query string in strNewUrl
Return Value:
HRESULT
--*/
{
STACK_STRA ( straUrl, MAX_PATH );
HRESULT hr = S_OK;
DWORD lenToConvert = 0;
WCHAR * pFirstQuery = wcschr(strNewUrl.QueryStr(), L'?');
if (NULL == pFirstQuery)
{
lenToConvert = strNewUrl.QueryCCH();
}
else
{
lenToConvert = DIFF(pFirstQuery - strNewUrl.QueryStr());
}
if (FAILED(hr = straUrl.CopyWToUTF8(strNewUrl.QueryStr(), lenToConvert)))
{
return hr;
}
straUrl.AppendW(strNewUrl.QueryStr() + lenToConvert);
//
// SetUrlA does the canonicalization, unescaping
//
return SetUrlA( straUrl, fResetQueryString );
}
HRESULT
W3_REQUEST::SetUrlA(
STRA & strNewUrl,
BOOL fResetQueryString // = TRUE
)
/*++
Routine Description:
Change the URL of the request. Takes in an ANSI URL
Arguments:
strNewUrl - RAW version of URL which is also stored away
fResetQueryString - Should we expect query string in strNewUrl
Return Value:
HRESULT
--*/
{
DWORD cchNewUrl;
HRESULT hr = NO_ERROR;
ULONG cbBytesCopied;
LPWSTR pszQueryString;
CHAR * pszNewRawUrl;
LPWSTR pszNewFullUrl;
LPWSTR pszNewAbsPath;
STACK_STRU ( strFullUrl, MAX_PATH);
STACK_STRU ( strAbsPath, MAX_PATH);
//
// Need to process the URL ourselves. This means:
// -Unescaping, canonicalizing, and query-string-ilizing
//
//
// BUGBUG. Probably need to handle HTTP:// and HTTPS:// preceded URLs
// so that MS proxy can still work
//
hr = _HeaderBuffer.AllocateSpace( strNewUrl.QueryStr(),
strNewUrl.QueryCCH(),
&pszNewRawUrl );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Need to patch the UL_HTTP_REQUEST raw URL
//
_pUlHttpRequest->pRawUrl = pszNewRawUrl;
_pUlHttpRequest->RawUrlLength = (USHORT) strNewUrl.QueryCCH();
hr = _HeaderBuffer.AllocateSpace( (strNewUrl.QueryCCH() + 1)*sizeof(WCHAR),
&pszNewAbsPath );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Call into a UL ripped helper to do the parsing
//
hr = UlCleanAndCopyUrl( (PUCHAR)pszNewRawUrl,
strNewUrl.QueryCCH(),
&cbBytesCopied,
pszNewAbsPath,
&pszQueryString );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Need to patch the UL_HTTP_REQUEST AbsPath and QueryString
//
_pUlHttpRequest->CookedUrl.pAbsPath = pszNewAbsPath;
if ( pszQueryString != NULL )
{
_pUlHttpRequest->CookedUrl.pQueryString = pszQueryString;
_pUlHttpRequest->CookedUrl.AbsPathLength = DIFF(pszQueryString - pszNewAbsPath) * sizeof(WCHAR);
_pUlHttpRequest->CookedUrl.QueryStringLength = (USHORT)(cbBytesCopied - _pUlHttpRequest->CookedUrl.AbsPathLength);
}
else
{
if ( fResetQueryString )
{
_pUlHttpRequest->CookedUrl.pQueryString = NULL;
_pUlHttpRequest->CookedUrl.QueryStringLength = 0;
}
_pUlHttpRequest->CookedUrl.AbsPathLength = (USHORT) cbBytesCopied;
}
hr = strAbsPath.Copy(pszNewAbsPath);
if (FAILED(hr))
{
goto Finished;
}
//
// Need to patch up the Full Url.
//
BuildFullUrl( strAbsPath, &strFullUrl, FALSE);
hr = _HeaderBuffer.AllocateSpace( strFullUrl.QueryStr(),
strFullUrl.QueryCCH(),
&pszNewFullUrl );
if (FAILED(hr))
{
goto Finished;
}
_pUlHttpRequest->CookedUrl.pFullUrl = pszNewFullUrl;
_pUlHttpRequest->CookedUrl.FullUrlLength = (USHORT) strFullUrl.QueryCB();
Finished:
return hr;
}
HRESULT
W3_REQUEST::BuildISAPIHeaderLine(
CHAR * pszHeaderName,
DWORD cchHeaderName,
CHAR * pszHeaderValue,
DWORD cchHeaderValue,
STRA * pstrHeaderLine
)
/*++
Routine Description:
Private utility to build a header line as such:
pszHeaderName = "this-is-a-header", pszHeaderValue = "foobar"
PRODUCES
"HTTP_THIS_IS_A_HEADER:foobar\n"
Arguments:
pszHeaderName - Header name
cchHeaderName - Length of header name
pszHeaderValue - Header value
cchHeaderValue - Length of header value
pstrHeaderLine - Header line is appended
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR * pszCursor;
DWORD currHeaderLength = pstrHeaderLine->QueryCCH();
//
// Convert header name "a-b-c" into "HTTP_A_B_C"
//
hr = pstrHeaderLine->Append( "HTTP_", 5 );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrHeaderLine->Append( pszHeaderName, cchHeaderName );
if ( FAILED( hr ) )
{
return hr;
}
//
// Convert - to _
//
pszCursor = strchr( pstrHeaderLine->QueryStr() + currHeaderLength + 5,
'-' );
while ( pszCursor != NULL )
{
*pszCursor++ = '_';
pszCursor = strchr( pszCursor, L'-' );
}
//
// Uppercase it
//
_strupr( pstrHeaderLine->QueryStr() + currHeaderLength + 5 );
//
// Now finish the header line by adding ":<header value>\n"
//
// Note that raw HTTP looks like ": <header value>", but earlier
// versions of IIS did not include the space, and there are
// legacy ISAPI's that depend on the space after the colon
// not being there.
//
hr = pstrHeaderLine->Append( ":", 1 );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrHeaderLine->Append( pszHeaderValue, cchHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrHeaderLine->Append( "\n", 1 );
if ( FAILED( hr ) )
{
return hr;
}
return NO_ERROR;
}
HRESULT
W3_REQUEST::BuildRawHeaderLine(
CHAR * pszHeaderName,
DWORD cchHeaderName,
CHAR * pszHeaderValue,
DWORD cchHeaderValue,
STRA * pstrHeaderLine
)
/*++
Routine Description:
Private utility to build a header line as such:
pszHeaderName = "this-is-a-header", pszHeaderValue = "foobar"
PRODUCES
this-is-a-header: foobar\r\n
Arguments:
pszHeaderName - Header name
cchHeaderName - Length of header name
pszHeaderValue - Header value
cchHeaderValue - Length of header value
pstrHeaderLine - Header line is appended
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR * pszCursor;
hr = pstrHeaderLine->Append( pszHeaderName );
if ( FAILED( hr ) )
{
return hr;
}
//
// Now finish the header line by adding ": <header value>\n"
//
hr = pstrHeaderLine->Append( ": ", 2 );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrHeaderLine->Append( pszHeaderValue, cchHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrHeaderLine->Append( "\r\n" );
if ( FAILED( hr ) )
{
return hr;
}
return NO_ERROR;
}
HRESULT
W3_REQUEST::GetAllHeaders(
STRA * pstrHeaders,
BOOL fISAPIStyle
)
/*++
Routine Description:
Get all headers in one string, delimited by \r\n
Arguments:
pstrHeaders - Filled with headers
fISAPIStyle -
If TRUE, format is: HTTP_CONTENT_LENGTH: 245\nHTTP_CONTENT_TYPE: t\n
If FALSE, format is: CONTENT-LENGTH: 245\r\nCONTENT-TYPE: t\r\n
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
DWORD cCounter;
HTTP_KNOWN_HEADER * pKnownHeader;
CHAR * pszName;
DWORD cchName;
HTTP_UNKNOWN_HEADER * pUnknownHeader;
if ( pstrHeaders == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// Copy known headers
//
for ( cCounter = 0;
cCounter < HttpHeaderRequestMaximum;
cCounter++ )
{
pKnownHeader = &(_pUlHttpRequest->Headers.pKnownHeaders[ cCounter ]);
if ( pKnownHeader->RawValueLength != 0 )
{
pszName = REQUEST_HEADER_HASH::GetString( cCounter, &cchName );
if ( pszName == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_DATA );
}
if ( fISAPIStyle )
{
hr = BuildISAPIHeaderLine( pszName,
cchName,
pKnownHeader->pRawValue,
pKnownHeader->RawValueLength,
pstrHeaders );
}
else
{
hr = BuildRawHeaderLine( pszName,
cchName,
pKnownHeader->pRawValue,
pKnownHeader->RawValueLength,
pstrHeaders );
}
if ( FAILED( hr ) )
{
return hr;
}
}
}
//
// Copy unknown headers
//
for ( cCounter = 0;
cCounter < _pUlHttpRequest->Headers.UnknownHeaderCount;
cCounter++ )
{
pUnknownHeader = &(_pUlHttpRequest->Headers.pUnknownHeaders[ cCounter ]);
pszName = pUnknownHeader->pName;
cchName = pUnknownHeader->NameLength;
if ( fISAPIStyle )
{
hr = BuildISAPIHeaderLine( pszName,
cchName,
pUnknownHeader->pRawValue,
pUnknownHeader->RawValueLength,
pstrHeaders );
}
else
{
hr = BuildRawHeaderLine( pszName,
cchName,
pUnknownHeader->pRawValue,
pUnknownHeader->RawValueLength,
pstrHeaders );
}
if ( FAILED( hr ) )
{
return hr;
}
}
return NO_ERROR;
}
HRESULT
W3_REQUEST::CloneRequest(
DWORD dwCloneFlags,
W3_REQUEST ** ppRequest
)
/*++
Routine Description:
Clone request. Used to setup a child request to execute
Arguments:
dwCloneFlags - Flags controlling how much of the current request to clone.
Without any flag, we will copy only the bare minimum
W3_REQUEST_CLONE_BASICS - clone URL/querystring/Verb
W3_REQUEST_CLONE_HEADERS - clone request headers
W3_REQUEST_CLONE_ENTITY - clone the entity body
W3_REQUEST_CLONE_NO_PRECONDITION - remove range/if-*
W3_REQUEST_CLONE_NO_DAV - remove DAV requests
ppRequest - Set to point to a new W3_REQUEST on success
Return Value:
HRESULT
--*/
{
W3_CLONE_REQUEST * pCloneRequest = NULL;
HRESULT hr = NO_ERROR;
if ( ppRequest == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
*ppRequest = NULL;
//
// Allocate a new cloned request
//
pCloneRequest = new W3_CLONE_REQUEST();
if ( pCloneRequest == NULL )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
goto Finished;
}
//
// Copy the bare minimum
//
hr = pCloneRequest->CopyMinimum( _pUlHttpRequest );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Should we copy the request basics (URL/querystring/Verb)?
//
if ( dwCloneFlags & W3_REQUEST_CLONE_BASICS )
{
hr = pCloneRequest->CopyBasics( _pUlHttpRequest );
}
else
{
hr = pCloneRequest->CopyBasics( NULL );
}
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Should we copy the headers?
//
if ( dwCloneFlags & W3_REQUEST_CLONE_HEADERS )
{
hr = pCloneRequest->CopyHeaders( _pUlHttpRequest );
}
else
{
hr = pCloneRequest->CopyHeaders( NULL );
}
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Should we also reference the parent's entity body
//
if ( dwCloneFlags & W3_REQUEST_CLONE_ENTITY )
{
hr = pCloneRequest->CopyEntity( _pUlHttpRequest );
}
else
{
hr = pCloneRequest->CopyEntity( NULL );
}
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Remove conditionals if requested
//
if ( dwCloneFlags & W3_REQUEST_CLONE_NO_PRECONDITION )
{
pCloneRequest->RemoveConditionals();
}
//
// Remove DAV'ness if requested
//
if ( dwCloneFlags & W3_REQUEST_CLONE_NO_DAV )
{
pCloneRequest->RemoveDav();
}
*ppRequest = pCloneRequest;
Finished:
if ( FAILED( hr ) )
{
if ( pCloneRequest != NULL )
{
delete pCloneRequest;
pCloneRequest = NULL;
}
}
return hr;
}
//static
HRESULT
W3_REQUEST::Initialize(
VOID
)
/*++
Routine Description:
Global initalization for utilities used by W3_REQUEST object
Arguments:
None
Return Value:
HRESULT
--*/
{
CHAR achName[ MAX_PATH + 1 ];
INT err;
HRESULT hr;
//
// Get the host name for use in remote/local determination
//
err = gethostname( achName, sizeof( achName ) );
if ( err != 0 )
{
hr = HRESULT_FROM_WIN32( WSAGetLastError() );
DBGPRINTF(( DBG_CONTEXT,
"Error getting host name. hr = %x\n",
hr ));
return hr;
}
sm_pHostEnt = gethostbyname( achName );
if ( sm_pHostEnt == NULL )
{
hr = HRESULT_FROM_WIN32( WSAGetLastError() );
DBGPRINTF(( DBG_CONTEXT,
"Error getting host. hr = %x\n",
hr ));
return hr;
}
hr = REQUEST_HEADER_HASH::Initialize();
if ( FAILED( hr ) )
{
return hr;
}
hr = METHOD_HASH::Initialize();
if ( FAILED( hr ) )
{
return hr;
}
hr = W3_CLONE_REQUEST::Initialize();
if ( FAILED( hr ) )
{
REQUEST_HEADER_HASH::Terminate();
return hr;
}
return NO_ERROR;
}
//static
VOID
W3_REQUEST::Terminate(
VOID
)
{
W3_CLONE_REQUEST::Terminate();
REQUEST_HEADER_HASH::Terminate();
METHOD_HASH::Terminate();
}
HRESULT
W3_CLONE_REQUEST::CopyEntity(
HTTP_REQUEST * pRequestToClone
)
/*++
Routine Description:
Reference the parents entity body if required
Arguments:
pRequestToClone - UL_HTTP_REQUEST to clone. NULL if we shouldn't clone
Return Value:
HRESULT
--*/
{
if ( pRequestToClone == NULL )
{
_ulHttpRequest.MoreEntityBodyExists = FALSE;
_ulHttpRequest.EntityChunkCount = 0;
_ulHttpRequest.pEntityChunks = NULL;
}
else
{
_ulHttpRequest.MoreEntityBodyExists = pRequestToClone->MoreEntityBodyExists;
_ulHttpRequest.EntityChunkCount = pRequestToClone->EntityChunkCount;
_ulHttpRequest.pEntityChunks = pRequestToClone->pEntityChunks;
}
return S_OK;
}
HRESULT
W3_CLONE_REQUEST::CopyBasics(
HTTP_REQUEST * pRequestToClone
)
/*++
Routine Description:
Copy the URL/query-string/Verb if required
Arguments:
pRequestToClone - HTTP_REQUEST to clone. NULL if we shouldn't clone
Return Value:
HRESULT
--*/
{
if ( pRequestToClone == NULL )
{
_ulHttpRequest.Verb = HttpVerbUnparsed;
_ulHttpRequest.UnknownVerbLength = 0;
_ulHttpRequest.pUnknownVerb = NULL;
_ulHttpRequest.RawUrlLength = 0;
_ulHttpRequest.pRawUrl = NULL;
_ulHttpRequest.CookedUrl.FullUrlLength = 0;
_ulHttpRequest.CookedUrl.pFullUrl = NULL;
_ulHttpRequest.CookedUrl.HostLength = 0;
_ulHttpRequest.CookedUrl.pHost = NULL;
_ulHttpRequest.CookedUrl.AbsPathLength = 0;
_ulHttpRequest.CookedUrl.pAbsPath = NULL;
_ulHttpRequest.CookedUrl.QueryStringLength = 0;
_ulHttpRequest.CookedUrl.pQueryString = NULL;
}
else
{
_ulHttpRequest.Verb = pRequestToClone->Verb;
_ulHttpRequest.UnknownVerbLength = pRequestToClone->UnknownVerbLength;
_ulHttpRequest.pUnknownVerb = pRequestToClone->pUnknownVerb;
_ulHttpRequest.RawUrlLength = pRequestToClone->RawUrlLength;
_ulHttpRequest.pRawUrl = pRequestToClone->pRawUrl;
_ulHttpRequest.CookedUrl.FullUrlLength = pRequestToClone->CookedUrl.FullUrlLength;
_ulHttpRequest.CookedUrl.pFullUrl = pRequestToClone->CookedUrl.pFullUrl;
_ulHttpRequest.CookedUrl.HostLength = pRequestToClone->CookedUrl.HostLength;
_ulHttpRequest.CookedUrl.pHost = pRequestToClone->CookedUrl.pHost;
_ulHttpRequest.CookedUrl.AbsPathLength = pRequestToClone->CookedUrl.AbsPathLength;
_ulHttpRequest.CookedUrl.pAbsPath = pRequestToClone->CookedUrl.pAbsPath;
_ulHttpRequest.CookedUrl.QueryStringLength = pRequestToClone->CookedUrl.QueryStringLength;
_ulHttpRequest.CookedUrl.pQueryString = pRequestToClone->CookedUrl.pQueryString;
}
return S_OK;
}
HRESULT
W3_CLONE_REQUEST::CopyMinimum(
HTTP_REQUEST * pRequestToClone
)
/*++
Routine Description:
Copies the bare minimum from the clonee. Bare minimums includes
remote/local port/address, version, etc.
Arguments:
pRequestToClone - UL_HTTP_REQUEST to clone
Return Value:
HRESULT
--*/
{
if ( pRequestToClone == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// Miscellaneous UL goo
//
_ulHttpRequest.ConnectionId = pRequestToClone->ConnectionId;
_ulHttpRequest.RequestId = pRequestToClone->RequestId;
_ulHttpRequest.UrlContext = pRequestToClone->UrlContext;
_ulHttpRequest.Version = pRequestToClone->Version;
//
// Local/Remote address
//
_ulHttpRequest.Address.RemoteAddressLength = pRequestToClone->Address.RemoteAddressLength;
_ulHttpRequest.Address.RemoteAddressType = pRequestToClone->Address.RemoteAddressType;
_ulHttpRequest.Address.LocalAddressLength = pRequestToClone->Address.LocalAddressLength;
_ulHttpRequest.Address.LocalAddressType = pRequestToClone->Address.LocalAddressType;
_ulHttpRequest.Address.pRemoteAddress = pRequestToClone->Address.pRemoteAddress;
_ulHttpRequest.Address.pLocalAddress = pRequestToClone->Address.pLocalAddress;
//
// Other stuff
//
_ulHttpRequest.RawConnectionId = pRequestToClone->RawConnectionId;
_ulHttpRequest.pSslInfo = pRequestToClone->pSslInfo;
return NO_ERROR;
}
HRESULT
W3_CLONE_REQUEST::CopyHeaders(
HTTP_REQUEST * pRequestToClone
)
/*++
Routine Description:
Copies request headers from pRequestToClone into the current cloned
request
Arguments:
pRequestToClone - HTTP_REQUEST to clone, NULL if there should be no
headers
Return Value:
HRESULT
--*/
{
DWORD cUnknownHeaders;
if ( pRequestToClone == NULL )
{
//
// No headers.
//
ZeroMemory( &( _ulHttpRequest.Headers ),
sizeof( _ulHttpRequest.Headers ) );
}
else
{
//
// Copy all the headers
//
//
// Start with the known headers. Note that we can just copy
// the Headers member directly. The memory being referenced by
// the pointers are guaranteed to be around for the life of this
// request. (the memory is either off the UL_NATIVE_REQUEST or
// it is off a CHUNK_BUFFER from the main parent request)
//
memcpy( _ulHttpRequest.Headers.pKnownHeaders,
pRequestToClone->Headers.pKnownHeaders,
sizeof( _ulHttpRequest.Headers.pKnownHeaders ) );
//
// Copy the unknown headers. For this case, we will have to
// allocate our own buffer since the unknown header array can be
// resized. But as before, the memory referenced by the
// unknown headers is OK to reference again.
//
cUnknownHeaders = pRequestToClone->Headers.UnknownHeaderCount;
if ( cUnknownHeaders > 0 )
{
_pExtraUnknown = (HTTP_UNKNOWN_HEADER*) LocalAlloc(
LPTR,
sizeof( HTTP_UNKNOWN_HEADER)*
cUnknownHeaders );
if ( _pExtraUnknown == NULL )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
memcpy( _pExtraUnknown,
pRequestToClone->Headers.pUnknownHeaders,
cUnknownHeaders * sizeof( HTTP_UNKNOWN_HEADER ) );
}
_ulHttpRequest.Headers.UnknownHeaderCount = cUnknownHeaders;
_ulHttpRequest.Headers.pUnknownHeaders = _pExtraUnknown;
}
return NO_ERROR;
}
VOID
W3_CLONE_REQUEST::RemoveConditionals(
VOID
)
/*++
Routine Description:
Remove conditional/range headers from request. Used to allow a custom
error URL to work correctly
Arguments:
None
Return Value:
None
--*/
{
HTTP_REQUEST_HEADERS * pHeaders;
pHeaders = &(_pUlHttpRequest->Headers);
//
// Remove Range:
//
pHeaders->pKnownHeaders[ HttpHeaderRange ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderRange ].RawValueLength = 0;
//
// Remove If-Modified-Since:
//
pHeaders->pKnownHeaders[ HttpHeaderIfModifiedSince ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderIfModifiedSince ].RawValueLength = 0;
//
// Remove If-Match:
//
pHeaders->pKnownHeaders[ HttpHeaderIfMatch ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderIfMatch ].RawValueLength = 0;
//
// Remove If-Unmodifed-Since:
//
pHeaders->pKnownHeaders[ HttpHeaderIfUnmodifiedSince ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderIfUnmodifiedSince ].RawValueLength = 0;
//
// Remove If-Range:
//
pHeaders->pKnownHeaders[ HttpHeaderIfRange ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderIfRange ].RawValueLength = 0;
//
// Remove If-None-Match:
//
pHeaders->pKnownHeaders[ HttpHeaderIfNoneMatch ].pRawValue = NULL;
pHeaders->pKnownHeaders[ HttpHeaderIfNoneMatch ].RawValueLength = 0;
}
//static
HRESULT
W3_CLONE_REQUEST::Initialize(
VOID
)
/*++
Routine Description:
Initialize clone request lookaside
Arguments:
None
Return Value:
HRESULT
--*/
{
ALLOC_CACHE_CONFIGURATION acConfig;
DBG_ASSERT( sm_pachCloneRequests == NULL );
//
// Setup allocation lookaside
//
acConfig.nConcurrency = 1;
acConfig.nThreshold = 100;
acConfig.cbSize = sizeof( W3_CLONE_REQUEST );
sm_pachCloneRequests = new ALLOC_CACHE_HANDLER( "W3_CLONE_REQUEST",
&acConfig );
if ( sm_pachCloneRequests == NULL )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
return NO_ERROR;
}
//static
VOID
W3_CLONE_REQUEST::Terminate(
VOID
)
/*++
Routine Description:
Terminate clone request lookaside
Arguments:
None
Return Value:
None
--*/
{
if ( sm_pachCloneRequests != NULL )
{
delete sm_pachCloneRequests;
sm_pachCloneRequests = NULL;
}
}
HRESULT
W3_REQUEST::PreloadEntityBody(
W3_CONTEXT *pW3Context,
BOOL *pfComplete
)
/*++
Routine Description:
Preload entity body for this request if appropriate
Arguments:
cbConfiguredReadAhead - Amount to preload
pfComplete - Set to TRUE if preload is complete
Return Value:
HRESULT
--*/
{
DWORD cbConfiguredReadAhead;
DWORD cbAvailableAlready = 0;
PVOID pbAvailableAlready = NULL;
DWORD cbAmountToPreload = 0;
HRESULT hr;
W3_METADATA *pMetadata = pW3Context->QueryUrlContext()->QueryMetaData();
cbConfiguredReadAhead = pMetadata->QueryEntityReadAhead();
*pfComplete = FALSE;
//
// How much entity do we already have available to us? If it is more
// than the preload size then we are finished
//
pbAvailableAlready = QueryEntityBody();
cbAvailableAlready = QueryAvailableBytes();
if ( cbAvailableAlready >= cbConfiguredReadAhead )
{
*pfComplete = TRUE;
return S_OK;
}
//
// OK. We don't have the configured preload-size number of bytes
// currently available.
//
// Do we know how many bytes of entity are available from UL still.
//
cbAmountToPreload = pW3Context->QueryRemainingEntityFromUl();
if ( cbAmountToPreload == INFINITE )
{
//
// Must be a chunked request. Cap at configured read ahead
//
cbAmountToPreload = cbConfiguredReadAhead;
}
else if ( cbAmountToPreload == 0 )
{
//
// There is no more data available from UL.
//
*pfComplete = TRUE;
return S_OK;
}
else
{
//
// There is still data to be read from UL
//
cbAmountToPreload += cbAvailableAlready;
cbAmountToPreload = min( cbAmountToPreload, cbConfiguredReadAhead );
}
//
// Allocate the buffer
//
if ( !_buffEntityBodyPreload.Resize( cbAmountToPreload ) )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
//
// Copy any data already available to us
//
if ( cbAvailableAlready > 0 &&
pbAvailableAlready != _buffEntityBodyPreload.QueryPtr())
{
DBG_ASSERT( pbAvailableAlready != NULL );
memcpy( _buffEntityBodyPreload.QueryPtr(),
pbAvailableAlready,
cbAvailableAlready );
}
//
// Now read the read from UL asychronously
//
hr = pW3Context->ReceiveEntity( W3_FLAG_ASYNC,
(PBYTE) _buffEntityBodyPreload.QueryPtr() + cbAvailableAlready,
cbAmountToPreload - cbAvailableAlready,
NULL );
if ( FAILED( hr ) )
{
//
// In the chunked case, we do not know how many bytes there were so
// we can hit EOF. However, if the client sent content-length, then
// it is an error
//
if (hr == HRESULT_FROM_WIN32(ERROR_HANDLE_EOF) &&
pW3Context->QueryRemainingEntityFromUl() == INFINITE)
{
pW3Context->SetRemainingEntityFromUl(0);
*pfComplete = TRUE;
return S_OK;
}
return hr;
}
*pfComplete = FALSE;
return S_OK;
}
HRESULT W3_REQUEST::PreloadCompletion(W3_CONTEXT *pW3Context,
DWORD cbRead,
DWORD dwStatus,
BOOL *pfComplete)
{
if ( dwStatus )
{
//
// In the chunked case, we do not know how many bytes there were so
// we can hit EOF. However, if the client sent content-length, then
// it is an error
//
if (dwStatus == ERROR_HANDLE_EOF &&
pW3Context->QueryRemainingEntityFromUl() == INFINITE)
{
pW3Context->SetRemainingEntityFromUl(0);
*pfComplete = TRUE;
return S_OK;
}
return HRESULT_FROM_WIN32(dwStatus);
}
SetNewPreloadedEntityBody(_buffEntityBodyPreload.QueryPtr(),
QueryAvailableBytes() + cbRead);
return PreloadEntityBody(pW3Context, pfComplete);
}