1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! HTTP API specification
7 use shared::guiddef::GUID;
8 use shared::minwindef::{DWORD, PUCHAR, PULONG, UCHAR, ULONG, USHORT};
9 use shared::sspi::SECURITY_STATUS;
10 use shared::ws2def::{PSOCKADDR, SOCKADDR_STORAGE};
11 use um::minwinbase::{LPOVERLAPPED, PSECURITY_ATTRIBUTES};
12 use um::winnt::{
13     ANYSIZE_ARRAY, BOOLEAN, HANDLE, PCHAR, PCSTR, PCWSTR, PHANDLE, PSECURITY_DESCRIPTOR, PVOID,
14     PWCHAR, PWSTR, ULARGE_INTEGER, ULONGLONG,
15 };
16 pub const HTTP_INITIALIZE_SERVER: ULONG = 0x00000001;
17 pub const HTTP_INITIALIZE_CONFIG: ULONG = 0x00000002;
18 pub const HTTP_DEMAND_CBT: ULONG = 0x00000004;
19 ENUM!{enum HTTP_SERVER_PROPERTY {
20     HttpServerAuthenticationProperty,
21     HttpServerLoggingProperty,
22     HttpServerQosProperty,
23     HttpServerTimeoutsProperty,
24     HttpServerQueueLengthProperty,
25     HttpServerStateProperty,
26     HttpServer503VerbosityProperty,
27     HttpServerBindingProperty,
28     HttpServerExtendedAuthenticationProperty,
29     HttpServerListenEndpointProperty,
30     HttpServerChannelBindProperty,
31     HttpServerProtectionLevelProperty,
32 }}
33 pub type PHTTP_SERVER_PROPERTY = *mut HTTP_SERVER_PROPERTY;
34 STRUCT!{struct HTTP_PROPERTY_FLAGS {
35     BitFields: ULONG,
36 }}
37 BITFIELD!{HTTP_PROPERTY_FLAGS BitFields: ULONG [
38     Present set_Present[0..1],
39 ]}
40 pub type PHTTP_PROPERTY_FLAGS = *mut HTTP_PROPERTY_FLAGS;
41 ENUM!{enum HTTP_ENABLED_STATE {
42     HttpEnabledStateActive,
43     HttpEnabledStateInactive,
44 }}
45 pub type PHTTP_ENABLED_STATE = *mut HTTP_ENABLED_STATE;
46 STRUCT!{struct HTTP_STATE_INFO {
47     Flags: HTTP_PROPERTY_FLAGS,
48     State: HTTP_ENABLED_STATE,
49 }}
50 pub type PHTTP_STATE_INFO = *mut HTTP_STATE_INFO;
51 ENUM!{enum HTTP_503_RESPONSE_VERBOSITY {
52     Http503ResponseVerbosityBasic,
53     Http503ResponseVerbosityLimited,
54     Http503ResponseVerbosityFull,
55 }}
56 pub type PHTTP_503_RESPONSE_VERBOSITY = *mut HTTP_503_RESPONSE_VERBOSITY;
57 ENUM!{enum HTTP_QOS_SETTING_TYPE {
58     HttpQosSettingTypeBandwidth,
59     HttpQosSettingTypeConnectionLimit,
60     HttpQosSettingTypeFlowRate,
61 }}
62 pub type PHTTP_QOS_SETTING_TYPE = *mut HTTP_QOS_SETTING_TYPE;
63 STRUCT!{struct HTTP_QOS_SETTING_INFO {
64     QosType: HTTP_QOS_SETTING_TYPE,
65     QosSetting: PVOID,
66 }}
67 pub type PHTTP_QOS_SETTING_INFO = *mut HTTP_QOS_SETTING_INFO;
68 STRUCT!{struct HTTP_CONNECTION_LIMIT_INFO {
69     Flags: HTTP_PROPERTY_FLAGS,
70     MaxConnections: ULONG,
71 }}
72 pub type PHTTP_CONNECTION_LIMIT_INFO = *mut HTTP_CONNECTION_LIMIT_INFO;
73 STRUCT!{struct HTTP_BANDWIDTH_LIMIT_INFO {
74     Flags: HTTP_PROPERTY_FLAGS,
75     MaxBandwidth: ULONG,
76 }}
77 pub type PHTTP_BANDWIDTH_LIMIT_INFO = *mut HTTP_BANDWIDTH_LIMIT_INFO;
78 STRUCT!{struct HTTP_FLOWRATE_INFO {
79     Flags: HTTP_PROPERTY_FLAGS,
80     MaxBandwidth: ULONG,
81     MaxPeakBandwidth: ULONG,
82     BurstSize: ULONG,
83 }}
84 pub type PHTTP_FLOWRATE_INFO = *mut HTTP_FLOWRATE_INFO;
85 pub const HTTP_MIN_ALLOWED_BANDWIDTH_THROTTLING_RATE: ULONG = 1024;
86 pub const HTTP_LIMIT_INFINITE: ULONG = !0;
87 ENUM!{enum HTTP_SERVICE_CONFIG_TIMEOUT_KEY {
88     IdleConnectionTimeout = 0,
89     HeaderWaitTimeout,
90 }}
91 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_KEY = *mut HTTP_SERVICE_CONFIG_TIMEOUT_KEY;
92 pub type HTTP_SERVICE_CONFIG_TIMEOUT_PARAM = USHORT;
93 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_PARAM = *mut USHORT;
94 STRUCT!{struct HTTP_SERVICE_CONFIG_TIMEOUT_SET {
95     KeyDesc: HTTP_SERVICE_CONFIG_TIMEOUT_KEY,
96     ParamDesc: HTTP_SERVICE_CONFIG_TIMEOUT_PARAM,
97 }}
98 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_SET = *mut HTTP_SERVICE_CONFIG_TIMEOUT_SET;
99 STRUCT!{struct HTTP_TIMEOUT_LIMIT_INFO {
100     Flags: HTTP_PROPERTY_FLAGS,
101     EntityBody: USHORT,
102     DrainEntityBody: USHORT,
103     RequestQueue: USHORT,
104     IdleConnection: USHORT,
105     HeaderWait: USHORT,
106     MinSendRate: ULONG,
107 }}
108 pub type PHTTP_TIMEOUT_LIMIT_INFO = *mut HTTP_TIMEOUT_LIMIT_INFO;
109 STRUCT!{struct HTTP_LISTEN_ENDPOINT_INFO {
110     Flags: HTTP_PROPERTY_FLAGS,
111     EnableSharing: BOOLEAN,
112 }}
113 pub type PHTTP_LISTEN_ENDPOINT_INFO = *mut HTTP_LISTEN_ENDPOINT_INFO;
114 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS {
115     DomainNameLength: USHORT,
116     DomainName: PWSTR,
117     RealmLength: USHORT,
118     Realm: PWSTR,
119 }}
120 pub type PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS;
121 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS {
122     RealmLength: USHORT,
123     Realm: PWSTR,
124 }}
125 pub type PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS;
126 pub const HTTP_AUTH_ENABLE_BASIC: ULONG = 0x00000001;
127 pub const HTTP_AUTH_ENABLE_DIGEST: ULONG = 0x00000002;
128 pub const HTTP_AUTH_ENABLE_NTLM: ULONG = 0x00000004;
129 pub const HTTP_AUTH_ENABLE_NEGOTIATE: ULONG = 0x00000008;
130 pub const HTTP_AUTH_ENABLE_KERBEROS: ULONG = 0x00000010;
131 pub const HTTP_AUTH_ENABLE_ALL: ULONG = HTTP_AUTH_ENABLE_BASIC | HTTP_AUTH_ENABLE_DIGEST |
132     HTTP_AUTH_ENABLE_NTLM | HTTP_AUTH_ENABLE_NEGOTIATE | HTTP_AUTH_ENABLE_KERBEROS;
133 pub const HTTP_AUTH_EX_FLAG_ENABLE_KERBEROS_CREDENTIAL_CACHING: UCHAR = 0x01;
134 pub const HTTP_AUTH_EX_FLAG_CAPTURE_CREDENTIAL: UCHAR = 0x02;
135 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_INFO {
136     Flags: HTTP_PROPERTY_FLAGS,
137     AuthSchemes: ULONG,
138     ReceiveMutualAuth: BOOLEAN,
139     ReceiveContextHandle: BOOLEAN,
140     DisableNTLMCredentialCaching: BOOLEAN,
141     ExFlags: UCHAR,
142     DigestParams: HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS,
143     BasicParams: HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS,
144 }}
145 pub type PHTTP_SERVER_AUTHENTICATION_INFO = *mut HTTP_SERVER_AUTHENTICATION_INFO;
146 ENUM!{enum HTTP_SERVICE_BINDING_TYPE {
147     HttpServiceBindingTypeNone = 0,
148     HttpServiceBindingTypeW,
149     HttpServiceBindingTypeA,
150 }}
151 STRUCT!{struct HTTP_SERVICE_BINDING_BASE {
152     Type: HTTP_SERVICE_BINDING_TYPE,
153 }}
154 pub type PHTTP_SERVICE_BINDING_BASE = *mut HTTP_SERVICE_BINDING_BASE;
155 STRUCT!{struct HTTP_SERVICE_BINDING_A {
156     Base: HTTP_SERVICE_BINDING_BASE,
157     Buffer: PCHAR,
158     BufferSize: ULONG,
159 }}
160 pub type PHTTP_SERVICE_BINDING_A = *mut HTTP_SERVICE_BINDING_A;
161 STRUCT!{struct HTTP_SERVICE_BINDING_W {
162     Base: HTTP_SERVICE_BINDING_BASE,
163     Buffer: PWCHAR,
164     BufferSize: ULONG,
165 }}
166 pub type PHTTP_SERVICE_BINDING_W = *mut HTTP_SERVICE_BINDING_W;
167 ENUM!{enum HTTP_AUTHENTICATION_HARDENING_LEVELS {
168     HttpAuthenticationHardeningLegacy = 0,
169     HttpAuthenticationHardeningMedium,
170     HttpAuthenticationHardeningStrict,
171 }}
172 pub const HTTP_CHANNEL_BIND_PROXY: ULONG = 0x1;
173 pub const HTTP_CHANNEL_BIND_PROXY_COHOSTING: ULONG = 0x20;
174 pub const HTTP_CHANNEL_BIND_NO_SERVICE_NAME_CHECK: ULONG = 0x2;
175 pub const HTTP_CHANNEL_BIND_DOTLESS_SERVICE: ULONG = 0x4;
176 pub const HTTP_CHANNEL_BIND_SECURE_CHANNEL_TOKEN: ULONG = 0x8;
177 pub const HTTP_CHANNEL_BIND_CLIENT_SERVICE: ULONG = 0x10;
178 STRUCT!{struct HTTP_CHANNEL_BIND_INFO {
179     Hardening: HTTP_AUTHENTICATION_HARDENING_LEVELS,
180     Flags: ULONG,
181     ServiceNames: *mut PHTTP_SERVICE_BINDING_BASE,
182     NumberOfServiceNames: ULONG,
183 }}
184 pub type PHTTP_CHANNEL_BIND_INFO = *mut HTTP_CHANNEL_BIND_INFO;
185 STRUCT!{struct HTTP_REQUEST_CHANNEL_BIND_STATUS {
186     ServiceName: PHTTP_SERVICE_BINDING_BASE,
187     ChannelToken: PUCHAR,
188     ChannelTokenSize: ULONG,
189     Flags: ULONG,
190 }}
191 pub type PHTTP_REQUEST_CHANNEL_BIND_STATUS = *mut HTTP_REQUEST_CHANNEL_BIND_STATUS;
192 pub const HTTP_LOG_FIELD_DATE: ULONG = 0x00000001;
193 pub const HTTP_LOG_FIELD_TIME: ULONG = 0x00000002;
194 pub const HTTP_LOG_FIELD_CLIENT_IP: ULONG = 0x00000004;
195 pub const HTTP_LOG_FIELD_USER_NAME: ULONG = 0x00000008;
196 pub const HTTP_LOG_FIELD_SITE_NAME: ULONG = 0x00000010;
197 pub const HTTP_LOG_FIELD_COMPUTER_NAME: ULONG = 0x00000020;
198 pub const HTTP_LOG_FIELD_SERVER_IP: ULONG = 0x00000040;
199 pub const HTTP_LOG_FIELD_METHOD: ULONG = 0x00000080;
200 pub const HTTP_LOG_FIELD_URI_STEM: ULONG = 0x00000100;
201 pub const HTTP_LOG_FIELD_URI_QUERY: ULONG = 0x00000200;
202 pub const HTTP_LOG_FIELD_STATUS: ULONG = 0x00000400;
203 pub const HTTP_LOG_FIELD_WIN32_STATUS: ULONG = 0x00000800;
204 pub const HTTP_LOG_FIELD_BYTES_SENT: ULONG = 0x00001000;
205 pub const HTTP_LOG_FIELD_BYTES_RECV: ULONG = 0x00002000;
206 pub const HTTP_LOG_FIELD_TIME_TAKEN: ULONG = 0x00004000;
207 pub const HTTP_LOG_FIELD_SERVER_PORT: ULONG = 0x00008000;
208 pub const HTTP_LOG_FIELD_USER_AGENT: ULONG = 0x00010000;
209 pub const HTTP_LOG_FIELD_COOKIE: ULONG = 0x00020000;
210 pub const HTTP_LOG_FIELD_REFERER: ULONG = 0x00040000;
211 pub const HTTP_LOG_FIELD_VERSION: ULONG = 0x00080000;
212 pub const HTTP_LOG_FIELD_HOST: ULONG = 0x00100000;
213 pub const HTTP_LOG_FIELD_SUB_STATUS: ULONG = 0x00200000;
214 pub const HTTP_LOG_FIELD_CLIENT_PORT: ULONG = 0x00400000;
215 pub const HTTP_LOG_FIELD_URI: ULONG = 0x00800000;
216 pub const HTTP_LOG_FIELD_SITE_ID: ULONG = 0x01000000;
217 pub const HTTP_LOG_FIELD_REASON: ULONG = 0x02000000;
218 pub const HTTP_LOG_FIELD_QUEUE_NAME: ULONG = 0x04000000;
219 ENUM!{enum HTTP_LOGGING_TYPE {
220     HttpLoggingTypeW3C,
221     HttpLoggingTypeIIS,
222     HttpLoggingTypeNCSA,
223     HttpLoggingTypeRaw,
224 }}
225 ENUM!{enum HTTP_LOGGING_ROLLOVER_TYPE {
226     HttpLoggingRolloverSize,
227     HttpLoggingRolloverDaily,
228     HttpLoggingRolloverWeekly,
229     HttpLoggingRolloverMonthly,
230     HttpLoggingRolloverHourly,
231 }}
232 pub const HTTP_MIN_ALLOWED_LOG_FILE_ROLLOVER_SIZE: ULONG = 1 * 1024 * 1024;
233 pub const HTTP_LOGGING_FLAG_LOCAL_TIME_ROLLOVER: ULONG = 0x00000001;
234 pub const HTTP_LOGGING_FLAG_USE_UTF8_CONVERSION: ULONG = 0x00000002;
235 pub const HTTP_LOGGING_FLAG_LOG_ERRORS_ONLY: ULONG = 0x00000004;
236 pub const HTTP_LOGGING_FLAG_LOG_SUCCESS_ONLY: ULONG = 0x00000008;
237 STRUCT!{struct HTTP_LOGGING_INFO {
238     Flags: HTTP_PROPERTY_FLAGS,
239     LoggingFlags: ULONG,
240     SoftwareName: PCWSTR,
241     SoftwareNameLength: USHORT,
242     DirectoryNameLength: USHORT,
243     DirectoryName: PCWSTR,
244     Format: HTTP_LOGGING_TYPE,
245     Fields: ULONG,
246     pExtFields: PVOID,
247     NumOfExtFields: USHORT,
248     MaxRecordSize: USHORT,
249     RolloverType: HTTP_LOGGING_ROLLOVER_TYPE,
250     RolloverSize: ULONG,
251     pSecurityDescriptor: PSECURITY_DESCRIPTOR,
252 }}
253 pub type PHTTP_LOGGING_INFO = *mut HTTP_LOGGING_INFO;
254 STRUCT!{struct HTTP_BINDING_INFO {
255     Flags: HTTP_PROPERTY_FLAGS,
256     RequestQueueHandle: HANDLE,
257 }}
258 pub type PHTTP_BINDING_INFO = *mut HTTP_BINDING_INFO;
259 ENUM!{enum HTTP_PROTECTION_LEVEL_TYPE {
260     HttpProtectionLevelUnrestricted,
261     HttpProtectionLevelEdgeRestricted,
262     HttpProtectionLevelRestricted,
263 }}
264 pub type PHTTP_PROTECTION_LEVEL_TYPE = *mut HTTP_PROTECTION_LEVEL_TYPE;
265 STRUCT!{struct HTTP_PROTECTION_LEVEL_INFO {
266     Flags: HTTP_PROPERTY_FLAGS,
267     Level: HTTP_PROTECTION_LEVEL_TYPE,
268 }}
269 pub type PHTTP_PROTECTION_LEVEL_INFO = *mut HTTP_PROTECTION_LEVEL_INFO;
270 pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_OPEN_EXISTING: ULONG = 0x00000001;
271 pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_CONTROLLER: ULONG = 0x00000002;
272 pub const HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY: ULONG = 0x00000001;
273 pub const HTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODY: ULONG = 0x00000002;
274 pub const HTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFER: ULONG = 0x00000001;
275 pub const HTTP_SEND_RESPONSE_FLAG_DISCONNECT: ULONG = 0x00000001;
276 pub const HTTP_SEND_RESPONSE_FLAG_MORE_DATA: ULONG = 0x00000002;
277 pub const HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA: ULONG = 0x00000004;
278 pub const HTTP_SEND_RESPONSE_FLAG_ENABLE_NAGLING: ULONG = 0x00000008;
279 pub const HTTP_SEND_RESPONSE_FLAG_PROCESS_RANGES: ULONG = 0x00000020;
280 pub const HTTP_SEND_RESPONSE_FLAG_OPAQUE: ULONG = 0x00000040;
281 pub const HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE: ULONG = 0x00000001;
282 pub type HTTP_OPAQUE_ID = ULONGLONG;
283 pub type PHTTP_OPAQUE_ID = *mut ULONGLONG;
284 pub type HTTP_REQUEST_ID = HTTP_OPAQUE_ID;
285 pub type PHTTP_REQUEST_ID = *mut HTTP_OPAQUE_ID;
286 pub type HTTP_CONNECTION_ID = HTTP_OPAQUE_ID;
287 pub type PHTTP_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
288 pub type HTTP_RAW_CONNECTION_ID = HTTP_OPAQUE_ID;
289 pub type PHTTP_RAW_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
290 pub type HTTP_URL_GROUP_ID = HTTP_OPAQUE_ID;
291 pub type PHTTP_URL_GROUP_ID = *mut HTTP_OPAQUE_ID;
292 pub type HTTP_SERVER_SESSION_ID = HTTP_OPAQUE_ID;
293 pub type PHTTP_SERVER_SESSION_ID = *mut HTTP_OPAQUE_ID;
294 pub const HTTP_BYTE_RANGE_TO_EOF: ULONGLONG = !0;
295 STRUCT!{struct HTTP_BYTE_RANGE {
296     StartingOffset: ULARGE_INTEGER,
297     Length: ULARGE_INTEGER,
298 }}
299 pub type PHTTP_BYTE_RANGE = *mut HTTP_BYTE_RANGE;
300 STRUCT!{struct HTTP_VERSION {
301     MajorVersion: USHORT,
302     MinorVersion: USHORT,
303 }}
304 pub type PHTTP_VERSION = *mut HTTP_VERSION;
305 pub const HTTP_VERSION_UNKNOWN: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 0 };
306 pub const HTTP_VERSION_0_9: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 9 };
307 pub const HTTP_VERSION_1_0: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 0 };
308 pub const HTTP_VERSION_1_1: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 1 };
309 #[inline]
HTTP_SET_VERSION(mut version: HTTP_VERSION, major: USHORT, minor: USHORT)310 pub fn HTTP_SET_VERSION(mut version: HTTP_VERSION, major: USHORT, minor: USHORT) {
311     version.MajorVersion = major;
312     version.MinorVersion = minor;
313 }
314 #[inline]
HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool315 pub fn HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
316     version.MajorVersion == major && version.MinorVersion == minor
317 }
318 #[inline]
HTTP_GREATER_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool319 pub fn HTTP_GREATER_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
320     version.MajorVersion > major || (version.MajorVersion == major && version.MinorVersion > minor)
321 }
322 #[inline]
HTTP_LESS_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool323 pub fn HTTP_LESS_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
324     version.MajorVersion < major || (version.MajorVersion == major && version.MinorVersion < minor)
325 }
326 #[inline]
HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool327 pub fn HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
328     !HTTP_EQUAL_VERSION(version, major, minor)
329 }
330 #[inline]
HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool331 pub fn HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
332     !HTTP_LESS_VERSION(version, major, minor)
333 }
334 #[inline]
HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool335 pub fn HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: USHORT, minor: USHORT) -> bool {
336     !HTTP_GREATER_VERSION(version, major, minor)
337 }
338 ENUM!{enum HTTP_VERB {
339     HttpVerbUnparsed,
340     HttpVerbUnknown,
341     HttpVerbInvalid,
342     HttpVerbOPTIONS,
343     HttpVerbGET,
344     HttpVerbHEAD,
345     HttpVerbPOST,
346     HttpVerbPUT,
347     HttpVerbDELETE,
348     HttpVerbTRACE,
349     HttpVerbCONNECT,
350     HttpVerbTRACK,
351     HttpVerbMOVE,
352     HttpVerbCOPY,
353     HttpVerbPROPFIND,
354     HttpVerbPROPPATCH,
355     HttpVerbMKCOL,
356     HttpVerbLOCK,
357     HttpVerbUNLOCK,
358     HttpVerbSEARCH,
359     HttpVerbMaximum,
360 }}
361 pub type PHTTP_VERB = *mut HTTP_VERB;
362 ENUM!{enum HTTP_HEADER_ID {
363     HttpHeaderCacheControl = 0,
364     HttpHeaderConnection = 1,
365     HttpHeaderDate = 2,
366     HttpHeaderKeepAlive = 3,
367     HttpHeaderPragma = 4,
368     HttpHeaderTrailer = 5,
369     HttpHeaderTransferEncoding = 6,
370     HttpHeaderUpgrade = 7,
371     HttpHeaderVia = 8,
372     HttpHeaderWarning = 9,
373     HttpHeaderAllow = 10,
374     HttpHeaderContentLength = 11,
375     HttpHeaderContentType = 12,
376     HttpHeaderContentEncoding = 13,
377     HttpHeaderContentLanguage = 14,
378     HttpHeaderContentLocation = 15,
379     HttpHeaderContentMd5 = 16,
380     HttpHeaderContentRange = 17,
381     HttpHeaderExpires = 18,
382     HttpHeaderLastModified = 19,
383     HttpHeaderAccept = 20,
384     HttpHeaderAcceptCharset = 21,
385     HttpHeaderAcceptEncoding = 22,
386     HttpHeaderAcceptLanguage = 23,
387     HttpHeaderAuthorization = 24,
388     HttpHeaderCookie = 25,
389     HttpHeaderExpect = 26,
390     HttpHeaderFrom = 27,
391     HttpHeaderHost = 28,
392     HttpHeaderIfMatch = 29,
393     HttpHeaderIfModifiedSince = 30,
394     HttpHeaderIfNoneMatch = 31,
395     HttpHeaderIfRange = 32,
396     HttpHeaderIfUnmodifiedSince = 33,
397     HttpHeaderMaxForwards = 34,
398     HttpHeaderProxyAuthorization = 35,
399     HttpHeaderReferer = 36,
400     HttpHeaderRange = 37,
401     HttpHeaderTe = 38,
402     HttpHeaderTranslate = 39,
403     HttpHeaderUserAgent = 40,
404     HttpHeaderRequestMaximum = 41,
405     HttpHeaderAcceptRanges = 20,
406     HttpHeaderAge = 21,
407     HttpHeaderEtag = 22,
408     HttpHeaderLocation = 23,
409     HttpHeaderProxyAuthenticate = 24,
410     HttpHeaderRetryAfter = 25,
411     HttpHeaderServer = 26,
412     HttpHeaderSetCookie = 27,
413     HttpHeaderVary = 28,
414     HttpHeaderWwwAuthenticate = 29,
415     HttpHeaderResponseMaximum = 30,
416     HttpHeaderMaximum = 41,
417 }}
418 pub type PHTTP_HEADER_ID = *mut HTTP_HEADER_ID;
419 STRUCT!{struct HTTP_KNOWN_HEADER {
420     RawValueLength: USHORT,
421     pRawValue: PCSTR,
422 }}
423 pub type PHTTP_KNOWN_HEADER = *mut HTTP_KNOWN_HEADER;
424 STRUCT!{struct HTTP_UNKNOWN_HEADER {
425     NameLength: USHORT,
426     RawValueLength: USHORT,
427     pName: PCSTR,
428     pRawValue: PCSTR,
429 }}
430 pub type PHTTP_UNKNOWN_HEADER = *mut HTTP_UNKNOWN_HEADER;
431 ENUM!{enum HTTP_LOG_DATA_TYPE {
432     HttpLogDataTypeFields = 0,
433 }}
434 pub type PHTTP_LOG_DATA_TYPE = *mut HTTP_LOG_DATA_TYPE;
435 STRUCT!{struct HTTP_LOG_DATA {
436     Type: HTTP_LOG_DATA_TYPE,
437 }}
438 pub type PHTTP_LOG_DATA = *mut HTTP_LOG_DATA;
439 STRUCT!{struct HTTP_LOG_FIELDS_DATA {
440     Base: HTTP_LOG_DATA,
441     UserNameLength: USHORT,
442     UriStemLength: USHORT,
443     ClientIpLength: USHORT,
444     ServerNameLength: USHORT,
445     ServiceNameLength: USHORT,
446     ServerIpLength: USHORT,
447     MethodLength: USHORT,
448     UriQueryLength: USHORT,
449     HostLength: USHORT,
450     UserAgentLength: USHORT,
451     CookieLength: USHORT,
452     ReferrerLength: USHORT,
453     UserName: PWCHAR,
454     UriStem: PWCHAR,
455     ClientIp: PCHAR,
456     ServerName: PCHAR,
457     ServiceName: PCHAR,
458     ServerIp: PCHAR,
459     Method: PCHAR,
460     UriQuery: PCHAR,
461     Host: PCHAR,
462     UserAgent: PCHAR,
463     Cookie: PCHAR,
464     Referrer: PCHAR,
465     ServerPort: USHORT,
466     ProtocolStatus: USHORT,
467     Win32Status: ULONG,
468     MethodNum: HTTP_VERB,
469     SubStatus: USHORT,
470 }}
471 pub type PHTTP_LOG_FIELDS_DATA = *mut HTTP_LOG_FIELDS_DATA;
472 ENUM!{enum HTTP_DATA_CHUNK_TYPE {
473     HttpDataChunkFromMemory,
474     HttpDataChunkFromFileHandle,
475     HttpDataChunkFromFragmentCache,
476     HttpDataChunkFromFragmentCacheEx,
477     HttpDataChunkMaximum,
478 }}
479 pub type PHTTP_DATA_CHUNK_TYPE = *mut HTTP_DATA_CHUNK_TYPE;
480 STRUCT!{struct HTTP_DATA_CHUNK_FromMemory {
481     pBuffer: PVOID,
482     BufferLength: ULONG,
483 }}
484 STRUCT!{struct HTTP_DATA_CHUNK_FromFileHandle {
485     ByteRange: HTTP_BYTE_RANGE,
486     FileHandle: HANDLE,
487 }}
488 STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCache {
489     FragmentNameLength: USHORT,
490     pFragmentName: PCWSTR,
491 }}
492 STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCacheEx {
493     ByteRange: HTTP_BYTE_RANGE,
494     pFragmentName: PCWSTR,
495 }}
496 UNION!{union HTTP_DATA_CHUNK_u {
497     [u64; 3],
498     FromMemory FromMemory_mut: HTTP_DATA_CHUNK_FromMemory,
499     FromFileHandle FromFileHandle_mut: HTTP_DATA_CHUNK_FromFileHandle,
500     FromFragmentCache FromFragmentCache_mut: HTTP_DATA_CHUNK_FromFragmentCache,
501     FromFragmentCacheEx FromFragmentCacheEx_mut: HTTP_DATA_CHUNK_FromFragmentCacheEx,
502 }}
503 STRUCT!{struct HTTP_DATA_CHUNK {
504     DataChunkType: HTTP_DATA_CHUNK_TYPE,
505     u: HTTP_DATA_CHUNK_u,
506 }}
507 pub type PHTTP_DATA_CHUNK = *mut HTTP_DATA_CHUNK;
508 STRUCT!{struct HTTP_REQUEST_HEADERS {
509     UnknownHeaderCount: USHORT,
510     pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
511     TrailerCount: USHORT,
512     pTrailers: PHTTP_UNKNOWN_HEADER,
513     KnownHeaders: [HTTP_KNOWN_HEADER; 41], // FIXME HttpHeaderRequestMaximum
514 }}
515 pub type PHTTP_REQUEST_HEADERS = *mut HTTP_REQUEST_HEADERS;
516 STRUCT!{struct HTTP_RESPONSE_HEADERS {
517     UnknownHeaderCount: USHORT,
518     pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
519     TrailerCount: USHORT,
520     pTrailers: PHTTP_UNKNOWN_HEADER,
521     KnownHeaders: [HTTP_KNOWN_HEADER; 30], // FIXME HttpHeaderResponseMaximum
522 }}
523 pub type PHTTP_RESPONSE_HEADERS = *mut HTTP_RESPONSE_HEADERS;
524 STRUCT!{struct HTTP_TRANSPORT_ADDRESS {
525     pRemoteAddress: PSOCKADDR,
526     pLocalAddress: PSOCKADDR,
527 }}
528 pub type PHTTP_TRANSPORT_ADDRESS = *mut HTTP_TRANSPORT_ADDRESS;
529 STRUCT!{struct HTTP_COOKED_URL {
530     FullUrlLength: USHORT,
531     HostLength: USHORT,
532     AbsPathLength: USHORT,
533     QueryStringLength: USHORT,
534     pFullUrl: PCWSTR,
535     pHost: PCWSTR,
536     pAbsPath: PCWSTR,
537     pQueryString: PCWSTR,
538 }}
539 pub type PHTTP_COOKED_URL = *mut HTTP_COOKED_URL;
540 pub type HTTP_URL_CONTEXT = ULONGLONG;
541 pub const HTTP_URL_FLAG_REMOVE_ALL: ULONG = 0x00000001;
542 ENUM!{enum HTTP_AUTH_STATUS {
543     HttpAuthStatusSuccess,
544     HttpAuthStatusNotAuthenticated,
545     HttpAuthStatusFailure,
546 }}
547 pub type PHTTP_AUTH_STATUS = *mut HTTP_AUTH_STATUS;
548 ENUM!{enum HTTP_REQUEST_AUTH_TYPE {
549     HttpRequestAuthTypeNone = 0,
550     HttpRequestAuthTypeBasic,
551     HttpRequestAuthTypeDigest,
552     HttpRequestAuthTypeNTLM,
553     HttpRequestAuthTypeNegotiate,
554     HttpRequestAuthTypeKerberos,
555 }}
556 pub type PHTTP_REQUEST_AUTH_TYPE = *mut HTTP_REQUEST_AUTH_TYPE;
557 STRUCT!{struct HTTP_SSL_CLIENT_CERT_INFO {
558     CertFlags: ULONG,
559     CertEncodedSize: ULONG,
560     pCertEncoded: PUCHAR,
561     Token: HANDLE,
562     CertDeniedByMapper: BOOLEAN,
563 }}
564 pub type PHTTP_SSL_CLIENT_CERT_INFO = *mut HTTP_SSL_CLIENT_CERT_INFO;
565 pub const HTTP_RECEIVE_SECURE_CHANNEL_TOKEN: ULONG = 0x1;
566 STRUCT!{struct HTTP_SSL_INFO {
567     ServerCertKeySize: USHORT,
568     ConnectionKeySize: USHORT,
569     ServerCertIssuerSize: ULONG,
570     ServerCertSubjectSize: ULONG,
571     pServerCertIssuer: PCSTR,
572     pServerCertSubject: PCSTR,
573     pClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
574     SslClientCertNegotiated: ULONG,
575 }}
576 pub type PHTTP_SSL_INFO = *mut HTTP_SSL_INFO;
577 ENUM!{enum HTTP_REQUEST_INFO_TYPE {
578     HttpRequestInfoTypeAuth,
579     HttpRequestInfoTypeChannelBind,
580 }}
581 STRUCT!{struct HTTP_REQUEST_INFO {
582     InfoType: HTTP_REQUEST_INFO_TYPE,
583     InfoLength: ULONG,
584     pInfo: PVOID,
585 }}
586 pub type PHTTP_REQUEST_INFO = *mut HTTP_REQUEST_INFO;
587 pub const HTTP_REQUEST_AUTH_FLAG_TOKEN_FOR_CACHED_CRED: ULONG = 0x00000001;
588 STRUCT!{struct HTTP_REQUEST_AUTH_INFO {
589     AuthStatus: HTTP_AUTH_STATUS,
590     SecStatus: SECURITY_STATUS,
591     Flags: ULONG,
592     AuthType: HTTP_REQUEST_AUTH_TYPE,
593     AccessToken: HANDLE,
594     ContextAttributes: ULONG,
595     PackedContextLength: ULONG,
596     PackedContextType: ULONG,
597     PackedContext: PVOID,
598     MutualAuthDataLength: ULONG,
599     pMutualAuthData: PCHAR,
600     PackageNameLength: USHORT,
601     pPackageName: PWSTR,
602 }}
603 pub type PHTTP_REQUEST_AUTH_INFO = *mut HTTP_REQUEST_AUTH_INFO;
604 STRUCT!{struct HTTP_REQUEST_V1 {
605     Flags: ULONG,
606     ConnectionId: HTTP_CONNECTION_ID,
607     RequestId: HTTP_REQUEST_ID,
608     UrlContext: HTTP_URL_CONTEXT,
609     Version: HTTP_VERSION,
610     Verb: HTTP_VERB,
611     UnknownVerbLength: USHORT,
612     RawUrlLength: USHORT,
613     pUnknownVerb: PCSTR,
614     pRawUrl: PCSTR,
615     CookedUrl: HTTP_COOKED_URL,
616     Address: HTTP_TRANSPORT_ADDRESS,
617     Headers: HTTP_REQUEST_HEADERS,
618     BytesReceived: ULONGLONG,
619     EntityChunkCount: USHORT,
620     pEntityChunks: PHTTP_DATA_CHUNK,
621     RawConnectionId: HTTP_RAW_CONNECTION_ID,
622     pSslInfo: PHTTP_SSL_INFO,
623 }}
624 pub type PHTTP_REQUEST_V1 = *mut HTTP_REQUEST_V1;
625 STRUCT!{struct HTTP_REQUEST_V2 {
626     Base: HTTP_REQUEST_V1,
627     RequestInfoCount: USHORT,
628     pRequestInfo: PHTTP_REQUEST_INFO,
629 }}
630 pub type PHTTP_REQUEST_V2 = *mut HTTP_REQUEST_V2;
631 pub type HTTP_REQUEST = HTTP_REQUEST_V2;
632 pub type PHTTP_REQUEST = *mut HTTP_REQUEST;
633 pub const HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS: ULONG = 0x00000001;
634 pub const HTTP_REQUEST_FLAG_IP_ROUTED: ULONG = 0x00000002;
635 STRUCT!{struct HTTP_RESPONSE_V1 {
636     Flags: ULONG,
637     Version: HTTP_VERSION,
638     StatusCode: USHORT,
639     ReasonLength: USHORT,
640     pReason: PCSTR,
641     Headers: HTTP_RESPONSE_HEADERS,
642     EntityChunkCount: USHORT,
643     pEntityChunks: PHTTP_DATA_CHUNK,
644 }}
645 pub type PHTTP_RESPONSE_V1 = *mut HTTP_RESPONSE_V1;
646 pub const HTTP_RESPONSE_FLAG_MULTIPLE_ENCODINGS_AVAILABLE: ULONG = 0x00000001;
647 ENUM!{enum HTTP_RESPONSE_INFO_TYPE {
648     HttpResponseInfoTypeMultipleKnownHeaders,
649     HttpResponseInfoTypeAuthenticationProperty,
650     HttpResponseInfoTypeQoSProperty,
651     HttpResponseInfoTypeChannelBind,
652 }}
653 pub type PHTTP_RESPONSE_INFO_TYPE = *mut HTTP_RESPONSE_INFO_TYPE;
654 STRUCT!{struct HTTP_RESPONSE_INFO {
655     Type: HTTP_RESPONSE_INFO_TYPE,
656     Length: ULONG,
657     pInfo: PVOID,
658 }}
659 pub type PHTTP_RESPONSE_INFO = *mut HTTP_RESPONSE_INFO;
660 pub const HTTP_RESPONSE_INFO_FLAGS_PRESERVE_ORDER: ULONG = 0x00000001;
661 STRUCT!{struct HTTP_MULTIPLE_KNOWN_HEADERS {
662     HeaderId: HTTP_HEADER_ID,
663     Flags: ULONG,
664     KnownHeaderCount: USHORT,
665     KnownHeaders: PHTTP_KNOWN_HEADER,
666 }}
667 pub type PHTTP_MULTIPLE_KNOWN_HEADERS = *mut HTTP_MULTIPLE_KNOWN_HEADERS;
668 STRUCT!{struct HTTP_RESPONSE_V2 {
669     Base: HTTP_RESPONSE_V1,
670     ResponseInfoCount: USHORT,
671     pResponseInfo: PHTTP_RESPONSE_INFO,
672 }}
673 pub type PHTTP_RESPONSE_V2 = *mut HTTP_RESPONSE_V2;
674 pub type HTTP_RESPONSE = HTTP_RESPONSE_V2;
675 pub type PHTTP_RESPONSE = *mut HTTP_RESPONSE;
676 STRUCT!{struct HTTPAPI_VERSION {
677     HttpApiMajorVersion: USHORT,
678     HttpApiMinorVersion: USHORT,
679 }}
680 pub type PHTTPAPI_VERSION = *mut HTTPAPI_VERSION;
681 pub const HTTPAPI_VERSION_2: HTTPAPI_VERSION = HTTPAPI_VERSION {
682     HttpApiMajorVersion: 2,
683     HttpApiMinorVersion: 0,
684 };
685 pub const HTTPAPI_VERSION_1: HTTPAPI_VERSION = HTTPAPI_VERSION {
686     HttpApiMajorVersion: 1,
687     HttpApiMinorVersion: 0,
688 };
689 #[inline]
HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool690 pub fn HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
691     version.HttpApiMajorVersion == major && version.HttpApiMinorVersion == minor
692 }
693 #[inline]
HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool694 pub fn HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
695     version.HttpApiMajorVersion > major ||
696     (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion > minor)
697 }
698 #[inline]
HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool699 pub fn HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: USHORT, minor: USHORT) -> bool {
700     version.HttpApiMajorVersion < major ||
701     (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion < minor)
702 }
703 #[inline]
HTTPAPI_VERSION_GREATER_OR_EQUAL( version: HTTPAPI_VERSION, major: USHORT, minor: USHORT, ) -> bool704 pub fn HTTPAPI_VERSION_GREATER_OR_EQUAL(
705     version: HTTPAPI_VERSION,
706     major: USHORT,
707     minor: USHORT,
708 ) -> bool {
709     !HTTPAPI_LESS_VERSION(version, major, minor)
710 }
711 ENUM!{enum HTTP_CACHE_POLICY_TYPE {
712     HttpCachePolicyNocache,
713     HttpCachePolicyUserInvalidates,
714     HttpCachePolicyTimeToLive,
715     HttpCachePolicyMaximum,
716 }}
717 pub type PHTTP_CACHE_POLICY_TYPE = *mut HTTP_CACHE_POLICY_TYPE;
718 STRUCT!{struct HTTP_CACHE_POLICY {
719     Policy: HTTP_CACHE_POLICY_TYPE,
720     SecondsToLive: ULONG,
721 }}
722 pub type PHTTP_CACHE_POLICY = *mut HTTP_CACHE_POLICY;
723 ENUM!{enum HTTP_SERVICE_CONFIG_ID {
724     HttpServiceConfigIPListenList,
725     HttpServiceConfigSSLCertInfo,
726     HttpServiceConfigUrlAclInfo,
727     HttpServiceConfigTimeout,
728     HttpServiceConfigCache,
729     HttpServiceConfigSslSniCertInfo,
730     HttpServiceConfigSslCcsCertInfo,
731     HttpServiceConfigMax,
732 }}
733 pub type PHTTP_SERVICE_CONFIG_ID = *mut HTTP_SERVICE_CONFIG_ID;
734 ENUM!{enum HTTP_SERVICE_CONFIG_QUERY_TYPE {
735     HttpServiceConfigQueryExact,
736     HttpServiceConfigQueryNext,
737     HttpServiceConfigQueryMax,
738 }}
739 pub type PHTTP_SERVICE_CONFIG_QUERY_TYPE = *mut HTTP_SERVICE_CONFIG_QUERY_TYPE;
740 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_KEY {
741     pIpPort: PSOCKADDR,
742 }}
743 pub type PHTTP_SERVICE_CONFIG_SSL_KEY = *mut HTTP_SERVICE_CONFIG_SSL_KEY;
744 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_KEY {
745     IpPort: SOCKADDR_STORAGE,
746     Host: PWSTR,
747 }}
748 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_KEY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_KEY;
749 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_KEY {
750     LocalAddress: SOCKADDR_STORAGE,
751 }}
752 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_KEY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_KEY;
753 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_PARAM {
754     SslHashLength: ULONG,
755     pSslHash: PVOID,
756     AppId: GUID,
757     pSslCertStoreName: PWSTR,
758     DefaultCertCheckMode: DWORD,
759     DefaultRevocationFreshnessTime: DWORD,
760     DefaultRevocationUrlRetrievalTimeout: DWORD,
761     pDefaultSslCtlIdentifier: PWSTR,
762     pDefaultSslCtlStoreName: PWSTR,
763     DefaultFlags: DWORD,
764 }}
765 pub type PHTTP_SERVICE_CONFIG_SSL_PARAM = *mut HTTP_SERVICE_CONFIG_SSL_PARAM;
766 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER: DWORD = 0x00000001;
767 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT: DWORD = 0x00000002;
768 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER: DWORD = 0x00000004;
769 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SET {
770     KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
771     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
772 }}
773 pub type PHTTP_SERVICE_CONFIG_SSL_SET = *mut HTTP_SERVICE_CONFIG_SSL_SET;
774 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_SET {
775     KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
776     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
777 }}
778 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_SET = *mut HTTP_SERVICE_CONFIG_SSL_SNI_SET;
779 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_SET {
780     KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
781     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
782 }}
783 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_SET = *mut HTTP_SERVICE_CONFIG_SSL_CCS_SET;
784 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_QUERY {
785     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
786     KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
787     dwToken: DWORD,
788 }}
789 pub type PHTTP_SERVICE_CONFIG_SSL_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_QUERY;
790 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SNI_QUERY {
791     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
792     KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
793     dwToken: DWORD,
794 }}
795 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_QUERY;
796 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_CCS_QUERY {
797     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
798     KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
799     dwToken: DWORD,
800 }}
801 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_QUERY;
802 STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM {
803     AddrLength: USHORT,
804     pAddress: PSOCKADDR,
805 }}
806 pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM;
807 STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY {
808     AddrCount: ULONG,
809     AddrList: [SOCKADDR_STORAGE; ANYSIZE_ARRAY],
810 }}
811 pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY;
812 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_KEY {
813     pUrlPrefix: PWSTR,
814 }}
815 pub type PHTTP_SERVICE_CONFIG_URLACL_KEY = *mut HTTP_SERVICE_CONFIG_URLACL_KEY;
816 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_PARAM {
817     pStringSecurityDescriptor: PWSTR,
818 }}
819 pub type PHTTP_SERVICE_CONFIG_URLACL_PARAM = *mut HTTP_SERVICE_CONFIG_URLACL_PARAM;
820 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_SET {
821     KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
822     ParamDesc: HTTP_SERVICE_CONFIG_URLACL_PARAM,
823 }}
824 pub type PHTTP_SERVICE_CONFIG_URLACL_SET = *mut HTTP_SERVICE_CONFIG_URLACL_SET;
825 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_QUERY {
826     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
827     KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
828     dwToken: DWORD,
829 }}
830 pub type PHTTP_SERVICE_CONFIG_URLACL_QUERY = *mut HTTP_SERVICE_CONFIG_URLACL_QUERY;
831 ENUM!{enum HTTP_SERVICE_CONFIG_CACHE_KEY {
832     MaxCacheResponseSize = 0,
833     CacheRangeChunkSize,
834 }}
835 pub type PHTTP_SERVICE_CONFIG_CACHE_KEY = *mut HTTP_SERVICE_CONFIG_CACHE_KEY;
836 pub type HTTP_SERVICE_CONFIG_CACHE_PARAM = ULONG;
837 pub type PHTTP_SERVICE_CONFIG_CACHE_PARAM = *mut ULONG;
838 STRUCT!{struct HTTP_SERVICE_CONFIG_CACHE_SET {
839     KeyDesc: HTTP_SERVICE_CONFIG_CACHE_KEY,
840     ParamDesc: HTTP_SERVICE_CONFIG_CACHE_PARAM,
841 }}
842 pub type PHTTP_SERVICE_CONFIG_CACHE_SET = *mut HTTP_SERVICE_CONFIG_CACHE_SET;
843 pub const HTTP_NULL_ID: ULONGLONG = 0;
844 #[inline]
HTTP_IS_NULL_ID(pid: PHTTP_OPAQUE_ID) -> bool845 pub unsafe fn HTTP_IS_NULL_ID(pid: PHTTP_OPAQUE_ID) -> bool {
846     HTTP_NULL_ID == *pid
847 }
848 #[inline]
HTTP_SET_NULL_ID(pid: PHTTP_OPAQUE_ID)849 pub unsafe fn HTTP_SET_NULL_ID(pid: PHTTP_OPAQUE_ID) {
850     *pid = HTTP_NULL_ID
851 }
852 extern "system" {
HttpInitialize( Version: HTTPAPI_VERSION, Flags: ULONG, pReserved: PVOID, ) -> ULONG853     pub fn HttpInitialize(
854         Version: HTTPAPI_VERSION,
855         Flags: ULONG,
856         pReserved: PVOID,
857     ) -> ULONG;
HttpTerminate( Flags: ULONG, pReserved: PVOID, ) -> ULONG858     pub fn HttpTerminate(
859         Flags: ULONG,
860         pReserved: PVOID,
861     ) -> ULONG;
HttpCreateHttpHandle( pReqQueueHandle: PHANDLE, Reserved: ULONG, ) -> ULONG862     pub fn HttpCreateHttpHandle(
863         pReqQueueHandle: PHANDLE,
864         Reserved: ULONG,
865     ) -> ULONG;
HttpCreateRequestQueue( Version: HTTPAPI_VERSION, pName: PCWSTR, pSecurityAttributes: PSECURITY_ATTRIBUTES, Flags: ULONG, pReqQueueHandle: PHANDLE, ) -> ULONG866     pub fn HttpCreateRequestQueue(
867         Version: HTTPAPI_VERSION,
868         pName: PCWSTR,
869         pSecurityAttributes: PSECURITY_ATTRIBUTES,
870         Flags: ULONG,
871         pReqQueueHandle: PHANDLE,
872     ) -> ULONG;
HttpCloseRequestQueue( ReqQueueHandle: HANDLE, ) -> ULONG873     pub fn HttpCloseRequestQueue(
874         ReqQueueHandle: HANDLE,
875     ) -> ULONG;
HttpSetRequestQueueProperty( Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReserved: PVOID, ) -> ULONG876     pub fn HttpSetRequestQueueProperty(
877         Handle: HANDLE,
878         Property: HTTP_SERVER_PROPERTY,
879         pPropertyInformation: PVOID,
880         PropertyInformationLength: ULONG,
881         Reserved: ULONG,
882         pReserved: PVOID,
883     ) -> ULONG;
HttpQueryRequestQueueProperty( Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReturnLength: PULONG, pReserved: PVOID, ) -> ULONG884     pub fn HttpQueryRequestQueueProperty(
885         Handle: HANDLE,
886         Property: HTTP_SERVER_PROPERTY,
887         pPropertyInformation: PVOID,
888         PropertyInformationLength: ULONG,
889         Reserved: ULONG,
890         pReturnLength: PULONG,
891         pReserved: PVOID,
892     ) -> ULONG;
HttpShutdownRequestQueue( ReqQueueHandle: HANDLE, ) -> ULONG893     pub fn HttpShutdownRequestQueue(
894         ReqQueueHandle: HANDLE,
895     ) -> ULONG;
HttpReceiveClientCertificate( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, Flags: ULONG, pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO, SslClientCertInfoSize: ULONG, pBytesReceived: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG896     pub fn HttpReceiveClientCertificate(
897         ReqQueueHandle: HANDLE,
898         ConnectionId: HTTP_CONNECTION_ID,
899         Flags: ULONG,
900         pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
901         SslClientCertInfoSize: ULONG,
902         pBytesReceived: PULONG,
903         pOverlapped: LPOVERLAPPED,
904     ) -> ULONG;
HttpCreateServerSession( Version: HTTPAPI_VERSION, pServerSessionId: PHTTP_SERVER_SESSION_ID, Reserved: ULONG, ) -> ULONG905     pub fn HttpCreateServerSession(
906         Version: HTTPAPI_VERSION,
907         pServerSessionId: PHTTP_SERVER_SESSION_ID,
908         Reserved: ULONG,
909     ) -> ULONG;
HttpCloseServerSession( ServerSessionId: HTTP_SERVER_SESSION_ID, ) -> ULONG910     pub fn HttpCloseServerSession(
911         ServerSessionId: HTTP_SERVER_SESSION_ID,
912     ) -> ULONG;
HttpQueryServerSessionProperty( ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG, ) -> ULONG913     pub fn HttpQueryServerSessionProperty(
914         ServerSessionId: HTTP_SERVER_SESSION_ID,
915         Property: HTTP_SERVER_PROPERTY,
916         pPropertyInformation: PVOID,
917         PropertyInformationLength: ULONG,
918         pReturnLength: PULONG,
919     ) -> ULONG;
HttpSetServerSessionProperty( ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, ) -> ULONG920     pub fn HttpSetServerSessionProperty(
921         ServerSessionId: HTTP_SERVER_SESSION_ID,
922         Property: HTTP_SERVER_PROPERTY,
923         pPropertyInformation: PVOID,
924         PropertyInformationLength: ULONG,
925     ) -> ULONG;
HttpAddUrl( ReqQueueHandle: HANDLE, pFullyQualifiedUrl: PCWSTR, pReserved: PVOID, ) -> ULONG926     pub fn HttpAddUrl(
927         ReqQueueHandle: HANDLE,
928         pFullyQualifiedUrl: PCWSTR,
929         pReserved: PVOID,
930     ) -> ULONG;
HttpRemoveUrl( ReqQueueHandle: HANDLE, pFullyQualifiedUrl: PCWSTR, ) -> ULONG931     pub fn HttpRemoveUrl(
932         ReqQueueHandle: HANDLE,
933         pFullyQualifiedUrl: PCWSTR,
934     ) -> ULONG;
HttpCreateUrlGroup( ServerSessionId: HTTP_SERVER_SESSION_ID, pUrlGroupId: PHTTP_URL_GROUP_ID, Reserved: ULONG, ) -> ULONG935     pub fn HttpCreateUrlGroup(
936         ServerSessionId: HTTP_SERVER_SESSION_ID,
937         pUrlGroupId: PHTTP_URL_GROUP_ID,
938         Reserved: ULONG,
939     ) -> ULONG;
HttpCloseUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, ) -> ULONG940     pub fn HttpCloseUrlGroup(
941         UrlGroupId: HTTP_URL_GROUP_ID,
942     ) -> ULONG;
HttpAddUrlToUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, UrlContext: HTTP_URL_CONTEXT, Reserved: ULONG, ) -> ULONG943     pub fn HttpAddUrlToUrlGroup(
944         UrlGroupId: HTTP_URL_GROUP_ID,
945         pFullyQualifiedUrl: PCWSTR,
946         UrlContext: HTTP_URL_CONTEXT,
947         Reserved: ULONG,
948     ) -> ULONG;
HttpRemoveUrlFromUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, Flags: ULONG, ) -> ULONG949     pub fn HttpRemoveUrlFromUrlGroup(
950         UrlGroupId: HTTP_URL_GROUP_ID,
951         pFullyQualifiedUrl: PCWSTR,
952         Flags: ULONG,
953     ) -> ULONG;
HttpSetUrlGroupProperty( UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, ) -> ULONG954     pub fn HttpSetUrlGroupProperty(
955         UrlGroupId: HTTP_URL_GROUP_ID,
956         Property: HTTP_SERVER_PROPERTY,
957         pPropertyInformation: PVOID,
958         PropertyInformationLength: ULONG,
959     ) -> ULONG;
HttpQueryUrlGroupProperty( UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG, ) -> ULONG960     pub fn HttpQueryUrlGroupProperty(
961         UrlGroupId: HTTP_URL_GROUP_ID,
962         Property: HTTP_SERVER_PROPERTY,
963         pPropertyInformation: PVOID,
964         PropertyInformationLength: ULONG,
965         pReturnLength: PULONG,
966     ) -> ULONG;
HttpPrepareUrl( Reserved: PVOID, Flags: ULONG, Url: PCWSTR, PreparedUrl: *mut PWSTR, ) -> ULONG967     pub fn HttpPrepareUrl(
968         Reserved: PVOID,
969         Flags: ULONG,
970         Url: PCWSTR,
971         PreparedUrl: *mut PWSTR,
972     ) -> ULONG;
HttpReceiveHttpRequest( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pRequestBuffer: PHTTP_REQUEST, RequestBufferLength: ULONG, pBytesReturned: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG973     pub fn HttpReceiveHttpRequest(
974         ReqQueueHandle: HANDLE,
975         RequestId: HTTP_REQUEST_ID,
976         Flags: ULONG,
977         pRequestBuffer: PHTTP_REQUEST,
978         RequestBufferLength: ULONG,
979         pBytesReturned: PULONG,
980         pOverlapped: LPOVERLAPPED,
981     ) -> ULONG;
HttpReceiveRequestEntityBody( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pBuffer: PVOID, EntityBufferLength: ULONG, pBytesReturned: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG982     pub fn HttpReceiveRequestEntityBody(
983         ReqQueueHandle: HANDLE,
984         RequestId: HTTP_REQUEST_ID,
985         Flags: ULONG,
986         pBuffer: PVOID,
987         EntityBufferLength: ULONG,
988         pBytesReturned: PULONG,
989         pOverlapped: LPOVERLAPPED,
990     ) -> ULONG;
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, ) -> ULONG991     pub fn HttpSendHttpResponse(
992         ReqQueueHandle: HANDLE,
993         RequestId: HTTP_REQUEST_ID,
994         Flags: ULONG,
995         pHttpResponse: PHTTP_RESPONSE,
996         pCachePolicy: PHTTP_CACHE_POLICY,
997         pBytesSent: PULONG,
998         pReserved1: PVOID,
999         Reserved2: ULONG,
1000         pOverlapped: LPOVERLAPPED,
1001         pLogData: PHTTP_LOG_DATA,
1002     ) -> ULONG;
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, ) -> ULONG1003     pub fn HttpSendResponseEntityBody(
1004         ReqQueueHandle: HANDLE,
1005         RequestId: HTTP_REQUEST_ID,
1006         Flags: ULONG,
1007         EntityChunkCount: USHORT,
1008         pEntityChunks: PHTTP_DATA_CHUNK,
1009         pBytesSent: PULONG,
1010         pReserved1: PVOID,
1011         Reserved2: ULONG,
1012         pOverlapped: LPOVERLAPPED,
1013         pLogData: PHTTP_LOG_DATA,
1014     ) -> ULONG;
HttpWaitForDisconnect( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, pOverlapped: LPOVERLAPPED, ) -> ULONG1015     pub fn HttpWaitForDisconnect(
1016         ReqQueueHandle: HANDLE,
1017         ConnectionId: HTTP_CONNECTION_ID,
1018         pOverlapped: LPOVERLAPPED,
1019     ) -> ULONG;
HttpWaitForDisconnectEx( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, Reserved: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1020     pub fn HttpWaitForDisconnectEx(
1021         ReqQueueHandle: HANDLE,
1022         ConnectionId: HTTP_CONNECTION_ID,
1023         Reserved: ULONG,
1024         pOverlapped: LPOVERLAPPED,
1025     ) -> ULONG;
HttpCancelHttpRequest( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, pOverlapped: LPOVERLAPPED, ) -> ULONG1026     pub fn HttpCancelHttpRequest(
1027         ReqQueueHandle: HANDLE,
1028         RequestId: HTTP_REQUEST_ID,
1029         pOverlapped: LPOVERLAPPED,
1030     ) -> ULONG;
HttpWaitForDemandStart( ReqQueueHandle: HANDLE, pOverlapped: LPOVERLAPPED, ) -> ULONG1031     pub fn HttpWaitForDemandStart(
1032         ReqQueueHandle: HANDLE,
1033         pOverlapped: LPOVERLAPPED,
1034     ) -> ULONG;
HttpFlushResponseCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, Flags: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1035     pub fn HttpFlushResponseCache(
1036         ReqQueueHandle: HANDLE,
1037         pUrlPrefix: PCWSTR,
1038         Flags: ULONG,
1039         pOverlapped: LPOVERLAPPED,
1040     ) -> ULONG;
HttpAddFragmentToCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pDataChunk: PHTTP_DATA_CHUNK, pCachePolicy: PHTTP_CACHE_POLICY, pOverlapped: LPOVERLAPPED, ) -> ULONG1041     pub fn HttpAddFragmentToCache(
1042         ReqQueueHandle: HANDLE,
1043         pUrlPrefix: PCWSTR,
1044         pDataChunk: PHTTP_DATA_CHUNK,
1045         pCachePolicy: PHTTP_CACHE_POLICY,
1046         pOverlapped: LPOVERLAPPED,
1047     ) -> ULONG;
HttpReadFragmentFromCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pByteRange: PHTTP_BYTE_RANGE, pBuffer: PVOID, BufferLength: ULONG, pBytesRead: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1048     pub fn HttpReadFragmentFromCache(
1049         ReqQueueHandle: HANDLE,
1050         pUrlPrefix: PCWSTR,
1051         pByteRange: PHTTP_BYTE_RANGE,
1052         pBuffer: PVOID,
1053         BufferLength: ULONG,
1054         pBytesRead: PULONG,
1055         pOverlapped: LPOVERLAPPED,
1056     ) -> ULONG;
HttpSetServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1057     pub fn HttpSetServiceConfiguration(
1058         ServiceHandle: HANDLE,
1059         ConfigId: HTTP_SERVICE_CONFIG_ID,
1060         pConfigInformation: PVOID,
1061         ConfigInformationLength: ULONG,
1062         pOverlapped: LPOVERLAPPED,
1063     ) -> ULONG;
HttpDeleteServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1064     pub fn HttpDeleteServiceConfiguration(
1065         ServiceHandle: HANDLE,
1066         ConfigId: HTTP_SERVICE_CONFIG_ID,
1067         pConfigInformation: PVOID,
1068         ConfigInformationLength: ULONG,
1069         pOverlapped: LPOVERLAPPED,
1070     ) -> ULONG;
HttpQueryServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pInput: PVOID, InputLength: ULONG, pOutput: PVOID, OutputLength: ULONG, pReturnLength: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1071     pub fn HttpQueryServiceConfiguration(
1072         ServiceHandle: HANDLE,
1073         ConfigId: HTTP_SERVICE_CONFIG_ID,
1074         pInput: PVOID,
1075         InputLength: ULONG,
1076         pOutput: PVOID,
1077         OutputLength: ULONG,
1078         pReturnLength: PULONG,
1079         pOverlapped: LPOVERLAPPED,
1080     ) -> ULONG;
HttpDeclarePush( RequestQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Verb: HTTP_VERB, Path: PCWSTR, Query: PCSTR, Headers: PHTTP_REQUEST_HEADERS, ) -> ULONG1081     pub fn HttpDeclarePush(
1082         RequestQueueHandle: HANDLE,
1083         RequestId: HTTP_REQUEST_ID,
1084         Verb: HTTP_VERB,
1085         Path: PCWSTR,
1086         Query: PCSTR,
1087         Headers: PHTTP_REQUEST_HEADERS,
1088     ) -> ULONG;
HttpUpdateServiceConfiguration( Handle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, ConfigInfo: PVOID, ConfigInfoLength: ULONG, Overlapped: LPOVERLAPPED, ) -> ULONG1089     pub fn HttpUpdateServiceConfiguration(
1090         Handle: HANDLE,
1091         ConfigId: HTTP_SERVICE_CONFIG_ID,
1092         ConfigInfo: PVOID,
1093         ConfigInfoLength: ULONG,
1094         Overlapped: LPOVERLAPPED,
1095     ) -> ULONG;
1096 }
1097