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 extern "system" {
HttpInitialize( Version: HTTPAPI_VERSION, Flags: ULONG, pReserved: PVOID, ) -> ULONG844     pub fn HttpInitialize(
845         Version: HTTPAPI_VERSION,
846         Flags: ULONG,
847         pReserved: PVOID,
848     ) -> ULONG;
HttpTerminate( Flags: ULONG, pReserved: PVOID, ) -> ULONG849     pub fn HttpTerminate(
850         Flags: ULONG,
851         pReserved: PVOID,
852     ) -> ULONG;
HttpCreateHttpHandle( pReqQueueHandle: HANDLE, Reserved: ULONG, ) -> ULONG853     pub fn HttpCreateHttpHandle(
854         pReqQueueHandle: HANDLE,
855         Reserved: ULONG,
856     ) -> ULONG;
HttpCreateRequestQueue( Version: HTTPAPI_VERSION, pName: PCWSTR, pSecurityAttributes: PSECURITY_ATTRIBUTES, Flags: ULONG, pReqQueueHandle: PHANDLE, ) -> ULONG857     pub fn HttpCreateRequestQueue(
858         Version: HTTPAPI_VERSION,
859         pName: PCWSTR,
860         pSecurityAttributes: PSECURITY_ATTRIBUTES,
861         Flags: ULONG,
862         pReqQueueHandle: PHANDLE,
863     ) -> ULONG;
HttpCloseRequestQueue( ReqQueueHandle: HANDLE, ) -> ULONG864     pub fn HttpCloseRequestQueue(
865         ReqQueueHandle: HANDLE,
866     ) -> ULONG;
HttpSetRequestQueueProperty( Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReserved: PVOID, ) -> ULONG867     pub fn HttpSetRequestQueueProperty(
868         Handle: HANDLE,
869         Property: HTTP_SERVER_PROPERTY,
870         pPropertyInformation: PVOID,
871         PropertyInformationLength: ULONG,
872         Reserved: ULONG,
873         pReserved: PVOID,
874     ) -> ULONG;
HttpQueryRequestQueueProperty( Handle: HANDLE, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, Reserved: ULONG, pReturnLength: PULONG, pReserved: PVOID, ) -> ULONG875     pub fn HttpQueryRequestQueueProperty(
876         Handle: HANDLE,
877         Property: HTTP_SERVER_PROPERTY,
878         pPropertyInformation: PVOID,
879         PropertyInformationLength: ULONG,
880         Reserved: ULONG,
881         pReturnLength: PULONG,
882         pReserved: PVOID,
883     ) -> ULONG;
HttpShutdownRequestQueue( ReqQueueHandle: HANDLE, ) -> ULONG884     pub fn HttpShutdownRequestQueue(
885         ReqQueueHandle: HANDLE,
886     ) -> ULONG;
HttpReceiveClientCertificate( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, Flags: ULONG, pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO, SslClientCertInfoSize: ULONG, pBytesReceived: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG887     pub fn HttpReceiveClientCertificate(
888         ReqQueueHandle: HANDLE,
889         ConnectionId: HTTP_CONNECTION_ID,
890         Flags: ULONG,
891         pSslClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
892         SslClientCertInfoSize: ULONG,
893         pBytesReceived: PULONG,
894         pOverlapped: LPOVERLAPPED,
895     ) -> ULONG;
HttpCreateServerSession( Version: HTTPAPI_VERSION, pServerSessionId: PHTTP_SERVER_SESSION_ID, Reserved: ULONG, ) -> ULONG896     pub fn HttpCreateServerSession(
897         Version: HTTPAPI_VERSION,
898         pServerSessionId: PHTTP_SERVER_SESSION_ID,
899         Reserved: ULONG,
900     ) -> ULONG;
HttpCloseServerSession( ServerSessionId: HTTP_SERVER_SESSION_ID, ) -> ULONG901     pub fn HttpCloseServerSession(
902         ServerSessionId: HTTP_SERVER_SESSION_ID,
903     ) -> ULONG;
HttpQueryServerSessionProperty( ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG, ) -> ULONG904     pub fn HttpQueryServerSessionProperty(
905         ServerSessionId: HTTP_SERVER_SESSION_ID,
906         Property: HTTP_SERVER_PROPERTY,
907         pPropertyInformation: PVOID,
908         PropertyInformationLength: ULONG,
909         pReturnLength: PULONG,
910     ) -> ULONG;
HttpSetServerSessionProperty( ServerSessionId: HTTP_SERVER_SESSION_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, ) -> ULONG911     pub fn HttpSetServerSessionProperty(
912         ServerSessionId: HTTP_SERVER_SESSION_ID,
913         Property: HTTP_SERVER_PROPERTY,
914         pPropertyInformation: PVOID,
915         PropertyInformationLength: ULONG,
916     ) -> ULONG;
HttpAddUrl( ReqQueueHandle: HANDLE, pFullyQualifiedUrl: PCWSTR, pReserved: PVOID, ) -> ULONG917     pub fn HttpAddUrl(
918         ReqQueueHandle: HANDLE,
919         pFullyQualifiedUrl: PCWSTR,
920         pReserved: PVOID,
921     ) -> ULONG;
HttpRemoveUrl( ReqQueueHandle: HANDLE, pFullyQualifiedUrl: PCWSTR, ) -> ULONG922     pub fn HttpRemoveUrl(
923         ReqQueueHandle: HANDLE,
924         pFullyQualifiedUrl: PCWSTR,
925     ) -> ULONG;
HttpCreateUrlGroup( ServerSessionId: HTTP_SERVER_SESSION_ID, pUrlGroupId: PHTTP_URL_GROUP_ID, Reserved: ULONG, ) -> ULONG926     pub fn HttpCreateUrlGroup(
927         ServerSessionId: HTTP_SERVER_SESSION_ID,
928         pUrlGroupId: PHTTP_URL_GROUP_ID,
929         Reserved: ULONG,
930     ) -> ULONG;
HttpCloseUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, ) -> ULONG931     pub fn HttpCloseUrlGroup(
932         UrlGroupId: HTTP_URL_GROUP_ID,
933     ) -> ULONG;
HttpAddUrlToUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, UrlContext: HTTP_URL_CONTEXT, Reserved: ULONG, ) -> ULONG934     pub fn HttpAddUrlToUrlGroup(
935         UrlGroupId: HTTP_URL_GROUP_ID,
936         pFullyQualifiedUrl: PCWSTR,
937         UrlContext: HTTP_URL_CONTEXT,
938         Reserved: ULONG,
939     ) -> ULONG;
HttpRemoveUrlFromUrlGroup( UrlGroupId: HTTP_URL_GROUP_ID, pFullyQualifiedUrl: PCWSTR, Flags: ULONG, ) -> ULONG940     pub fn HttpRemoveUrlFromUrlGroup(
941         UrlGroupId: HTTP_URL_GROUP_ID,
942         pFullyQualifiedUrl: PCWSTR,
943         Flags: ULONG,
944     ) -> ULONG;
HttpSetUrlGroupProperty( UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, ) -> ULONG945     pub fn HttpSetUrlGroupProperty(
946         UrlGroupId: HTTP_URL_GROUP_ID,
947         Property: HTTP_SERVER_PROPERTY,
948         pPropertyInformation: PVOID,
949         PropertyInformationLength: ULONG,
950     ) -> ULONG;
HttpQueryUrlGroupProperty( UrlGroupId: HTTP_URL_GROUP_ID, Property: HTTP_SERVER_PROPERTY, pPropertyInformation: PVOID, PropertyInformationLength: ULONG, pReturnLength: PULONG, ) -> ULONG951     pub fn HttpQueryUrlGroupProperty(
952         UrlGroupId: HTTP_URL_GROUP_ID,
953         Property: HTTP_SERVER_PROPERTY,
954         pPropertyInformation: PVOID,
955         PropertyInformationLength: ULONG,
956         pReturnLength: PULONG,
957     ) -> ULONG;
HttpPrepareUrl( Reserved: PVOID, Flags: ULONG, Url: PCWSTR, PreparedUrl: *mut PWSTR, ) -> ULONG958     pub fn HttpPrepareUrl(
959         Reserved: PVOID,
960         Flags: ULONG,
961         Url: PCWSTR,
962         PreparedUrl: *mut PWSTR,
963     ) -> ULONG;
HttpReceiveHttpRequest( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pRequestBuffer: PHTTP_REQUEST, RequestBufferLength: ULONG, pBytesReturned: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG964     pub fn HttpReceiveHttpRequest(
965         ReqQueueHandle: HANDLE,
966         RequestId: HTTP_REQUEST_ID,
967         Flags: ULONG,
968         pRequestBuffer: PHTTP_REQUEST,
969         RequestBufferLength: ULONG,
970         pBytesReturned: PULONG,
971         pOverlapped: LPOVERLAPPED,
972     ) -> ULONG;
HttpReceiveRequestEntityBody( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, Flags: ULONG, pBuffer: PVOID, EntityBufferLength: ULONG, pBytesReturned: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG973     pub fn HttpReceiveRequestEntityBody(
974         ReqQueueHandle: HANDLE,
975         RequestId: HTTP_REQUEST_ID,
976         Flags: ULONG,
977         pBuffer: PVOID,
978         EntityBufferLength: ULONG,
979         pBytesReturned: PULONG,
980         pOverlapped: LPOVERLAPPED,
981     ) -> 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, ) -> ULONG982     pub fn HttpSendHttpResponse(
983         ReqQueueHandle: HANDLE,
984         RequestId: HTTP_REQUEST_ID,
985         Flags: ULONG,
986         pHttpResponse: PHTTP_RESPONSE,
987         pCachePolicy: PHTTP_CACHE_POLICY,
988         pBytesSent: PULONG,
989         pReserved1: PVOID,
990         Reserved2: ULONG,
991         pOverlapped: LPOVERLAPPED,
992         pLogData: PHTTP_LOG_DATA,
993     ) -> 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, ) -> ULONG994     pub fn HttpSendResponseEntityBody(
995         ReqQueueHandle: HANDLE,
996         RequestId: HTTP_REQUEST_ID,
997         Flags: ULONG,
998         EntityChunkCount: USHORT,
999         pEntityChunks: PHTTP_DATA_CHUNK,
1000         pBytesSent: PULONG,
1001         pReserved1: PVOID,
1002         Reserved2: ULONG,
1003         pOverlapped: LPOVERLAPPED,
1004         pLogData: PHTTP_LOG_DATA,
1005     ) -> ULONG;
HttpWaitForDisconnect( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, pOverlapped: LPOVERLAPPED, ) -> ULONG1006     pub fn HttpWaitForDisconnect(
1007         ReqQueueHandle: HANDLE,
1008         ConnectionId: HTTP_CONNECTION_ID,
1009         pOverlapped: LPOVERLAPPED,
1010     ) -> ULONG;
HttpWaitForDisconnectEx( ReqQueueHandle: HANDLE, ConnectionId: HTTP_CONNECTION_ID, Reserved: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1011     pub fn HttpWaitForDisconnectEx(
1012         ReqQueueHandle: HANDLE,
1013         ConnectionId: HTTP_CONNECTION_ID,
1014         Reserved: ULONG,
1015         pOverlapped: LPOVERLAPPED,
1016     ) -> ULONG;
HttpCancelHttpRequest( ReqQueueHandle: HANDLE, RequestId: HTTP_REQUEST_ID, pOverlapped: LPOVERLAPPED, ) -> ULONG1017     pub fn HttpCancelHttpRequest(
1018         ReqQueueHandle: HANDLE,
1019         RequestId: HTTP_REQUEST_ID,
1020         pOverlapped: LPOVERLAPPED,
1021     ) -> ULONG;
HttpWaitForDemandStart( ReqQueueHandle: HANDLE, pOverlapped: LPOVERLAPPED, ) -> ULONG1022     pub fn HttpWaitForDemandStart(
1023         ReqQueueHandle: HANDLE,
1024         pOverlapped: LPOVERLAPPED,
1025     ) -> ULONG;
HttpFlushResponseCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, Flags: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1026     pub fn HttpFlushResponseCache(
1027         ReqQueueHandle: HANDLE,
1028         pUrlPrefix: PCWSTR,
1029         Flags: ULONG,
1030         pOverlapped: LPOVERLAPPED,
1031     ) -> ULONG;
HttpAddFragmentToCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pDataChunk: PHTTP_DATA_CHUNK, pCachePolicy: PHTTP_CACHE_POLICY, pOverlapped: LPOVERLAPPED, ) -> ULONG1032     pub fn HttpAddFragmentToCache(
1033         ReqQueueHandle: HANDLE,
1034         pUrlPrefix: PCWSTR,
1035         pDataChunk: PHTTP_DATA_CHUNK,
1036         pCachePolicy: PHTTP_CACHE_POLICY,
1037         pOverlapped: LPOVERLAPPED,
1038     ) -> ULONG;
HttpReadFragmentFromCache( ReqQueueHandle: HANDLE, pUrlPrefix: PCWSTR, pByteRange: PHTTP_BYTE_RANGE, pBuffer: PVOID, BufferLength: ULONG, pBytesRead: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1039     pub fn HttpReadFragmentFromCache(
1040         ReqQueueHandle: HANDLE,
1041         pUrlPrefix: PCWSTR,
1042         pByteRange: PHTTP_BYTE_RANGE,
1043         pBuffer: PVOID,
1044         BufferLength: ULONG,
1045         pBytesRead: PULONG,
1046         pOverlapped: LPOVERLAPPED,
1047     ) -> ULONG;
HttpSetServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1048     pub fn HttpSetServiceConfiguration(
1049         ServiceHandle: HANDLE,
1050         ConfigId: HTTP_SERVICE_CONFIG_ID,
1051         pConfigInformation: PVOID,
1052         ConfigInformationLength: ULONG,
1053         pOverlapped: LPOVERLAPPED,
1054     ) -> ULONG;
HttpDeleteServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pConfigInformation: PVOID, ConfigInformationLength: ULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1055     pub fn HttpDeleteServiceConfiguration(
1056         ServiceHandle: HANDLE,
1057         ConfigId: HTTP_SERVICE_CONFIG_ID,
1058         pConfigInformation: PVOID,
1059         ConfigInformationLength: ULONG,
1060         pOverlapped: LPOVERLAPPED,
1061     ) -> ULONG;
HttpQueryServiceConfiguration( ServiceHandle: HANDLE, ConfigId: HTTP_SERVICE_CONFIG_ID, pInput: PVOID, InputLength: ULONG, pOutput: PVOID, OutputLength: ULONG, pReturnLength: PULONG, pOverlapped: LPOVERLAPPED, ) -> ULONG1062     pub fn HttpQueryServiceConfiguration(
1063         ServiceHandle: HANDLE,
1064         ConfigId: HTTP_SERVICE_CONFIG_ID,
1065         pInput: PVOID,
1066         InputLength: ULONG,
1067         pOutput: PVOID,
1068         OutputLength: ULONG,
1069         pReturnLength: PULONG,
1070         pOverlapped: LPOVERLAPPED,
1071     ) -> ULONG;
1072 }
1073