1 // Copyright © 2015, skdltmxn
2 // Licensed under the MIT License <LICENSE.md>
3 //! HTTP API specification
4 pub const HTTP_INITIALIZE_SERVER: ::ULONG = 0x00000001;
5 pub const HTTP_INITIALIZE_CONFIG: ::ULONG = 0x00000002;
6 pub const HTTP_DEMAND_CBT: ::ULONG = 0x00000004;
7 ENUM!{enum HTTP_SERVER_PROPERTY {
8     HttpServerAuthenticationProperty,
9     HttpServerLoggingProperty,
10     HttpServerQosProperty,
11     HttpServerTimeoutsProperty,
12     HttpServerQueueLengthProperty,
13     HttpServerStateProperty,
14     HttpServer503VerbosityProperty,
15     HttpServerBindingProperty,
16     HttpServerExtendedAuthenticationProperty,
17     HttpServerListenEndpointProperty,
18     HttpServerChannelBindProperty,
19     HttpServerProtectionLevelProperty,
20 }}
21 pub type PHTTP_SERVER_PROPERTY = *mut HTTP_SERVER_PROPERTY;
22 STRUCT!{struct HTTP_PROPERTY_FLAGS {
23     BitFields: ::ULONG,
24 }}
25 BITFIELD!(HTTP_PROPERTY_FLAGS BitFields: ::ULONG [
26     Present set_Present[0..1],
27 ]);
28 pub type PHTTP_PROPERTY_FLAGS = *mut HTTP_PROPERTY_FLAGS;
29 ENUM!{enum HTTP_ENABLED_STATE {
30     HttpEnabledStateActive,
31     HttpEnabledStateInactive,
32 }}
33 pub type PHTTP_ENABLED_STATE = *mut HTTP_ENABLED_STATE;
34 STRUCT!{struct HTTP_STATE_INFO {
35     Flags: HTTP_PROPERTY_FLAGS,
36     State: HTTP_ENABLED_STATE,
37 }}
38 pub type PHTTP_STATE_INFO = *mut HTTP_STATE_INFO;
39 ENUM!{enum HTTP_503_RESPONSE_VERBOSITY {
40     Http503ResponseVerbosityBasic,
41     Http503ResponseVerbosityLimited,
42     Http503ResponseVerbosityFull,
43 }}
44 pub type PHTTP_503_RESPONSE_VERBOSITY = *mut HTTP_503_RESPONSE_VERBOSITY;
45 ENUM!{enum HTTP_QOS_SETTING_TYPE {
46     HttpQosSettingTypeBandwidth,
47     HttpQosSettingTypeConnectionLimit,
48     HttpQosSettingTypeFlowRate,
49 }}
50 pub type PHTTP_QOS_SETTING_TYPE = *mut HTTP_QOS_SETTING_TYPE;
51 STRUCT!{struct HTTP_QOS_SETTING_INFO {
52     QosType: HTTP_QOS_SETTING_TYPE,
53     QosSetting: ::PVOID,
54 }}
55 pub type PHTTP_QOS_SETTING_INFO = *mut HTTP_QOS_SETTING_INFO;
56 STRUCT!{struct HTTP_CONNECTION_LIMIT_INFO {
57     Flags: HTTP_PROPERTY_FLAGS,
58     MaxConnections: ::ULONG,
59 }}
60 pub type PHTTP_CONNECTION_LIMIT_INFO = *mut HTTP_CONNECTION_LIMIT_INFO;
61 STRUCT!{struct HTTP_BANDWIDTH_LIMIT_INFO {
62     Flags: HTTP_PROPERTY_FLAGS,
63     MaxBandwidth: ::ULONG,
64 }}
65 pub type PHTTP_BANDWIDTH_LIMIT_INFO = *mut HTTP_BANDWIDTH_LIMIT_INFO;
66 STRUCT!{struct HTTP_FLOWRATE_INFO {
67     Flags: HTTP_PROPERTY_FLAGS,
68     MaxBandwidth: ::ULONG,
69     MaxPeakBandwidth: ::ULONG,
70     BurstSize: ::ULONG,
71 }}
72 pub type PHTTP_FLOWRATE_INFO = *mut HTTP_FLOWRATE_INFO;
73 pub const HTTP_MIN_ALLOWED_BANDWIDTH_THROTTLING_RATE: ::ULONG = 1024;
74 pub const HTTP_LIMIT_INFINITE: ::ULONG = !0;
75 ENUM!{enum HTTP_SERVICE_CONFIG_TIMEOUT_KEY {
76     IdleConnectionTimeout = 0,
77     HeaderWaitTimeout,
78 }}
79 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_KEY = *mut HTTP_SERVICE_CONFIG_TIMEOUT_KEY;
80 pub type HTTP_SERVICE_CONFIG_TIMEOUT_PARAM = ::USHORT;
81 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_PARAM = *mut ::USHORT;
82 STRUCT!{struct HTTP_SERVICE_CONFIG_TIMEOUT_SET {
83     KeyDesc: HTTP_SERVICE_CONFIG_TIMEOUT_KEY,
84     ParamDesc: HTTP_SERVICE_CONFIG_TIMEOUT_PARAM,
85 }}
86 pub type PHTTP_SERVICE_CONFIG_TIMEOUT_SET = *mut HTTP_SERVICE_CONFIG_TIMEOUT_SET;
87 STRUCT!{struct HTTP_TIMEOUT_LIMIT_INFO {
88     Flags: HTTP_PROPERTY_FLAGS,
89     EntityBody: ::USHORT,
90     DrainEntityBody: ::USHORT,
91     RequestQueue: ::USHORT,
92     IdleConnection: ::USHORT,
93     HeaderWait: ::USHORT,
94     MinSendRate: ::ULONG,
95 }}
96 pub type PHTTP_TIMEOUT_LIMIT_INFO = *mut HTTP_TIMEOUT_LIMIT_INFO;
97 STRUCT!{struct HTTP_LISTEN_ENDPOINT_INFO {
98     Flags: HTTP_PROPERTY_FLAGS,
99     EnableSharing: ::BOOLEAN,
100 }}
101 pub type PHTTP_LISTEN_ENDPOINT_INFO = *mut HTTP_LISTEN_ENDPOINT_INFO;
102 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS {
103     DomainNameLength: ::USHORT,
104     DomainName: ::PWSTR,
105     RealmLength: ::USHORT,
106     Realm: ::PWSTR,
107 }}
108 pub type PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS;
109 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS {
110     RealmLength: ::USHORT,
111     Realm: ::PWSTR,
112 }}
113 pub type PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS;
114 pub const HTTP_AUTH_ENABLE_BASIC: ::ULONG = 0x00000001;
115 pub const HTTP_AUTH_ENABLE_DIGEST: ::ULONG = 0x00000002;
116 pub const HTTP_AUTH_ENABLE_NTLM: ::ULONG = 0x00000004;
117 pub const HTTP_AUTH_ENABLE_NEGOTIATE: ::ULONG = 0x00000008;
118 pub const HTTP_AUTH_ENABLE_KERBEROS: ::ULONG = 0x00000010;
119 pub const HTTP_AUTH_ENABLE_ALL: ::ULONG =  HTTP_AUTH_ENABLE_BASIC | HTTP_AUTH_ENABLE_DIGEST |
120     HTTP_AUTH_ENABLE_NTLM | HTTP_AUTH_ENABLE_NEGOTIATE | HTTP_AUTH_ENABLE_KERBEROS;
121 pub const HTTP_AUTH_EX_FLAG_ENABLE_KERBEROS_CREDENTIAL_CACHING: ::UCHAR = 0x01;
122 pub const HTTP_AUTH_EX_FLAG_CAPTURE_CREDENTIAL: ::UCHAR = 0x02;
123 STRUCT!{struct HTTP_SERVER_AUTHENTICATION_INFO {
124     Flags: HTTP_PROPERTY_FLAGS,
125     AuthSchemes: ::ULONG,
126     ReceiveMutualAuth: ::BOOLEAN,
127     ReceiveContextHandle: ::BOOLEAN,
128     DisableNTLMCredentialCaching: ::BOOLEAN,
129     ExFlags: ::UCHAR,
130     DigestParams: HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS,
131     BasicParams: HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS,
132 }}
133 pub type PHTTP_SERVER_AUTHENTICATION_INFO = *mut HTTP_SERVER_AUTHENTICATION_INFO;
134 ENUM!{enum HTTP_SERVICE_BINDING_TYPE {
135     HttpServiceBindingTypeNone = 0,
136     HttpServiceBindingTypeW,
137     HttpServiceBindingTypeA,
138 }}
139 STRUCT!{struct HTTP_SERVICE_BINDING_BASE {
140     Type: HTTP_SERVICE_BINDING_TYPE,
141 }}
142 pub type PHTTP_SERVICE_BINDING_BASE = *mut HTTP_SERVICE_BINDING_BASE;
143 STRUCT!{struct HTTP_SERVICE_BINDING_A {
144     Base: HTTP_SERVICE_BINDING_BASE,
145     Buffer: ::PCHAR,
146     BufferSize: ::ULONG,
147 }}
148 pub type PHTTP_SERVICE_BINDING_A = *mut HTTP_SERVICE_BINDING_A;
149 STRUCT!{struct HTTP_SERVICE_BINDING_W {
150     Base: HTTP_SERVICE_BINDING_BASE,
151     Buffer: ::PWCHAR,
152     BufferSize: ::ULONG,
153 }}
154 pub type PHTTP_SERVICE_BINDING_W = *mut HTTP_SERVICE_BINDING_W;
155 ENUM!{enum HTTP_AUTHENTICATION_HARDENING_LEVELS {
156     HttpAuthenticationHardeningLegacy = 0,
157     HttpAuthenticationHardeningMedium,
158     HttpAuthenticationHardeningStrict,
159 }}
160 pub const HTTP_CHANNEL_BIND_PROXY: ::ULONG = 0x1;
161 pub const HTTP_CHANNEL_BIND_PROXY_COHOSTING: ::ULONG = 0x20;
162 pub const HTTP_CHANNEL_BIND_NO_SERVICE_NAME_CHECK: ::ULONG = 0x2;
163 pub const HTTP_CHANNEL_BIND_DOTLESS_SERVICE: ::ULONG = 0x4;
164 pub const HTTP_CHANNEL_BIND_SECURE_CHANNEL_TOKEN: ::ULONG = 0x8;
165 pub const HTTP_CHANNEL_BIND_CLIENT_SERVICE: ::ULONG = 0x10;
166 STRUCT!{struct HTTP_CHANNEL_BIND_INFO {
167     Hardening: HTTP_AUTHENTICATION_HARDENING_LEVELS,
168     Flags: ::ULONG,
169     ServiceNames: *mut PHTTP_SERVICE_BINDING_BASE,
170     NumberOfServiceNames: ::ULONG,
171 }}
172 pub type PHTTP_CHANNEL_BIND_INFO = *mut HTTP_CHANNEL_BIND_INFO;
173 STRUCT!{struct HTTP_REQUEST_CHANNEL_BIND_STATUS {
174     ServiceName: PHTTP_SERVICE_BINDING_BASE,
175     ChannelToken: ::PUCHAR,
176     ChannelTokenSize: ::ULONG,
177     Flags: ::ULONG,
178 }}
179 pub type PHTTP_REQUEST_CHANNEL_BIND_STATUS = *mut HTTP_REQUEST_CHANNEL_BIND_STATUS;
180 pub const HTTP_LOG_FIELD_DATE: ::ULONG = 0x00000001;
181 pub const HTTP_LOG_FIELD_TIME: ::ULONG = 0x00000002;
182 pub const HTTP_LOG_FIELD_CLIENT_IP: ::ULONG = 0x00000004;
183 pub const HTTP_LOG_FIELD_USER_NAME: ::ULONG = 0x00000008;
184 pub const HTTP_LOG_FIELD_SITE_NAME: ::ULONG = 0x00000010;
185 pub const HTTP_LOG_FIELD_COMPUTER_NAME: ::ULONG = 0x00000020;
186 pub const HTTP_LOG_FIELD_SERVER_IP: ::ULONG = 0x00000040;
187 pub const HTTP_LOG_FIELD_METHOD: ::ULONG = 0x00000080;
188 pub const HTTP_LOG_FIELD_URI_STEM: ::ULONG = 0x00000100;
189 pub const HTTP_LOG_FIELD_URI_QUERY: ::ULONG = 0x00000200;
190 pub const HTTP_LOG_FIELD_STATUS: ::ULONG = 0x00000400;
191 pub const HTTP_LOG_FIELD_WIN32_STATUS: ::ULONG = 0x00000800;
192 pub const HTTP_LOG_FIELD_BYTES_SENT: ::ULONG = 0x00001000;
193 pub const HTTP_LOG_FIELD_BYTES_RECV: ::ULONG = 0x00002000;
194 pub const HTTP_LOG_FIELD_TIME_TAKEN: ::ULONG = 0x00004000;
195 pub const HTTP_LOG_FIELD_SERVER_PORT: ::ULONG = 0x00008000;
196 pub const HTTP_LOG_FIELD_USER_AGENT: ::ULONG = 0x00010000;
197 pub const HTTP_LOG_FIELD_COOKIE: ::ULONG = 0x00020000;
198 pub const HTTP_LOG_FIELD_REFERER: ::ULONG = 0x00040000;
199 pub const HTTP_LOG_FIELD_VERSION: ::ULONG = 0x00080000;
200 pub const HTTP_LOG_FIELD_HOST: ::ULONG = 0x00100000;
201 pub const HTTP_LOG_FIELD_SUB_STATUS: ::ULONG = 0x00200000;
202 pub const HTTP_LOG_FIELD_CLIENT_PORT: ::ULONG = 0x00400000;
203 pub const HTTP_LOG_FIELD_URI: ::ULONG = 0x00800000;
204 pub const HTTP_LOG_FIELD_SITE_ID: ::ULONG = 0x01000000;
205 pub const HTTP_LOG_FIELD_REASON: ::ULONG = 0x02000000;
206 pub const HTTP_LOG_FIELD_QUEUE_NAME: ::ULONG = 0x04000000;
207 ENUM!{enum HTTP_LOGGING_TYPE {
208     HttpLoggingTypeW3C,
209     HttpLoggingTypeIIS,
210     HttpLoggingTypeNCSA,
211     HttpLoggingTypeRaw,
212 }}
213 ENUM!{enum HTTP_LOGGING_ROLLOVER_TYPE {
214     HttpLoggingRolloverSize,
215     HttpLoggingRolloverDaily,
216     HttpLoggingRolloverWeekly,
217     HttpLoggingRolloverMonthly,
218     HttpLoggingRolloverHourly,
219 }}
220 pub const HTTP_MIN_ALLOWED_LOG_FILE_ROLLOVER_SIZE: ::ULONG = (1 * 1024 * 1024) as ::ULONG;
221 pub const HTTP_LOGGING_FLAG_LOCAL_TIME_ROLLOVER: ::ULONG = 0x00000001;
222 pub const HTTP_LOGGING_FLAG_USE_UTF8_CONVERSION: ::ULONG = 0x00000002;
223 pub const HTTP_LOGGING_FLAG_LOG_ERRORS_ONLY: ::ULONG = 0x00000004;
224 pub const HTTP_LOGGING_FLAG_LOG_SUCCESS_ONLY: ::ULONG = 0x00000008;
225 STRUCT!{struct HTTP_LOGGING_INFO {
226     Flags: HTTP_PROPERTY_FLAGS,
227     LoggingFlags: ::ULONG,
228     SoftwareName: ::PCWSTR,
229     SoftwareNameLength: ::USHORT,
230     DirectoryNameLength: ::USHORT,
231     DirectoryName: ::PCWSTR,
232     Format: HTTP_LOGGING_TYPE,
233     Fields: ::ULONG,
234     pExtFields: ::PVOID,
235     NumOfExtFields: ::USHORT,
236     MaxRecordSize: ::USHORT,
237     RolloverType: HTTP_LOGGING_ROLLOVER_TYPE,
238     RolloverSize: ::ULONG,
239     pSecurityDescriptor: ::PSECURITY_DESCRIPTOR,
240 }}
241 pub type PHTTP_LOGGING_INFO = *mut HTTP_LOGGING_INFO;
242 STRUCT!{struct HTTP_BINDING_INFO {
243     Flags: HTTP_PROPERTY_FLAGS,
244     RequestQueueHandle: ::HANDLE,
245 }}
246 pub type PHTTP_BINDING_INFO = *mut HTTP_BINDING_INFO;
247 ENUM!{enum HTTP_PROTECTION_LEVEL_TYPE {
248     HttpProtectionLevelUnrestricted,
249     HttpProtectionLevelEdgeRestricted,
250     HttpProtectionLevelRestricted,
251 }}
252 pub type PHTTP_PROTECTION_LEVEL_TYPE = *mut HTTP_PROTECTION_LEVEL_TYPE;
253 STRUCT!{struct HTTP_PROTECTION_LEVEL_INFO {
254     Flags: HTTP_PROPERTY_FLAGS,
255     Level: HTTP_PROTECTION_LEVEL_TYPE,
256 }}
257 pub type PHTTP_PROTECTION_LEVEL_INFO = *mut HTTP_PROTECTION_LEVEL_INFO;
258 pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_OPEN_EXISTING: ::ULONG = 0x00000001;
259 pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_CONTROLLER: ::ULONG = 0x00000002;
260 pub const HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY: ::ULONG = 0x00000001;
261 pub const HTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODY: ::ULONG = 0x00000002;
262 pub const HTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFER: ::ULONG = 0x00000001;
263 pub const HTTP_SEND_RESPONSE_FLAG_DISCONNECT: ::ULONG = 0x00000001;
264 pub const HTTP_SEND_RESPONSE_FLAG_MORE_DATA: ::ULONG = 0x00000002;
265 pub const HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA: ::ULONG = 0x00000004;
266 pub const HTTP_SEND_RESPONSE_FLAG_ENABLE_NAGLING: ::ULONG = 0x00000008;
267 pub const HTTP_SEND_RESPONSE_FLAG_PROCESS_RANGES: ::ULONG = 0x00000020;
268 pub const HTTP_SEND_RESPONSE_FLAG_OPAQUE: ::ULONG = 0x00000040;
269 pub const HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE: ::ULONG = 0x00000001;
270 pub type HTTP_OPAQUE_ID = ::ULONGLONG;
271 pub type PHTTP_OPAQUE_ID = *mut ::ULONGLONG;
272 pub type HTTP_REQUEST_ID = HTTP_OPAQUE_ID;
273 pub type PHTTP_REQUEST_ID = *mut HTTP_OPAQUE_ID;
274 pub type HTTP_CONNECTION_ID = HTTP_OPAQUE_ID;
275 pub type PHTTP_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
276 pub type HTTP_RAW_CONNECTION_ID = HTTP_OPAQUE_ID;
277 pub type PHTTP_RAW_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
278 pub type HTTP_URL_GROUP_ID = HTTP_OPAQUE_ID;
279 pub type PHTTP_URL_GROUP_ID = *mut HTTP_OPAQUE_ID;
280 pub type HTTP_SERVER_SESSION_ID = HTTP_OPAQUE_ID;
281 pub type PHTTP_SERVER_SESSION_ID = *mut HTTP_OPAQUE_ID;
282 pub const HTTP_BYTE_RANGE_TO_EOF: ::ULONGLONG = !0;
283 STRUCT!{struct HTTP_BYTE_RANGE {
284     StartingOffset: ::ULARGE_INTEGER,
285     Length: ::ULARGE_INTEGER,
286 }}
287 pub type PHTTP_BYTE_RANGE = *mut HTTP_BYTE_RANGE;
288 STRUCT!{struct HTTP_VERSION {
289     MajorVersion: ::USHORT,
290     MinorVersion: ::USHORT,
291 }}
292 pub type PHTTP_VERSION = *mut HTTP_VERSION;
293 pub const HTTP_VERSION_UNKNOWN: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 0 };
294 pub const HTTP_VERSION_0_9: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 9 };
295 pub const HTTP_VERSION_1_0: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 0 };
296 pub const HTTP_VERSION_1_1: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 1 };
297 #[inline] #[allow(dead_code)]
HTTP_SET_VERSION(mut version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT)298 pub fn HTTP_SET_VERSION(mut version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) {
299     version.MajorVersion = major;
300     version.MinorVersion = minor;
301 }
302 #[inline] #[allow(dead_code)]
HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool303 pub fn HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
304     version.MajorVersion == major && version.MinorVersion == minor
305 }
306 #[inline] #[allow(dead_code)]
HTTP_GREATER_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool307 pub fn HTTP_GREATER_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
308     version.MajorVersion > major || (version.MajorVersion == major && version.MinorVersion > minor)
309 }
310 #[inline] #[allow(dead_code)]
HTTP_LESS_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool311 pub fn HTTP_LESS_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
312     version.MajorVersion < major || (version.MajorVersion == major && version.MinorVersion < minor)
313 }
314 #[inline] #[allow(dead_code)]
HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool315 pub fn HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
316     !HTTP_EQUAL_VERSION(version, major, minor)
317 }
318 #[inline] #[allow(dead_code)]
HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool319 pub fn HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
320     !HTTP_LESS_VERSION(version, major, minor)
321 }
322 #[inline] #[allow(dead_code)]
HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool323 pub fn HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
324     !HTTP_GREATER_VERSION(version, major, minor)
325 }
326 ENUM!{enum HTTP_VERB {
327     HttpVerbUnparsed,
328     HttpVerbUnknown,
329     HttpVerbInvalid,
330     HttpVerbOPTIONS,
331     HttpVerbGET,
332     HttpVerbHEAD,
333     HttpVerbPOST,
334     HttpVerbPUT,
335     HttpVerbDELETE,
336     HttpVerbTRACE,
337     HttpVerbCONNECT,
338     HttpVerbTRACK,
339     HttpVerbMOVE,
340     HttpVerbCOPY,
341     HttpVerbPROPFIND,
342     HttpVerbPROPPATCH,
343     HttpVerbMKCOL,
344     HttpVerbLOCK,
345     HttpVerbUNLOCK,
346     HttpVerbSEARCH,
347     HttpVerbMaximum,
348 }}
349 pub type PHTTP_VERB = *mut HTTP_VERB;
350 ENUM!{enum HTTP_HEADER_ID {
351     HttpHeaderCacheControl = 0,
352     HttpHeaderConnection = 1,
353     HttpHeaderDate = 2,
354     HttpHeaderKeepAlive = 3,
355     HttpHeaderPragma = 4,
356     HttpHeaderTrailer = 5,
357     HttpHeaderTransferEncoding = 6,
358     HttpHeaderUpgrade = 7,
359     HttpHeaderVia = 8,
360     HttpHeaderWarning = 9,
361     HttpHeaderAllow = 10,
362     HttpHeaderContentLength = 11,
363     HttpHeaderContentType = 12,
364     HttpHeaderContentEncoding = 13,
365     HttpHeaderContentLanguage = 14,
366     HttpHeaderContentLocation = 15,
367     HttpHeaderContentMd5 = 16,
368     HttpHeaderContentRange = 17,
369     HttpHeaderExpires = 18,
370     HttpHeaderLastModified = 19,
371     HttpHeaderAccept = 20,
372     HttpHeaderAcceptCharset = 21,
373     HttpHeaderAcceptEncoding = 22,
374     HttpHeaderAcceptLanguage = 23,
375     HttpHeaderAuthorization = 24,
376     HttpHeaderCookie = 25,
377     HttpHeaderExpect = 26,
378     HttpHeaderFrom = 27,
379     HttpHeaderHost = 28,
380     HttpHeaderIfMatch = 29,
381     HttpHeaderIfModifiedSince = 30,
382     HttpHeaderIfNoneMatch = 31,
383     HttpHeaderIfRange = 32,
384     HttpHeaderIfUnmodifiedSince = 33,
385     HttpHeaderMaxForwards = 34,
386     HttpHeaderProxyAuthorization = 35,
387     HttpHeaderReferer = 36,
388     HttpHeaderRange = 37,
389     HttpHeaderTe = 38,
390     HttpHeaderTranslate = 39,
391     HttpHeaderUserAgent = 40,
392     HttpHeaderRequestMaximum = 41,
393     HttpHeaderAcceptRanges = 20,
394     HttpHeaderAge = 21,
395     HttpHeaderEtag = 22,
396     HttpHeaderLocation = 23,
397     HttpHeaderProxyAuthenticate = 24,
398     HttpHeaderRetryAfter = 25,
399     HttpHeaderServer = 26,
400     HttpHeaderSetCookie = 27,
401     HttpHeaderVary = 28,
402     HttpHeaderWwwAuthenticate = 29,
403     HttpHeaderResponseMaximum = 30,
404     HttpHeaderMaximum = 41,
405 }}
406 pub type PHTTP_HEADER_ID = *mut HTTP_HEADER_ID;
407 STRUCT!{struct HTTP_KNOWN_HEADER {
408     RawValueLength: ::USHORT,
409     pRawValue: ::PCSTR,
410 }}
411 pub type PHTTP_KNOWN_HEADER = *mut HTTP_KNOWN_HEADER;
412 STRUCT!{struct HTTP_UNKNOWN_HEADER {
413     NameLength: ::USHORT,
414     RawValueLength: ::USHORT,
415     pName: ::PCSTR,
416     pRawValue: ::PCSTR,
417 }}
418 pub type PHTTP_UNKNOWN_HEADER = *mut HTTP_UNKNOWN_HEADER;
419 ENUM!{enum HTTP_LOG_DATA_TYPE {
420     HttpLogDataTypeFields = 0,
421 }}
422 pub type PHTTP_LOG_DATA_TYPE = *mut HTTP_LOG_DATA_TYPE;
423 STRUCT!{struct HTTP_LOG_DATA {
424     Type: HTTP_LOG_DATA_TYPE,
425 }}
426 pub type PHTTP_LOG_DATA = *mut HTTP_LOG_DATA;
427 STRUCT!{struct HTTP_LOG_FIELDS_DATA {
428     Base: HTTP_LOG_DATA,
429     UserNameLength: ::USHORT,
430     UriStemLength: ::USHORT,
431     ClientIpLength: ::USHORT,
432     ServerNameLength: ::USHORT,
433     ServiceNameLength: ::USHORT,
434     ServerIpLength: ::USHORT,
435     MethodLength: ::USHORT,
436     UriQueryLength: ::USHORT,
437     HostLength: ::USHORT,
438     UserAgentLength: ::USHORT,
439     CookieLength: ::USHORT,
440     ReferrerLength: ::USHORT,
441     UserName: ::PWCHAR,
442     UriStem: ::PWCHAR,
443     ClientIp: ::PCHAR,
444     ServerName: ::PCHAR,
445     ServiceName: ::PCHAR,
446     ServerIp: ::PCHAR,
447     Method: ::PCHAR,
448     UriQuery: ::PCHAR,
449     Host: ::PCHAR,
450     UserAgent: ::PCHAR,
451     Cookie: ::PCHAR,
452     Referrer: ::PCHAR,
453     ServerPort: ::USHORT,
454     ProtocolStatus: ::USHORT,
455     Win32Status: ::ULONG,
456     MethodNum: HTTP_VERB,
457     SubStatus: ::USHORT,
458 }}
459 pub type PHTTP_LOG_FIELDS_DATA = *mut HTTP_LOG_FIELDS_DATA;
460 ENUM!{enum HTTP_DATA_CHUNK_TYPE {
461     HttpDataChunkFromMemory,
462     HttpDataChunkFromFileHandle,
463     HttpDataChunkFromFragmentCache,
464     HttpDataChunkFromFragmentCacheEx,
465     HttpDataChunkMaximum,
466 }}
467 pub type PHTTP_DATA_CHUNK_TYPE = *mut HTTP_DATA_CHUNK_TYPE;
468 STRUCT!{struct HTTP_DATA_CHUNK_FromMemory {
469     pBuffer: ::PVOID,
470     BufferLength: ::ULONG,
471 }}
472 STRUCT!{struct HTTP_DATA_CHUNK_FromFileHandle {
473     ByteRange: HTTP_BYTE_RANGE,
474     FileHandle: ::HANDLE,
475 }}
476 STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCache {
477     FragmentNameLength: ::USHORT,
478     pFragmentName: ::PCWSTR,
479 }}
480 STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCacheEx {
481     ByteRange: HTTP_BYTE_RANGE,
482     pFragmentName: ::PCWSTR,
483 }}
484 STRUCT!{struct HTTP_DATA_CHUNK {
485     DataChunkType: HTTP_DATA_CHUNK_TYPE,
486     FromFileHandle: HTTP_DATA_CHUNK_FromFileHandle,
487 }}
488 UNION!(HTTP_DATA_CHUNK, FromFileHandle, FromMemory, FromMemory_mut, HTTP_DATA_CHUNK_FromMemory);
489 UNION!(
490     HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCache, FromFragmentCache_mut,
491     HTTP_DATA_CHUNK_FromFragmentCache
492 );
493 UNION!(
494     HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCacheEx, FromFragmentCacheEx_mut,
495     HTTP_DATA_CHUNK_FromFragmentCacheEx
496 );
497 pub type PHTTP_DATA_CHUNK = *mut HTTP_DATA_CHUNK;
498 STRUCT!{nodebug struct HTTP_REQUEST_HEADERS {
499     UnknownHeaderCount: ::USHORT,
500     pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
501     TrailerCount: ::USHORT,
502     pTrailers: PHTTP_UNKNOWN_HEADER,
503     KnownHeaders: [HTTP_KNOWN_HEADER; 41], // FIXME HttpHeaderRequestMaximum
504 }}
505 pub type PHTTP_REQUEST_HEADERS = *mut HTTP_REQUEST_HEADERS;
506 STRUCT!{nodebug struct HTTP_RESPONSE_HEADERS {
507     UnknownHeaderCount: ::USHORT,
508     pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
509     TrailerCount: ::USHORT,
510     pTrailers: PHTTP_UNKNOWN_HEADER,
511     KnownHeaders: [HTTP_KNOWN_HEADER; 30], // FIXME HttpHeaderResponseMaximum
512 }}
513 pub type PHTTP_RESPONSE_HEADERS = *mut HTTP_RESPONSE_HEADERS;
514 STRUCT!{struct HTTP_TRANSPORT_ADDRESS {
515     pRemoteAddress: ::PSOCKADDR,
516     pLocalAddress: ::PSOCKADDR,
517 }}
518 pub type PHTTP_TRANSPORT_ADDRESS = *mut HTTP_TRANSPORT_ADDRESS;
519 STRUCT!{struct HTTP_COOKED_URL {
520     FullUrlLength: ::USHORT,
521     HostLength: ::USHORT,
522     AbsPathLength: ::USHORT,
523     QueryStringLength: ::USHORT,
524     pFullUrl: ::PCWSTR,
525     pHost: ::PCWSTR,
526     pAbsPath: ::PCWSTR,
527     pQueryString: ::PCWSTR,
528 }}
529 pub type PHTTP_COOKED_URL = *mut HTTP_COOKED_URL;
530 pub type HTTP_URL_CONTEXT = ::ULONGLONG;
531 pub const HTTP_URL_FLAG_REMOVE_ALL: ::ULONG = 0x00000001;
532 ENUM!{enum HTTP_AUTH_STATUS {
533     HttpAuthStatusSuccess,
534     HttpAuthStatusNotAuthenticated,
535     HttpAuthStatusFailure,
536 }}
537 pub type PHTTP_AUTH_STATUS = *mut HTTP_AUTH_STATUS;
538 ENUM!{enum HTTP_REQUEST_AUTH_TYPE {
539     HttpRequestAuthTypeNone = 0,
540     HttpRequestAuthTypeBasic,
541     HttpRequestAuthTypeDigest,
542     HttpRequestAuthTypeNTLM,
543     HttpRequestAuthTypeNegotiate,
544     HttpRequestAuthTypeKerberos,
545 }}
546 pub type PHTTP_REQUEST_AUTH_TYPE = *mut HTTP_REQUEST_AUTH_TYPE;
547 STRUCT!{struct HTTP_SSL_CLIENT_CERT_INFO {
548     CertFlags: ::ULONG,
549     CertEncodedSize: ::ULONG,
550     pCertEncoded: ::PUCHAR,
551     Token: ::HANDLE,
552     CertDeniedByMapper: ::BOOLEAN,
553 }}
554 pub type PHTTP_SSL_CLIENT_CERT_INFO = *mut HTTP_SSL_CLIENT_CERT_INFO;
555 pub const HTTP_RECEIVE_SECURE_CHANNEL_TOKEN: ::ULONG = 0x1;
556 STRUCT!{struct HTTP_SSL_INFO {
557     ServerCertKeySize: ::USHORT,
558     ConnectionKeySize: ::USHORT,
559     ServerCertIssuerSize: ::ULONG,
560     ServerCertSubjectSize: ::ULONG,
561     pServerCertIssuer: ::PCSTR,
562     pServerCertSubject: ::PCSTR,
563     pClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
564     SslClientCertNegotiated: ::ULONG,
565 }}
566 pub type PHTTP_SSL_INFO = *mut HTTP_SSL_INFO;
567 ENUM!{enum HTTP_REQUEST_INFO_TYPE {
568     HttpRequestInfoTypeAuth,
569     HttpRequestInfoTypeChannelBind,
570 }}
571 STRUCT!{struct HTTP_REQUEST_INFO {
572     InfoType: HTTP_REQUEST_INFO_TYPE,
573     InfoLength: ::ULONG,
574     pInfo: ::PVOID,
575 }}
576 pub type PHTTP_REQUEST_INFO = *mut HTTP_REQUEST_INFO;
577 pub const HTTP_REQUEST_AUTH_FLAG_TOKEN_FOR_CACHED_CRED: ::ULONG = 0x00000001;
578 STRUCT!{struct HTTP_REQUEST_AUTH_INFO {
579     AuthStatus: HTTP_AUTH_STATUS,
580     SecStatus: ::SECURITY_STATUS,
581     Flags: ::ULONG,
582     AuthType: HTTP_REQUEST_AUTH_TYPE,
583     AccessToken: ::HANDLE,
584     ContextAttributes: ::ULONG,
585     PackedContextLength: ::ULONG,
586     PackedContextType: ::ULONG,
587     PackedContext: ::PVOID,
588     MutualAuthDataLength: ::ULONG,
589     pMutualAuthData: ::PCHAR,
590     PackageNameLength: ::USHORT,
591     pPackageName: ::PWSTR,
592 }}
593 pub type PHTTP_REQUEST_AUTH_INFO = *mut HTTP_REQUEST_AUTH_INFO;
594 STRUCT!{nodebug struct HTTP_REQUEST_V1 {
595     Flags: ::ULONG,
596     ConnectionId: HTTP_CONNECTION_ID,
597     RequestId: HTTP_REQUEST_ID,
598     UrlContext: HTTP_URL_CONTEXT,
599     Version: HTTP_VERSION,
600     Verb: HTTP_VERB,
601     UnknownVerbLength: ::USHORT,
602     RawUrlLength: ::USHORT,
603     pUnknownVerb: ::PCSTR,
604     pRawUrl: ::PCSTR,
605     CookedUrl: HTTP_COOKED_URL,
606     Address: HTTP_TRANSPORT_ADDRESS,
607     Headers: HTTP_REQUEST_HEADERS,
608     BytesReceived: ::ULONGLONG,
609     EntityChunkCount: ::USHORT,
610     pEntityChunks: PHTTP_DATA_CHUNK,
611     RawConnectionId: HTTP_RAW_CONNECTION_ID,
612     pSslInfo: PHTTP_SSL_INFO,
613 }}
614 pub type PHTTP_REQUEST_V1 = *mut HTTP_REQUEST_V1;
615 STRUCT!{nodebug struct HTTP_REQUEST_V2 {
616     Base: HTTP_REQUEST_V1,
617     RequestInfoCount: ::USHORT,
618     pRequestInfo: PHTTP_REQUEST_INFO,
619 }}
620 pub type PHTTP_REQUEST_V2 = *mut HTTP_REQUEST_V2;
621 pub type HTTP_REQUEST = HTTP_REQUEST_V2;
622 pub type PHTTP_REQUEST = *mut HTTP_REQUEST;
623 pub const HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS: ::ULONG = 0x00000001;
624 pub const HTTP_REQUEST_FLAG_IP_ROUTED: ::ULONG = 0x00000002;
625 STRUCT!{nodebug struct HTTP_RESPONSE_V1 {
626     Flags: ::ULONG,
627     Version: HTTP_VERSION,
628     StatusCode: ::USHORT,
629     ReasonLength: ::USHORT,
630     pReason: ::PCSTR,
631     Headers: HTTP_RESPONSE_HEADERS,
632     EntityChunkCount: ::USHORT,
633     pEntityChunks: PHTTP_DATA_CHUNK,
634 }}
635 pub type PHTTP_RESPONSE_V1 = *mut HTTP_RESPONSE_V1;
636 pub const HTTP_RESPONSE_FLAG_MULTIPLE_ENCODINGS_AVAILABLE: ::ULONG = 0x00000001;
637 ENUM!{enum HTTP_RESPONSE_INFO_TYPE {
638     HttpResponseInfoTypeMultipleKnownHeaders,
639     HttpResponseInfoTypeAuthenticationProperty,
640     HttpResponseInfoTypeQoSProperty,
641     HttpResponseInfoTypeChannelBind,
642 }}
643 pub type PHTTP_RESPONSE_INFO_TYPE = *mut HTTP_RESPONSE_INFO_TYPE;
644 STRUCT!{struct HTTP_RESPONSE_INFO {
645     Type: HTTP_RESPONSE_INFO_TYPE,
646     Length: ::ULONG,
647     pInfo: ::PVOID,
648 }}
649 pub type PHTTP_RESPONSE_INFO = *mut HTTP_RESPONSE_INFO;
650 pub const HTTP_RESPONSE_INFO_FLAGS_PRESERVE_ORDER: ::ULONG = 0x00000001;
651 STRUCT!{struct HTTP_MULTIPLE_KNOWN_HEADERS {
652     HeaderId: HTTP_HEADER_ID,
653     Flags: ::ULONG,
654     KnownHeaderCount: ::USHORT,
655     KnownHeaders: PHTTP_KNOWN_HEADER,
656 }}
657 pub type PHTTP_MULTIPLE_KNOWN_HEADERS = *mut HTTP_MULTIPLE_KNOWN_HEADERS;
658 STRUCT!{nodebug struct HTTP_RESPONSE_V2 {
659     Base: HTTP_RESPONSE_V1,
660     ResponseInfoCount: ::USHORT,
661     pResponseInfo: PHTTP_RESPONSE_INFO,
662 }}
663 pub type PHTTP_RESPONSE_V2 = *mut HTTP_RESPONSE_V2;
664 pub type HTTP_RESPONSE = HTTP_RESPONSE_V2;
665 pub type PHTTP_RESPONSE = *mut HTTP_RESPONSE;
666 STRUCT!{struct HTTPAPI_VERSION {
667     HttpApiMajorVersion: ::USHORT,
668     HttpApiMinorVersion: ::USHORT,
669 }}
670 pub type PHTTPAPI_VERSION = *mut HTTPAPI_VERSION;
671 pub const HTTPAPI_VERSION_2: HTTPAPI_VERSION = HTTPAPI_VERSION {
672     HttpApiMajorVersion: 2, HttpApiMinorVersion: 0,
673 };
674 pub const HTTPAPI_VERSION_1: HTTPAPI_VERSION = HTTPAPI_VERSION {
675     HttpApiMajorVersion: 1, HttpApiMinorVersion: 0,
676 };
677 #[inline] #[allow(dead_code)]
HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool678 pub fn HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
679     version.HttpApiMajorVersion == major && version.HttpApiMinorVersion == minor
680 }
681 #[inline] #[allow(dead_code)]
HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool682 pub fn HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
683     version.HttpApiMajorVersion > major ||
684     (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion > minor)
685 }
686 #[inline] #[allow(dead_code)]
HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool687 pub fn HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
688     version.HttpApiMajorVersion < major ||
689     (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion < minor)
690 }
691 #[inline] #[allow(dead_code)]
HTTPAPI_VERSION_GREATER_OR_EQUAL( version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT ) -> bool692 pub fn HTTPAPI_VERSION_GREATER_OR_EQUAL(
693     version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT
694 ) -> bool {
695     !HTTPAPI_LESS_VERSION(version, major, minor)
696 }
697 ENUM!{enum HTTP_CACHE_POLICY_TYPE {
698     HttpCachePolicyNocache,
699     HttpCachePolicyUserInvalidates,
700     HttpCachePolicyTimeToLive,
701     HttpCachePolicyMaximum,
702 }}
703 pub type PHTTP_CACHE_POLICY_TYPE = *mut HTTP_CACHE_POLICY_TYPE;
704 STRUCT!{struct HTTP_CACHE_POLICY {
705     Policy: HTTP_CACHE_POLICY_TYPE,
706     SecondsToLive: ::ULONG,
707 }}
708 pub type PHTTP_CACHE_POLICY = *mut HTTP_CACHE_POLICY;
709 ENUM!{enum HTTP_SERVICE_CONFIG_ID {
710     HttpServiceConfigIPListenList,
711     HttpServiceConfigSSLCertInfo,
712     HttpServiceConfigUrlAclInfo,
713     HttpServiceConfigTimeout,
714     HttpServiceConfigCache,
715     HttpServiceConfigSslSniCertInfo,
716     HttpServiceConfigSslCcsCertInfo,
717     HttpServiceConfigMax,
718 }}
719 pub type PHTTP_SERVICE_CONFIG_ID = *mut HTTP_SERVICE_CONFIG_ID;
720 ENUM!{enum HTTP_SERVICE_CONFIG_QUERY_TYPE {
721     HttpServiceConfigQueryExact,
722     HttpServiceConfigQueryNext,
723     HttpServiceConfigQueryMax,
724 }}
725 pub type PHTTP_SERVICE_CONFIG_QUERY_TYPE = *mut HTTP_SERVICE_CONFIG_QUERY_TYPE;
726 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_KEY {
727     pIpPort: ::PSOCKADDR,
728 }}
729 pub type PHTTP_SERVICE_CONFIG_SSL_KEY = *mut HTTP_SERVICE_CONFIG_SSL_KEY;
730 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_KEY {
731     IpPort: ::SOCKADDR_STORAGE,
732     Host: ::PWSTR,
733 }}
734 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_KEY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_KEY;
735 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_KEY {
736     LocalAddress: ::SOCKADDR_STORAGE,
737 }}
738 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_KEY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_KEY;
739 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_PARAM {
740     SslHashLength: ::ULONG,
741     pSslHash: ::PVOID,
742     AppId: ::GUID,
743     pSslCertStoreName: ::PWSTR,
744     DefaultCertCheckMode: ::DWORD,
745     DefaultRevocationFreshnessTime: ::DWORD,
746     DefaultRevocationUrlRetrievalTimeout: ::DWORD,
747     pDefaultSslCtlIdentifier: ::PWSTR,
748     pDefaultSslCtlStoreName: ::PWSTR,
749     DefaultFlags: ::DWORD,
750 }}
751 pub type PHTTP_SERVICE_CONFIG_SSL_PARAM = *mut HTTP_SERVICE_CONFIG_SSL_PARAM;
752 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER: ::DWORD = 0x00000001;
753 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT: ::DWORD = 0x00000002;
754 pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER: ::DWORD = 0x00000004;
755 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SET {
756     KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
757     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
758 }}
759 pub type PHTTP_SERVICE_CONFIG_SSL_SET = *mut HTTP_SERVICE_CONFIG_SSL_SET;
760 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_SET {
761     KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
762     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
763 }}
764 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_SET = *mut HTTP_SERVICE_CONFIG_SSL_SNI_SET;
765 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_SET {
766     KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
767     ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
768 }}
769 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_SET = *mut HTTP_SERVICE_CONFIG_SSL_CCS_SET;
770 STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_QUERY {
771     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
772     KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
773     dwToken: ::DWORD,
774 }}
775 pub type PHTTP_SERVICE_CONFIG_SSL_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_QUERY;
776 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_QUERY {
777     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
778     KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
779     dwToken: ::DWORD,
780 }}
781 pub type PHTTP_SERVICE_CONFIG_SSL_SNI_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_QUERY;
782 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_QUERY {
783     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
784     KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
785     dwToken: ::DWORD,
786 }}
787 pub type PHTTP_SERVICE_CONFIG_SSL_CCS_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_QUERY;
788 STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM {
789     AddrLength: ::USHORT,
790     pAddress: ::PSOCKADDR,
791 }}
792 pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM;
793 STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY {
794     AddrCount: ::ULONG,
795     AddrList: [::SOCKADDR_STORAGE; ::ANYSIZE_ARRAY],
796 }}
797 pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY;
798 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_KEY {
799     pUrlPrefix: ::PWSTR,
800 }}
801 pub type PHTTP_SERVICE_CONFIG_URLACL_KEY = *mut HTTP_SERVICE_CONFIG_URLACL_KEY;
802 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_PARAM {
803     pStringSecurityDescriptor: ::PWSTR,
804 }}
805 pub type PHTTP_SERVICE_CONFIG_URLACL_PARAM = *mut HTTP_SERVICE_CONFIG_URLACL_PARAM;
806 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_SET {
807     KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
808     ParamDesc: HTTP_SERVICE_CONFIG_URLACL_PARAM,
809 }}
810 pub type PHTTP_SERVICE_CONFIG_URLACL_SET = *mut HTTP_SERVICE_CONFIG_URLACL_SET;
811 STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_QUERY {
812     QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
813     KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
814     dwToken: ::DWORD,
815 }}
816 pub type PHTTP_SERVICE_CONFIG_URLACL_QUERY = *mut HTTP_SERVICE_CONFIG_URLACL_QUERY;
817 ENUM!{enum HTTP_SERVICE_CONFIG_CACHE_KEY {
818     MaxCacheResponseSize = 0,
819     CacheRangeChunkSize,
820 }}
821 pub type PHTTP_SERVICE_CONFIG_CACHE_KEY = *mut HTTP_SERVICE_CONFIG_CACHE_KEY;
822 pub type HTTP_SERVICE_CONFIG_CACHE_PARAM = ::ULONG;
823 pub type PHTTP_SERVICE_CONFIG_CACHE_PARAM = *mut ::ULONG;
824 STRUCT!{struct HTTP_SERVICE_CONFIG_CACHE_SET {
825     KeyDesc: HTTP_SERVICE_CONFIG_CACHE_KEY,
826     ParamDesc: HTTP_SERVICE_CONFIG_CACHE_PARAM,
827 }}
828 pub type PHTTP_SERVICE_CONFIG_CACHE_SET = *mut HTTP_SERVICE_CONFIG_CACHE_SET;
829