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