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