// Copyright © 2015, skdltmxn // Licensed under the MIT License //! 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;