mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3282 lines
86 KiB
3282 lines
86 KiB
/**********************************************************************/
|
|
/** 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
|
|
|
|
|
|
|
|
|