| // Copyright © 2015, skdltmxn |
| // Licensed under the MIT License <LICENSE.md> |
| //! HTTP API specification |
| 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) as ::ULONG; |
| 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] #[allow(dead_code)] |
| pub fn HTTP_SET_VERSION(mut version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) { |
| version.MajorVersion = major; |
| version.MinorVersion = minor; |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.MajorVersion == major && version.MinorVersion == minor |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTP_GREATER_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.MajorVersion > major || (version.MajorVersion == major && version.MinorVersion > minor) |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTP_LESS_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.MajorVersion < major || (version.MajorVersion == major && version.MinorVersion < minor) |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| !HTTP_EQUAL_VERSION(version, major, minor) |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| !HTTP_LESS_VERSION(version, major, minor) |
| } |
| #[inline] #[allow(dead_code)] |
| 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, |
| }} |
| STRUCT!{struct HTTP_DATA_CHUNK { |
| DataChunkType: HTTP_DATA_CHUNK_TYPE, |
| FromFileHandle: HTTP_DATA_CHUNK_FromFileHandle, |
| }} |
| UNION!(HTTP_DATA_CHUNK, FromFileHandle, FromMemory, FromMemory_mut, HTTP_DATA_CHUNK_FromMemory); |
| UNION!( |
| HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCache, FromFragmentCache_mut, |
| HTTP_DATA_CHUNK_FromFragmentCache |
| ); |
| UNION!( |
| HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCacheEx, FromFragmentCacheEx_mut, |
| HTTP_DATA_CHUNK_FromFragmentCacheEx |
| ); |
| pub type PHTTP_DATA_CHUNK = *mut HTTP_DATA_CHUNK; |
| STRUCT!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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] #[allow(dead_code)] |
| pub fn HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.HttpApiMajorVersion == major && version.HttpApiMinorVersion == minor |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.HttpApiMajorVersion > major || |
| (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion > minor) |
| } |
| #[inline] #[allow(dead_code)] |
| pub fn HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool { |
| version.HttpApiMajorVersion < major || |
| (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion < minor) |
| } |
| #[inline] #[allow(dead_code)] |
| 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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!{nodebug 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; |
