/*++
Copyright (c) 1995 Microsoft Corporation
Module Name :
basereq.hxx
Abstract:
This file declares the class for http base request, that is used
by the w3 information service.
Author:
Murali R. Krishnan ( MuraliK ) 16-Oct-1995
Environment:
Win32 -- User Mode
Project:
W3 Server DLL
Revision History:
Murali R. Krishnan (MuraliK) 22-Jan-1996
make impersonation/revert function virtual
--*/
# ifndef _BASEREQ_HXX_
# define _BASEREQ_HXX_
/************************************************************
* Include Headers
************************************************************/
# include "string.hxx"
# include "httphdr.hxx"
# include "tssec.hxx"
# include "w3type.hxx"
# include "filter.hxx"
# include "redirect.hxx"
extern BOOL ReadEntireFile(
CHAR *pszFileName,
TSVC_CACHE &Cache,
HANDLE User,
BUFFER *pBuf,
DWORD *pdwBytesRead
);
// Forward References
class CLIENT_CONN;
class HTTP_FILTER;
class HTTP_FILTER_DLL;
class W3_SERVER_INSTANCE;
/************************************************************
* Symbolic Constants
************************************************************/
//
// HTTP Server response status codes
//
#define HT_OK 200
#define HT_CREATED 201
//#define HT_ACCEPTED 202
//#define HT_PARTIAL 203
#define HT_NO_CONTENT 204
#define HT_RANGE 206
//#define HT_MULT_CHOICE 300
#define HT_MOVED 301
#define HT_REDIRECT 302
#define HT_REDIRECT_METHOD 303
#define HT_NOT_MODIFIED 304
#define HT_BAD_REQUEST 400
#define HT_DENIED 401
//#define HT_PAYMENT_REQ 402
#define HT_FORBIDDEN 403
#define HT_NOT_FOUND 404
#define HT_METHOD_NOT_ALLOWED 405
#define HT_NONE_ACCEPTABLE 406
#define HT_PROXY_AUTH_REQ 407
//#define HT_REQUEST_TIMEOUT 408
//#define HT_CONFLICT 409
//#define HT_GONE 410
#define HT_LENGTH_REQUIRED 411
#define HT_PRECOND_FAILED 412
#define HT_URL_TOO_LONG 414
#define HT_RANGE_NOT_SATISFIABLE 416
#define HT_SERVER_ERROR 500
#define HT_NOT_SUPPORTED 501
#define HT_BAD_GATEWAY 502
#define HT_SVC_UNAVAILABLE 503
#define HT_GATEWAY_TIMOUT 504
//
// Special invalid HTTP response code used to indicate a request should not
// be logged
//
#define HT_DONT_LOG 000
//
// The versioning string for responses
//
#define HTTP_VERSION_STR PSZ_HTTP_VERSION_STR
//
// Flags for network communications over this request
//
#define IO_FLAG_ASYNC 0x00000010 // Call is async
#define IO_FLAG_SYNC 0x00000020 // Call is synchronous
#define IO_FLAG_SEND 0x00000040 // Call is a send
#define IO_FLAG_RECV 0x00000080 // Call is a recv
#define IO_FLAG_NO_FILTER 0x00000100 // Don't go through filters
#define IO_FLAG_AND_RECV 0x00000400 // Add recv operation to IO
#define IO_FLAG_NO_RECV 0x00000800 // Don't do auto-recv after TransmitFile
#define IO_FLAG_NO_DELAY 0x00001000 // Disable Nagling on the socket
// Flags for header generation
#define HTTPH_SEND_GLOBAL_EXPIRE 0x00000001
#define HTTPH_NO_DATE 0x00000002
#define HTTPH_NO_CONNECTION 0x00000004
#define HTTPH_NO_CUSTOM 0x00000008
#define MIN_BUFFER_SIZE_FOR_HEADERS 384
#define MAX_CUSTOM_ERROR_FILE_SIZE (48 * 1024)
#define MD_AUTH_ALL (MD_AUTH_ANONYMOUS|MD_AUTH_BASIC|MD_AUTH_MD5|MD_AUTH_MAPBASIC)
#define MAX_CERT_FIELD_SIZE 4096
#define MAX_ALLOW_SIZE (sizeof("Allow: OPTIONS, TRACE, PUT, DELETE, HEAD, GET\r\n") - 1)
#define MAX_URI_LENGTH 255
//
// Back trace configuration
//
#define MAX_BACKTRACE_FRAMES 10
/************************************************************
* Type Definitions
************************************************************/
enum HTTP_VERB
{
HTV_GET = 0,
HTV_HEAD,
HTV_TRACE,
HTV_PUT,
HTV_DELETE,
HTV_TRACECK,
HTV_POST,
HTV_OPTIONS,
HTV_UNKNOWN
};
//
// Class of a custom error entry.
//
class CUSTOM_ERROR_ENTRY
{
public:
CUSTOM_ERROR_ENTRY( DWORD dwErr,
DWORD dwSubError,
BOOL bWildcard,
CHAR *pszPath,
BOOL bFileError
)
{
m_dwErr = dwErr;
m_dwSubError = dwSubError;
m_bIsFileError = bFileError;
m_bIsWildcard = bWildcard;
if (bFileError)
{
m_pszNames.ErrorFileName = pszPath;
}
else
{
m_pszNames.ErrorURL = pszPath;
}
}
~CUSTOM_ERROR_ENTRY( VOID )
{
CHAR *pszTemp;
if (m_bIsFileError)
{
pszTemp = m_pszNames.ErrorFileName;
}
else
{
pszTemp = m_pszNames.ErrorURL;
}
if (pszTemp != NULL)
{
TCP_FREE(pszTemp);
}
}
BOOL IsFileError( VOID )
{ return m_bIsFileError; }
CHAR *QueryErrorFileName( VOID )
{ return m_pszNames.ErrorFileName; }
CHAR *QueryErrorURL( VOID )
{ return m_pszNames.ErrorURL; }
DWORD QueryError( VOID )
{ return m_dwErr; }
DWORD QuerySubError( VOID )
{ return m_dwSubError; }
DWORD QueryWildcard( VOID )
{ return m_bIsWildcard; }
LIST_ENTRY _ListEntry;
private:
BOOL m_bIsFileError;
BOOL m_bIsWildcard;
DWORD m_dwErr;
DWORD m_dwSubError;
union
{
CHAR *ErrorFileName;
CHAR *ErrorURL;
} m_pszNames;
};
typedef CUSTOM_ERROR_ENTRY *PCUSTOM_ERROR_ENTRY;
//
// The structure of the server's pre-digested meta data.
//
#define W3MD_CREATE_PROCESS_AS_USER 0x00000001
#define W3MD_CREATE_PROCESS_NEW_CONSOLE 0x00000002
#define EXPIRE_MODE_NONE 0
#define EXPIRE_MODE_STATIC 1
#define EXPIRE_MODE_DYNAMIC 2
#define EXPIRE_MODE_OFF 3
class W3_METADATA : public COMMON_METADATA {
public:
//
// Hmmm, since most of these values aren't getting initialized, if
// somebody went and deleted all the metadata items from the tree, then
// bad things could happen. We should initialize with defaults things
// that might mess us
//
W3_METADATA(VOID) :
m_dwAuthentication ( MD_AUTH_ANONYMOUS ),
m_dwAuthenticationPersistence( MD_AUTH_SINGLEREQUESTIFPROXY ),
m_fAnyExtAllowedOnReadDir( FALSE ),
m_pRBlob ( NULL ),
m_dwFooterLength ( 0 ),
m_pszFooter ( NULL ),
m_bFooterEnabled ( TRUE ),
m_bHaveNoCache ( FALSE ),
m_bHaveMaxAge ( FALSE ),
m_bSSIExecDisabled ( FALSE ),
m_dwCGIScriptTimeout ( DEFAULT_SCRIPT_TIMEOUT ),
m_csecPoolIDCTimeout ( 0 ),
m_dwCreateProcessFlags( W3MD_CREATE_PROCESS_AS_USER ),
m_fAllowKeepAlives ( TRUE ),
m_fCacheISAPIApps ( TRUE ),
m_fDoReverseDns ( FALSE ),
m_dwExpireMaxLength ( 0 ),
m_dwExpireMode ( EXPIRE_MODE_NONE ),
m_pWildcardMapping ( NULL ),
m_dwNotifyExAuth ( 0 ),
m_pszCCPointer ( NULL ),
m_dwUploadReadAhead (DEFAULT_W3_UPLOAD_READ_AHEAD),
m_dwPutReadSize (8192),
#if defined(CAL_ENABLED)
m_dwCalHnd ( INVALID_CAL_EXEMPT_HANDLE ),
#endif
m_dwDirBrowseFlags ( MD_DIRBROW_LOADDEFAULT ),
m_fJobCGIEnabled ( FALSE ),
m_fIgnoreTranslate ( FALSE ),
m_fUseDigestSSP ( FALSE ),
m_dwMaxExtLen (0)
{
InitializeListHead( &m_ExtMapHead );
InitializeListHead( &m_CustomErrorHead );
memset( m_apszNTProviders, 0, sizeof(m_apszNTProviders) );
if ( g_fIsWindows95 )
{
m_dwCreateProcessFlags &= ~W3MD_CREATE_PROCESS_AS_USER;
}
}
~W3_METADATA(VOID)
{
DWORD i = 0;
DestroyCustomErrorTable();
TerminateExtMap();
if (m_pRBlob != NULL )
{
delete m_pRBlob;
m_pRBlob = NULL;
}
while ( m_apszNTProviders[i] )
{
TCP_FREE( m_apszNTProviders[i++] );
}
#if defined(CAL_ENABLED)
if ( m_dwCalHnd != INVALID_CAL_EXEMPT_HANDLE )
{
CalExemptRelease( m_dwCalHnd );
}
#endif
}
BOOL HandlePrivateProperty(
LPSTR pszURL,
PIIS_SERVER_INSTANCE pInstance,
METADATA_GETALL_INTERNAL_RECORD *pMDRecord,
LPVOID pDataPointer,
BUFFER *pBuffer,
DWORD *pdwBytesUsed,
PMETADATA_ERROR_INFO pMDErrorInfo
);
BOOL FinishPrivateProperties(
BUFFER *pBuffer,
DWORD dwBytesUsed,
BOOL bSucceeded
);
//
// Query Methods
//
STR * QueryDefaultDocs( VOID )
{ return &m_strDefaultDocs; }
STR * QueryHeaders( VOID )
{ return &m_strHeaders; }
BUFFER * QueryMimeMap( VOID )
{ return &m_bufMimeMap; }
DWORD QueryAuthentication( VOID ) const
{ return m_dwAuthentication; }
DWORD QueryAuthenticationPersistence( VOID ) const
{ return m_dwAuthenticationPersistence; }
DWORD QueryScriptTimeout( VOID ) const
{ return m_dwCGIScriptTimeout; }
DWORD QueryDirBrowseFlags( VOID ) const
{ return m_dwDirBrowseFlags; }
BOOL LookupExtMap(
IN const CHAR * pchExt,
IN BOOL fNoWildcards,
OUT STR * pstrGatewayImage,
OUT GATEWAY_TYPE * pGatewayType,
OUT DWORD * pcchExt,
OUT BOOL * pfImageInURL,
OUT BOOL * pfVerbExcluded,
OUT DWORD * pdwFlags,
IN const CHAR *pszVerb,
IN enum HTTP_VERB Verb,
IN OUT PVOID * ppvExtMapInfo
);
PTCP_AUTHENT_INFO QueryAuthentInfo(VOID) const
{ return (const PTCP_AUTHENT_INFO) &m_TCPAuthentInfo; }
BOOL
BuildProviderList(
CHAR *pszProviders
);
BOOL
CheckSSPPackage(
IN LPCSTR pszAuthString
);
PCHAR QueryRealm(VOID) const
{ return (m_strRealm.IsEmpty() ? NULL : m_strRealm.QueryStr()); }
DWORD QueryCreateProcessAsUser(VOID) const
{ return (m_dwCreateProcessFlags & W3MD_CREATE_PROCESS_AS_USER); }
DWORD QueryCreateProcessNewConsole(VOID) const
{ return (m_dwCreateProcessFlags & W3MD_CREATE_PROCESS_NEW_CONSOLE); }
BOOL QueryAnyExtAllowedOnReadDir() const
{ return m_fAnyExtAllowedOnReadDir; }
PREDIRECTION_BLOB QueryRedirectionBlob(VOID) const
{ return m_pRBlob; }
dllexp
PCUSTOM_ERROR_ENTRY LookupCustomError( DWORD dwErr, DWORD dwSubError )
{
LIST_ENTRY *pEntry;
PCUSTOM_ERROR_ENTRY pCustomErrorItem;
PCUSTOM_ERROR_ENTRY pCustomErrorWildcard = NULL;
for ( pEntry = m_CustomErrorHead.Flink;
pEntry != &m_CustomErrorHead;
pEntry = pEntry->Flink )
{
pCustomErrorItem = CONTAINING_RECORD( pEntry,
CUSTOM_ERROR_ENTRY,
_ListEntry );
if ( pCustomErrorItem->QueryError() == dwErr )
{
if ( pCustomErrorItem->QuerySubError() == dwSubError )
{
return pCustomErrorItem;
}
else if ( pCustomErrorItem->QueryWildcard() )
{
pCustomErrorWildcard = pCustomErrorItem;
}
}
}
return pCustomErrorWildcard;
}
DWORD QueryFooterLength(VOID) const
{ return m_dwFooterLength; }
CHAR *QueryFooter(VOID) const
{ return m_pszFooter; }
BOOL FooterEnabled(VOID) const
{ return m_bFooterEnabled; }
BOOL SSIExecDisabled(VOID) const
{ return m_bSSIExecDisabled; }
DWORD QueryPoolIDCTimeout( VOID ) const
{ return m_csecPoolIDCTimeout; }
const LPSTR * QueryNTProviders( VOID ) const
{ return m_apszNTProviders; }
BOOL QueryKeepAlives( VOID ) const
{ return m_fAllowKeepAlives; }
BOOL QueryCacheISAPIApps( VOID ) const
{ return m_fCacheISAPIApps; }
BOOL QueryDoReverseDns(VOID) const
{ return m_fDoReverseDns; }
DWORD QueryExpireMaxLength(VOID) const
{ return m_dwExpireMaxLength;}
DWORD QueryExpireDelta(VOID) const
{ return m_dwExpireDelta;}
DWORD QueryExpireMode(VOID) const
{ return m_dwExpireMode;}
LPSTR QueryExpireHeader(VOID) const
{ return m_strExpireHeader.QueryStr();}
DWORD QueryExpireHeaderLength(VOID) const
{ return m_strExpireHeader.QueryCCH();}
LARGE_INTEGER QueryExpireTime(VOID) const
{ return m_liExpireTime;}
PVOID QueryWildcardMapping(VOID) const
{ return m_pWildcardMapping; }
DWORD QueryNotifyExAuth(VOID) const
{ return m_dwNotifyExAuth; }
BOOL QueryConfigNoCache(VOID) const
{ return m_bHaveNoCache; }
BOOL QueryHaveMaxAge(VOID) const
{ return m_bHaveMaxAge; }
LPSTR QueryCacheControlHeader(VOID) const
{ return m_strCacheControlHeader.QueryStr(); }
DWORD QueryCacheControlHeaderLength(VOID) const
{ return m_strCacheControlHeader.QueryCB(); }
STR * QueryRedirectHeaders( VOID )
{ return &m_strRedirectHeaders; }
DWORD QueryUploadReadAhead(VOID) const
{ return m_dwUploadReadAhead; }
DWORD QueryPutReadSize(VOID) const
{ return m_dwPutReadSize; }
BOOL QueryJobCGIEnabled()
{ return m_fJobCGIEnabled; }
BOOL QueryIgnoreTranslate() const
{ return m_fIgnoreTranslate; }
BOOL QueryUseDigestSSP() const
{ return m_fUseDigestSSP; }
//
// Set Methods
//
BOOL SetAnonUserName(PCHAR AnonUserName)
{ return m_TCPAuthentInfo.strAnonUserName.Copy( AnonUserName ); }
BOOL SetAnonUserPassword(PCHAR AnonUserPassword)
{ return m_TCPAuthentInfo.strAnonUserPassword.Copy( AnonUserPassword ); }
BOOL SetDefaultLogonDomain(PCHAR DefLogonDom)
{ return m_TCPAuthentInfo.strDefaultLogonDomain.Copy( DefLogonDom ); }
VOID SetLogonMethod(DWORD dwLogonMethod)
{ m_TCPAuthentInfo.dwLogonMethod = dwLogonMethod; }
VOID SetUseAnonSubAuth( BOOL fUseAnonSubAuth )
{ m_TCPAuthentInfo.fDontUseAnonSubAuth = !fUseAnonSubAuth; }
VOID SetAuthentication( DWORD dwFlags )
{
if (g_fIsWindows95)
{
dwFlags &= INET_INFO_AUTH_W95_MASK;
}
m_dwAuthentication = dwFlags;
}
VOID SetAuthenticationPersistence( DWORD dwFlags )
{
m_dwAuthenticationPersistence = dwFlags;
}
VOID SetCGIScriptTimeout( DWORD dwScriptTimeout )
{ m_dwCGIScriptTimeout = dwScriptTimeout; }
VOID SetDirBrowseFlags( DWORD dwDirBrowseFlags )
{ m_dwDirBrowseFlags = dwDirBrowseFlags; }
BOOL BuildExtMap(CHAR *pszExtMapString);
BOOL SetRealm(PCHAR pszRealm)
{ return m_strRealm.Copy( pszRealm ); }
VOID SetCreateProcessAsUser(BOOL fValue)
{
if ( fValue )
{
if ( !g_fIsWindows95 ) {
m_dwCreateProcessFlags |= W3MD_CREATE_PROCESS_AS_USER;
}
}
else
{
m_dwCreateProcessFlags &= ~W3MD_CREATE_PROCESS_AS_USER;
}
}
VOID SetCreateProcessNewConsole(BOOL fValue)
{
if ( fValue )
{
m_dwCreateProcessFlags |= W3MD_CREATE_PROCESS_NEW_CONSOLE;
}
else
{
m_dwCreateProcessFlags &= ~W3MD_CREATE_PROCESS_NEW_CONSOLE;
}
}
BOOL SetRedirectionBlob( STR & strSource,
STR & strDestination )
{
//
// If the redirection is nullified, don't allocate a blob
// and just return success.
//
if ( *( strDestination.QueryStr() ) == '!' )
{
return TRUE;
}
m_pRBlob = new REDIRECTION_BLOB( strSource, strDestination );
if (m_pRBlob == NULL)
{
return FALSE;
}
return m_pRBlob->IsValid();
}
BOOL BuildCustomErrorTable( CHAR *pszErrorList,
PMETADATA_ERROR_INFO pMDErrorInfo
);
VOID DestroyCustomErrorTable( VOID );
BOOL ReadCustomFooter( CHAR *pszFooterString,
TSVC_CACHE &Cache,
HANDLE User,
PMETADATA_ERROR_INFO pMDErrorInfo
);
VOID SetFooter(DWORD dwLength, CHAR *pszFooter)
{ m_dwFooterLength = dwLength; m_pszFooter = pszFooter; }
VOID SetFooterEnabled(BOOL bEnabled)
{ m_bFooterEnabled = bEnabled; }
VOID SetSSIExecDisabled( BOOL bDisabled )
{ m_bSSIExecDisabled = bDisabled; }
VOID SetPoolIDCTimeout( DWORD csecPoolIDCTimeout )
{ m_csecPoolIDCTimeout = csecPoolIDCTimeout; }
VOID SetAllowKeepAlives( BOOL fAllowKeepAlives )
{ m_fAllowKeepAlives = fAllowKeepAlives; }
VOID SetCacheISAPIApps( BOOL fCacheISAPIApps )
{ m_fCacheISAPIApps = fCacheISAPIApps; }
BOOL SetExpire( CHAR* pszExpire,
PMETADATA_ERROR_INFO pMDErrorInfo
);
VOID SetWildcardMapping(PVOID pMapping)
{ m_pWildcardMapping = pMapping; }
VOID SetConfigNoCache(VOID)
{ m_bHaveNoCache = TRUE; }
VOID SetHaveMaxAge(VOID)
{ m_bHaveMaxAge = TRUE; }
VOID ClearConfigNoCache(VOID)
{ m_bHaveNoCache = FALSE; }
VOID ClearHaveMaxAge(VOID)
{ m_bHaveMaxAge = FALSE; }
BOOL
SetCCHeader( BOOL bNoCache,
BOOL bMaxAge,
DWORD dwMaxAge
);
VOID SetUploadReadAhead(DWORD dwUploadSize)
{ m_dwUploadReadAhead = dwUploadSize; }
VOID SetPutReadSize(DWORD dwSize)
{ m_dwPutReadSize = dwSize; }
//
// Disable job objects on IIS5.1, original code would read the
// property from metabase
//
VOID SetJobCGIEnabled( BOOL f ) { m_fJobCGIEnabled = FALSE; }
VOID SetIgnoreTranslate( BOOL f ) { m_fIgnoreTranslate = f; }
VOID SetUseDigestSSP( BOOL f ) { m_fUseDigestSSP = f; }
private:
VOID TerminateExtMap( VOID );
TCP_AUTHENT_INFO m_TCPAuthentInfo;
STR m_strDefaultDocs;
STR m_strHeaders;
BUFFER m_bufMimeMap;
STR m_strRealm;
DWORD m_dwAuthentication;
DWORD m_dwAuthenticationPersistence;
DWORD m_dwCGIScriptTimeout;
DWORD m_dwDirBrowseFlags;
DWORD m_dwCreateProcessFlags;
LIST_ENTRY m_ExtMapHead;
LIST_ENTRY m_CustomErrorHead;
PREDIRECTION_BLOB m_pRBlob;
DWORD m_dwFooterLength;
CHAR *m_pszFooter;
BUFFER m_bufFooter;
BOOL m_fAnyExtAllowedOnReadDir:1;
BOOL m_bFooterEnabled:1;
BOOL m_bHaveNoCache:1;
BOOL m_bHaveMaxAge:1;
BOOL m_bSSIExecDisabled:1;
BOOL m_fAllowKeepAlives:1;
BOOL m_fCacheISAPIApps:1;
BOOL m_fDoReverseDns:1;
DWORD m_csecPoolIDCTimeout;
LPSTR m_apszNTProviders[MAX_SSPI_PROVIDERS];
STR m_strExpireHeader;
STR m_strCacheControlHeader;
DWORD m_dwExpireMaxLength;
DWORD m_dwExpireMode;
DWORD m_dwExpireDelta;
LARGE_INTEGER m_liExpireTime;
PVOID m_pWildcardMapping;
DWORD m_dwNotifyExAuth;
LPSTR m_pszCCPointer;
STR m_strRedirectHeaders;
DWORD m_dwUploadReadAhead;
DWORD m_dwPutReadSize;
BOOL m_fJobCGIEnabled;
#if defined(CAL_ENABLED)
DWORD m_dwCalHnd;
#endif
DWORD m_dwMaxExtLen;
BOOL m_fIgnoreTranslate;
BOOL m_fUseDigestSSP;
};
typedef W3_METADATA *PW3_METADATA;
typedef struct _W3_METADATA_INFO
{
DWORD dwMaxAge;
} W3_METADATA_INFO, *PW3_METADATA_INFO;
//
// Various states the HTTP Request goes through
//
enum HTR_STATE
{
//
// We're still gathering the client request header
//
HTR_READING_CLIENT_REQUEST = 0,
//
// The client is supplying some gateway data, deal with it
//
HTR_READING_GATEWAY_DATA,
//
// We need to take apart the client request and figure out what they
// want
//
HTR_PARSE,
//
// We're executing the verb or handing the request off to a gateway
//
HTR_DOVERB,
//
// The ISAPI application has submitted async IO operation
//
HTR_GATEWAY_ASYNC_IO,
//
// The client requested a file so send them the file
//
HTR_SEND_FILE,
//
// The proxy server is forwarding the request on to the remote server
//
HTR_PROXY_SENDING_REQUEST,
//
// The proxy server is waiting for a response from the remote server
//
HTR_PROXY_READING_RESPONSE,
//
// We're processing a CGI request so we need to ignore any IO
// completions that may occur as the CGIThread forwards the
// program's output
//
HTR_CGI,
//
// Processing a range request
//
HTR_RANGE,
//
// resume processing with clear text logon
//
HTR_RESTART_REQUEST,
//
// We're in the process of writing data from a client PUT request to
// disk
//
HTR_WRITING_FILE,
//
// We're renegotiating a certificate with the client
//
HTR_CERT_RENEGOTIATE,
//
// We're reading the entity body before doing redirect
//
HTR_REDIRECT,
//
// We're reading the entity body before sending access denial
//
HTR_ACCESS_DENIED,
//
// We've completely handled the client's request
//
HTR_DONE
};
enum CHUNK_STATE
{
READ_CHUNK_SIZE = 0,
READ_CHUNK_PARAMS,
READ_CHUNK,
READ_CHUNK_FOOTER,
READ_CHUNK_CRLF,
READ_CHUNK_DONE
};
#if 0 // This routine is no longer used /SAB
#define IS_WRITE_VERB(__verb__) ( (__verb__) == HTV_PUT || \
(__verb__) == HTV_DELETE)
#endif 0
#define CHUNK_READ_SIZE 80 // Important to keep this small, to
// avoid getting two chunks into the
// same buffer in one read.
#define CRLF_SIZE 2
#define SSLNEGO_MAP 0x00000001
/*******************************************************************
CLASS: HTTP_REQ_BASE
SYNOPSIS: Basic HTTP request object
HISTORY:
Johnl 24-Aug-1994 Created
********************************************************************/
class HTTP_REQ_BASE
{
public:
//
// Constructor/Destructor
//
HTTP_REQ_BASE( CLIENT_CONN * pClientConn,
PVOID pvInitialBuff,
DWORD cbInitialBuff );
virtual ~HTTP_REQ_BASE( VOID );
//
// This is the work entry point that is driven by the completion of the
// async IO.
//
virtual BOOL DoWork( BOOL * pfFinished ) = 0;
//
// Parses the client's HTTP request
//
virtual BOOL Parse( const CHAR* pchRequest,
DWORD cbData,
DWORD * pcbExtraData,
BOOL * pfHandled,
BOOL * pfFinished ) = 0;
// Following function can be overridden by individual derived object.
virtual dllexp BOOL GetInfo( const TCHAR * pszValName,
STR * pstr,
BOOL * pfFound = NULL )
{ if ( pfFound )
{
*pfFound = FALSE;
}
return (TRUE);
}
//
// Kicks off the read for a client request header
//
BOOL StartNewRequest( PVOID pvInitialBuff,
DWORD cbInitialBuff,
BOOL fFirst,
BOOL *pfDoAgain);
BOOL OnFillClientReq( BOOL * pfCompleteRequest,
BOOL * pfFinished,
BOOL * pfHandled );
BOOL OnCompleteRequest( TCHAR * pchRequest,
DWORD cbData,
BOOL * pfFinished,
BOOL * pfHandled );
BOOL OnRestartRequest( TCHAR * pchRequest,
DWORD cbData,
BOOL * pfFinished,
BOOL * pfHandled);
BOOL HandleCertRenegotiation( BOOL * pfFinished,
BOOL * pfHandled,
DWORD cbData );
BOOL DenyAccess( BOOL * pfFinished,
BOOL * pfDisconnected );
BOOL VrootAccessCheck( PW3_METADATA pMetaData,
DWORD dwDesiredAccess );
BOOL DoChange( LPBOOL );
BOOL UnWrapRequest( BOOL * pfCompleteRequest,
BOOL * pfFinished,
BOOL * pfHandled );
//
// Attempts to logon with the user information gleaned from the Parse
// we just did
//
BOOL LogonUser( BOOL * pfFinished );
BOOL LogonAsSystem( VOID );
//
// Common header parsing functions.
//
BOOL OnContentLength ( CHAR * pszValue );
BOOL OnIfModifiedSince( CHAR * pszValue );
BOOL OnIfUnmodifiedSince( CHAR * pszValue );
BOOL OnIfMatch( CHAR * pszValue );
BOOL OnIfNoneMatch( CHAR * pszValue );
BOOL OnIfRange( CHAR * pszValue );
BOOL OnUnlessModifiedSince( CHAR * pszValue );
BOOL ProcessAuthorization ( CHAR * pszValue );
BOOL OnProxyAuthorization ( CHAR * pszValue );
BOOL OnHost ( CHAR * pszValue );
BOOL OnRange ( CHAR * pszValue );
//BOOL OnAuthorization ( CHAR * pszValue );
BOOL ParseAuthorization( CHAR * pszValue );
//
// Builds and optionally sends an HTTP server response back to the client
//
static BOOL BuildStatusLine( BUFFER * pstrResp,
DWORD dwHTTPError,
DWORD dwError2,
LPSTR pszError2 = NULL,
STR *pstrErrorStr = NULL
);
//
// Builds a complete HTTP reply with extended explanation text
//
static BOOL BuildExtendedStatus(
STR * pstrResp,
DWORD dwHTTPError,
DWORD dwError2 = NO_ERROR,
DWORD dwExplanation = 0,
LPSTR pszError2 = NULL
);
//
// Sets the http status code and win32 error that should be used for
// this request when it gets written to the logfile
//
VOID SetLogStatus( DWORD LogHttpResponse, DWORD LogWinError )
{
_dwLogHttpResponse = LogHttpResponse;
_dwLogWinError = LogWinError;
}
DWORD QueryLogHttpResponse( VOID ) const
{ return _dwLogHttpResponse; }
DWORD QueryLogWinError( VOID ) const
{ return _dwLogWinError; }
//
// Builds a server header for responding back to the client
//
BOOL BuildBaseResponseHeader(
BUFFER * pbufResponse,
BOOL * pfFinished,
STR * pstrStatus = NULL, // Full status string
DWORD dwOptions = 0 );
BOOL BuildHttpHeader( OUT BOOL * pfFinished,
IN CHAR * pchStatus = NULL,
IN CHAR * pchAdditionalHeaders = NULL,
IN DWORD dwOptions = 0);
dllexp
BOOL SendHeader( IN CHAR * pchStatus OPTIONAL,
IN CHAR * pchAdditionalHeaders OPTIONAL,
IN DWORD IOFlags,
OUT BOOL * pfFinished,
IN DWORD dwOptions = 0,
IN BOOL fWriteHeader = TRUE );
BOOL SendHeader( IN CHAR * pchHeaders,
IN DWORD cbHeaders,
IN DWORD IOFlags,
OUT BOOL * pfFinished );
//
// Builds a 301 or 302 URL Moved message
//
dllexp
BOOL BuildURLMovedResponse( BUFFER * pbufResp,
STR * pstrURL,
DWORD dwServerCode,
BOOL fIncludeParams = FALSE );
dllexp
BOOL WriteLogRecord( VOID );
BOOL AppendLogParameter( CHAR * pszParam );
//
// Sends an access denied message with the forms of authorization
// we support
//
BOOL SendAuthNeededResp( BOOL * pfFinished );
BOOL SetUserNameAndPassword( TCHAR * pszUserName, TCHAR * pszPassword )
{ return _strUserName.Copy( pszUserName ) && _strPassword.Copy( pszPassword ); }
STR * QueryDenialHeaders( VOID )
{ return &_strDenialHdrs; }
STR * QueryAdditionalRespHeaders( VOID )
{ return &_strRespHdrs; }
DWORD QueryAuthentication( VOID ) const
{ return _pMetaData->QueryAuthentication(); }
DWORD QueryNotifyExAuth( VOID ) const
{ return _pMetaData->QueryNotifyExAuth(); }
DWORD QueryDirBrowseFlags( VOID ) const
{ return _pMetaData->QueryDirBrowseFlags(); }
BOOL IsIpDnsAccessCheckPresent( VOID ) const
{ return _pMetaData->IsIpDnsAccessCheckPresent(); }
PW3_METADATA QueryMetaData( VOID ) const
{ return _pMetaData; }
//
// Retrieves various bits of request information
//
enum HTR_STATE QueryState( VOID ) const
{ return _htrState; }
BOOL IsKeepConnSet( VOID ) const
{ return _fKeepConn; }
BOOL IsProcessByteRange( VOID ) const
{ return _fProcessByteRange; }
BOOL IsAuthenticationRequested( VOID ) const
{ return _fAuthenticationRequested; }
BOOL IsAuthenticated( VOID ) const
{ return !_strUserName.IsEmpty(); }
DWORD IsChunked( VOID ) const
{ return _fChunked; }
VOID SetChunked( VOID )
{ _fChunked = TRUE; }
VOID ClearChunked( VOID )
{ _fChunked = FALSE; }
VOID SetKeepConn( BOOL fKeepConn )
{ _fKeepConn = fKeepConn; }
VOID SetAuthenticationRequested( BOOL fAuthenticationRequested )
{ _fAuthenticationRequested = fAuthenticationRequested; }
BOOL IsLoggedOn( VOID ) const
{ return _fLoggedOn; }
BOOL IsClearTextPassword( VOID ) const
{ return _fClearTextPass; };
BOOL IsNTLMImpersonation( VOID ) const
{ return !_fClearTextPass && !_fAnonymous && !UseVrAccessToken(); }
BOOL IsSecurePort( VOID ) const
{ return _fSecurePort; }
BOOL IsProxyRequest( VOID ) const
{ return _fProxyRequest; }
VOID SetProxyRequest( BOOL fIsProxyRequest )
{ _fProxyRequest = fIsProxyRequest; }
BOOL IsClientProxy( VOID );
CLIENT_CONN * QueryClientConn( VOID ) const
{ return _pClientConn; }
W3_SERVER_INSTANCE * QueryW3Instance( VOID ) const
{ return _pW3Instance; }
W3_SERVER_INSTANCE * QueryW3InstanceAggressively( VOID ) const;
VOID SetW3Instance( IN W3_SERVER_INSTANCE* pInstance )
{ DBG_ASSERT(_pW3Instance == NULL); _pW3Instance = pInstance; }
W3_SERVER_STATISTICS * QueryW3StatsObj( VOID ) const
{ return _pW3Stats; }
VOID SetW3StatsObj( IN LPW3_SERVER_STATISTICS pW3Stats )
{ _pW3Stats = pW3Stats; }
BOOL IsPointNine( VOID ) const
{ return (_VersionMajor < 1); }
BOOL IsAtLeastOneOne( VOID ) const
{ return ((_VersionMajor == 1 && _VersionMinor >= 1) ||
(_VersionMajor >= 2)); }
BOOL IsOneOne( VOID ) const
{ return ((_VersionMajor == 1) && (_VersionMinor == 1)); }
BOOL IsAuthenticating( VOID ) const
{ return _fAuthenticating; }
DWORD QueryClientContentLength( VOID ) const
{ return _cbContentLength; }
DWORD QueryTotalRequestLength( VOID ) const
{ return _cbContentLength + _cbClientRequest; }
BYTE * QueryClientRequest( VOID ) const
{ return (BYTE *) _bufClientRequest.QueryPtr(); }
BUFFER * QueryClientReqBuff( VOID )
{ return &_bufClientRequest; }
CHAR * QueryURL( VOID ) const
{ return _strURL.QueryStr(); }
CHAR * QueryURLParams( VOID ) const
{ return _strURLParams.QueryStr(); }
HTTP_HEADERS * QueryHeaderList( VOID )
{ return &_HeaderList; }
BUFFER * QueryRespBuf( VOID )
{ return &_bufServerResp; }
CHAR * QueryRespBufPtr( VOID )
{ return (CHAR *) _bufServerResp.QueryPtr(); }
DWORD QueryRespBufCB( VOID )
{ return strlen( (CHAR *)_bufServerResp.QueryPtr()); }
VOID SetDeniedFlags( DWORD dwDeniedFlags )
{ _Filter.SetDeniedFlags( dwDeniedFlags ); }
CHAR * QueryHostAddr( VOID );
//
// If the client supplied additional data in their request, we store
// the byte count and data here.
//
DWORD QueryEntityBodyCB( VOID ) const
{ return _cbEntityBody; }
DWORD QueryTotalEntityBodyCB( VOID ) const
{ return _cbTotalEntityBody; }
VOID AddTotalEntityBodyCB( DWORD cbAdditionalEntityBody )
{ _cbTotalEntityBody += cbAdditionalEntityBody; }
BYTE * QueryEntityBody( VOID ) const
{ return (BYTE *) _bufClientRequest.QueryPtr() + _cbClientRequest; }
BOOL ReadMoreEntityBody(DWORD cbOffset,
DWORD cbSize);
BOOL ReadEntityBody( BOOL *pfDone,
BOOL fFirstRead = FALSE,
DWORD dwMaxAmountToRead = 0,
BOOL *pfDisconnected = NULL );
BOOL DecodeChunkedBytes( LPBYTE lpBuffer,
LPDWORD pnBytes );
BOOL IsChunkedReadComplete( ) {
return ( _ChunkState == READ_CHUNK_DONE );
}
//
// IO Status stuff
//
VOID SetLastCompletionStatus( DWORD BytesWritten,
DWORD CompletionStatus )
{
_cbBytesWritten = BytesWritten;
_status = CompletionStatus;
//
// Do accounting for async sends so that the total bytes matches
// the number actually sent to they client.
//
// TODO: If the client disconnects then the io completion may
// complete with an error even the data was successfully sent.
// This appears to be an issue with TCP, but requires further
// investigation. (taylorw)
//
if ( _fAsyncSendPosted )
{
_cbBytesSent += BytesWritten;
_fAsyncSendPosted = FALSE;
}
}
DWORD QueryIOStatus( VOID ) const
{ return _status; }
DWORD QueryBytesWritten( VOID ) const
{ return _cbBytesWritten; }
DWORD QueryBytesReceived( VOID ) const
{ return _cbBytesReceived; }
//
// Impersonation related stuff
//
BOOL UseVrAccessToken() const
{ return _pMetaData->QueryVrAccessToken() &&
(!_pMetaData->QueryVrPassThrough() || !_tcpauth.IsForwardable()); }
BOOL ImpersonateUser( VOID )
{ return (!UseVrAccessToken() ?
_tcpauth.Impersonate() :
_pMetaData->ImpersonateVrAccessToken()
); }
VOID RevertUser( VOID )
{ (!UseVrAccessToken() ?
_tcpauth.RevertToSelf():
::RevertToSelf()
); }
HANDLE QueryPrimaryToken( HANDLE * phDelete );
HANDLE QueryImpersonationHandle( BOOL fUnused = FALSE )
{ return (UseVrAccessToken() ?
_pMetaData->QueryVrAccessToken() :
_tcpauth.QueryImpersonationToken() ); }
HANDLE QueryUserImpersonationHandle( VOID )
{ return _tcpauth.QueryImpersonationToken(); }
HANDLE QueryVrootImpersonateHandle(VOID) const
{ return UseVrAccessToken() ? _pMetaData->QueryVrAccessToken() : NULL; }
TCP_AUTHENT * QueryAuthenticationObj( VOID )
{ return &_tcpauth; }
BOOL IsValid( VOID ) const
{ return _fValid; }
//
// Forwards request to the client connection object
//
VOID Disconnect( DWORD htResp = 0,
DWORD dwError2 = NO_ERROR,
BOOL fShutdown= FALSE,
LPBOOL pfFinished = NULL );
dllexp
BOOL ReadFile( LPVOID lpBuffer,
DWORD nBytesToRead,
DWORD * pcbBytesRead, // Only for sync reads
DWORD dwFlags = IO_FLAG_ASYNC );
dllexp
BOOL WriteFile( LPVOID lpBuffer,
DWORD nBytesToRead,
DWORD * pcbBytesWritten, // Only for sync writes
DWORD dwFlags = IO_FLAG_ASYNC );
dllexp
BOOL TestConnection( VOID );
BOOL TransmitFile( TS_OPEN_FILE_INFO * pOpenFile,
HANDLE hFile,
DWORD Offset,
DWORD BytesToWrite,
DWORD dwFlags = IO_FLAG_ASYNC,
PVOID pHead = NULL,
DWORD HeadLength = 0,
PVOID pTail = NULL,
DWORD TailLength = 0);
BOOL TransmitFileTs( TS_OPEN_FILE_INFO * pOpenFile,
DWORD Offset,
DWORD BytesToWrite,
DWORD dwFlags = IO_FLAG_ASYNC,
PVOID pHead = NULL,
DWORD HeadLength = 0,
PVOID pTail = NULL,
DWORD TailLength = 0);
BOOL SyncWsaSend( WSABUF * rgWsaBuffers,
DWORD cWsaBuffers,
LPDWORD pcbWritten );
BOOL PostCompletionStatus( DWORD cbBytesTransferred );
DWORD Reference( VOID );
DWORD Dereference( VOID );
DWORD QueryRefCount( VOID );
//
// Reset is called at the beginning of every request
//
virtual BOOL Reset( BOOL fResetPipelineInfo );
virtual VOID ReleaseCacheInfo( VOID );
//
// Called to reset Authentication status
//
BOOL ResetAuth( BOOL fSessionTerminated = TRUE );
// added these methods for exposing them to the Server extension processor
dllexp
const STR & QueryContentTypeStr( void) const { return ( _strContentType); }
dllexp
const STR & QueryMethodStr( void) const { return ( _strMethod); }
dllexp
const STR & QueryURLStr(void) const { return ( _strURL); }
dllexp
const STR & QueryPhysicalPathStr( void) const { return ( _strPhysicalPath); }
dllexp
const LPSTR QueryExpireHeader( void ) const
{ return ( _pMetaData->QueryExpireHeader() ); }
//
// Called at the beginning and end of a TCP session
//
VOID InitializeSession( CLIENT_CONN * pConn,
PVOID pvInitialBuff,
DWORD cbInitialBuff );
virtual VOID EndOfRequest( VOID ) = 0;
virtual VOID SessionTerminated( VOID );
//
// Generally when the state is set to HTR_DONE
//
VOID SetState( enum HTR_STATE htrstate,
DWORD dwLogHttpResponse = HT_DONT_LOG,
DWORD dwLogWinError = NO_ERROR )
{ _htrState = htrstate;
_dwLogHttpResponse = dwLogHttpResponse;
_dwLogWinError = dwLogWinError;
}
BOOL SetCertificateInfo( PHTTP_FILTER_CERTIFICATE_INFO pData,
CtxtHandle* pCtxt,
HANDLE hImpersonationToken,
HTTP_FILTER_DLL* pFilter );
BOOL CheckValidSSPILogin( VOID );
BOOL NotifyRequestSecurityContextClose( CtxtHandle *pH )
{ return _pAuthFilter ? _Filter.NotifyRequestSecurityContextClose( _pAuthFilter,
pH ) : TRUE; }
dllexp
BOOL CheckForBasicAuthenticationHeader( LPSTR pszHeaders );
BOOL IsAnonymous( VOID ) const
{ return _fAnonymous; }
HTTP_FILTER * QueryFilter( VOID )
{ return &_Filter; }
BOOL CheckCustomError(BUFFER *pBuf, DWORD dwErr, DWORD dwSubError,
BOOL *pfFinished, DWORD *pdwMsgSize, BOOL bCheckURL = TRUE);
VOID SetNoCache( VOID )
{ _bForceNoCache = 1; }
VOID ClearNoCache( VOID )
{ _bForceNoCache = 0; }
DWORD QueryNoCache( VOID)
{ return _bForceNoCache; }
VOID SetSendVary( VOID )
{ _bSendVary = 1; }
VOID ClearSendVary( VOID )
{ _bSendVary = 0; }
VOID ToggleSendCL( VOID )
{ _bSendContentLocation ^= 1; }
VOID SetSendCL( VOID )
{ _bSendContentLocation = 1; }
VOID ClearSendCL( VOID )
{ _bSendContentLocation = 0; }
BOOL IsCGIRequest( VOID ) const
{ return _GatewayType == GATEWAY_CGI; }
//
// The request looks like a gateway request (but may just be a poorly named
// directory)
//
BOOL IsProbablyGatewayRequest( VOID ) const
{ return (_GatewayType & GT_GATEWAY_REQUEST); }
enum HTTP_VERB QueryVerb( VOID ) const
{ return _verb; }
virtual DWORD BuildAllowHeader(CHAR *pszURL, CHAR *pszTail) = 0;
//
// Set the time for start of processing
//
VOID SetRequestStartTime( VOID )
{ if (!_fStartTimeValid) { _msStartRequest= GetCurrentTime(); _fStartTimeValid= TRUE;}}
HANDLE GetFileHandle( TS_OPEN_FILE_INFO * pOpenFile )
{
HANDLE hHandle = INVALID_HANDLE_VALUE;
if ( pOpenFile )
{
if ( ImpersonateUser() )
{
hHandle = pOpenFile->QueryFileHandle();
RevertUser();
}
}
return hHandle;
}
VOID IncrementBytesSeenByRawReadFilter( DWORD cbBytesSeen )
{
_cbOldData += cbBytesSeen;
}
protected:
//
// Breaks out the simple authorization info
//
BOOL ExtractClearNameAndPswd( CHAR * pch,
STR * pstrUserName,
STR * pstrPassword,
BOOL fUUEncoded );
//
// Appends the forms of authentication the server supports to the
// server response string
//
BOOL AppendAuthenticationHdrs( STR * pstrAuthHdrs,
BOOL * pfFinished );
//
// Data members
//
//
// Points to connection object we are communicating on
//
CLIENT_CONN * _pClientConn;
// Meta data info for this request.
PW3_METADATA _pMetaData;
// URI related info (file and metadata) for this request.
PW3_URI_INFO _pURIInfo;
//
// Points to the w3 instance
//
W3_SERVER_INSTANCE * _pW3Instance;
//
// Points to server instance's statistics object.
//
W3_SERVER_STATISTICS * _pW3Stats;
//
// Action the client is requesting
//
enum HTTP_VERB _verb;
//
// Statistics trackers
//
DWORD _cFilesSent;
DWORD _cFilesReceived;
DWORD _cbBytesSent; // Total for this request
DWORD _cbBytesReceived;
DWORD _cbTotalBytesSent; // Total for all requests using this
DWORD _cbTotalBytesReceived; // object
//
// Flags
//
BOOL _fValid:1; // TRUE if this object constructed successfully
BOOL _fKeepConn:1; // Pragma: Keep-connection was specified
BOOL _fAuthenticationRequested:1; // request client authentication
BOOL _fLoggedOn:1; // A user was successfully logged on
BOOL _fAnonymous:1; // The user is using the Anonymous user token
BOOL _fSecurePort; // This request is coming over an encrypted port
BOOL _fMappedAcct:1; // The user is using a mapped account
BOOL _fClearTextPass:1; // The user supplied a clear text password
BOOL _fAuthenticating:1; // We're in an NT authentication conversation
BOOL _fBasicRealm:1; // TRUE if realm specified
BOOL _fAuthSystem:1;
BOOL _fAuthCert:1;
BOOL _fInvalidAccessToken:1;
BOOL _fAsyncSendPosted:1; // TRUE when we send data to the client asychronously
BOOL _fChunked:1; // TRUE iff the entity body is in the chunked
// transfer-encoding
BOOL _fDiscNoError:1; // TRUE if we're to disconnect w/o an error.
BOOL _fNoDisconnectOnError:1; // TRUE if we're not to disconnect on an early error.
BOOL _fProxyRequest:1; // This is request is a proxy request
// Accept range variables
BOOL _fAcceptRange:1; // TRUE if the referenced file accept byte ranges
BOOL _fProcessByteRange:1; // TRUE while processing a byte range request
BOOL _fUnsatisfiableByteRange:1; // TRUE if an unsatisfiable byte range was encountered
BOOL _fMimeMultipart:1; // TRUE if generating a MIME multipart message
BOOL _fIfModifier:1; // TRUE if we've seen an If-Match, etc.
BOOL _fHaveContentLength:1;// Set to TRUE if we've seen a content length
// on this requests.
BOOL _fLogRecordWritten:1; // TRUE if we've written a log record
DWORD _iRangeIdx; // index in strRange string
DWORD _dwRgNxOffset; // next range offset
DWORD _dwRgNxSizeToSend; // next range size
DWORD _cbMimeMultipart; // length of a MIME multipart message body
//
// The state of the HTTP request
//
enum HTR_STATE _htrState;
enum GATEWAY_TYPE _GatewayType; // BGI vs CGI vs BAT
//
// List of raw headers passed by client
//
HTTP_HEADERS _HeaderList;
//
// Client protocol version information
//
BYTE _VersionMajor;
BYTE _VersionMinor;
//
// If the client is passing data to a gateway, they will specify
// the length and type in a Content-length/type header that is stored
// here
//
STR _strContentType;
UINT _cbContentLength;
//
// The URL the client is requesting
//
STR _strURL; // Just the URL
STR _strURLPathInfo; // Combined URL and script path info
STR _strURLParams; // Just the params (w/o '?')
STR _strLogParams; // Copy of _strURLParams for logging
STR _strPathInfo; // Additional script path info
STR _strRawURL; // Combined URL and params
STR _strOriginalURL; // URL before being passed to filters
//
// Various other pieces of data in the HTTP request we care about
//
STR _strMethod; // GET, HEAD, POST etc.
STR _strAuthType; // "user", "kerberos", "nt" etc.
STR _strAuthInfo; // Current SSP authorization blob
STR _strUserName; // The user name (empty if Guest)
STR _strPassword; // Temporarily holds the password
STR _strUnmappedUserName; // User before filter mappings
STR _strUnmappedPassword; // Password before filter mappings
STR _strPhysicalPath; // Physical path of URL (maybe empty)
STR _strUnmappedPhysicalPath; // unmapped Physical path of URL (maybe empty)
STR _strRespHdrs; // Optional headers from filters
STR _strDenialHdrs; // Optional headers from filters
// to add if request is denied
STR _strHostAddr; // Host address as a domain name
STR _strRange;
BOOL _fAuthTypeDigest; // is auth type Digest/NT-Digest
LARGE_INTEGER _liModifiedSince; // Contains If-Modified-Since time
LARGE_INTEGER _liUnlessModifiedSince; // Contains Unless-Modified-Since time
LARGE_INTEGER _liUnmodifiedSince; // Contains If-Unmodified-Since time
DWORD _dwExpireInDay; // # of days before pwd expiration
// or 0x7fffffff if n/a
DWORD _dwModifiedSinceLength; // Length parameter passed in with IMS.
BOOL _bProcessingCustomError:1; // TRUE if we're processing a custom error.
BOOL _bForceNoCache:1; // Set to TRUE if must force no-cache.
BOOL _bSendContentLocation:1; // Set to TRUE if we need to send C-L:
BOOL _bSendVary:1; // Set to TRUE if we need to send Vary: *.
//
// Encapsulates authentication and impersonation code
//
BOOL _fSingleRequestAuth:1;
TCP_AUTHENT _tcpauth;
//
// Used to calculate the time of this request
//
BOOL _fStartTimeValid:1;
DWORD _msStartRequest;
//
// Filter context information
//
HTTP_FILTER _Filter;
HTTP_FILTER_DLL * _pAuthFilter;
//
// Contains the HTTP client request buffer
// _cbClientRequest indicates the number of bytes in the HTTP request
// (excluding gateway data)
// _cbOldData - Number of bytes in buffer raw read filters have already
// seen
// _cbEntityBody - Number of bytes of entity body currently in buffer
// _cbTotalEntityBody - Number of bytes expected in entity body.
// _cbChunkHeader - Number of bytes in chunk header processed.
// _cbChunkBytesRead - Number of bytes in the current transfer-encoded
// chunk we've read.
// _cbExtraData - Number of 'extra' bytes in buffer.
// _pchExtraData - Pointer to start of 'extra' bytes.
//
BUFFER _bufClientRequest;
DWORD _cbClientRequest;
DWORD _cbOldData;
DWORD _cbEntityBody;
DWORD _cbTotalEntityBody;
DWORD _cbChunkHeader;
DWORD _cbChunkBytesRead;
DWORD _cbExtraData;
CHAR *_pchExtraData;
//
// Contains the server response buffer, generally only used for response
// headers
//
BUFFER _bufServerResp;
//
// Stores the results of the last IO request
//
APIERR _status;
DWORD _cbBytesWritten;
DWORD _cbRestartBytesWritten;
DWORD _dwRenegotiated;
DWORD _dwSslNegoFlags;
AC_RESULT _acIpAccess;
BOOL _fNeedDnsCheck;
//
// Stores the request codes to write to the request log
//
DWORD _dwLogHttpResponse;
DWORD _dwLogWinError;
// Information used for decoding chunked requests.
enum CHUNK_STATE _ChunkState;
DWORD _dwChunkSize; // reset value is -1 => chunk size not sent.
BYTE _CRCount;
BYTE _LFCount;
BUFFER _bufLastAnonAcctDesc;
DWORD _cbLastAnonAcctDesc;
#if defined(CAL_ENABLED)
LPVOID m_pCalAuthCtxt;
LPVOID m_pCalSslCtxt;
#endif
VOID * m_ppvFrames[ MAX_BACKTRACE_FRAMES ];
};
#define CERT_NEGO_SUCCESS 1
#define CERT_NEGO_FAILURE 2
//
// Macro to check for both normal and localhost access
//
#define IS_ACCESS_ALLOWED(op) ( \
((GetFilePerms() & VROOT_MASK_## op) != 0) && \
(((GetFilePerms() & VROOT_MASK_NO_REMOTE_## op) == 0) || \
IsIPAddressLocal( \
QueryClientConn()->QueryLocalIPAddress(), \
QueryClientConn()->QueryRemoteIPAddress()) ) )
#define IS_ACCESS_ALLOWED2(_pExec, op) ( \
((_pExec->_pMetaData->QueryAccessPerms() & VROOT_MASK_## op) != 0) && \
(((_pExec->_pMetaData->QueryAccessPerms() & VROOT_MASK_NO_REMOTE_## op) == 0) || \
IsIPAddressLocal( \
QueryClientConn()->QueryLocalIPAddress(), \
QueryClientConn()->QueryRemoteIPAddress()) ) )
# endif // _BASEREQ_HXX_