able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/iisrearc/inc/httpdef.h

1568 lines
37 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1998-2001 Microsoft Corporation
Module Name:
httpdef.h
Abstract:
This module contains basic HTTP protocol stack type definitions
shared between the user- and kernel-mode components.
Author:
Keith Moore (keithmo) 29-Jul-1998
Revision History:
Paul McDaniel (paulmcd) 15-Mar-1999
Added new response flags.
Chun Ye (chunye) 27-Sep-2000
Renamed UL_* to HTTP_*.
--*/
#ifndef _HTTPDEF_H_
#define _HTTPDEF_H_
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
//
// Forward references.
//
typedef struct _HTTP_RESPONSE *PHTTP_RESPONSE;
typedef struct _HTTP_DATA_CHUNK *PHTTP_DATA_CHUNK;
typedef struct _HTTP_SSL_INFO *PHTTP_SSL_INFO;
//
// Generic option flags. These apply to control channels and application
// pools.
//
// HTTP_OPTION_OVERLAPPED - Opens the object for asynchronous I/O.
//
// HTTP_OPTION_CONTROLLER - Opens the object that doesn't read data.
//
#define HTTP_OPTION_OVERLAPPED 0x00000001
#define HTTP_OPTION_CONTROLLER 0x00000002
#define HTTP_OPTION_VALID 0x00000003
//
// Flags for HttpReceiveHttpRequest().
//
// HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY - Specifies that the caller would like
// any available entity body to be copied along with the protocol headers
//
#define HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY 0x00000001
#define HTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODY 0x00000002
#define HTTP_RECEIVE_REQUEST_FLAG_VALID 0x00000003
//
// Flags for HttpSendHttpResponse() and HttpSendEntityBody().
//
// HTTP_SEND_RESPONSE_FLAG_DISCONNECT - Specifies that the network connection
// should be disconnected immediately after sending the response, overriding
// the HTTP protocol's persistent connection features.
//
// HTTP_SEND_RESPONSE_FLAG_MORE_DATA - Specifies that additional entity body
// data will be sent by the caller.
//
// HTTP_SEND_REPONSE_RAW_HEADER - Specifies that a caller of
// HttpSendEntityBody is intentionally omitting a call to
// HttpSendHttpResponse in order to bypass normal header processing. The
// actual HTTP header will be generated by the application and sent
// as entity body. This flag should be passed on the first call to
// HttpSendEntityBody, and not after.
//
#define HTTP_SEND_RESPONSE_FLAG_DISCONNECT 0x00000001
#define HTTP_SEND_RESPONSE_FLAG_MORE_DATA 0x00000002
#define HTTP_SEND_RESPONSE_FLAG_RAW_HEADER 0x00000004
#define HTTP_SEND_RESPONSE_FLAG_VALID 0x00000007
//
// Flags for HttpFlushResponseCache().
//
// HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE - Flushes the specified URL and all
// heirarchally related sub-URLs from the response cache.
//
#define HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE 0x00000001
#define HTTP_FLUSH_RESPONSE_FLAG_VALID 0x00000001
//
// Flags for HttpReceiveClientCertificate
//
// HTTP_RECEIVE_CLIENT_CERT_FLAG_MAP - Maps the client certificate to a token.
//
#define HTTP_RECEIVE_CLIENT_CERT_FLAG_MAP 0x00000001
#define HTTP_RECEIVE_CLIENT_CERT_FLAG_VALID 0x00000001
//
// Opaque identifiers for various kernel objects.
//
typedef ULONGLONG HTTP_OPAQUE_ID, *PHTTP_OPAQUE_ID;
typedef HTTP_OPAQUE_ID HTTP_REQUEST_ID, *PHTTP_REQUEST_ID;
typedef HTTP_OPAQUE_ID HTTP_CONNECTION_ID, *PHTTP_CONNECTION_ID;
typedef HTTP_OPAQUE_ID HTTP_CONFIG_GROUP_ID, *PHTTP_CONFIG_GROUP_ID;
typedef HTTP_OPAQUE_ID HTTP_RAW_CONNECTION_ID, *PHTTP_RAW_CONNECTION_ID;
#define HTTP_NULL_ID 0
#define HTTP_IS_NULL_ID(pid) (*(pid) == 0)
#define HTTP_SET_NULL_ID(pid) (*(pid) = 0)
//
// An opaque context for URLs in an configuration group.
//
typedef ULONGLONG HTTP_URL_CONTEXT;
//
// Network QOS stuff.
//
typedef ULONG HTTP_BANDWIDTH_LIMIT, *PHTTP_BANDWIDTH_LIMIT;
typedef ULONG HTTP_CONNECTION_LIMIT, *PHTTP_CONNECTION_LIMIT;
//
// Distinguished value for bandwidth and connection limits indicating
// "no limit".
//
#define HTTP_LIMIT_INFINITE (ULONG)-1L
//
// Enabled states. Used for configuration groups and the control channel.
//
typedef enum _HTTP_ENABLED_STATE
{
HttpEnabledStateActive,
HttpEnabledStateInactive,
HttpEnabledStateMaximum
} HTTP_ENABLED_STATE, *PHTTP_ENABLED_STATE;
//
// UTF8 Logging
//
typedef BOOLEAN HTTP_CONTROL_CHANNEL_UTF8_LOGGING, *PHTTP_CONTROL_CHANNEL_UTF8_LOGGING;
//
// Control channel query/set information classes used for the
// HttpQueryControlChannelInformation() and HttpSetControlChannelInformation()
// APIs.
//
typedef enum _HTTP_CONTROL_CHANNEL_INFORMATION_CLASS
{
//
// Query/set the master state.
//
// pControlChannelInformation points to a HTTP_ENABLED_STATE enum.
//
HttpControlChannelStateInformation,
//
// Query/set the default network bandwidth limit.
//
// pControlChannelInformation points to a HTTP_BANDWIDTH_LIMIT value.
//
HttpControlChannelBandwidthInformation,
//
// Query/set the default network connections limit.
//
// pControlChannelInformation points to a HTTP_CONNECTION_LIMIT value.
//
HttpControlChannelConnectionInformation,
//
// Set the HTTP response to be sent with either HTTP has been deactivated
// or in critically bad situations in which it is impossible to even
// determine which process should receive the request.
//
// pControlChannelInformation points to a HTTP_AUTO_RESPONSE structure.
//
// Note this cannot be queried.
//
HttpControlChannelAutoResponseInformation,
//
// Set the handle used to communicate with the Filter/SSL process.
//
// Note this cannot be queried.
//
HttpControlChannelFilterInformation,
//
// Set the global Connection Timeout information
//
// pControlChannelInformation points to a HTTP_CONTROL_CHANNEL_TIMEOUT_LIMIT structure.
//
HttpControlChannelTimeoutInformation,
//
// Set the UTF8 Logging property for all sites
//
// pControlChannelInformation points to a HTTP_CONTROL_CHANNEL_UTF8_LOGGING structure.
//
HttpControlChannelUTF8Logging,
HttpControlChannelMaximumInformation
} HTTP_CONTROL_CHANNEL_INFORMATION_CLASS, *PHTTP_CONTROL_CHANNEL_INFORMATION_CLASS;
//
// Default control channel property values.
//
#define HTTP_CONTROL_CHANNEL_STATE_DEFAULT HttpEnabledStateInactive
#define HTTP_CONTROL_CHANNEL_MAX_BANDWIDTH_DEFAULT HTTP_LIMIT_INFINITE
#define HTTP_CONTROL_CHANNEL_MAX_CONNECTIONS_DEFAULT HTTP_LIMIT_INFINITE
#define HTTP_CONTROL_CHANNEL_AUTO_RESPONSE_DEFAULT NULL
//
// Connection Timeout Limits structure for HttpControlChannelTimeoutInformation
//
typedef struct _HTTP_CONTROL_CHANNEL_TIMEOUT_LIMIT
{
ULONG ConnectionTimeout; // Seconds
ULONG HeaderWaitTimeout; // Seconds
ULONG MinFileKbSec; // Bytes/Seconds
} HTTP_CONTROL_CHANNEL_TIMEOUT_LIMIT, *PHTTP_CONTROL_CHANNEL_TIMEOUT_LIMIT;
//
// Application pool query/set information classes used for the
// HttpQueryAppPoolInformation() and HttpSetAppPoolInforamtion()
// APIs.
//
typedef enum _HTTP_APP_POOL_INFORMATION_CLASS
{
//
// Query/set the maximum number of processes for the specified
// application group. This value is typically 1 in the normal case
// and greater than 1 for Web Gardens.
//
// pAppPoolInformation points to a ULONG containing the maximum
// number of processes.
//
// NOTE: not used.
HttpAppPoolDemandStartInformation,
//
// Clears the demand start flag. This is part of the demand start
// handshake protocol used between the user- and kernel-mode
// components.
//
// pAppPoolInformation is unused.
//
// NOTE: not used.
HttpAppPoolDemandStartFlagInformation,
//
// Query/set the maximum number of queued new requests on
// the application pool.
//
// pAppPoolInformation points to a LONG containing the maximum
// number of queued requests.
//
HttpAppPoolQueueLengthInformation,
//
// Query/set the active state of the application pool.
//
// pAppPoolInformation points to a HTTP_ENABLED_STATE enum.
//
HttpAppPoolStateInformation,
HttpAppPoolMaximumInformation
} HTTP_APP_POOL_INFORMATION_CLASS, *PHTTP_APP_POOL_INFORMATION_CLASS;
//
// Configuration group query/set information classes use for the
// HttpQueryConfigGroupInformation() and HttpSetConfigGroupInformation()
// APIs.
//
typedef enum _HTTP_CONFIG_GROUP_INFORMATION_CLASS
{
//
// Query/set the current state of the configuration group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_STATE structure
// that receives the current state.
//
HttpConfigGroupStateInformation,
//
// Query/set the maximum network bandwidth allowed for the configuration
// group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_MAX_BANDWIDTH
// structure specifying the maximum bytes per second allowed for the
// contiainer.
//
HttpConfigGroupBandwidthInformation,
//
// Query/set the maximum network connections allowed for the
// configuration group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_MAX_CONNECTIONS
// structure containing the maximum number of network connections
// allowed for the container.
//
HttpConfigGroupConnectionInformation,
//
// Set the response to be sent when the configuration group is
// in a nonresponsive state.
//
// pConfigGroupInformation points to a HTTP_AUTO_RESPONSE
// structure.
//
// Note this cannot be queried.
//
HttpConfigGroupAutoResponseInformation,
//
// Set the application pool associated with the configuration
// group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_APP_POOL
// structure containing the HANDLE of the application pool to
// associate.
//
HttpConfigGroupAppPoolInformation,
//
// Set the cache size associated with the configuration
// group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_APP_POOL
// structure containing the HANDLE of the application pool to
// associate.
//
HttpConfigGroupCacheSizeInformation,
//
// Set the security descriptor associated with the configuration
// group. This security descriptor is used to control the
// creation of transient URL registrations beneath the
// configuration group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_SECURITY
// structure.
//
// Note this cannot be queried.
//
HttpConfigGroupSecurityInformation,
//
// Set the logging related config settings.
// This allows WAS to supply logging config as a config group
// setting group.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_LOGGING
// structure.
//
// Note this cannot be queried.
//
HttpConfigGroupLogInformation,
//
// Set this information only on the root config object for the
// site.
//
// pConfigGroupInformation points to a HTTP_CONFIG_GROUP_SITE
// structure.
//
HttpConfigGroupSiteInformation,
//
// Set this information only on the root config object for the
// site.
//
// pConfigGroupInformation points to a DWORD that contains
// the ConnectionTimeout value (in seconds)
//
HttpConfigGroupConnectionTimeoutInformation,
#if DBG
//
// Private for dev testing only.
//
HttpConfigGroupGetUrlInfo,
HttpConfigGroupFreeUrlInfo,
HttpConfigGroupUrlStaleTest,
//
// End private dev testing only.
//
#endif
HttpConfigGroupMaximumInformation
} HTTP_CONFIG_GROUP_INFORMATION_CLASS, *PHTTP_CONFIG_GROUP_INFORMATION_CLASS;
//
// Generic configuration group property flags. Each structure defining a
// property value must contain an element of this type.
//
typedef struct _HTTP_PROPERTY_FLAGS
{
ULONG_PTR Present:1;
} HTTP_PROPERTY_FLAGS, *PHTTP_PROPERTY_FLAGS;
//
// Individual property values.
//
typedef struct _HTTP_CONFIG_GROUP_STATE
{
HTTP_PROPERTY_FLAGS Flags;
HTTP_ENABLED_STATE State;
} HTTP_CONFIG_GROUP_STATE, *PHTTP_CONFIG_GROUP_STATE;
typedef struct _HTTP_CONFIG_GROUP_MAX_BANDWIDTH
{
HTTP_PROPERTY_FLAGS Flags;
HTTP_BANDWIDTH_LIMIT MaxBandwidth;
} HTTP_CONFIG_GROUP_MAX_BANDWIDTH, *PHTTP_CONFIG_GROUP_MAX_BANDWIDTH;
typedef struct _HTTP_CONFIG_GROUP_MAX_CONNECTIONS
{
HTTP_PROPERTY_FLAGS Flags;
HTTP_CONNECTION_LIMIT MaxConnections;
} HTTP_CONFIG_GROUP_MAX_CONNECTIONS, *PHTTP_CONFIG_GROUP_MAX_CONNECTIONS;
typedef struct _HTTP_AUTO_RESPONSE
{
HTTP_PROPERTY_FLAGS Flags;
PHTTP_RESPONSE pResponse;
ULONG EntityChunkCount;
PHTTP_DATA_CHUNK pEntityChunks;
} HTTP_AUTO_RESPONSE, *PHTTP_AUTO_RESPONSE;
typedef struct _HTTP_CONTROL_CHANNEL_FILTER
{
HTTP_PROPERTY_FLAGS Flags;
HANDLE FilterHandle;
BOOLEAN FilterOnlySsl;
} HTTP_CONTROL_CHANNEL_FILTER, *PHTTP_CONTROL_CHANNEL_FILTER;
typedef struct _HTTP_CONFIG_GROUP_APP_POOL
{
HTTP_PROPERTY_FLAGS Flags;
HANDLE AppPoolHandle;
} HTTP_CONFIG_GROUP_APP_POOL, *PHTTP_CONFIG_GROUP_APP_POOL;
typedef struct _HTTP_CONFIG_GROUP_CACHE_SIZE
{
HTTP_PROPERTY_FLAGS Flags;
ULONG CacheSize;
} HTTP_CONFIG_GROUP_CACHE_SIZE, *PHTTP_CONFIG_GROUP_CACHE_SIZE;
typedef struct _HTTP_CONFIG_GROUP_SECURITY
{
HTTP_PROPERTY_FLAGS Flags;
PSECURITY_DESCRIPTOR pSecurityDescriptor;
} HTTP_CONFIG_GROUP_SECURITY, *PHTTP_CONFIG_GROUP_SECURITY;
typedef enum _HTTP_LOGGING_TYPE
{
HttpLoggingTypeW3C,
HttpLoggingTypeIIS,
HttpLoggingTypeNCSA,
HttpLoggingTypeMaximum
} HTTP_LOGGING_TYPE, *PHTTP_LOGGING_TYPE;
typedef enum _HTTP_LOGGING_PERIOD
{
HttpLoggingPeriodMaxSize = 0,
HttpLoggingPeriodDaily = 1,
HttpLoggingPeriodWeekly = 2,
HttpLoggingPeriodMonthly = 3,
HttpLoggingPeriodHourly = 4,
HttpLoggingPeriodMaximum
} HTTP_LOGGING_PERIOD, *PHTTP_LOGGING_PERIOD;
typedef struct _HTTP_CONFIG_GROUP_LOGGING
{
//
// To indicate if this property exist or not
// in the config group
//
HTTP_PROPERTY_FLAGS Flags;
//
// This is field?s counterpart in the metabase is
// LogType
//
BOOLEAN LoggingEnabled;
//
// Indicates the Logging Format
//
HTTP_LOGGING_TYPE LogFormat;
//
// Indicates the exact directory where the log file
// will be written to for a site.
//
UNICODE_STRING LogFileDir;
//
// HTTP does not keep the site name information.
// WAS should pass down this. E.g. "W3SVC1"
//
UNICODE_STRING SiteName;
//
// Log Period in terms of
// 0 = MAX SIZE, 1 = DAILY, 2 = WEEKLY,
// 3 = MONTHLY, 4 = HOURLY
//
ULONG LogPeriod;
//
// Indicates the max size,in bytes,after which the
// log file should be rotated. A value of -1
// (HTTP_LIMIT_INFINITE) indicates unlimited size.
//
ULONG LogFileTruncateSize;
//
// A bit mask indicating which fields to log when
// LogFormat is set to W3C Extended
//
ULONG LogExtFileFlags;
//
// If this has been set then we recycle log files
// based on the local time for this site. Default
// should be FALSE.
//
BOOLEAN LocaltimeRollover;
} HTTP_CONFIG_GROUP_LOGGING, *PHTTP_CONFIG_GROUP_LOGGING;
//
// HTTP_CONFIG_GROUP_SITE
//
typedef struct _HTTP_CONFIG_GROUP_SITE
{
ULONG SiteId;
} HTTP_CONFIG_GROUP_SITE, *PHTTP_CONFIG_GROUP_SITE;
//
// This structure holds all the necessary Logging Info,
// And pushed down by User (Worker Process) with
// Sendresponse or SendEntityBody Ioctls.
//
typedef struct _HTTP_LOG_FIELDS_DATA
{
USHORT UserNameLength;
USHORT UriStemLength;
USHORT ClientIpLength;
USHORT ServerNameLength;
USHORT ServiceNameLength;
USHORT ServerIpLength;
USHORT MethodLength;
USHORT UriQueryLength;
USHORT HostLength;
USHORT UserAgentLength;
USHORT CookieLength;
USHORT ReferrerLength;
PWSTR UserName;
PWSTR UriStem;
PSTR ClientIp;
PSTR ServerName;
PSTR ServiceName;
PSTR ServerIp;
PSTR Method;
PSTR UriQuery;
PSTR Host;
PSTR UserAgent;
PSTR Cookie;
PSTR Referrer;
ULONG ServerPort;
ULONG ProtocolStatus;
ULONG Win32Status;
} HTTP_LOG_FIELDS_DATA, *PHTTP_LOG_FIELDS_DATA;
#if DBG
//
// Private for dev testing only.
//
typedef struct _HTTP_CONFIG_GROUP_DBG_URL_INFO
{
UNICODE_STRING Url; // IN
HTTP_ENABLED_STATE CurrentState; // OUT
HTTP_BANDWIDTH_LIMIT MaxBandwidth; // OUT
HTTP_CONNECTION_LIMIT MaxConnections; // OUT
HTTP_URL_CONTEXT UrlContext; // OUT
PVOID pReserved; // OUT
BOOLEAN Stale; // OUT
} HTTP_CONFIG_GROUP_DBG_URL_INFO, *PHTTP_CONFIG_GROUP_DBG_URL_INFO;
//
// End private dev testing only.
//
#endif
//
// This structure defines a file byte range.
//
// If the StartingOffset field is HTTP_BYTE_RANGE_TO_EOF (see below) then
// the last Length bytes of the file are sent.
//
// If the Length field is HTTP_BYTE_RANGE_TO_EOF then the remainder of the
// file (everything after StartingOffset) is sent.
//
typedef struct _HTTP_BYTE_RANGE
{
LARGE_INTEGER StartingOffset;
LARGE_INTEGER Length;
} HTTP_BYTE_RANGE, *PHTTP_BYTE_RANGE;
#define HTTP_BYTE_RANGE_TO_EOF ((ULONGLONG)-1)
//
// The type for version numbers.
//
typedef struct _HTTP_VERSION
{
USHORT MajorVersion;
USHORT MinorVersion;
} HTTP_VERSION, *PHTTP_VERSION;
//
// Some useful macros for version manipulation.
//
#define HTTP_VERSION_UNKNOWN { 0, 0 }
#define HTTP_VERSION_0_9 { 0, 9 }
#define HTTP_VERSION_1_0 { 1, 0 }
#define HTTP_VERSION_1_1 { 1, 1 }
#define HTTP_SET_VERSION(version, major, minor) \
{ \
(version).MajorVersion = (major); \
(version).MinorVersion = (minor); \
}
#define HTTP_EQUAL_VERSION(version, major, minor) \
((version).MajorVersion == (major) && \
(version).MinorVersion == (minor))
#define HTTP_GREATER_VERSION(version, major, minor) \
((version).MajorVersion > (major) || \
((version).MajorVersion == (major) && \
(version).MinorVersion > (minor)))
#define HTTP_LESS_VERSION(version, major, minor) \
((version).MajorVersion < (major) || \
((version).MajorVersion == (major) && \
(version).MinorVersion < (minor)))
#define HTTP_NOT_EQUAL_VERSION(version, major, minor) \
(!HTTP_EQUAL_VERSION(version, major, minor))
#define HTTP_GREATER_EQUAL_VERSION(version, major, minor) \
(!HTTP_LESS_VERSION(version, major, minor))
#define HTTP_LESS_EQUAL_VERSION(version, major, minor) \
(!HTTP_GREATER_VERSION(version, major, minor))
//
// The enum type for HTTP verbs.
//
typedef enum _HTTP_VERB
{
HttpVerbUnparsed,
HttpVerbUnknown,
HttpVerbInvalid,
HttpVerbOPTIONS,
HttpVerbGET,
HttpVerbHEAD,
HttpVerbPOST,
HttpVerbPUT,
HttpVerbDELETE,
HttpVerbTRACE,
HttpVerbCONNECT,
HttpVerbTRACK, // used by wolf-pack for a non-logged trace
HttpVerbMOVE,
HttpVerbCOPY,
HttpVerbPROPFIND,
HttpVerbPROPPATCH,
HttpVerbMKCOL,
HttpVerbLOCK,
HttpVerbUNLOCK,
HttpVerbSEARCH,
HttpVerbMaximum
} HTTP_VERB, *PHTTP_VERB;
//
// Symbols for all HTTP/1.1 headers and other tokens. Notice request +
// response values overlap. Make sure you know which type of header array
// you are indexing.
//
// These values are used as offsets into arrays and as token values in
// HTTP_KNOWN_HEADER.
//
typedef enum _HTTP_HEADER_ID
{
HttpHeaderCacheControl = 0, // general-header [section 4.5]
HttpHeaderConnection , // general-header [section 4.5]
HttpHeaderDate , // general-header [section 4.5]
HttpHeaderKeepAlive , // general-header [not in rfc]
HttpHeaderPragma , // general-header [section 4.5]
HttpHeaderTrailer , // general-header [section 4.5]
HttpHeaderTransferEncoding , // general-header [section 4.5]
HttpHeaderUpgrade , // general-header [section 4.5]
HttpHeaderVia , // general-header [section 4.5]
HttpHeaderWarning = 9, // general-header [section 4.5]
HttpHeaderAllow = 10, // entity-header [section 7.1]
HttpHeaderContentLength , // entity-header [section 7.1]
HttpHeaderContentType , // entity-header [section 7.1]
HttpHeaderContentEncoding , // entity-header [section 7.1]
HttpHeaderContentLanguage , // entity-header [section 7.1]
HttpHeaderContentLocation , // entity-header [section 7.1]
HttpHeaderContentMd5 , // entity-header [section 7.1]
HttpHeaderContentRange , // entity-header [section 7.1]
HttpHeaderExpires , // entity-header [section 7.1]
HttpHeaderLastModified = 19, // entity-header [section 7.1]
HttpHeaderAccept = 20, // request-header [section 5.3]
HttpHeaderAcceptCharset , // request-header [section 5.3]
HttpHeaderAcceptEncoding , // request-header [section 5.3]
HttpHeaderAcceptLanguage , // request-header [section 5.3]
HttpHeaderAuthorization , // request-header [section 5.3]
HttpHeaderCookie , // request-header [not in rfc] // 25
HttpHeaderExpect , // request-header [section 5.3]
HttpHeaderFrom , // request-header [section 5.3]
HttpHeaderHost , // request-header [section 5.3]
HttpHeaderIfMatch , // request-header [section 5.3]
HttpHeaderIfModifiedSince , // request-header [section 5.3] // 30
HttpHeaderIfNoneMatch , // request-header [section 5.3]
HttpHeaderIfRange , // request-header [section 5.3]
HttpHeaderIfUnmodifiedSince , // request-header [section 5.3]
HttpHeaderMaxForwards , // request-header [section 5.3]
HttpHeaderProxyAuthorization , // request-header [section 5.3] // 35
HttpHeaderReferer , // request-header [section 5.3]
HttpHeaderRange , // request-header [section 5.3]
HttpHeaderTe , // request-header [section 5.3]
HttpHeaderTranslate , // request-header [webDAV, not in rfc 2518]
HttpHeaderUserAgent = 40, // request-header [section 5.3] // 40
HttpHeaderRequestMaximum = 41,
HttpHeaderAcceptRanges = 20, // response-header [section 6.2]
HttpHeaderAge , // response-header [section 6.2]
HttpHeaderEtag , // response-header [section 6.2]
HttpHeaderLocation , // response-header [section 6.2]
HttpHeaderProxyAuthenticate , // response-header [section 6.2]
HttpHeaderRetryAfter , // response-header [section 6.2]
HttpHeaderServer , // response-header [section 6.2]
HttpHeaderSetCookie , // response-header [not in rfc]
HttpHeaderVary , // response-header [section 6.2]
HttpHeaderWwwAuthenticate = 29, // response-header [section 6.2]
HttpHeaderResponseMaximum = 30,
HttpHeaderMaximum = 41
} HTTP_HEADER_ID, *PHTTP_HEADER_ID;
//
// Structure defining format of known header.
//
typedef struct _HTTP_KNOWN_HEADER
{
//
// raw value
//
USHORT RawValueLength; // in bytes not including the NULL
PSTR pRawValue;
} HTTP_KNOWN_HEADER, *PHTTP_KNOWN_HEADER;
//
// Structure defining format of unknown header.
//
typedef struct _HTTP_UNKNOWN_HEADER
{
USHORT NameLength; // in bytes not including the NULL
USHORT RawValueLength; // in bytes not including the NULL
//
// The header name (minus the ':' character)
//
PSTR pName;
//
// The header value
//
PSTR pRawValue;
} HTTP_UNKNOWN_HEADER, *PHTTP_UNKNOWN_HEADER;
//
// This enum defines a data source for a particular chunk of data.
//
typedef enum _HTTP_DATA_CHUNK_TYPE
{
HttpDataChunkFromMemory,
HttpDataChunkFromFileName,
HttpDataChunkFromFileHandle,
HttpDataChunkMaximum
} HTTP_DATA_CHUNK_TYPE, *PHTTP_DATA_CHUNK_TYPE;
//
// This structure describes an individual data chunk.
//
typedef struct _HTTP_DATA_CHUNK
{
//
// The type of this data chunk.
//
HTTP_DATA_CHUNK_TYPE DataChunkType;
//
// The data chunk structures, one per supported data chunk type.
//
union
{
//
// From memory data chunk.
//
struct
{
PVOID pBuffer;
ULONG BufferLength;
} FromMemory;
//
// From filename data chunk.
//
struct
{
HTTP_BYTE_RANGE ByteRange;
USHORT FileNameLength; // in bytes not including the NULL
PCWSTR pFileName;
} FromFileName;
//
// From file handle data chunk.
//
struct
{
HTTP_BYTE_RANGE ByteRange;
HANDLE FileHandle;
} FromFileHandle;
};
} HTTP_DATA_CHUNK, *PHTTP_DATA_CHUNK;
//
// The enum type for HTTP request reasons.
//
typedef enum _HTTP_REQUEST_REASON
{
HttpReasonResponseCacheMiss,
HttpReasonFileHandleCacheMiss,
HttpReasonCachePolicy,
HttpReasonCacheSecurity,
HttpReasonClientDisconnect,
HttpReasonMaximum
} HTTP_REQUEST_REASON, *PHTTP_REQUEST_REASON;
//
// Structure defining format of request headers.
//
typedef struct _HTTP_REQUEST_HEADERS
{
//
// The array of unknown HTTP headers and the number of
// entries in the array.
//
ULONG UnknownHeaderCount;
PHTTP_UNKNOWN_HEADER pUnknownHeaders;
//
// Known headers.
//
HTTP_KNOWN_HEADER pKnownHeaders[HttpHeaderRequestMaximum];
} HTTP_REQUEST_HEADERS, *PHTTP_REQUEST_HEADERS;
//
// Structure defining format of request headers.
//
typedef struct _HTTP_RESPONSE_HEADERS
{
//
// The array of unknown HTTP headers and the number of
// entries in the array.
//
ULONG UnknownHeaderCount;
PHTTP_UNKNOWN_HEADER pUnknownHeaders;
//
// Known headers.
//
HTTP_KNOWN_HEADER pKnownHeaders[HttpHeaderResponseMaximum];
} HTTP_RESPONSE_HEADERS, *PHTTP_RESPONSE_HEADERS;
//
// Network address definitions.
//
#define HTTP_NETWORK_ADDRESS_TYPE_IPV4 0
typedef struct _HTTP_NETWORK_ADDRESS_IPV4
{
ULONG IpAddress;
USHORT Port;
USHORT Spare; // for alignment
} HTTP_NETWORK_ADDRESS_IPV4, *PHTTP_NETWORK_ADDRESS_IPV4;
//
// Structure defining format of transport address.
//
typedef struct _HTTP_TRANSPORT_ADDRESS
{
USHORT RemoteAddressLength; // sizeof(HTTP_NETWORK_ADDRESS_xxx)
USHORT RemoteAddressType; // HTTP_NETWORK_ADDRESS_TYPE_xxx
USHORT LocalAddressLength; // sizeof(HTTP_NETWORK_ADDRESS_xxx)
USHORT LocalAddressType; // HTTP_NETWORK_ADDRESS_TYPE_xxx
PVOID pRemoteAddress; // points to a HTTP_NETWORK_ADDRESS_xxx
PVOID pLocalAddress; // points to a HTTP_NETWORK_ADDRESS_xxx
} HTTP_TRANSPORT_ADDRESS, *PHTTP_TRANSPORT_ADDRESS;
//
// Structure defining format of cooked URL.
//
typedef struct _HTTP_COOKED_URL
{
//
// Pointers overlap and point into pFullUrl. NULL if not present.
//
USHORT FullUrlLength; // in bytes not including the NULL
USHORT HostLength; // in bytes not including the NULL
USHORT AbsPathLength; // in bytes not including the NULL
USHORT QueryStringLength; // in bytes not including the NULL
PWSTR pFullUrl; // points to "http://...."
PWSTR pHost; // points to the first char in the hostname
PWSTR pAbsPath; // Points to the 3rd '/' char
PWSTR pQueryString; // Points to the 1st '?' char
} HTTP_COOKED_URL, *PHTTP_COOKED_URL;
//
// The structure of an HTTP request.
//
typedef struct _HTTP_REQUEST
{
//
// An opaque request identifier. These values are used by the driver
// to correlate outgoing responses with incoming requests.
//
HTTP_CONNECTION_ID ConnectionId;
HTTP_REQUEST_ID RequestId;
//
// The context associated with the URL prefix.
//
HTTP_URL_CONTEXT UrlContext;
//
// The HTTP version number.
//
HTTP_VERSION Version;
//
// The request verb.
//
HTTP_VERB Verb;
//
// An indication of the reason the request was issued to/from user-mode.
//
HTTP_REQUEST_REASON Reason;
//
// The pointer and length of the verb string if the Verb field is
// HttpVerbUnknown.
//
//
// The pointer and length of the raw URL.
//
USHORT UnknownVerbLength; // in bytes not including the NULL
USHORT RawUrlLength; // in bytes not including the NULL
PSTR pUnknownVerb;
PSTR pRawUrl;
//
// The pointers and length of the canonicalized URL and parts.
//
HTTP_COOKED_URL CookedUrl;
//
// Transport addresses for the connection.
//
HTTP_TRANSPORT_ADDRESS Address;
//
// The request headers.
//
HTTP_REQUEST_HEADERS Headers;
//
// The total number of bytes received from network for this request.
//
ULONGLONG BytesReceived;
//
// 1 if there is more entity body to be read or written for this request.
// 0 if there is no entity body or all of the entity body was copied into
// pEntityChunks.
//
ULONG MoreEntityBodyExists:1;
//
// The pointer and length of any copied entity body. Entity body is only
// copied if HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY is passed to receive.
//
ULONG EntityChunkCount;
PHTTP_DATA_CHUNK pEntityChunks;
//
// SSL connection information.
//
HTTP_RAW_CONNECTION_ID RawConnectionId;
PHTTP_SSL_INFO pSslInfo;
} HTTP_REQUEST, *PHTTP_REQUEST;
//
// This structure describes an HTTP response.
//
typedef struct _HTTP_RESPONSE
{
//
// Response flags (see HTTP_RESPONSE_FLAG_* definitions below).
//
USHORT Flags;
//
// The raw HTTP version number. Used by client side API only.
//
HTTP_VERSION Version;
//
// The HTTP status code (e.g. 200).
//
USHORT StatusCode;
//
// The HTTP reason (e.g. "OK") . This is a unicode string for convenience,
// but MUST not contain non-ascii characters.
//
ULONG ReasonLength; // in bytes not including the NULL
PSTR pReason;
//
// The response headers.
//
HTTP_RESPONSE_HEADERS Headers;
//
// 1 if there is more entity body to be read or written for this response.
// 0 if there is no entity body or all of the entity body was copied into
// pEntityChunks.
//
ULONG MoreEntityBodyExists:1;
//
// The pointer and length of any entity body.
//
ULONG EntityChunkCount;
PHTTP_DATA_CHUNK pEntityChunks;
} HTTP_RESPONSE, *PHTTP_RESPONSE;
//
// Flags for HTTP_RESPONSE_FLAGS.
//
// HTTP_RESPONSE_FLAG_CALC_CONTENT_LENGTH - The content length is
// calculated by summing the length of all entity body data chunks.
//
// HTTP_RESPONSE_FLAG_CALC_ETAG - An entity tag is calculated for
// the reponse based on the memory and file data chunks representing the
// entity data.
//
// HTTP_RESPONSE_FLAG_CALC_LAST_MODIFIED - The last modified time is
// calculated by examining the file data chunks within the entity body.
//
#define HTTP_RESPONSE_FLAG_CALC_CONTENT_LENGTH 0x00000001
#define HTTP_RESPONSE_FLAG_CALC_ETAG 0x00000002
#define HTTP_RESPONSE_FLAG_CALC_LAST_MODIFIED 0x00000004
#define HTTP_RESPONSE_FLAG_VALID 0x00000007
//
// Cache control.
//
//
// This enum defines the available cache policies.
//
typedef enum _HTTP_CACHE_POLICY_TYPE
{
HttpCachePolicyNocache,
HttpCachePolicyUserInvalidates,
HttpCachePolicyTimeToLive,
HttpCachePolicyMaximum
} HTTP_CACHE_POLICY_TYPE, *PHTTP_CACHE_POLICY_TYPE;
//
// o Only cache GET's + HEAD's.
// o Don't cache if VARY is present.
//
typedef struct _HTTP_CACHE_POLICY
{
HTTP_CACHE_POLICY_TYPE Policy;
ULONG SecondsToLive;
} HTTP_CACHE_POLICY, *PHTTP_CACHE_POLICY;
//
// Filters and SSL.
//
//
// Data associated with raw transport connections.
//
typedef struct _HTTP_RAW_CONNECTION_INFO
{
//
// Connection ID.
//
HTTP_RAW_CONNECTION_ID ConnectionId;
//
// Transport address info.
//
HTTP_TRANSPORT_ADDRESS Address;
//
// Used by client APIs only
//
ULONG ServerNameLength; // Length of server name (in bytes)
PWSTR pServerName; // Name of remote server
//
// Initial data.
//
ULONG InitialDataSize; // size of initial data
PVOID pInitialData; // pointer to initial data
} HTTP_RAW_CONNECTION_INFO, *PHTTP_RAW_CONNECTION_INFO;
//
// Client certificate information.
//
typedef struct _HTTP_SSL_CLIENT_CERT_INFO
{
ULONG CertFlags;
ULONG CertEncodedSize;
PUCHAR pCertEncoded;
HANDLE Token;
ULONG CertDeniedByMapper:1;
} HTTP_SSL_CLIENT_CERT_INFO, *PHTTP_SSL_CLIENT_CERT_INFO;
//
// Data computed during SSL handshake.
//
typedef struct _HTTP_SSL_INFO
{
USHORT ServerCertKeySize;
USHORT ConnectionKeySize;
ULONG ServerCertIssuerSize;
ULONG ServerCertSubjectSize;
PSTR pServerCertIssuer;
PSTR pServerCertSubject;
PHTTP_SSL_CLIENT_CERT_INFO pClientCertInfo;
} HTTP_SSL_INFO, *PHTTP_SSL_INFO;
//
// For transfers between filters and upper levels.
//
typedef enum _HTTP_FILTER_BUFFER_TYPE
{
HttpFilterBufferHttpStream, // both directions
HttpFilterBufferSslInitInfo, // filter -> app
HttpFilterBufferSslClientCert, // filter -> app
HttpFilterBufferSslClientCertAndMap, // filter -> app
HttpFilterBufferSslRenegotiate, // app -> filter
HttpFilterBufferSslRenegotiateAndMap, // app -> filter
HttpFilterBufferCloseConnection, // app -> filter
HttpFilterBufferMaximum
} HTTP_FILTER_BUFFER_TYPE;
//
// The buffer transferred between filters and upper levels.
//
typedef struct _HTTP_FILTER_BUFFER
{
HTTP_FILTER_BUFFER_TYPE BufferType;
ULONG BufferSize;
PUCHAR pBuffer;
ULONGLONG Reserved;
} HTTP_FILTER_BUFFER, *PHTTP_FILTER_BUFFER;
//
// Counter Group.
//
//
// Counter property description.
//
typedef struct _HTTP_PROP_DESC
{
ULONG Size;
ULONG Offset;
BOOLEAN WPZeros;
} HTTP_PROP_DESC, *PHTTP_PROP_DESC;
//
// This enum defines the available couter groups.
//
typedef enum _HTTP_COUNTER_GROUP
{
HttpCounterGroupSite,
HttpCounterGroupGlobal,
HttpCounterGroupMaximum
} HTTP_COUNTER_GROUP;
//
// This enum defines the type of global couters.
//
typedef enum _HTTP_GLOBAL_COUNTER_ID
{
HttpGlobalCounterCurrentUrisCached,
HttpGlobalCounterTotalUrisCached,
HttpGlobalCounterUriCacheHits,
HttpGlobalCounterUriCacheMisses,
HttpGlobalCounterUriCacheFlushes,
HttpGlobalCounterTotalFlushedUris,
HttpGlobalCounterMaximum
} HTTP_GLOBAL_COUNTER_ID;
//
// Global couters.
//
typedef struct _HTTP_GLOBAL_COUNTERS
{
ULONG CurrentUrisCached;
ULONG TotalUrisCached;
ULONG UriCacheHits;
ULONG UriCacheMisses;
ULONG UriCacheFlushes;
ULONG TotalFlushedUris;
} HTTP_GLOBAL_COUNTERS, *PHTTP_GLOBAL_COUNTERS;
//
// This enum defines the type of site couters.
//
typedef enum _HTTP_SITE_COUNTER_ID
{
HttpSiteCounterBytesSent,
HttpSiteCounterBytesReceived,
HttpSiteCounterBytesTransfered,
HttpSiteCounterCurrentConns,
HttpSiteCounterMaxConnections,
HttpSiteCounterConnAttempts,
HttpSiteCounterGetReqs,
HttpSiteCounterHeadReqs,
HttpSiteCounterAllReqs,
HttpSiteCounterMeasuredIoBandwidthUsage,
HttpSiteCounterCurrentBlockedBandwidthBytes,
HttpSiteCounterTotalBlockedBandwidthBytes,
HttpSiteCounterMaximum
} HTTP_SITE_COUNTER_ID;
//
// Site couters.
//
typedef struct _HTTP_SITE_COUNTERS
{
ULONG SiteId;
ULONGLONG BytesSent;
ULONGLONG BytesReceived;
ULONGLONG BytesTransfered;
ULONG CurrentConns;
ULONG MaxConnections;
ULONG ConnAttempts;
ULONG GetReqs;
ULONG HeadReqs;
ULONG AllReqs;
ULONG MeasuredIoBandwidthUsage;
ULONG CurrentBlockedBandwidthBytes;
ULONG TotalBlockedBandwidthBytes;
} HTTP_SITE_COUNTERS, *PHTTP_SITE_COUNTERS;
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
#endif // _HTTPDEF_H_
Reference in a new issue Copy permalink