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