/*++

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_