/**
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file is part of the mingw-w64 runtime package.
 * No warranty is given; refer to the file DISCLAIMER.PD within this package.
 */
#ifndef __HTTP_H__
#define __HTTP_H__

#include <winsock2.h>
#include <ws2tcpip.h>

#ifdef __cplusplus
extern "C" {
#endif

#define HTTP_INITIALIZE_SERVER 0x00000001
#define HTTP_INITIALIZE_CONFIG 0x00000002

#define HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY 0x00000001

#define HTTP_SEND_RESPONSE_FLAG_DISCONNECT 0x00000001
#define HTTP_SEND_RESPONSE_FLAG_MORE_DATA 0x00000002
#define HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA 0x00000004

#define HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE 0x00000001

  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_RAW_CONNECTION_ID,*PHTTP_RAW_CONNECTION_ID;

#define HTTP_NULL_ID (0ull)
#define HTTP_IS_NULL_ID(pid) (HTTP_NULL_ID==*(pid))
#define HTTP_SET_NULL_ID(pid) (*(pid) = HTTP_NULL_ID)

#define HTTP_BYTE_RANGE_TO_EOF ((ULONGLONG)-1)

  typedef struct _HTTP_BYTE_RANGE {
    ULARGE_INTEGER StartingOffset;
    ULARGE_INTEGER Length;
  } HTTP_BYTE_RANGE,*PHTTP_BYTE_RANGE;

  typedef struct _HTTP_VERSION {
    USHORT MajorVersion;
    USHORT MinorVersion;
  } HTTP_VERSION,*PHTTP_VERSION;

#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) do { (version).MajorVersion = (major); (version).MinorVersion = (minor); } while (0,0)
#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))

  typedef enum _HTTP_VERB {
    HttpVerbUnparsed = 0,
    HttpVerbUnknown,HttpVerbInvalid,HttpVerbOPTIONS,HttpVerbGET,HttpVerbHEAD,HttpVerbPOST,HttpVerbPUT,HttpVerbDELETE,
    HttpVerbTRACE,HttpVerbCONNECT,HttpVerbTRACK,HttpVerbMOVE,HttpVerbCOPY,HttpVerbPROPFIND,HttpVerbPROPPATCH,HttpVerbMKCOL,HttpVerbLOCK,
    HttpVerbUNLOCK,HttpVerbSEARCH,HttpVerbMaximum
  } HTTP_VERB,*PHTTP_VERB;

  typedef enum _HTTP_HEADER_ID {
    HttpHeaderCacheControl = 0,HttpHeaderConnection = 1,HttpHeaderDate = 2,HttpHeaderKeepAlive = 3,HttpHeaderPragma = 4,HttpHeaderTrailer = 5,
    HttpHeaderTransferEncoding = 6,HttpHeaderUpgrade = 7,HttpHeaderVia = 8,HttpHeaderWarning = 9,HttpHeaderAllow = 10,HttpHeaderContentLength = 11,
    HttpHeaderContentType = 12,HttpHeaderContentEncoding = 13,HttpHeaderContentLanguage = 14,HttpHeaderContentLocation = 15,HttpHeaderContentMd5 = 16,
    HttpHeaderContentRange = 17,HttpHeaderExpires = 18,HttpHeaderLastModified = 19,HttpHeaderAccept = 20,HttpHeaderAcceptCharset = 21,
    HttpHeaderAcceptEncoding = 22,HttpHeaderAcceptLanguage = 23,HttpHeaderAuthorization = 24,HttpHeaderCookie = 25,HttpHeaderExpect = 26,
    HttpHeaderFrom = 27,HttpHeaderHost = 28,HttpHeaderIfMatch = 29,HttpHeaderIfModifiedSince = 30,HttpHeaderIfNoneMatch = 31,HttpHeaderIfRange = 32,
    HttpHeaderIfUnmodifiedSince = 33,HttpHeaderMaxForwards = 34,HttpHeaderProxyAuthorization = 35,HttpHeaderReferer = 36,HttpHeaderRange = 37,
    HttpHeaderTe = 38,HttpHeaderTranslate = 39,HttpHeaderUserAgent = 40,HttpHeaderRequestMaximum = 41,HttpHeaderAcceptRanges = 20,HttpHeaderAge = 21,
    HttpHeaderEtag = 22,HttpHeaderLocation = 23,HttpHeaderProxyAuthenticate = 24,HttpHeaderRetryAfter = 25,HttpHeaderServer = 26,
    HttpHeaderSetCookie = 27,HttpHeaderVary = 28,HttpHeaderWwwAuthenticate = 29,HttpHeaderResponseMaximum = 30,HttpHeaderMaximum = 41
  } HTTP_HEADER_ID,*PHTTP_HEADER_ID;

  typedef struct _HTTP_KNOWN_HEADER {
    USHORT RawValueLength;
    PCSTR pRawValue;
  } HTTP_KNOWN_HEADER,*PHTTP_KNOWN_HEADER;

  typedef struct _HTTP_UNKNOWN_HEADER {
    USHORT NameLength;
    USHORT RawValueLength;
    PCSTR pName;
    PCSTR pRawValue;
  } HTTP_UNKNOWN_HEADER,*PHTTP_UNKNOWN_HEADER;

  typedef enum _HTTP_DATA_CHUNK_TYPE {
    HttpDataChunkFromMemory = 0,
    HttpDataChunkFromFileHandle,
    HttpDataChunkFromFragmentCache,
    HttpDataChunkFromFragmentCacheEx,
    HttpDataChunkMaximum
  } HTTP_DATA_CHUNK_TYPE,*PHTTP_DATA_CHUNK_TYPE;

  typedef struct _HTTP_DATA_CHUNK {
    HTTP_DATA_CHUNK_TYPE DataChunkType;
    __C89_NAMELESS union {
      struct {
	PVOID pBuffer;
	ULONG BufferLength;
      } FromMemory;
      struct {
	HTTP_BYTE_RANGE ByteRange;
	HANDLE FileHandle;
      } FromFileHandle;
      struct {
	USHORT FragmentNameLength;
	PCWSTR pFragmentName;
      } FromFragmentCache;
    };
  } HTTP_DATA_CHUNK,*PHTTP_DATA_CHUNK;

  typedef struct _HTTP_REQUEST_HEADERS {
    USHORT UnknownHeaderCount;
    PHTTP_UNKNOWN_HEADER pUnknownHeaders;
    USHORT TrailerCount;
    PHTTP_UNKNOWN_HEADER pTrailers;
    HTTP_KNOWN_HEADER KnownHeaders[HttpHeaderRequestMaximum];
  } HTTP_REQUEST_HEADERS,*PHTTP_REQUEST_HEADERS;

  typedef struct _HTTP_RESPONSE_HEADERS {
    USHORT UnknownHeaderCount;
    PHTTP_UNKNOWN_HEADER pUnknownHeaders;
    USHORT TrailerCount;
    PHTTP_UNKNOWN_HEADER pTrailers;
    HTTP_KNOWN_HEADER KnownHeaders[HttpHeaderResponseMaximum];
  } HTTP_RESPONSE_HEADERS,*PHTTP_RESPONSE_HEADERS;

  typedef struct _HTTP_TRANSPORT_ADDRESS {
    PSOCKADDR pRemoteAddress;
    PSOCKADDR pLocalAddress;
  } HTTP_TRANSPORT_ADDRESS,*PHTTP_TRANSPORT_ADDRESS;

  typedef struct _HTTP_COOKED_URL {
    USHORT FullUrlLength;
    USHORT HostLength;
    USHORT AbsPathLength;
    USHORT QueryStringLength;
    PCWSTR pFullUrl;
    PCWSTR pHost;
    PCWSTR pAbsPath;
    PCWSTR pQueryString;
  } HTTP_COOKED_URL,*PHTTP_COOKED_URL;

  typedef ULONGLONG HTTP_URL_CONTEXT;

  typedef struct _HTTP_SSL_CLIENT_CERT_INFO {
    ULONG CertFlags;
    ULONG CertEncodedSize;
    PUCHAR pCertEncoded;
    HANDLE Token;
    BOOLEAN CertDeniedByMapper;
  } HTTP_SSL_CLIENT_CERT_INFO,*PHTTP_SSL_CLIENT_CERT_INFO;

  typedef struct _HTTP_SSL_INFO {
    USHORT ServerCertKeySize;
    USHORT ConnectionKeySize;
    ULONG ServerCertIssuerSize;
    ULONG ServerCertSubjectSize;
    PCSTR pServerCertIssuer;
    PCSTR pServerCertSubject;
    PHTTP_SSL_CLIENT_CERT_INFO pClientCertInfo;
    ULONG SslClientCertNegotiated;
  } HTTP_SSL_INFO,*PHTTP_SSL_INFO;

  typedef struct _HTTP_REQUEST_V1 {
    ULONG Flags;
    HTTP_CONNECTION_ID ConnectionId;
    HTTP_REQUEST_ID RequestId;
    HTTP_URL_CONTEXT UrlContext;
    HTTP_VERSION Version;
    HTTP_VERB Verb;
    USHORT UnknownVerbLength;
    USHORT RawUrlLength;
    PCSTR pUnknownVerb;
    PCSTR pRawUrl;
    HTTP_COOKED_URL CookedUrl;
    HTTP_TRANSPORT_ADDRESS Address;
    HTTP_REQUEST_HEADERS Headers;
    ULONGLONG BytesReceived;
    USHORT EntityChunkCount;
    PHTTP_DATA_CHUNK pEntityChunks;
    HTTP_RAW_CONNECTION_ID RawConnectionId;
    PHTTP_SSL_INFO pSslInfo;
  } HTTP_REQUEST_V1, *PHTTP_REQUEST_V1;

  typedef enum _HTTP_REQUEST_INFO_TYPE {
    HttpRequestInfoTypeAuth = 0
  } HTTP_REQUEST_INFO_TYPE, *PHTTP_REQUEST_INFO_TYPE;

  typedef struct _HTTP_REQUEST_INFO {
    HTTP_REQUEST_INFO_TYPE InfoType;
    ULONG                  InfoLength;
    PVOID                  pInfo;
  } HTTP_REQUEST_INFO, *PHTTP_REQUEST_INFO;

  typedef struct _HTTP_REQUEST_V2 {
    struct HTTP_REQUEST_V1;
    USHORT             RequestInfoCount;
    PHTTP_REQUEST_INFO pRequestInfo;
  } HTTP_REQUEST_V2, *PHTTP_REQUEST_V2;

#if (_WIN32_WINNT >= 0x0600)
  typedef HTTP_REQUEST_V2 HTTP_REQUEST, *PHTTP_REQUEST;
#else
  typedef HTTP_REQUEST_V1 HTTP_REQUEST, *PHTTP_REQUEST;
#endif

#define HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS 0x00000001

  typedef struct _HTTP_RESPONSE_V1 {
    ULONG Flags;
    HTTP_VERSION Version;
    USHORT StatusCode;
    USHORT ReasonLength;
    PCSTR pReason;
    HTTP_RESPONSE_HEADERS Headers;
    USHORT EntityChunkCount;
    PHTTP_DATA_CHUNK pEntityChunks;
  } HTTP_RESPONSE_V1,*PHTTP_RESPONSE_V1;

  typedef enum _HTTP_RESPONSE_INFO_TYPE {
    HttpResponseInfoTypeMultipleKnownHeaders = 0,
    HttpResponseInfoTypeAuthenticationProperty,
    HttpResponseInfoTypeQosProperty,
    HttpResponseInfoTypeChannelBind 
  } HTTP_RESPONSE_INFO_TYPE, *PHTTP_RESPONSE_INFO_TYPE;

  typedef struct _HTTP_RESPONSE_INFO {
    HTTP_RESPONSE_INFO_TYPE Type;
    ULONG                   Length;
    PVOID                   pInfo;
  } HTTP_RESPONSE_INFO, *PHTTP_RESPONSE_INFO;

  typedef struct {
    struct HTTP_RESPONSE_V1;
    USHORT              ResponseInfoCount;
    PHTTP_RESPONSE_INFO pResponseInfo;
  } HTTP_RESPONSE_V2, *PHTTP_RESPONSE_V2;

#if (_WIN32_WINNT >= 0x0600)
  typedef HTTP_RESPONSE_V2 HTTP_RESPONSE, *PHTTP_RESPONSE;
#else
  typedef HTTP_RESPONSE_V1 HTTP_RESPONSE, *PHTTP_RESPONSE;
#endif /* _WIN32_WINNT >= 0x0600 */

  typedef enum _HTTP_CACHE_POLICY_TYPE {
    HttpCachePolicyNocache = 0,
    HttpCachePolicyUserInvalidates,
    HttpCachePolicyTimeToLive,
    HttpCachePolicyMaximum
  } HTTP_CACHE_POLICY_TYPE,*PHTTP_CACHE_POLICY_TYPE;

  typedef struct _HTTP_CACHE_POLICY {
    HTTP_CACHE_POLICY_TYPE Policy;
    ULONG SecondsToLive;
  } HTTP_CACHE_POLICY, *PHTTP_CACHE_POLICY;

  typedef enum _HTTP_SERVICE_CONFIG_ID {
    HttpServiceConfigIPListenList = 0,
    HttpServiceConfigSSLCertInfo,
    HttpServiceConfigUrlAclInfo,
    HttpServiceConfigMax
  } HTTP_SERVICE_CONFIG_ID, *PHTTP_SERVICE_CONFIG_ID;

  typedef enum _HTTP_SERVICE_CONFIG_QUERY_TYPE {
    HttpServiceConfigQueryExact = 0,
    HttpServiceConfigQueryNext,
    HttpServiceConfigQueryMax
  } HTTP_SERVICE_CONFIG_QUERY_TYPE,*PHTTP_SERVICE_CONFIG_QUERY_TYPE;

  typedef struct _HTTP_SERVICE_CONFIG_SSL_KEY {
    PSOCKADDR pIpPort;
  } HTTP_SERVICE_CONFIG_SSL_KEY,*PHTTP_SERVICE_CONFIG_SSL_KEY;

  typedef struct _HTTP_SERVICE_CONFIG_SSL_PARAM {
    ULONG SslHashLength;
    PVOID pSslHash;
    GUID AppId;
    PWSTR pSslCertStoreName;
    DWORD DefaultCertCheckMode;
    DWORD DefaultRevocationFreshnessTime;
    DWORD DefaultRevocationUrlRetrievalTimeout;
    PWSTR pDefaultSslCtlIdentifier;
    PWSTR pDefaultSslCtlStoreName;
    DWORD DefaultFlags;
  } HTTP_SERVICE_CONFIG_SSL_PARAM,*PHTTP_SERVICE_CONFIG_SSL_PARAM;

#define HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER 0x00000001
#define HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT 0x00000002
#define HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER 0x00000004

  typedef struct _HTTP_SERVICE_CONFIG_SSL_SET {
    HTTP_SERVICE_CONFIG_SSL_KEY KeyDesc;
    HTTP_SERVICE_CONFIG_SSL_PARAM ParamDesc;
  } HTTP_SERVICE_CONFIG_SSL_SET,*PHTTP_SERVICE_CONFIG_SSL_SET;

  typedef struct _HTTP_SERVICE_CONFIG_SSL_QUERY {
    HTTP_SERVICE_CONFIG_QUERY_TYPE QueryDesc;
    HTTP_SERVICE_CONFIG_SSL_KEY KeyDesc;
    DWORD dwToken;
  } HTTP_SERVICE_CONFIG_SSL_QUERY,*PHTTP_SERVICE_CONFIG_SSL_QUERY;

  typedef struct _HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM {
    USHORT AddrLength;
    PSOCKADDR pAddress;
  } HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM,*PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM;

  typedef struct _HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY {
    ULONG AddrCount;
    SOCKADDR_STORAGE AddrList[ANYSIZE_ARRAY];
  } HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY,*PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY;

  typedef struct _HTTP_SERVICE_CONFIG_URLACL_KEY {
    PWSTR pUrlPrefix;
  } HTTP_SERVICE_CONFIG_URLACL_KEY,*PHTTP_SERVICE_CONFIG_URLACL_KEY;

  typedef struct _HTTP_SERVICE_CONFIG_URLACL_PARAM {
    PWSTR pStringSecurityDescriptor;
  } HTTP_SERVICE_CONFIG_URLACL_PARAM,*PHTTP_SERVICE_CONFIG_URLACL_PARAM;

  typedef struct _HTTP_SERVICE_CONFIG_URLACL_SET {
    HTTP_SERVICE_CONFIG_URLACL_KEY KeyDesc;
    HTTP_SERVICE_CONFIG_URLACL_PARAM ParamDesc;
  } HTTP_SERVICE_CONFIG_URLACL_SET,*PHTTP_SERVICE_CONFIG_URLACL_SET;

  typedef struct _HTTP_SERVICE_CONFIG_URLACL_QUERY {
    HTTP_SERVICE_CONFIG_QUERY_TYPE QueryDesc;
    HTTP_SERVICE_CONFIG_URLACL_KEY KeyDesc;
    DWORD dwToken;
  } HTTP_SERVICE_CONFIG_URLACL_QUERY,*PHTTP_SERVICE_CONFIG_URLACL_QUERY;

#if !defined(HTTPAPI_LINKAGE)
#define HTTPAPI_LINKAGE DECLSPEC_IMPORT
#endif

  typedef struct _HTTPAPI_VERSION {
    USHORT HttpApiMajorVersion;
    USHORT HttpApiMinorVersion;
  } HTTPAPI_VERSION,*PHTTPAPI_VERSION;

#define HTTPAPI_VERSION_1 {1,0}

  HTTPAPI_LINKAGE ULONG WINAPI HttpInitialize(HTTPAPI_VERSION Version,ULONG Flags,PVOID pReserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpTerminate(ULONG Flags,PVOID pReserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCreateHttpHandle(PHANDLE pReqQueueHandle,ULONG Options);
  HTTPAPI_LINKAGE ULONG WINAPI HttpReceiveClientCertificate(HANDLE ReqQueueHandle,HTTP_CONNECTION_ID ConnectionId,ULONG Flags,PHTTP_SSL_CLIENT_CERT_INFO pSslClientCertInfo,ULONG SslClientCertInfoSize,PULONG pBytesReceived,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpAddUrl(HANDLE ReqQueueHandle,PCWSTR pUrlPrefix,PVOID pReserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpRemoveUrl(HANDLE ReqQueueHandle,PCWSTR pUrlPrefix);
  HTTPAPI_LINKAGE ULONG WINAPI HttpReceiveHttpRequest(HANDLE ReqQueueHandle,HTTP_REQUEST_ID RequestId,ULONG Flags,PHTTP_REQUEST pRequestBuffer,ULONG RequestBufferLength,PULONG pBytesReceived,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpReceiveRequestEntityBody(HANDLE ReqQueueHandle,HTTP_REQUEST_ID RequestId,ULONG Flags,PVOID pBuffer,ULONG BufferLength,PULONG pBytesReceived,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpSendHttpResponse(HANDLE ReqQueueHandle,HTTP_REQUEST_ID RequestId,ULONG Flags,PHTTP_RESPONSE pHttpResponse,PVOID pReserved1,PULONG pBytesSent,PVOID pReserved2,ULONG Reserved3,LPOVERLAPPED pOverlapped,PVOID pReserved4);
  HTTPAPI_LINKAGE ULONG WINAPI HttpSendResponseEntityBody(HANDLE ReqQueueHandle,HTTP_REQUEST_ID RequestId,ULONG Flags,USHORT EntityChunkCount,PHTTP_DATA_CHUNK pEntityChunks,PULONG pBytesSent,PVOID pReserved1,ULONG Reserved2,LPOVERLAPPED pOverlapped,PVOID pReserved3);
  HTTPAPI_LINKAGE ULONG WINAPI HttpWaitForDisconnect(HANDLE ReqQueueHandle,HTTP_CONNECTION_ID ConnectionId,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpFlushResponseCache(HANDLE ReqQueueHandle,PCWSTR pUrlPrefix,ULONG Flags,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpAddFragmentToCache(HANDLE ReqQueueHandle,PCWSTR pUrlPrefix,PHTTP_DATA_CHUNK pDataChunk,PHTTP_CACHE_POLICY pCachePolicy,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpReadFragmentFromCache(HANDLE ReqQueueHandle,PCWSTR pUrlPrefix,PHTTP_BYTE_RANGE pByteRange,PVOID pBuffer,ULONG BufferLength,PULONG pBytesRead,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpSetServiceConfiguration(HANDLE ServiceHandle,HTTP_SERVICE_CONFIG_ID ConfigId,PVOID pConfigInformation,ULONG ConfigInformationLength,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpDeleteServiceConfiguration(HANDLE ServiceHandle,HTTP_SERVICE_CONFIG_ID ConfigId,PVOID pConfigInformation,ULONG ConfigInformationLength,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpQueryServiceConfiguration(HANDLE ServiceHandle,HTTP_SERVICE_CONFIG_ID ConfigId,PVOID pInputConfigInformation,ULONG InputConfigInformationLength,PVOID pOutputConfigInformation,ULONG OutputConfigInformationLength,PULONG pReturnLength,LPOVERLAPPED pOverlapped);

#if (_WIN32_WINNT >= 0x0600)
#define HTTP_VERSION_2_0	{ 2, 0 }
#define HTTPAPI_VERSION_2	{ 2, 0 }

  typedef enum _HTTP_503_RESPONSE_VERBOSITY {
    Http503ResponseVerbosityBasic = 0,
    Http503ResponseVerbosityLimited,
    Http503ResponseVerbosityFull
  } HTTP_503_RESPONSE_VERBOSITY, *PHTTP_503_RESPONSE_VERBOSITY;

  typedef enum _HTTP_ENABLED_STATE {
    HttpEnabledStateActive = 0,
    HttpEnabledStateInactive
  } HTTP_ENABLED_STATE, *PHTTP_ENABLED_STATE;

  typedef enum _HTTP_LOGGING_ROLLOVER_TYPE {
    HttpLoggingRolloverSize = 0,
    HttpLoggingRolloverDaily,
    HttpLoggingRolloverWeekly,
    HttpLoggingRolloverMonthly,
    HttpLoggingRolloverHourly
  } HTTP_LOGGING_ROLLOVER_TYPE, *PHTTP_LOGGING_ROLLOVER_TYPE;

  typedef enum _HTTP_LOGGING_TYPE {
    HttpLoggingTypeW3C = 0,
    HttpLoggingTypeIIS,
    HttpLoggingTypeNCSA,
    HttpLoggingTypeRaw
  } HTTP_LOGGING_TYPE, *PHTTP_LOGGING_TYPE;

  typedef enum _HTTP_QOS_SETTING_TYPE {
    HttpQosSettingTypeBandwidth = 0,
    HttpQosSettingTypeConnectionLimit,
    HttpQosSettingTypeFlowRate
  } HTTP_QOS_SETTING_TYPE, *PHTTP_QOS_SETTING_TYPE;

  typedef enum _HTTP_SERVER_PROPERTY {
    HttpServerAuthenticationProperty = 0,
    HttpServerLoggingProperty,
    HttpServerQosProperty,
    HttpServerTimeoutsProperty,
    HttpServerQueueLengthProperty,
    HttpServerStateProperty,
    HttpServer503VerbosityProperty,
    HttpServerBindingProperty,
    HttpServerExtendedAuthenticationProperty,
    HttpServerListenEndpointProperty,
    HttpServerChannelBindProperty
  } HTTP_SERVER_PROPERTY, *PHTTP_SERVER_PROPERTY;

  typedef enum _HTTP_AUTHENTICATION_HARDENING_LEVELS {
    HttpAuthenticationHardeningLegacy   = 0,
    HttpAuthenticationHardeningMedium   = 1,
    HttpAuthenticationHardeningStrict   = 2
  } HTTP_AUTHENTICATION_HARDENING_LEVELS;

  typedef enum _HTTP_SERVICE_BINDING_TYPE {
    HttpServiceBindingTypeNone   = 0,
    HttpServiceBindingTypeW      = 1,
    HttpServiceBindingTypeA      = 2
  } HTTP_SERVICE_BINDING_TYPE;

  typedef enum _HTTP_LOG_DATA_TYPE {
    HttpLogDataTypeFields   = 0
  } HTTP_LOG_DATA_TYPE, *PHTTP_LOG_DATA_TYPE;

  typedef enum _HTTP_REQUEST_AUTH_TYPE {
    HttpRequestAuthTypeNone = 0,
    HttpRequestAuthTypeBasic,
    HttpRequestAuthTypeDigest,
    HttpRequestAuthTypeNTLM,
    HttpRequestAuthTypeNegotiate,
    HttpRequestAuthTypeKerberos
  } HTTP_REQUEST_AUTH_TYPE, *PHTTP_REQUEST_AUTH_TYPE;

  typedef enum _HTTP_AUTH_STATUS {
    HttpAuthStatusSuccess = 0,
    HttpAuthStatusNotAuthenticated,
    HttpAuthStatusFailure
  } HTTP_AUTH_STATUS, *PHTTP_AUTH_STATUS;

  typedef enum _HTTP_SERVICE_CONFIG_TIMEOUT_KEY {
    IdleConnectionTimeout = 0,
    HeaderWaitTimeout
  } HTTP_SERVICE_CONFIG_TIMEOUT_KEY, *PHTTP_SERVICE_CONFIG_TIMEOUT_KEY;

  typedef struct _HTTP_PROPERTY_FLAGS {
    ULONG Present:1;
  } HTTP_PROPERTY_FLAGS, *PHTTP_PROPERTY_FLAGS

  typedef struct _HTTP_CONNECTION_LIMIT_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    ULONG               MaxConnections;
  } HTTP_CONNECTION_LIMIT_INFO, *PHTTP_CONNECTION_LIMIT_INFO;

  typedef struct _HTTP_STATE_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    HTTP_ENABLED_STATE  State;
  } HTTP_STATE_INFO, *PHTTP_STATE_INFO;

  typedef struct _HTTP_QOS_SETTING_INFO {
    HTTP_QOS_SETTING_TYPE  QosType;
    PVOID               QosSetting;
  } HTTP_QOS_SETTING_INFO, *PHTTP_QOS_SETTING_INFO;

  typedef struct _HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS {
    USHORT DomainNameLength;
    PWSTR  DomainName;
    USHORT RealmLength;
    PWSTR  Realm;
  } HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS, *PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS;

  typedef struct _HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS {
    USHORT RealmLength;
    PWSTR  Realm;
  } HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS, *PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS;

  typedef struct _HTTP_SERVER_AUTHENTICATION_INFO {
    HTTP_PROPERTY_FLAGS                      Flags;
    ULONG                                    AuthSchemes;
    BOOLEAN                                  ReceiveMutualAuth;
    BOOLEAN                                  ReceiveContextHandle;
    BOOLEAN                                  DisableNTLMCredentialCaching;
    UCHAR                                    ExFlags;
    HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS DigestParams;
    HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS  BasicParams;
  } HTTP_SERVER_AUTHENTICATION_INFO, *PHTTP_SERVER_AUTHENTICATION_INFO;

  typedef struct _HTTP_LOGGING_INFO {
    HTTP_PROPERTY_FLAGS        Flags;
    ULONG                      LoggingFlags;
    PCWSTR                     SoftwareName;
    USHORT                     SoftwareNameLength;
    USHORT                     DirectoryNameLength;
    PCWSTR                     DirectoryName;
    HTTP_LOGGING_TYPE          Format;
    ULONG                      Fields;
    PVOID                      pExtFields;
    USHORT                     NumOfExtFields;
    USHORT                     MaxRecordSize;
    HTTP_LOGGING_ROLLOVER_TYPE RolloverType;
    ULONG                      RolloverSize;
    PSECURITY_DESCRIPTOR       pSecurityDescriptor;
  } HTTP_LOGGING_INFO, *PHTTP_LOGGING_INFO;

  typedef struct _HTTP_TIMEOUT_LIMIT_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    USHORT              EntityBody;
    USHORT              DrainEntityBody;
    USHORT              RequestQueue;
    USHORT              IdleConnection;
    USHORT              HeaderWait;
    ULONG               MinSendRate;
  } HTTP_TIMEOUT_LIMIT_INFO, *PHTTP_TIMEOUT_LIMIT_INFO;

  typedef struct _HTTP_SERVICE_BINDING_BASE {
    HTTP_SERVICE_BINDING_TYPE Type;
  } HTTP_SERVICE_BINDING_BASE, *PHTTP_SERVICE_BINDING_BASE;

  typedef struct _HTTP_CHANNEL_BIND_INFO {
    HTTP_AUTHENTICATION_HARDENING_LEVELS Hardening;
    ULONG                                Flags;
    PHTTP_SERVICE_BINDING_BASE           *ServiceNames;
    ULONG                                NumberOfServiceNames;
  } HTTP_CHANNEL_BIND_INFO, *PHTTP_CHANNEL_BIND_INFO;

  typedef struct _HTTP_REQUEST_CHANNEL_BIND_STATUS {
    PHTTP_SERVICE_BINDING_BASE ServiceName;
    PUCHAR                     ChannelToken;
    ULONG                      ChannelTokenSize;
    ULONG                      Flags;
  } HTTP_REQUEST_CHANNEL_BIND_STATUS, *PHTTP_REQUEST_CHANNEL_BIND_STATUS;

  typedef struct _HTTP_SERVICE_BINDING_A {
    HTTP_SERVICE_BINDING_BASE Base;
    PCHAR                     Buffer;
    ULONG                     BufferSize;
  } HTTP_SERVICE_BINDING_A, *PHTTP_SERVICE_BINDING_A;

  typedef struct _HTTP_SERVICE_BINDING_W {
    HTTP_SERVICE_BINDING_BASE Base;
    PWCHAR                    Buffer;
    ULONG                     BufferSize;
  } HTTP_SERVICE_BINDING_W, *PHTTP_SERVICE_BINDING_W;

  /* TODO: Is there the abstract unicode type HTTP_SERVICE_BINDING present, too? */

  typedef struct _HTTP_LOG_FIELDS_DATA {
    HTTP_LOG_DATA Base;
    USHORT        UserNameLength;
    USHORT        UriStemLength;
    USHORT        ClientIpLength;
    USHORT        ServerNameLength;
    USHORT        ServerIpLength;
    USHORT        MethodLength;
    USHORT        UriQueryLength;
    USHORT        HostLength;
    USHORT        UserAgentLength;
    USHORT        CookieLength;
    USHORT        ReferrerLength;
    PWCHAR        UserName;
    PWCHAR        UriStem;
    PCHAR         ClientIp;
    PCHAR         ServerName;
    PCHAR         ServiceName;
    PCHAR         ServerIp;
    PCHAR         Method;
    PCHAR         UriQuery;
    PCHAR         Host;
    PCHAR         UserAgent;
    PCHAR         Cookie;
    PCHAR         Referrer;
    USHORT        ServerPort;
    USHORT        ProtocolStatus;
    ULONG         Win32Status;
    HTTP_VERB     MethodNum;
    USHORT        SubStatus;
  } HTTP_LOG_FIELDS_DATA, *PHTTP_LOG_FIELDS_DATA;

  typedef struct _HTTP_REQUEST_AUTH_INFO {
    HTTP_AUTH_STATUS       AuthStatus;
    SECURITY_STATUS        SecStatus;
    ULONG                  Flags;
    HTTP_REQUEST_AUTH_TYPE AuthType;
    HANDLE                 AccessToken;
    ULONG                  ContextAttributes;
    ULONG                  PackedContextLength;
    ULONG                  PackedContextType;
    PVOID                  PackedContext;
    ULONG                  MutualAuthDataLength;
    PCHAR                  pMutualAuthData;
  } HTTP_REQUEST_AUTH_INFO, *PHTTP_REQUEST_AUTH_INFO;

  typedef struct _HTTP_MULTIPLE_KNOWN_HEADERS {
    HTTP_HEADER_ID     HeaderId;
    ULONG              Flags;
    USHORT             KnownHeaderCount;
    PHTTP_KNOWN_HEADER KnownHeaders;
  } HTTP_MULTIPLE_KNOWN_HEADERS, *PHTTP_MULTIPLE_KNOWN_HEADERS;

  typedef struct _HTTP_SERVICE_CONFIG_TIMEOUT_SET {
    HTTP_SERVICE_CONFIG_TIMEOUT_KEY   KeyDesc;
    HTTP_SERVICE_CONFIG_TIMEOUT_PARAM ParamDesc;
  } HTTP_SERVICE_CONFIG_TIMEOUT_SET, *PHTTP_SERVICE_CONFIG_TIMEOUT_SET;

  typedef struct _HTTP_BANDWIDTH_LIMIT_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    ULONG               MaxBandwidth;
  } HTTP_BANDWIDTH_LIMIT_INFO, *PHTTP_BANDWIDTH_LIMIT_INFO;

  typedef struct _HTTP_BINDING_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    HANDLE              RequestQueueHandle;
  } HTTP_BINDING_INFO, *PHTTP_BINDING_INFO;

  typedef struct _HTTP_LISTEN_ENDPOINT_INFO {
    HTTP_PROPERTY_FLAGS Flags;
    BOOLEAN             EnableSharing;
  } HTTP_LISTEN_ENDPOINT_INFO, *PHTTP_LISTEN_ENDPOINT_INFO;

  HTTPAPI_LINKAGE ULONG WINAPI HttpSetRequestQueueProperty(HANDLE Handle,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength,ULONG Reserved,PVOID pReserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpQueryRequestQueueProperty(HANDLE Handle,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength,ULONG Reserved,PULONG pReturnLength,PVOID pReserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCreateRequestQueue(HTTPAPI_VERSION Version,PCWSTR pName,PSECURITY_ATTRIBUTES pSecurityAttributes,ULONG Flags,PHANDLE pReqQueueHandle);
  HTTPAPI_LINKAGE ULONG WINAPI HttpAddUrlToUrlGroup(HTTP_URL_GROUP_ID UrlGroupId,PCWSTR pFullyQualifiedUrl,HTTP_URL_CONTEXT UrlContext,ULONG Reserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCancelHttpRequest(HANDLE ReqQueueHandle,HTTP_REQUEST_ID RequestId,LPOVERLAPPED pOverlapped);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCloseRequestQueue(HANDLE ReqQueueHandle);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCloseServerSession(HTTP_SERVER_SESSION_ID ServerSessionId);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCloseUrlGroup(HTTP_URL_GROUP_ID UrlGroupId);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCreateServerSession(HTTPAPI_VERSION Version,PHTTP_SERVER_SESSION_ID pServerSessionId,ULONG Reserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpCreateUrlGroup(HTTP_SERVER_SESSION_ID ServerSessionId,PHTTP_URL_GROUP_ID pUrlGroupId,ULONG Reserved);
  HTTPAPI_LINKAGE ULONG WINAPI HttpQueryServerSessionProperty(HTTP_SERVER_SESSION_ID ServerSessionId,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength,PULONG pReturnLength);
  HTTPAPI_LINKAGE ULONG WINAPI HttpQueryUrlGroupProperty(HTTP_URL_GROUP_ID UrlGroupId,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength,PULONG pReturnLength);
  HTTPAPI_LINKAGE ULONG WINAPI HttpRemoveUrlFromUrlGroup(HTTP_URL_GROUP_ID UrlGroupId,PCWSTR pFullyQualifiedUrl,ULONG Flags);
  HTTPAPI_LINKAGE ULONG WINAPI HttpSetServerSessionProperty(HTTP_SERVER_SESSION_ID ServerSessionId,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength);
  HTTPAPI_LINKAGE ULONG WINAPI HttpSetUrlGroupProperty(HTTP_URL_GROUP_ID UrlGroupId,HTTP_SERVER_PROPERTY Property,PVOID pPropertyInformation,ULONG PropertyInformationLength);
  HTTPAPI_LINKAGE ULONG WINAPI HttpShutdownRequestQueue(HANDLE ReqQueueHandle);
  HTTPAPI_LINKAGE ULONG WINAPI HttpWaitForDemandStart(HANDLE ReqQueueHandle,LPOVERLAPPED pOverlapped);

#if (_WIN32_WINNT >= 0x0601)
  typedef ULONG HTTP_SERVICE_CONFIG_CACHE_PARAM;

  typedef enum _HTTP_SERVICE_CONFIG_CACHE_KEY {
    MaxCacheResponseSize  = 0,
    CacheRangeChunkSize
  } HTTP_SERVICE_CONFIG_CACHE_KEY;

  typedef struct _HTTP_FLOWRATE_INFO {
    HTTP_PROPERTY_FLAGS  Flags;
    ULONG                MaxBandwidth;
    ULONG                MaxPeakBandwidth;
    ULONG                BurstSize;
  } HTTP_FLOWRATE_INFO, *PHTTP_FLOWRATE_INFO;

typedef struct _HTTP_SERVICE_CONFIG_CACHE_SET {
  HTTP_SERVICE_CONFIG_CACHE_KEY KeyDesc;
  HTTP_SERVICE_CONFIG_CACHE_PARAM ParamDesc;
} HTTP_SERVICE_CONFIG_CACHE_SET, *PHTTP_SERVICE_CONFIG_CACHE_SET;

#endif /*(_WIN32_WINNT >= 0x0601)*/

#endif /*(_WIN32_WINNT >= 0x0600)*/

#ifdef __cplusplus
}
#endif

#endif /* __HTTP_H__ */