| // 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; |
| } |
