/**********************************************************************/
/** Microsoft Windows NT **/
/** Copyright(c) Microsoft Corp., 1994 **/
/**********************************************************************/
/*
doget.cxx
This module contains the code for the GET and HEAD verb
FILE HISTORY:
Johnl 23-Aug-1994 Created
Phillich 24-Jan-1996 Added support for NCSA map files
Phillich 20-Feb-1996 Added support for byte ranges
*/
#include "w3p.hxx"
//
// Private constants.
//
//
// Computes the square of a number. Used for circle image maps
//
#define SQR(x) ((x) * (x))
//
// Maximum number of vertices in image map polygon
//
#define MAXVERTS 160
//
// Point offset of x and y
//
#define X 0
#define Y 1
//
// Private globals.
//
#define BOUNDARY_STRING_DEFINITION "[lka9uw3et5vxybtp87ghq23dpu7djv84nhls9p]"
// The boundary string is preceded by a line delimiter ( cf RFC 1521 )
// This can be set to "\n" instead of "\r\n" as Navigator 2.0 apparently handles
// all bytes before the "\n" as part of the reply body.
#define BOUNDARY_STRING "\r\n--" BOUNDARY_STRING_DEFINITION "\r\n"
#define LAST_BOUNDARY_STRING "\r\n--" BOUNDARY_STRING_DEFINITION "--\r\n\r\n"
// addition to 1st delimiter of boundary string ( can be "\r" if not included
// in BOUNDARY_STRING )
#define DELIMIT_FIRST ""
#define ADJ_FIRST (2-(sizeof(DELIMIT_FIRST)-1))
#define MMIME_TYPE_1 "Content-Type: "
#define MMIME_TYPE_2 "\r\n"
#define MMIME_TYPE MMIME_TYPE_1 \
"%s" \
MMIME_TYPE_2
char g_achMMimeTypeFmt[] = MMIME_TYPE_1 MMIME_TYPE_2;
#define MMIME_RANGE_1 "Content-Range: bytes "
#define MMIME_RANGE_2 "-"
#define MMIME_RANGE_3 "/"
#define MMIME_RANGE_4 "\r\n\r\n"
#define MMIME_RANGE MMIME_RANGE_1 \
"%u" \
MMIME_RANGE_2 \
"%u" \
MMIME_RANGE_3 \
"%u" \
MMIME_RANGE_4
char g_achMMimeRangeFmt[] = MMIME_RANGE_1
MMIME_RANGE_2
MMIME_RANGE_3
MMIME_RANGE_4;
#define MIN_ADDL_BUF_HDR_SIZE_CACHED (sizeof("Date: ") - 1 + \
sizeof("Mon, 00 Jan 0000 00:00:00 GMT\r\n") - 1 +\
MAX_SIZE_HTTP_INFO)
#define MIN_ADDL_BUF_HDR_SIZE (sizeof("Content-Type: \r\n") - 1 + \
sizeof("Accept-Ranges: bytes\r\n") - 1 + \
sizeof("Last-Modified: ") - 1 +\
sizeof("Mon, 00 Jan 0000 00:00:00 GMT\r\n") - 1 +\
sizeof("ETag: W/\r\n") - 1 + \
MAX_ETAG_BUFFER_LENGTH + \
sizeof("Content-Length: 4294967295\r\n\r\n") - 1)
#define RANGE_ADDL_BUF_HDR_SIZE (sizeof("Content-Type: multipart/x-byteranges; boundary=")\
- 1 + sizeof(BOUNDARY_STRING) - 1 + \
sizeof("Date: ") - 1 + \
sizeof("Mon, 00 Jan 0000 00:00:00 GMT\r\n") - 1 +\
sizeof("Accept-Ranges: bytes\r\n") - 1 + \
sizeof("Last-Modified: ") - 1 +\
sizeof("Mon, 00 Jan 0000 00:00:00 GMT\r\n") - 1 +\
sizeof("ETag: W/\r\n") - 1 + \
MAX_ETAG_BUFFER_LENGTH + \
sizeof("Content-Length: 4294967295\r\n\r\n") - 1)
//
// Private prototypes.
//
BOOL SearchMapFile( LPTS_OPEN_FILE_INFO gFile,
CHAR * pchFile,
TSVC_CACHE * pTsvcCache,
HANDLE hToken,
INT x,
INT y,
STR * pstrURL,
BOOL * pfFound,
BOOL fmayCacheAccessToken );
int pointinpoly(int x, int y, double pgon[MAXVERTS][2]);
INT GetNumber( CHAR * * ppch );
DWORD NbDigit( DWORD dw );
//
// Public functions.
//
//
// Private functions.
//
// Forward references.
extern BOOL DisposeOpenURIFileInfo(IN PVOID pvOldBlock);
DWORD NbDigit( DWORD dw )
{
if ( dw < 10 )
{
return 1;
}
else if ( dw < 100 )
{
return 2;
}
else if ( dw < 1000 )
{
return 3;
}
else if ( dw < 10000 )
{
return 4;
}
else if ( dw < 100000 )
{
return 5;
}
else if ( dw < 1000000 )
{
return 6;
}
DWORD cD = 7;
for ( dw /= 10000000 ; dw ; ++cD )
{
dw /= 10;
}
return cD;
}
LPSYSTEMTIME
MinSystemTime(
LPSYSTEMTIME Now,
LPSYSTEMTIME Other
)
/*++
Routine Descriptions:
Compare to systemtime dates, and return a pointer to the earlier one.
Arguments:
Now - The current date.
Other - Other date to compare.
Return Value:
Pointer to the earlier of Now and Other.
--*/
{
if (Now->wYear > Other->wYear)
{
return Other;
}
else
{
if (Now->wYear == Other->wYear)
{
if (Now->wMonth > Other->wMonth)
{
return Other;
}
else
{
if (Now->wMonth == Other->wMonth)
{
if (Now->wDay > Other->wDay)
{
return Other;
}
else
{
if (Now->wDay == Other->wDay)
{
if (Now->wHour > Other->wHour)
{
return Other;
}
else
{
if (Now->wHour == Other->wHour)
{
if (Now->wMinute > Other->wMinute)
{
return Other;
}
else
{
if (Now->wMinute == Other->wMinute)
{
if (Now->wSecond > Other->wSecond)
{
return Other;
}
else
{
if (Now->wSecond == Other->wSecond)
{
if (Now->wMilliseconds >= Other->wMilliseconds)
{
return Other;
}
else
{
return Now;
}
}
else
{
return Now;
}
}
}
else
{
return Now;
}
}
}
else
{
return Now;
}
}
}
else
{
return Now;
}
}
}
else
{
return Now;
}
}
}
else
{
return Now;
}
}
}
BOOL
HTTP_REQUEST::DoTraceCk(
BOOL * pfFinished
)
/*++
Routine Description:
Handle a TRACECK request ( used by WolfPack as non-logged TRACE request )
Basically echo the client request as a message body
Arguments:
None
Return Value:
TRUE if success, else FALSE
--*/
{
return DoTrace( pfFinished );
}
BOOL
HTTP_REQUEST::DoTrace(
BOOL * pfFinished
)
/*++
Routine Description:
Handle a TRACE request ( cf HTTP 1.1 spec )
Basically echo the client request as a message body
Arguments:
None
Return Value:
TRUE if success, else FALSE
--*/
{
BUFFER buHeader;
BOOL fHandled = FALSE;
LPSTR pszResp;
LPSTR pszTail;
UINT cHeaderSize;
UINT cMsgSize;
DWORD dwWrt;
DWORD cbContentLength;
//
// build response header
//
if ( !buHeader.Resize( MIN_BUFFER_SIZE_FOR_HEADERS ) )
{
return FALSE;
}
if ( !BuildBaseResponseHeader( &buHeader,
&fHandled,
NULL,
0 ))
{
return FALSE;
}
if ( fHandled )
{
return TRUE;
}
cHeaderSize = strlen( (PSTR)buHeader.QueryPtr() );
if (!buHeader.Resize(cHeaderSize + sizeof("Content-Type: message/http\r\n")
- 1 + sizeof("Content-Length: 4294967295\r\n\r\n") - 1))
{
return FALSE;
}
pszResp = (PSTR) buHeader.QueryPtr();
pszTail = pszResp + cHeaderSize;
cMsgSize = _cbClientRequest + _cbContentLength;
APPEND_STRING( pszTail, "Content-Type: message/http\r\n" );
pszTail += wsprintf( pszTail,
"Content-Length: %lu\r\n\r\n",
cMsgSize );
SetState( HTR_DONE, HT_OK, NO_ERROR );
//
// send response header
//
if ( !SendHeader( (CHAR *) buHeader.QueryPtr(),
(DWORD) (pszTail - (PSTR)buHeader.QueryPtr()),
IO_FLAG_SYNC,
pfFinished ))
{
return FALSE;
}
if ( *pfFinished )
return TRUE;
//
// send echo of request headers
// NOTE : we're using the original client buffer because a filter may have
// modified the server response buffer
//
cbContentLength = _cbContentLength;
if (! WriteFile( (PSTR) _bufClientRequest.QueryPtr(),
_cbClientRequest,
&dwWrt,
cbContentLength ? IO_FLAG_SYNC : IO_FLAG_ASYNC ) )
{
return FALSE;
}
//
// send echo of request message body
//
if ( cbContentLength &&
!WriteFile( (PSTR)_bufClientRequest.QueryPtr()
+ _cbClientRequest,
cbContentLength,
NULL,
IO_FLAG_ASYNC ) )
{
return FALSE;
}
return TRUE;
}
/*******************************************************************
NAME: HTTP_REQUEST::DoGet
SYNOPSIS: Transmits a the specified file or directory in response
to a Get or Head request
RETURNS: TRUE if successful, FALSE on error
FALSE should be returned for fatal errors (memory etc),
a server error response will be sent with error text from
GetLastError()
For other errors (access denied, path not found etc)
disconnect with status should be called and TRUE should be
returned.
If no further processing is needed (and the caller needs to
setup for the next request), set *pfFinished to TRUE
NOTES: The file handle gets closed during destruction
We never retrieve a hidden file or directory. We will process
hidden map files however.
HISTORY:
Johnl 29-Aug-1994 Created
********************************************************************/
BOOL
HTTP_REQUEST::DoGet(
BOOL * pfFinished
)
{
BOOL fHandled = FALSE;
DWORD cbSizeLow;
DWORD cbSizeHigh;
BOOL fHidden;
BOOL fMatches;
DWORD dwMask;
BOOL fSendFile = (QueryVerb() == HTV_GET);
PW3_SERVER_INSTANCE pInstance = QueryW3Instance();
DWORD err;
//
// Open the file (or directory)
//
IF_DEBUG( REQUEST )
{
DBGPRINTF((DBG_CONTEXT,
"SendFileOrDir: Opening %s\n",
_strPhysicalPath.QueryStr()));
}
if ( !IS_ACCESS_ALLOWED(READ) && !_fPossibleDefaultExecute )
{
DBGPRINTF((DBG_CONTEXT,
"ACCESS_DENIED. No Read Permission for URL %s (Physical Path: %s)\n",
_strURL.QueryStr(),
_strPhysicalPath.QueryStr()));
SetState( HTR_DONE, HT_FORBIDDEN, ERROR_ACCESS_DENIED );
Disconnect( HT_FORBIDDEN,
IDS_READ_ACCESS_DENIED,
FALSE,
pfFinished );
return TRUE;
}
if (*_strURL.QueryStr() == '*')
{
// Don't allow GETs on the server URL.
SetState( HTR_DONE, HT_BAD_REQUEST, ERROR_INVALID_PARAMETER );
Disconnect( HT_BAD_REQUEST,
NULL,
FALSE,
pfFinished );
return TRUE;
}
if( _strURL.QueryCCH() > MAX_URI_LENGTH )
{
SetState( HTR_DONE, HT_URL_TOO_LONG, ERROR_INSUFFICIENT_BUFFER);
Disconnect( HT_URL_TOO_LONG, IDS_URL_TOO_LONG, FALSE, pfFinished);
return TRUE;
}
if ( _pURIInfo == NULL )
{
if ( !CacheUri( QueryW3Instance(),
&_pURIInfo,
_pMetaData,
_strURL.QueryStr(),
_strURL.QueryCCH(),
&_strPhysicalPath,
&_strUnmappedPhysicalPath ) )
{
return FALSE;
}
}
if ( _pMetaData->QueryDoCache() && !_pMetaData->QueryVrError() )
{
_pGetFile = TsCreateFileFromURI(pInstance->GetTsvcCache(),
_pURIInfo,
QueryImpersonationHandle( FALSE ),
TS_NOT_IMPERSONATED
| ((_fClearTextPass || _fAnonymous) ? 0 :
TS_DONT_CACHE_ACCESS_TOKEN)
| (DoAccessCheckOnUrl()
? 0 : TS_NO_ACCESS_CHECK ),
&err
);
}
else
{
_pGetFile = TsCreateFile( pInstance->GetTsvcCache(),
_strPhysicalPath.QueryStr(),
QueryImpersonationHandle(),
TS_NOT_IMPERSONATED );
if (_pGetFile == NULL) {
err = GetLastError();
}
}
if ( _pGetFile == NULL ) {
IF_DEBUG(ERROR) {
DBGPRINTF((DBG_CONTEXT,
"DoGetHeadAux: Failed to open %s, error %d\n",
_strURL.QueryStr(),
err ));
}
if ( err == ERROR_FILE_NOT_FOUND ||
err == ERROR_PATH_NOT_FOUND ||
err == ERROR_INVALID_NAME )
{
SetState( HTR_DONE, HT_NOT_FOUND, err );
Disconnect( HT_NOT_FOUND, NO_ERROR, FALSE, pfFinished );
return TRUE;
}
if (err == ERROR_INSUFFICIENT_BUFFER)
{
// Really means the file name was too long.
SetState(HTR_DONE, HT_URL_TOO_LONG, err);
Disconnect(HT_URL_TOO_LONG, IDS_URL_TOO_LONG, FALSE, pfFinished );
return TRUE;
}
if ( err == ERROR_ACCESS_DENIED )
{
DBGPRINTF((DBG_CONTEXT,
"ACCESS_DENIED. ACLs restricting acess to URL %s (Physical Path: %s)\n",
_strURL.QueryStr(), _strPhysicalPath.QueryStr()));
DBGPRINTF((DBG_CONTEXT,
"User: %s, AuthorizationType: %s\n",
_strUserName.QueryStr(), _strAuthType.QueryStr()));
SetDeniedFlags( SF_DENIED_RESOURCE );
}
return FALSE;
}
fHidden = ((_pGetFile->QueryAttributes() & FILE_ATTRIBUTE_HIDDEN) != 0);
//
// If the file is a directory, then we may need to do a directory listing
//
if ( _pGetFile->QueryAttributes() & FILE_ATTRIBUTE_DIRECTORY &&
(QueryVerb() == HTV_GET || QueryVerb() == HTV_HEAD) )
{
DWORD dirBrowFlags;
if ( fHidden )
{
SetState( HTR_DONE, HT_NOT_FOUND, ERROR_PATH_NOT_FOUND );
Disconnect( HT_NOT_FOUND, NO_ERROR, FALSE, pfFinished );
return TRUE;
}
//
// If a default file is in the directory and the feature is enabled,
// then return the default file to the user
//
dirBrowFlags = QueryDirBrowseFlags();
if ( dirBrowFlags & DIRBROW_LOADDEFAULT )
{
if ( !CheckDefaultLoad( &_strPhysicalPath, &fHandled, pfFinished ))
{
if ( GetLastError() == ERROR_ACCESS_DENIED )
{
SetDeniedFlags( SF_DENIED_RESOURCE );
}
return FALSE;
}
if ( fHandled || *pfFinished )
{
return TRUE;
}
}
//
// We're doing a directory listing, so send the directory list
// with the response headers. The request is finished at that
// point.
//
SetState( HTR_DONE, HT_OK, NO_ERROR );
if ( dirBrowFlags & DIRBROW_ENABLED )
{
return DoDirList( _strPhysicalPath, QueryRespBuf(), pfFinished );
}
DBGPRINTF((DBG_CONTEXT,
"[DoDirList] Denying request for directory browsing\n"));
SetLogStatus( HT_FORBIDDEN, ERROR_ACCESS_DENIED );
Disconnect( HT_FORBIDDEN, IDS_DIR_LIST_DENIED, FALSE, pfFinished );
return TRUE;
}
//
// We're dealing with a file. Is it an ismap request?
//
if ( _GatewayType == GATEWAY_MAP )
{
BOOL fFound = FALSE;
//
// This may be an ISMAP request so check the parameters and process
// the map file if it is. _hGetFile is a map file if it is.
//
if ( !ProcessISMAP( _pGetFile,
_strPhysicalPath.QueryStr(),
QueryRespBuf(),
&fFound,
&fHandled ))
{
return FALSE;
}
if ( fHandled )
{
return TRUE;
}
if ( fFound )
{
SetState( HTR_DONE, HT_OK, NO_ERROR );
return SendHeader( QueryRespBufPtr(),
(DWORD) -1,
IsKeepConnSet() ?
(IO_FLAG_ASYNC | IO_FLAG_AND_RECV) :
IO_FLAG_ASYNC,
pfFinished );
}
}
if ( fHidden )
{
SetState( HTR_DONE, HT_NOT_FOUND, ERROR_FILE_NOT_FOUND );
Disconnect( HT_NOT_FOUND, NO_ERROR, FALSE, pfFinished );
return TRUE;
}
//
// At this point we know the user wants to retrieve the file
//
// If we're currently using a weak ETag for this file, try to make it
// strong.
if (_pGetFile->WeakETag())
{
_pGetFile->MakeStrongETag();
}
//
// If the client sent an If-* modifier, check it now. Skip if Custom Error
//
if ( _fIfModifier && !_bProcessingCustomError)
{
BOOL bReturn;
if (CheckPreconditions(_pGetFile, pfFinished, &bReturn))
{
return bReturn;
}
}
TCP_REQUIRE( _pGetFile->QuerySize( &cbSizeLow,
&cbSizeHigh ));
// check if range requested
DWORD dwOffset;
DWORD dwSizeToSend;
BOOL fIsNxRange;
_fAcceptRange = pInstance->IsAcceptByteRanges();
if ( _fAcceptRange && !_strRange.IsEmpty() && fSendFile )
{
ProcessRangeRequest( &_strPhysicalPath,
&dwOffset,
&dwSizeToSend,
&fIsNxRange );
//
// Error HT_RANGE_NOT_SATISFIABLE if we saw no valid ranges and we saw an
// unsatisfiable byte range and no If-Range header was sent.
//
if ( (!_fProcessByteRange) && _fUnsatisfiableByteRange &&
( NULL == _HeaderList.FastMapQueryValue(HM_IFR)))
{
CHAR ach[17];
STR * pstrAdditionalHeader = QueryAdditionalRespHeaders();
_itoa( cbSizeLow, ach, 10 );
pstrAdditionalHeader->Append("Content-Range: bytes */");
pstrAdditionalHeader->Append(ach);
pstrAdditionalHeader->Append("\r\n");
SetState( HTR_DONE, HT_RANGE_NOT_SATISFIABLE, NO_ERROR );
Disconnect( HT_RANGE_NOT_SATISFIABLE, NO_ERROR, FALSE, pfFinished );
return TRUE;
}
if ( !BuildResponseHeader( QueryRespBuf(),
&_strPhysicalPath,
_pGetFile,
&fHandled,
NULL,
pfFinished ))
{
return FALSE;
}
}
//
// Build the header response based on file type and client
// requests
//
// It's possible we may not want to send the file (if the client
// doesn't have a needed MIME type for example)
//
else if ( !BuildFileResponseHeader( QueryRespBuf(),
&_strPhysicalPath,
_pGetFile,
&fHandled,
pfFinished ))
{
return FALSE;
}
if ( fHandled )
{
return TRUE;
}
//
// Send the header response and file and cleanup the request
//
if ( !fSendFile )
{
SetState( HTR_DONE, HT_OK, NO_ERROR );
return SendHeader( QueryRespBufPtr(),
QueryRespBufCB(),
(IsKeepConnSet() &&
(_cbBytesReceived == _cbClientRequest)) ?
(IO_FLAG_ASYNC | IO_FLAG_AND_RECV) :
IO_FLAG_ASYNC,
pfFinished );
}
//
// Refuse requests for files greater then four gigs
//
if ( cbSizeHigh )
{
SetState( HTR_DONE, HT_NOT_SUPPORTED, ERROR_NOT_SUPPORTED );
Disconnect( HT_NOT_SUPPORTED, NO_ERROR, FALSE, pfFinished );
return TRUE;
}
//
// Notify filters of the headers we're about to send
//
if ( _Filter.IsNotificationNeeded( SF_NOTIFY_SEND_RESPONSE,
IsSecurePort() ))
{
if ( !_Filter.NotifySendHeaders( QueryRespBufPtr(),
pfFinished,
NULL,
QueryRespBuf() ))
{
return FALSE;
}
if ( *pfFinished )
{
return TRUE;
}
}
if ( _fProcessByteRange )
{
if ( fIsNxRange )
{
SetState( HTR_RANGE, HT_RANGE, NO_ERROR );
}
return SendRange( QueryRespBufCB(), dwOffset, dwSizeToSend, !fIsNxRange );
}
else
{
DWORD dwIOFlags = IO_FLAG_ASYNC;
//
// If a filter needs a send response notification, keep the socket open
// and make sure we receive the TransmitFile completion
// otherwise if this is not a keep-alive connection, tell ATQ to
// disconnect after sending the file
//
if ( _Filter.IsNotificationNeeded( SF_NOTIFY_END_OF_REQUEST,
IsSecurePort() ))
{
dwIOFlags |= IO_FLAG_NO_RECV;
}
else if ( !IsKeepConnSet() )
{
dwIOFlags |= TF_DISCONNECT | TF_REUSE_SOCKET;
}
SetState( HTR_DONE, HT_OK, NO_ERROR );
//
// If we've still got unprocessed data left in the buffer, don't
// allow a receive after the transmit file.
//
if (_cbBytesReceived > _cbClientRequest)
{
dwIOFlags |= IO_FLAG_NO_RECV;
}
if ( !TransmitFile( _pGetFile,
NULL,
0,
cbSizeLow,
dwIOFlags,
QueryRespBufPtr(),
QueryRespBufCB() ,
QueryMetaData()->QueryFooter(),
QueryMetaData()->QueryFooterLength())
)
{
DBGPRINTF((DBG_CONTEXT,
"DoGetHeadAux: TransmitFile failed sending header, error %d\n",
GetLastError() ));
return FALSE;
}
}
return TRUE;
}
DWORD AToDW(
LPSTR *ppRng,
BOOL *pfIsB
)
/*++
Routine Description:
Convert ASCII to DWORD, set flag stating presence
of a numeric value, update pointer to character stream
Returns:
DWORD value converted from ASCII
Arguments:
ppRng PSTR to numeric value, updated on return
pfIsB flag set to TRUE if numeric value present on return
History:
Phillich 08-Feb-1996 Created
--*/
{
LPSTR pRng = *ppRng;
DWORD dwV = 0;
if ( isdigit( (UCHAR)(*pRng) ) )
{
int c;
while ( (c = *pRng) && isdigit( (UCHAR)c ) )
{
dwV = dwV * 10 + c - '0';
++pRng;
}
*pfIsB = TRUE;
*ppRng = pRng;
}
else
{
*pfIsB = FALSE;
}
return dwV;
}
void
HTTP_REQUEST::ProcessRangeRequest(
STR * pstrPath,
DWORD * pdwOffset,
DWORD * pdwSizeToSend,
BOOL * pfIsNxRange )
/*++
Routine Description:
Process a range request, updating member variables
Returns:
VOID
Arguments:
pstrPath File being requested
pdwOffset Range offset
pdwSizeToSend Range size
pfIsNxRange TRUE if valid next range exists
History:
Phillich 08-Feb-1996 Created
--*/
{
DWORD cbSizeLow;
DWORD cbSizeHigh;
FILETIME tm;
BOOL fEntireFile; // Indicates: Skip all Range headers. Send Entire File
BOOL fIsLastRange; // Indicates: No valid range after this.
//
// Check range specified & optional UnlessModifiedSince
//
TCP_REQUIRE( _pGetFile->QueryLastWriteTime( &tm ));
TCP_REQUIRE( _pGetFile->QuerySize( &cbSizeLow,
&cbSizeHigh ));
if ( !_liUnlessModifiedSince.QuadPart ||
*(LONGLONG*)&tm <= _liUnlessModifiedSince.QuadPart )
{
//
// Run through all valid ranges
//
DWORD cRanges = 0;
DWORD dwContentLength = 0;
DWORD dwFirstRangeEnd = 0;
DWORD dwFx = 0;
while ( ScanRange( &_dwRgNxOffset,
&_dwRgNxSizeToSend,
&fEntireFile,
&fIsLastRange ))
{
_fProcessByteRange = TRUE; // At least one range to process
if (fEntireFile)
{
//
// Ignore Range headers. Send Full File.
//
_fUnsatisfiableByteRange = FALSE;
_fProcessByteRange = FALSE;
return;
}
cRanges++;
if ( 1 == cRanges)
{
//
// First valid range. Special processing
//
*pdwOffset = _dwRgNxOffset;
*pdwSizeToSend = _cbMimeMultipart = _dwRgNxSizeToSend;
if (!fIsLastRange)
{
//
// There are more ranges left in the header. However they may or
// may not be syntactically valid or satisfiable.
//
SelectMimeMapping( &_strReturnMimeType,
pstrPath->QueryStr(),
_pMetaData);
dwFirstRangeEnd = _iRangeIdx; // Save this for restoring later.
//
// For each segment in the MIME multipart message the size of the MIME type
// and the number of digits in document total size will be constant,
// so compute them now.
//
dwFx = strlen( _strReturnMimeType.QueryStr() ) + NbDigit( cbSizeLow );
dwContentLength = sizeof(BOUNDARY_STRING) - 1
+ _dwRgNxSizeToSend
+ sizeof(g_achMMimeTypeFmt) - 1
+ sizeof(g_achMMimeRangeFmt) - 1
+ NbDigit( _dwRgNxOffset )
+ NbDigit( _dwRgNxOffset + _dwRgNxSizeToSend - 1 )
+ dwFx;
}
else
{
break;
}
}
else
{
//
// We need to send a multipart response.
//
dwContentLength += sizeof(BOUNDARY_STRING) - 1
+ _dwRgNxSizeToSend
+ sizeof(g_achMMimeTypeFmt) - 1
+ sizeof(g_achMMimeRangeFmt) - 1
+ NbDigit( _dwRgNxOffset )
+ NbDigit( _dwRgNxOffset + _dwRgNxSizeToSend - 1 )
+ dwFx;
}
}
if (cRanges > 1)
{
//
// adjust Content-Length because initial delimiter is part of the header delimiter
//
dwContentLength += sizeof(LAST_BOUNDARY_STRING) - ADJ_FIRST - 1;
_fMimeMultipart = TRUE;
_cbMimeMultipart = dwContentLength;
*pfIsNxRange = TRUE;
//
// Restore the end of Range for subsequent processing
//
_iRangeIdx = dwFirstRangeEnd;
}
else
{
*pfIsNxRange = FALSE;
}
}
}
BOOL
HTTP_REQUEST::ScanRange(
LPDWORD pdwOffset,
LPDWORD pdwSizeToSend,
BOOL *pfEntireFile,
BOOL *pfIsLastRange
)
/*++
Routine Description:
Scan the next range in strRange
Returns:
TRUE if a range was found, else FALSE
Arguments:
pdwOffset update range offset on return
pdwSizeToSend update range size on return
pfEntireFile set to TRUE on return if entire file to be send
pfIsLastRange set to TRUE on return if this is the last range
History:
Phillich 08-Feb-1996 Created
--*/
{
DWORD cbSizeLow;
DWORD cbSizeHigh;
DWORD dwOffset = 0;
DWORD cbSizeToSend = 0;
BOOL fEndOfRange = FALSE;
BOOL fInvalidRange;
BOOL fEntireFile = FALSE;
int c;
TCP_REQUIRE( _pGetFile->QuerySize( &cbSizeLow,
&cbSizeHigh ));
LPSTR pRng = _strRange.QueryStr() + _iRangeIdx;
//
// Rules for processing ranges
//
// If there is any Syntactically Invalid Byte-Range in the request, then the header
// must be ignored. Return code is 200 with entire body (i.e. *pfEntireFile = TRUE).
//
// If the request is Syntactically Valid & any element is satisfiable, the partial
// data for the satisfiable portions should be sent with return code HT_PARTIAL_CONTENT.
//
// If the request is Syntactically Valid & all elements are unsatisfiable and there
// is no If-Range header the return error code is HT_RANGE_NOT_SATISFIABLE (416)
do
{
fInvalidRange = FALSE;
//
// Skip to begining of next range
//
while ( (c=*pRng) && (' '==c) )
{
++pRng;
}
//
// Test for no range
//
if ( *pRng == '\0' )
{
_iRangeIdx = (DWORD)(pRng - _strRange.QueryStr());
*pfEntireFile = fEntireFile;
*pfIsLastRange = TRUE;
return FALSE;
}
// determine Offset & Size to send
DWORD dwB, dwE;
BOOL fIsB, fIsE;
dwB = AToDW( &pRng, &fIsB );
if ( *pRng == '-' )
{
++pRng;
dwE = AToDW( &pRng, &fIsE );
if ( *pRng == '-' || (!fIsB && !fIsE) )
{
//
// Syntactically Invalid Range. Skip RANGE Header
//
fEntireFile = TRUE;
break;
}
if ( fIsB )
{
if ( fIsE )
{
if ( dwB <= dwE )
{
if ( dwE < cbSizeLow )
{
dwOffset = dwB;
cbSizeToSend = dwE - dwB + 1;
}
else if (dwE < (cbSizeLow + QueryMetaData()->QueryFooterLength()) )
{
//
// Asking for part of footer, send entire file.
//
dwOffset = 0;
cbSizeToSend = cbSizeLow;
}
else
{
if ( dwB < cbSizeLow )
{
dwOffset = dwB;
cbSizeToSend = cbSizeLow - dwB;
}
else if (dwB < (cbSizeLow + QueryMetaData()->QueryFooterLength()) )
{
//
// Asking for part of footer,send entire file.
//
dwOffset = 0;
cbSizeToSend = cbSizeLow;
}
else
{
//
// Syntactically Valid but Unsatisfiable range. Zap this range and
// skip to the next range.
//
_fUnsatisfiableByteRange = TRUE;
fInvalidRange = TRUE;
memmove( _strRange.QueryStr()+_iRangeIdx, pRng,
_strRange.QueryCCH() - (size_t)(pRng - _strRange.QueryStr())+1);
pRng = _strRange.QueryStr()+_iRangeIdx;
}
}
}
else
{
//
// E < B : Syntactically Invalid Range. Skip RANGE Header
//
fEntireFile = TRUE;
break;
}
}
else
{
//
// Starting at B until end.
//
DWORD dwFooter = QueryMetaData()->QueryFooterLength() ;
if ( dwB < cbSizeLow + dwFooter)
{
if ( 0 != dwFooter)
{
//
// There's a footer on the file, send the whole thing.
//
dwOffset = 0;
cbSizeToSend = cbSizeLow;
}
else
{
dwOffset = dwB;
cbSizeToSend = cbSizeLow - dwB;
}
}
else
{
//
// Syntactically Valid but Unsatisfiable range. Zap this range and
// skip to the next range.
//
_fUnsatisfiableByteRange = TRUE;
fInvalidRange = TRUE;
memmove( _strRange.QueryStr()+_iRangeIdx, pRng,
_strRange.QueryCCH() - (size_t)(pRng - _strRange.QueryStr())+1);
pRng = _strRange.QueryStr()+_iRangeIdx;
}
}
}
else
{
//
// E last bytes
//
if ( 0 != dwE &&
dwE < cbSizeLow &&
QueryMetaData()->QueryFooterLength() == 0)
{
dwOffset = cbSizeLow - dwE;
cbSizeToSend = dwE;
}
else if ( 0 == dwE )
{
//
// Syntactically Valid but Unsatisfiable range. Zap this range and
// skip to the next range.
//
_fUnsatisfiableByteRange = TRUE;
fInvalidRange = TRUE;
memmove( _strRange.QueryStr()+_iRangeIdx, pRng,
_strRange.QueryCCH() - (size_t)(pRng - _strRange.QueryStr())+1);
pRng = _strRange.QueryStr()+_iRangeIdx;
}
else
{
//
// Return entire file
//
dwOffset = 0;
cbSizeToSend = cbSizeLow;
}
}
}
else
{
//
// Syntactically Invalid Range. Skip RANGE Header
//
fEntireFile = TRUE;
break;
}
//
// Skip to begining of next range
//
while ( (c=*pRng) && c!=',' )
{
++pRng;
}
if ( c == ',' )
{
++pRng;
}
}
while ( fInvalidRange );
_iRangeIdx = (DWORD)(pRng - _strRange.QueryStr());
*pfEntireFile = fEntireFile;
*pfIsLastRange = (*pRng == '\0');
*pdwOffset = dwOffset;
*pdwSizeToSend = cbSizeToSend;
return TRUE;
}
BOOL
HTTP_REQUEST::SendRange(
DWORD dwBufLen,
DWORD dwOffset,
DWORD dwSizeToSend,
BOOL fIsLast
)
/*++
Routine Description:
Send a byte range to the client
Returns:
TRUE if TransmitFile OK, FALSE on error
Arguments:
dwBufLen length of the header already created in pbufResponse
dwOffset range offset in file
dwSizeToSend range size
fIsLast TRUE if this is the last range to send
History:
Phillich 08-Feb-1996 Created
--*/
{
CHAR * pszResp;
CHAR * pszTail;
BUFFER * pbufResponse = QueryRespBuf();
DWORD cbSizeLow;
DWORD cbSizeHigh;
DWORD dwFlags = IO_FLAG_ASYNC | (fIsLast ? 0 : IO_FLAG_NO_RECV);
pszTail = pszResp = (CHAR *) pbufResponse->QueryPtr() + dwBufLen;
if ( _fMimeMultipart )
{
pszTail += wsprintf( pszTail,
MMIME_TYPE,
_strReturnMimeType.QueryStr() );
}
if ( fIsLast )
{
SetState( HTR_DONE, HT_RANGE, NO_ERROR );
if (_cbBytesReceived > _cbClientRequest)
{
dwFlags |= IO_FLAG_NO_RECV;
}
}
TCP_REQUIRE( _pGetFile->QuerySize( &cbSizeLow,
&cbSizeHigh ));
pszTail += wsprintf( pszTail,
MMIME_RANGE,
dwOffset, dwOffset + dwSizeToSend - 1,
cbSizeLow
);
if ( fIsLast && (!IsKeepConnSet() &&
!_Filter.IsNotificationNeeded( SF_NOTIFY_END_OF_REQUEST,
IsSecurePort() )))
{
dwFlags |= TF_DISCONNECT | TF_REUSE_SOCKET;
}
if ( !TransmitFile( _pGetFile,
NULL,
dwOffset,
dwSizeToSend,
dwFlags,
QueryRespBufPtr(),
QueryRespBufCB(),
_fMimeMultipart ? (fIsLast ? LAST_BOUNDARY_STRING : BOUNDARY_STRING) : NULL,
(DWORD)(_fMimeMultipart ? (fIsLast ? sizeof(LAST_BOUNDARY_STRING)-1 : sizeof(BOUNDARY_STRING)-1 ) : 0 ) ) )
{
SetState( HTR_DONE );
return FALSE;
}
return TRUE;
}
/*******************************************************************
NAME: HTTP_REQ_BASE::BuildResponseHeader
SYNOPSIS: Builds a successful response header
ENTRY: pstrResponse - Receives reply headers
pstrPath - Fully qualified path to file, may be NULL
pFile - File information about pstrPath, may be NULL
pfHandled - Does processing need to continue? Will be
set to TRUE if no further processing is needed by
the caller
pstrStatus - Alternate status string to use
RETURNS: TRUE if successful, FALSE on error
NOTES: if pstrPath is NULL, then the base header is put into
pstrResponse without the header termination or file
information
HISTORY:
Johnl 30-Aug-1994 Created
********************************************************************/
BOOL
HTTP_REQUEST::BuildResponseHeader(
BUFFER * pbufResponse,
STR * pstrPath,
TS_OPEN_FILE_INFO * pFile,
BOOL * pfHandled,
STR * pstrStatus,
LPBOOL pfFinished
)
{
FILETIME FileTime;
DWORD cbSizeLow;
SYSTEMTIME SysTime;
SYSTEMTIME SysFileTime;
LPSYSTEMTIME pMinSysTime;
CHAR * pszResp;
CHAR * pszTail;
CHAR ach[64];
DWORD cb;
DWORD dwHdrLength;
if ( pfHandled )
{
*pfHandled = FALSE;
}
//
// HTTP 0.9 clients don't use MIME headers, they just expect the data
//
if ( IsPointNine() )
{
IF_DEBUG( PARSING )
{
DBGPRINTF((DBG_CONTEXT,
"[BuildResponseHeader] Skipping headers, 0.9 client\n"));
}
*((CHAR *)pbufResponse->QueryPtr()) = '\0';
return TRUE;
}
if ( !BuildBaseResponseHeader( pbufResponse,
pfHandled,
pstrStatus,
(HTTPH_SEND_GLOBAL_EXPIRE |
HTTPH_NO_DATE) ))
{
return FALSE;
}
//
// If no file, then don't add the content type headers
//
if ( !pstrPath )
{
return TRUE;
}
//
// "Content-Type: xxx/xxx"
//
// We check to make sure the client can accept the type we
// want to send
//
if ( !::SelectMimeMapping( &_strReturnMimeType,
pstrPath->QueryStr(),
_pMetaData) )
{
return FALSE;
}
dwHdrLength = strlen((CHAR *) pbufResponse->QueryPtr());
if (!pbufResponse->Resize(dwHdrLength + RANGE_ADDL_BUF_HDR_SIZE +
_strReturnMimeType.QueryCB()))
{
return FALSE;
}
pszResp = (CHAR *) pbufResponse->QueryPtr();
// build Date: uses Date/Time cache
dwHdrLength += g_pDateTimeCache->GetFormattedCurrentDateTime(
pszResp + dwHdrLength );
pszTail = pszResp + dwHdrLength;
if ( !DoesClientAccept( _strReturnMimeType.QueryStr() ) )
{
IF_DEBUG( PARSING )
{
DBGPRINTF((DBG_CONTEXT,
"[BuildResponseHeader] Client doesn't accept %s\n",
_strReturnMimeType.QueryStr() ));
}
SetState( HTR_DONE, HT_NONE_ACCEPTABLE, NO_ERROR );
Disconnect( HT_NONE_ACCEPTABLE, NO_ERROR, FALSE, pfFinished );
//
// No further processing is needed
//
if ( pfHandled )
{
*pfHandled = TRUE;
}
return TRUE;
}
if ( _fMimeMultipart && _fProcessByteRange )
{
if ( _VersionMajor > 1 || (_VersionMajor == 1 && _VersionMinor > 0) )
{
APPEND_STRING( pszTail, "Content-Type: multipart/byteranges; boundary="
BOUNDARY_STRING_DEFINITION "\r\n" );
}
else
{
APPEND_STRING( pszTail, "Content-Type: multipart/x-byteranges; boundary="
BOUNDARY_STRING_DEFINITION "\r\n" );
}
}
else
{
if ( _fAcceptRange && !_fProcessByteRange )
{
APPEND_STRING( pszTail, "Accept-Ranges: bytes\r\n" );
}
APPEND_STR_HEADER( pszTail, "Content-Type: ", _strReturnMimeType, "\r\n" );
}
if ( !pFile )
{
return TRUE;
}
if ( !QueryNoCache() )
{
//
// "Last-Modified: <GMT time>". Only do this if we're not
// satisfying an If-Range: request.
//
if (!_fProcessByteRange ||
(_HeaderList.FastMapQueryValue(HM_IFR) == NULL) )
{
if ( !pFile->QueryLastWriteTime( &FileTime ) ||
!::FileTimeToSystemTime( &FileTime, &SysFileTime ))
{
return FALSE;
}
IISGetCurrentTimeAsSystemTime(&SysTime);
pMinSysTime = MinSystemTime(&SysTime, &SysFileTime);
if (!::SystemTimeToGMT( *pMinSysTime, ach, sizeof(ach) ))
{
return FALSE;
}
APPEND_PSZ_HEADER( pszTail, "Last-Modified: ", ach, "\r\n" );
}
//
// ETag: <Etag>
//
if (pFile->WeakETag())
{
APPEND_PSZ_HEADER(pszTail, "ETag: W/", pFile->QueryETag(), "\r\n");
} else
{
APPEND_PSZ_HEADER(pszTail, "ETag: ", pFile->QueryETag(), "\r\n");
}
}
//
// "Content-Length: nnnn" and end of headers
//
if ( _fMimeMultipart )
{
if ( _cbMimeMultipart )
{
APPEND_NUMERIC_HEADER( pszTail,
"Content-Length: ",
_cbMimeMultipart,
"\r\n" );
}
//
// first boundary string
//
APPEND_STRING( pszTail, DELIMIT_FIRST BOUNDARY_STRING );
}
else
{
if ( _fProcessByteRange )
{
cbSizeLow = _cbMimeMultipart;
}
else
{
TCP_REQUIRE( pFile->QuerySize( &cbSizeLow ));
cbSizeLow += QueryMetaData()->QueryFooterLength();
}
APPEND_NUMERIC_HEADER_TAILVAR( pszTail,
"Content-Length: ",
cbSizeLow,
(_fProcessByteRange ? "\r\n" : "\r\n\r\n") );
}
IF_DEBUG( REQUEST )
{
DBGPRINTF((DBG_CONTEXT,
"BuildResponseHeader: Built the following header:\n%s",
pszResp ));
}
return TRUE;
}
BOOL
HTTP_REQUEST::BuildFileResponseHeader(
BUFFER * pbufResponse,
STR * pstrPath,
TS_OPEN_FILE_INFO * pFile,
BOOL * pfHandled,
LPBOOL pfFinished
)
/*++
Routine Description:
Builds a successful response header for a file request
without byte ranges.
Returns:
TRUE if successful, FALSE on error
Arguments:
pstrResponse - Receives reply headers
pstrPath - Fully qualified path to file, may be NULL
pFile - File information about pstrPath, may be NULL
pfHandled - Does processing need to continue? Will be
set to TRUE if no further processing is needed by
the caller
History:
Phillich 26-Feb-1996 Created
--*/
{
FILETIME FileTime;
DWORD cbSizeLow;
SYSTEMTIME SysTime;
SYSTEMTIME SysFileTime;
LPSYSTEMTIME pMinSysTime;
CHAR * pszResp;
CHAR * pszTail;
CHAR * pszVariant;
CHAR ach[64];
int cMod;
DWORD dwCurrentHeaderLength;
if ( pfHandled )
{
*pfHandled = FALSE;
}
//
// HTTP 0.9 clients don't use MIME headers, they just expect the data
//
if ( IsPointNine() )
{
IF_DEBUG( PARSING )
{
DBGPRINTF((DBG_CONTEXT,
"[BuildResponseHeader] Skipping headers, 0.9 client\n"));
}
*((CHAR *)pbufResponse->QueryPtr()) = '\0';
return TRUE;
}
if ( !BuildBaseResponseHeader( pbufResponse,
pfHandled,
NULL,
HTTPH_SEND_GLOBAL_EXPIRE
|HTTPH_NO_DATE ))
{
return FALSE;
}
//
// Make sure that we have enough room left in the buffer. Note
// that right here we only account for enough space for the Date:
// header and the max. amount of cached info. If there is more
// uncached info that may be inserted here, make sure to change the
// MIN_ADDL_BUF_HDR_SIZE_CACHED define above.
//
dwCurrentHeaderLength = strlen((CHAR *) pbufResponse->QueryPtr());
if (!pbufResponse->Resize(dwCurrentHeaderLength +
MIN_ADDL_BUF_HDR_SIZE_CACHED) )
{
return FALSE;
}
pszResp = (CHAR *) pbufResponse->QueryPtr();
// build Date: uses Date/Time cache
dwCurrentHeaderLength += g_pDateTimeCache->GetFormattedCurrentDateTime(
pszResp + dwCurrentHeaderLength );
pszTail = pszResp + dwCurrentHeaderLength;
if ( !QueryNoCache() && pFile->RetrieveHttpInfo( pszTail, &cMod ) )
{
// 1st line is Content-Type:, check client accepts it
PSTR pDelim = strchr( pszTail, '\r' );
if ( pDelim )
{
*pDelim = '\0';
}
if ( !DoesClientAccept( pszTail + sizeof( "Content-Type: " ) - sizeof(CHAR) ) )
{
goto no_match_type;
}
if ( pDelim )
{
*pDelim = '\r';
}
return TRUE;
}
//
// "Content-Type: xxx/xxx"
//
// We check to make sure the client can accept the type we
// want to send
//
if ( !::SelectMimeMapping( &_strReturnMimeType,
pstrPath->QueryStr(),
_pMetaData) )
{
return FALSE;
}
if (!pbufResponse->Resize(dwCurrentHeaderLength +
_strReturnMimeType.QueryCB() +
MIN_ADDL_BUF_HDR_SIZE))
{
return FALSE;
}
pszResp = (CHAR *) pbufResponse->QueryPtr();
pszTail = pszResp + dwCurrentHeaderLength;
pszVariant = pszTail;
if ( !DoesClientAccept( _strReturnMimeType.QueryStr() ) )
{
no_match_type:
IF_DEBUG( PARSING )
{
DBGPRINTF((DBG_CONTEXT,
"[BuildResponseHeader] Client doesn't accept %s\n",
_strReturnMimeType.QueryStr() ));
}
SetState( HTR_DONE, HT_NONE_ACCEPTABLE, NO_ERROR );
Disconnect( HT_NONE_ACCEPTABLE, NO_ERROR, FALSE, pfFinished );
//
// No further processing is needed
//
if ( pfHandled )
{
*pfHandled = TRUE;
}
return TRUE;
}
//
// Content-Type: MUST be the 1st header, or we get messed up when
// we use the cached headers and try to pass the mime type to
// DoesClientAccept().
//
APPEND_STR_HEADER( pszTail, "Content-Type: ", _strReturnMimeType, "\r\n" );
if ( _fAcceptRange )
{
APPEND_STRING( pszTail, "Accept-Ranges: bytes\r\n" );
}
if ( !QueryNoCache() )
{
//
// "Last-Modified: <GMT time>"
//
if ( !pFile->QueryLastWriteTime( &FileTime ) ||
!::FileTimeToSystemTime( &FileTime, &SysFileTime ))
{
return FALSE;
}
IISGetCurrentTimeAsSystemTime(&SysTime);
pMinSysTime = MinSystemTime(&SysTime, &SysFileTime);
if (!::SystemTimeToGMT( *pMinSysTime, ach, sizeof(ach) ))
{
return FALSE;
}
APPEND_PSZ_HEADER( pszTail, "Last-Modified: ", ach, "\r\n" );
//
// ETag: <Etag>
//
if (pFile->WeakETag())
{
APPEND_PSZ_HEADER(pszTail, "ETag: W/", pFile->QueryETag(), "\r\n");
} else
{
APPEND_PSZ_HEADER(pszTail, "ETag: ", pFile->QueryETag(), "\r\n");
}
}
//
// "Content-Length: nnnn" and end of headers
//
TCP_REQUIRE( pFile->QuerySize( &cbSizeLow ));
cbSizeLow += QueryMetaData()->QueryFooterLength();
APPEND_NUMERIC_HEADER( pszTail,
"Content-Length: ",
cbSizeLow,
"\r\n\r\n" );
if ( !QueryNoCache() )
{
pFile->SetHttpInfo( pszVariant, DIFF(pszTail - pszVariant) );
}
IF_DEBUG( REQUEST )
{
DBGPRINTF((DBG_CONTEXT,
"BuildResponseHeader: Built the following header:\n%s",
pszResp ));
}
return TRUE;
}
/*******************************************************************
NAME: HTTP_REQUEST::ProcessISMAP
SYNOPSIS: Checks of the URL and passed parameters specify an
image mapping file
RETURNS: TRUE if successful, FALSE on error
NOTES: gFile - Opened file Info
pchFile - Fully qualified name of file
pstrResp - Response to send if *pfHandled is FALSE
pfFound - TRUE if a mapping was found
pfHandled - Set to TRUE if no further processing is needed,
FALSE if pstrResp should be sent to the client
HISTORY:
Johnl 17-Sep-1994 Created
********************************************************************/
BOOL HTTP_REQUEST::ProcessISMAP( LPTS_OPEN_FILE_INFO gFile,
CHAR * pchFile,
BUFFER * pbufResp,
BOOL * pfFound,
BOOL * pfHandled )
{
INT x, y;
TCHAR * pch = _strURLParams.QueryStr();
PW3_SERVER_INSTANCE pInstance = QueryW3Instance();
STACK_STR( strURL, MAX_PATH);
*pfHandled = FALSE;
*pfFound = FALSE;
//
// Get the x and y cooridinates of the mouse click on the image
//
x = _tcstoul( pch,
NULL,
10 );
//
// Move past x and any intervening delimiters
//
while ( isdigit( (UCHAR)(*pch) ))
pch++;
while ( *pch && !isdigit( (UCHAR)(*pch) ))
pch++;
y = _tcstoul( pch,
NULL,
10 );
if ( !ImpersonateUser() )
{
return FALSE;
}
if ( !SearchMapFile( gFile,
pchFile,
&pInstance->GetTsvcCache(),
QueryImpersonationHandle(),
x,
y,
&strURL,
pfFound,
IsAnonymous()||IsClearTextPassword() ))
{
RevertUser();
return FALSE;
}
RevertUser();
if ( !*pfFound )
{
if ( (pch = (TCHAR * ) _HeaderList.FastMapQueryValue( HM_REF )) )
{
#if 0
// handle relative URL ( i.e. not fully qualified
// and not specifying an absolute path ).
// disabled for now.
PSTR pColon = strchr( pch, ':' );
PSTR pDelim = strchr( pch, '/' );
BOOL fValid;
// check for relative URL
if ( *pch != '/' && (pColon == NULL || pDelim < pColon) )
{
strURL.Copy( _strURL.QueryStr() );
PSTR pL = strURL.QueryStr();
// look for last '/'
int iL = strlen( pL );
while ( iL && pL[iL-1] != '/' )
--iL;
// combine request URL & relative referer URL
strURL.Resize( iL + strlen( pch ) + 1 );
strcpy( strURL.QueryStr() + iL, pch );
fValid = TRUE;
CanonURL( strURL.QueryStr());
CanonURL.SetLen( strlen( strURL.QueryStr() ));
}
else
#endif
strURL.Copy( (TCHAR *) pch );
}
else
return TRUE;
}
CloseGetFile();
//
// If the found URL starts with a forward slash ("/foo/bar/doc.htm")
// and it doesn't contain a bookmark ('#')
// then the URL is local and we build a fully qualified URL to send
// back to the client.
// we assume it's a fully qualified URL ("http://foo/bar/doc.htm")
// and send the client a redirection notice to the mapped URL
//
if ( *strURL.QueryStr() == TEXT('/') )
{
#if 0
// disabled :
// we now always send a redirect
TCHAR * pch = strURL.QueryStr();
//
// Make sure there's no bookmark
//
if ( !(strchr( strURL.QueryStr(), '#' )) )
{
//
// Call OnURL to reparse the URL and set the members then
// call the verb again
//
if ( !ReprocessURL( pch ) )
{
return FALSE;
}
*pfHandled = TRUE;
}
else
#endif
{
CHAR achPort[32];
STACK_STR( strOldURL, MAX_PATH );
//
// fully qualify the URL and send a
// redirect. Some browsers (emosaic) don't like doc relative
// URLs with bookmarks
//
if ( !strOldURL.Copy( strURL ) ||
!strURL.Resize( strOldURL.QueryCB() + 128 ))
{
return FALSE;
}
//
// NOTE: We fully qualify the URL with the protocol (http or
// https) based on the port this request came in on. This means
// you cannot have a partial URL with a bookmark (which is how
// we got here) go from a secure part of the server to a
// nonsecure part of the server.
//
strURL.Copy( (IsSecurePort() ? "https://" : "http://" ));
strURL.Append( QueryHostAddr() );
if ( IsSecurePort() ? (INT) QueryClientConn()->QueryPort()
!= HTTP_SSL_PORT
: (INT) QueryClientConn()->QueryPort() != 80 )
{
strURL.Append( ":" );
_itoa( (INT) QueryClientConn()->QueryPort(), achPort, 10 );
strURL.Append( achPort );
}
strURL.Append( strOldURL );
if ( !BuildURLMovedResponse( pbufResp, &strURL, HT_REDIRECT, FALSE ))
return FALSE;
}
}
else
{
if ( !BuildURLMovedResponse( pbufResp, &strURL, HT_REDIRECT, FALSE ))
return FALSE;
}
*pfFound = TRUE;
return TRUE;
}
/*******************************************************************
NAME: EncodeStringToHTML
SYNOPSIS: Enode string in HTML format
ENTRY: szSrc - Source string to be encoded, in system codepage
szDest - Space to output HTML (in system codepage)
cbDest - Size of space in szDest (number of bytes)
RETURNS: number of bytes required for HTML text
NOTES: If cbDest is less than target HTML, then we fit
as much characters as possible into szDest. But the
return value remains the same and is greater than
cbDest. szDest is not zero terminated in this case.
HISTORY:
markzh 17-Jan-2002 Created
********************************************************************/
UINT EncodeStringToHTML(CHAR *szSrc, CHAR *szDest, UINT cbDest)
{
CHAR *pSrc = szSrc;
CHAR *pDest = szDest;
BOOL isSecondByte=FALSE;
do {
CHAR *szAppend = pSrc;
UINT cbAppend = 1;
// We may be running on DBCS. Ideally we should encode them to &#nnnnn
// but we dont want that many code here
if (isSecondByte)
{
isSecondByte = FALSE;
}
else if (IsDBCSLeadByte(*pSrc))
{
isSecondByte = TRUE;
}
else switch (*pSrc)
{
#define SetAppend(s) (szAppend=(s), cbAppend=sizeof(s)-1)
case '&': SetAppend("&");
break;
case '"': SetAppend(""");
break;
case '<': SetAppend("<");
break;
case '>': SetAppend(">");
break;
default:
break;
#undef SetAppend
}
if (pDest - szDest + cbAppend <= cbDest)
{
memcpy(pDest, szAppend, cbAppend);
}
pDest += cbAppend;
}while (*pSrc++);
return DIFF(pDest - szDest);
}
/*******************************************************************
NAME: HTTP_REQ_BASE::BuildURLMovedResponse
SYNOPSIS: Builds a full request indicating an object has moved to
the location specified by URL
ENTRY: pbufResp - String to receive built response
pstrURL - New location of object, gets escaped
dwServerCode - Server response code
(either HT_REDIRECT or HT_MOVED)
fIncludeParams - TRUE to include params from original request
in redirect
RETURNS: TRUE if successful, FALSE on error
NOTES: This routine doesn't support sending a Unicode doc moved
message
HISTORY:
Johnl 17-Sep-1994 Created
********************************************************************/
BOOL HTTP_REQ_BASE::BuildURLMovedResponse( BUFFER * pbufResp,
STR * pstrURL,
DWORD dwServerCode,
BOOL fIncludeParams )
{
STACK_STR(strMovedMessage, 512);
STR* pstrMovedMessage;
STACK_STR(strUrlWithParams, 512);
UINT cb;
UINT cbA;
CHAR * pszTail;
CHAR * pszResp;
DWORD cbURL;
BOOL fDone;
BOOL bHaveCustom;
DWORD dwMsgSize;
DWORD dwRedirHeaderSize;
DBG_ASSERT(dwServerCode == HT_REDIRECT || dwServerCode == HT_MOVED);
if (CheckCustomError(&strMovedMessage, HT_REDIRECT, 0, &fDone, &dwMsgSize, FALSE))
{
DBG_ASSERT(!fDone);
strMovedMessage.SetLen(strlen((CHAR *)strMovedMessage.QueryPtr()));
bHaveCustom = TRUE;
pstrMovedMessage = &strMovedMessage;
}
else
{
pstrMovedMessage = g_pstrMovedMessage;
DBG_ASSERT( pstrMovedMessage->QueryCB() );
bHaveCustom = FALSE;
}
//
// Make sure the response buffer is large enough
//
#define CB_FIXED_RESP 500
//
// Technically we should escape more characters then just the spaces but
// that would probably break some number of client apps
//
if ( !pstrURL->EscapeSpaces() )
{
return FALSE;
}
if ( fIncludeParams &&
!_strURLParams.IsEmpty() )
{
if ( !strUrlWithParams.Copy( *pstrURL ) ||
!strUrlWithParams.Append( "?" ) ||
!strUrlWithParams.Append( _strURLParams ) )
{
return FALSE;
}
pstrURL = &strUrlWithParams;
}
cbURL = pstrURL->QueryCB();
// WinSE 24915
// Enode string in HTML format
STACK_STR(strUrlInHTML, 512);
UINT cbUrlInHTML;
cbUrlInHTML = EncodeStringToHTML(pstrURL->QueryStr(),
strUrlInHTML.QueryStr(),
strUrlInHTML.QuerySize());
if ( cbUrlInHTML > strUrlInHTML.QuerySize() )
{
if (! strUrlInHTML.Resize(cbUrlInHTML))
{
return FALSE;
}
cbUrlInHTML = EncodeStringToHTML(pstrURL->QueryStr(),
strUrlInHTML.QueryStr(),
strUrlInHTML.QuerySize());
}
if ( (cbUrlInHTML + cbURL + CB_FIXED_RESP) > pbufResp->QuerySize() )
{
if ( !pbufResp->Resize( cbUrlInHTML + cbURL + CB_FIXED_RESP ))
return FALSE;
}
//
// "HTTP/<ver> 302 Redirect" or
// "HTTP/<ver> 301 Redirect"
//
if ( !BuildStatusLine( pbufResp,
dwServerCode,
NO_ERROR ))
{
return FALSE;
}
//
// Set the status to log here
//
SetLogStatus( dwServerCode, NO_ERROR );
pszResp = (CHAR *) pbufResp->QueryPtr();
pszTail = pszResp + strlen( pszResp );
//
// "Location: <URL>"
//
APPEND_STR_HEADER( pszTail, "Location: ", *pstrURL, "\r\n" );
//
// "Server: <Server>/<version>
//
APPEND_VER_STR( pszTail );
//
// Content-Type, it's OK to assume all clients accept text/html
//
if (!bHaveCustom)
{
APPEND_STRING( pszTail, "Content-Type: text/html\r\n" );
}
//
// Calculate the bytes in the body of the message for Content-Length
//
// cbUrlInHTML is total bytes in the string (-1 for the null)
//
// pstrMovedMessage->QueryCB does not include the null, but
// it may be a format string that will contain the url, so -2 for %s
//
// Wait to subtract the %s away, though since pstrMovedMessage
// my be custom error file data - This code is so @#$#%@%$.
// Of course none of these calculations are right if %s is actually
// in the custom error file, and if it isn't then the error is
// useless. Whoever wrote this deserves a beating.
//
cb = ( cbUrlInHTML - 1 ) +
( pstrMovedMessage->QueryCB() );
if (!bHaveCustom)
{
//
// Now compensate for %s. It is okay that cb is a little too
// big in this case dwMsgSize will be what determines the value
// of the content length header.
//
dwMsgSize = cb - 2;
}
if ( IsKeepConnSet() )
{
if (!IsOneOne())
{
APPEND_STRING( pszTail, "Connection: keep-alive\r\n" );
}
} else
{
if (IsOneOne())
{
APPEND_STRING( pszTail, "Connection: close\r\n" );
}
}
//
// If we have any redirection specific headers, copy them in now.
//
dwRedirHeaderSize = QueryMetaData()->QueryRedirectHeaders()->QueryCCH();
if (dwRedirHeaderSize != 0)
{
if (!pbufResp->Resize(DIFF(pszTail - pszResp) + dwRedirHeaderSize ))
{
return FALSE;
}
pszTail = (CHAR *) pbufResp->QueryPtr() + (pszTail - pszResp);
pszResp = (CHAR *) pbufResp->QueryPtr();
memcpy(pszTail, QueryMetaData()->QueryRedirectHeaders()->QueryStr(),
dwRedirHeaderSize);
pszTail += dwRedirHeaderSize;
}
//
// Append any headers specified by filters
//
if ( cbA = QueryAdditionalRespHeaders()->QueryCB() )
{
if (!pbufResp->Resize(DIFF(pszTail - pszResp) + cbA ))
{
return FALSE;
}
pszTail = (CHAR *) pbufResp->QueryPtr() + (pszTail - pszResp);
pszResp = (CHAR *) pbufResp->QueryPtr();
memcpy( pszTail, QueryAdditionalRespHeaders()->QueryStr(), cbA );
pszTail += cbA;
}
//
// Figure out the total length to see if we have enough room for the "Content-Length"
// header
//
cb += DIFF(pszTail - pszResp) +
sizeof("Content-Length: ") - 1 +
30 + // [magic #] max length of string containing numeric value of Content-Length
( bHaveCustom ? sizeof("\r\n") - 1 : sizeof("\r\n\r\n") - 1 ) +
sizeof(TCHAR);
if ( !pbufResp->Resize( cb ))
{
return FALSE;
}
if ( pbufResp->QueryPtr() != pszResp )
{
pszTail = (CHAR *) pbufResp->QueryPtr() + (pszTail - pszResp);
pszResp = (CHAR *) pbufResp->QueryPtr();
}
//
// "Content-Length: <length>"
//
APPEND_NUMERIC_HEADER_TAILVAR( pszTail, "Content-Length: ", dwMsgSize, bHaveCustom ? "\r\n" : "\r\n\r\n" );
//
// pstrMovedMessage is something along the lines of "This object can be found at %s" and
// pstrURL is the URL that replaces the %s in pstrMovedMessage, so the max length of the
// actual HTML doc is the sum of the lengths of pstrMovedMessage and pstrURL
//
if (HTV_HEAD != QueryVerb())
{
DWORD cbMaxMsg = pstrMovedMessage->QueryCB() + strUrlInHTML.QueryCB();
if ( !pbufResp->Resize( DIFF(pszTail - pszResp) + cbMaxMsg ) )
{
return FALSE;
}
//
// Watch for pointer shift
//
if ( pbufResp->QueryPtr() != pszResp )
{
pszTail = (CHAR*) pbufResp->QueryPtr() + (pszTail - pszResp);
pszResp = (CHAR *) pbufResp->QueryPtr();
}
//
// Add the short HTML doc indicating the new location of the URL,
// making sure we have enough space for it
// Note we've already added the message body length. Add in the terminator.
//
::sprintf( pszTail,
pstrMovedMessage->QueryStr(),
strUrlInHTML.QueryStr() );
}
return TRUE;
}
/*******************************************************************
NAME: SearchMapFile
SYNOPSIS: Searches the given mapfile for a shape that contains
the passed cooridinates
ENTRY: gFile - Open file Info
pchFile - Fully qualified path to file
pTsvcCache - Cache ID
hToken - Impersonation token
x - x cooridinate
y - y cooridinate
pstrURL - receives URL indicated in the map file
pfFound - Set to TRUE if a mapping was found
fMayCacheAccessToken - TRUE access token may be cached
RETURNS: TRUE if successful, FALSE on error
NOTES: This routine will attempt to cache the file. You must call
this function while impersonating the appropriate user
HISTORY:
Johnl 19-Sep-1994 Created
********************************************************************/
#define SKIPNONWHITE( pch ) while ( *pch && \
!ISWHITEA( *pch )) \
pch++;
#define SKIPWHITE( pch ) while ( ISWHITE( *pch ) || \
*pch == ')' || \
*pch == '(' ) \
pch++;
BOOL SearchMapFile( LPTS_OPEN_FILE_INFO gFile,
CHAR * pchFile,
TSVC_CACHE * pTsvcCache,
HANDLE hToken,
INT x,
INT y,
STR * pstrURL,
BOOL * pfFound,
BOOL fMayCacheAccessToken )
{
DWORD BytesRead;
CHAR * pch;
CACHE_FILE_INFO CacheFileInfo;
CHAR * pchDefault = NULL;
CHAR * pchPoint = NULL;
CHAR * pchStart;
BOOL fRet = TRUE;
DWORD cchUrl;
UINT dis;
UINT bdis = UINT(-1);
STACK_STR( strDefaultURL, MAX_PATH );
*pfFound = FALSE;
//
// Retrieve the '\0' terminated map file
//
if ( !CheckOutCachedFileFromURI( (PVOID)gFile,
pchFile,
pTsvcCache,
hToken,
(BYTE **) &pch,
&BytesRead,
fMayCacheAccessToken,
&CacheFileInfo,
0 )) // no code conversion
{
if ( !CheckOutCachedFile( pchFile,
pTsvcCache,
hToken,
(BYTE **) &pch,
&BytesRead,
fMayCacheAccessToken,
&CacheFileInfo,
0 )) // no code conversion
{
return FALSE;
}
}
//
// Loop through the contents of the buffer and see what we've got
//
BOOL fComment = FALSE;
BOOL fIsNCSA = FALSE;
LPSTR pURL; // valid only if fIsNCSA is TRUE
while ( *pch )
{
fIsNCSA = FALSE;
//
// note: _tolower doesn't check case (tolower does)
//
switch ( (*pch >= 'A' && *pch <= 'Z') ? _tolower( *pch ) : *pch )
{
case '#':
fComment = TRUE;
break;
case '\r':
case '\n':
fComment = FALSE;
break;
//
// Rectangle
//
case 'r':
case 'o':
if ( !fComment &&
(!_strnicmp( "rect", pch, 4 )
// handles oval as a rect, as they are using
// the same specification format. Should do better.
|| !_strnicmp( "oval", pch, 4 )) )
{
INT x1, y1, x2, y2;
SKIPNONWHITE( pch );
pURL = pch;
SKIPWHITE( pch );
if ( !isdigit((UCHAR)(*pch)) && *pch!='(' )
{
fIsNCSA = TRUE;
SKIPNONWHITE( pch );
}
x1 = GetNumber( &pch );
y1 = GetNumber( &pch );
x2 = GetNumber( &pch );
y2 = GetNumber( &pch );
if ( x >= x1 && x < x2 &&
y >= y1 && y < y2 )
{
if ( fIsNCSA )
pch = pURL;
goto Found;
}
//
// Skip the URL
//
if ( !fIsNCSA )
{
SKIPWHITE( pch );
SKIPNONWHITE( pch );
}
continue;
}
break;
//
// Circle
//
case 'c':
if ( !fComment &&
!_strnicmp( "circ", pch, 4 ))
{
INT xCenter, yCenter, xEdge, yEdge;
INT r1, r2;
SKIPNONWHITE( pch );
pURL = pch;
SKIPWHITE( pch );
if ( !isdigit((UCHAR)(*pch)) && *pch!='(' )
{
fIsNCSA = TRUE;
SKIPNONWHITE( pch );
}
//
// Get the center and edge of the circle
//
xCenter = GetNumber( &pch );
yCenter = GetNumber( &pch );
xEdge = GetNumber( &pch );
yEdge = GetNumber( &pch );
//
// If there's a yEdge, then we have the NCSA format, otherwise
// we have the CERN format, which specifies a radius
//
if ( yEdge != -1 )
{
r1 = ((yCenter - yEdge) * (yCenter - yEdge)) +
((xCenter - xEdge) * (xCenter - xEdge));
r2 = ((yCenter - y) * (yCenter - y)) +
((xCenter - x) * (xCenter - x));
if ( r2 <= r1 )
{
if ( fIsNCSA )
pch = pURL;
goto Found;
}
}
else
{
INT radius;
//
// CERN format, third param is the radius
//
radius = xEdge;
if ( SQR( xCenter - x ) + SQR( yCenter - y ) <=
SQR( radius ))
{
if ( fIsNCSA )
pch = pURL;
goto Found;
}
}
//
// Skip the URL
//
if ( !fIsNCSA )
{
SKIPWHITE( pch );
SKIPNONWHITE( pch );
}
continue;
}
break;
//
// Polygon
//
case 'p':
if ( !fComment &&
!_strnicmp( "poly", pch, 4 ))
{
double pgon[MAXVERTS][2];
DWORD i = 0;
CHAR * pchLast;
BOOL fOverflow = FALSE;
SKIPNONWHITE( pch );
pURL = pch;
SKIPWHITE( pch );
if ( !isdigit((UCHAR)(*pch)) && *pch!='(' )
{
fIsNCSA = TRUE;
SKIPNONWHITE( pch );
}
//
// Build the array of points
//
while ( *pch && *pch != '\r' && *pch != '\n' )
{
pgon[i][0] = GetNumber( &pch );
//
// Did we hit the end of the line (and go past the URL)?
//
if ( pgon[i][0] != -1 )
{
pgon[i][1] = GetNumber( &pch );
}
else
{
break;
}
if ( i < MAXVERTS-1 )
{
i++;
}
else
{
fOverflow = TRUE;
}
}
pgon[i][X] = -1;
if ( !fOverflow && pointinpoly( x, y, pgon ))
{
if ( fIsNCSA )
pch = pURL;
goto Found;
}
//
// Skip the URL
//
if ( !fIsNCSA )
{
SKIPWHITE( pch );
SKIPNONWHITE( pch );
}
continue;
}
else if ( !fComment &&
!_strnicmp( "point", pch, 5 ))
{
INT x1,y1;
SKIPNONWHITE( pch );
pURL = pch;
SKIPWHITE( pch );
SKIPNONWHITE( pch );
x1 = GetNumber( &pch );
y1 = GetNumber( &pch );
x1 -= x;
y1 -= y;
dis = x1*x1 + y1*y1;
if ( dis < bdis )
{
pchPoint = pURL;
bdis = dis;
}
}
break;
//
// Default URL
//
case 'd':
if ( !fComment &&
!_strnicmp( "def", pch, 3 ) )
{
//
// Skip "default" (don't skip white space)
//
SKIPNONWHITE( pch );
pchDefault = pch;
//
// Skip URL
//
SKIPWHITE( pch );
SKIPNONWHITE( pch );
continue;
}
break;
}
pch++;
SKIPWHITE( pch );
}
//
// If we didn't find a mapping and a default was specified, use
// the default URL
//
if ( pchPoint )
{
pch = pchPoint;
goto Found;
}
if ( pchDefault )
{
pch = pchDefault;
goto Found;
}
IF_DEBUG( PARSING )
{
DBGPRINTF(( DBG_CONTEXT,
"[SearchMapFile] No mapping found for (%d,%d)\n",
x,
y ));
}
goto Exit;
Found:
//
// pch should point to the white space immediately before the URL
//
SKIPWHITE( pch );
pchStart = pch;
SKIPNONWHITE( pch );
//
// Determine the length of the URL and copy it out
//
cchUrl = DIFF(pch - pchStart);
if ( !pstrURL->Resize( cchUrl + 1 ))
{
fRet = FALSE;
goto Exit;
}
memcpy( pstrURL->QueryStr(),
pchStart,
cchUrl );
pstrURL->SetLen(cchUrl);
if ( !pstrURL->Unescape() )
{
fRet = FALSE;
goto Exit;
}
IF_DEBUG( PARSING )
{
DBGPRINTF((DBG_CONTEXT,
"[SearchMapFile] Mapping for (%d,%d) is %s\n",
x,
y,
pstrURL->QueryStr() ));
}
*pfFound = TRUE;
Exit:
TCP_REQUIRE( CheckInCachedFile( pTsvcCache,
&CacheFileInfo ));
return fRet;
}
int pointinpoly(int point_x, int point_y, double pgon[MAXVERTS][2])
{
int i, numverts, inside_flag, xflag0;
int crossings;
double *p, *stop;
double tx, ty, y;
for (i = 0; pgon[i][X] != -1 && i < MAXVERTS; i++)
;
numverts = i;
crossings = 0;
tx = (double) point_x;
ty = (double) point_y;
y = pgon[numverts - 1][Y];
p = (double *) pgon + 1;
if ((y >= ty) != (*p >= ty))
{
if ((xflag0 = (pgon[numverts - 1][X] >= tx)) == (*(double *) pgon >= tx))
{
if (xflag0)
crossings++;
}
else
{
crossings += (pgon[numverts - 1][X] - (y - ty) *
(*(double *) pgon - pgon[numverts - 1][X]) /
(*p - y)) >= tx;
}
}
stop = pgon[numverts];
for (y = *p, p += 2; p < stop; y = *p, p += 2)
{
if (y >= ty)
{
while ((p < stop) && (*p >= ty))
p += 2;
if (p >= stop)
break;
if ((xflag0 = (*(p - 3) >= tx)) == (*(p - 1) >= tx))
{
if (xflag0)
crossings++;
}
else
{
crossings += (*(p - 3) - (*(p - 2) - ty) *
(*(p - 1) - *(p - 3)) / (*p - *(p - 2))) >= tx;
}
}
else
{
while ((p < stop) && (*p < ty))
p += 2;
if (p >= stop)
break;
if ((xflag0 = (*(p - 3) >= tx)) == (*(p - 1) >= tx))
{
if (xflag0)
crossings++;
}
else
{
crossings += (*(p - 3) - (*(p - 2) - ty) *
(*(p - 1) - *(p - 3)) / (*p - *(p - 2))) >= tx;
}
}
}
inside_flag = crossings & 0x01;
return (inside_flag);
}
/*******************************************************************
NAME: GetNumber
SYNOPSIS: Scans for the beginning of a number and places the
pointer after the found number
ENTRY: ppch - Place to begin. Will be set to character after
the last digit of the found number
RETURNS: Integer value of found number (or -1 if not found)
HISTORY:
Johnl 19-Sep-1994 Created
********************************************************************/
INT GetNumber( CHAR * * ppch )
{
CHAR * pch = *ppch;
INT n;
//
// Make sure we don't get into the URL
//
while ( *pch &&
!isdigit( (UCHAR)(*pch) ) &&
!isalpha( (UCHAR)(*pch) ) &&
*pch != '/' &&
*pch != '\r' &&
*pch != '\n' )
{
pch++;
}
if ( !isdigit( (UCHAR)(*pch) ) )
return -1;
n = atoi( pch );
while ( isdigit( (UCHAR)(*pch) ))
pch++;
*ppch = pch;
return n;
}
BOOL
DisposeOpenURIFileInfo(
IN PVOID pvOldBlock
)
/*++
Routine Description
Close an open URI file information block. This involves closing the
handle if the file information is valid and freeing and associated
structures.
Arguments
pvOldBlock - pointer to the URI file information block.
Returns
TRUE if operation successful.
--*/
{
PW3_URI_INFO pURIInfo;
PVOID pvBlob;
BOOL bSuccess;
pURIInfo = (PW3_URI_INFO ) pvOldBlock;
if (pURIInfo->pszName != NULL) {
LocalFree(pURIInfo->pszName);
}
if (pURIInfo->pszUnmappedName != NULL) {
LocalFree(pURIInfo->pszUnmappedName);
}
if( pURIInfo->pMetaData != NULL ) {
TsFreeMetaData(pURIInfo->pMetaData->QueryCacheInfo() );
}
if ( pURIInfo->pOpenFileInfo != NULL ) {
TsDerefURIFile(pURIInfo->pOpenFileInfo);
}
return( TRUE );
} // DisposeOpenURIFileInfo