mirror of
https://git.proxmox.com/git/rustc
synced 2025-08-14 12:43:32 +00:00
829 lines
30 KiB
Rust
829 lines
30 KiB
Rust
// 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;
|