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