Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 1096 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/http.rs b/vendor/winapi/src/um/http.rs
new file mode 100644
index 0000000..71d4109
--- /dev/null
+++ b/vendor/winapi/src/um/http.rs
@@ -0,0 +1,1096 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! HTTP API specification
+use shared::guiddef::GUID;
+use shared::minwindef::{DWORD, PUCHAR, PULONG, UCHAR, ULONG, USHORT};
+use shared::sspi::SECURITY_STATUS;
+use shared::ws2def::{PSOCKADDR, SOCKADDR_STORAGE};
+use um::minwinbase::{LPOVERLAPPED, PSECURITY_ATTRIBUTES};
+use um::winnt::{
+    ANYSIZE_ARRAY, BOOLEAN, HANDLE, PCHAR, PCSTR, PCWSTR, PHANDLE, PSECURITY_DESCRIPTOR, PVOID,
+    PWCHAR, PWSTR, ULARGE_INTEGER, ULONGLONG,
+};
+pub const HTTP_INITIALIZE_SERVER: ULONG = 0x00000001;
+pub const HTTP_INITIALIZE_CONFIG: ULONG = 0x00000002;
+pub const HTTP_DEMAND_CBT: ULONG = 0x00000004;
+ENUM!{enum HTTP_SERVER_PROPERTY {
+    HttpServerAuthenticationProperty,
+    HttpServerLoggingProperty,
+    HttpServerQosProperty,
+    HttpServerTimeoutsProperty,
+    HttpServerQueueLengthProperty,
+    HttpServerStateProperty,
+    HttpServer503VerbosityProperty,
+    HttpServerBindingProperty,
+    HttpServerExtendedAuthenticationProperty,
+    HttpServerListenEndpointProperty,
+    HttpServerChannelBindProperty,
+    HttpServerProtectionLevelProperty,
+}}
+pub type PHTTP_SERVER_PROPERTY = *mut HTTP_SERVER_PROPERTY;
+STRUCT!{struct HTTP_PROPERTY_FLAGS {
+    BitFields: ULONG,
+}}
+BITFIELD!{HTTP_PROPERTY_FLAGS BitFields: ULONG [
+    Present set_Present[0..1],
+]}
+pub type PHTTP_PROPERTY_FLAGS = *mut HTTP_PROPERTY_FLAGS;
+ENUM!{enum HTTP_ENABLED_STATE {
+    HttpEnabledStateActive,
+    HttpEnabledStateInactive,
+}}
+pub type PHTTP_ENABLED_STATE = *mut HTTP_ENABLED_STATE;
+STRUCT!{struct HTTP_STATE_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    State: HTTP_ENABLED_STATE,
+}}
+pub type PHTTP_STATE_INFO = *mut HTTP_STATE_INFO;
+ENUM!{enum HTTP_503_RESPONSE_VERBOSITY {
+    Http503ResponseVerbosityBasic,
+    Http503ResponseVerbosityLimited,
+    Http503ResponseVerbosityFull,
+}}
+pub type PHTTP_503_RESPONSE_VERBOSITY = *mut HTTP_503_RESPONSE_VERBOSITY;
+ENUM!{enum HTTP_QOS_SETTING_TYPE {
+    HttpQosSettingTypeBandwidth,
+    HttpQosSettingTypeConnectionLimit,
+    HttpQosSettingTypeFlowRate,
+}}
+pub type PHTTP_QOS_SETTING_TYPE = *mut HTTP_QOS_SETTING_TYPE;
+STRUCT!{struct HTTP_QOS_SETTING_INFO {
+    QosType: HTTP_QOS_SETTING_TYPE,
+    QosSetting: PVOID,
+}}
+pub type PHTTP_QOS_SETTING_INFO = *mut HTTP_QOS_SETTING_INFO;
+STRUCT!{struct HTTP_CONNECTION_LIMIT_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    MaxConnections: ULONG,
+}}
+pub type PHTTP_CONNECTION_LIMIT_INFO = *mut HTTP_CONNECTION_LIMIT_INFO;
+STRUCT!{struct HTTP_BANDWIDTH_LIMIT_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    MaxBandwidth: ULONG,
+}}
+pub type PHTTP_BANDWIDTH_LIMIT_INFO = *mut HTTP_BANDWIDTH_LIMIT_INFO;
+STRUCT!{struct HTTP_FLOWRATE_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    MaxBandwidth: ULONG,
+    MaxPeakBandwidth: ULONG,
+    BurstSize: ULONG,
+}}
+pub type PHTTP_FLOWRATE_INFO = *mut HTTP_FLOWRATE_INFO;
+pub const HTTP_MIN_ALLOWED_BANDWIDTH_THROTTLING_RATE: ULONG = 1024;
+pub const HTTP_LIMIT_INFINITE: ULONG = !0;
+ENUM!{enum HTTP_SERVICE_CONFIG_TIMEOUT_KEY {
+    IdleConnectionTimeout = 0,
+    HeaderWaitTimeout,
+}}
+pub type PHTTP_SERVICE_CONFIG_TIMEOUT_KEY = *mut HTTP_SERVICE_CONFIG_TIMEOUT_KEY;
+pub type HTTP_SERVICE_CONFIG_TIMEOUT_PARAM = USHORT;
+pub type PHTTP_SERVICE_CONFIG_TIMEOUT_PARAM = *mut USHORT;
+STRUCT!{struct HTTP_SERVICE_CONFIG_TIMEOUT_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_TIMEOUT_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_TIMEOUT_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_TIMEOUT_SET = *mut HTTP_SERVICE_CONFIG_TIMEOUT_SET;
+STRUCT!{struct HTTP_TIMEOUT_LIMIT_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    EntityBody: USHORT,
+    DrainEntityBody: USHORT,
+    RequestQueue: USHORT,
+    IdleConnection: USHORT,
+    HeaderWait: USHORT,
+    MinSendRate: ULONG,
+}}
+pub type PHTTP_TIMEOUT_LIMIT_INFO = *mut HTTP_TIMEOUT_LIMIT_INFO;
+STRUCT!{struct HTTP_LISTEN_ENDPOINT_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    EnableSharing: BOOLEAN,
+}}
+pub type PHTTP_LISTEN_ENDPOINT_INFO = *mut HTTP_LISTEN_ENDPOINT_INFO;
+STRUCT!{struct HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS {
+    DomainNameLength: USHORT,
+    DomainName: PWSTR,
+    RealmLength: USHORT,
+    Realm: PWSTR,
+}}
+pub type PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS;
+STRUCT!{struct HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS {
+    RealmLength: USHORT,
+    Realm: PWSTR,
+}}
+pub type PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS;
+pub const HTTP_AUTH_ENABLE_BASIC: ULONG = 0x00000001;
+pub const HTTP_AUTH_ENABLE_DIGEST: ULONG = 0x00000002;
+pub const HTTP_AUTH_ENABLE_NTLM: ULONG = 0x00000004;
+pub const HTTP_AUTH_ENABLE_NEGOTIATE: ULONG = 0x00000008;
+pub const HTTP_AUTH_ENABLE_KERBEROS: ULONG = 0x00000010;
+pub const HTTP_AUTH_ENABLE_ALL: ULONG = HTTP_AUTH_ENABLE_BASIC | HTTP_AUTH_ENABLE_DIGEST |
+    HTTP_AUTH_ENABLE_NTLM | HTTP_AUTH_ENABLE_NEGOTIATE | HTTP_AUTH_ENABLE_KERBEROS;
+pub const HTTP_AUTH_EX_FLAG_ENABLE_KERBEROS_CREDENTIAL_CACHING: UCHAR = 0x01;
+pub const HTTP_AUTH_EX_FLAG_CAPTURE_CREDENTIAL: UCHAR = 0x02;
+STRUCT!{struct HTTP_SERVER_AUTHENTICATION_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    AuthSchemes: ULONG,
+    ReceiveMutualAuth: BOOLEAN,
+    ReceiveContextHandle: BOOLEAN,
+    DisableNTLMCredentialCaching: BOOLEAN,
+    ExFlags: UCHAR,
+    DigestParams: HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS,
+    BasicParams: HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS,
+}}
+pub type PHTTP_SERVER_AUTHENTICATION_INFO = *mut HTTP_SERVER_AUTHENTICATION_INFO;
+ENUM!{enum HTTP_SERVICE_BINDING_TYPE {
+    HttpServiceBindingTypeNone = 0,
+    HttpServiceBindingTypeW,
+    HttpServiceBindingTypeA,
+}}
+STRUCT!{struct HTTP_SERVICE_BINDING_BASE {
+    Type: HTTP_SERVICE_BINDING_TYPE,
+}}
+pub type PHTTP_SERVICE_BINDING_BASE = *mut HTTP_SERVICE_BINDING_BASE;
+STRUCT!{struct HTTP_SERVICE_BINDING_A {
+    Base: HTTP_SERVICE_BINDING_BASE,
+    Buffer: PCHAR,
+    BufferSize: ULONG,
+}}
+pub type PHTTP_SERVICE_BINDING_A = *mut HTTP_SERVICE_BINDING_A;
+STRUCT!{struct HTTP_SERVICE_BINDING_W {
+    Base: HTTP_SERVICE_BINDING_BASE,
+    Buffer: PWCHAR,
+    BufferSize: ULONG,
+}}
+pub type PHTTP_SERVICE_BINDING_W = *mut HTTP_SERVICE_BINDING_W;
+ENUM!{enum HTTP_AUTHENTICATION_HARDENING_LEVELS {
+    HttpAuthenticationHardeningLegacy = 0,
+    HttpAuthenticationHardeningMedium,
+    HttpAuthenticationHardeningStrict,
+}}
+pub const HTTP_CHANNEL_BIND_PROXY: ULONG = 0x1;
+pub const HTTP_CHANNEL_BIND_PROXY_COHOSTING: ULONG = 0x20;
+pub const HTTP_CHANNEL_BIND_NO_SERVICE_NAME_CHECK: ULONG = 0x2;
+pub const HTTP_CHANNEL_BIND_DOTLESS_SERVICE: ULONG = 0x4;
+pub const HTTP_CHANNEL_BIND_SECURE_CHANNEL_TOKEN: ULONG = 0x8;
+pub const HTTP_CHANNEL_BIND_CLIENT_SERVICE: ULONG = 0x10;
+STRUCT!{struct HTTP_CHANNEL_BIND_INFO {
+    Hardening: HTTP_AUTHENTICATION_HARDENING_LEVELS,
+    Flags: ULONG,
+    ServiceNames: *mut PHTTP_SERVICE_BINDING_BASE,
+    NumberOfServiceNames: ULONG,
+}}
+pub type PHTTP_CHANNEL_BIND_INFO = *mut HTTP_CHANNEL_BIND_INFO;
+STRUCT!{struct HTTP_REQUEST_CHANNEL_BIND_STATUS {
+    ServiceName: PHTTP_SERVICE_BINDING_BASE,
+    ChannelToken: PUCHAR,
+    ChannelTokenSize: ULONG,
+    Flags: ULONG,
+}}
+pub type PHTTP_REQUEST_CHANNEL_BIND_STATUS = *mut HTTP_REQUEST_CHANNEL_BIND_STATUS;
+pub const HTTP_LOG_FIELD_DATE: ULONG = 0x00000001;
+pub const HTTP_LOG_FIELD_TIME: ULONG = 0x00000002;
+pub const HTTP_LOG_FIELD_CLIENT_IP: ULONG = 0x00000004;
+pub const HTTP_LOG_FIELD_USER_NAME: ULONG = 0x00000008;
+pub const HTTP_LOG_FIELD_SITE_NAME: ULONG = 0x00000010;
+pub const HTTP_LOG_FIELD_COMPUTER_NAME: ULONG = 0x00000020;
+pub const HTTP_LOG_FIELD_SERVER_IP: ULONG = 0x00000040;
+pub const HTTP_LOG_FIELD_METHOD: ULONG = 0x00000080;
+pub const HTTP_LOG_FIELD_URI_STEM: ULONG = 0x00000100;
+pub const HTTP_LOG_FIELD_URI_QUERY: ULONG = 0x00000200;
+pub const HTTP_LOG_FIELD_STATUS: ULONG = 0x00000400;
+pub const HTTP_LOG_FIELD_WIN32_STATUS: ULONG = 0x00000800;
+pub const HTTP_LOG_FIELD_BYTES_SENT: ULONG = 0x00001000;
+pub const HTTP_LOG_FIELD_BYTES_RECV: ULONG = 0x00002000;
+pub const HTTP_LOG_FIELD_TIME_TAKEN: ULONG = 0x00004000;
+pub const HTTP_LOG_FIELD_SERVER_PORT: ULONG = 0x00008000;
+pub const HTTP_LOG_FIELD_USER_AGENT: ULONG = 0x00010000;
+pub const HTTP_LOG_FIELD_COOKIE: ULONG = 0x00020000;
+pub const HTTP_LOG_FIELD_REFERER: ULONG = 0x00040000;
+pub const HTTP_LOG_FIELD_VERSION: ULONG = 0x00080000;
+pub const HTTP_LOG_FIELD_HOST: ULONG = 0x00100000;
+pub const HTTP_LOG_FIELD_SUB_STATUS: ULONG = 0x00200000;
+pub const HTTP_LOG_FIELD_CLIENT_PORT: ULONG = 0x00400000;
+pub const HTTP_LOG_FIELD_URI: ULONG = 0x00800000;
+pub const HTTP_LOG_FIELD_SITE_ID: ULONG = 0x01000000;
+pub const HTTP_LOG_FIELD_REASON: ULONG = 0x02000000;
+pub const HTTP_LOG_FIELD_QUEUE_NAME: ULONG = 0x04000000;
+ENUM!{enum HTTP_LOGGING_TYPE {
+    HttpLoggingTypeW3C,
+    HttpLoggingTypeIIS,
+    HttpLoggingTypeNCSA,
+    HttpLoggingTypeRaw,
+}}
+ENUM!{enum HTTP_LOGGING_ROLLOVER_TYPE {
+    HttpLoggingRolloverSize,
+    HttpLoggingRolloverDaily,
+    HttpLoggingRolloverWeekly,
+    HttpLoggingRolloverMonthly,
+    HttpLoggingRolloverHourly,
+}}
+pub const HTTP_MIN_ALLOWED_LOG_FILE_ROLLOVER_SIZE: ULONG = 1 * 1024 * 1024;
+pub const HTTP_LOGGING_FLAG_LOCAL_TIME_ROLLOVER: ULONG = 0x00000001;
+pub const HTTP_LOGGING_FLAG_USE_UTF8_CONVERSION: ULONG = 0x00000002;
+pub const HTTP_LOGGING_FLAG_LOG_ERRORS_ONLY: ULONG = 0x00000004;
+pub const HTTP_LOGGING_FLAG_LOG_SUCCESS_ONLY: ULONG = 0x00000008;
+STRUCT!{struct HTTP_LOGGING_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    LoggingFlags: ULONG,
+    SoftwareName: PCWSTR,
+    SoftwareNameLength: USHORT,
+    DirectoryNameLength: USHORT,
+    DirectoryName: PCWSTR,
+    Format: HTTP_LOGGING_TYPE,
+    Fields: ULONG,
+    pExtFields: PVOID,
+    NumOfExtFields: USHORT,
+    MaxRecordSize: USHORT,
+    RolloverType: HTTP_LOGGING_ROLLOVER_TYPE,
+    RolloverSize: ULONG,
+    pSecurityDescriptor: PSECURITY_DESCRIPTOR,
+}}
+pub type PHTTP_LOGGING_INFO = *mut HTTP_LOGGING_INFO;
+STRUCT!{struct HTTP_BINDING_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    RequestQueueHandle: HANDLE,
+}}
+pub type PHTTP_BINDING_INFO = *mut HTTP_BINDING_INFO;
+ENUM!{enum HTTP_PROTECTION_LEVEL_TYPE {
+    HttpProtectionLevelUnrestricted,
+    HttpProtectionLevelEdgeRestricted,
+    HttpProtectionLevelRestricted,
+}}
+pub type PHTTP_PROTECTION_LEVEL_TYPE = *mut HTTP_PROTECTION_LEVEL_TYPE;
+STRUCT!{struct HTTP_PROTECTION_LEVEL_INFO {
+    Flags: HTTP_PROPERTY_FLAGS,
+    Level: HTTP_PROTECTION_LEVEL_TYPE,
+}}
+pub type PHTTP_PROTECTION_LEVEL_INFO = *mut HTTP_PROTECTION_LEVEL_INFO;
+pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_OPEN_EXISTING: ULONG = 0x00000001;
+pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_CONTROLLER: ULONG = 0x00000002;
+pub const HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY: ULONG = 0x00000001;
+pub const HTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODY: ULONG = 0x00000002;
+pub const HTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFER: ULONG = 0x00000001;
+pub const HTTP_SEND_RESPONSE_FLAG_DISCONNECT: ULONG = 0x00000001;
+pub const HTTP_SEND_RESPONSE_FLAG_MORE_DATA: ULONG = 0x00000002;
+pub const HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA: ULONG = 0x00000004;
+pub const HTTP_SEND_RESPONSE_FLAG_ENABLE_NAGLING: ULONG = 0x00000008;
+pub const HTTP_SEND_RESPONSE_FLAG_PROCESS_RANGES: ULONG = 0x00000020;
+pub const HTTP_SEND_RESPONSE_FLAG_OPAQUE: ULONG = 0x00000040;
+pub const HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE: ULONG = 0x00000001;
+pub type HTTP_OPAQUE_ID = ULONGLONG;
+pub type PHTTP_OPAQUE_ID = *mut ULONGLONG;
+pub type HTTP_REQUEST_ID = HTTP_OPAQUE_ID;
+pub type PHTTP_REQUEST_ID = *mut HTTP_OPAQUE_ID;
+pub type HTTP_CONNECTION_ID = HTTP_OPAQUE_ID;
+pub type PHTTP_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
+pub type HTTP_RAW_CONNECTION_ID = HTTP_OPAQUE_ID;
+pub type PHTTP_RAW_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
+pub type HTTP_URL_GROUP_ID = HTTP_OPAQUE_ID;
+pub type PHTTP_URL_GROUP_ID = *mut HTTP_OPAQUE_ID;
+pub type HTTP_SERVER_SESSION_ID = HTTP_OPAQUE_ID;
+pub type PHTTP_SERVER_SESSION_ID = *mut HTTP_OPAQUE_ID;
+pub const HTTP_BYTE_RANGE_TO_EOF: ULONGLONG = !0;
+STRUCT!{struct HTTP_BYTE_RANGE {
+    StartingOffset: ULARGE_INTEGER,
+    Length: ULARGE_INTEGER,
+}}
+pub type PHTTP_BYTE_RANGE = *mut HTTP_BYTE_RANGE;
+STRUCT!{struct HTTP_VERSION {
+    MajorVersion: USHORT,
+    MinorVersion: USHORT,
+}}
+pub type PHTTP_VERSION = *mut HTTP_VERSION;
+pub const HTTP_VERSION_UNKNOWN: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 0 };
+pub const HTTP_VERSION_0_9: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 9 };
+pub const HTTP_VERSION_1_0: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 0 };
+pub const HTTP_VERSION_1_1: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 1 };
+#[inline]
+pub fn HTTP_SET_VERSION(mut version: HTTP_VERSION, major: USHORT, minor: USHORT) {
+    version.MajorVersion = major;
+    version.MinorVersion = minor;
+}
+#[inline]
+pub fn HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.MajorVersion == major && version.MinorVersion == minor
+}
+#[inline]
+pub fn HTTP_GREATER_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.MajorVersion > major || (version.MajorVersion == major && version.MinorVersion > minor)
+}
+#[inline]
+pub fn HTTP_LESS_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.MajorVersion < major || (version.MajorVersion == major && version.MinorVersion < minor)
+}
+#[inline]
+pub fn HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    !HTTP_EQUAL_VERSION(version, major, minor)
+}
+#[inline]
+pub fn HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    !HTTP_LESS_VERSION(version, major, minor)
+}
+#[inline]
+pub fn HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
+    !HTTP_GREATER_VERSION(version, major, minor)
+}
+ENUM!{enum HTTP_VERB {
+    HttpVerbUnparsed,
+    HttpVerbUnknown,
+    HttpVerbInvalid,
+    HttpVerbOPTIONS,
+    HttpVerbGET,
+    HttpVerbHEAD,
+    HttpVerbPOST,
+    HttpVerbPUT,
+    HttpVerbDELETE,
+    HttpVerbTRACE,
+    HttpVerbCONNECT,
+    HttpVerbTRACK,
+    HttpVerbMOVE,
+    HttpVerbCOPY,
+    HttpVerbPROPFIND,
+    HttpVerbPROPPATCH,
+    HttpVerbMKCOL,
+    HttpVerbLOCK,
+    HttpVerbUNLOCK,
+    HttpVerbSEARCH,
+    HttpVerbMaximum,
+}}
+pub type PHTTP_VERB = *mut HTTP_VERB;
+ENUM!{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,
+}}
+pub type PHTTP_HEADER_ID = *mut HTTP_HEADER_ID;
+STRUCT!{struct HTTP_KNOWN_HEADER {
+    RawValueLength: USHORT,
+    pRawValue: PCSTR,
+}}
+pub type PHTTP_KNOWN_HEADER = *mut HTTP_KNOWN_HEADER;
+STRUCT!{struct HTTP_UNKNOWN_HEADER {
+    NameLength: USHORT,
+    RawValueLength: USHORT,
+    pName: PCSTR,
+    pRawValue: PCSTR,
+}}
+pub type PHTTP_UNKNOWN_HEADER = *mut HTTP_UNKNOWN_HEADER;
+ENUM!{enum HTTP_LOG_DATA_TYPE {
+    HttpLogDataTypeFields = 0,
+}}
+pub type PHTTP_LOG_DATA_TYPE = *mut HTTP_LOG_DATA_TYPE;
+STRUCT!{struct HTTP_LOG_DATA {
+    Type: HTTP_LOG_DATA_TYPE,
+}}
+pub type PHTTP_LOG_DATA = *mut HTTP_LOG_DATA;
+STRUCT!{struct HTTP_LOG_FIELDS_DATA {
+    Base: HTTP_LOG_DATA,
+    UserNameLength: USHORT,
+    UriStemLength: USHORT,
+    ClientIpLength: USHORT,
+    ServerNameLength: USHORT,
+    ServiceNameLength: USHORT,
+    ServerIpLength: USHORT,
+    MethodLength: USHORT,
+    UriQueryLength: USHORT,
+    HostLength: USHORT,
+    UserAgentLength: USHORT,
+    CookieLength: USHORT,
+    ReferrerLength: USHORT,
+    UserName: PWCHAR,
+    UriStem: PWCHAR,
+    ClientIp: PCHAR,
+    ServerName: PCHAR,
+    ServiceName: PCHAR,
+    ServerIp: PCHAR,
+    Method: PCHAR,
+    UriQuery: PCHAR,
+    Host: PCHAR,
+    UserAgent: PCHAR,
+    Cookie: PCHAR,
+    Referrer: PCHAR,
+    ServerPort: USHORT,
+    ProtocolStatus: USHORT,
+    Win32Status: ULONG,
+    MethodNum: HTTP_VERB,
+    SubStatus: USHORT,
+}}
+pub type PHTTP_LOG_FIELDS_DATA = *mut HTTP_LOG_FIELDS_DATA;
+ENUM!{enum HTTP_DATA_CHUNK_TYPE {
+    HttpDataChunkFromMemory,
+    HttpDataChunkFromFileHandle,
+    HttpDataChunkFromFragmentCache,
+    HttpDataChunkFromFragmentCacheEx,
+    HttpDataChunkMaximum,
+}}
+pub type PHTTP_DATA_CHUNK_TYPE = *mut HTTP_DATA_CHUNK_TYPE;
+STRUCT!{struct HTTP_DATA_CHUNK_FromMemory {
+    pBuffer: PVOID,
+    BufferLength: ULONG,
+}}
+STRUCT!{struct HTTP_DATA_CHUNK_FromFileHandle {
+    ByteRange: HTTP_BYTE_RANGE,
+    FileHandle: HANDLE,
+}}
+STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCache {
+    FragmentNameLength: USHORT,
+    pFragmentName: PCWSTR,
+}}
+STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCacheEx {
+    ByteRange: HTTP_BYTE_RANGE,
+    pFragmentName: PCWSTR,
+}}
+UNION!{union HTTP_DATA_CHUNK_u {
+    [u64; 3],
+    FromMemory FromMemory_mut: HTTP_DATA_CHUNK_FromMemory,
+    FromFileHandle FromFileHandle_mut: HTTP_DATA_CHUNK_FromFileHandle,
+    FromFragmentCache FromFragmentCache_mut: HTTP_DATA_CHUNK_FromFragmentCache,
+    FromFragmentCacheEx FromFragmentCacheEx_mut: HTTP_DATA_CHUNK_FromFragmentCacheEx,
+}}
+STRUCT!{struct HTTP_DATA_CHUNK {
+    DataChunkType: HTTP_DATA_CHUNK_TYPE,
+    u: HTTP_DATA_CHUNK_u,
+}}
+pub type PHTTP_DATA_CHUNK = *mut HTTP_DATA_CHUNK;
+STRUCT!{struct HTTP_REQUEST_HEADERS {
+    UnknownHeaderCount: USHORT,
+    pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
+    TrailerCount: USHORT,
+    pTrailers: PHTTP_UNKNOWN_HEADER,
+    KnownHeaders: [HTTP_KNOWN_HEADER; 41], // FIXME HttpHeaderRequestMaximum
+}}
+pub type PHTTP_REQUEST_HEADERS = *mut HTTP_REQUEST_HEADERS;
+STRUCT!{struct HTTP_RESPONSE_HEADERS {
+    UnknownHeaderCount: USHORT,
+    pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
+    TrailerCount: USHORT,
+    pTrailers: PHTTP_UNKNOWN_HEADER,
+    KnownHeaders: [HTTP_KNOWN_HEADER; 30], // FIXME HttpHeaderResponseMaximum
+}}
+pub type PHTTP_RESPONSE_HEADERS = *mut HTTP_RESPONSE_HEADERS;
+STRUCT!{struct HTTP_TRANSPORT_ADDRESS {
+    pRemoteAddress: PSOCKADDR,
+    pLocalAddress: PSOCKADDR,
+}}
+pub type PHTTP_TRANSPORT_ADDRESS = *mut HTTP_TRANSPORT_ADDRESS;
+STRUCT!{struct HTTP_COOKED_URL {
+    FullUrlLength: USHORT,
+    HostLength: USHORT,
+    AbsPathLength: USHORT,
+    QueryStringLength: USHORT,
+    pFullUrl: PCWSTR,
+    pHost: PCWSTR,
+    pAbsPath: PCWSTR,
+    pQueryString: PCWSTR,
+}}
+pub type PHTTP_COOKED_URL = *mut HTTP_COOKED_URL;
+pub type HTTP_URL_CONTEXT = ULONGLONG;
+pub const HTTP_URL_FLAG_REMOVE_ALL: ULONG = 0x00000001;
+ENUM!{enum HTTP_AUTH_STATUS {
+    HttpAuthStatusSuccess,
+    HttpAuthStatusNotAuthenticated,
+    HttpAuthStatusFailure,
+}}
+pub type PHTTP_AUTH_STATUS = *mut HTTP_AUTH_STATUS;
+ENUM!{enum HTTP_REQUEST_AUTH_TYPE {
+    HttpRequestAuthTypeNone = 0,
+    HttpRequestAuthTypeBasic,
+    HttpRequestAuthTypeDigest,
+    HttpRequestAuthTypeNTLM,
+    HttpRequestAuthTypeNegotiate,
+    HttpRequestAuthTypeKerberos,
+}}
+pub type PHTTP_REQUEST_AUTH_TYPE = *mut HTTP_REQUEST_AUTH_TYPE;
+STRUCT!{struct HTTP_SSL_CLIENT_CERT_INFO {
+    CertFlags: ULONG,
+    CertEncodedSize: ULONG,
+    pCertEncoded: PUCHAR,
+    Token: HANDLE,
+    CertDeniedByMapper: BOOLEAN,
+}}
+pub type PHTTP_SSL_CLIENT_CERT_INFO = *mut HTTP_SSL_CLIENT_CERT_INFO;
+pub const HTTP_RECEIVE_SECURE_CHANNEL_TOKEN: ULONG = 0x1;
+STRUCT!{struct HTTP_SSL_INFO {
+    ServerCertKeySize: USHORT,
+    ConnectionKeySize: USHORT,
+    ServerCertIssuerSize: ULONG,
+    ServerCertSubjectSize: ULONG,
+    pServerCertIssuer: PCSTR,
+    pServerCertSubject: PCSTR,
+    pClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
+    SslClientCertNegotiated: ULONG,
+}}
+pub type PHTTP_SSL_INFO = *mut HTTP_SSL_INFO;
+ENUM!{enum HTTP_REQUEST_INFO_TYPE {
+    HttpRequestInfoTypeAuth,
+    HttpRequestInfoTypeChannelBind,
+}}
+STRUCT!{struct HTTP_REQUEST_INFO {
+    InfoType: HTTP_REQUEST_INFO_TYPE,
+    InfoLength: ULONG,
+    pInfo: PVOID,
+}}
+pub type PHTTP_REQUEST_INFO = *mut HTTP_REQUEST_INFO;
+pub const HTTP_REQUEST_AUTH_FLAG_TOKEN_FOR_CACHED_CRED: ULONG = 0x00000001;
+STRUCT!{struct HTTP_REQUEST_AUTH_INFO {
+    AuthStatus: HTTP_AUTH_STATUS,
+    SecStatus: SECURITY_STATUS,
+    Flags: ULONG,
+    AuthType: HTTP_REQUEST_AUTH_TYPE,
+    AccessToken: HANDLE,
+    ContextAttributes: ULONG,
+    PackedContextLength: ULONG,
+    PackedContextType: ULONG,
+    PackedContext: PVOID,
+    MutualAuthDataLength: ULONG,
+    pMutualAuthData: PCHAR,
+    PackageNameLength: USHORT,
+    pPackageName: PWSTR,
+}}
+pub type PHTTP_REQUEST_AUTH_INFO = *mut HTTP_REQUEST_AUTH_INFO;
+STRUCT!{struct HTTP_REQUEST_V1 {
+    Flags: ULONG,
+    ConnectionId: HTTP_CONNECTION_ID,
+    RequestId: HTTP_REQUEST_ID,
+    UrlContext: HTTP_URL_CONTEXT,
+    Version: HTTP_VERSION,
+    Verb: HTTP_VERB,
+    UnknownVerbLength: USHORT,
+    RawUrlLength: USHORT,
+    pUnknownVerb: PCSTR,
+    pRawUrl: PCSTR,
+    CookedUrl: HTTP_COOKED_URL,
+    Address: HTTP_TRANSPORT_ADDRESS,
+    Headers: HTTP_REQUEST_HEADERS,
+    BytesReceived: ULONGLONG,
+    EntityChunkCount: USHORT,
+    pEntityChunks: PHTTP_DATA_CHUNK,
+    RawConnectionId: HTTP_RAW_CONNECTION_ID,
+    pSslInfo: PHTTP_SSL_INFO,
+}}
+pub type PHTTP_REQUEST_V1 = *mut HTTP_REQUEST_V1;
+STRUCT!{struct HTTP_REQUEST_V2 {
+    Base: HTTP_REQUEST_V1,
+    RequestInfoCount: USHORT,
+    pRequestInfo: PHTTP_REQUEST_INFO,
+}}
+pub type PHTTP_REQUEST_V2 = *mut HTTP_REQUEST_V2;
+pub type HTTP_REQUEST = HTTP_REQUEST_V2;
+pub type PHTTP_REQUEST = *mut HTTP_REQUEST;
+pub const HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS: ULONG = 0x00000001;
+pub const HTTP_REQUEST_FLAG_IP_ROUTED: ULONG = 0x00000002;
+STRUCT!{struct HTTP_RESPONSE_V1 {
+    Flags: ULONG,
+    Version: HTTP_VERSION,
+    StatusCode: USHORT,
+    ReasonLength: USHORT,
+    pReason: PCSTR,
+    Headers: HTTP_RESPONSE_HEADERS,
+    EntityChunkCount: USHORT,
+    pEntityChunks: PHTTP_DATA_CHUNK,
+}}
+pub type PHTTP_RESPONSE_V1 = *mut HTTP_RESPONSE_V1;
+pub const HTTP_RESPONSE_FLAG_MULTIPLE_ENCODINGS_AVAILABLE: ULONG = 0x00000001;
+ENUM!{enum HTTP_RESPONSE_INFO_TYPE {
+    HttpResponseInfoTypeMultipleKnownHeaders,
+    HttpResponseInfoTypeAuthenticationProperty,
+    HttpResponseInfoTypeQoSProperty,
+    HttpResponseInfoTypeChannelBind,
+}}
+pub type PHTTP_RESPONSE_INFO_TYPE = *mut HTTP_RESPONSE_INFO_TYPE;
+STRUCT!{struct HTTP_RESPONSE_INFO {
+    Type: HTTP_RESPONSE_INFO_TYPE,
+    Length: ULONG,
+    pInfo: PVOID,
+}}
+pub type PHTTP_RESPONSE_INFO = *mut HTTP_RESPONSE_INFO;
+pub const HTTP_RESPONSE_INFO_FLAGS_PRESERVE_ORDER: ULONG = 0x00000001;
+STRUCT!{struct HTTP_MULTIPLE_KNOWN_HEADERS {
+    HeaderId: HTTP_HEADER_ID,
+    Flags: ULONG,
+    KnownHeaderCount: USHORT,
+    KnownHeaders: PHTTP_KNOWN_HEADER,
+}}
+pub type PHTTP_MULTIPLE_KNOWN_HEADERS = *mut HTTP_MULTIPLE_KNOWN_HEADERS;
+STRUCT!{struct HTTP_RESPONSE_V2 {
+    Base: HTTP_RESPONSE_V1,
+    ResponseInfoCount: USHORT,
+    pResponseInfo: PHTTP_RESPONSE_INFO,
+}}
+pub type PHTTP_RESPONSE_V2 = *mut HTTP_RESPONSE_V2;
+pub type HTTP_RESPONSE = HTTP_RESPONSE_V2;
+pub type PHTTP_RESPONSE = *mut HTTP_RESPONSE;
+STRUCT!{struct HTTPAPI_VERSION {
+    HttpApiMajorVersion: USHORT,
+    HttpApiMinorVersion: USHORT,
+}}
+pub type PHTTPAPI_VERSION = *mut HTTPAPI_VERSION;
+pub const HTTPAPI_VERSION_2: HTTPAPI_VERSION = HTTPAPI_VERSION {
+    HttpApiMajorVersion: 2,
+    HttpApiMinorVersion: 0,
+};
+pub const HTTPAPI_VERSION_1: HTTPAPI_VERSION = HTTPAPI_VERSION {
+    HttpApiMajorVersion: 1,
+    HttpApiMinorVersion: 0,
+};
+#[inline]
+pub fn HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.HttpApiMajorVersion == major && version.HttpApiMinorVersion == minor
+}
+#[inline]
+pub fn HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.HttpApiMajorVersion > major ||
+    (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion > minor)
+}
+#[inline]
+pub fn HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
+    version.HttpApiMajorVersion < major ||
+    (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion < minor)
+}
+#[inline]
+pub fn HTTPAPI_VERSION_GREATER_OR_EQUAL(
+    version: HTTPAPI_VERSION,
+    major: USHORT,
+    minor: USHORT,
+) -> bool {
+    !HTTPAPI_LESS_VERSION(version, major, minor)
+}
+ENUM!{enum HTTP_CACHE_POLICY_TYPE {
+    HttpCachePolicyNocache,
+    HttpCachePolicyUserInvalidates,
+    HttpCachePolicyTimeToLive,
+    HttpCachePolicyMaximum,
+}}
+pub type PHTTP_CACHE_POLICY_TYPE = *mut HTTP_CACHE_POLICY_TYPE;
+STRUCT!{struct HTTP_CACHE_POLICY {
+    Policy: HTTP_CACHE_POLICY_TYPE,
+    SecondsToLive: ULONG,
+}}
+pub type PHTTP_CACHE_POLICY = *mut HTTP_CACHE_POLICY;
+ENUM!{enum HTTP_SERVICE_CONFIG_ID {
+    HttpServiceConfigIPListenList,
+    HttpServiceConfigSSLCertInfo,
+    HttpServiceConfigUrlAclInfo,
+    HttpServiceConfigTimeout,
+    HttpServiceConfigCache,
+    HttpServiceConfigSslSniCertInfo,
+    HttpServiceConfigSslCcsCertInfo,
+    HttpServiceConfigMax,
+}}
+pub type PHTTP_SERVICE_CONFIG_ID = *mut HTTP_SERVICE_CONFIG_ID;
+ENUM!{enum HTTP_SERVICE_CONFIG_QUERY_TYPE {
+    HttpServiceConfigQueryExact,
+    HttpServiceConfigQueryNext,
+    HttpServiceConfigQueryMax,
+}}
+pub type PHTTP_SERVICE_CONFIG_QUERY_TYPE = *mut HTTP_SERVICE_CONFIG_QUERY_TYPE;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_KEY {
+    pIpPort: PSOCKADDR,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_KEY = *mut HTTP_SERVICE_CONFIG_SSL_KEY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_KEY {
+    IpPort: SOCKADDR_STORAGE,
+    Host: PWSTR,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_SNI_KEY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_KEY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_KEY {
+    LocalAddress: SOCKADDR_STORAGE,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_CCS_KEY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_KEY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_PARAM {
+    SslHashLength: ULONG,
+    pSslHash: PVOID,
+    AppId: GUID,
+    pSslCertStoreName: PWSTR,
+    DefaultCertCheckMode: DWORD,
+    DefaultRevocationFreshnessTime: DWORD,
+    DefaultRevocationUrlRetrievalTimeout: DWORD,
+    pDefaultSslCtlIdentifier: PWSTR,
+    pDefaultSslCtlStoreName: PWSTR,
+    DefaultFlags: DWORD,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_PARAM = *mut HTTP_SERVICE_CONFIG_SSL_PARAM;
+pub const HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER: DWORD = 0x00000001;
+pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT: DWORD = 0x00000002;
+pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER: DWORD = 0x00000004;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_SET = *mut HTTP_SERVICE_CONFIG_SSL_SET;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_SNI_SET = *mut HTTP_SERVICE_CONFIG_SSL_SNI_SET;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_CCS_SET = *mut HTTP_SERVICE_CONFIG_SSL_CCS_SET;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_QUERY {
+    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
+    dwToken: DWORD,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_QUERY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_QUERY {
+    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
+    dwToken: DWORD,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_SNI_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_QUERY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_QUERY {
+    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
+    KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
+    dwToken: DWORD,
+}}
+pub type PHTTP_SERVICE_CONFIG_SSL_CCS_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_QUERY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM {
+    AddrLength: USHORT,
+    pAddress: PSOCKADDR,
+}}
+pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM;
+STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY {
+    AddrCount: ULONG,
+    AddrList: [SOCKADDR_STORAGE; ANYSIZE_ARRAY],
+}}
+pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_KEY {
+    pUrlPrefix: PWSTR,
+}}
+pub type PHTTP_SERVICE_CONFIG_URLACL_KEY = *mut HTTP_SERVICE_CONFIG_URLACL_KEY;
+STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_PARAM {
+    pStringSecurityDescriptor: PWSTR,
+}}
+pub type PHTTP_SERVICE_CONFIG_URLACL_PARAM = *mut HTTP_SERVICE_CONFIG_URLACL_PARAM;
+STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_URLACL_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_URLACL_SET = *mut HTTP_SERVICE_CONFIG_URLACL_SET;
+STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_QUERY {
+    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
+    KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
+    dwToken: DWORD,
+}}
+pub type PHTTP_SERVICE_CONFIG_URLACL_QUERY = *mut HTTP_SERVICE_CONFIG_URLACL_QUERY;
+ENUM!{enum HTTP_SERVICE_CONFIG_CACHE_KEY {
+    MaxCacheResponseSize = 0,
+    CacheRangeChunkSize,
+}}
+pub type PHTTP_SERVICE_CONFIG_CACHE_KEY = *mut HTTP_SERVICE_CONFIG_CACHE_KEY;
+pub type HTTP_SERVICE_CONFIG_CACHE_PARAM = ULONG;
+pub type PHTTP_SERVICE_CONFIG_CACHE_PARAM = *mut ULONG;
+STRUCT!{struct HTTP_SERVICE_CONFIG_CACHE_SET {
+    KeyDesc: HTTP_SERVICE_CONFIG_CACHE_KEY,
+    ParamDesc: HTTP_SERVICE_CONFIG_CACHE_PARAM,
+}}
+pub type PHTTP_SERVICE_CONFIG_CACHE_SET = *mut HTTP_SERVICE_CONFIG_CACHE_SET;
+pub const HTTP_NULL_ID: ULONGLONG = 0;
+#[inline]
+pub unsafe fn HTTP_IS_NULL_ID(pid: PHTTP_OPAQUE_ID) -> bool {
+    HTTP_NULL_ID == *pid
+}
+#[inline]
+pub unsafe fn HTTP_SET_NULL_ID(pid: PHTTP_OPAQUE_ID) {
+    *pid = HTTP_NULL_ID
+}
+extern "system" {
+    pub fn HttpInitialize(
+        Version: HTTPAPI_VERSION,
+        Flags: ULONG,
+        pReserved: PVOID,
+    ) -> ULONG;
+    pub fn HttpTerminate(
+        Flags: ULONG,
+        pReserved: PVOID,
+    ) -> ULONG;
+    pub fn HttpCreateHttpHandle(
+        pReqQueueHandle: PHANDLE,
+        Reserved: ULONG,
+    ) -> ULONG;
+    pub fn HttpCreateRequestQueue(
+        Version: HTTPAPI_VERSION,
+        pName: PCWSTR,
+        pSecurityAttributes: PSECURITY_ATTRIBUTES,
+        Flags: ULONG,
+        pReqQueueHandle: PHANDLE,
+    ) -> ULONG;
+    pub fn HttpCloseRequestQueue(
+        ReqQueueHandle: HANDLE,
+    ) -> ULONG;
+    pub fn HttpSetRequestQueueProperty(
+        Handle: HANDLE,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+        Reserved: ULONG,
+        pReserved: PVOID,
+    ) -> ULONG;
+    pub fn HttpQueryRequestQueueProperty(
+        Handle: HANDLE,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+        Reserved: ULONG,
+        pReturnLength: PULONG,
+        pReserved: PVOID,
+    ) -> ULONG;
+    pub fn HttpShutdownRequestQueue(
+        ReqQueueHandle: HANDLE,
+    ) -> ULONG;
+    pub fn HttpReceiveClientCertificate(
+        ReqQueueHandle: HANDLE,
+        ConnectionId: HTTP_CONNECTION_ID,
+        Flags: ULONG,
+        pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
+        SslClientCertInfoSize: ULONG,
+        pBytesReceived: PULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpCreateServerSession(
+        Version: HTTPAPI_VERSION,
+        pServerSessionId: PHTTP_SERVER_SESSION_ID,
+        Reserved: ULONG,
+    ) -> ULONG;
+    pub fn HttpCloseServerSession(
+        ServerSessionId: HTTP_SERVER_SESSION_ID,
+    ) -> ULONG;
+    pub fn HttpQueryServerSessionProperty(
+        ServerSessionId: HTTP_SERVER_SESSION_ID,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+        pReturnLength: PULONG,
+    ) -> ULONG;
+    pub fn HttpSetServerSessionProperty(
+        ServerSessionId: HTTP_SERVER_SESSION_ID,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+    ) -> ULONG;
+    pub fn HttpAddUrl(
+        ReqQueueHandle: HANDLE,
+        pFullyQualifiedUrl: PCWSTR,
+        pReserved: PVOID,
+    ) -> ULONG;
+    pub fn HttpRemoveUrl(
+        ReqQueueHandle: HANDLE,
+        pFullyQualifiedUrl: PCWSTR,
+    ) -> ULONG;
+    pub fn HttpCreateUrlGroup(
+        ServerSessionId: HTTP_SERVER_SESSION_ID,
+        pUrlGroupId: PHTTP_URL_GROUP_ID,
+        Reserved: ULONG,
+    ) -> ULONG;
+    pub fn HttpCloseUrlGroup(
+        UrlGroupId: HTTP_URL_GROUP_ID,
+    ) -> ULONG;
+    pub fn HttpAddUrlToUrlGroup(
+        UrlGroupId: HTTP_URL_GROUP_ID,
+        pFullyQualifiedUrl: PCWSTR,
+        UrlContext: HTTP_URL_CONTEXT,
+        Reserved: ULONG,
+    ) -> ULONG;
+    pub fn HttpRemoveUrlFromUrlGroup(
+        UrlGroupId: HTTP_URL_GROUP_ID,
+        pFullyQualifiedUrl: PCWSTR,
+        Flags: ULONG,
+    ) -> ULONG;
+    pub fn HttpSetUrlGroupProperty(
+        UrlGroupId: HTTP_URL_GROUP_ID,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+    ) -> ULONG;
+    pub fn HttpQueryUrlGroupProperty(
+        UrlGroupId: HTTP_URL_GROUP_ID,
+        Property: HTTP_SERVER_PROPERTY,
+        pPropertyInformation: PVOID,
+        PropertyInformationLength: ULONG,
+        pReturnLength: PULONG,
+    ) -> ULONG;
+    pub fn HttpPrepareUrl(
+        Reserved: PVOID,
+        Flags: ULONG,
+        Url: PCWSTR,
+        PreparedUrl: *mut PWSTR,
+    ) -> ULONG;
+    pub fn HttpReceiveHttpRequest(
+        ReqQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        Flags: ULONG,
+        pRequestBuffer: PHTTP_REQUEST,
+        RequestBufferLength: ULONG,
+        pBytesReturned: PULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpReceiveRequestEntityBody(
+        ReqQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        Flags: ULONG,
+        pBuffer: PVOID,
+        EntityBufferLength: ULONG,
+        pBytesReturned: PULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpSendHttpResponse(
+        ReqQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        Flags: ULONG,
+        pHttpResponse: PHTTP_RESPONSE,
+        pCachePolicy: PHTTP_CACHE_POLICY,
+        pBytesSent: PULONG,
+        pReserved1: PVOID,
+        Reserved2: ULONG,
+        pOverlapped: LPOVERLAPPED,
+        pLogData: PHTTP_LOG_DATA,
+    ) -> ULONG;
+    pub fn HttpSendResponseEntityBody(
+        ReqQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        Flags: ULONG,
+        EntityChunkCount: USHORT,
+        pEntityChunks: PHTTP_DATA_CHUNK,
+        pBytesSent: PULONG,
+        pReserved1: PVOID,
+        Reserved2: ULONG,
+        pOverlapped: LPOVERLAPPED,
+        pLogData: PHTTP_LOG_DATA,
+    ) -> ULONG;
+    pub fn HttpWaitForDisconnect(
+        ReqQueueHandle: HANDLE,
+        ConnectionId: HTTP_CONNECTION_ID,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpWaitForDisconnectEx(
+        ReqQueueHandle: HANDLE,
+        ConnectionId: HTTP_CONNECTION_ID,
+        Reserved: ULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpCancelHttpRequest(
+        ReqQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpWaitForDemandStart(
+        ReqQueueHandle: HANDLE,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpFlushResponseCache(
+        ReqQueueHandle: HANDLE,
+        pUrlPrefix: PCWSTR,
+        Flags: ULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpAddFragmentToCache(
+        ReqQueueHandle: HANDLE,
+        pUrlPrefix: PCWSTR,
+        pDataChunk: PHTTP_DATA_CHUNK,
+        pCachePolicy: PHTTP_CACHE_POLICY,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpReadFragmentFromCache(
+        ReqQueueHandle: HANDLE,
+        pUrlPrefix: PCWSTR,
+        pByteRange: PHTTP_BYTE_RANGE,
+        pBuffer: PVOID,
+        BufferLength: ULONG,
+        pBytesRead: PULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpSetServiceConfiguration(
+        ServiceHandle: HANDLE,
+        ConfigId: HTTP_SERVICE_CONFIG_ID,
+        pConfigInformation: PVOID,
+        ConfigInformationLength: ULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpDeleteServiceConfiguration(
+        ServiceHandle: HANDLE,
+        ConfigId: HTTP_SERVICE_CONFIG_ID,
+        pConfigInformation: PVOID,
+        ConfigInformationLength: ULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpQueryServiceConfiguration(
+        ServiceHandle: HANDLE,
+        ConfigId: HTTP_SERVICE_CONFIG_ID,
+        pInput: PVOID,
+        InputLength: ULONG,
+        pOutput: PVOID,
+        OutputLength: ULONG,
+        pReturnLength: PULONG,
+        pOverlapped: LPOVERLAPPED,
+    ) -> ULONG;
+    pub fn HttpDeclarePush(
+        RequestQueueHandle: HANDLE,
+        RequestId: HTTP_REQUEST_ID,
+        Verb: HTTP_VERB,
+        Path: PCWSTR,
+        Query: PCSTR,
+        Headers: PHTTP_REQUEST_HEADERS,
+    ) -> ULONG;
+    pub fn HttpUpdateServiceConfiguration(
+        Handle: HANDLE,
+        ConfigId: HTTP_SERVICE_CONFIG_ID,
+        ConfigInfo: PVOID,
+        ConfigInfoLength: ULONG,
+        Overlapped: LPOVERLAPPED,
+    ) -> ULONG;
+}