1894 lines
47 KiB
C++
1894 lines
47 KiB
C++
/*++
|
||
|
||
Copyright (c) 1996 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
ism.hxx
|
||
|
||
Abstract:
|
||
|
||
HTML administrator include file
|
||
|
||
Author:
|
||
|
||
Philippe Choquier (phillich) 10-january-1996
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
# ifndef _HTMLA_HXX_
|
||
# define _HTMLA_HXX_
|
||
|
||
/************************************************************
|
||
* 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_MULT_CHOICE 300
|
||
#define HT_MOVED 301
|
||
#define HT_REDIRECT 302
|
||
#define HT_REDIRECT_METHOD 303
|
||
#define HT_NOT_MODIFIED 304
|
||
|
||
#define HT_REDIRECTH 380
|
||
|
||
|
||
#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_SERVER_ERROR 500
|
||
#define HT_NOT_SUPPORTED 501
|
||
#define HT_BAD_GATEWAY 502
|
||
//#define HT_SVC_UNAVAILABLE 503
|
||
#define HT_GATEWAY_TIMOUE 504
|
||
|
||
// some values not conflicting with their respective domain ranges
|
||
|
||
#define HT_REPROCESS 0x10000000
|
||
|
||
#define HSE_REPROCESS 0x10000000
|
||
|
||
#define INET_DIR 0xffff0000
|
||
|
||
#define INET_LOG_INVALID_TO_FILE 4
|
||
|
||
//
|
||
// script execution status
|
||
//
|
||
|
||
#define HTR_OK 0
|
||
#define HTR_OUT_OF_RESOURCE 1000
|
||
#define HTR_COM_CONFIG_ACCESS_ERROR 2000
|
||
#define HTR_USER_ENUM_ACCESS_ERROR 2010
|
||
#define HTR_USER_DISCONNECT_ERROR 2020
|
||
#define HTR_CONFIG_ACCESS_ERROR 2100
|
||
#define HTR_W3_CONFIG_ACCESS_ERROR 2200
|
||
#define HTR_FTP_CONFIG_ACCESS_ERROR 2300
|
||
#define HTR_GD_CONFIG_ACCESS_ERROR 2400
|
||
#define HTR_CONFIG_WRITE_ERROR 2500
|
||
#define HTR_W3_CONFIG_WRITE_ERROR 2600
|
||
#define HTR_FTP_CONFIG_WRITE_ERROR 2700
|
||
#define HTR_GD_CONFIG_WRITE_ERROR 2800
|
||
#define HTR_COM_CONFIG_WRITE_ERROR 2900
|
||
#define HTR_REF_NOT_FOUND 4000
|
||
#define HTR_BAD_PARAM 5000 // invalid syntax in param
|
||
#define HTR_INVALID_VAR_TYPE 6000
|
||
#define HTR_INVALID_FORM_PARAM_NAME 7000
|
||
#define HTR_INVALID_FORM_PARAM 8000
|
||
#define HTR_VAR_NOT_FOUND 9000
|
||
#define HTR_TOO_MANY_NESTED_IF 10000
|
||
#define HTR_IF_UNDERFLOW 11000
|
||
#define HTR_VALIDATION_FAILED 12000 // Update indication rejected
|
||
#define HTR_ACCESS_DENIED 13000
|
||
#define HTR_DIR_SAME_NAME 14000
|
||
|
||
#define IP_ADDR_BYTE_SIZE 4
|
||
|
||
#define MAX_SIZE_OF_DWORD_AS_STRING 32
|
||
#define INET_LOG_PERIOD_ON_SIZE 5 // next value in INET_LOG_PERIOD_*
|
||
#define HOME_DIR_PATH L"/"
|
||
|
||
//
|
||
// max size DNS name
|
||
//
|
||
|
||
#define MAX_DOMAIN_LENGTH 128
|
||
|
||
|
||
//
|
||
// max error code length [when converted to a string]
|
||
//
|
||
#define MAX_ERROR_CODE_LENGTH 32
|
||
|
||
//
|
||
// HTMLA variables types
|
||
//
|
||
// Some types are defined to enable specific validation / alteration
|
||
// even if their storage convention is the same as already available
|
||
// types.
|
||
//
|
||
|
||
enum INET_ELEM_TYPE {
|
||
ITYPE_BOOL, // 0 ( FALSE) or 1 ( TRUE ), in a DWORD
|
||
ITYPE_LPWSTR, // pointer to UNICODE
|
||
ITYPE_LPSTR, // pointer to ASCII
|
||
ITYPE_AWCHAR, // array of UNICODE
|
||
ITYPE_DWORD, // 32 bits unsigned
|
||
ITYPE_SHORT, // 16 bits
|
||
ITYPE_IP_ADDR, // array of bytes ( len is IP_ADDR_BYTE_SIZE )
|
||
ITYPE_IP_MASK, // array of bytes ( len is IP_ADDR_BYTE_SIZE )
|
||
ITYPE_1K, // as DWORD, scaled 1024
|
||
ITYPE_TIME, // seconds, in a DWORD
|
||
ITYPE_PARAM_LIT_STRING, // as LPSTR
|
||
ITYPE_VIRT_DIR_LPWSTR, // virtual root name, as a LPWSTR
|
||
ITYPE_SHORTDW, // 16 significant bits in a DWORD
|
||
ITYPE_1M, // as DWORD, scaled 1024*1024
|
||
ITYPE_PATH_LPWSTR // directory path as LPWSTR
|
||
};
|
||
|
||
|
||
#define HEXDIGIT( nDigit ) \
|
||
(TCHAR)((nDigit) > 9 ? \
|
||
(nDigit) - 10 + 'A' \
|
||
: (nDigit) + '0')
|
||
|
||
//
|
||
// Status of HTML script parsing
|
||
//
|
||
|
||
enum HTR_SKIP_STATUS { HSS_NO_SKIP, HSS_SKIP_ITER=1, HSS_SKIP_IF=2,
|
||
HSS_SKIP_GOTO=4, HSS_WAIT_ENDIF=8 };
|
||
|
||
#define MAX_NESTED_IF 16
|
||
|
||
//
|
||
// type of command for the HandleVirtDirRequest() functions
|
||
//
|
||
|
||
#define _VIRT_DIR_REQ_CHECK 0
|
||
#define _VIRT_DIR_REQ_ALIAS 1
|
||
|
||
extern DWORD g_dwZero;
|
||
extern DWORD g_dwOne;
|
||
extern LPSTR g_pszIPNullAddr;
|
||
|
||
#if defined(IISv1)
|
||
extern OSVERSIONINFO g_OSVersion;
|
||
extern DWORD g_dwCap1Flag;
|
||
extern DWORD g_dwCap1Mask;
|
||
#endif
|
||
|
||
|
||
//
|
||
//DLLs to look in for error codes
|
||
//
|
||
LPSTR g_apszErrorCodeDlls[] =
|
||
{
|
||
"KERNEL32.DLL",
|
||
"NETMSG.DLL",
|
||
"NTDLL.DLL"
|
||
};
|
||
|
||
#define NUM_ERROR_CODE_DLLS (sizeof(g_apszErrorCodeDlls)/sizeof(g_apszErrorCodeDlls[0]))
|
||
|
||
class CInetInfoMap;
|
||
|
||
|
||
//
|
||
// Global functions
|
||
//
|
||
|
||
BOOL SortVirtualRoots( LPINET_INFO_VIRTUAL_ROOT_LIST pL );
|
||
BOOL SortIpSecList( LPINET_INFO_IP_SEC_LIST pL );
|
||
|
||
//
|
||
// Dynamic string
|
||
//
|
||
|
||
class CDStr {
|
||
public:
|
||
CDStr();
|
||
~CDStr();
|
||
|
||
BOOL Init();
|
||
|
||
// returns pointer to string, always zero-delimited
|
||
LPSTR GetString();
|
||
|
||
// return string length ( excluding delimiter )
|
||
DWORD GetLen() { return m_dwLen; }
|
||
|
||
// add a zero-delimited string
|
||
BOOL Add( LPSTR );
|
||
|
||
// add a byte range
|
||
BOOL AddRange( LPSTR, DWORD ); // add a byte range
|
||
|
||
// reset content to NULL
|
||
void Reset();
|
||
|
||
private:
|
||
DWORD m_dwAlloc; // # of alloc'ed bytes
|
||
DWORD m_dwLen; // string length
|
||
LPSTR m_pStr; // pointer to buffer
|
||
} ;
|
||
|
||
|
||
#if defined(GENERATE_AUTH_HEADERS)
|
||
|
||
//
|
||
// Maintains a list of authentication schemes supported
|
||
// by the Web server
|
||
//
|
||
|
||
class CAuthenticationReqs {
|
||
|
||
public:
|
||
|
||
CAuthenticationReqs();
|
||
~CAuthenticationReqs();
|
||
//
|
||
BOOL Init();
|
||
|
||
// Retrieve list of authentication methods as a W3 header
|
||
// i.e. each method is prefixed with WWW-Authenticate
|
||
// and "\r\n" is appended to the list.
|
||
// returns NULL if no supported authentication methods.
|
||
|
||
LPSTR GetAuthenticationListHeader();
|
||
|
||
// To be used while accessing the LPSTR returned
|
||
// by GetAuthenticationListHeader()
|
||
|
||
void Lock()
|
||
{ EnterCriticalSection( &m_csR ); }
|
||
|
||
void UnLock()
|
||
{ LeaveCriticalSection( &m_csR ); }
|
||
|
||
//
|
||
BOOL UpdateMethodsIndication();
|
||
|
||
BOOL UpdateNTAuthenticationProvidersIndication();
|
||
|
||
// Request termination of this object ( will terminate
|
||
// notification thread )
|
||
|
||
BOOL Terminate();
|
||
|
||
//
|
||
DWORD UpdateIndication();
|
||
|
||
private:
|
||
|
||
BOOL BuildListHeader();
|
||
|
||
private:
|
||
|
||
HANDLE m_hNotifyEvent;
|
||
BOOL m_fRequestTerminate;
|
||
HANDLE m_hThread;
|
||
CDStr m_dsH; // WWW-Authenticate list
|
||
DWORD m_dwMethods; // bitmask from INET_INFO_AUTH_*
|
||
LPSTR m_pszProviders;
|
||
CRITICAL_SECTION m_csR;
|
||
HKEY m_hKey;
|
||
} ;
|
||
|
||
#endif
|
||
|
||
//
|
||
// Memory allocation node, used by CInetInfoConfigInfoMapper to maintain
|
||
// a list of all allocations made during a request to allow them to be
|
||
// freed at the end of the request.
|
||
//
|
||
// The memory block is initialized to all 0.
|
||
//
|
||
|
||
class CAllocNode {
|
||
|
||
public:
|
||
|
||
// constructor allocates requested memory block
|
||
|
||
CAllocNode( DWORD dwL )
|
||
{
|
||
if ( m_pBuff = new BYTE[ dwL ] )
|
||
{
|
||
memset( m_pBuff, '\0', dwL );
|
||
}
|
||
m_pNext = NULL;
|
||
}
|
||
|
||
~CAllocNode()
|
||
{ delete [] m_pBuff; }
|
||
|
||
void SetNext( CAllocNode* pN )
|
||
{ m_pNext = pN; }
|
||
|
||
CAllocNode* GetNext()
|
||
{ return m_pNext; }
|
||
|
||
LPBYTE GetBuff()
|
||
{ return m_pBuff; }
|
||
|
||
private:
|
||
|
||
LPBYTE m_pBuff; // pointer to buffer
|
||
CAllocNode* m_pNext; // pointer to next alloc node
|
||
} ;
|
||
|
||
|
||
class CInetInfoConfigInfoMapper;
|
||
|
||
//
|
||
// Give access to the list of currently connected users for a given
|
||
// servive ( as specified by the CInetInfoConfigInfoMapper given
|
||
// at Init() time )
|
||
//
|
||
|
||
class CUserEnum {
|
||
|
||
public:
|
||
|
||
CUserEnum();
|
||
|
||
~CUserEnum();
|
||
|
||
//
|
||
BOOL Init( CInetInfoConfigInfoMapper* );
|
||
|
||
void Reset();
|
||
|
||
// Get count of connected users as a .htr variable
|
||
|
||
BOOL GetCount( LPVOID* );
|
||
|
||
// Retrieve info about the current index in the user array
|
||
// as a .htr variable
|
||
// the index is specified by the bound CInetInfoConfigInfoMapper
|
||
// via the GetIter() function. Returns FALSE if invalid/out of range
|
||
|
||
BOOL GetName( LPVOID* );
|
||
|
||
BOOL GetAnonymous( LPVOID* );
|
||
|
||
BOOL GetAddr( LPVOID* );
|
||
|
||
BOOL GetTime( LPVOID* );
|
||
|
||
BOOL GetID( LPVOID* );
|
||
|
||
// same as GetID but as a DWORD
|
||
|
||
BOOL GetIDAsDWORD( LPDWORD );
|
||
|
||
// Get count of connected users as a DWORD
|
||
|
||
BOOL GetCountAsDWORD( LPDWORD );
|
||
|
||
private:
|
||
|
||
BOOL InsureLoaded();
|
||
|
||
private:
|
||
|
||
CInetInfoConfigInfoMapper* m_pMapper;
|
||
DWORD m_dwCount;
|
||
W3_USER_INFO *m_pUsers;
|
||
} ;
|
||
|
||
|
||
// Directory & drive list management
|
||
|
||
class CDriveView {
|
||
|
||
public:
|
||
|
||
CDriveView();
|
||
~CDriveView();
|
||
//
|
||
BOOL Init( CInetInfoConfigInfoMapper* );
|
||
|
||
BOOL Reset();
|
||
|
||
BOOL Entry( UINT i, UINT cMax, CDStr &dsList, PVOID pRes );
|
||
|
||
//
|
||
BOOL GenerateDirList( LPSTR pDir );
|
||
|
||
BOOL ValidateDir( LPSTR pDir );
|
||
|
||
BOOL CreateDir( LPSTR pPath, LPSTR pNewDir );
|
||
|
||
//
|
||
BOOL RootDir( LPSTR *pV )
|
||
{ *pV = m_achRootDir; return TRUE; }
|
||
|
||
BOOL BaseDir( LPSTR *pV )
|
||
{ *pV = m_achBaseDir; return TRUE; }
|
||
|
||
BOOL DirCount( LPDWORD *pV )
|
||
{ *pV = &m_cDirs; return TRUE; }
|
||
|
||
BOOL DirEntry( UINT i, LPVOID pV )
|
||
{ return Entry( i, m_cDirs, m_dsDirs, pV); }
|
||
|
||
BOOL DirCompCount( LPDWORD *pV )
|
||
{ *pV = &m_cComp; return TRUE; }
|
||
|
||
BOOL DirCompEntry( UINT i, LPVOID pV )
|
||
{ return Entry( i, m_cComp, m_dsComp, pV); }
|
||
|
||
BOOL DirFCompEntry( UINT i, LPVOID pV )
|
||
{ return Entry( i, m_cComp, m_dsFComp, pV); }
|
||
|
||
BOOL DriveCount( LPDWORD *pV )
|
||
{ *pV = &m_cDrives; return TRUE; }
|
||
|
||
BOOL DriveNameEntry( UINT i, LPVOID pV )
|
||
{ return Entry( i, m_cDrives, m_dsDriveName, pV); }
|
||
|
||
BOOL DriveLabelEntry( UINT i, LPVOID pV )
|
||
{ return Entry( i, m_cDrives, m_dsDriveLabel, pV); }
|
||
|
||
BOOL DriveTypeEntry( UINT i, LPVOID pV )
|
||
{ if (i < m_cDrives ) { *(LPDWORD*)pV
|
||
= (DWORD*)(m_dsDriveType.GetString()+sizeof(DWORD)*i);
|
||
return TRUE;} else return FALSE; }
|
||
|
||
private:
|
||
|
||
CInetInfoConfigInfoMapper* m_pMapper;
|
||
|
||
CDStr m_dsDirs;
|
||
CDStr m_dsDriveName;
|
||
CDStr m_dsDriveLabel;
|
||
CDStr m_dsDriveType; // as array of DWORD
|
||
CDStr m_dsComp;
|
||
CDStr m_dsFComp;
|
||
|
||
DWORD m_cDirs;
|
||
DWORD m_cDrives;
|
||
DWORD m_cComp;
|
||
char m_achRootDir[MAX_PATH];
|
||
char m_achBaseDir[MAX_PATH];
|
||
|
||
// cache info
|
||
DWORD m_dwCachedDrive;
|
||
time_t m_tmCacheExpire;
|
||
} ;
|
||
|
||
// expiration time for drive cache ( in second )
|
||
|
||
#define DRIVE_CACHE_EXPIRE 30
|
||
|
||
|
||
//
|
||
// Entry describing a service using its name and type
|
||
//
|
||
|
||
class CServType {
|
||
|
||
public:
|
||
|
||
LPSTR GetName() { return pszName; }
|
||
|
||
DWORD GetType() { return dwType; }
|
||
|
||
public:
|
||
|
||
LPSTR pszName;
|
||
DWORD dwType;
|
||
} ;
|
||
|
||
|
||
//
|
||
// Mapper between service names and types
|
||
//
|
||
|
||
class CServTypeEnum {
|
||
|
||
public:
|
||
|
||
CServType* GetServByName( LPSTR pName );
|
||
CServType* GetServByType( DWORD dwT );
|
||
} ;
|
||
|
||
|
||
class CInetInfoRequest;
|
||
|
||
//
|
||
// Provides access to all .htr variables
|
||
// Handles RPC access ( get/put )
|
||
// and provides set functions for non-RPC variables to make them
|
||
// accessible to a .htr script.
|
||
// Also handles !Functions
|
||
//
|
||
|
||
class CInetInfoConfigInfoMapper {
|
||
|
||
public:
|
||
|
||
CInetInfoConfigInfoMapper();
|
||
|
||
~CInetInfoConfigInfoMapper();
|
||
|
||
BOOL Init( CInetInfoMap*, int, DWORD );
|
||
|
||
DWORD GetType()
|
||
{ return m_dwCurrentServerType; }
|
||
|
||
LPWSTR GetComputerName()
|
||
{ return m_achComputerName; }
|
||
|
||
DWORD GetRPCStatus()
|
||
{ return m_dwRPCStatus; }
|
||
|
||
VOID SetRPCStatus( DWORD dwS )
|
||
{ m_dwRPCStatus = dwS; SetRPCStatusString(dwS); }
|
||
|
||
// return addr of HTMLA script variable
|
||
|
||
BOOL RequestStatus( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwRequestStatus; return TRUE; }
|
||
|
||
BOOL RPCStatus( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwRPCStatus; return TRUE; }
|
||
|
||
BOOL RPCStatusString( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszRPCStatusString; return TRUE; }
|
||
|
||
BOOL HttpStatus( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwHttpStatus; return TRUE; }
|
||
|
||
BOOL FtpStatus( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwFtpStatus; return TRUE; }
|
||
|
||
BOOL GopherStatus( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwGopherStatus; return TRUE; }
|
||
|
||
BOOL OSMajorVersion( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_OSVersion.dwMajorVersion; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL ) { *pV = (LPVOID)
|
||
&m_pServerCaps->MajorVersion; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwZero; return FALSE;} }
|
||
#endif
|
||
|
||
BOOL OSMinorVersion( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_OSVersion.dwMinorVersion; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL ) { *pV = (LPVOID)
|
||
&m_pServerCaps->MinorVersion; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwZero; return FALSE;} }
|
||
#endif
|
||
|
||
BOOL OSBuildNumber( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_OSVersion.dwBuildNumber; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL ) { *pV = (LPVOID)
|
||
&m_pServerCaps->BuildNumber; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwZero; return FALSE;} }
|
||
#endif
|
||
|
||
BOOL MajorVersion( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwMajorVersion; return TRUE; }
|
||
|
||
BOOL MinorVersion( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwMinorVersion; return TRUE; }
|
||
|
||
BOOL W3Version( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszW3Version; return TRUE; }
|
||
|
||
BOOL Cap1Flag( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_dwCap1Flag; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL && m_pServerCaps->NumCapFlags > 0)
|
||
{ *pV = (LPVOID)&m_pServerCaps->CapFlags[0].Flag; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwZero; return FALSE;} }
|
||
#endif
|
||
|
||
BOOL Cap1Mask( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_dwCap1Mask; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL && m_pServerCaps->NumCapFlags > 0)
|
||
{ *pV = (LPVOID)&m_pServerCaps->CapFlags[0].Mask; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwZero; return FALSE;} }
|
||
#endif
|
||
|
||
BOOL URLParam( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszURLParam; return TRUE; }
|
||
|
||
BOOL PlatformType( LPVOID *pV )
|
||
#if defined(IISv1)
|
||
{*pV = (LPVOID)&g_dwZero; return TRUE;}
|
||
#else
|
||
{ if ( m_pServerCaps != NULL )
|
||
{ *pV = (LPVOID)&m_pServerCaps->ProductType; return TRUE; }
|
||
else {*pV = (LPVOID)&g_dwOne; return TRUE;} }
|
||
#endif
|
||
|
||
BOOL ServName( LPVOID *pV );
|
||
|
||
BOOL ServIdx( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwCurrentServerType; return TRUE; }
|
||
|
||
BOOL Iter( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_iIter; return TRUE; }
|
||
|
||
BOOL ReqParam( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszReqParam; return TRUE; }
|
||
|
||
BOOL RemoteAddr( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszRemoteAddr; return TRUE; }
|
||
|
||
BOOL IPNullAddr( LPVOID *pV )
|
||
{ *pV = (LPVOID)&g_pszIPNullAddr; return TRUE; }
|
||
|
||
BOOL HostName( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszHostName; return TRUE; }
|
||
|
||
BOOL HtmlaPath( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszHtmlaPath; return TRUE; }
|
||
|
||
BOOL Arg1( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszArg1; return m_dwCurrentServerType == INET_DIR; }
|
||
|
||
BOOL Arg2( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszArg2; return m_dwCurrentServerType == INET_DIR; }
|
||
|
||
BOOL Arg3( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pszArg3; return m_dwCurrentServerType == INET_DIR; }
|
||
|
||
BOOL UserFlags( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_dwUserFlags; return TRUE; }
|
||
|
||
//
|
||
BOOL CommTimeout( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->dwConnectionTimeout;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL MaxConn( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->dwMaxConnections;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL AdminName( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpszAdminName;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL AdminEmail( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpszAdminEmail;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL ServerComment( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpszServerComment;
|
||
return TRUE;} else return FALSE; }
|
||
//
|
||
BOOL LogSrc( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpLogConfig->rgchDataSource;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL LogName( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpLogConfig->rgchTableName;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL LogUser( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpLogConfig->rgchUserName;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL LogPw( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV
|
||
= (LPVOID)&m_pConfig->lpLogConfig->rgchPassword;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL LogDir( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV = (LPVOID)
|
||
&m_pConfig->lpLogConfig->rgchLogFileDirectory;
|
||
return TRUE;} else return FALSE; }
|
||
//
|
||
BOOL LogAnonymous( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pConfig->fLogAnonymous;
|
||
return m_pConfig ? TRUE : FALSE; }
|
||
|
||
BOOL LogNonAnonymous( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pConfig->fLogNonAnonymous;
|
||
return m_pConfig ? TRUE : FALSE; }
|
||
|
||
BOOL AnonUserName( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pConfig->lpszAnonUserName;
|
||
return m_pConfig ? TRUE : FALSE; }
|
||
|
||
BOOL AnonUserPw( LPVOID *pV )
|
||
{ *pV = (LPVOID)m_pConfig->szAnonPassword;
|
||
return m_pConfig ? TRUE : FALSE; }
|
||
|
||
BOOL DirBrowseEnab( LPVOID *pV );
|
||
|
||
BOOL DefFileEnab( LPVOID *pV );
|
||
|
||
BOOL AuthAnon( LPVOID *pV );
|
||
|
||
BOOL AuthBasic( LPVOID *pV );
|
||
|
||
BOOL AuthNT( LPVOID *pV );
|
||
|
||
BOOL SPort( LPVOID *pV )
|
||
{ *pV = (LPVOID)&m_pConfig->sPort; return m_pConfig ? TRUE : FALSE; }
|
||
|
||
//
|
||
BOOL DenyIPCount( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV = m_pConfig->DenyIPList
|
||
? (LPVOID)&m_pConfig->DenyIPList->cEntries : (LPVOID)&g_dwZero;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL DenyIsIPSingle( LPVOID *pV );
|
||
|
||
BOOL DenyIPAddr( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->DenyIPList
|
||
&& m_iIter < m_pConfig->DenyIPList->cEntries )
|
||
{ *pV = (LPVOID)&m_pConfig->DenyIPList->aIPSecEntry[m_iIter].dwNetwork;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL DenyIPMask( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->DenyIPList
|
||
&& m_iIter < m_pConfig->DenyIPList->cEntries )
|
||
{ *pV = (LPVOID)&m_pConfig->DenyIPList->aIPSecEntry[m_iIter].dwMask;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GrantIPCount( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV = m_pConfig->GrantIPList
|
||
? (LPVOID)&m_pConfig->GrantIPList->cEntries : (LPVOID)&g_dwZero;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GrantIsIPSingle( LPVOID *pV );
|
||
|
||
BOOL GrantIPAddr( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->GrantIPList
|
||
&& m_iIter < m_pConfig->GrantIPList->cEntries ) { *pV
|
||
= (LPVOID)&m_pConfig->GrantIPList->aIPSecEntry[m_iIter].dwNetwork;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GrantIPMask( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->GrantIPList
|
||
&& m_iIter < m_pConfig->GrantIPList->cEntries ) { *pV
|
||
= (LPVOID)&m_pConfig->GrantIPList->aIPSecEntry[m_iIter].dwMask;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL IPDenyRef( LPVOID *pV );
|
||
|
||
BOOL IPGrantRef( LPVOID *pV );
|
||
|
||
BOOL IPRef( LPVOID *pV, INET_INFO_IP_SEC_LIST*, LPSTR* );
|
||
|
||
void AdjustFromIPSingle( LPBYTE );
|
||
|
||
void AdjustIPSingle( LPBYTE );
|
||
|
||
void InvalidateIPSingle() { m_dwIsIPSingle = 2; }
|
||
|
||
//
|
||
|
||
BOOL RootCount( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL ) { *pV = m_pConfig->VirtualRoots
|
||
? (LPVOID)&m_pConfig->VirtualRoots->cEntries : (LPVOID)&g_dwZero;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootName( LPVOID *pV );
|
||
|
||
BOOL RootAddr( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->VirtualRoots
|
||
&& m_iIter < m_pConfig->VirtualRoots->cEntries ) { *pV
|
||
= (LPVOID)&m_pConfig->VirtualRoots->aVirtRootEntry[m_iIter].pszAddress;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootDir( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->VirtualRoots
|
||
&& m_iIter < m_pConfig->VirtualRoots->cEntries ) { *pV =
|
||
(LPVOID)&m_pConfig->VirtualRoots->aVirtRootEntry[m_iIter].pszDirectory;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootAcctName( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->VirtualRoots
|
||
&& m_iIter < m_pConfig->VirtualRoots->cEntries ) { *pV = (LPVOID)
|
||
&m_pConfig->VirtualRoots->aVirtRootEntry[m_iIter].pszAccountName;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootAcctPw( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->VirtualRoots
|
||
&& m_iIter < m_pConfig->VirtualRoots->cEntries ) { *pV = (LPVOID)
|
||
m_pConfig->VirtualRoots->aVirtRootEntry[m_iIter].AccountPassword;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootError( LPVOID *pV )
|
||
{ if ( m_pConfig!=NULL && m_pConfig->VirtualRoots
|
||
&& m_iIter < m_pConfig->VirtualRoots->cEntries ) { *pV = (LPVOID)
|
||
&m_pConfig->VirtualRoots->aVirtRootEntry[m_iIter].dwError;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL RootIsHome( LPVOID *pV );
|
||
|
||
BOOL RootIsRead( LPVOID *pV );
|
||
|
||
BOOL RootIsWrite( LPVOID *pV );
|
||
|
||
BOOL RootIsExec( LPVOID *pV );
|
||
|
||
BOOL RootIsSSL( LPVOID *pV );
|
||
|
||
BOOL RootRef( LPVOID *pV );
|
||
|
||
BOOL SetRootEntryVars();
|
||
|
||
//
|
||
|
||
BOOL DefFile( LPVOID *pV )
|
||
{ if ( m_pW3Config!=NULL ) { *pV = (LPVOID)
|
||
&m_pW3Config->lpszDefaultLoadFile; return TRUE;} else return FALSE; }
|
||
|
||
BOOL SSIEnabled( LPVOID *pV )
|
||
{ if ( m_pW3Config!=NULL ) { *pV = (LPVOID)&m_pW3Config->fSSIEnabled;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL SSIExt( LPVOID *pV )
|
||
{ if ( m_pW3Config!=NULL ) { *pV = (LPVOID)
|
||
&m_pW3Config->lpszSSIExtension; return TRUE;} else return FALSE; }
|
||
|
||
BOOL CryptCapable( LPVOID *pV );
|
||
|
||
//
|
||
|
||
BOOL EnableLog( LPVOID *pV );
|
||
|
||
BOOL EnableNewLog( LPVOID *pV );
|
||
|
||
BOOL LogType( LPVOID *pV )
|
||
{ if ( m_pConfig!= NULL ) {*pV =
|
||
&m_pConfig->lpLogConfig->inetLogType; return TRUE;}
|
||
else return FALSE; }
|
||
|
||
BOOL LogSize( LPVOID *pV )
|
||
{ if ( m_pConfig!= NULL ) {*pV =
|
||
&m_pConfig->lpLogConfig->cbSizeForTruncation;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL LogPeriod( LPVOID *pV );
|
||
|
||
BOOL LogFormat( LPVOID *pV );
|
||
|
||
BOOL SetLogEntryVars();
|
||
|
||
BOOL InvalidLogUpdate( LPVOID *pV );
|
||
|
||
//
|
||
// Gopher variables
|
||
//
|
||
|
||
BOOL GopherSite( LPVOID *pV )
|
||
{ if ( m_pGdConfig!= NULL ) {*pV = &m_pGdConfig->lpszSite;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GopherOrg( LPVOID *pV )
|
||
{ if ( m_pGdConfig!= NULL ) {*pV = &m_pGdConfig->lpszOrganization;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GopherLoc( LPVOID *pV )
|
||
{ if ( m_pGdConfig!= NULL ) {*pV = &m_pGdConfig->lpszLocation;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GopherGeo( LPVOID *pV )
|
||
{ if ( m_pGdConfig!= NULL ) {*pV = &m_pGdConfig->lpszGeography;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL GopherLang( LPVOID *pV )
|
||
{ if ( m_pGdConfig!= NULL ) {*pV = &m_pGdConfig->lpszLanguage;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
// FTP variables
|
||
//
|
||
|
||
BOOL FTPIsAnon( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->fAllowAnonymous;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPIsGuest( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->fAllowGuestAccess;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPIsAnotDir( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->fAnnotateDirectories;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPIsAnonOnly( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->fAnonymousOnly;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPExitMsg( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->lpszExitMessage;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPGreetMsg( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->lpszGreetingMessage;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPHomeDir( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->lpszHomeDirectory;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
BOOL FTPMaxClMsg( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV =
|
||
&m_pFtpConfig->lpszMaxClientsMessage; return TRUE;}
|
||
else return FALSE; }
|
||
|
||
BOOL FTPIsMsdos( LPVOID *pV )
|
||
{ if ( m_pFtpConfig!= NULL ) {*pV = &m_pFtpConfig->fMsdosDirOutput;
|
||
return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
// User enumeration ( for all services )
|
||
//
|
||
|
||
BOOL UCount( LPVOID *pV )
|
||
{ return m_Users.GetCount( pV ); }
|
||
|
||
BOOL UName( LPVOID *pV )
|
||
{ return m_Users.GetName( pV ); }
|
||
|
||
BOOL UAnonymous( LPVOID *pV )
|
||
{ return m_Users.GetAnonymous( pV ); }
|
||
|
||
BOOL UAddr( LPVOID *pV )
|
||
{ return m_Users.GetAddr( pV ); }
|
||
|
||
BOOL UTime( LPVOID *pV )
|
||
{ return m_Users.GetTime( pV ); }
|
||
|
||
BOOL UID( LPVOID *pV )
|
||
{ return m_Users.GetID( pV ); }
|
||
|
||
//
|
||
// Global information
|
||
//
|
||
|
||
BOOL GlobalBandwidth( LPVOID *pV )
|
||
{ if ( m_pGlobalConfig!= NULL ) {*pV =
|
||
&m_pGlobalConfig->BandwidthLevel; return TRUE;} else return FALSE; }
|
||
|
||
BOOL GlobalCache( LPVOID *pV )
|
||
{ if ( m_pGlobalConfig!= NULL ) {*pV =
|
||
&m_pGlobalConfig->cbMemoryCacheSize; return TRUE;} else return FALSE; }
|
||
|
||
BOOL GlobalIsBandwidthLimited( LPVOID *pV );
|
||
|
||
//
|
||
// Directory browsing
|
||
//
|
||
// these functions are a shell around the m_Drive object
|
||
//
|
||
|
||
BOOL DirRootDir( LPVOID *pV )
|
||
{ return m_Drive.RootDir( (LPSTR*)(*pV = (LPVOID*)&m_pszRootDir ) ); }
|
||
|
||
BOOL DirBaseDir( LPVOID *pV )
|
||
{ return m_Drive.BaseDir( (LPSTR*)(*pV = (LPVOID*)&m_pszBaseDir ) ); }
|
||
|
||
BOOL DirCount( LPVOID *pV )
|
||
{ return m_Drive.DirCount( (LPDWORD*)pV ); }
|
||
|
||
BOOL DirEntry( LPVOID *pV )
|
||
{ return m_Drive.DirEntry( m_iIter, *pV = (LPVOID*)&m_pszDirEntry ); }
|
||
|
||
BOOL DirCompCount( LPVOID *pV )
|
||
{ return m_Drive.DirCompCount( (LPDWORD*)pV ); }
|
||
|
||
BOOL DirCompEntry( LPVOID *pV )
|
||
{ return m_Drive.DirCompEntry( m_iIter,
|
||
*pV = (LPVOID*)&m_pszDirCompEntry ); }
|
||
|
||
BOOL DirFCompEntry( LPVOID *pV )
|
||
{ return m_Drive.DirFCompEntry( m_iIter,
|
||
*pV = (LPVOID*)&m_pszDirFCompEntry ); }
|
||
|
||
BOOL DriveCount( LPVOID *pV )
|
||
{ return m_Drive.DriveCount( (LPDWORD*)pV ); }
|
||
|
||
BOOL DriveNameEntry( LPVOID *pV )
|
||
{ return m_Drive.DriveNameEntry( m_iIter,
|
||
*pV = (LPVOID*)&m_pszDriveNameEntry ); }
|
||
|
||
BOOL DriveLabelEntry( LPVOID *pV )
|
||
{ return m_Drive.DriveLabelEntry( m_iIter,
|
||
*pV = (LPVOID*)&m_pszDriveLabelEntry ); }
|
||
|
||
BOOL DriveTypeEntry( LPVOID *pV )
|
||
{ return m_Drive.DriveTypeEntry( m_iIter, pV ); }
|
||
|
||
//
|
||
// Function called to validate a HTMLA variable update.
|
||
// if return FALSE then update is invalidated, and a error condition
|
||
// will be generated at the HTMLA script level
|
||
//
|
||
// These functions have to set the relevant bit in the appropriate
|
||
// FieldControl of the various RPC structures in order to request
|
||
// the server to update its internal state.
|
||
//
|
||
|
||
BOOL UpdateCommTimeout()
|
||
{ if ( m_pConfig!=NULL ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_CONNECTION_TIMEOUT); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateMaxConn()
|
||
{ if ( m_pConfig!=NULL ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_MAX_CONNECTIONS); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateAdminName()
|
||
{ if ( m_pConfig!=NULL ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_ADMIN_NAME); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateAdminEmail()
|
||
{ if ( m_pConfig!=NULL ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_ADMIN_EMAIL); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateServerComment()
|
||
{ if ( m_pConfig!=NULL ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_SERVER_COMMENT); return TRUE;} else return FALSE; }
|
||
|
||
// Triggers error to indicates the associated variable
|
||
// should not be updated
|
||
|
||
BOOL DenyUpdate()
|
||
{ return FALSE; }
|
||
|
||
BOOL IgnoreUpdate()
|
||
{ return TRUE; }
|
||
|
||
BOOL UpdateLogAnonymous()
|
||
{ if ( m_pConfig ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_LOG_ANONYMOUS); return TRUE;} else return FALSE;}
|
||
|
||
BOOL UpdateLogNonAnonymous()
|
||
{ if ( m_pConfig ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_LOG_NONANONYMOUS); return TRUE;} else return FALSE;}
|
||
|
||
BOOL UpdateAnonUserName()
|
||
{ if ( m_pConfig ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_ANON_USER_NAME); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateAnonUserPw()
|
||
{ if ( m_pConfig ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_ANON_PASSWORD); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateSPort()
|
||
{ if ( m_pConfig ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_PORT_NUMBER); return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
|
||
BOOL UpdateDenyIsIPSingle();
|
||
|
||
BOOL UpdateGrantIsIPSingle();
|
||
|
||
BOOL UpdateIP()
|
||
{ if ( m_pConfig ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_SITE_SECURITY); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateDirControl();
|
||
|
||
BOOL UpdateRoot()
|
||
{ if ( m_pConfig ) { SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_VIRTUAL_ROOTS); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateRootName();
|
||
|
||
BOOL UpdateRootMask();
|
||
|
||
BOOL UpdateAuth();
|
||
|
||
BOOL UpdateLog();
|
||
|
||
BOOL UpdateNewLog();
|
||
|
||
BOOL UpdateLogType();
|
||
|
||
BOOL UpdateLogPeriod();
|
||
|
||
BOOL UpdateLogFormat();
|
||
|
||
BOOL UpdateLogSize();
|
||
|
||
BOOL UpdateLogInfo()
|
||
{ if ( m_pConfig!=NULL ) {SetField( m_pConfig->FieldControl,
|
||
FC_INET_INFO_ALL ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateLogFileInfo();
|
||
|
||
BOOL UpdateLogODBCInfo();
|
||
|
||
//
|
||
// W3 variables
|
||
//
|
||
|
||
BOOL UpdateDefFile()
|
||
{ if ( m_pW3Config!=NULL ) { SetField( m_pW3Config->FieldControl,
|
||
FC_W3_DEFAULT_LOAD_FILE ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateSSIEnabled()
|
||
{ if ( m_pW3Config!=NULL ) { SetField( m_pW3Config->FieldControl,
|
||
FC_W3_SSI_ENABLED ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateSSIExt()
|
||
{ if ( m_pW3Config!=NULL ) { SetField( m_pW3Config->FieldControl,
|
||
FC_W3_SSI_EXTENSION ); return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
// Gopher variables
|
||
//
|
||
|
||
BOOL UpdateGopherSite()
|
||
{ if ( m_pGdConfig!=NULL ) { SetField( m_pGdConfig->FieldControl,
|
||
GDA_SITE ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateGopherOrg()
|
||
{ if ( m_pGdConfig!=NULL ) { SetField( m_pGdConfig->FieldControl,
|
||
GDA_ORGANIZATION ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateGopherLoc()
|
||
{ if ( m_pGdConfig!=NULL ) { SetField( m_pGdConfig->FieldControl,
|
||
GDA_LOCATION ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateGopherGeo()
|
||
{ if ( m_pGdConfig!=NULL ) { SetField( m_pGdConfig->FieldControl,
|
||
GDA_GEOGRAPHY ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateGopherLang()
|
||
{ if ( m_pGdConfig!=NULL ) { SetField( m_pGdConfig->FieldControl,
|
||
GDA_LANGUAGE ); return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
// FTP variables
|
||
//
|
||
|
||
BOOL UpdateFTPIsAnon()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_ALLOW_ANONYMOUS ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPIsGuest()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_ALLOW_GUEST_ACCESS ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPIsAnotDir()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_ANNOTATE_DIRECTORIES ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPIsAnonOnly()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_ANONYMOUS_ONLY ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPExitMsg()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_EXIT_MESSAGE ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPGreetMsg()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_GREETING_MESSAGE ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPHomeDir()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_HOME_DIRECTORY ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPMaxClMsg()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_MAX_CLIENTS_MESSAGE ); return TRUE;} else return FALSE; }
|
||
|
||
BOOL UpdateFTPIsMsdos()
|
||
{ if ( m_pFtpConfig!=NULL ) { SetField( m_pFtpConfig->FieldControl,
|
||
FC_FTP_MSDOS_DIR_OUTPUT ); return TRUE;} else return FALSE; }
|
||
|
||
//
|
||
// Global configuration variables
|
||
//
|
||
|
||
BOOL UpdateGlobal()
|
||
{ if ( m_pGlobalConfig != NULL ) { SetField(
|
||
m_pGlobalConfig->FieldControl, FC_GINET_INFO_ALL ); return TRUE;}
|
||
else return FALSE; }
|
||
|
||
BOOL UpdateGlobalBandwidth();
|
||
|
||
BOOL UpdateGlobalIsBandwidthLimited();
|
||
|
||
//
|
||
// variables linked to current client request
|
||
//
|
||
|
||
void SetRequestStatus ( DWORD dwS )
|
||
{ m_dwRequestStatus = dwS; }
|
||
|
||
void SetReqParam( LPSTR pszP, CInetInfoRequest* pR, LPSTR pszPRaw )
|
||
{
|
||
m_pszReqParam = pszP;
|
||
m_piiR = pR;
|
||
m_pszReqParamRaw = pszPRaw;
|
||
}
|
||
|
||
DWORD GetRequestStatus ()
|
||
{ return m_dwRequestStatus; }
|
||
|
||
void SetURLParam( LPSTR pszP )
|
||
{ m_pszURLParam = pszP; }
|
||
|
||
BOOL SetRemoteAddr( LPSTR pR );
|
||
|
||
VOID SetUserFlags( DWORD dw ) { m_dwUserFlags = dw; }
|
||
|
||
//
|
||
// Structure management
|
||
//
|
||
|
||
BOOL GetCurrentConfig();
|
||
|
||
BOOL Update();
|
||
|
||
BOOL FreeInfo(); // based on SetField() info
|
||
|
||
LPVOID Alloc( DWORD );
|
||
|
||
void Lock( );
|
||
|
||
void UnLock( );
|
||
|
||
// Map a variable name to a variable descriptor
|
||
BOOL Map( LPBYTE pName, DWORD dwNameLen, CInetInfoMap** );
|
||
|
||
// return to be deleted depending on fFree
|
||
BOOL GetString( CInetInfoMap*, LPSTR *pResult, DWORD *pdwResLen,
|
||
BOOL *pfFree );
|
||
|
||
BOOL EscapeString( LPSTR *pResult, DWORD *pdwResLen,
|
||
BOOL fFree );
|
||
|
||
BOOL GetString( LPBYTE pName, DWORD dwNameLen, LPSTR *pResult,
|
||
DWORD *pdwResLen, BOOL *pfFree );
|
||
|
||
BOOL PutString( CInetInfoMap *pMap, LPSTR pSet );
|
||
|
||
void ResetIter()
|
||
{ m_iIter = 0; m_fInvEntry = TRUE; }
|
||
|
||
void IncIter()
|
||
{ ++m_iIter; m_fInvEntry = TRUE; }
|
||
|
||
void SetIter( DWORD dwI )
|
||
{ ++m_iIter = dwI; m_fInvEntry = TRUE; }
|
||
|
||
DWORD GetIter() { return m_iIter; }
|
||
|
||
BOOL GetFromMsgBody( LPSTR pName, DWORD dwNameLen, LPSTR *pResult,
|
||
DWORD *pdwResLen );
|
||
|
||
BOOL GetFromServer( LPSTR pName, DWORD dwNameLen, LPSTR *pResult,
|
||
DWORD *pdwResLen );
|
||
|
||
//
|
||
// HTMLA Verbs
|
||
//
|
||
|
||
//
|
||
// Directory management
|
||
//
|
||
|
||
BOOL GenerateDirList( LPSTR pV )
|
||
{ return m_Drive.GenerateDirList( pV ); }
|
||
|
||
BOOL ValidateDir( LPSTR pV )
|
||
{ return m_Drive.ValidateDir( pV ); }
|
||
|
||
BOOL CreateDir( LPSTR pV, LPSTR pV2 )
|
||
{ return m_Drive.CreateDir( pV, pV2 ); }
|
||
|
||
//
|
||
// IP access list management
|
||
//
|
||
|
||
BOOL AddIPAccess( BOOL );
|
||
|
||
BOOL DeleteIPAccess( BOOL, LPSTR pID );
|
||
|
||
BOOL PositionIPAccess( BOOL, LPSTR pID );
|
||
|
||
BOOL CloneIPAccesses( BOOL, BOOL fExtend, BOOL fDel, DWORD dwToDel );
|
||
|
||
BOOL SetIPAccessDefault( BOOL fIsDeny );
|
||
|
||
BOOL BuildIPUniqueID( LPSTR, INET_INFO_IP_SEC_ENTRY* );
|
||
|
||
//
|
||
// Virtual directories list management
|
||
//
|
||
|
||
BOOL AddVirtDir();
|
||
|
||
BOOL DeleteVirtDir( LPSTR pID );
|
||
|
||
BOOL PositionVirtDir( LPSTR pID );
|
||
|
||
BOOL CloneVirtDirs( BOOL fExtend, BOOL fDel, DWORD dwToDel );
|
||
|
||
BOOL BuildVirtDirUniqueID( LPSTR, INET_INFO_VIRTUAL_ROOT_ENTRY* );
|
||
|
||
BOOL VirtDirCmp( INET_INFO_VIRTUAL_ROOT_ENTRY* p1,
|
||
INET_INFO_VIRTUAL_ROOT_ENTRY* p2, BOOL );
|
||
|
||
BOOL HandleVirtDirRequest( LPSTR, LPSTR, int );
|
||
|
||
BOOL AliasVirtDir( INET_INFO_VIRTUAL_ROOT_ENTRY *pU );
|
||
|
||
//
|
||
// Disconnect User management
|
||
//
|
||
|
||
BOOL DisconnectUser( LPSTR );
|
||
|
||
BOOL DisconnectAll();
|
||
|
||
//
|
||
// Password management
|
||
//
|
||
|
||
BOOL ChangePassword();
|
||
|
||
//
|
||
BOOL GetStatus();
|
||
|
||
//
|
||
LPSTR IPToMultiByte( LPBYTE pB );
|
||
|
||
BOOL MultiByteToIP( LPSTR *pS, LPBYTE pB );
|
||
|
||
private:
|
||
|
||
void SetRPCStatusString(DWORD dwS); //should only be called from SetRPCStatus()
|
||
|
||
CInetInfoMap *m_pMap; // map name to member
|
||
int m_cNbMap;
|
||
CInetInfoRequest *m_piiR;
|
||
INET_INFO_GLOBAL_CONFIG_INFO *m_pGlobalConfig;
|
||
INET_INFO_CONFIG_INFO *m_pConfig; //
|
||
W3_CONFIG_INFO *m_pW3Config;
|
||
FTP_CONFIG_INFO *m_pFtpConfig;
|
||
GOPHERD_CONFIG_INFO *m_pGdConfig;
|
||
LPINET_INFO_CAPABILITIES m_pServerCaps;
|
||
CUserEnum m_Users;
|
||
DWORD m_dwCurrentServerType; // type of bind pConfig
|
||
DWORD m_dwUserFlags;
|
||
|
||
//
|
||
DWORD m_iIter; // index in iterated sub-struc
|
||
CRITICAL_SECTION m_csLock;
|
||
LPSTR m_pszURLParam;
|
||
LPSTR m_pszReqParamRaw;
|
||
DWORD m_dwRequestStatus;
|
||
DWORD m_dwRPCStatus;
|
||
LPTSTR m_pszRPCStatusString;
|
||
DWORD m_dwHttpStatus;
|
||
DWORD m_dwFtpStatus;
|
||
DWORD m_dwGopherStatus;
|
||
|
||
// memory allocation support for RPC structure update
|
||
CAllocNode *m_pFirstAlloc;
|
||
CAllocNode *m_pLastAlloc;
|
||
|
||
//
|
||
WCHAR m_achComputerName[MAX_COMPUTERNAME_LENGTH+1];
|
||
|
||
// virtual vars
|
||
BOOL m_DirBrowseEnab;
|
||
BOOL m_DefFileEnab;
|
||
BOOL m_fRootIsRead;
|
||
BOOL m_fRootIsWrite;
|
||
BOOL m_fRootIsExec;
|
||
BOOL m_fRootIsSSL;
|
||
BOOL m_fRootIsHome;
|
||
BOOL m_fAuthAnon;
|
||
BOOL m_fAuthBasic;
|
||
BOOL m_fAuthNT;
|
||
BOOL m_fEnableLog;
|
||
BOOL m_fEnableNewLog;
|
||
DWORD m_dwLogPeriod;
|
||
DWORD m_dwLogFormat;
|
||
LPSTR m_pDenyRef;
|
||
LPSTR m_pGrantRef;
|
||
LPSTR m_pRootRef;
|
||
LPSTR m_pszVarServName;
|
||
DWORD m_dwIsBandwidthLimited;
|
||
DWORD m_dwIsIPSingle;
|
||
LPSTR m_pszReqParam;
|
||
BOOL m_fInvEntry;
|
||
LPBYTE m_pRemoteAddr;
|
||
LPSTR m_pszRemoteAddr;
|
||
CHAR m_achHostName[MAX_DOMAIN_LENGTH + 1];
|
||
LPSTR m_pszHtmlaPath;
|
||
LPSTR m_pszHostName;
|
||
DWORD m_dwInvalidLogUpdate;
|
||
BOOL m_fLogFileUpdate;
|
||
BOOL m_fLogODBCUpdate;
|
||
DWORD m_dwWasLogPeriod;
|
||
DWORD m_dwWasLogType;
|
||
DWORD m_dwWasSizeForTruncation;
|
||
|
||
// directory browsing
|
||
CDriveView m_Drive;
|
||
DWORD m_dwDirCount;
|
||
DWORD m_dwDirCompCount;
|
||
DWORD m_dwDriveCount;
|
||
LPSTR m_pszRootDir;
|
||
LPSTR m_pszBaseDir;
|
||
LPSTR m_pszDirEntry;
|
||
LPSTR m_pszDirCompEntry;
|
||
LPSTR m_pszDirFCompEntry;
|
||
LPSTR m_pszDriveNameEntry;
|
||
LPSTR m_pszDriveLabelEntry;
|
||
LPSTR m_pszArg1;
|
||
LPSTR m_pszArg2;
|
||
LPSTR m_pszArg3;
|
||
|
||
//
|
||
DWORD m_dwCryptCapable;
|
||
BOOL m_fGotServerCapsAndVersion;
|
||
DWORD m_dwMajorVersion;
|
||
DWORD m_dwMinorVersion;
|
||
LPSTR m_pszW3Version;
|
||
|
||
//For dealing with RPC error strings
|
||
BOOL m_fAllocatedRPCStatusString;
|
||
TCHAR m_achRPCErrorCodeBuffer[MAX_ERROR_CODE_LENGTH];
|
||
|
||
|
||
} ;
|
||
|
||
|
||
// Description for an .htr variable
|
||
|
||
class CInetInfoMap {
|
||
|
||
public:
|
||
|
||
LPSTR pName;
|
||
|
||
INET_ELEM_TYPE iType;
|
||
|
||
BOOL (CInetInfoConfigInfoMapper::*GetAddr)(LPVOID*);
|
||
|
||
// called to indicate received update from client
|
||
BOOL (CInetInfoConfigInfoMapper::*UpdateIndication)();
|
||
|
||
DWORD dwParam; // type dependant, used as size for AWCHAR
|
||
} ;
|
||
|
||
|
||
//
|
||
// Dynamic buffer
|
||
//
|
||
|
||
class CExtBuff {
|
||
|
||
public:
|
||
|
||
CExtBuff::CExtBuff();
|
||
|
||
CExtBuff::~CExtBuff();
|
||
|
||
// Reset buffer : free memory, set length to 0
|
||
void Reset();
|
||
|
||
// Add a byte range
|
||
BOOL CopyBuff( LPBYTE pB, UINT cNb );
|
||
|
||
// Reserve a byte range, returns ptr to start of range
|
||
LPBYTE ReserveRange( UINT cNb )
|
||
{ Extend( cNb ); return m_pB+m_cCurrent; }
|
||
|
||
// Declare # of bytes consumed in the previously reserved range
|
||
void SkipRange( UINT cNb )
|
||
{ m_cCurrent += cNb; }
|
||
|
||
// Declare that a zero-delimited string worth of bytes
|
||
// was consumed in the previously reserved range
|
||
void SkipString() { m_cCurrent += lstrlen((char*)m_pB+m_cCurrent); }
|
||
|
||
// returns ptr to the buffer
|
||
LPBYTE GetPtr() { return m_pB; }
|
||
|
||
// returns length of the buffer
|
||
UINT GetLen() { return m_cCurrent; }
|
||
|
||
private:
|
||
|
||
BOOL Extend( UINT );
|
||
LPBYTE m_pB;
|
||
UINT m_cCurrent;
|
||
UINT m_cAlloc;
|
||
} ;
|
||
|
||
#define EXTBUFF_INCALLOC 4096
|
||
|
||
class CInetInfoVerbMap;
|
||
|
||
|
||
// Contains !Function execution context ( parameters )
|
||
|
||
class CVerbContext {
|
||
|
||
public:
|
||
|
||
CVerbContext();
|
||
|
||
~CVerbContext();
|
||
|
||
CInetInfoMap* GetInfoMap( DWORD dwI );
|
||
|
||
DWORD GetNbInfoMap()
|
||
{ return m_cNbInfoMap; }
|
||
|
||
LPSTR GetVerbName()
|
||
{ return m_pszVerbName; }
|
||
|
||
DWORD Parse( CInetInfoConfigInfoMapper*, LPBYTE, DWORD );
|
||
|
||
private:
|
||
|
||
BOOL AddInfoMap( CInetInfoMap* pI );
|
||
|
||
private:
|
||
|
||
LPSTR m_pszVerbName;
|
||
DWORD m_cNbInfoMap;
|
||
DWORD m_cAllocedInfoMap;
|
||
CInetInfoMap **m_pMaps;
|
||
} ;
|
||
|
||
|
||
//
|
||
// Information specific to a given HTTP request
|
||
// Handles data writes to the client
|
||
//
|
||
|
||
class CInetInfoRequest {
|
||
|
||
public:
|
||
|
||
CInetInfoRequest( EXTENSION_CONTROL_BLOCK*, CInetInfoConfigInfoMapper*,
|
||
LPSTR, LPSTR );
|
||
|
||
~CInetInfoRequest();
|
||
|
||
EXTENSION_CONTROL_BLOCK* GetECB()
|
||
{ return m_pECB; }
|
||
|
||
CInetInfoConfigInfoMapper* GetMapper()
|
||
{ return m_pMapper; }
|
||
|
||
LPSTR GetScr()
|
||
{ return m_pScr; }
|
||
|
||
LPSTR GetParam()
|
||
{ return m_pParam; }
|
||
|
||
LPSTR GetData()
|
||
{ return m_pData; }
|
||
|
||
LPSTR GetDataRaw()
|
||
{ return m_pDataRaw; }
|
||
|
||
CExtBuff* GetBuffer()
|
||
{ return &m_eb; }
|
||
|
||
BOOL Init( LPSTR, int );
|
||
|
||
DWORD Done();
|
||
|
||
void SetHTTPStatus( DWORD dwS )
|
||
{ m_dwHTTPStatus = dwS; }
|
||
|
||
LPSTR HTTPStatusStringFromCode();
|
||
|
||
LPWSTR AnsiToUnicode( LPSTR );
|
||
|
||
//
|
||
BOOL DoVerb( CVerbContext * );
|
||
|
||
LPSTR GetVarAsString( DWORD, BOOL* );
|
||
|
||
//
|
||
BOOL AddDenyIPAccess();
|
||
BOOL DeleteDenyIPAccess();
|
||
BOOL PositionDenyIPAccess();
|
||
BOOL DefaultIsDenyIPAccess();
|
||
BOOL AddGrantIPAccess();
|
||
BOOL DeleteGrantIPAccess();
|
||
BOOL PositionGrantIPAccess();
|
||
BOOL DefaultIsGrantIPAccess();
|
||
|
||
//
|
||
BOOL AddVirtDir();
|
||
BOOL DeleteVirtDir();
|
||
BOOL PositionVirtDir();
|
||
|
||
BOOL ChangePassword();
|
||
BOOL GetUserFlags();
|
||
|
||
BOOL SetHttpStatus();
|
||
|
||
// Default update function, no validation
|
||
BOOL Update();
|
||
|
||
// clear var
|
||
BOOL Clear();
|
||
|
||
//
|
||
BOOL DisconnectUser();
|
||
BOOL DisconnectAll();
|
||
|
||
//
|
||
BOOL GetStatus();
|
||
|
||
//
|
||
BOOL ValidateDir();
|
||
BOOL CreateDir();
|
||
BOOL GenerateDirList();
|
||
|
||
//
|
||
BOOL CheckForVirtDir();
|
||
BOOL AliasVirtDir();
|
||
BOOL HandleVirtDirRequest( int );
|
||
//
|
||
|
||
private:
|
||
|
||
EXTENSION_CONTROL_BLOCK *m_pECB;
|
||
CExtBuff m_eb; // for result
|
||
CInetInfoConfigInfoMapper *m_pMapper;
|
||
LPSTR m_pScr;
|
||
LPSTR m_pParam;
|
||
// request body
|
||
LPSTR m_pData;
|
||
DWORD m_dwDataLen;
|
||
|
||
LPSTR m_pDataRaw;
|
||
DWORD m_dwDataRawLen;
|
||
|
||
DWORD m_dwHTTPStatus;
|
||
//
|
||
CInetInfoVerbMap *m_apV;
|
||
UINT m_cV;
|
||
CVerbContext *m_pVerbContext;
|
||
LPSTR m_pHeader;
|
||
} ;
|
||
|
||
|
||
class CInetInfoVerbMap {
|
||
|
||
public:
|
||
|
||
LPSTR pszName;
|
||
|
||
BOOL (CInetInfoRequest::*pHandler)();
|
||
} ;
|
||
|
||
|
||
class CStatusStringAndCode
|
||
{
|
||
|
||
public:
|
||
|
||
DWORD dwStatus;
|
||
UINT dwID;
|
||
CHAR achStatus[128];
|
||
} ;
|
||
|
||
|
||
//
|
||
// Parse a .htr script, using a CInetInfoConfigInfoMapper object
|
||
// to access variables and !Functions
|
||
//
|
||
|
||
class CInetInfoMerger {
|
||
|
||
public:
|
||
|
||
CInetInfoMerger();
|
||
|
||
~CInetInfoMerger();
|
||
|
||
//
|
||
BOOL Init();
|
||
|
||
BOOL Merge( CInetInfoRequest* );
|
||
|
||
private:
|
||
|
||
BOOL GetToken( LPBYTE pVS, DWORD dwSize, LPBYTE* pStart, DWORD* dwL );
|
||
|
||
LPSTR AllocDup( CInetInfoConfigInfoMapper *pM, LPBYTE pDup, DWORD dwL );
|
||
|
||
CInetInfoMap *GetVarMap( CInetInfoConfigInfoMapper *pM,
|
||
LPBYTE pVS, DWORD dwSize );
|
||
} ;
|
||
|
||
|
||
class CInetInfoRequestMap;
|
||
|
||
|
||
// Map an incoming request to a CInetInfoConfigInfoMapper, then
|
||
// calls CInetInfoMerger
|
||
|
||
class CInetInfoDispatcher {
|
||
|
||
public:
|
||
|
||
CInetInfoDispatcher();
|
||
|
||
~CInetInfoDispatcher();
|
||
|
||
BOOL Init();
|
||
|
||
DWORD Invoke( EXTENSION_CONTROL_BLOCK* );
|
||
|
||
CInetInfoConfigInfoMapper* GetMapperFromString( LPSTR pszServ );
|
||
|
||
UINT GetNbH( VOID )
|
||
{ return m_cH; }
|
||
|
||
// Handle display for all screens
|
||
BOOL HandleDisplay( CInetInfoRequest* );
|
||
|
||
//
|
||
|
||
private:
|
||
|
||
// maintain mapper, merger
|
||
//
|
||
CInetInfoConfigInfoMapper m_MapperHTTP;
|
||
CInetInfoConfigInfoMapper m_MapperFTP;
|
||
CInetInfoConfigInfoMapper m_MapperGOPHER;
|
||
CInetInfoConfigInfoMapper m_MapperDNS;
|
||
|
||
CInetInfoConfigInfoMapper m_MapperDIR;
|
||
|
||
CInetInfoMerger m_IFMerger;
|
||
|
||
CInetInfoRequestMap *m_apH;
|
||
UINT m_cH;
|
||
} ;
|
||
|
||
|
||
class CInetInfoRequestMap {
|
||
|
||
public:
|
||
|
||
LPSTR pszName;
|
||
|
||
BOOL (CInetInfoDispatcher::*pHandler)(CInetInfoRequest*);
|
||
|
||
BOOL fIsStd;
|
||
} ;
|
||
|
||
|
||
//
|
||
// .htr expression handling
|
||
//
|
||
|
||
class CExpr {
|
||
|
||
public:
|
||
|
||
CExpr( CInetInfoConfigInfoMapper*pM )
|
||
{ m_pMap = pM; m_fMustFree = FALSE; m_pV = NULL; }
|
||
|
||
~CExpr()
|
||
{ if ( m_fMustFree ) delete [] m_pV; }
|
||
|
||
DWORD Get( LPBYTE, DWORD );
|
||
|
||
LPSTR GetAsStr()
|
||
{ return m_pV; }
|
||
|
||
DWORD GetAsDWORD();
|
||
|
||
INET_ELEM_TYPE GetType()
|
||
{ return m_iType; }
|
||
|
||
private:
|
||
|
||
CInetInfoConfigInfoMapper *m_pMap;
|
||
LPSTR m_pV;
|
||
DWORD m_dwV;
|
||
INET_ELEM_TYPE m_iType;
|
||
BOOL m_fMustFree;
|
||
} ;
|
||
|
||
|
||
//
|
||
// relational operator mapping for the CRelop class
|
||
//
|
||
|
||
enum RELOP_TYPE {
|
||
|
||
RELOP_INV, // invalid, must be present in front of array
|
||
RELOP_EQ, // equal
|
||
RELOP_NE, // not equal
|
||
RELOP_GT, // greater than
|
||
RELOP_LT, // less than
|
||
RELOP_GE, // greater or equal
|
||
RELOP_LE, // less or equal
|
||
RELOP_RF, // reference
|
||
RELOP_BA // bitwise AND
|
||
};
|
||
|
||
|
||
//
|
||
// .htr relational operator ( for %if constructs )
|
||
//
|
||
|
||
class CRelop {
|
||
|
||
public:
|
||
|
||
CRelop( )
|
||
{ m_iType = RELOP_INV; }
|
||
|
||
~CRelop()
|
||
{}
|
||
|
||
DWORD Get( LPBYTE, DWORD );
|
||
|
||
BOOL IsTrue( CExpr& v1, CExpr& v2, BOOL * pfValid );
|
||
|
||
private:
|
||
|
||
RELOP_TYPE m_iType;
|
||
} ;
|
||
|
||
BOOL
|
||
InlineFromTransparent(
|
||
LPBYTE pData,
|
||
DWORD *pdwDataLen,
|
||
BOOL
|
||
);
|
||
|
||
#endif
|
||
|