1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const AAL5_MODE_MESSAGE: u32 = 1u32;
3 pub const AAL5_MODE_STREAMING: u32 = 2u32;
4 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5 #[repr(C)]
6 pub struct AAL5_PARAMETERS {
7     pub ForwardMaxCPCSSDUSize: u32,
8     pub BackwardMaxCPCSSDUSize: u32,
9     pub Mode: u8,
10     pub SSCSType: u8,
11 }
12 impl AAL5_PARAMETERS {}
13 impl ::std::default::Default for AAL5_PARAMETERS {
default() -> Self14     fn default() -> Self {
15         unsafe { ::std::mem::zeroed() }
16     }
17 }
18 impl ::std::fmt::Debug for AAL5_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result19     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20         fmt.debug_struct("AAL5_PARAMETERS").field("ForwardMaxCPCSSDUSize", &self.ForwardMaxCPCSSDUSize).field("BackwardMaxCPCSSDUSize", &self.BackwardMaxCPCSSDUSize).field("Mode", &self.Mode).field("SSCSType", &self.SSCSType).finish()
21     }
22 }
23 impl ::std::cmp::PartialEq for AAL5_PARAMETERS {
eq(&self, other: &Self) -> bool24     fn eq(&self, other: &Self) -> bool {
25         self.ForwardMaxCPCSSDUSize == other.ForwardMaxCPCSSDUSize && self.BackwardMaxCPCSSDUSize == other.BackwardMaxCPCSSDUSize && self.Mode == other.Mode && self.SSCSType == other.SSCSType
26     }
27 }
28 impl ::std::cmp::Eq for AAL5_PARAMETERS {}
29 unsafe impl ::windows::runtime::Abi for AAL5_PARAMETERS {
30     type Abi = Self;
31     type DefaultType = Self;
32 }
33 pub const AAL5_SSCS_FRAME_RELAY: u32 = 4u32;
34 pub const AAL5_SSCS_NULL: u32 = 0u32;
35 pub const AAL5_SSCS_SSCOP_ASSURED: u32 = 1u32;
36 pub const AAL5_SSCS_SSCOP_NON_ASSURED: u32 = 2u32;
37 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
38 #[repr(C)]
39 pub struct AALUSER_PARAMETERS {
40     pub UserDefined: u32,
41 }
42 impl AALUSER_PARAMETERS {}
43 impl ::std::default::Default for AALUSER_PARAMETERS {
default() -> Self44     fn default() -> Self {
45         unsafe { ::std::mem::zeroed() }
46     }
47 }
48 impl ::std::fmt::Debug for AALUSER_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result49     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
50         fmt.debug_struct("AALUSER_PARAMETERS").field("UserDefined", &self.UserDefined).finish()
51     }
52 }
53 impl ::std::cmp::PartialEq for AALUSER_PARAMETERS {
eq(&self, other: &Self) -> bool54     fn eq(&self, other: &Self) -> bool {
55         self.UserDefined == other.UserDefined
56     }
57 }
58 impl ::std::cmp::Eq for AALUSER_PARAMETERS {}
59 unsafe impl ::windows::runtime::Abi for AALUSER_PARAMETERS {
60     type Abi = Self;
61     type DefaultType = Self;
62 }
63 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
64 #[repr(C)]
65 pub struct AAL_PARAMETERS_IE {
66     pub AALType: AAL_TYPE,
67     pub AALSpecificParameters: AAL_PARAMETERS_IE_0,
68 }
69 impl AAL_PARAMETERS_IE {}
70 impl ::std::default::Default for AAL_PARAMETERS_IE {
default() -> Self71     fn default() -> Self {
72         unsafe { ::std::mem::zeroed() }
73     }
74 }
75 impl ::std::cmp::PartialEq for AAL_PARAMETERS_IE {
eq(&self, _other: &Self) -> bool76     fn eq(&self, _other: &Self) -> bool {
77         unimplemented!()
78     }
79 }
80 impl ::std::cmp::Eq for AAL_PARAMETERS_IE {}
81 unsafe impl ::windows::runtime::Abi for AAL_PARAMETERS_IE {
82     type Abi = Self;
83     type DefaultType = Self;
84 }
85 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
86 #[repr(C)]
87 pub union AAL_PARAMETERS_IE_0 {
88     pub AAL5Parameters: AAL5_PARAMETERS,
89     pub AALUserParameters: AALUSER_PARAMETERS,
90 }
91 impl AAL_PARAMETERS_IE_0 {}
92 impl ::std::default::Default for AAL_PARAMETERS_IE_0 {
default() -> Self93     fn default() -> Self {
94         unsafe { ::std::mem::zeroed() }
95     }
96 }
97 impl ::std::cmp::PartialEq for AAL_PARAMETERS_IE_0 {
eq(&self, _other: &Self) -> bool98     fn eq(&self, _other: &Self) -> bool {
99         unimplemented!()
100     }
101 }
102 impl ::std::cmp::Eq for AAL_PARAMETERS_IE_0 {}
103 unsafe impl ::windows::runtime::Abi for AAL_PARAMETERS_IE_0 {
104     type Abi = Self;
105     type DefaultType = Self;
106 }
107 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
108 #[repr(transparent)]
109 pub struct AAL_TYPE(pub i32);
110 pub const AALTYPE_5: AAL_TYPE = AAL_TYPE(5i32);
111 pub const AALTYPE_USER: AAL_TYPE = AAL_TYPE(16i32);
112 impl ::std::convert::From<i32> for AAL_TYPE {
from(value: i32) -> Self113     fn from(value: i32) -> Self {
114         Self(value)
115     }
116 }
117 unsafe impl ::windows::runtime::Abi for AAL_TYPE {
118     type Abi = Self;
119     type DefaultType = Self;
120 }
121 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
122 #[repr(C)]
123 #[cfg(feature = "Win32_Foundation")]
124 pub struct ADDRINFOA {
125     pub ai_flags: i32,
126     pub ai_family: i32,
127     pub ai_socktype: i32,
128     pub ai_protocol: i32,
129     pub ai_addrlen: usize,
130     pub ai_canonname: super::super::Foundation::PSTR,
131     pub ai_addr: *mut SOCKADDR,
132     pub ai_next: *mut ADDRINFOA,
133 }
134 #[cfg(feature = "Win32_Foundation")]
135 impl ADDRINFOA {}
136 #[cfg(feature = "Win32_Foundation")]
137 impl ::std::default::Default for ADDRINFOA {
default() -> Self138     fn default() -> Self {
139         unsafe { ::std::mem::zeroed() }
140     }
141 }
142 #[cfg(feature = "Win32_Foundation")]
143 impl ::std::fmt::Debug for ADDRINFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result144     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
145         fmt.debug_struct("ADDRINFOA")
146             .field("ai_flags", &self.ai_flags)
147             .field("ai_family", &self.ai_family)
148             .field("ai_socktype", &self.ai_socktype)
149             .field("ai_protocol", &self.ai_protocol)
150             .field("ai_addrlen", &self.ai_addrlen)
151             .field("ai_canonname", &self.ai_canonname)
152             .field("ai_addr", &self.ai_addr)
153             .field("ai_next", &self.ai_next)
154             .finish()
155     }
156 }
157 #[cfg(feature = "Win32_Foundation")]
158 impl ::std::cmp::PartialEq for ADDRINFOA {
eq(&self, other: &Self) -> bool159     fn eq(&self, other: &Self) -> bool {
160         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_next == other.ai_next
161     }
162 }
163 #[cfg(feature = "Win32_Foundation")]
164 impl ::std::cmp::Eq for ADDRINFOA {}
165 #[cfg(feature = "Win32_Foundation")]
166 unsafe impl ::windows::runtime::Abi for ADDRINFOA {
167     type Abi = Self;
168     type DefaultType = Self;
169 }
170 pub const ADDRINFOEX_VERSION_2: u32 = 2u32;
171 pub const ADDRINFOEX_VERSION_3: u32 = 3u32;
172 pub const ADDRINFOEX_VERSION_4: u32 = 4u32;
173 pub const ADDRINFOEX_VERSION_5: u32 = 5u32;
174 pub const ADDRINFOEX_VERSION_6: u32 = 6u32;
175 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
176 #[repr(C)]
177 pub struct AFPROTOCOLS {
178     pub iAddressFamily: i32,
179     pub iProtocol: i32,
180 }
181 impl AFPROTOCOLS {}
182 impl ::std::default::Default for AFPROTOCOLS {
default() -> Self183     fn default() -> Self {
184         unsafe { ::std::mem::zeroed() }
185     }
186 }
187 impl ::std::fmt::Debug for AFPROTOCOLS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result188     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
189         fmt.debug_struct("AFPROTOCOLS").field("iAddressFamily", &self.iAddressFamily).field("iProtocol", &self.iProtocol).finish()
190     }
191 }
192 impl ::std::cmp::PartialEq for AFPROTOCOLS {
eq(&self, other: &Self) -> bool193     fn eq(&self, other: &Self) -> bool {
194         self.iAddressFamily == other.iAddressFamily && self.iProtocol == other.iProtocol
195     }
196 }
197 impl ::std::cmp::Eq for AFPROTOCOLS {}
198 unsafe impl ::windows::runtime::Abi for AFPROTOCOLS {
199     type Abi = Self;
200     type DefaultType = Self;
201 }
202 pub const AF_12844: u16 = 25u16;
203 pub const AF_APPLETALK: u16 = 16u16;
204 pub const AF_ATM: u16 = 22u16;
205 pub const AF_BAN: u16 = 21u16;
206 pub const AF_CCITT: u16 = 10u16;
207 pub const AF_CHAOS: u16 = 5u16;
208 pub const AF_CLUSTER: u16 = 24u16;
209 pub const AF_DATAKIT: u16 = 9u16;
210 pub const AF_DECnet: u16 = 12u16;
211 pub const AF_DLI: u16 = 13u16;
212 pub const AF_ECMA: u16 = 8u16;
213 pub const AF_FIREFOX: u16 = 19u16;
214 pub const AF_HYLINK: u16 = 15u16;
215 pub const AF_HYPERV: u16 = 34u16;
216 pub const AF_ICLFXBM: u16 = 31u16;
217 pub const AF_IMPLINK: u16 = 3u16;
218 pub const AF_IPX: u16 = 6u16;
219 pub const AF_IRDA: u16 = 26u16;
220 pub const AF_ISO: u16 = 7u16;
221 pub const AF_LAT: u16 = 14u16;
222 pub const AF_LINK: u16 = 33u16;
223 pub const AF_MAX: u16 = 29u16;
224 pub const AF_NETBIOS: u16 = 17u16;
225 pub const AF_NETDES: u16 = 28u16;
226 pub const AF_NS: u16 = 6u16;
227 pub const AF_OSI: u16 = 7u16;
228 pub const AF_PUP: u16 = 4u16;
229 pub const AF_SNA: u16 = 11u16;
230 pub const AF_TCNMESSAGE: u16 = 30u16;
231 pub const AF_TCNPROCESS: u16 = 29u16;
232 pub const AF_UNIX: u16 = 1u16;
233 pub const AF_UNKNOWN1: u16 = 20u16;
234 pub const AF_VOICEVIEW: u16 = 18u16;
235 pub const AI_ADDRCONFIG: u32 = 1024u32;
236 pub const AI_ALL: u32 = 256u32;
237 pub const AI_BYPASS_DNS_CACHE: u32 = 64u32;
238 pub const AI_CANONNAME: u32 = 2u32;
239 pub const AI_DISABLE_IDN_ENCODING: u32 = 524288u32;
240 pub const AI_DNS_ONLY: u32 = 16u32;
241 pub const AI_DNS_RESPONSE_HOSTFILE: u32 = 2u32;
242 pub const AI_DNS_RESPONSE_SECURE: u32 = 1u32;
243 pub const AI_DNS_SERVER_TYPE_DOH: u32 = 2u32;
244 pub const AI_DNS_SERVER_TYPE_UDP: u32 = 1u32;
245 pub const AI_DNS_SERVER_UDP_FALLBACK: u32 = 1u32;
246 pub const AI_EXCLUSIVE_CUSTOM_SERVERS: u32 = 2097152u32;
247 pub const AI_EXTENDED: u32 = 2147483648u32;
248 pub const AI_FILESERVER: u32 = 262144u32;
249 pub const AI_FORCE_CLEAR_TEXT: u32 = 32u32;
250 pub const AI_FQDN: u32 = 131072u32;
251 pub const AI_NON_AUTHORITATIVE: u32 = 16384u32;
252 pub const AI_NUMERICHOST: u32 = 4u32;
253 pub const AI_NUMERICSERV: u32 = 8u32;
254 pub const AI_PASSIVE: u32 = 1u32;
255 pub const AI_REQUIRE_SECURE: u32 = 536870912u32;
256 pub const AI_RESOLUTION_HANDLE: u32 = 1073741824u32;
257 pub const AI_RETURN_PREFERRED_NAMES: u32 = 65536u32;
258 pub const AI_RETURN_RESPONSE_FLAGS: u32 = 268435456u32;
259 pub const AI_RETURN_TTL: u32 = 128u32;
260 pub const AI_SECURE: u32 = 32768u32;
261 pub const AI_SECURE_WITH_FALLBACK: u32 = 1048576u32;
262 pub const AI_V4MAPPED: u32 = 2048u32;
263 pub const ASSOCIATE_NAMERES_CONTEXT: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1503890279, 54526, 18145, [186, 60, 135, 234, 116, 202, 48, 73]);
264 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
265 #[repr(C)]
266 pub struct ASSOCIATE_NAMERES_CONTEXT_INPUT {
267     pub TransportSettingId: TRANSPORT_SETTING_ID,
268     pub Handle: u64,
269 }
270 impl ASSOCIATE_NAMERES_CONTEXT_INPUT {}
271 impl ::std::default::Default for ASSOCIATE_NAMERES_CONTEXT_INPUT {
default() -> Self272     fn default() -> Self {
273         unsafe { ::std::mem::zeroed() }
274     }
275 }
276 impl ::std::fmt::Debug for ASSOCIATE_NAMERES_CONTEXT_INPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result277     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
278         fmt.debug_struct("ASSOCIATE_NAMERES_CONTEXT_INPUT").field("TransportSettingId", &self.TransportSettingId).field("Handle", &self.Handle).finish()
279     }
280 }
281 impl ::std::cmp::PartialEq for ASSOCIATE_NAMERES_CONTEXT_INPUT {
eq(&self, other: &Self) -> bool282     fn eq(&self, other: &Self) -> bool {
283         self.TransportSettingId == other.TransportSettingId && self.Handle == other.Handle
284     }
285 }
286 impl ::std::cmp::Eq for ASSOCIATE_NAMERES_CONTEXT_INPUT {}
287 unsafe impl ::windows::runtime::Abi for ASSOCIATE_NAMERES_CONTEXT_INPUT {
288     type Abi = Self;
289     type DefaultType = Self;
290 }
291 pub const ATMPROTO_AAL1: u32 = 1u32;
292 pub const ATMPROTO_AAL2: u32 = 2u32;
293 pub const ATMPROTO_AAL34: u32 = 3u32;
294 pub const ATMPROTO_AAL5: u32 = 5u32;
295 pub const ATMPROTO_AALUSER: u32 = 0u32;
296 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
297 #[repr(C)]
298 pub struct ATM_ADDRESS {
299     pub AddressType: u32,
300     pub NumofDigits: u32,
301     pub Addr: [u8; 20],
302 }
303 impl ATM_ADDRESS {}
304 impl ::std::default::Default for ATM_ADDRESS {
default() -> Self305     fn default() -> Self {
306         unsafe { ::std::mem::zeroed() }
307     }
308 }
309 impl ::std::fmt::Debug for ATM_ADDRESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result310     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
311         fmt.debug_struct("ATM_ADDRESS").field("AddressType", &self.AddressType).field("NumofDigits", &self.NumofDigits).field("Addr", &self.Addr).finish()
312     }
313 }
314 impl ::std::cmp::PartialEq for ATM_ADDRESS {
eq(&self, other: &Self) -> bool315     fn eq(&self, other: &Self) -> bool {
316         self.AddressType == other.AddressType && self.NumofDigits == other.NumofDigits && self.Addr == other.Addr
317     }
318 }
319 impl ::std::cmp::Eq for ATM_ADDRESS {}
320 unsafe impl ::windows::runtime::Abi for ATM_ADDRESS {
321     type Abi = Self;
322     type DefaultType = Self;
323 }
324 pub const ATM_ADDR_SIZE: u32 = 20u32;
325 pub const ATM_AESA: u32 = 2u32;
326 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
327 #[repr(C)]
328 pub struct ATM_BHLI {
329     pub HighLayerInfoType: u32,
330     pub HighLayerInfoLength: u32,
331     pub HighLayerInfo: [u8; 8],
332 }
333 impl ATM_BHLI {}
334 impl ::std::default::Default for ATM_BHLI {
default() -> Self335     fn default() -> Self {
336         unsafe { ::std::mem::zeroed() }
337     }
338 }
339 impl ::std::fmt::Debug for ATM_BHLI {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result340     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
341         fmt.debug_struct("ATM_BHLI").field("HighLayerInfoType", &self.HighLayerInfoType).field("HighLayerInfoLength", &self.HighLayerInfoLength).field("HighLayerInfo", &self.HighLayerInfo).finish()
342     }
343 }
344 impl ::std::cmp::PartialEq for ATM_BHLI {
eq(&self, other: &Self) -> bool345     fn eq(&self, other: &Self) -> bool {
346         self.HighLayerInfoType == other.HighLayerInfoType && self.HighLayerInfoLength == other.HighLayerInfoLength && self.HighLayerInfo == other.HighLayerInfo
347     }
348 }
349 impl ::std::cmp::Eq for ATM_BHLI {}
350 unsafe impl ::windows::runtime::Abi for ATM_BHLI {
351     type Abi = Self;
352     type DefaultType = Self;
353 }
354 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
355 #[repr(C)]
356 pub struct ATM_BLLI {
357     pub Layer2Protocol: u32,
358     pub Layer2UserSpecifiedProtocol: u32,
359     pub Layer3Protocol: u32,
360     pub Layer3UserSpecifiedProtocol: u32,
361     pub Layer3IPI: u32,
362     pub SnapID: [u8; 5],
363 }
364 impl ATM_BLLI {}
365 impl ::std::default::Default for ATM_BLLI {
default() -> Self366     fn default() -> Self {
367         unsafe { ::std::mem::zeroed() }
368     }
369 }
370 impl ::std::fmt::Debug for ATM_BLLI {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result371     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
372         fmt.debug_struct("ATM_BLLI")
373             .field("Layer2Protocol", &self.Layer2Protocol)
374             .field("Layer2UserSpecifiedProtocol", &self.Layer2UserSpecifiedProtocol)
375             .field("Layer3Protocol", &self.Layer3Protocol)
376             .field("Layer3UserSpecifiedProtocol", &self.Layer3UserSpecifiedProtocol)
377             .field("Layer3IPI", &self.Layer3IPI)
378             .field("SnapID", &self.SnapID)
379             .finish()
380     }
381 }
382 impl ::std::cmp::PartialEq for ATM_BLLI {
eq(&self, other: &Self) -> bool383     fn eq(&self, other: &Self) -> bool {
384         self.Layer2Protocol == other.Layer2Protocol && self.Layer2UserSpecifiedProtocol == other.Layer2UserSpecifiedProtocol && self.Layer3Protocol == other.Layer3Protocol && self.Layer3UserSpecifiedProtocol == other.Layer3UserSpecifiedProtocol && self.Layer3IPI == other.Layer3IPI && self.SnapID == other.SnapID
385     }
386 }
387 impl ::std::cmp::Eq for ATM_BLLI {}
388 unsafe impl ::windows::runtime::Abi for ATM_BLLI {
389     type Abi = Self;
390     type DefaultType = Self;
391 }
392 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
393 #[repr(C)]
394 pub struct ATM_BLLI_IE {
395     pub Layer2Protocol: u32,
396     pub Layer2Mode: u8,
397     pub Layer2WindowSize: u8,
398     pub Layer2UserSpecifiedProtocol: u32,
399     pub Layer3Protocol: u32,
400     pub Layer3Mode: u8,
401     pub Layer3DefaultPacketSize: u8,
402     pub Layer3PacketWindowSize: u8,
403     pub Layer3UserSpecifiedProtocol: u32,
404     pub Layer3IPI: u32,
405     pub SnapID: [u8; 5],
406 }
407 impl ATM_BLLI_IE {}
408 impl ::std::default::Default for ATM_BLLI_IE {
default() -> Self409     fn default() -> Self {
410         unsafe { ::std::mem::zeroed() }
411     }
412 }
413 impl ::std::fmt::Debug for ATM_BLLI_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result414     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
415         fmt.debug_struct("ATM_BLLI_IE")
416             .field("Layer2Protocol", &self.Layer2Protocol)
417             .field("Layer2Mode", &self.Layer2Mode)
418             .field("Layer2WindowSize", &self.Layer2WindowSize)
419             .field("Layer2UserSpecifiedProtocol", &self.Layer2UserSpecifiedProtocol)
420             .field("Layer3Protocol", &self.Layer3Protocol)
421             .field("Layer3Mode", &self.Layer3Mode)
422             .field("Layer3DefaultPacketSize", &self.Layer3DefaultPacketSize)
423             .field("Layer3PacketWindowSize", &self.Layer3PacketWindowSize)
424             .field("Layer3UserSpecifiedProtocol", &self.Layer3UserSpecifiedProtocol)
425             .field("Layer3IPI", &self.Layer3IPI)
426             .field("SnapID", &self.SnapID)
427             .finish()
428     }
429 }
430 impl ::std::cmp::PartialEq for ATM_BLLI_IE {
eq(&self, other: &Self) -> bool431     fn eq(&self, other: &Self) -> bool {
432         self.Layer2Protocol == other.Layer2Protocol
433             && self.Layer2Mode == other.Layer2Mode
434             && self.Layer2WindowSize == other.Layer2WindowSize
435             && self.Layer2UserSpecifiedProtocol == other.Layer2UserSpecifiedProtocol
436             && self.Layer3Protocol == other.Layer3Protocol
437             && self.Layer3Mode == other.Layer3Mode
438             && self.Layer3DefaultPacketSize == other.Layer3DefaultPacketSize
439             && self.Layer3PacketWindowSize == other.Layer3PacketWindowSize
440             && self.Layer3UserSpecifiedProtocol == other.Layer3UserSpecifiedProtocol
441             && self.Layer3IPI == other.Layer3IPI
442             && self.SnapID == other.SnapID
443     }
444 }
445 impl ::std::cmp::Eq for ATM_BLLI_IE {}
446 unsafe impl ::windows::runtime::Abi for ATM_BLLI_IE {
447     type Abi = Self;
448     type DefaultType = Self;
449 }
450 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
451 #[repr(C)]
452 pub struct ATM_BROADBAND_BEARER_CAPABILITY_IE {
453     pub BearerClass: u8,
454     pub TrafficType: u8,
455     pub TimingRequirements: u8,
456     pub ClippingSusceptability: u8,
457     pub UserPlaneConnectionConfig: u8,
458 }
459 impl ATM_BROADBAND_BEARER_CAPABILITY_IE {}
460 impl ::std::default::Default for ATM_BROADBAND_BEARER_CAPABILITY_IE {
default() -> Self461     fn default() -> Self {
462         unsafe { ::std::mem::zeroed() }
463     }
464 }
465 impl ::std::fmt::Debug for ATM_BROADBAND_BEARER_CAPABILITY_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result466     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
467         fmt.debug_struct("ATM_BROADBAND_BEARER_CAPABILITY_IE")
468             .field("BearerClass", &self.BearerClass)
469             .field("TrafficType", &self.TrafficType)
470             .field("TimingRequirements", &self.TimingRequirements)
471             .field("ClippingSusceptability", &self.ClippingSusceptability)
472             .field("UserPlaneConnectionConfig", &self.UserPlaneConnectionConfig)
473             .finish()
474     }
475 }
476 impl ::std::cmp::PartialEq for ATM_BROADBAND_BEARER_CAPABILITY_IE {
eq(&self, other: &Self) -> bool477     fn eq(&self, other: &Self) -> bool {
478         self.BearerClass == other.BearerClass && self.TrafficType == other.TrafficType && self.TimingRequirements == other.TimingRequirements && self.ClippingSusceptability == other.ClippingSusceptability && self.UserPlaneConnectionConfig == other.UserPlaneConnectionConfig
479     }
480 }
481 impl ::std::cmp::Eq for ATM_BROADBAND_BEARER_CAPABILITY_IE {}
482 unsafe impl ::windows::runtime::Abi for ATM_BROADBAND_BEARER_CAPABILITY_IE {
483     type Abi = Self;
484     type DefaultType = Self;
485 }
486 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
487 #[repr(C)]
488 pub struct ATM_CALLING_PARTY_NUMBER_IE {
489     pub ATM_Number: ATM_ADDRESS,
490     pub Presentation_Indication: u8,
491     pub Screening_Indicator: u8,
492 }
493 impl ATM_CALLING_PARTY_NUMBER_IE {}
494 impl ::std::default::Default for ATM_CALLING_PARTY_NUMBER_IE {
default() -> Self495     fn default() -> Self {
496         unsafe { ::std::mem::zeroed() }
497     }
498 }
499 impl ::std::fmt::Debug for ATM_CALLING_PARTY_NUMBER_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result500     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
501         fmt.debug_struct("ATM_CALLING_PARTY_NUMBER_IE").field("ATM_Number", &self.ATM_Number).field("Presentation_Indication", &self.Presentation_Indication).field("Screening_Indicator", &self.Screening_Indicator).finish()
502     }
503 }
504 impl ::std::cmp::PartialEq for ATM_CALLING_PARTY_NUMBER_IE {
eq(&self, other: &Self) -> bool505     fn eq(&self, other: &Self) -> bool {
506         self.ATM_Number == other.ATM_Number && self.Presentation_Indication == other.Presentation_Indication && self.Screening_Indicator == other.Screening_Indicator
507     }
508 }
509 impl ::std::cmp::Eq for ATM_CALLING_PARTY_NUMBER_IE {}
510 unsafe impl ::windows::runtime::Abi for ATM_CALLING_PARTY_NUMBER_IE {
511     type Abi = Self;
512     type DefaultType = Self;
513 }
514 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
515 #[repr(C)]
516 pub struct ATM_CAUSE_IE {
517     pub Location: u8,
518     pub Cause: u8,
519     pub DiagnosticsLength: u8,
520     pub Diagnostics: [u8; 4],
521 }
522 impl ATM_CAUSE_IE {}
523 impl ::std::default::Default for ATM_CAUSE_IE {
default() -> Self524     fn default() -> Self {
525         unsafe { ::std::mem::zeroed() }
526     }
527 }
528 impl ::std::fmt::Debug for ATM_CAUSE_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result529     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
530         fmt.debug_struct("ATM_CAUSE_IE").field("Location", &self.Location).field("Cause", &self.Cause).field("DiagnosticsLength", &self.DiagnosticsLength).field("Diagnostics", &self.Diagnostics).finish()
531     }
532 }
533 impl ::std::cmp::PartialEq for ATM_CAUSE_IE {
eq(&self, other: &Self) -> bool534     fn eq(&self, other: &Self) -> bool {
535         self.Location == other.Location && self.Cause == other.Cause && self.DiagnosticsLength == other.DiagnosticsLength && self.Diagnostics == other.Diagnostics
536     }
537 }
538 impl ::std::cmp::Eq for ATM_CAUSE_IE {}
539 unsafe impl ::windows::runtime::Abi for ATM_CAUSE_IE {
540     type Abi = Self;
541     type DefaultType = Self;
542 }
543 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
544 #[repr(C)]
545 pub struct ATM_CONNECTION_ID {
546     pub DeviceNumber: u32,
547     pub VPI: u32,
548     pub VCI: u32,
549 }
550 impl ATM_CONNECTION_ID {}
551 impl ::std::default::Default for ATM_CONNECTION_ID {
default() -> Self552     fn default() -> Self {
553         unsafe { ::std::mem::zeroed() }
554     }
555 }
556 impl ::std::fmt::Debug for ATM_CONNECTION_ID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result557     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
558         fmt.debug_struct("ATM_CONNECTION_ID").field("DeviceNumber", &self.DeviceNumber).field("VPI", &self.VPI).field("VCI", &self.VCI).finish()
559     }
560 }
561 impl ::std::cmp::PartialEq for ATM_CONNECTION_ID {
eq(&self, other: &Self) -> bool562     fn eq(&self, other: &Self) -> bool {
563         self.DeviceNumber == other.DeviceNumber && self.VPI == other.VPI && self.VCI == other.VCI
564     }
565 }
566 impl ::std::cmp::Eq for ATM_CONNECTION_ID {}
567 unsafe impl ::windows::runtime::Abi for ATM_CONNECTION_ID {
568     type Abi = Self;
569     type DefaultType = Self;
570 }
571 pub const ATM_E164: u32 = 1u32;
572 pub const ATM_NSAP: u32 = 2u32;
573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
574 #[repr(C, packed(4))]
575 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
576 pub struct ATM_PVC_PARAMS {
577     pub PvcConnectionId: ATM_CONNECTION_ID,
578     pub PvcQos: super::super::NetworkManagement::QoS::QOS,
579 }
580 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
581 impl ATM_PVC_PARAMS {}
582 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
583 impl ::std::default::Default for ATM_PVC_PARAMS {
default() -> Self584     fn default() -> Self {
585         unsafe { ::std::mem::zeroed() }
586     }
587 }
588 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
589 impl ::std::cmp::PartialEq for ATM_PVC_PARAMS {
eq(&self, _other: &Self) -> bool590     fn eq(&self, _other: &Self) -> bool {
591         unimplemented!()
592     }
593 }
594 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
595 impl ::std::cmp::Eq for ATM_PVC_PARAMS {}
596 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
597 unsafe impl ::windows::runtime::Abi for ATM_PVC_PARAMS {
598     type Abi = Self;
599     type DefaultType = Self;
600 }
601 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
602 #[repr(C)]
603 pub struct ATM_QOS_CLASS_IE {
604     pub QOSClassForward: u8,
605     pub QOSClassBackward: u8,
606 }
607 impl ATM_QOS_CLASS_IE {}
608 impl ::std::default::Default for ATM_QOS_CLASS_IE {
default() -> Self609     fn default() -> Self {
610         unsafe { ::std::mem::zeroed() }
611     }
612 }
613 impl ::std::fmt::Debug for ATM_QOS_CLASS_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result614     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
615         fmt.debug_struct("ATM_QOS_CLASS_IE").field("QOSClassForward", &self.QOSClassForward).field("QOSClassBackward", &self.QOSClassBackward).finish()
616     }
617 }
618 impl ::std::cmp::PartialEq for ATM_QOS_CLASS_IE {
eq(&self, other: &Self) -> bool619     fn eq(&self, other: &Self) -> bool {
620         self.QOSClassForward == other.QOSClassForward && self.QOSClassBackward == other.QOSClassBackward
621     }
622 }
623 impl ::std::cmp::Eq for ATM_QOS_CLASS_IE {}
624 unsafe impl ::windows::runtime::Abi for ATM_QOS_CLASS_IE {
625     type Abi = Self;
626     type DefaultType = Self;
627 }
628 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
629 #[repr(C)]
630 #[cfg(feature = "Win32_Foundation")]
631 pub struct ATM_TD {
632     pub PeakCellRate_CLP0: u32,
633     pub PeakCellRate_CLP01: u32,
634     pub SustainableCellRate_CLP0: u32,
635     pub SustainableCellRate_CLP01: u32,
636     pub MaxBurstSize_CLP0: u32,
637     pub MaxBurstSize_CLP01: u32,
638     pub Tagging: super::super::Foundation::BOOL,
639 }
640 #[cfg(feature = "Win32_Foundation")]
641 impl ATM_TD {}
642 #[cfg(feature = "Win32_Foundation")]
643 impl ::std::default::Default for ATM_TD {
default() -> Self644     fn default() -> Self {
645         unsafe { ::std::mem::zeroed() }
646     }
647 }
648 #[cfg(feature = "Win32_Foundation")]
649 impl ::std::fmt::Debug for ATM_TD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result650     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
651         fmt.debug_struct("ATM_TD")
652             .field("PeakCellRate_CLP0", &self.PeakCellRate_CLP0)
653             .field("PeakCellRate_CLP01", &self.PeakCellRate_CLP01)
654             .field("SustainableCellRate_CLP0", &self.SustainableCellRate_CLP0)
655             .field("SustainableCellRate_CLP01", &self.SustainableCellRate_CLP01)
656             .field("MaxBurstSize_CLP0", &self.MaxBurstSize_CLP0)
657             .field("MaxBurstSize_CLP01", &self.MaxBurstSize_CLP01)
658             .field("Tagging", &self.Tagging)
659             .finish()
660     }
661 }
662 #[cfg(feature = "Win32_Foundation")]
663 impl ::std::cmp::PartialEq for ATM_TD {
eq(&self, other: &Self) -> bool664     fn eq(&self, other: &Self) -> bool {
665         self.PeakCellRate_CLP0 == other.PeakCellRate_CLP0 && self.PeakCellRate_CLP01 == other.PeakCellRate_CLP01 && self.SustainableCellRate_CLP0 == other.SustainableCellRate_CLP0 && self.SustainableCellRate_CLP01 == other.SustainableCellRate_CLP01 && self.MaxBurstSize_CLP0 == other.MaxBurstSize_CLP0 && self.MaxBurstSize_CLP01 == other.MaxBurstSize_CLP01 && self.Tagging == other.Tagging
666     }
667 }
668 #[cfg(feature = "Win32_Foundation")]
669 impl ::std::cmp::Eq for ATM_TD {}
670 #[cfg(feature = "Win32_Foundation")]
671 unsafe impl ::windows::runtime::Abi for ATM_TD {
672     type Abi = Self;
673     type DefaultType = Self;
674 }
675 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
676 #[repr(C)]
677 #[cfg(feature = "Win32_Foundation")]
678 pub struct ATM_TRAFFIC_DESCRIPTOR_IE {
679     pub Forward: ATM_TD,
680     pub Backward: ATM_TD,
681     pub BestEffort: super::super::Foundation::BOOL,
682 }
683 #[cfg(feature = "Win32_Foundation")]
684 impl ATM_TRAFFIC_DESCRIPTOR_IE {}
685 #[cfg(feature = "Win32_Foundation")]
686 impl ::std::default::Default for ATM_TRAFFIC_DESCRIPTOR_IE {
default() -> Self687     fn default() -> Self {
688         unsafe { ::std::mem::zeroed() }
689     }
690 }
691 #[cfg(feature = "Win32_Foundation")]
692 impl ::std::fmt::Debug for ATM_TRAFFIC_DESCRIPTOR_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result693     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
694         fmt.debug_struct("ATM_TRAFFIC_DESCRIPTOR_IE").field("Forward", &self.Forward).field("Backward", &self.Backward).field("BestEffort", &self.BestEffort).finish()
695     }
696 }
697 #[cfg(feature = "Win32_Foundation")]
698 impl ::std::cmp::PartialEq for ATM_TRAFFIC_DESCRIPTOR_IE {
eq(&self, other: &Self) -> bool699     fn eq(&self, other: &Self) -> bool {
700         self.Forward == other.Forward && self.Backward == other.Backward && self.BestEffort == other.BestEffort
701     }
702 }
703 #[cfg(feature = "Win32_Foundation")]
704 impl ::std::cmp::Eq for ATM_TRAFFIC_DESCRIPTOR_IE {}
705 #[cfg(feature = "Win32_Foundation")]
706 unsafe impl ::windows::runtime::Abi for ATM_TRAFFIC_DESCRIPTOR_IE {
707     type Abi = Self;
708     type DefaultType = Self;
709 }
710 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
711 #[repr(C)]
712 pub struct ATM_TRANSIT_NETWORK_SELECTION_IE {
713     pub TypeOfNetworkId: u8,
714     pub NetworkIdPlan: u8,
715     pub NetworkIdLength: u8,
716     pub NetworkId: [u8; 1],
717 }
718 impl ATM_TRANSIT_NETWORK_SELECTION_IE {}
719 impl ::std::default::Default for ATM_TRANSIT_NETWORK_SELECTION_IE {
default() -> Self720     fn default() -> Self {
721         unsafe { ::std::mem::zeroed() }
722     }
723 }
724 impl ::std::fmt::Debug for ATM_TRANSIT_NETWORK_SELECTION_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result725     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
726         fmt.debug_struct("ATM_TRANSIT_NETWORK_SELECTION_IE").field("TypeOfNetworkId", &self.TypeOfNetworkId).field("NetworkIdPlan", &self.NetworkIdPlan).field("NetworkIdLength", &self.NetworkIdLength).field("NetworkId", &self.NetworkId).finish()
727     }
728 }
729 impl ::std::cmp::PartialEq for ATM_TRANSIT_NETWORK_SELECTION_IE {
eq(&self, other: &Self) -> bool730     fn eq(&self, other: &Self) -> bool {
731         self.TypeOfNetworkId == other.TypeOfNetworkId && self.NetworkIdPlan == other.NetworkIdPlan && self.NetworkIdLength == other.NetworkIdLength && self.NetworkId == other.NetworkId
732     }
733 }
734 impl ::std::cmp::Eq for ATM_TRANSIT_NETWORK_SELECTION_IE {}
735 unsafe impl ::windows::runtime::Abi for ATM_TRANSIT_NETWORK_SELECTION_IE {
736     type Abi = Self;
737     type DefaultType = Self;
738 }
739 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
740 #[inline]
AcceptEx<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, SOCKET>>(slistensocket: Param0, sacceptsocket: Param1, lpoutputbuffer: *mut ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, lpdwbytesreceived: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL741 pub unsafe fn AcceptEx<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, SOCKET>>(slistensocket: Param0, sacceptsocket: Param1, lpoutputbuffer: *mut ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, lpdwbytesreceived: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL {
742     #[cfg(windows)]
743     {
744         #[link(name = "windows")]
745         extern "system" {
746             fn AcceptEx(slistensocket: SOCKET, sacceptsocket: SOCKET, lpoutputbuffer: *mut ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, lpdwbytesreceived: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
747         }
748         ::std::mem::transmute(AcceptEx(
749             slistensocket.into_param().abi(),
750             sacceptsocket.into_param().abi(),
751             ::std::mem::transmute(lpoutputbuffer),
752             ::std::mem::transmute(dwreceivedatalength),
753             ::std::mem::transmute(dwlocaladdresslength),
754             ::std::mem::transmute(dwremoteaddresslength),
755             ::std::mem::transmute(lpdwbytesreceived),
756             ::std::mem::transmute(lpoverlapped),
757         ))
758     }
759     #[cfg(not(windows))]
760     unimplemented!("Unsupported target OS");
761 }
762 pub const BASE_PROTOCOL: u32 = 1u32;
763 pub const BCOB_A: u32 = 1u32;
764 pub const BCOB_C: u32 = 3u32;
765 pub const BCOB_X: u32 = 16u32;
766 pub const BHLI_HighLayerProfile: u32 = 2u32;
767 pub const BHLI_ISO: u32 = 0u32;
768 pub const BHLI_UserSpecific: u32 = 1u32;
769 pub const BHLI_VendorSpecificAppId: u32 = 3u32;
770 pub const BIGENDIAN: u32 = 0u32;
771 pub const BITS_PER_BYTE: u32 = 8u32;
772 pub const BLLI_L2_ELAPB: u32 = 8u32;
773 pub const BLLI_L2_HDLC_ABM: u32 = 11u32;
774 pub const BLLI_L2_HDLC_ARM: u32 = 9u32;
775 pub const BLLI_L2_HDLC_NRM: u32 = 10u32;
776 pub const BLLI_L2_ISO_1745: u32 = 1u32;
777 pub const BLLI_L2_ISO_7776: u32 = 17u32;
778 pub const BLLI_L2_LLC: u32 = 12u32;
779 pub const BLLI_L2_MODE_EXT: u32 = 128u32;
780 pub const BLLI_L2_MODE_NORMAL: u32 = 64u32;
781 pub const BLLI_L2_Q921: u32 = 2u32;
782 pub const BLLI_L2_Q922: u32 = 14u32;
783 pub const BLLI_L2_USER_SPECIFIED: u32 = 16u32;
784 pub const BLLI_L2_X25L: u32 = 6u32;
785 pub const BLLI_L2_X25M: u32 = 7u32;
786 pub const BLLI_L2_X75: u32 = 13u32;
787 pub const BLLI_L3_IPI_IP: u32 = 204u32;
788 pub const BLLI_L3_IPI_SNAP: u32 = 128u32;
789 pub const BLLI_L3_ISO_8208: u32 = 7u32;
790 pub const BLLI_L3_ISO_TR9577: u32 = 11u32;
791 pub const BLLI_L3_MODE_EXT: u32 = 128u32;
792 pub const BLLI_L3_MODE_NORMAL: u32 = 64u32;
793 pub const BLLI_L3_PACKET_1024: u32 = 10u32;
794 pub const BLLI_L3_PACKET_128: u32 = 7u32;
795 pub const BLLI_L3_PACKET_16: u32 = 4u32;
796 pub const BLLI_L3_PACKET_2048: u32 = 11u32;
797 pub const BLLI_L3_PACKET_256: u32 = 8u32;
798 pub const BLLI_L3_PACKET_32: u32 = 5u32;
799 pub const BLLI_L3_PACKET_4096: u32 = 12u32;
800 pub const BLLI_L3_PACKET_512: u32 = 9u32;
801 pub const BLLI_L3_PACKET_64: u32 = 6u32;
802 pub const BLLI_L3_SIO_8473: u32 = 9u32;
803 pub const BLLI_L3_T70: u32 = 10u32;
804 pub const BLLI_L3_USER_SPECIFIED: u32 = 16u32;
805 pub const BLLI_L3_X223: u32 = 8u32;
806 pub const BLLI_L3_X25: u32 = 6u32;
807 pub const CAUSE_AAL_PARAMETERS_UNSUPPORTED: u32 = 93u32;
808 pub const CAUSE_ACCESS_INFORMAION_DISCARDED: u32 = 43u32;
809 pub const CAUSE_BEARER_CAPABILITY_UNAUTHORIZED: u32 = 57u32;
810 pub const CAUSE_BEARER_CAPABILITY_UNAVAILABLE: u32 = 58u32;
811 pub const CAUSE_BEARER_CAPABILITY_UNIMPLEMENTED: u32 = 65u32;
812 pub const CAUSE_CALL_REJECTED: u32 = 21u32;
813 pub const CAUSE_CHANNEL_NONEXISTENT: u32 = 82u32;
814 pub const CAUSE_COND_PERMANENT: u32 = 1u32;
815 pub const CAUSE_COND_TRANSIENT: u32 = 2u32;
816 pub const CAUSE_COND_UNKNOWN: u32 = 0u32;
817 pub const CAUSE_DESTINATION_OUT_OF_ORDER: u32 = 27u32;
818 pub const CAUSE_INCOMPATIBLE_DESTINATION: u32 = 88u32;
819 pub const CAUSE_INCORRECT_MESSAGE_LENGTH: u32 = 104u32;
820 pub const CAUSE_INVALID_CALL_REFERENCE: u32 = 81u32;
821 pub const CAUSE_INVALID_ENDPOINT_REFERENCE: u32 = 89u32;
822 pub const CAUSE_INVALID_IE_CONTENTS: u32 = 100u32;
823 pub const CAUSE_INVALID_NUMBER_FORMAT: u32 = 28u32;
824 pub const CAUSE_INVALID_STATE_FOR_MESSAGE: u32 = 101u32;
825 pub const CAUSE_INVALID_TRANSIT_NETWORK_SELECTION: u32 = 91u32;
826 pub const CAUSE_LOC_BEYOND_INTERWORKING: u32 = 10u32;
827 pub const CAUSE_LOC_INTERNATIONAL_NETWORK: u32 = 7u32;
828 pub const CAUSE_LOC_PRIVATE_LOCAL: u32 = 1u32;
829 pub const CAUSE_LOC_PRIVATE_REMOTE: u32 = 5u32;
830 pub const CAUSE_LOC_PUBLIC_LOCAL: u32 = 2u32;
831 pub const CAUSE_LOC_PUBLIC_REMOTE: u32 = 4u32;
832 pub const CAUSE_LOC_TRANSIT_NETWORK: u32 = 3u32;
833 pub const CAUSE_LOC_USER: u32 = 0u32;
834 pub const CAUSE_MANDATORY_IE_MISSING: u32 = 96u32;
835 pub const CAUSE_NA_ABNORMAL: u32 = 4u32;
836 pub const CAUSE_NA_NORMAL: u32 = 0u32;
837 pub const CAUSE_NETWORK_OUT_OF_ORDER: u32 = 38u32;
838 pub const CAUSE_NORMAL_CALL_CLEARING: u32 = 16u32;
839 pub const CAUSE_NORMAL_UNSPECIFIED: u32 = 31u32;
840 pub const CAUSE_NO_ROUTE_TO_DESTINATION: u32 = 3u32;
841 pub const CAUSE_NO_ROUTE_TO_TRANSIT_NETWORK: u32 = 2u32;
842 pub const CAUSE_NO_USER_RESPONDING: u32 = 18u32;
843 pub const CAUSE_NO_VPI_VCI_AVAILABLE: u32 = 45u32;
844 pub const CAUSE_NUMBER_CHANGED: u32 = 22u32;
845 pub const CAUSE_OPTION_UNAVAILABLE: u32 = 63u32;
846 pub const CAUSE_PROTOCOL_ERROR: u32 = 111u32;
847 pub const CAUSE_PU_PROVIDER: u32 = 0u32;
848 pub const CAUSE_PU_USER: u32 = 8u32;
849 pub const CAUSE_QOS_UNAVAILABLE: u32 = 49u32;
850 pub const CAUSE_REASON_IE_INSUFFICIENT: u32 = 8u32;
851 pub const CAUSE_REASON_IE_MISSING: u32 = 4u32;
852 pub const CAUSE_REASON_USER: u32 = 0u32;
853 pub const CAUSE_RECOVERY_ON_TIMEOUT: u32 = 102u32;
854 pub const CAUSE_RESOURCE_UNAVAILABLE: u32 = 47u32;
855 pub const CAUSE_STATUS_ENQUIRY_RESPONSE: u32 = 30u32;
856 pub const CAUSE_TEMPORARY_FAILURE: u32 = 41u32;
857 pub const CAUSE_TOO_MANY_PENDING_ADD_PARTY: u32 = 92u32;
858 pub const CAUSE_UNALLOCATED_NUMBER: u32 = 1u32;
859 pub const CAUSE_UNIMPLEMENTED_IE: u32 = 99u32;
860 pub const CAUSE_UNIMPLEMENTED_MESSAGE_TYPE: u32 = 97u32;
861 pub const CAUSE_UNSUPPORTED_TRAFFIC_PARAMETERS: u32 = 73u32;
862 pub const CAUSE_USER_BUSY: u32 = 17u32;
863 pub const CAUSE_USER_CELL_RATE_UNAVAILABLE: u32 = 51u32;
864 pub const CAUSE_USER_REJECTS_CLIR: u32 = 23u32;
865 pub const CAUSE_VPI_VCI_UNACCEPTABLE: u32 = 10u32;
866 pub const CAUSE_VPI_VCI_UNAVAILABLE: u32 = 35u32;
867 pub const CF_ACCEPT: u32 = 0u32;
868 pub const CF_DEFER: u32 = 2u32;
869 pub const CF_REJECT: u32 = 1u32;
870 pub const CLIP_NOT: u32 = 0u32;
871 pub const CLIP_SUS: u32 = 32u32;
872 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
873 #[repr(transparent)]
874 pub struct CONTROL_CHANNEL_TRIGGER_STATUS(pub i32);
875 pub const CONTROL_CHANNEL_TRIGGER_STATUS_INVALID: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(0i32);
876 pub const CONTROL_CHANNEL_TRIGGER_STATUS_SOFTWARE_SLOT_ALLOCATED: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(1i32);
877 pub const CONTROL_CHANNEL_TRIGGER_STATUS_HARDWARE_SLOT_ALLOCATED: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(2i32);
878 pub const CONTROL_CHANNEL_TRIGGER_STATUS_POLICY_ERROR: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(3i32);
879 pub const CONTROL_CHANNEL_TRIGGER_STATUS_SYSTEM_ERROR: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(4i32);
880 pub const CONTROL_CHANNEL_TRIGGER_STATUS_TRANSPORT_DISCONNECTED: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(5i32);
881 pub const CONTROL_CHANNEL_TRIGGER_STATUS_SERVICE_UNAVAILABLE: CONTROL_CHANNEL_TRIGGER_STATUS = CONTROL_CHANNEL_TRIGGER_STATUS(6i32);
882 impl ::std::convert::From<i32> for CONTROL_CHANNEL_TRIGGER_STATUS {
from(value: i32) -> Self883     fn from(value: i32) -> Self {
884         Self(value)
885     }
886 }
887 unsafe impl ::windows::runtime::Abi for CONTROL_CHANNEL_TRIGGER_STATUS {
888     type Abi = Self;
889     type DefaultType = Self;
890 }
891 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
892 #[repr(C)]
893 #[cfg(feature = "Win32_Foundation")]
894 pub struct CSADDR_INFO {
895     pub LocalAddr: SOCKET_ADDRESS,
896     pub RemoteAddr: SOCKET_ADDRESS,
897     pub iSocketType: i32,
898     pub iProtocol: i32,
899 }
900 #[cfg(feature = "Win32_Foundation")]
901 impl CSADDR_INFO {}
902 #[cfg(feature = "Win32_Foundation")]
903 impl ::std::default::Default for CSADDR_INFO {
default() -> Self904     fn default() -> Self {
905         unsafe { ::std::mem::zeroed() }
906     }
907 }
908 #[cfg(feature = "Win32_Foundation")]
909 impl ::std::fmt::Debug for CSADDR_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result910     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
911         fmt.debug_struct("CSADDR_INFO").field("LocalAddr", &self.LocalAddr).field("RemoteAddr", &self.RemoteAddr).field("iSocketType", &self.iSocketType).field("iProtocol", &self.iProtocol).finish()
912     }
913 }
914 #[cfg(feature = "Win32_Foundation")]
915 impl ::std::cmp::PartialEq for CSADDR_INFO {
eq(&self, other: &Self) -> bool916     fn eq(&self, other: &Self) -> bool {
917         self.LocalAddr == other.LocalAddr && self.RemoteAddr == other.RemoteAddr && self.iSocketType == other.iSocketType && self.iProtocol == other.iProtocol
918     }
919 }
920 #[cfg(feature = "Win32_Foundation")]
921 impl ::std::cmp::Eq for CSADDR_INFO {}
922 #[cfg(feature = "Win32_Foundation")]
923 unsafe impl ::windows::runtime::Abi for CSADDR_INFO {
924     type Abi = Self;
925     type DefaultType = Self;
926 }
927 pub const DE_REUSE_SOCKET: u32 = 2u32;
928 #[inline]
EnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32929 pub unsafe fn EnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32 {
930     #[cfg(windows)]
931     {
932         #[link(name = "windows")]
933         extern "system" {
934             fn EnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32;
935         }
936         ::std::mem::transmute(EnumProtocolsA(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength)))
937     }
938     #[cfg(not(windows))]
939     unimplemented!("Unsupported target OS");
940 }
941 #[inline]
EnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32942 pub unsafe fn EnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32 {
943     #[cfg(windows)]
944     {
945         #[link(name = "windows")]
946         extern "system" {
947             fn EnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32) -> i32;
948         }
949         ::std::mem::transmute(EnumProtocolsW(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength)))
950     }
951     #[cfg(not(windows))]
952     unimplemented!("Unsupported target OS");
953 }
954 pub const FD_ACCEPT: u32 = 8u32;
955 pub const FD_ACCEPT_BIT: u32 = 3u32;
956 pub const FD_ADDRESS_LIST_CHANGE_BIT: u32 = 9u32;
957 pub const FD_CLOSE: u32 = 32u32;
958 pub const FD_CLOSE_BIT: u32 = 5u32;
959 pub const FD_CONNECT: u32 = 16u32;
960 pub const FD_CONNECT_BIT: u32 = 4u32;
961 pub const FD_GROUP_QOS_BIT: u32 = 7u32;
962 pub const FD_MAX_EVENTS: u32 = 10u32;
963 pub const FD_OOB: u32 = 4u32;
964 pub const FD_OOB_BIT: u32 = 2u32;
965 pub const FD_QOS_BIT: u32 = 6u32;
966 pub const FD_READ: u32 = 1u32;
967 pub const FD_READ_BIT: u32 = 0u32;
968 pub const FD_ROUTING_INTERFACE_CHANGE_BIT: u32 = 8u32;
969 pub const FD_SETSIZE: u32 = 64u32;
970 pub const FD_WRITE: u32 = 2u32;
971 pub const FD_WRITE_BIT: u32 = 1u32;
972 pub const FROM_PROTOCOL_INFO: i32 = -1i32;
973 #[cfg(feature = "Win32_Foundation")]
974 #[inline]
FreeAddrInfoEx(paddrinfoex: *const addrinfoexA)975 pub unsafe fn FreeAddrInfoEx(paddrinfoex: *const addrinfoexA) {
976     #[cfg(windows)]
977     {
978         #[link(name = "windows")]
979         extern "system" {
980             fn FreeAddrInfoEx(paddrinfoex: *const addrinfoexA);
981         }
982         ::std::mem::transmute(FreeAddrInfoEx(::std::mem::transmute(paddrinfoex)))
983     }
984     #[cfg(not(windows))]
985     unimplemented!("Unsupported target OS");
986 }
987 #[cfg(feature = "Win32_Foundation")]
988 #[inline]
FreeAddrInfoExW(paddrinfoex: *const addrinfoexW)989 pub unsafe fn FreeAddrInfoExW(paddrinfoex: *const addrinfoexW) {
990     #[cfg(windows)]
991     {
992         #[link(name = "windows")]
993         extern "system" {
994             fn FreeAddrInfoExW(paddrinfoex: *const addrinfoexW);
995         }
996         ::std::mem::transmute(FreeAddrInfoExW(::std::mem::transmute(paddrinfoex)))
997     }
998     #[cfg(not(windows))]
999     unimplemented!("Unsupported target OS");
1000 }
1001 #[cfg(feature = "Win32_Foundation")]
1002 #[inline]
FreeAddrInfoW(paddrinfo: *const addrinfoW)1003 pub unsafe fn FreeAddrInfoW(paddrinfo: *const addrinfoW) {
1004     #[cfg(windows)]
1005     {
1006         #[link(name = "windows")]
1007         extern "system" {
1008             fn FreeAddrInfoW(paddrinfo: *const addrinfoW);
1009         }
1010         ::std::mem::transmute(FreeAddrInfoW(::std::mem::transmute(paddrinfo)))
1011     }
1012     #[cfg(not(windows))]
1013     unimplemented!("Unsupported target OS");
1014 }
1015 pub const GAI_STRERROR_BUFFER_SIZE: u32 = 1024u32;
1016 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1017 #[repr(C)]
1018 #[cfg(feature = "Win32_Foundation")]
1019 pub struct GROUP_FILTER {
1020     pub gf_interface: u32,
1021     pub gf_group: SOCKADDR_STORAGE,
1022     pub gf_fmode: MULTICAST_MODE_TYPE,
1023     pub gf_numsrc: u32,
1024     pub gf_slist: [SOCKADDR_STORAGE; 1],
1025 }
1026 #[cfg(feature = "Win32_Foundation")]
1027 impl GROUP_FILTER {}
1028 #[cfg(feature = "Win32_Foundation")]
1029 impl ::std::default::Default for GROUP_FILTER {
default() -> Self1030     fn default() -> Self {
1031         unsafe { ::std::mem::zeroed() }
1032     }
1033 }
1034 #[cfg(feature = "Win32_Foundation")]
1035 impl ::std::fmt::Debug for GROUP_FILTER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1036     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1037         fmt.debug_struct("GROUP_FILTER").field("gf_interface", &self.gf_interface).field("gf_group", &self.gf_group).field("gf_fmode", &self.gf_fmode).field("gf_numsrc", &self.gf_numsrc).field("gf_slist", &self.gf_slist).finish()
1038     }
1039 }
1040 #[cfg(feature = "Win32_Foundation")]
1041 impl ::std::cmp::PartialEq for GROUP_FILTER {
eq(&self, other: &Self) -> bool1042     fn eq(&self, other: &Self) -> bool {
1043         self.gf_interface == other.gf_interface && self.gf_group == other.gf_group && self.gf_fmode == other.gf_fmode && self.gf_numsrc == other.gf_numsrc && self.gf_slist == other.gf_slist
1044     }
1045 }
1046 #[cfg(feature = "Win32_Foundation")]
1047 impl ::std::cmp::Eq for GROUP_FILTER {}
1048 #[cfg(feature = "Win32_Foundation")]
1049 unsafe impl ::windows::runtime::Abi for GROUP_FILTER {
1050     type Abi = Self;
1051     type DefaultType = Self;
1052 }
1053 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1054 #[repr(C)]
1055 #[cfg(feature = "Win32_Foundation")]
1056 pub struct GROUP_REQ {
1057     pub gr_interface: u32,
1058     pub gr_group: SOCKADDR_STORAGE,
1059 }
1060 #[cfg(feature = "Win32_Foundation")]
1061 impl GROUP_REQ {}
1062 #[cfg(feature = "Win32_Foundation")]
1063 impl ::std::default::Default for GROUP_REQ {
default() -> Self1064     fn default() -> Self {
1065         unsafe { ::std::mem::zeroed() }
1066     }
1067 }
1068 #[cfg(feature = "Win32_Foundation")]
1069 impl ::std::fmt::Debug for GROUP_REQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1070     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1071         fmt.debug_struct("GROUP_REQ").field("gr_interface", &self.gr_interface).field("gr_group", &self.gr_group).finish()
1072     }
1073 }
1074 #[cfg(feature = "Win32_Foundation")]
1075 impl ::std::cmp::PartialEq for GROUP_REQ {
eq(&self, other: &Self) -> bool1076     fn eq(&self, other: &Self) -> bool {
1077         self.gr_interface == other.gr_interface && self.gr_group == other.gr_group
1078     }
1079 }
1080 #[cfg(feature = "Win32_Foundation")]
1081 impl ::std::cmp::Eq for GROUP_REQ {}
1082 #[cfg(feature = "Win32_Foundation")]
1083 unsafe impl ::windows::runtime::Abi for GROUP_REQ {
1084     type Abi = Self;
1085     type DefaultType = Self;
1086 }
1087 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1088 #[repr(C)]
1089 #[cfg(feature = "Win32_Foundation")]
1090 pub struct GROUP_SOURCE_REQ {
1091     pub gsr_interface: u32,
1092     pub gsr_group: SOCKADDR_STORAGE,
1093     pub gsr_source: SOCKADDR_STORAGE,
1094 }
1095 #[cfg(feature = "Win32_Foundation")]
1096 impl GROUP_SOURCE_REQ {}
1097 #[cfg(feature = "Win32_Foundation")]
1098 impl ::std::default::Default for GROUP_SOURCE_REQ {
default() -> Self1099     fn default() -> Self {
1100         unsafe { ::std::mem::zeroed() }
1101     }
1102 }
1103 #[cfg(feature = "Win32_Foundation")]
1104 impl ::std::fmt::Debug for GROUP_SOURCE_REQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1105     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1106         fmt.debug_struct("GROUP_SOURCE_REQ").field("gsr_interface", &self.gsr_interface).field("gsr_group", &self.gsr_group).field("gsr_source", &self.gsr_source).finish()
1107     }
1108 }
1109 #[cfg(feature = "Win32_Foundation")]
1110 impl ::std::cmp::PartialEq for GROUP_SOURCE_REQ {
eq(&self, other: &Self) -> bool1111     fn eq(&self, other: &Self) -> bool {
1112         self.gsr_interface == other.gsr_interface && self.gsr_group == other.gsr_group && self.gsr_source == other.gsr_source
1113     }
1114 }
1115 #[cfg(feature = "Win32_Foundation")]
1116 impl ::std::cmp::Eq for GROUP_SOURCE_REQ {}
1117 #[cfg(feature = "Win32_Foundation")]
1118 unsafe impl ::windows::runtime::Abi for GROUP_SOURCE_REQ {
1119     type Abi = Self;
1120     type DefaultType = Self;
1121 }
1122 #[cfg(feature = "Win32_Foundation")]
1123 #[inline]
GetAcceptExSockaddrs(lpoutputbuffer: *const ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, localsockaddr: *mut *mut SOCKADDR, localsockaddrlength: *mut i32, remotesockaddr: *mut *mut SOCKADDR, remotesockaddrlength: *mut i32)1124 pub unsafe fn GetAcceptExSockaddrs(lpoutputbuffer: *const ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, localsockaddr: *mut *mut SOCKADDR, localsockaddrlength: *mut i32, remotesockaddr: *mut *mut SOCKADDR, remotesockaddrlength: *mut i32) {
1125     #[cfg(windows)]
1126     {
1127         #[link(name = "windows")]
1128         extern "system" {
1129             fn GetAcceptExSockaddrs(lpoutputbuffer: *const ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, localsockaddr: *mut *mut SOCKADDR, localsockaddrlength: *mut i32, remotesockaddr: *mut *mut SOCKADDR, remotesockaddrlength: *mut i32);
1130         }
1131         ::std::mem::transmute(GetAcceptExSockaddrs(
1132             ::std::mem::transmute(lpoutputbuffer),
1133             ::std::mem::transmute(dwreceivedatalength),
1134             ::std::mem::transmute(dwlocaladdresslength),
1135             ::std::mem::transmute(dwremoteaddresslength),
1136             ::std::mem::transmute(localsockaddr),
1137             ::std::mem::transmute(localsockaddrlength),
1138             ::std::mem::transmute(remotesockaddr),
1139             ::std::mem::transmute(remotesockaddrlength),
1140         ))
1141     }
1142     #[cfg(not(windows))]
1143     unimplemented!("Unsupported target OS");
1144 }
1145 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
1146 #[inline]
GetAddrInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( pname: Param0, pservicename: Param1, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, hints: *const addrinfoexA, ppresult: *mut *mut addrinfoexA, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>, lpnamehandle: *mut super::super::Foundation::HANDLE, ) -> i321147 pub unsafe fn GetAddrInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
1148     pname: Param0,
1149     pservicename: Param1,
1150     dwnamespace: u32,
1151     lpnspid: *const ::windows::runtime::GUID,
1152     hints: *const addrinfoexA,
1153     ppresult: *mut *mut addrinfoexA,
1154     timeout: *const timeval,
1155     lpoverlapped: *const super::super::System::IO::OVERLAPPED,
1156     lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>,
1157     lpnamehandle: *mut super::super::Foundation::HANDLE,
1158 ) -> i32 {
1159     #[cfg(windows)]
1160     {
1161         #[link(name = "windows")]
1162         extern "system" {
1163             fn GetAddrInfoExA(pname: super::super::Foundation::PSTR, pservicename: super::super::Foundation::PSTR, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, hints: *const addrinfoexA, ppresult: *mut *mut addrinfoexA, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpnamehandle: *mut super::super::Foundation::HANDLE) -> i32;
1164         }
1165         ::std::mem::transmute(GetAddrInfoExA(
1166             pname.into_param().abi(),
1167             pservicename.into_param().abi(),
1168             ::std::mem::transmute(dwnamespace),
1169             ::std::mem::transmute(lpnspid),
1170             ::std::mem::transmute(hints),
1171             ::std::mem::transmute(ppresult),
1172             ::std::mem::transmute(timeout),
1173             ::std::mem::transmute(lpoverlapped),
1174             ::std::mem::transmute(lpcompletionroutine),
1175             ::std::mem::transmute(lpnamehandle),
1176         ))
1177     }
1178     #[cfg(not(windows))]
1179     unimplemented!("Unsupported target OS");
1180 }
1181 #[cfg(feature = "Win32_Foundation")]
1182 #[inline]
GetAddrInfoExCancel(lphandle: *const super::super::Foundation::HANDLE) -> i321183 pub unsafe fn GetAddrInfoExCancel(lphandle: *const super::super::Foundation::HANDLE) -> i32 {
1184     #[cfg(windows)]
1185     {
1186         #[link(name = "windows")]
1187         extern "system" {
1188             fn GetAddrInfoExCancel(lphandle: *const super::super::Foundation::HANDLE) -> i32;
1189         }
1190         ::std::mem::transmute(GetAddrInfoExCancel(::std::mem::transmute(lphandle)))
1191     }
1192     #[cfg(not(windows))]
1193     unimplemented!("Unsupported target OS");
1194 }
1195 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
1196 #[inline]
GetAddrInfoExOverlappedResult(lpoverlapped: *const super::super::System::IO::OVERLAPPED) -> i321197 pub unsafe fn GetAddrInfoExOverlappedResult(lpoverlapped: *const super::super::System::IO::OVERLAPPED) -> i32 {
1198     #[cfg(windows)]
1199     {
1200         #[link(name = "windows")]
1201         extern "system" {
1202             fn GetAddrInfoExOverlappedResult(lpoverlapped: *const super::super::System::IO::OVERLAPPED) -> i32;
1203         }
1204         ::std::mem::transmute(GetAddrInfoExOverlappedResult(::std::mem::transmute(lpoverlapped)))
1205     }
1206     #[cfg(not(windows))]
1207     unimplemented!("Unsupported target OS");
1208 }
1209 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
1210 #[inline]
GetAddrInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( pname: Param0, pservicename: Param1, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, hints: *const addrinfoexW, ppresult: *mut *mut addrinfoexW, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>, lphandle: *mut super::super::Foundation::HANDLE, ) -> i321211 pub unsafe fn GetAddrInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
1212     pname: Param0,
1213     pservicename: Param1,
1214     dwnamespace: u32,
1215     lpnspid: *const ::windows::runtime::GUID,
1216     hints: *const addrinfoexW,
1217     ppresult: *mut *mut addrinfoexW,
1218     timeout: *const timeval,
1219     lpoverlapped: *const super::super::System::IO::OVERLAPPED,
1220     lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>,
1221     lphandle: *mut super::super::Foundation::HANDLE,
1222 ) -> i32 {
1223     #[cfg(windows)]
1224     {
1225         #[link(name = "windows")]
1226         extern "system" {
1227             fn GetAddrInfoExW(pname: super::super::Foundation::PWSTR, pservicename: super::super::Foundation::PWSTR, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, hints: *const addrinfoexW, ppresult: *mut *mut addrinfoexW, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lphandle: *mut super::super::Foundation::HANDLE) -> i32;
1228         }
1229         ::std::mem::transmute(GetAddrInfoExW(
1230             pname.into_param().abi(),
1231             pservicename.into_param().abi(),
1232             ::std::mem::transmute(dwnamespace),
1233             ::std::mem::transmute(lpnspid),
1234             ::std::mem::transmute(hints),
1235             ::std::mem::transmute(ppresult),
1236             ::std::mem::transmute(timeout),
1237             ::std::mem::transmute(lpoverlapped),
1238             ::std::mem::transmute(lpcompletionroutine),
1239             ::std::mem::transmute(lphandle),
1240         ))
1241     }
1242     #[cfg(not(windows))]
1243     unimplemented!("Unsupported target OS");
1244 }
1245 #[cfg(feature = "Win32_Foundation")]
1246 #[inline]
GetAddrInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pnodename: Param0, pservicename: Param1, phints: *const addrinfoW, ppresult: *mut *mut addrinfoW) -> i321247 pub unsafe fn GetAddrInfoW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pnodename: Param0, pservicename: Param1, phints: *const addrinfoW, ppresult: *mut *mut addrinfoW) -> i32 {
1248     #[cfg(windows)]
1249     {
1250         #[link(name = "windows")]
1251         extern "system" {
1252             fn GetAddrInfoW(pnodename: super::super::Foundation::PWSTR, pservicename: super::super::Foundation::PWSTR, phints: *const addrinfoW, ppresult: *mut *mut addrinfoW) -> i32;
1253         }
1254         ::std::mem::transmute(GetAddrInfoW(pnodename.into_param().abi(), pservicename.into_param().abi(), ::std::mem::transmute(phints), ::std::mem::transmute(ppresult)))
1255     }
1256     #[cfg(not(windows))]
1257     unimplemented!("Unsupported target OS");
1258 }
1259 #[cfg(feature = "Win32_Foundation")]
1260 #[inline]
GetAddressByNameA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwnamespace: u32, lpservicetype: *const ::windows::runtime::GUID, lpservicename: Param2, lpiprotocols: *const i32, dwresolution: u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpcsaddrbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32, lpaliasbuffer: Param8, lpdwaliasbufferlength: *mut u32) -> i321261 pub unsafe fn GetAddressByNameA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwnamespace: u32, lpservicetype: *const ::windows::runtime::GUID, lpservicename: Param2, lpiprotocols: *const i32, dwresolution: u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpcsaddrbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32, lpaliasbuffer: Param8, lpdwaliasbufferlength: *mut u32) -> i32 {
1262     #[cfg(windows)]
1263     {
1264         #[link(name = "windows")]
1265         extern "system" {
1266             fn GetAddressByNameA(dwnamespace: u32, lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PSTR, lpiprotocols: *const i32, dwresolution: u32, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>, lpcsaddrbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32, lpaliasbuffer: super::super::Foundation::PSTR, lpdwaliasbufferlength: *mut u32) -> i32;
1267         }
1268         ::std::mem::transmute(GetAddressByNameA(
1269             ::std::mem::transmute(dwnamespace),
1270             ::std::mem::transmute(lpservicetype),
1271             lpservicename.into_param().abi(),
1272             ::std::mem::transmute(lpiprotocols),
1273             ::std::mem::transmute(dwresolution),
1274             ::std::mem::transmute(lpserviceasyncinfo),
1275             ::std::mem::transmute(lpcsaddrbuffer),
1276             ::std::mem::transmute(lpdwbufferlength),
1277             lpaliasbuffer.into_param().abi(),
1278             ::std::mem::transmute(lpdwaliasbufferlength),
1279         ))
1280     }
1281     #[cfg(not(windows))]
1282     unimplemented!("Unsupported target OS");
1283 }
1284 #[cfg(feature = "Win32_Foundation")]
1285 #[inline]
GetAddressByNameW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( dwnamespace: u32, lpservicetype: *const ::windows::runtime::GUID, lpservicename: Param2, lpiprotocols: *const i32, dwresolution: u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpcsaddrbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32, lpaliasbuffer: Param8, lpdwaliasbufferlength: *mut u32, ) -> i321286 pub unsafe fn GetAddressByNameW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
1287     dwnamespace: u32,
1288     lpservicetype: *const ::windows::runtime::GUID,
1289     lpservicename: Param2,
1290     lpiprotocols: *const i32,
1291     dwresolution: u32,
1292     lpserviceasyncinfo: *const SERVICE_ASYNC_INFO,
1293     lpcsaddrbuffer: *mut ::std::ffi::c_void,
1294     lpdwbufferlength: *mut u32,
1295     lpaliasbuffer: Param8,
1296     lpdwaliasbufferlength: *mut u32,
1297 ) -> i32 {
1298     #[cfg(windows)]
1299     {
1300         #[link(name = "windows")]
1301         extern "system" {
1302             fn GetAddressByNameW(dwnamespace: u32, lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PWSTR, lpiprotocols: *const i32, dwresolution: u32, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>, lpcsaddrbuffer: *mut ::std::ffi::c_void, lpdwbufferlength: *mut u32, lpaliasbuffer: super::super::Foundation::PWSTR, lpdwaliasbufferlength: *mut u32) -> i32;
1303         }
1304         ::std::mem::transmute(GetAddressByNameW(
1305             ::std::mem::transmute(dwnamespace),
1306             ::std::mem::transmute(lpservicetype),
1307             lpservicename.into_param().abi(),
1308             ::std::mem::transmute(lpiprotocols),
1309             ::std::mem::transmute(dwresolution),
1310             ::std::mem::transmute(lpserviceasyncinfo),
1311             ::std::mem::transmute(lpcsaddrbuffer),
1312             ::std::mem::transmute(lpdwbufferlength),
1313             lpaliasbuffer.into_param().abi(),
1314             ::std::mem::transmute(lpdwaliasbufferlength),
1315         ))
1316     }
1317     #[cfg(not(windows))]
1318     unimplemented!("Unsupported target OS");
1319 }
1320 #[cfg(feature = "Win32_Foundation")]
1321 #[inline]
GetHostNameW(name: super::super::Foundation::PWSTR, namelen: i32) -> i321322 pub unsafe fn GetHostNameW(name: super::super::Foundation::PWSTR, namelen: i32) -> i32 {
1323     #[cfg(windows)]
1324     {
1325         #[link(name = "windows")]
1326         extern "system" {
1327             fn GetHostNameW(name: super::super::Foundation::PWSTR, namelen: i32) -> i32;
1328         }
1329         ::std::mem::transmute(GetHostNameW(::std::mem::transmute(name), ::std::mem::transmute(namelen)))
1330     }
1331     #[cfg(not(windows))]
1332     unimplemented!("Unsupported target OS");
1333 }
1334 #[cfg(feature = "Win32_Foundation")]
1335 #[inline]
GetNameByTypeA(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PSTR, dwnamelength: u32) -> i321336 pub unsafe fn GetNameByTypeA(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PSTR, dwnamelength: u32) -> i32 {
1337     #[cfg(windows)]
1338     {
1339         #[link(name = "windows")]
1340         extern "system" {
1341             fn GetNameByTypeA(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PSTR, dwnamelength: u32) -> i32;
1342         }
1343         ::std::mem::transmute(GetNameByTypeA(::std::mem::transmute(lpservicetype), ::std::mem::transmute(lpservicename), ::std::mem::transmute(dwnamelength)))
1344     }
1345     #[cfg(not(windows))]
1346     unimplemented!("Unsupported target OS");
1347 }
1348 #[cfg(feature = "Win32_Foundation")]
1349 #[inline]
GetNameByTypeW(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PWSTR, dwnamelength: u32) -> i321350 pub unsafe fn GetNameByTypeW(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PWSTR, dwnamelength: u32) -> i32 {
1351     #[cfg(windows)]
1352     {
1353         #[link(name = "windows")]
1354         extern "system" {
1355             fn GetNameByTypeW(lpservicetype: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PWSTR, dwnamelength: u32) -> i32;
1356         }
1357         ::std::mem::transmute(GetNameByTypeW(::std::mem::transmute(lpservicetype), ::std::mem::transmute(lpservicename), ::std::mem::transmute(dwnamelength)))
1358     }
1359     #[cfg(not(windows))]
1360     unimplemented!("Unsupported target OS");
1361 }
1362 #[cfg(feature = "Win32_Foundation")]
1363 #[inline]
GetNameInfoW(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PWSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PWSTR, servicebuffersize: u32, flags: i32) -> i321364 pub unsafe fn GetNameInfoW(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PWSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PWSTR, servicebuffersize: u32, flags: i32) -> i32 {
1365     #[cfg(windows)]
1366     {
1367         #[link(name = "windows")]
1368         extern "system" {
1369             fn GetNameInfoW(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PWSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PWSTR, servicebuffersize: u32, flags: i32) -> i32;
1370         }
1371         ::std::mem::transmute(GetNameInfoW(::std::mem::transmute(psockaddr), ::std::mem::transmute(sockaddrlength), ::std::mem::transmute(pnodebuffer), ::std::mem::transmute(nodebuffersize), ::std::mem::transmute(pservicebuffer), ::std::mem::transmute(servicebuffersize), ::std::mem::transmute(flags)))
1372     }
1373     #[cfg(not(windows))]
1374     unimplemented!("Unsupported target OS");
1375 }
1376 #[cfg(feature = "Win32_Foundation")]
1377 #[inline]
GetServiceA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: Param2, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO) -> i321378 pub unsafe fn GetServiceA<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: Param2, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO) -> i32 {
1379     #[cfg(windows)]
1380     {
1381         #[link(name = "windows")]
1382         extern "system" {
1383             fn GetServiceA(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PSTR, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>) -> i32;
1384         }
1385         ::std::mem::transmute(GetServiceA(::std::mem::transmute(dwnamespace), ::std::mem::transmute(lpguid), lpservicename.into_param().abi(), ::std::mem::transmute(dwproperties), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(lpdwbuffersize), ::std::mem::transmute(lpserviceasyncinfo)))
1386     }
1387     #[cfg(not(windows))]
1388     unimplemented!("Unsupported target OS");
1389 }
1390 #[cfg(feature = "Win32_Foundation")]
1391 #[inline]
GetServiceW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: Param2, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO) -> i321392 pub unsafe fn GetServiceW<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: Param2, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO) -> i32 {
1393     #[cfg(windows)]
1394     {
1395         #[link(name = "windows")]
1396         extern "system" {
1397             fn GetServiceW(dwnamespace: u32, lpguid: *const ::windows::runtime::GUID, lpservicename: super::super::Foundation::PWSTR, dwproperties: u32, lpbuffer: *mut ::std::ffi::c_void, lpdwbuffersize: *mut u32, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>) -> i32;
1398         }
1399         ::std::mem::transmute(GetServiceW(::std::mem::transmute(dwnamespace), ::std::mem::transmute(lpguid), lpservicename.into_param().abi(), ::std::mem::transmute(dwproperties), ::std::mem::transmute(lpbuffer), ::std::mem::transmute(lpdwbuffersize), ::std::mem::transmute(lpserviceasyncinfo)))
1400     }
1401     #[cfg(not(windows))]
1402     unimplemented!("Unsupported target OS");
1403 }
1404 #[cfg(feature = "Win32_Foundation")]
1405 #[inline]
GetTypeByNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpservicename: Param0, lpservicetype: *mut ::windows::runtime::GUID) -> i321406 pub unsafe fn GetTypeByNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(lpservicename: Param0, lpservicetype: *mut ::windows::runtime::GUID) -> i32 {
1407     #[cfg(windows)]
1408     {
1409         #[link(name = "windows")]
1410         extern "system" {
1411             fn GetTypeByNameA(lpservicename: super::super::Foundation::PSTR, lpservicetype: *mut ::windows::runtime::GUID) -> i32;
1412         }
1413         ::std::mem::transmute(GetTypeByNameA(lpservicename.into_param().abi(), ::std::mem::transmute(lpservicetype)))
1414     }
1415     #[cfg(not(windows))]
1416     unimplemented!("Unsupported target OS");
1417 }
1418 #[cfg(feature = "Win32_Foundation")]
1419 #[inline]
GetTypeByNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpservicename: Param0, lpservicetype: *mut ::windows::runtime::GUID) -> i321420 pub unsafe fn GetTypeByNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpservicename: Param0, lpservicetype: *mut ::windows::runtime::GUID) -> i32 {
1421     #[cfg(windows)]
1422     {
1423         #[link(name = "windows")]
1424         extern "system" {
1425             fn GetTypeByNameW(lpservicename: super::super::Foundation::PWSTR, lpservicetype: *mut ::windows::runtime::GUID) -> i32;
1426         }
1427         ::std::mem::transmute(GetTypeByNameW(lpservicename.into_param().abi(), ::std::mem::transmute(lpservicetype)))
1428     }
1429     #[cfg(not(windows))]
1430     unimplemented!("Unsupported target OS");
1431 }
1432 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
1433 #[repr(transparent)]
1434 pub struct HWSAEVENT(pub isize);
1435 impl ::std::default::Default for HWSAEVENT {
default() -> Self1436     fn default() -> Self {
1437         unsafe { ::std::mem::zeroed() }
1438     }
1439 }
1440 unsafe impl ::windows::runtime::Handle for HWSAEVENT {}
1441 unsafe impl ::windows::runtime::Abi for HWSAEVENT {
1442     type Abi = Self;
1443     type DefaultType = Self;
1444 }
1445 pub const IAS_ATTRIB_INT: u32 = 1u32;
1446 pub const IAS_ATTRIB_NO_ATTRIB: u32 = 0u32;
1447 pub const IAS_ATTRIB_NO_CLASS: u32 = 16u32;
1448 pub const IAS_ATTRIB_OCTETSEQ: u32 = 2u32;
1449 pub const IAS_ATTRIB_STR: u32 = 3u32;
1450 pub const IAS_MAX_ATTRIBNAME: u32 = 256u32;
1451 pub const IAS_MAX_CLASSNAME: u32 = 64u32;
1452 pub const IAS_MAX_OCTET_STRING: u32 = 1024u32;
1453 pub const IAS_MAX_USER_STRING: u32 = 256u32;
1454 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1455 #[repr(C)]
1456 #[cfg(feature = "Win32_Foundation")]
1457 pub struct ICMP_ERROR_INFO {
1458     pub srcaddress: SOCKADDR_INET,
1459     pub protocol: IPPROTO,
1460     pub r#type: u8,
1461     pub code: u8,
1462 }
1463 #[cfg(feature = "Win32_Foundation")]
1464 impl ICMP_ERROR_INFO {}
1465 #[cfg(feature = "Win32_Foundation")]
1466 impl ::std::default::Default for ICMP_ERROR_INFO {
default() -> Self1467     fn default() -> Self {
1468         unsafe { ::std::mem::zeroed() }
1469     }
1470 }
1471 #[cfg(feature = "Win32_Foundation")]
1472 impl ::std::cmp::PartialEq for ICMP_ERROR_INFO {
eq(&self, _other: &Self) -> bool1473     fn eq(&self, _other: &Self) -> bool {
1474         unimplemented!()
1475     }
1476 }
1477 #[cfg(feature = "Win32_Foundation")]
1478 impl ::std::cmp::Eq for ICMP_ERROR_INFO {}
1479 #[cfg(feature = "Win32_Foundation")]
1480 unsafe impl ::windows::runtime::Abi for ICMP_ERROR_INFO {
1481     type Abi = Self;
1482     type DefaultType = Self;
1483 }
1484 pub const IFF_BROADCAST: u32 = 2u32;
1485 pub const IFF_LOOPBACK: u32 = 4u32;
1486 pub const IFF_MULTICAST: u32 = 16u32;
1487 pub const IFF_POINTTOPOINT: u32 = 8u32;
1488 pub const IFF_UP: u32 = 1u32;
1489 pub const IMPLINK_HIGHEXPER: u32 = 158u32;
1490 pub const IMPLINK_IP: u32 = 155u32;
1491 pub const IMPLINK_LOWEXPER: u32 = 156u32;
1492 pub const IN4ADDR_LINKLOCALPREFIX_LENGTH: u32 = 16u32;
1493 pub const IN4ADDR_LOOPBACK: u32 = 16777343u32;
1494 pub const IN4ADDR_LOOPBACKPREFIX_LENGTH: u32 = 8u32;
1495 pub const IN4ADDR_MULTICASTPREFIX_LENGTH: u32 = 4u32;
1496 pub const IN6ADDR_6TO4PREFIX_LENGTH: u32 = 16u32;
1497 pub const IN6ADDR_LINKLOCALPREFIX_LENGTH: u32 = 64u32;
1498 pub const IN6ADDR_MULTICASTPREFIX_LENGTH: u32 = 8u32;
1499 pub const IN6ADDR_SOLICITEDNODEMULTICASTPREFIX_LENGTH: u32 = 104u32;
1500 pub const IN6ADDR_TEREDOPREFIX_LENGTH: u32 = 32u32;
1501 pub const IN6ADDR_V4MAPPEDPREFIX_LENGTH: u32 = 96u32;
1502 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1503 #[repr(C)]
1504 pub struct IN6_ADDR {
1505     pub u: IN6_ADDR_0,
1506 }
1507 impl IN6_ADDR {}
1508 impl ::std::default::Default for IN6_ADDR {
default() -> Self1509     fn default() -> Self {
1510         unsafe { ::std::mem::zeroed() }
1511     }
1512 }
1513 impl ::std::cmp::PartialEq for IN6_ADDR {
eq(&self, _other: &Self) -> bool1514     fn eq(&self, _other: &Self) -> bool {
1515         unimplemented!()
1516     }
1517 }
1518 impl ::std::cmp::Eq for IN6_ADDR {}
1519 unsafe impl ::windows::runtime::Abi for IN6_ADDR {
1520     type Abi = Self;
1521     type DefaultType = Self;
1522 }
1523 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1524 #[repr(C)]
1525 pub union IN6_ADDR_0 {
1526     pub Byte: [u8; 16],
1527     pub Word: [u16; 8],
1528 }
1529 impl IN6_ADDR_0 {}
1530 impl ::std::default::Default for IN6_ADDR_0 {
default() -> Self1531     fn default() -> Self {
1532         unsafe { ::std::mem::zeroed() }
1533     }
1534 }
1535 impl ::std::cmp::PartialEq for IN6_ADDR_0 {
eq(&self, _other: &Self) -> bool1536     fn eq(&self, _other: &Self) -> bool {
1537         unimplemented!()
1538     }
1539 }
1540 impl ::std::cmp::Eq for IN6_ADDR_0 {}
1541 unsafe impl ::windows::runtime::Abi for IN6_ADDR_0 {
1542     type Abi = Self;
1543     type DefaultType = Self;
1544 }
1545 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1546 #[repr(C)]
1547 pub struct IN6_PKTINFO {
1548     pub ipi6_addr: IN6_ADDR,
1549     pub ipi6_ifindex: u32,
1550 }
1551 impl IN6_PKTINFO {}
1552 impl ::std::default::Default for IN6_PKTINFO {
default() -> Self1553     fn default() -> Self {
1554         unsafe { ::std::mem::zeroed() }
1555     }
1556 }
1557 impl ::std::cmp::PartialEq for IN6_PKTINFO {
eq(&self, _other: &Self) -> bool1558     fn eq(&self, _other: &Self) -> bool {
1559         unimplemented!()
1560     }
1561 }
1562 impl ::std::cmp::Eq for IN6_PKTINFO {}
1563 unsafe impl ::windows::runtime::Abi for IN6_PKTINFO {
1564     type Abi = Self;
1565     type DefaultType = Self;
1566 }
1567 pub const INADDR_LOOPBACK: u32 = 2130706433u32;
1568 pub const INADDR_NONE: u32 = 4294967295u32;
1569 pub const INCL_WINSOCK_API_PROTOTYPES: u32 = 1u32;
1570 pub const INCL_WINSOCK_API_TYPEDEFS: u32 = 0u32;
1571 pub const INET6_ADDRSTRLEN: u32 = 65u32;
1572 pub const INET_ADDRSTRLEN: u32 = 22u32;
1573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1574 #[repr(C)]
1575 pub struct INET_PORT_RANGE {
1576     pub StartPort: u16,
1577     pub NumberOfPorts: u16,
1578 }
1579 impl INET_PORT_RANGE {}
1580 impl ::std::default::Default for INET_PORT_RANGE {
default() -> Self1581     fn default() -> Self {
1582         unsafe { ::std::mem::zeroed() }
1583     }
1584 }
1585 impl ::std::fmt::Debug for INET_PORT_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1586     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1587         fmt.debug_struct("INET_PORT_RANGE").field("StartPort", &self.StartPort).field("NumberOfPorts", &self.NumberOfPorts).finish()
1588     }
1589 }
1590 impl ::std::cmp::PartialEq for INET_PORT_RANGE {
eq(&self, other: &Self) -> bool1591     fn eq(&self, other: &Self) -> bool {
1592         self.StartPort == other.StartPort && self.NumberOfPorts == other.NumberOfPorts
1593     }
1594 }
1595 impl ::std::cmp::Eq for INET_PORT_RANGE {}
1596 unsafe impl ::windows::runtime::Abi for INET_PORT_RANGE {
1597     type Abi = Self;
1598     type DefaultType = Self;
1599 }
1600 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1601 #[repr(C)]
1602 pub struct INET_PORT_RESERVATION_INFORMATION {
1603     pub OwningPid: u32,
1604 }
1605 impl INET_PORT_RESERVATION_INFORMATION {}
1606 impl ::std::default::Default for INET_PORT_RESERVATION_INFORMATION {
default() -> Self1607     fn default() -> Self {
1608         unsafe { ::std::mem::zeroed() }
1609     }
1610 }
1611 impl ::std::fmt::Debug for INET_PORT_RESERVATION_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1612     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1613         fmt.debug_struct("INET_PORT_RESERVATION_INFORMATION").field("OwningPid", &self.OwningPid).finish()
1614     }
1615 }
1616 impl ::std::cmp::PartialEq for INET_PORT_RESERVATION_INFORMATION {
eq(&self, other: &Self) -> bool1617     fn eq(&self, other: &Self) -> bool {
1618         self.OwningPid == other.OwningPid
1619     }
1620 }
1621 impl ::std::cmp::Eq for INET_PORT_RESERVATION_INFORMATION {}
1622 unsafe impl ::windows::runtime::Abi for INET_PORT_RESERVATION_INFORMATION {
1623     type Abi = Self;
1624     type DefaultType = Self;
1625 }
1626 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1627 #[repr(C)]
1628 pub struct INET_PORT_RESERVATION_INSTANCE {
1629     pub Reservation: INET_PORT_RANGE,
1630     pub Token: INET_PORT_RESERVATION_TOKEN,
1631 }
1632 impl INET_PORT_RESERVATION_INSTANCE {}
1633 impl ::std::default::Default for INET_PORT_RESERVATION_INSTANCE {
default() -> Self1634     fn default() -> Self {
1635         unsafe { ::std::mem::zeroed() }
1636     }
1637 }
1638 impl ::std::fmt::Debug for INET_PORT_RESERVATION_INSTANCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1639     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1640         fmt.debug_struct("INET_PORT_RESERVATION_INSTANCE").field("Reservation", &self.Reservation).field("Token", &self.Token).finish()
1641     }
1642 }
1643 impl ::std::cmp::PartialEq for INET_PORT_RESERVATION_INSTANCE {
eq(&self, other: &Self) -> bool1644     fn eq(&self, other: &Self) -> bool {
1645         self.Reservation == other.Reservation && self.Token == other.Token
1646     }
1647 }
1648 impl ::std::cmp::Eq for INET_PORT_RESERVATION_INSTANCE {}
1649 unsafe impl ::windows::runtime::Abi for INET_PORT_RESERVATION_INSTANCE {
1650     type Abi = Self;
1651     type DefaultType = Self;
1652 }
1653 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1654 #[repr(C)]
1655 pub struct INET_PORT_RESERVATION_TOKEN {
1656     pub Token: u64,
1657 }
1658 impl INET_PORT_RESERVATION_TOKEN {}
1659 impl ::std::default::Default for INET_PORT_RESERVATION_TOKEN {
default() -> Self1660     fn default() -> Self {
1661         unsafe { ::std::mem::zeroed() }
1662     }
1663 }
1664 impl ::std::fmt::Debug for INET_PORT_RESERVATION_TOKEN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1665     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1666         fmt.debug_struct("INET_PORT_RESERVATION_TOKEN").field("Token", &self.Token).finish()
1667     }
1668 }
1669 impl ::std::cmp::PartialEq for INET_PORT_RESERVATION_TOKEN {
eq(&self, other: &Self) -> bool1670     fn eq(&self, other: &Self) -> bool {
1671         self.Token == other.Token
1672     }
1673 }
1674 impl ::std::cmp::Eq for INET_PORT_RESERVATION_TOKEN {}
1675 unsafe impl ::windows::runtime::Abi for INET_PORT_RESERVATION_TOKEN {
1676     type Abi = Self;
1677     type DefaultType = Self;
1678 }
1679 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1680 #[repr(C)]
1681 #[cfg(feature = "Win32_Foundation")]
1682 pub struct INTERFACE_INFO {
1683     pub iiFlags: u32,
1684     pub iiAddress: sockaddr_gen,
1685     pub iiBroadcastAddress: sockaddr_gen,
1686     pub iiNetmask: sockaddr_gen,
1687 }
1688 #[cfg(feature = "Win32_Foundation")]
1689 impl INTERFACE_INFO {}
1690 #[cfg(feature = "Win32_Foundation")]
1691 impl ::std::default::Default for INTERFACE_INFO {
default() -> Self1692     fn default() -> Self {
1693         unsafe { ::std::mem::zeroed() }
1694     }
1695 }
1696 #[cfg(feature = "Win32_Foundation")]
1697 impl ::std::cmp::PartialEq for INTERFACE_INFO {
eq(&self, _other: &Self) -> bool1698     fn eq(&self, _other: &Self) -> bool {
1699         unimplemented!()
1700     }
1701 }
1702 #[cfg(feature = "Win32_Foundation")]
1703 impl ::std::cmp::Eq for INTERFACE_INFO {}
1704 #[cfg(feature = "Win32_Foundation")]
1705 unsafe impl ::windows::runtime::Abi for INTERFACE_INFO {
1706     type Abi = Self;
1707     type DefaultType = Self;
1708 }
1709 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1710 #[repr(C)]
1711 #[cfg(feature = "Win32_Foundation")]
1712 pub struct INTERFACE_INFO_EX {
1713     pub iiFlags: u32,
1714     pub iiAddress: SOCKET_ADDRESS,
1715     pub iiBroadcastAddress: SOCKET_ADDRESS,
1716     pub iiNetmask: SOCKET_ADDRESS,
1717 }
1718 #[cfg(feature = "Win32_Foundation")]
1719 impl INTERFACE_INFO_EX {}
1720 #[cfg(feature = "Win32_Foundation")]
1721 impl ::std::default::Default for INTERFACE_INFO_EX {
default() -> Self1722     fn default() -> Self {
1723         unsafe { ::std::mem::zeroed() }
1724     }
1725 }
1726 #[cfg(feature = "Win32_Foundation")]
1727 impl ::std::fmt::Debug for INTERFACE_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1728     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1729         fmt.debug_struct("INTERFACE_INFO_EX").field("iiFlags", &self.iiFlags).field("iiAddress", &self.iiAddress).field("iiBroadcastAddress", &self.iiBroadcastAddress).field("iiNetmask", &self.iiNetmask).finish()
1730     }
1731 }
1732 #[cfg(feature = "Win32_Foundation")]
1733 impl ::std::cmp::PartialEq for INTERFACE_INFO_EX {
eq(&self, other: &Self) -> bool1734     fn eq(&self, other: &Self) -> bool {
1735         self.iiFlags == other.iiFlags && self.iiAddress == other.iiAddress && self.iiBroadcastAddress == other.iiBroadcastAddress && self.iiNetmask == other.iiNetmask
1736     }
1737 }
1738 #[cfg(feature = "Win32_Foundation")]
1739 impl ::std::cmp::Eq for INTERFACE_INFO_EX {}
1740 #[cfg(feature = "Win32_Foundation")]
1741 unsafe impl ::windows::runtime::Abi for INTERFACE_INFO_EX {
1742     type Abi = Self;
1743     type DefaultType = Self;
1744 }
1745 pub const INVALID_SOCKET: SOCKET = SOCKET(4294967295u32 as _);
1746 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1747 #[repr(C)]
1748 pub struct IN_ADDR {
1749     pub S_un: IN_ADDR_0,
1750 }
1751 impl IN_ADDR {}
1752 impl ::std::default::Default for IN_ADDR {
default() -> Self1753     fn default() -> Self {
1754         unsafe { ::std::mem::zeroed() }
1755     }
1756 }
1757 impl ::std::cmp::PartialEq for IN_ADDR {
eq(&self, _other: &Self) -> bool1758     fn eq(&self, _other: &Self) -> bool {
1759         unimplemented!()
1760     }
1761 }
1762 impl ::std::cmp::Eq for IN_ADDR {}
1763 unsafe impl ::windows::runtime::Abi for IN_ADDR {
1764     type Abi = Self;
1765     type DefaultType = Self;
1766 }
1767 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1768 #[repr(C)]
1769 pub union IN_ADDR_0 {
1770     pub S_un_b: IN_ADDR_0_0,
1771     pub S_un_w: IN_ADDR_0_1,
1772     pub S_addr: u32,
1773 }
1774 impl IN_ADDR_0 {}
1775 impl ::std::default::Default for IN_ADDR_0 {
default() -> Self1776     fn default() -> Self {
1777         unsafe { ::std::mem::zeroed() }
1778     }
1779 }
1780 impl ::std::cmp::PartialEq for IN_ADDR_0 {
eq(&self, _other: &Self) -> bool1781     fn eq(&self, _other: &Self) -> bool {
1782         unimplemented!()
1783     }
1784 }
1785 impl ::std::cmp::Eq for IN_ADDR_0 {}
1786 unsafe impl ::windows::runtime::Abi for IN_ADDR_0 {
1787     type Abi = Self;
1788     type DefaultType = Self;
1789 }
1790 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1791 #[repr(C)]
1792 pub struct IN_ADDR_0_0 {
1793     pub s_b1: u8,
1794     pub s_b2: u8,
1795     pub s_b3: u8,
1796     pub s_b4: u8,
1797 }
1798 impl IN_ADDR_0_0 {}
1799 impl ::std::default::Default for IN_ADDR_0_0 {
default() -> Self1800     fn default() -> Self {
1801         unsafe { ::std::mem::zeroed() }
1802     }
1803 }
1804 impl ::std::fmt::Debug for IN_ADDR_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1805     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1806         fmt.debug_struct("_S_un_b_e__Struct").field("s_b1", &self.s_b1).field("s_b2", &self.s_b2).field("s_b3", &self.s_b3).field("s_b4", &self.s_b4).finish()
1807     }
1808 }
1809 impl ::std::cmp::PartialEq for IN_ADDR_0_0 {
eq(&self, other: &Self) -> bool1810     fn eq(&self, other: &Self) -> bool {
1811         self.s_b1 == other.s_b1 && self.s_b2 == other.s_b2 && self.s_b3 == other.s_b3 && self.s_b4 == other.s_b4
1812     }
1813 }
1814 impl ::std::cmp::Eq for IN_ADDR_0_0 {}
1815 unsafe impl ::windows::runtime::Abi for IN_ADDR_0_0 {
1816     type Abi = Self;
1817     type DefaultType = Self;
1818 }
1819 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1820 #[repr(C)]
1821 pub struct IN_ADDR_0_1 {
1822     pub s_w1: u16,
1823     pub s_w2: u16,
1824 }
1825 impl IN_ADDR_0_1 {}
1826 impl ::std::default::Default for IN_ADDR_0_1 {
default() -> Self1827     fn default() -> Self {
1828         unsafe { ::std::mem::zeroed() }
1829     }
1830 }
1831 impl ::std::fmt::Debug for IN_ADDR_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1832     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1833         fmt.debug_struct("_S_un_w_e__Struct").field("s_w1", &self.s_w1).field("s_w2", &self.s_w2).finish()
1834     }
1835 }
1836 impl ::std::cmp::PartialEq for IN_ADDR_0_1 {
eq(&self, other: &Self) -> bool1837     fn eq(&self, other: &Self) -> bool {
1838         self.s_w1 == other.s_w1 && self.s_w2 == other.s_w2
1839     }
1840 }
1841 impl ::std::cmp::Eq for IN_ADDR_0_1 {}
1842 unsafe impl ::windows::runtime::Abi for IN_ADDR_0_1 {
1843     type Abi = Self;
1844     type DefaultType = Self;
1845 }
1846 pub const IN_CLASSA_HOST: u32 = 16777215u32;
1847 pub const IN_CLASSA_MAX: u32 = 128u32;
1848 pub const IN_CLASSA_NET: u32 = 4278190080u32;
1849 pub const IN_CLASSA_NSHIFT: u32 = 24u32;
1850 pub const IN_CLASSB_HOST: u32 = 65535u32;
1851 pub const IN_CLASSB_MAX: u32 = 65536u32;
1852 pub const IN_CLASSB_NET: u32 = 4294901760u32;
1853 pub const IN_CLASSB_NSHIFT: u32 = 16u32;
1854 pub const IN_CLASSC_HOST: u32 = 255u32;
1855 pub const IN_CLASSC_NET: u32 = 4294967040u32;
1856 pub const IN_CLASSC_NSHIFT: u32 = 8u32;
1857 pub const IN_CLASSD_HOST: u32 = 268435455u32;
1858 pub const IN_CLASSD_NET: u32 = 4026531840u32;
1859 pub const IN_CLASSD_NSHIFT: u32 = 28u32;
1860 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1861 #[repr(C)]
1862 pub struct IN_PKTINFO {
1863     pub ipi_addr: IN_ADDR,
1864     pub ipi_ifindex: u32,
1865 }
1866 impl IN_PKTINFO {}
1867 impl ::std::default::Default for IN_PKTINFO {
default() -> Self1868     fn default() -> Self {
1869         unsafe { ::std::mem::zeroed() }
1870     }
1871 }
1872 impl ::std::cmp::PartialEq for IN_PKTINFO {
eq(&self, _other: &Self) -> bool1873     fn eq(&self, _other: &Self) -> bool {
1874         unimplemented!()
1875     }
1876 }
1877 impl ::std::cmp::Eq for IN_PKTINFO {}
1878 unsafe impl ::windows::runtime::Abi for IN_PKTINFO {
1879     type Abi = Self;
1880     type DefaultType = Self;
1881 }
1882 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1883 #[repr(C)]
1884 pub struct IN_PKTINFO_EX {
1885     pub pkt_info: IN_PKTINFO,
1886     pub scope_id: SCOPE_ID,
1887 }
1888 impl IN_PKTINFO_EX {}
1889 impl ::std::default::Default for IN_PKTINFO_EX {
default() -> Self1890     fn default() -> Self {
1891         unsafe { ::std::mem::zeroed() }
1892     }
1893 }
1894 impl ::std::cmp::PartialEq for IN_PKTINFO_EX {
eq(&self, _other: &Self) -> bool1895     fn eq(&self, _other: &Self) -> bool {
1896         unimplemented!()
1897     }
1898 }
1899 impl ::std::cmp::Eq for IN_PKTINFO_EX {}
1900 unsafe impl ::windows::runtime::Abi for IN_PKTINFO_EX {
1901     type Abi = Self;
1902     type DefaultType = Self;
1903 }
1904 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1905 #[repr(C)]
1906 pub struct IN_RECVERR {
1907     pub protocol: IPPROTO,
1908     pub info: u32,
1909     pub r#type: u8,
1910     pub code: u8,
1911 }
1912 impl IN_RECVERR {}
1913 impl ::std::default::Default for IN_RECVERR {
default() -> Self1914     fn default() -> Self {
1915         unsafe { ::std::mem::zeroed() }
1916     }
1917 }
1918 impl ::std::fmt::Debug for IN_RECVERR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1919     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1920         fmt.debug_struct("IN_RECVERR").field("protocol", &self.protocol).field("info", &self.info).field("r#type", &self.r#type).field("code", &self.code).finish()
1921     }
1922 }
1923 impl ::std::cmp::PartialEq for IN_RECVERR {
eq(&self, other: &Self) -> bool1924     fn eq(&self, other: &Self) -> bool {
1925         self.protocol == other.protocol && self.info == other.info && self.r#type == other.r#type && self.code == other.code
1926     }
1927 }
1928 impl ::std::cmp::Eq for IN_RECVERR {}
1929 unsafe impl ::windows::runtime::Abi for IN_RECVERR {
1930     type Abi = Self;
1931     type DefaultType = Self;
1932 }
1933 pub const IOCPARM_MASK: u32 = 127u32;
1934 pub const IOC_IN: u32 = 2147483648u32;
1935 pub const IOC_OUT: u32 = 1073741824u32;
1936 pub const IOC_PROTOCOL: u32 = 268435456u32;
1937 pub const IOC_UNIX: u32 = 0u32;
1938 pub const IOC_VENDOR: u32 = 402653184u32;
1939 pub const IOC_VOID: u32 = 536870912u32;
1940 pub const IOC_WS2: u32 = 134217728u32;
1941 pub const IP6T_SO_ORIGINAL_DST: u32 = 12303u32;
1942 pub const IPPORT_BIFFUDP: u32 = 512u32;
1943 pub const IPPORT_CHARGEN: u32 = 19u32;
1944 pub const IPPORT_CMDSERVER: u32 = 514u32;
1945 pub const IPPORT_DAYTIME: u32 = 13u32;
1946 pub const IPPORT_DISCARD: u32 = 9u32;
1947 pub const IPPORT_DYNAMIC_MAX: u32 = 65535u32;
1948 pub const IPPORT_DYNAMIC_MIN: u32 = 49152u32;
1949 pub const IPPORT_ECHO: u32 = 7u32;
1950 pub const IPPORT_EFSSERVER: u32 = 520u32;
1951 pub const IPPORT_EPMAP: u32 = 135u32;
1952 pub const IPPORT_EXECSERVER: u32 = 512u32;
1953 pub const IPPORT_FINGER: u32 = 79u32;
1954 pub const IPPORT_FTP: u32 = 21u32;
1955 pub const IPPORT_FTP_DATA: u32 = 20u32;
1956 pub const IPPORT_HTTPS: u32 = 443u32;
1957 pub const IPPORT_IMAP: u32 = 143u32;
1958 pub const IPPORT_IMAP3: u32 = 220u32;
1959 pub const IPPORT_LDAP: u32 = 389u32;
1960 pub const IPPORT_LOGINSERVER: u32 = 513u32;
1961 pub const IPPORT_MICROSOFT_DS: u32 = 445u32;
1962 pub const IPPORT_MSP: u32 = 18u32;
1963 pub const IPPORT_MTP: u32 = 57u32;
1964 pub const IPPORT_NAMESERVER: u32 = 42u32;
1965 pub const IPPORT_NETBIOS_DGM: u32 = 138u32;
1966 pub const IPPORT_NETBIOS_NS: u32 = 137u32;
1967 pub const IPPORT_NETBIOS_SSN: u32 = 139u32;
1968 pub const IPPORT_NETSTAT: u32 = 15u32;
1969 pub const IPPORT_NTP: u32 = 123u32;
1970 pub const IPPORT_POP3: u32 = 110u32;
1971 pub const IPPORT_QOTD: u32 = 17u32;
1972 pub const IPPORT_REGISTERED_MAX: u32 = 49151u32;
1973 pub const IPPORT_REGISTERED_MIN: u32 = 1024u32;
1974 pub const IPPORT_RESERVED: u32 = 1024u32;
1975 pub const IPPORT_RJE: u32 = 77u32;
1976 pub const IPPORT_ROUTESERVER: u32 = 520u32;
1977 pub const IPPORT_SMTP: u32 = 25u32;
1978 pub const IPPORT_SNMP: u32 = 161u32;
1979 pub const IPPORT_SNMP_TRAP: u32 = 162u32;
1980 pub const IPPORT_SUPDUP: u32 = 95u32;
1981 pub const IPPORT_SYSTAT: u32 = 11u32;
1982 pub const IPPORT_TCPMUX: u32 = 1u32;
1983 pub const IPPORT_TELNET: u32 = 23u32;
1984 pub const IPPORT_TFTP: u32 = 69u32;
1985 pub const IPPORT_TIMESERVER: u32 = 37u32;
1986 pub const IPPORT_TTYLINK: u32 = 87u32;
1987 pub const IPPORT_WHOIS: u32 = 43u32;
1988 pub const IPPORT_WHOSERVER: u32 = 513u32;
1989 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1990 #[repr(transparent)]
1991 pub struct IPPROTO(pub i32);
1992 pub const IPPROTO_HOPOPTS: IPPROTO = IPPROTO(0i32);
1993 pub const IPPROTO_ICMP: IPPROTO = IPPROTO(1i32);
1994 pub const IPPROTO_IGMP: IPPROTO = IPPROTO(2i32);
1995 pub const IPPROTO_GGP: IPPROTO = IPPROTO(3i32);
1996 pub const IPPROTO_IPV4: IPPROTO = IPPROTO(4i32);
1997 pub const IPPROTO_ST: IPPROTO = IPPROTO(5i32);
1998 pub const IPPROTO_TCP: IPPROTO = IPPROTO(6i32);
1999 pub const IPPROTO_CBT: IPPROTO = IPPROTO(7i32);
2000 pub const IPPROTO_EGP: IPPROTO = IPPROTO(8i32);
2001 pub const IPPROTO_IGP: IPPROTO = IPPROTO(9i32);
2002 pub const IPPROTO_PUP: IPPROTO = IPPROTO(12i32);
2003 pub const IPPROTO_UDP: IPPROTO = IPPROTO(17i32);
2004 pub const IPPROTO_IDP: IPPROTO = IPPROTO(22i32);
2005 pub const IPPROTO_RDP: IPPROTO = IPPROTO(27i32);
2006 pub const IPPROTO_IPV6: IPPROTO = IPPROTO(41i32);
2007 pub const IPPROTO_ROUTING: IPPROTO = IPPROTO(43i32);
2008 pub const IPPROTO_FRAGMENT: IPPROTO = IPPROTO(44i32);
2009 pub const IPPROTO_ESP: IPPROTO = IPPROTO(50i32);
2010 pub const IPPROTO_AH: IPPROTO = IPPROTO(51i32);
2011 pub const IPPROTO_ICMPV6: IPPROTO = IPPROTO(58i32);
2012 pub const IPPROTO_NONE: IPPROTO = IPPROTO(59i32);
2013 pub const IPPROTO_DSTOPTS: IPPROTO = IPPROTO(60i32);
2014 pub const IPPROTO_ND: IPPROTO = IPPROTO(77i32);
2015 pub const IPPROTO_ICLFXBM: IPPROTO = IPPROTO(78i32);
2016 pub const IPPROTO_PIM: IPPROTO = IPPROTO(103i32);
2017 pub const IPPROTO_PGM: IPPROTO = IPPROTO(113i32);
2018 pub const IPPROTO_L2TP: IPPROTO = IPPROTO(115i32);
2019 pub const IPPROTO_SCTP: IPPROTO = IPPROTO(132i32);
2020 pub const IPPROTO_RAW: IPPROTO = IPPROTO(255i32);
2021 pub const IPPROTO_MAX: IPPROTO = IPPROTO(256i32);
2022 pub const IPPROTO_RESERVED_RAW: IPPROTO = IPPROTO(257i32);
2023 pub const IPPROTO_RESERVED_IPSEC: IPPROTO = IPPROTO(258i32);
2024 pub const IPPROTO_RESERVED_IPSECOFFLOAD: IPPROTO = IPPROTO(259i32);
2025 pub const IPPROTO_RESERVED_WNV: IPPROTO = IPPROTO(260i32);
2026 pub const IPPROTO_RESERVED_MAX: IPPROTO = IPPROTO(261i32);
2027 impl ::std::convert::From<i32> for IPPROTO {
from(value: i32) -> Self2028     fn from(value: i32) -> Self {
2029         Self(value)
2030     }
2031 }
2032 unsafe impl ::windows::runtime::Abi for IPPROTO {
2033     type Abi = Self;
2034     type DefaultType = Self;
2035 }
2036 pub const IPPROTO_IP: u32 = 0u32;
2037 pub const IPPROTO_RM: u32 = 113u32;
2038 pub const IPV6_ADD_IFLIST: u32 = 29u32;
2039 pub const IPV6_ADD_MEMBERSHIP: u32 = 12u32;
2040 pub const IPV6_CHECKSUM: u32 = 26u32;
2041 pub const IPV6_DEL_IFLIST: u32 = 30u32;
2042 pub const IPV6_DONTFRAG: u32 = 14u32;
2043 pub const IPV6_DROP_MEMBERSHIP: u32 = 13u32;
2044 pub const IPV6_ECN: u32 = 50u32;
2045 pub const IPV6_GET_IFLIST: u32 = 33u32;
2046 pub const IPV6_HDRINCL: u32 = 2u32;
2047 pub const IPV6_HOPLIMIT: u32 = 21u32;
2048 pub const IPV6_HOPOPTS: u32 = 1u32;
2049 pub const IPV6_IFLIST: u32 = 28u32;
2050 pub const IPV6_JOIN_GROUP: u32 = 12u32;
2051 pub const IPV6_LEAVE_GROUP: u32 = 13u32;
2052 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2053 #[repr(C)]
2054 pub struct IPV6_MREQ {
2055     pub ipv6mr_multiaddr: IN6_ADDR,
2056     pub ipv6mr_interface: u32,
2057 }
2058 impl IPV6_MREQ {}
2059 impl ::std::default::Default for IPV6_MREQ {
default() -> Self2060     fn default() -> Self {
2061         unsafe { ::std::mem::zeroed() }
2062     }
2063 }
2064 impl ::std::cmp::PartialEq for IPV6_MREQ {
eq(&self, _other: &Self) -> bool2065     fn eq(&self, _other: &Self) -> bool {
2066         unimplemented!()
2067     }
2068 }
2069 impl ::std::cmp::Eq for IPV6_MREQ {}
2070 unsafe impl ::windows::runtime::Abi for IPV6_MREQ {
2071     type Abi = Self;
2072     type DefaultType = Self;
2073 }
2074 pub const IPV6_MTU: u32 = 72u32;
2075 pub const IPV6_MTU_DISCOVER: u32 = 71u32;
2076 pub const IPV6_MULTICAST_HOPS: u32 = 10u32;
2077 pub const IPV6_MULTICAST_IF: u32 = 9u32;
2078 pub const IPV6_MULTICAST_LOOP: u32 = 11u32;
2079 pub const IPV6_NRT_INTERFACE: u32 = 74u32;
2080 pub const IPV6_PKTINFO: u32 = 19u32;
2081 pub const IPV6_PKTINFO_EX: u32 = 51u32;
2082 pub const IPV6_PROTECTION_LEVEL: u32 = 23u32;
2083 pub const IPV6_RECVDSTADDR: u32 = 25u32;
2084 pub const IPV6_RECVECN: u32 = 50u32;
2085 pub const IPV6_RECVERR: u32 = 75u32;
2086 pub const IPV6_RECVIF: u32 = 24u32;
2087 pub const IPV6_RECVRTHDR: u32 = 38u32;
2088 pub const IPV6_RECVTCLASS: u32 = 40u32;
2089 pub const IPV6_RTHDR: u32 = 32u32;
2090 pub const IPV6_TCLASS: u32 = 39u32;
2091 pub const IPV6_UNICAST_HOPS: u32 = 4u32;
2092 pub const IPV6_UNICAST_IF: u32 = 31u32;
2093 pub const IPV6_USER_MTU: u32 = 76u32;
2094 pub const IPV6_V6ONLY: u32 = 27u32;
2095 pub const IPV6_WFP_REDIRECT_CONTEXT: u32 = 70u32;
2096 pub const IPV6_WFP_REDIRECT_RECORDS: u32 = 60u32;
2097 pub const IPX_ADDRESS: u32 = 16391u32;
2098 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2099 #[repr(C)]
2100 #[cfg(feature = "Win32_Foundation")]
2101 pub struct IPX_ADDRESS_DATA {
2102     pub adapternum: i32,
2103     pub netnum: [u8; 4],
2104     pub nodenum: [u8; 6],
2105     pub wan: super::super::Foundation::BOOLEAN,
2106     pub status: super::super::Foundation::BOOLEAN,
2107     pub maxpkt: i32,
2108     pub linkspeed: u32,
2109 }
2110 #[cfg(feature = "Win32_Foundation")]
2111 impl IPX_ADDRESS_DATA {}
2112 #[cfg(feature = "Win32_Foundation")]
2113 impl ::std::default::Default for IPX_ADDRESS_DATA {
default() -> Self2114     fn default() -> Self {
2115         unsafe { ::std::mem::zeroed() }
2116     }
2117 }
2118 #[cfg(feature = "Win32_Foundation")]
2119 impl ::std::fmt::Debug for IPX_ADDRESS_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2120     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2121         fmt.debug_struct("IPX_ADDRESS_DATA").field("adapternum", &self.adapternum).field("netnum", &self.netnum).field("nodenum", &self.nodenum).field("wan", &self.wan).field("status", &self.status).field("maxpkt", &self.maxpkt).field("linkspeed", &self.linkspeed).finish()
2122     }
2123 }
2124 #[cfg(feature = "Win32_Foundation")]
2125 impl ::std::cmp::PartialEq for IPX_ADDRESS_DATA {
eq(&self, other: &Self) -> bool2126     fn eq(&self, other: &Self) -> bool {
2127         self.adapternum == other.adapternum && self.netnum == other.netnum && self.nodenum == other.nodenum && self.wan == other.wan && self.status == other.status && self.maxpkt == other.maxpkt && self.linkspeed == other.linkspeed
2128     }
2129 }
2130 #[cfg(feature = "Win32_Foundation")]
2131 impl ::std::cmp::Eq for IPX_ADDRESS_DATA {}
2132 #[cfg(feature = "Win32_Foundation")]
2133 unsafe impl ::windows::runtime::Abi for IPX_ADDRESS_DATA {
2134     type Abi = Self;
2135     type DefaultType = Self;
2136 }
2137 pub const IPX_ADDRESS_NOTIFY: u32 = 16396u32;
2138 pub const IPX_DSTYPE: u32 = 16386u32;
2139 pub const IPX_EXTENDED_ADDRESS: u32 = 16388u32;
2140 pub const IPX_FILTERPTYPE: u32 = 16385u32;
2141 pub const IPX_GETNETINFO: u32 = 16392u32;
2142 pub const IPX_GETNETINFO_NORIP: u32 = 16393u32;
2143 pub const IPX_IMMEDIATESPXACK: u32 = 16400u32;
2144 pub const IPX_MAXSIZE: u32 = 16390u32;
2145 pub const IPX_MAX_ADAPTER_NUM: u32 = 16397u32;
2146 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2147 #[repr(C)]
2148 pub struct IPX_NETNUM_DATA {
2149     pub netnum: [u8; 4],
2150     pub hopcount: u16,
2151     pub netdelay: u16,
2152     pub cardnum: i32,
2153     pub router: [u8; 6],
2154 }
2155 impl IPX_NETNUM_DATA {}
2156 impl ::std::default::Default for IPX_NETNUM_DATA {
default() -> Self2157     fn default() -> Self {
2158         unsafe { ::std::mem::zeroed() }
2159     }
2160 }
2161 impl ::std::fmt::Debug for IPX_NETNUM_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2162     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2163         fmt.debug_struct("IPX_NETNUM_DATA").field("netnum", &self.netnum).field("hopcount", &self.hopcount).field("netdelay", &self.netdelay).field("cardnum", &self.cardnum).field("router", &self.router).finish()
2164     }
2165 }
2166 impl ::std::cmp::PartialEq for IPX_NETNUM_DATA {
eq(&self, other: &Self) -> bool2167     fn eq(&self, other: &Self) -> bool {
2168         self.netnum == other.netnum && self.hopcount == other.hopcount && self.netdelay == other.netdelay && self.cardnum == other.cardnum && self.router == other.router
2169     }
2170 }
2171 impl ::std::cmp::Eq for IPX_NETNUM_DATA {}
2172 unsafe impl ::windows::runtime::Abi for IPX_NETNUM_DATA {
2173     type Abi = Self;
2174     type DefaultType = Self;
2175 }
2176 pub const IPX_PTYPE: u32 = 16384u32;
2177 pub const IPX_RECEIVE_BROADCAST: u32 = 16399u32;
2178 pub const IPX_RECVHDR: u32 = 16389u32;
2179 pub const IPX_RERIPNETNUMBER: u32 = 16398u32;
2180 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2181 #[repr(C)]
2182 pub struct IPX_SPXCONNSTATUS_DATA {
2183     pub ConnectionState: u8,
2184     pub WatchDogActive: u8,
2185     pub LocalConnectionId: u16,
2186     pub RemoteConnectionId: u16,
2187     pub LocalSequenceNumber: u16,
2188     pub LocalAckNumber: u16,
2189     pub LocalAllocNumber: u16,
2190     pub RemoteAckNumber: u16,
2191     pub RemoteAllocNumber: u16,
2192     pub LocalSocket: u16,
2193     pub ImmediateAddress: [u8; 6],
2194     pub RemoteNetwork: [u8; 4],
2195     pub RemoteNode: [u8; 6],
2196     pub RemoteSocket: u16,
2197     pub RetransmissionCount: u16,
2198     pub EstimatedRoundTripDelay: u16,
2199     pub RetransmittedPackets: u16,
2200     pub SuppressedPacket: u16,
2201 }
2202 impl IPX_SPXCONNSTATUS_DATA {}
2203 impl ::std::default::Default for IPX_SPXCONNSTATUS_DATA {
default() -> Self2204     fn default() -> Self {
2205         unsafe { ::std::mem::zeroed() }
2206     }
2207 }
2208 impl ::std::fmt::Debug for IPX_SPXCONNSTATUS_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2209     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2210         fmt.debug_struct("IPX_SPXCONNSTATUS_DATA")
2211             .field("ConnectionState", &self.ConnectionState)
2212             .field("WatchDogActive", &self.WatchDogActive)
2213             .field("LocalConnectionId", &self.LocalConnectionId)
2214             .field("RemoteConnectionId", &self.RemoteConnectionId)
2215             .field("LocalSequenceNumber", &self.LocalSequenceNumber)
2216             .field("LocalAckNumber", &self.LocalAckNumber)
2217             .field("LocalAllocNumber", &self.LocalAllocNumber)
2218             .field("RemoteAckNumber", &self.RemoteAckNumber)
2219             .field("RemoteAllocNumber", &self.RemoteAllocNumber)
2220             .field("LocalSocket", &self.LocalSocket)
2221             .field("ImmediateAddress", &self.ImmediateAddress)
2222             .field("RemoteNetwork", &self.RemoteNetwork)
2223             .field("RemoteNode", &self.RemoteNode)
2224             .field("RemoteSocket", &self.RemoteSocket)
2225             .field("RetransmissionCount", &self.RetransmissionCount)
2226             .field("EstimatedRoundTripDelay", &self.EstimatedRoundTripDelay)
2227             .field("RetransmittedPackets", &self.RetransmittedPackets)
2228             .field("SuppressedPacket", &self.SuppressedPacket)
2229             .finish()
2230     }
2231 }
2232 impl ::std::cmp::PartialEq for IPX_SPXCONNSTATUS_DATA {
eq(&self, other: &Self) -> bool2233     fn eq(&self, other: &Self) -> bool {
2234         self.ConnectionState == other.ConnectionState
2235             && self.WatchDogActive == other.WatchDogActive
2236             && self.LocalConnectionId == other.LocalConnectionId
2237             && self.RemoteConnectionId == other.RemoteConnectionId
2238             && self.LocalSequenceNumber == other.LocalSequenceNumber
2239             && self.LocalAckNumber == other.LocalAckNumber
2240             && self.LocalAllocNumber == other.LocalAllocNumber
2241             && self.RemoteAckNumber == other.RemoteAckNumber
2242             && self.RemoteAllocNumber == other.RemoteAllocNumber
2243             && self.LocalSocket == other.LocalSocket
2244             && self.ImmediateAddress == other.ImmediateAddress
2245             && self.RemoteNetwork == other.RemoteNetwork
2246             && self.RemoteNode == other.RemoteNode
2247             && self.RemoteSocket == other.RemoteSocket
2248             && self.RetransmissionCount == other.RetransmissionCount
2249             && self.EstimatedRoundTripDelay == other.EstimatedRoundTripDelay
2250             && self.RetransmittedPackets == other.RetransmittedPackets
2251             && self.SuppressedPacket == other.SuppressedPacket
2252     }
2253 }
2254 impl ::std::cmp::Eq for IPX_SPXCONNSTATUS_DATA {}
2255 unsafe impl ::windows::runtime::Abi for IPX_SPXCONNSTATUS_DATA {
2256     type Abi = Self;
2257     type DefaultType = Self;
2258 }
2259 pub const IPX_SPXGETCONNECTIONSTATUS: u32 = 16395u32;
2260 pub const IPX_STOPFILTERPTYPE: u32 = 16387u32;
2261 pub const IP_ADD_IFLIST: u32 = 29u32;
2262 pub const IP_ADD_MEMBERSHIP: u32 = 12u32;
2263 pub const IP_ADD_SOURCE_MEMBERSHIP: u32 = 15u32;
2264 pub const IP_BLOCK_SOURCE: u32 = 17u32;
2265 pub const IP_DEFAULT_MULTICAST_LOOP: u32 = 1u32;
2266 pub const IP_DEFAULT_MULTICAST_TTL: u32 = 1u32;
2267 pub const IP_DEL_IFLIST: u32 = 30u32;
2268 pub const IP_DONTFRAGMENT: u32 = 14u32;
2269 pub const IP_DROP_MEMBERSHIP: u32 = 13u32;
2270 pub const IP_DROP_SOURCE_MEMBERSHIP: u32 = 16u32;
2271 pub const IP_ECN: u32 = 50u32;
2272 pub const IP_GET_IFLIST: u32 = 33u32;
2273 pub const IP_HDRINCL: u32 = 2u32;
2274 pub const IP_HOPLIMIT: u32 = 21u32;
2275 pub const IP_IFLIST: u32 = 28u32;
2276 pub const IP_MAX_MEMBERSHIPS: u32 = 20u32;
2277 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2278 #[repr(C)]
2279 pub struct IP_MREQ {
2280     pub imr_multiaddr: IN_ADDR,
2281     pub imr_interface: IN_ADDR,
2282 }
2283 impl IP_MREQ {}
2284 impl ::std::default::Default for IP_MREQ {
default() -> Self2285     fn default() -> Self {
2286         unsafe { ::std::mem::zeroed() }
2287     }
2288 }
2289 impl ::std::cmp::PartialEq for IP_MREQ {
eq(&self, _other: &Self) -> bool2290     fn eq(&self, _other: &Self) -> bool {
2291         unimplemented!()
2292     }
2293 }
2294 impl ::std::cmp::Eq for IP_MREQ {}
2295 unsafe impl ::windows::runtime::Abi for IP_MREQ {
2296     type Abi = Self;
2297     type DefaultType = Self;
2298 }
2299 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2300 #[repr(C)]
2301 pub struct IP_MREQ_SOURCE {
2302     pub imr_multiaddr: IN_ADDR,
2303     pub imr_sourceaddr: IN_ADDR,
2304     pub imr_interface: IN_ADDR,
2305 }
2306 impl IP_MREQ_SOURCE {}
2307 impl ::std::default::Default for IP_MREQ_SOURCE {
default() -> Self2308     fn default() -> Self {
2309         unsafe { ::std::mem::zeroed() }
2310     }
2311 }
2312 impl ::std::cmp::PartialEq for IP_MREQ_SOURCE {
eq(&self, _other: &Self) -> bool2313     fn eq(&self, _other: &Self) -> bool {
2314         unimplemented!()
2315     }
2316 }
2317 impl ::std::cmp::Eq for IP_MREQ_SOURCE {}
2318 unsafe impl ::windows::runtime::Abi for IP_MREQ_SOURCE {
2319     type Abi = Self;
2320     type DefaultType = Self;
2321 }
2322 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2323 #[repr(C)]
2324 pub struct IP_MSFILTER {
2325     pub imsf_multiaddr: IN_ADDR,
2326     pub imsf_interface: IN_ADDR,
2327     pub imsf_fmode: MULTICAST_MODE_TYPE,
2328     pub imsf_numsrc: u32,
2329     pub imsf_slist: [IN_ADDR; 1],
2330 }
2331 impl IP_MSFILTER {}
2332 impl ::std::default::Default for IP_MSFILTER {
default() -> Self2333     fn default() -> Self {
2334         unsafe { ::std::mem::zeroed() }
2335     }
2336 }
2337 impl ::std::cmp::PartialEq for IP_MSFILTER {
eq(&self, _other: &Self) -> bool2338     fn eq(&self, _other: &Self) -> bool {
2339         unimplemented!()
2340     }
2341 }
2342 impl ::std::cmp::Eq for IP_MSFILTER {}
2343 unsafe impl ::windows::runtime::Abi for IP_MSFILTER {
2344     type Abi = Self;
2345     type DefaultType = Self;
2346 }
2347 pub const IP_MTU: u32 = 73u32;
2348 pub const IP_MTU_DISCOVER: u32 = 71u32;
2349 pub const IP_MULTICAST_IF: u32 = 9u32;
2350 pub const IP_MULTICAST_LOOP: u32 = 11u32;
2351 pub const IP_MULTICAST_TTL: u32 = 10u32;
2352 pub const IP_NRT_INTERFACE: u32 = 74u32;
2353 pub const IP_OPTIONS: u32 = 1u32;
2354 pub const IP_ORIGINAL_ARRIVAL_IF: u32 = 47u32;
2355 pub const IP_PKTINFO: u32 = 19u32;
2356 pub const IP_PKTINFO_EX: u32 = 51u32;
2357 pub const IP_PROTECTION_LEVEL: u32 = 23u32;
2358 pub const IP_RECEIVE_BROADCAST: u32 = 22u32;
2359 pub const IP_RECVDSTADDR: u32 = 25u32;
2360 pub const IP_RECVECN: u32 = 50u32;
2361 pub const IP_RECVERR: u32 = 75u32;
2362 pub const IP_RECVIF: u32 = 24u32;
2363 pub const IP_RECVRTHDR: u32 = 38u32;
2364 pub const IP_RECVTCLASS: u32 = 40u32;
2365 pub const IP_RECVTOS: u32 = 40u32;
2366 pub const IP_RECVTTL: u32 = 21u32;
2367 pub const IP_RTHDR: u32 = 32u32;
2368 pub const IP_TCLASS: u32 = 39u32;
2369 pub const IP_TOS: u32 = 3u32;
2370 pub const IP_TTL: u32 = 4u32;
2371 pub const IP_UNBLOCK_SOURCE: u32 = 18u32;
2372 pub const IP_UNICAST_IF: u32 = 31u32;
2373 pub const IP_UNSPECIFIED_HOP_LIMIT: i32 = -1i32;
2374 pub const IP_UNSPECIFIED_TYPE_OF_SERVICE: i32 = -1i32;
2375 pub const IP_UNSPECIFIED_USER_MTU: u32 = 4294967295u32;
2376 pub const IP_USER_MTU: u32 = 76u32;
2377 pub const IP_WFP_REDIRECT_CONTEXT: u32 = 70u32;
2378 pub const IP_WFP_REDIRECT_RECORDS: u32 = 60u32;
2379 pub const IRDA_PROTO_SOCK_STREAM: u32 = 1u32;
2380 pub const IRLMP_9WIRE_MODE: u32 = 22u32;
2381 pub const IRLMP_DISCOVERY_MODE: u32 = 25u32;
2382 pub const IRLMP_ENUMDEVICES: u32 = 16u32;
2383 pub const IRLMP_EXCLUSIVE_MODE: u32 = 20u32;
2384 pub const IRLMP_IAS_QUERY: u32 = 18u32;
2385 pub const IRLMP_IAS_SET: u32 = 17u32;
2386 pub const IRLMP_IRLPT_MODE: u32 = 21u32;
2387 pub const IRLMP_PARAMETERS: u32 = 24u32;
2388 pub const IRLMP_SEND_PDU_LEN: u32 = 19u32;
2389 pub const IRLMP_SHARP_MODE: u32 = 32u32;
2390 pub const IRLMP_TINYTP_MODE: u32 = 23u32;
2391 pub const ISOPROTO_CLNP: u32 = 31u32;
2392 pub const ISOPROTO_CLTP: u32 = 30u32;
2393 pub const ISOPROTO_ESIS: u32 = 34u32;
2394 pub const ISOPROTO_INACT_NL: u32 = 33u32;
2395 pub const ISOPROTO_INTRAISIS: u32 = 35u32;
2396 pub const ISOPROTO_TP: u32 = 29u32;
2397 pub const ISOPROTO_TP0: u32 = 25u32;
2398 pub const ISOPROTO_TP1: u32 = 26u32;
2399 pub const ISOPROTO_TP2: u32 = 27u32;
2400 pub const ISOPROTO_TP3: u32 = 28u32;
2401 pub const ISOPROTO_TP4: u32 = 29u32;
2402 pub const ISOPROTO_X25: u32 = 32u32;
2403 pub const ISO_EXP_DATA_NUSE: u32 = 1u32;
2404 pub const ISO_EXP_DATA_USE: u32 = 0u32;
2405 pub const ISO_HIERARCHICAL: u32 = 0u32;
2406 pub const ISO_MAX_ADDR_LENGTH: u32 = 64u32;
2407 pub const ISO_NON_HIERARCHICAL: u32 = 1u32;
2408 #[cfg(feature = "Win32_Foundation")]
2409 #[inline]
InetNtopW(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PWSTR, stringbufsize: usize) -> super::super::Foundation::PWSTR2410 pub unsafe fn InetNtopW(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PWSTR, stringbufsize: usize) -> super::super::Foundation::PWSTR {
2411     #[cfg(windows)]
2412     {
2413         #[link(name = "windows")]
2414         extern "system" {
2415             fn InetNtopW(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PWSTR, stringbufsize: usize) -> super::super::Foundation::PWSTR;
2416         }
2417         ::std::mem::transmute(InetNtopW(::std::mem::transmute(family), ::std::mem::transmute(paddr), ::std::mem::transmute(pstringbuf), ::std::mem::transmute(stringbufsize)))
2418     }
2419     #[cfg(not(windows))]
2420     unimplemented!("Unsupported target OS");
2421 }
2422 #[cfg(feature = "Win32_Foundation")]
2423 #[inline]
InetPtonW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(family: i32, pszaddrstring: Param1, paddrbuf: *mut ::std::ffi::c_void) -> i322424 pub unsafe fn InetPtonW<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(family: i32, pszaddrstring: Param1, paddrbuf: *mut ::std::ffi::c_void) -> i32 {
2425     #[cfg(windows)]
2426     {
2427         #[link(name = "windows")]
2428         extern "system" {
2429             fn InetPtonW(family: i32, pszaddrstring: super::super::Foundation::PWSTR, paddrbuf: *mut ::std::ffi::c_void) -> i32;
2430         }
2431         ::std::mem::transmute(InetPtonW(::std::mem::transmute(family), pszaddrstring.into_param().abi(), ::std::mem::transmute(paddrbuf)))
2432     }
2433     #[cfg(not(windows))]
2434     unimplemented!("Unsupported target OS");
2435 }
2436 pub const JL_BOTH: u32 = 4u32;
2437 pub const JL_RECEIVER_ONLY: u32 = 2u32;
2438 pub const JL_SENDER_ONLY: u32 = 1u32;
2439 pub const LAYERED_PROTOCOL: u32 = 0u32;
2440 pub const LITTLEENDIAN: u32 = 1u32;
2441 pub const LM_BAUD_115200: u32 = 115200u32;
2442 pub const LM_BAUD_1152K: u32 = 1152000u32;
2443 pub const LM_BAUD_1200: u32 = 1200u32;
2444 pub const LM_BAUD_16M: u32 = 16000000u32;
2445 pub const LM_BAUD_19200: u32 = 19200u32;
2446 pub const LM_BAUD_2400: u32 = 2400u32;
2447 pub const LM_BAUD_38400: u32 = 38400u32;
2448 pub const LM_BAUD_4M: u32 = 4000000u32;
2449 pub const LM_BAUD_57600: u32 = 57600u32;
2450 pub const LM_BAUD_576K: u32 = 576000u32;
2451 pub const LM_BAUD_9600: u32 = 9600u32;
2452 pub const LM_HB1_Computer: i32 = 4i32;
2453 pub const LM_HB1_Fax: i32 = 32i32;
2454 pub const LM_HB1_LANAccess: i32 = 64i32;
2455 pub const LM_HB1_Modem: i32 = 16i32;
2456 pub const LM_HB1_PDA_Palmtop: i32 = 2i32;
2457 pub const LM_HB1_PnP: i32 = 1i32;
2458 pub const LM_HB1_Printer: i32 = 8i32;
2459 pub const LM_HB2_FileServer: i32 = 2i32;
2460 pub const LM_HB2_Telephony: i32 = 1i32;
2461 pub const LM_HB_Extension: i32 = 128i32;
2462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2463 #[repr(C)]
2464 pub struct LM_IRPARMS {
2465     pub nTXDataBytes: u32,
2466     pub nRXDataBytes: u32,
2467     pub nBaudRate: u32,
2468     pub thresholdTime: u32,
2469     pub discTime: u32,
2470     pub nMSLinkTurn: u16,
2471     pub nTXPackets: u8,
2472     pub nRXPackets: u8,
2473 }
2474 impl LM_IRPARMS {}
2475 impl ::std::default::Default for LM_IRPARMS {
default() -> Self2476     fn default() -> Self {
2477         unsafe { ::std::mem::zeroed() }
2478     }
2479 }
2480 impl ::std::fmt::Debug for LM_IRPARMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2481     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2482         fmt.debug_struct("LM_IRPARMS")
2483             .field("nTXDataBytes", &self.nTXDataBytes)
2484             .field("nRXDataBytes", &self.nRXDataBytes)
2485             .field("nBaudRate", &self.nBaudRate)
2486             .field("thresholdTime", &self.thresholdTime)
2487             .field("discTime", &self.discTime)
2488             .field("nMSLinkTurn", &self.nMSLinkTurn)
2489             .field("nTXPackets", &self.nTXPackets)
2490             .field("nRXPackets", &self.nRXPackets)
2491             .finish()
2492     }
2493 }
2494 impl ::std::cmp::PartialEq for LM_IRPARMS {
eq(&self, other: &Self) -> bool2495     fn eq(&self, other: &Self) -> bool {
2496         self.nTXDataBytes == other.nTXDataBytes && self.nRXDataBytes == other.nRXDataBytes && self.nBaudRate == other.nBaudRate && self.thresholdTime == other.thresholdTime && self.discTime == other.discTime && self.nMSLinkTurn == other.nMSLinkTurn && self.nTXPackets == other.nTXPackets && self.nRXPackets == other.nRXPackets
2497     }
2498 }
2499 impl ::std::cmp::Eq for LM_IRPARMS {}
2500 unsafe impl ::windows::runtime::Abi for LM_IRPARMS {
2501     type Abi = Self;
2502     type DefaultType = Self;
2503 }
2504 pub const LOG2_BITS_PER_BYTE: u32 = 3u32;
2505 #[cfg(feature = "Win32_Foundation")]
2506 pub type LPBLOCKINGCALLBACK = unsafe extern "system" fn(dwcontext: usize) -> super::super::Foundation::BOOL;
2507 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
2508 pub type LPCONDITIONPROC = unsafe extern "system" fn(lpcallerid: *mut WSABUF, lpcallerdata: *mut WSABUF, lpsqos: *mut super::super::NetworkManagement::QoS::QOS, lpgqos: *mut super::super::NetworkManagement::QoS::QOS, lpcalleeid: *mut WSABUF, lpcalleedata: *mut WSABUF, g: *mut u32, dwcallbackdata: usize) -> i32;
2509 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2510 pub type LPFN_ACCEPTEX = unsafe extern "system" fn(slistensocket: SOCKET, sacceptsocket: SOCKET, lpoutputbuffer: *mut ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, lpdwbytesreceived: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
2511 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2512 pub type LPFN_CONNECTEX = unsafe extern "system" fn(s: SOCKET, name: *const SOCKADDR, namelen: i32, lpsendbuffer: *const ::std::ffi::c_void, dwsenddatalength: u32, lpdwbytessent: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
2513 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2514 pub type LPFN_DISCONNECTEX = unsafe extern "system" fn(s: SOCKET, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwflags: u32, dwreserved: u32) -> super::super::Foundation::BOOL;
2515 #[cfg(feature = "Win32_Foundation")]
2516 pub type LPFN_GETACCEPTEXSOCKADDRS = unsafe extern "system" fn(lpoutputbuffer: *const ::std::ffi::c_void, dwreceivedatalength: u32, dwlocaladdresslength: u32, dwremoteaddresslength: u32, localsockaddr: *mut *mut SOCKADDR, localsockaddrlength: *mut i32, remotesockaddr: *mut *mut SOCKADDR, remotesockaddrlength: *mut i32);
2517 pub type LPFN_NSPAPI = unsafe extern "system" fn() -> u32;
2518 pub type LPFN_RIOCLOSECOMPLETIONQUEUE = unsafe extern "system" fn(cq: *const RIO_CQ_t);
2519 #[cfg(feature = "Win32_Foundation")]
2520 pub type LPFN_RIOCREATECOMPLETIONQUEUE = unsafe extern "system" fn(queuesize: u32, notificationcompletion: *const RIO_NOTIFICATION_COMPLETION) -> *mut RIO_CQ_t;
2521 pub type LPFN_RIOCREATEREQUESTQUEUE = unsafe extern "system" fn(socket: SOCKET, maxoutstandingreceive: u32, maxreceivedatabuffers: u32, maxoutstandingsend: u32, maxsenddatabuffers: u32, receivecq: *const RIO_CQ_t, sendcq: *const RIO_CQ_t, socketcontext: *const ::std::ffi::c_void) -> *mut RIO_RQ_t;
2522 pub type LPFN_RIODEQUEUECOMPLETION = unsafe extern "system" fn(cq: *const RIO_CQ_t, array: *mut RIORESULT, arraysize: u32) -> u32;
2523 pub type LPFN_RIODEREGISTERBUFFER = unsafe extern "system" fn(bufferid: *const RIO_BUFFERID_t);
2524 pub type LPFN_RIONOTIFY = unsafe extern "system" fn(cq: *const RIO_CQ_t) -> i32;
2525 #[cfg(feature = "Win32_Foundation")]
2526 pub type LPFN_RIORECEIVE = unsafe extern "system" fn(socketqueue: *const RIO_RQ_t, pdata: *const RIO_BUF, databuffercount: u32, flags: u32, requestcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2527 pub type LPFN_RIORECEIVEEX = unsafe extern "system" fn(socketqueue: *const RIO_RQ_t, pdata: *const RIO_BUF, databuffercount: u32, plocaladdress: *const RIO_BUF, premoteaddress: *const RIO_BUF, pcontrolcontext: *const RIO_BUF, pflags: *const RIO_BUF, flags: u32, requestcontext: *const ::std::ffi::c_void) -> i32;
2528 #[cfg(feature = "Win32_Foundation")]
2529 pub type LPFN_RIOREGISTERBUFFER = unsafe extern "system" fn(databuffer: super::super::Foundation::PSTR, datalength: u32) -> *mut RIO_BUFFERID_t;
2530 #[cfg(feature = "Win32_Foundation")]
2531 pub type LPFN_RIORESIZECOMPLETIONQUEUE = unsafe extern "system" fn(cq: *const RIO_CQ_t, queuesize: u32) -> super::super::Foundation::BOOL;
2532 #[cfg(feature = "Win32_Foundation")]
2533 pub type LPFN_RIORESIZEREQUESTQUEUE = unsafe extern "system" fn(rq: *const RIO_RQ_t, maxoutstandingreceive: u32, maxoutstandingsend: u32) -> super::super::Foundation::BOOL;
2534 #[cfg(feature = "Win32_Foundation")]
2535 pub type LPFN_RIOSEND = unsafe extern "system" fn(socketqueue: *const RIO_RQ_t, pdata: *const RIO_BUF, databuffercount: u32, flags: u32, requestcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2536 #[cfg(feature = "Win32_Foundation")]
2537 pub type LPFN_RIOSENDEX = unsafe extern "system" fn(socketqueue: *const RIO_RQ_t, pdata: *const RIO_BUF, databuffercount: u32, plocaladdress: *const RIO_BUF, premoteaddress: *const RIO_BUF, pcontrolcontext: *const RIO_BUF, pflags: *const RIO_BUF, flags: u32, requestcontext: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
2538 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2539 pub type LPFN_TRANSMITFILE = unsafe extern "system" fn(hsocket: SOCKET, hfile: super::super::Foundation::HANDLE, nnumberofbytestowrite: u32, nnumberofbytespersend: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lptransmitbuffers: *const TRANSMIT_FILE_BUFFERS, dwreserved: u32) -> super::super::Foundation::BOOL;
2540 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2541 pub type LPFN_TRANSMITPACKETS = unsafe extern "system" fn(hsocket: SOCKET, lppacketarray: *const TRANSMIT_PACKETS_ELEMENT, nelementcount: u32, nsendsize: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwflags: u32) -> super::super::Foundation::BOOL;
2542 pub type LPFN_WSAPOLL = unsafe extern "system" fn(fdarray: *mut WSAPOLLFD, nfds: u32, timeout: i32) -> i32;
2543 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2544 pub type LPFN_WSARECVMSG = unsafe extern "system" fn(s: SOCKET, lpmsg: *mut WSAMSG, lpdwnumberofbytesrecvd: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
2545 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2546 pub type LPFN_WSASENDMSG = unsafe extern "system" fn(s: SOCKET, lpmsg: *const WSAMSG, dwflags: u32, lpnumberofbytessent: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
2547 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2548 pub type LPLOOKUPSERVICE_COMPLETION_ROUTINE = unsafe extern "system" fn(dwerror: u32, dwbytes: u32, lpoverlapped: *const super::super::System::IO::OVERLAPPED);
2549 pub type LPNSPCLEANUP = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID) -> i32;
2550 #[cfg(feature = "Win32_Foundation")]
2551 pub type LPNSPGETSERVICECLASSINFO = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpdwbufsize: *const u32, lpserviceclassinfo: *const WSASERVICECLASSINFOW) -> i32;
2552 #[cfg(feature = "Win32_Foundation")]
2553 pub type LPNSPINSTALLSERVICECLASS = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassinfo: *const WSASERVICECLASSINFOW) -> i32;
2554 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2555 pub type LPNSPIOCTL = unsafe extern "system" fn(hlookup: super::super::Foundation::HANDLE, dwcontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpcompletion: *const ::std::mem::ManuallyDrop<WSACOMPLETION>, lpthreadid: *const WSATHREADID) -> i32;
2556 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2557 pub type LPNSPLOOKUPSERVICEBEGIN = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpqsrestrictions: *const WSAQUERYSETW, lpserviceclassinfo: *const WSASERVICECLASSINFOW, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i32;
2558 #[cfg(feature = "Win32_Foundation")]
2559 pub type LPNSPLOOKUPSERVICEEND = unsafe extern "system" fn(hlookup: super::super::Foundation::HANDLE) -> i32;
2560 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2561 pub type LPNSPLOOKUPSERVICENEXT = unsafe extern "system" fn(hlookup: super::super::Foundation::HANDLE, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETW) -> i32;
2562 pub type LPNSPREMOVESERVICECLASS = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID) -> i32;
2563 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2564 pub type LPNSPSETSERVICE = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassinfo: *const WSASERVICECLASSINFOW, lpqsreginfo: *const WSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i32;
2565 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
2566 pub type LPNSPSTARTUP = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpnsproutines: *mut ::std::mem::ManuallyDrop<NSP_ROUTINE>) -> i32;
2567 pub type LPNSPV2CLEANUP = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, pvclientsessionarg: *const ::std::ffi::c_void) -> i32;
2568 pub type LPNSPV2CLIENTSESSIONRUNDOWN = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, pvclientsessionarg: *const ::std::ffi::c_void);
2569 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2570 pub type LPNSPV2LOOKUPSERVICEBEGIN = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpqsrestrictions: *const WSAQUERYSET2W, dwcontrolflags: u32, lpvclientsessionarg: *const ::std::ffi::c_void, lphlookup: *mut super::super::Foundation::HANDLE) -> i32;
2571 #[cfg(feature = "Win32_Foundation")]
2572 pub type LPNSPV2LOOKUPSERVICEEND = unsafe extern "system" fn(hlookup: super::super::Foundation::HANDLE) -> i32;
2573 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2574 pub type LPNSPV2LOOKUPSERVICENEXTEX = unsafe extern "system" fn(hasynccall: super::super::Foundation::HANDLE, hlookup: super::super::Foundation::HANDLE, dwcontrolflags: u32, lpdwbufferlength: *const u32, lpqsresults: *mut WSAQUERYSET2W);
2575 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
2576 pub type LPNSPV2SETSERVICEEX = unsafe extern "system" fn(hasynccall: super::super::Foundation::HANDLE, lpproviderid: *const ::windows::runtime::GUID, lpqsreginfo: *const WSAQUERYSET2W, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32, lpvclientsessionarg: *const ::std::ffi::c_void);
2577 pub type LPNSPV2STARTUP = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, ppvclientsessionarg: *mut *mut ::std::ffi::c_void) -> i32;
2578 #[cfg(feature = "Win32_Foundation")]
2579 pub type LPSERVICE_CALLBACK_PROC = unsafe extern "system" fn(lparam: super::super::Foundation::LPARAM, hasynctaskhandle: super::super::Foundation::HANDLE);
2580 #[cfg(feature = "Win32_Foundation")]
2581 pub type LPWPUCLOSEEVENT = unsafe extern "system" fn(hevent: super::super::Foundation::HANDLE, lperrno: *mut i32) -> super::super::Foundation::BOOL;
2582 pub type LPWPUCLOSESOCKETHANDLE = unsafe extern "system" fn(s: SOCKET, lperrno: *mut i32) -> i32;
2583 #[cfg(feature = "Win32_Foundation")]
2584 pub type LPWPUCLOSETHREAD = unsafe extern "system" fn(lpthreadid: *const WSATHREADID, lperrno: *mut i32) -> i32;
2585 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2586 pub type LPWPUCOMPLETEOVERLAPPEDREQUEST = unsafe extern "system" fn(s: SOCKET, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwerror: u32, cbtransferred: u32, lperrno: *mut i32) -> i32;
2587 #[cfg(feature = "Win32_Foundation")]
2588 pub type LPWPUCREATEEVENT = unsafe extern "system" fn(lperrno: *mut i32) -> super::super::Foundation::HANDLE;
2589 pub type LPWPUCREATESOCKETHANDLE = unsafe extern "system" fn(dwcatalogentryid: u32, dwcontext: usize, lperrno: *mut i32) -> SOCKET;
2590 pub type LPWPUFDISSET = unsafe extern "system" fn(s: SOCKET, fdset: *const fd_set) -> i32;
2591 #[cfg(feature = "Win32_Foundation")]
2592 pub type LPWPUGETPROVIDERPATH = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32;
2593 pub type LPWPUMODIFYIFSHANDLE = unsafe extern "system" fn(dwcatalogentryid: u32, proposedhandle: SOCKET, lperrno: *mut i32) -> SOCKET;
2594 #[cfg(feature = "Win32_Foundation")]
2595 pub type LPWPUOPENCURRENTTHREAD = unsafe extern "system" fn(lpthreadid: *mut WSATHREADID, lperrno: *mut i32) -> i32;
2596 #[cfg(feature = "Win32_Foundation")]
2597 pub type LPWPUPOSTMESSAGE = unsafe extern "system" fn(hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> super::super::Foundation::BOOL;
2598 #[cfg(feature = "Win32_Foundation")]
2599 pub type LPWPUQUERYBLOCKINGCALLBACK = unsafe extern "system" fn(dwcatalogentryid: u32, lplpfncallback: *mut ::windows::runtime::RawPtr, lpdwcontext: *mut usize, lperrno: *mut i32) -> i32;
2600 pub type LPWPUQUERYSOCKETHANDLECONTEXT = unsafe extern "system" fn(s: SOCKET, lpcontext: *mut usize, lperrno: *mut i32) -> i32;
2601 #[cfg(feature = "Win32_Foundation")]
2602 pub type LPWPUQUEUEAPC = unsafe extern "system" fn(lpthreadid: *const WSATHREADID, lpfnuserapc: ::windows::runtime::RawPtr, dwcontext: usize, lperrno: *mut i32) -> i32;
2603 #[cfg(feature = "Win32_Foundation")]
2604 pub type LPWPURESETEVENT = unsafe extern "system" fn(hevent: super::super::Foundation::HANDLE, lperrno: *mut i32) -> super::super::Foundation::BOOL;
2605 #[cfg(feature = "Win32_Foundation")]
2606 pub type LPWPUSETEVENT = unsafe extern "system" fn(hevent: super::super::Foundation::HANDLE, lperrno: *mut i32) -> super::super::Foundation::BOOL;
2607 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2608 pub type LPWSAOVERLAPPED_COMPLETION_ROUTINE = unsafe extern "system" fn(dwerror: u32, cbtransferred: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwflags: u32);
2609 pub type LPWSAUSERAPC = unsafe extern "system" fn(dwcontext: usize);
2610 pub type LPWSCDEINSTALLPROVIDER = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i32;
2611 #[cfg(feature = "Win32_Foundation")]
2612 pub type LPWSCENABLENSPROVIDER = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, fenable: super::super::Foundation::BOOL) -> i32;
2613 pub type LPWSCENUMPROTOCOLS = unsafe extern "system" fn(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i32;
2614 #[cfg(feature = "Win32_Foundation")]
2615 pub type LPWSCGETPROVIDERPATH = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32;
2616 #[cfg(feature = "Win32_Foundation")]
2617 pub type LPWSCINSTALLNAMESPACE = unsafe extern "system" fn(lpszidentifier: super::super::Foundation::PWSTR, lpszpathname: super::super::Foundation::PWSTR, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i32;
2618 #[cfg(feature = "Win32_Foundation")]
2619 pub type LPWSCINSTALLPROVIDER = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
2620 pub type LPWSCUNINSTALLNAMESPACE = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID) -> i32;
2621 #[cfg(feature = "Win32_Foundation")]
2622 pub type LPWSCUPDATEPROVIDER = unsafe extern "system" fn(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
2623 pub type LPWSCWRITENAMESPACEORDER = unsafe extern "system" fn(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i32;
2624 pub type LPWSCWRITEPROVIDERORDER = unsafe extern "system" fn(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i32;
2625 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
2626 pub type LPWSPACCEPT = unsafe extern "system" fn(s: SOCKET, addr: *mut SOCKADDR, addrlen: *mut i32, lpfncondition: ::windows::runtime::RawPtr, dwcallbackdata: usize, lperrno: *mut i32) -> SOCKET;
2627 #[cfg(feature = "Win32_Foundation")]
2628 pub type LPWSPADDRESSTOSTRING = unsafe extern "system" fn(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpszaddressstring: super::super::Foundation::PWSTR, lpdwaddressstringlength: *mut u32, lperrno: *mut i32) -> i32;
2629 #[cfg(feature = "Win32_Foundation")]
2630 pub type LPWSPASYNCSELECT = unsafe extern "system" fn(s: SOCKET, hwnd: super::super::Foundation::HWND, wmsg: u32, levent: i32, lperrno: *mut i32) -> i32;
2631 #[cfg(feature = "Win32_Foundation")]
2632 pub type LPWSPBIND = unsafe extern "system" fn(s: SOCKET, name: *const SOCKADDR, namelen: i32, lperrno: *mut i32) -> i32;
2633 pub type LPWSPCANCELBLOCKINGCALL = unsafe extern "system" fn(lperrno: *mut i32) -> i32;
2634 pub type LPWSPCLEANUP = unsafe extern "system" fn(lperrno: *mut i32) -> i32;
2635 pub type LPWSPCLOSESOCKET = unsafe extern "system" fn(s: SOCKET, lperrno: *mut i32) -> i32;
2636 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
2637 pub type LPWSPCONNECT = unsafe extern "system" fn(s: SOCKET, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS, lperrno: *mut i32) -> i32;
2638 pub type LPWSPDUPLICATESOCKET = unsafe extern "system" fn(s: SOCKET, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOW, lperrno: *mut i32) -> i32;
2639 #[cfg(feature = "Win32_Foundation")]
2640 pub type LPWSPENUMNETWORKEVENTS = unsafe extern "system" fn(s: SOCKET, heventobject: super::super::Foundation::HANDLE, lpnetworkevents: *mut WSANETWORKEVENTS, lperrno: *mut i32) -> i32;
2641 #[cfg(feature = "Win32_Foundation")]
2642 pub type LPWSPEVENTSELECT = unsafe extern "system" fn(s: SOCKET, heventobject: super::super::Foundation::HANDLE, lnetworkevents: i32, lperrno: *mut i32) -> i32;
2643 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2644 pub type LPWSPGETOVERLAPPEDRESULT = unsafe extern "system" fn(s: SOCKET, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcbtransfer: *mut u32, fwait: super::super::Foundation::BOOL, lpdwflags: *mut u32, lperrno: *mut i32) -> super::super::Foundation::BOOL;
2645 #[cfg(feature = "Win32_Foundation")]
2646 pub type LPWSPGETPEERNAME = unsafe extern "system" fn(s: SOCKET, name: *mut SOCKADDR, namelen: *mut i32, lperrno: *mut i32) -> i32;
2647 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
2648 pub type LPWSPGETQOSBYNAME = unsafe extern "system" fn(s: SOCKET, lpqosname: *const WSABUF, lpqos: *mut super::super::NetworkManagement::QoS::QOS, lperrno: *mut i32) -> super::super::Foundation::BOOL;
2649 #[cfg(feature = "Win32_Foundation")]
2650 pub type LPWSPGETSOCKNAME = unsafe extern "system" fn(s: SOCKET, name: *mut SOCKADDR, namelen: *mut i32, lperrno: *mut i32) -> i32;
2651 #[cfg(feature = "Win32_Foundation")]
2652 pub type LPWSPGETSOCKOPT = unsafe extern "system" fn(s: SOCKET, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: *mut i32, lperrno: *mut i32) -> i32;
2653 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2654 pub type LPWSPIOCTL = unsafe extern "system" fn(s: SOCKET, dwiocontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpthreadid: *const WSATHREADID, lperrno: *mut i32) -> i32;
2655 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
2656 pub type LPWSPJOINLEAF = unsafe extern "system" fn(s: SOCKET, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS, dwflags: u32, lperrno: *mut i32) -> SOCKET;
2657 pub type LPWSPLISTEN = unsafe extern "system" fn(s: SOCKET, backlog: i32, lperrno: *mut i32) -> i32;
2658 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2659 pub type LPWSPRECV = unsafe extern "system" fn(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpthreadid: *const WSATHREADID, lperrno: *const i32) -> i32;
2660 #[cfg(feature = "Win32_Foundation")]
2661 pub type LPWSPRECVDISCONNECT = unsafe extern "system" fn(s: SOCKET, lpinbounddisconnectdata: *const WSABUF, lperrno: *mut i32) -> i32;
2662 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2663 pub type LPWSPRECVFROM = unsafe extern "system" fn(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpfrom: *mut SOCKADDR, lpfromlen: *mut i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpthreadid: *const WSATHREADID, lperrno: *mut i32) -> i32;
2664 pub type LPWSPSELECT = unsafe extern "system" fn(nfds: i32, readfds: *mut fd_set, writefds: *mut fd_set, exceptfds: *mut fd_set, timeout: *const timeval, lperrno: *mut i32) -> i32;
2665 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2666 pub type LPWSPSEND = unsafe extern "system" fn(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpthreadid: *const WSATHREADID, lperrno: *mut i32) -> i32;
2667 #[cfg(feature = "Win32_Foundation")]
2668 pub type LPWSPSENDDISCONNECT = unsafe extern "system" fn(s: SOCKET, lpoutbounddisconnectdata: *const WSABUF, lperrno: *mut i32) -> i32;
2669 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
2670 pub type LPWSPSENDTO = unsafe extern "system" fn(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpto: *const SOCKADDR, itolen: i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpthreadid: *const WSATHREADID, lperrno: *mut i32) -> i32;
2671 #[cfg(feature = "Win32_Foundation")]
2672 pub type LPWSPSETSOCKOPT = unsafe extern "system" fn(s: SOCKET, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: i32, lperrno: *mut i32) -> i32;
2673 pub type LPWSPSHUTDOWN = unsafe extern "system" fn(s: SOCKET, how: i32, lperrno: *mut i32) -> i32;
2674 pub type LPWSPSOCKET = unsafe extern "system" fn(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, g: u32, dwflags: u32, lperrno: *mut i32) -> SOCKET;
2675 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
2676 pub type LPWSPSTARTUP = unsafe extern "system" fn(wversionrequested: u16, lpwspdata: *const WSPData, lpprotocolinfo: *const WSAPROTOCOL_INFOW, upcalltable: ::std::mem::ManuallyDrop<WSPUPCALLTABLE>, lpproctable: *mut ::std::mem::ManuallyDrop<WSPPROC_TABLE>) -> i32;
2677 #[cfg(feature = "Win32_Foundation")]
2678 pub type LPWSPSTRINGTOADDRESS = unsafe extern "system" fn(addressstring: super::super::Foundation::PWSTR, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32, lperrno: *mut i32) -> i32;
2679 pub const LSP_CRYPTO_COMPRESS: u32 = 64u32;
2680 pub const LSP_FIREWALL: u32 = 8u32;
2681 pub const LSP_INBOUND_MODIFY: u32 = 16u32;
2682 pub const LSP_INSPECTOR: u32 = 1u32;
2683 pub const LSP_LOCAL_CACHE: u32 = 128u32;
2684 pub const LSP_OUTBOUND_MODIFY: u32 = 32u32;
2685 pub const LSP_PROXY: u32 = 4u32;
2686 pub const LSP_REDIRECTOR: u32 = 2u32;
2687 pub const LSP_SYSTEM: u32 = 2147483648u32;
2688 pub const LUP_ADDRCONFIG: u32 = 1048576u32;
2689 pub const LUP_API_ANSI: u32 = 16777216u32;
2690 pub const LUP_CONTAINERS: u32 = 2u32;
2691 pub const LUP_DEEP: u32 = 1u32;
2692 pub const LUP_DISABLE_IDN_ENCODING: u32 = 8388608u32;
2693 pub const LUP_DNS_ONLY: u32 = 131072u32;
2694 pub const LUP_DUAL_ADDR: u32 = 2097152u32;
2695 pub const LUP_EXCLUSIVE_CUSTOM_SERVERS: u32 = 134217728u32;
2696 pub const LUP_EXTENDED_QUERYSET: u32 = 33554432u32;
2697 pub const LUP_FILESERVER: u32 = 4194304u32;
2698 pub const LUP_FLUSHCACHE: u32 = 4096u32;
2699 pub const LUP_FLUSHPREVIOUS: u32 = 8192u32;
2700 pub const LUP_FORCE_CLEAR_TEXT: u32 = 1073741824u32;
2701 pub const LUP_NEAREST: u32 = 8u32;
2702 pub const LUP_NOCONTAINERS: u32 = 4u32;
2703 pub const LUP_NON_AUTHORITATIVE: u32 = 16384u32;
2704 pub const LUP_REQUIRE_SECURE: u32 = 268435456u32;
2705 pub const LUP_RESOLUTION_HANDLE: u32 = 2147483648u32;
2706 pub const LUP_RES_SERVICE: u32 = 32768u32;
2707 pub const LUP_RETURN_ADDR: u32 = 256u32;
2708 pub const LUP_RETURN_ALIASES: u32 = 1024u32;
2709 pub const LUP_RETURN_ALL: u32 = 4080u32;
2710 pub const LUP_RETURN_BLOB: u32 = 512u32;
2711 pub const LUP_RETURN_COMMENT: u32 = 128u32;
2712 pub const LUP_RETURN_NAME: u32 = 16u32;
2713 pub const LUP_RETURN_PREFERRED_NAMES: u32 = 65536u32;
2714 pub const LUP_RETURN_QUERY_STRING: u32 = 2048u32;
2715 pub const LUP_RETURN_RESPONSE_FLAGS: u32 = 262144u32;
2716 pub const LUP_RETURN_TTL: u32 = 536870912u32;
2717 pub const LUP_RETURN_TYPE: u32 = 32u32;
2718 pub const LUP_RETURN_VERSION: u32 = 64u32;
2719 pub const LUP_SECURE: u32 = 32768u32;
2720 pub const LUP_SECURE_WITH_FALLBACK: u32 = 67108864u32;
2721 pub const LmCharSetASCII: u32 = 0u32;
2722 pub const LmCharSetISO_8859_1: u32 = 1u32;
2723 pub const LmCharSetISO_8859_2: u32 = 2u32;
2724 pub const LmCharSetISO_8859_3: u32 = 3u32;
2725 pub const LmCharSetISO_8859_4: u32 = 4u32;
2726 pub const LmCharSetISO_8859_5: u32 = 5u32;
2727 pub const LmCharSetISO_8859_6: u32 = 6u32;
2728 pub const LmCharSetISO_8859_7: u32 = 7u32;
2729 pub const LmCharSetISO_8859_8: u32 = 8u32;
2730 pub const LmCharSetISO_8859_9: u32 = 9u32;
2731 pub const LmCharSetUNICODE: u32 = 255u32;
2732 pub const MAXGETHOSTSTRUCT: u32 = 1024u32;
2733 pub const MAX_MCAST_TTL: u32 = 255u32;
2734 pub const MAX_PROTOCOL_CHAIN: u32 = 7u32;
2735 pub const MAX_WINDOW_INCREMENT_PERCENTAGE: u32 = 25u32;
2736 pub const MCAST_BLOCK_SOURCE: u32 = 43u32;
2737 pub const MCAST_JOIN_GROUP: u32 = 41u32;
2738 pub const MCAST_JOIN_SOURCE_GROUP: u32 = 45u32;
2739 pub const MCAST_LEAVE_GROUP: u32 = 42u32;
2740 pub const MCAST_LEAVE_SOURCE_GROUP: u32 = 46u32;
2741 pub const MCAST_UNBLOCK_SOURCE: u32 = 44u32;
2742 pub const MSG_BCAST: u32 = 1024u32;
2743 pub const MSG_CTRUNC: u32 = 512u32;
2744 pub const MSG_ERRQUEUE: u32 = 4096u32;
2745 pub const MSG_INTERRUPT: u32 = 16u32;
2746 pub const MSG_MAXIOVLEN: u32 = 16u32;
2747 pub const MSG_MCAST: u32 = 2048u32;
2748 pub const MSG_PARTIAL: u32 = 32768u32;
2749 pub const MSG_PEEK: u32 = 2u32;
2750 pub const MSG_PUSH_IMMEDIATE: u32 = 32u32;
2751 pub const MSG_TRUNC: u32 = 256u32;
2752 pub const MSG_WAITALL: u32 = 8u32;
2753 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2754 #[repr(transparent)]
2755 pub struct MULTICAST_MODE_TYPE(pub i32);
2756 pub const MCAST_INCLUDE: MULTICAST_MODE_TYPE = MULTICAST_MODE_TYPE(0i32);
2757 pub const MCAST_EXCLUDE: MULTICAST_MODE_TYPE = MULTICAST_MODE_TYPE(1i32);
2758 impl ::std::convert::From<i32> for MULTICAST_MODE_TYPE {
from(value: i32) -> Self2759     fn from(value: i32) -> Self {
2760         Self(value)
2761     }
2762 }
2763 unsafe impl ::windows::runtime::Abi for MULTICAST_MODE_TYPE {
2764     type Abi = Self;
2765     type DefaultType = Self;
2766 }
2767 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2768 #[repr(C)]
2769 pub struct NAPI_DOMAIN_DESCRIPTION_BLOB {
2770     pub AuthLevel: u32,
2771     pub cchDomainName: u32,
2772     pub OffsetNextDomainDescription: u32,
2773     pub OffsetThisDomainName: u32,
2774 }
2775 impl NAPI_DOMAIN_DESCRIPTION_BLOB {}
2776 impl ::std::default::Default for NAPI_DOMAIN_DESCRIPTION_BLOB {
default() -> Self2777     fn default() -> Self {
2778         unsafe { ::std::mem::zeroed() }
2779     }
2780 }
2781 impl ::std::fmt::Debug for NAPI_DOMAIN_DESCRIPTION_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2782     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2783         fmt.debug_struct("NAPI_DOMAIN_DESCRIPTION_BLOB").field("AuthLevel", &self.AuthLevel).field("cchDomainName", &self.cchDomainName).field("OffsetNextDomainDescription", &self.OffsetNextDomainDescription).field("OffsetThisDomainName", &self.OffsetThisDomainName).finish()
2784     }
2785 }
2786 impl ::std::cmp::PartialEq for NAPI_DOMAIN_DESCRIPTION_BLOB {
eq(&self, other: &Self) -> bool2787     fn eq(&self, other: &Self) -> bool {
2788         self.AuthLevel == other.AuthLevel && self.cchDomainName == other.cchDomainName && self.OffsetNextDomainDescription == other.OffsetNextDomainDescription && self.OffsetThisDomainName == other.OffsetThisDomainName
2789     }
2790 }
2791 impl ::std::cmp::Eq for NAPI_DOMAIN_DESCRIPTION_BLOB {}
2792 unsafe impl ::windows::runtime::Abi for NAPI_DOMAIN_DESCRIPTION_BLOB {
2793     type Abi = Self;
2794     type DefaultType = Self;
2795 }
2796 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2797 #[repr(C)]
2798 pub struct NAPI_PROVIDER_INSTALLATION_BLOB {
2799     pub dwVersion: u32,
2800     pub dwProviderType: u32,
2801     pub fSupportsWildCard: u32,
2802     pub cDomains: u32,
2803     pub OffsetFirstDomain: u32,
2804 }
2805 impl NAPI_PROVIDER_INSTALLATION_BLOB {}
2806 impl ::std::default::Default for NAPI_PROVIDER_INSTALLATION_BLOB {
default() -> Self2807     fn default() -> Self {
2808         unsafe { ::std::mem::zeroed() }
2809     }
2810 }
2811 impl ::std::fmt::Debug for NAPI_PROVIDER_INSTALLATION_BLOB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2812     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2813         fmt.debug_struct("NAPI_PROVIDER_INSTALLATION_BLOB").field("dwVersion", &self.dwVersion).field("dwProviderType", &self.dwProviderType).field("fSupportsWildCard", &self.fSupportsWildCard).field("cDomains", &self.cDomains).field("OffsetFirstDomain", &self.OffsetFirstDomain).finish()
2814     }
2815 }
2816 impl ::std::cmp::PartialEq for NAPI_PROVIDER_INSTALLATION_BLOB {
eq(&self, other: &Self) -> bool2817     fn eq(&self, other: &Self) -> bool {
2818         self.dwVersion == other.dwVersion && self.dwProviderType == other.dwProviderType && self.fSupportsWildCard == other.fSupportsWildCard && self.cDomains == other.cDomains && self.OffsetFirstDomain == other.OffsetFirstDomain
2819     }
2820 }
2821 impl ::std::cmp::Eq for NAPI_PROVIDER_INSTALLATION_BLOB {}
2822 unsafe impl ::windows::runtime::Abi for NAPI_PROVIDER_INSTALLATION_BLOB {
2823     type Abi = Self;
2824     type DefaultType = Self;
2825 }
2826 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2827 #[repr(transparent)]
2828 pub struct NAPI_PROVIDER_LEVEL(pub i32);
2829 pub const ProviderLevel_None: NAPI_PROVIDER_LEVEL = NAPI_PROVIDER_LEVEL(0i32);
2830 pub const ProviderLevel_Secondary: NAPI_PROVIDER_LEVEL = NAPI_PROVIDER_LEVEL(1i32);
2831 pub const ProviderLevel_Primary: NAPI_PROVIDER_LEVEL = NAPI_PROVIDER_LEVEL(2i32);
2832 impl ::std::convert::From<i32> for NAPI_PROVIDER_LEVEL {
from(value: i32) -> Self2833     fn from(value: i32) -> Self {
2834         Self(value)
2835     }
2836 }
2837 unsafe impl ::windows::runtime::Abi for NAPI_PROVIDER_LEVEL {
2838     type Abi = Self;
2839     type DefaultType = Self;
2840 }
2841 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2842 #[repr(transparent)]
2843 pub struct NAPI_PROVIDER_TYPE(pub i32);
2844 pub const ProviderType_Application: NAPI_PROVIDER_TYPE = NAPI_PROVIDER_TYPE(1i32);
2845 pub const ProviderType_Service: NAPI_PROVIDER_TYPE = NAPI_PROVIDER_TYPE(2i32);
2846 impl ::std::convert::From<i32> for NAPI_PROVIDER_TYPE {
from(value: i32) -> Self2847     fn from(value: i32) -> Self {
2848         Self(value)
2849     }
2850 }
2851 unsafe impl ::windows::runtime::Abi for NAPI_PROVIDER_TYPE {
2852     type Abi = Self;
2853     type DefaultType = Self;
2854 }
2855 pub const NETBIOS_GROUP_NAME: u32 = 1u32;
2856 pub const NETBIOS_NAME_LENGTH: u32 = 16u32;
2857 pub const NETBIOS_TYPE_QUICK_GROUP: u32 = 3u32;
2858 pub const NETBIOS_TYPE_QUICK_UNIQUE: u32 = 2u32;
2859 pub const NETBIOS_UNIQUE_NAME: u32 = 0u32;
2860 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2861 #[repr(C)]
2862 #[cfg(feature = "Win32_Foundation")]
2863 pub struct NETRESOURCE2A {
2864     pub dwScope: u32,
2865     pub dwType: u32,
2866     pub dwUsage: u32,
2867     pub dwDisplayType: u32,
2868     pub lpLocalName: super::super::Foundation::PSTR,
2869     pub lpRemoteName: super::super::Foundation::PSTR,
2870     pub lpComment: super::super::Foundation::PSTR,
2871     pub ns_info: NS_INFOA,
2872     pub ServiceType: ::windows::runtime::GUID,
2873     pub dwProtocols: u32,
2874     pub lpiProtocols: *mut i32,
2875 }
2876 #[cfg(feature = "Win32_Foundation")]
2877 impl NETRESOURCE2A {}
2878 #[cfg(feature = "Win32_Foundation")]
2879 impl ::std::default::Default for NETRESOURCE2A {
default() -> Self2880     fn default() -> Self {
2881         unsafe { ::std::mem::zeroed() }
2882     }
2883 }
2884 #[cfg(feature = "Win32_Foundation")]
2885 impl ::std::fmt::Debug for NETRESOURCE2A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2886     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2887         fmt.debug_struct("NETRESOURCE2A")
2888             .field("dwScope", &self.dwScope)
2889             .field("dwType", &self.dwType)
2890             .field("dwUsage", &self.dwUsage)
2891             .field("dwDisplayType", &self.dwDisplayType)
2892             .field("lpLocalName", &self.lpLocalName)
2893             .field("lpRemoteName", &self.lpRemoteName)
2894             .field("lpComment", &self.lpComment)
2895             .field("ns_info", &self.ns_info)
2896             .field("ServiceType", &self.ServiceType)
2897             .field("dwProtocols", &self.dwProtocols)
2898             .field("lpiProtocols", &self.lpiProtocols)
2899             .finish()
2900     }
2901 }
2902 #[cfg(feature = "Win32_Foundation")]
2903 impl ::std::cmp::PartialEq for NETRESOURCE2A {
eq(&self, other: &Self) -> bool2904     fn eq(&self, other: &Self) -> bool {
2905         self.dwScope == other.dwScope && self.dwType == other.dwType && self.dwUsage == other.dwUsage && self.dwDisplayType == other.dwDisplayType && self.lpLocalName == other.lpLocalName && self.lpRemoteName == other.lpRemoteName && self.lpComment == other.lpComment && self.ns_info == other.ns_info && self.ServiceType == other.ServiceType && self.dwProtocols == other.dwProtocols && self.lpiProtocols == other.lpiProtocols
2906     }
2907 }
2908 #[cfg(feature = "Win32_Foundation")]
2909 impl ::std::cmp::Eq for NETRESOURCE2A {}
2910 #[cfg(feature = "Win32_Foundation")]
2911 unsafe impl ::windows::runtime::Abi for NETRESOURCE2A {
2912     type Abi = Self;
2913     type DefaultType = Self;
2914 }
2915 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2916 #[repr(C)]
2917 #[cfg(feature = "Win32_Foundation")]
2918 pub struct NETRESOURCE2W {
2919     pub dwScope: u32,
2920     pub dwType: u32,
2921     pub dwUsage: u32,
2922     pub dwDisplayType: u32,
2923     pub lpLocalName: super::super::Foundation::PWSTR,
2924     pub lpRemoteName: super::super::Foundation::PWSTR,
2925     pub lpComment: super::super::Foundation::PWSTR,
2926     pub ns_info: NS_INFOA,
2927     pub ServiceType: ::windows::runtime::GUID,
2928     pub dwProtocols: u32,
2929     pub lpiProtocols: *mut i32,
2930 }
2931 #[cfg(feature = "Win32_Foundation")]
2932 impl NETRESOURCE2W {}
2933 #[cfg(feature = "Win32_Foundation")]
2934 impl ::std::default::Default for NETRESOURCE2W {
default() -> Self2935     fn default() -> Self {
2936         unsafe { ::std::mem::zeroed() }
2937     }
2938 }
2939 #[cfg(feature = "Win32_Foundation")]
2940 impl ::std::fmt::Debug for NETRESOURCE2W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2941     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2942         fmt.debug_struct("NETRESOURCE2W")
2943             .field("dwScope", &self.dwScope)
2944             .field("dwType", &self.dwType)
2945             .field("dwUsage", &self.dwUsage)
2946             .field("dwDisplayType", &self.dwDisplayType)
2947             .field("lpLocalName", &self.lpLocalName)
2948             .field("lpRemoteName", &self.lpRemoteName)
2949             .field("lpComment", &self.lpComment)
2950             .field("ns_info", &self.ns_info)
2951             .field("ServiceType", &self.ServiceType)
2952             .field("dwProtocols", &self.dwProtocols)
2953             .field("lpiProtocols", &self.lpiProtocols)
2954             .finish()
2955     }
2956 }
2957 #[cfg(feature = "Win32_Foundation")]
2958 impl ::std::cmp::PartialEq for NETRESOURCE2W {
eq(&self, other: &Self) -> bool2959     fn eq(&self, other: &Self) -> bool {
2960         self.dwScope == other.dwScope && self.dwType == other.dwType && self.dwUsage == other.dwUsage && self.dwDisplayType == other.dwDisplayType && self.lpLocalName == other.lpLocalName && self.lpRemoteName == other.lpRemoteName && self.lpComment == other.lpComment && self.ns_info == other.ns_info && self.ServiceType == other.ServiceType && self.dwProtocols == other.dwProtocols && self.lpiProtocols == other.lpiProtocols
2961     }
2962 }
2963 #[cfg(feature = "Win32_Foundation")]
2964 impl ::std::cmp::Eq for NETRESOURCE2W {}
2965 #[cfg(feature = "Win32_Foundation")]
2966 unsafe impl ::windows::runtime::Abi for NETRESOURCE2W {
2967     type Abi = Self;
2968     type DefaultType = Self;
2969 }
2970 pub const NI_DGRAM: u32 = 16u32;
2971 pub const NI_MAXHOST: u32 = 1025u32;
2972 pub const NI_MAXSERV: u32 = 32u32;
2973 pub const NI_NAMEREQD: u32 = 4u32;
2974 pub const NI_NOFQDN: u32 = 1u32;
2975 pub const NI_NUMERICHOST: u32 = 2u32;
2976 pub const NI_NUMERICSERV: u32 = 8u32;
2977 pub const NLA_ALLUSERS_NETWORK: u32 = 1u32;
2978 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2979 #[repr(C)]
2980 #[cfg(feature = "Win32_Foundation")]
2981 pub struct NLA_BLOB {
2982     pub header: NLA_BLOB_1,
2983     pub data: NLA_BLOB_0,
2984 }
2985 #[cfg(feature = "Win32_Foundation")]
2986 impl NLA_BLOB {}
2987 #[cfg(feature = "Win32_Foundation")]
2988 impl ::std::default::Default for NLA_BLOB {
default() -> Self2989     fn default() -> Self {
2990         unsafe { ::std::mem::zeroed() }
2991     }
2992 }
2993 #[cfg(feature = "Win32_Foundation")]
2994 impl ::std::cmp::PartialEq for NLA_BLOB {
eq(&self, _other: &Self) -> bool2995     fn eq(&self, _other: &Self) -> bool {
2996         unimplemented!()
2997     }
2998 }
2999 #[cfg(feature = "Win32_Foundation")]
3000 impl ::std::cmp::Eq for NLA_BLOB {}
3001 #[cfg(feature = "Win32_Foundation")]
3002 unsafe impl ::windows::runtime::Abi for NLA_BLOB {
3003     type Abi = Self;
3004     type DefaultType = Self;
3005 }
3006 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3007 #[repr(C)]
3008 #[cfg(feature = "Win32_Foundation")]
3009 pub union NLA_BLOB_0 {
3010     pub rawData: [super::super::Foundation::CHAR; 1],
3011     pub interfaceData: NLA_BLOB_0_2,
3012     pub locationData: NLA_BLOB_0_3,
3013     pub connectivity: NLA_BLOB_0_1,
3014     pub ICS: NLA_BLOB_0_0,
3015 }
3016 #[cfg(feature = "Win32_Foundation")]
3017 impl NLA_BLOB_0 {}
3018 #[cfg(feature = "Win32_Foundation")]
3019 impl ::std::default::Default for NLA_BLOB_0 {
default() -> Self3020     fn default() -> Self {
3021         unsafe { ::std::mem::zeroed() }
3022     }
3023 }
3024 #[cfg(feature = "Win32_Foundation")]
3025 impl ::std::cmp::PartialEq for NLA_BLOB_0 {
eq(&self, _other: &Self) -> bool3026     fn eq(&self, _other: &Self) -> bool {
3027         unimplemented!()
3028     }
3029 }
3030 #[cfg(feature = "Win32_Foundation")]
3031 impl ::std::cmp::Eq for NLA_BLOB_0 {}
3032 #[cfg(feature = "Win32_Foundation")]
3033 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0 {
3034     type Abi = Self;
3035     type DefaultType = Self;
3036 }
3037 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3038 #[repr(C)]
3039 pub struct NLA_BLOB_0_0 {
3040     pub remote: NLA_BLOB_0_0_0,
3041 }
3042 impl NLA_BLOB_0_0 {}
3043 impl ::std::default::Default for NLA_BLOB_0_0 {
default() -> Self3044     fn default() -> Self {
3045         unsafe { ::std::mem::zeroed() }
3046     }
3047 }
3048 impl ::std::fmt::Debug for NLA_BLOB_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3049     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3050         fmt.debug_struct("_ICS_e__Struct").field("remote", &self.remote).finish()
3051     }
3052 }
3053 impl ::std::cmp::PartialEq for NLA_BLOB_0_0 {
eq(&self, other: &Self) -> bool3054     fn eq(&self, other: &Self) -> bool {
3055         self.remote == other.remote
3056     }
3057 }
3058 impl ::std::cmp::Eq for NLA_BLOB_0_0 {}
3059 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0_0 {
3060     type Abi = Self;
3061     type DefaultType = Self;
3062 }
3063 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3064 #[repr(C)]
3065 pub struct NLA_BLOB_0_0_0 {
3066     pub speed: u32,
3067     pub r#type: u32,
3068     pub state: u32,
3069     pub machineName: [u16; 256],
3070     pub sharedAdapterName: [u16; 256],
3071 }
3072 impl NLA_BLOB_0_0_0 {}
3073 impl ::std::default::Default for NLA_BLOB_0_0_0 {
default() -> Self3074     fn default() -> Self {
3075         unsafe { ::std::mem::zeroed() }
3076     }
3077 }
3078 impl ::std::fmt::Debug for NLA_BLOB_0_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3079     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3080         fmt.debug_struct("_remote_e__Struct").field("speed", &self.speed).field("r#type", &self.r#type).field("state", &self.state).field("machineName", &self.machineName).field("sharedAdapterName", &self.sharedAdapterName).finish()
3081     }
3082 }
3083 impl ::std::cmp::PartialEq for NLA_BLOB_0_0_0 {
eq(&self, other: &Self) -> bool3084     fn eq(&self, other: &Self) -> bool {
3085         self.speed == other.speed && self.r#type == other.r#type && self.state == other.state && self.machineName == other.machineName && self.sharedAdapterName == other.sharedAdapterName
3086     }
3087 }
3088 impl ::std::cmp::Eq for NLA_BLOB_0_0_0 {}
3089 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0_0_0 {
3090     type Abi = Self;
3091     type DefaultType = Self;
3092 }
3093 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3094 #[repr(C)]
3095 pub struct NLA_BLOB_0_1 {
3096     pub r#type: NLA_CONNECTIVITY_TYPE,
3097     pub internet: NLA_INTERNET,
3098 }
3099 impl NLA_BLOB_0_1 {}
3100 impl ::std::default::Default for NLA_BLOB_0_1 {
default() -> Self3101     fn default() -> Self {
3102         unsafe { ::std::mem::zeroed() }
3103     }
3104 }
3105 impl ::std::fmt::Debug for NLA_BLOB_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3106     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3107         fmt.debug_struct("_connectivity_e__Struct").field("r#type", &self.r#type).field("internet", &self.internet).finish()
3108     }
3109 }
3110 impl ::std::cmp::PartialEq for NLA_BLOB_0_1 {
eq(&self, other: &Self) -> bool3111     fn eq(&self, other: &Self) -> bool {
3112         self.r#type == other.r#type && self.internet == other.internet
3113     }
3114 }
3115 impl ::std::cmp::Eq for NLA_BLOB_0_1 {}
3116 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0_1 {
3117     type Abi = Self;
3118     type DefaultType = Self;
3119 }
3120 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3121 #[repr(C)]
3122 #[cfg(feature = "Win32_Foundation")]
3123 pub struct NLA_BLOB_0_2 {
3124     pub dwType: u32,
3125     pub dwSpeed: u32,
3126     pub adapterName: [super::super::Foundation::CHAR; 1],
3127 }
3128 #[cfg(feature = "Win32_Foundation")]
3129 impl NLA_BLOB_0_2 {}
3130 #[cfg(feature = "Win32_Foundation")]
3131 impl ::std::default::Default for NLA_BLOB_0_2 {
default() -> Self3132     fn default() -> Self {
3133         unsafe { ::std::mem::zeroed() }
3134     }
3135 }
3136 #[cfg(feature = "Win32_Foundation")]
3137 impl ::std::fmt::Debug for NLA_BLOB_0_2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3138     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3139         fmt.debug_struct("_interfaceData_e__Struct").field("dwType", &self.dwType).field("dwSpeed", &self.dwSpeed).field("adapterName", &self.adapterName).finish()
3140     }
3141 }
3142 #[cfg(feature = "Win32_Foundation")]
3143 impl ::std::cmp::PartialEq for NLA_BLOB_0_2 {
eq(&self, other: &Self) -> bool3144     fn eq(&self, other: &Self) -> bool {
3145         self.dwType == other.dwType && self.dwSpeed == other.dwSpeed && self.adapterName == other.adapterName
3146     }
3147 }
3148 #[cfg(feature = "Win32_Foundation")]
3149 impl ::std::cmp::Eq for NLA_BLOB_0_2 {}
3150 #[cfg(feature = "Win32_Foundation")]
3151 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0_2 {
3152     type Abi = Self;
3153     type DefaultType = Self;
3154 }
3155 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3156 #[repr(C)]
3157 #[cfg(feature = "Win32_Foundation")]
3158 pub struct NLA_BLOB_0_3 {
3159     pub information: [super::super::Foundation::CHAR; 1],
3160 }
3161 #[cfg(feature = "Win32_Foundation")]
3162 impl NLA_BLOB_0_3 {}
3163 #[cfg(feature = "Win32_Foundation")]
3164 impl ::std::default::Default for NLA_BLOB_0_3 {
default() -> Self3165     fn default() -> Self {
3166         unsafe { ::std::mem::zeroed() }
3167     }
3168 }
3169 #[cfg(feature = "Win32_Foundation")]
3170 impl ::std::fmt::Debug for NLA_BLOB_0_3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3171     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3172         fmt.debug_struct("_locationData_e__Struct").field("information", &self.information).finish()
3173     }
3174 }
3175 #[cfg(feature = "Win32_Foundation")]
3176 impl ::std::cmp::PartialEq for NLA_BLOB_0_3 {
eq(&self, other: &Self) -> bool3177     fn eq(&self, other: &Self) -> bool {
3178         self.information == other.information
3179     }
3180 }
3181 #[cfg(feature = "Win32_Foundation")]
3182 impl ::std::cmp::Eq for NLA_BLOB_0_3 {}
3183 #[cfg(feature = "Win32_Foundation")]
3184 unsafe impl ::windows::runtime::Abi for NLA_BLOB_0_3 {
3185     type Abi = Self;
3186     type DefaultType = Self;
3187 }
3188 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3189 #[repr(C)]
3190 pub struct NLA_BLOB_1 {
3191     pub r#type: NLA_BLOB_DATA_TYPE,
3192     pub dwSize: u32,
3193     pub nextOffset: u32,
3194 }
3195 impl NLA_BLOB_1 {}
3196 impl ::std::default::Default for NLA_BLOB_1 {
default() -> Self3197     fn default() -> Self {
3198         unsafe { ::std::mem::zeroed() }
3199     }
3200 }
3201 impl ::std::fmt::Debug for NLA_BLOB_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3202     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3203         fmt.debug_struct("_header_e__Struct").field("r#type", &self.r#type).field("dwSize", &self.dwSize).field("nextOffset", &self.nextOffset).finish()
3204     }
3205 }
3206 impl ::std::cmp::PartialEq for NLA_BLOB_1 {
eq(&self, other: &Self) -> bool3207     fn eq(&self, other: &Self) -> bool {
3208         self.r#type == other.r#type && self.dwSize == other.dwSize && self.nextOffset == other.nextOffset
3209     }
3210 }
3211 impl ::std::cmp::Eq for NLA_BLOB_1 {}
3212 unsafe impl ::windows::runtime::Abi for NLA_BLOB_1 {
3213     type Abi = Self;
3214     type DefaultType = Self;
3215 }
3216 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3217 #[repr(transparent)]
3218 pub struct NLA_BLOB_DATA_TYPE(pub i32);
3219 pub const NLA_RAW_DATA: NLA_BLOB_DATA_TYPE = NLA_BLOB_DATA_TYPE(0i32);
3220 pub const NLA_INTERFACE: NLA_BLOB_DATA_TYPE = NLA_BLOB_DATA_TYPE(1i32);
3221 pub const NLA_802_1X_LOCATION: NLA_BLOB_DATA_TYPE = NLA_BLOB_DATA_TYPE(2i32);
3222 pub const NLA_CONNECTIVITY: NLA_BLOB_DATA_TYPE = NLA_BLOB_DATA_TYPE(3i32);
3223 pub const NLA_ICS: NLA_BLOB_DATA_TYPE = NLA_BLOB_DATA_TYPE(4i32);
3224 impl ::std::convert::From<i32> for NLA_BLOB_DATA_TYPE {
from(value: i32) -> Self3225     fn from(value: i32) -> Self {
3226         Self(value)
3227     }
3228 }
3229 unsafe impl ::windows::runtime::Abi for NLA_BLOB_DATA_TYPE {
3230     type Abi = Self;
3231     type DefaultType = Self;
3232 }
3233 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3234 #[repr(transparent)]
3235 pub struct NLA_CONNECTIVITY_TYPE(pub i32);
3236 pub const NLA_NETWORK_AD_HOC: NLA_CONNECTIVITY_TYPE = NLA_CONNECTIVITY_TYPE(0i32);
3237 pub const NLA_NETWORK_MANAGED: NLA_CONNECTIVITY_TYPE = NLA_CONNECTIVITY_TYPE(1i32);
3238 pub const NLA_NETWORK_UNMANAGED: NLA_CONNECTIVITY_TYPE = NLA_CONNECTIVITY_TYPE(2i32);
3239 pub const NLA_NETWORK_UNKNOWN: NLA_CONNECTIVITY_TYPE = NLA_CONNECTIVITY_TYPE(3i32);
3240 impl ::std::convert::From<i32> for NLA_CONNECTIVITY_TYPE {
from(value: i32) -> Self3241     fn from(value: i32) -> Self {
3242         Self(value)
3243     }
3244 }
3245 unsafe impl ::windows::runtime::Abi for NLA_CONNECTIVITY_TYPE {
3246     type Abi = Self;
3247     type DefaultType = Self;
3248 }
3249 pub const NLA_FRIENDLY_NAME: u32 = 2u32;
3250 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3251 #[repr(transparent)]
3252 pub struct NLA_INTERNET(pub i32);
3253 pub const NLA_INTERNET_UNKNOWN: NLA_INTERNET = NLA_INTERNET(0i32);
3254 pub const NLA_INTERNET_NO: NLA_INTERNET = NLA_INTERNET(1i32);
3255 pub const NLA_INTERNET_YES: NLA_INTERNET = NLA_INTERNET(2i32);
3256 impl ::std::convert::From<i32> for NLA_INTERNET {
from(value: i32) -> Self3257     fn from(value: i32) -> Self {
3258         Self(value)
3259     }
3260 }
3261 unsafe impl ::windows::runtime::Abi for NLA_INTERNET {
3262     type Abi = Self;
3263     type DefaultType = Self;
3264 }
3265 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3266 #[repr(transparent)]
3267 pub struct NL_ADDRESS_TYPE(pub i32);
3268 pub const NlatUnspecified: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(0i32);
3269 pub const NlatUnicast: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(1i32);
3270 pub const NlatAnycast: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(2i32);
3271 pub const NlatMulticast: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(3i32);
3272 pub const NlatBroadcast: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(4i32);
3273 pub const NlatInvalid: NL_ADDRESS_TYPE = NL_ADDRESS_TYPE(5i32);
3274 impl ::std::convert::From<i32> for NL_ADDRESS_TYPE {
from(value: i32) -> Self3275     fn from(value: i32) -> Self {
3276         Self(value)
3277     }
3278 }
3279 unsafe impl ::windows::runtime::Abi for NL_ADDRESS_TYPE {
3280     type Abi = Self;
3281     type DefaultType = Self;
3282 }
3283 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3284 #[repr(transparent)]
3285 pub struct NL_BANDWIDTH_FLAG(pub i32);
3286 pub const NlbwDisabled: NL_BANDWIDTH_FLAG = NL_BANDWIDTH_FLAG(0i32);
3287 pub const NlbwEnabled: NL_BANDWIDTH_FLAG = NL_BANDWIDTH_FLAG(1i32);
3288 pub const NlbwUnchanged: NL_BANDWIDTH_FLAG = NL_BANDWIDTH_FLAG(-1i32);
3289 impl ::std::convert::From<i32> for NL_BANDWIDTH_FLAG {
from(value: i32) -> Self3290     fn from(value: i32) -> Self {
3291         Self(value)
3292     }
3293 }
3294 unsafe impl ::windows::runtime::Abi for NL_BANDWIDTH_FLAG {
3295     type Abi = Self;
3296     type DefaultType = Self;
3297 }
3298 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3299 #[repr(C)]
3300 #[cfg(feature = "Win32_Foundation")]
3301 pub struct NL_BANDWIDTH_INFORMATION {
3302     pub Bandwidth: u64,
3303     pub Instability: u64,
3304     pub BandwidthPeaked: super::super::Foundation::BOOLEAN,
3305 }
3306 #[cfg(feature = "Win32_Foundation")]
3307 impl NL_BANDWIDTH_INFORMATION {}
3308 #[cfg(feature = "Win32_Foundation")]
3309 impl ::std::default::Default for NL_BANDWIDTH_INFORMATION {
default() -> Self3310     fn default() -> Self {
3311         unsafe { ::std::mem::zeroed() }
3312     }
3313 }
3314 #[cfg(feature = "Win32_Foundation")]
3315 impl ::std::fmt::Debug for NL_BANDWIDTH_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3316     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3317         fmt.debug_struct("NL_BANDWIDTH_INFORMATION").field("Bandwidth", &self.Bandwidth).field("Instability", &self.Instability).field("BandwidthPeaked", &self.BandwidthPeaked).finish()
3318     }
3319 }
3320 #[cfg(feature = "Win32_Foundation")]
3321 impl ::std::cmp::PartialEq for NL_BANDWIDTH_INFORMATION {
eq(&self, other: &Self) -> bool3322     fn eq(&self, other: &Self) -> bool {
3323         self.Bandwidth == other.Bandwidth && self.Instability == other.Instability && self.BandwidthPeaked == other.BandwidthPeaked
3324     }
3325 }
3326 #[cfg(feature = "Win32_Foundation")]
3327 impl ::std::cmp::Eq for NL_BANDWIDTH_INFORMATION {}
3328 #[cfg(feature = "Win32_Foundation")]
3329 unsafe impl ::windows::runtime::Abi for NL_BANDWIDTH_INFORMATION {
3330     type Abi = Self;
3331     type DefaultType = Self;
3332 }
3333 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3334 #[repr(transparent)]
3335 pub struct NL_DAD_STATE(pub i32);
3336 pub const NldsInvalid: NL_DAD_STATE = NL_DAD_STATE(0i32);
3337 pub const NldsTentative: NL_DAD_STATE = NL_DAD_STATE(1i32);
3338 pub const NldsDuplicate: NL_DAD_STATE = NL_DAD_STATE(2i32);
3339 pub const NldsDeprecated: NL_DAD_STATE = NL_DAD_STATE(3i32);
3340 pub const NldsPreferred: NL_DAD_STATE = NL_DAD_STATE(4i32);
3341 pub const IpDadStateInvalid: NL_DAD_STATE = NL_DAD_STATE(0i32);
3342 pub const IpDadStateTentative: NL_DAD_STATE = NL_DAD_STATE(1i32);
3343 pub const IpDadStateDuplicate: NL_DAD_STATE = NL_DAD_STATE(2i32);
3344 pub const IpDadStateDeprecated: NL_DAD_STATE = NL_DAD_STATE(3i32);
3345 pub const IpDadStatePreferred: NL_DAD_STATE = NL_DAD_STATE(4i32);
3346 impl ::std::convert::From<i32> for NL_DAD_STATE {
from(value: i32) -> Self3347     fn from(value: i32) -> Self {
3348         Self(value)
3349     }
3350 }
3351 unsafe impl ::windows::runtime::Abi for NL_DAD_STATE {
3352     type Abi = Self;
3353     type DefaultType = Self;
3354 }
3355 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3356 #[repr(transparent)]
3357 pub struct NL_INTERFACE_NETWORK_CATEGORY_STATE(pub i32);
3358 pub const NlincCategoryUnknown: NL_INTERFACE_NETWORK_CATEGORY_STATE = NL_INTERFACE_NETWORK_CATEGORY_STATE(0i32);
3359 pub const NlincPublic: NL_INTERFACE_NETWORK_CATEGORY_STATE = NL_INTERFACE_NETWORK_CATEGORY_STATE(1i32);
3360 pub const NlincPrivate: NL_INTERFACE_NETWORK_CATEGORY_STATE = NL_INTERFACE_NETWORK_CATEGORY_STATE(2i32);
3361 pub const NlincDomainAuthenticated: NL_INTERFACE_NETWORK_CATEGORY_STATE = NL_INTERFACE_NETWORK_CATEGORY_STATE(3i32);
3362 pub const NlincCategoryStateMax: NL_INTERFACE_NETWORK_CATEGORY_STATE = NL_INTERFACE_NETWORK_CATEGORY_STATE(4i32);
3363 impl ::std::convert::From<i32> for NL_INTERFACE_NETWORK_CATEGORY_STATE {
from(value: i32) -> Self3364     fn from(value: i32) -> Self {
3365         Self(value)
3366     }
3367 }
3368 unsafe impl ::windows::runtime::Abi for NL_INTERFACE_NETWORK_CATEGORY_STATE {
3369     type Abi = Self;
3370     type DefaultType = Self;
3371 }
3372 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3373 #[repr(C)]
3374 pub struct NL_INTERFACE_OFFLOAD_ROD {
3375     pub _bitfield: u8,
3376 }
3377 impl NL_INTERFACE_OFFLOAD_ROD {}
3378 impl ::std::default::Default for NL_INTERFACE_OFFLOAD_ROD {
default() -> Self3379     fn default() -> Self {
3380         unsafe { ::std::mem::zeroed() }
3381     }
3382 }
3383 impl ::std::fmt::Debug for NL_INTERFACE_OFFLOAD_ROD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3384     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3385         fmt.debug_struct("NL_INTERFACE_OFFLOAD_ROD").field("_bitfield", &self._bitfield).finish()
3386     }
3387 }
3388 impl ::std::cmp::PartialEq for NL_INTERFACE_OFFLOAD_ROD {
eq(&self, other: &Self) -> bool3389     fn eq(&self, other: &Self) -> bool {
3390         self._bitfield == other._bitfield
3391     }
3392 }
3393 impl ::std::cmp::Eq for NL_INTERFACE_OFFLOAD_ROD {}
3394 unsafe impl ::windows::runtime::Abi for NL_INTERFACE_OFFLOAD_ROD {
3395     type Abi = Self;
3396     type DefaultType = Self;
3397 }
3398 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3399 #[repr(transparent)]
3400 pub struct NL_LINK_LOCAL_ADDRESS_BEHAVIOR(pub i32);
3401 pub const LinkLocalAlwaysOff: NL_LINK_LOCAL_ADDRESS_BEHAVIOR = NL_LINK_LOCAL_ADDRESS_BEHAVIOR(0i32);
3402 pub const LinkLocalDelayed: NL_LINK_LOCAL_ADDRESS_BEHAVIOR = NL_LINK_LOCAL_ADDRESS_BEHAVIOR(1i32);
3403 pub const LinkLocalAlwaysOn: NL_LINK_LOCAL_ADDRESS_BEHAVIOR = NL_LINK_LOCAL_ADDRESS_BEHAVIOR(2i32);
3404 pub const LinkLocalUnchanged: NL_LINK_LOCAL_ADDRESS_BEHAVIOR = NL_LINK_LOCAL_ADDRESS_BEHAVIOR(-1i32);
3405 impl ::std::convert::From<i32> for NL_LINK_LOCAL_ADDRESS_BEHAVIOR {
from(value: i32) -> Self3406     fn from(value: i32) -> Self {
3407         Self(value)
3408     }
3409 }
3410 unsafe impl ::windows::runtime::Abi for NL_LINK_LOCAL_ADDRESS_BEHAVIOR {
3411     type Abi = Self;
3412     type DefaultType = Self;
3413 }
3414 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3415 #[repr(transparent)]
3416 pub struct NL_NEIGHBOR_STATE(pub i32);
3417 pub const NlnsUnreachable: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(0i32);
3418 pub const NlnsIncomplete: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(1i32);
3419 pub const NlnsProbe: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(2i32);
3420 pub const NlnsDelay: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(3i32);
3421 pub const NlnsStale: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(4i32);
3422 pub const NlnsReachable: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(5i32);
3423 pub const NlnsPermanent: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(6i32);
3424 pub const NlnsMaximum: NL_NEIGHBOR_STATE = NL_NEIGHBOR_STATE(7i32);
3425 impl ::std::convert::From<i32> for NL_NEIGHBOR_STATE {
from(value: i32) -> Self3426     fn from(value: i32) -> Self {
3427         Self(value)
3428     }
3429 }
3430 unsafe impl ::windows::runtime::Abi for NL_NEIGHBOR_STATE {
3431     type Abi = Self;
3432     type DefaultType = Self;
3433 }
3434 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3435 #[repr(transparent)]
3436 pub struct NL_NETWORK_CATEGORY(pub i32);
3437 pub const NetworkCategoryPublic: NL_NETWORK_CATEGORY = NL_NETWORK_CATEGORY(0i32);
3438 pub const NetworkCategoryPrivate: NL_NETWORK_CATEGORY = NL_NETWORK_CATEGORY(1i32);
3439 pub const NetworkCategoryDomainAuthenticated: NL_NETWORK_CATEGORY = NL_NETWORK_CATEGORY(2i32);
3440 pub const NetworkCategoryUnchanged: NL_NETWORK_CATEGORY = NL_NETWORK_CATEGORY(-1i32);
3441 pub const NetworkCategoryUnknown: NL_NETWORK_CATEGORY = NL_NETWORK_CATEGORY(-1i32);
3442 impl ::std::convert::From<i32> for NL_NETWORK_CATEGORY {
from(value: i32) -> Self3443     fn from(value: i32) -> Self {
3444         Self(value)
3445     }
3446 }
3447 unsafe impl ::windows::runtime::Abi for NL_NETWORK_CATEGORY {
3448     type Abi = Self;
3449     type DefaultType = Self;
3450 }
3451 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3452 #[repr(transparent)]
3453 pub struct NL_NETWORK_CONNECTIVITY_COST_HINT(pub i32);
3454 pub const NetworkConnectivityCostHintUnknown: NL_NETWORK_CONNECTIVITY_COST_HINT = NL_NETWORK_CONNECTIVITY_COST_HINT(0i32);
3455 pub const NetworkConnectivityCostHintUnrestricted: NL_NETWORK_CONNECTIVITY_COST_HINT = NL_NETWORK_CONNECTIVITY_COST_HINT(1i32);
3456 pub const NetworkConnectivityCostHintFixed: NL_NETWORK_CONNECTIVITY_COST_HINT = NL_NETWORK_CONNECTIVITY_COST_HINT(2i32);
3457 pub const NetworkConnectivityCostHintVariable: NL_NETWORK_CONNECTIVITY_COST_HINT = NL_NETWORK_CONNECTIVITY_COST_HINT(3i32);
3458 impl ::std::convert::From<i32> for NL_NETWORK_CONNECTIVITY_COST_HINT {
from(value: i32) -> Self3459     fn from(value: i32) -> Self {
3460         Self(value)
3461     }
3462 }
3463 unsafe impl ::windows::runtime::Abi for NL_NETWORK_CONNECTIVITY_COST_HINT {
3464     type Abi = Self;
3465     type DefaultType = Self;
3466 }
3467 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3468 #[repr(C)]
3469 #[cfg(feature = "Win32_Foundation")]
3470 pub struct NL_NETWORK_CONNECTIVITY_HINT {
3471     pub ConnectivityLevel: NL_NETWORK_CONNECTIVITY_LEVEL_HINT,
3472     pub ConnectivityCost: NL_NETWORK_CONNECTIVITY_COST_HINT,
3473     pub ApproachingDataLimit: super::super::Foundation::BOOLEAN,
3474     pub OverDataLimit: super::super::Foundation::BOOLEAN,
3475     pub Roaming: super::super::Foundation::BOOLEAN,
3476 }
3477 #[cfg(feature = "Win32_Foundation")]
3478 impl NL_NETWORK_CONNECTIVITY_HINT {}
3479 #[cfg(feature = "Win32_Foundation")]
3480 impl ::std::default::Default for NL_NETWORK_CONNECTIVITY_HINT {
default() -> Self3481     fn default() -> Self {
3482         unsafe { ::std::mem::zeroed() }
3483     }
3484 }
3485 #[cfg(feature = "Win32_Foundation")]
3486 impl ::std::fmt::Debug for NL_NETWORK_CONNECTIVITY_HINT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3487     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3488         fmt.debug_struct("NL_NETWORK_CONNECTIVITY_HINT").field("ConnectivityLevel", &self.ConnectivityLevel).field("ConnectivityCost", &self.ConnectivityCost).field("ApproachingDataLimit", &self.ApproachingDataLimit).field("OverDataLimit", &self.OverDataLimit).field("Roaming", &self.Roaming).finish()
3489     }
3490 }
3491 #[cfg(feature = "Win32_Foundation")]
3492 impl ::std::cmp::PartialEq for NL_NETWORK_CONNECTIVITY_HINT {
eq(&self, other: &Self) -> bool3493     fn eq(&self, other: &Self) -> bool {
3494         self.ConnectivityLevel == other.ConnectivityLevel && self.ConnectivityCost == other.ConnectivityCost && self.ApproachingDataLimit == other.ApproachingDataLimit && self.OverDataLimit == other.OverDataLimit && self.Roaming == other.Roaming
3495     }
3496 }
3497 #[cfg(feature = "Win32_Foundation")]
3498 impl ::std::cmp::Eq for NL_NETWORK_CONNECTIVITY_HINT {}
3499 #[cfg(feature = "Win32_Foundation")]
3500 unsafe impl ::windows::runtime::Abi for NL_NETWORK_CONNECTIVITY_HINT {
3501     type Abi = Self;
3502     type DefaultType = Self;
3503 }
3504 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3505 #[repr(transparent)]
3506 pub struct NL_NETWORK_CONNECTIVITY_LEVEL_HINT(pub i32);
3507 pub const NetworkConnectivityLevelHintUnknown: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(0i32);
3508 pub const NetworkConnectivityLevelHintNone: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(1i32);
3509 pub const NetworkConnectivityLevelHintLocalAccess: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(2i32);
3510 pub const NetworkConnectivityLevelHintInternetAccess: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(3i32);
3511 pub const NetworkConnectivityLevelHintConstrainedInternetAccess: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(4i32);
3512 pub const NetworkConnectivityLevelHintHidden: NL_NETWORK_CONNECTIVITY_LEVEL_HINT = NL_NETWORK_CONNECTIVITY_LEVEL_HINT(5i32);
3513 impl ::std::convert::From<i32> for NL_NETWORK_CONNECTIVITY_LEVEL_HINT {
from(value: i32) -> Self3514     fn from(value: i32) -> Self {
3515         Self(value)
3516     }
3517 }
3518 unsafe impl ::windows::runtime::Abi for NL_NETWORK_CONNECTIVITY_LEVEL_HINT {
3519     type Abi = Self;
3520     type DefaultType = Self;
3521 }
3522 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3523 #[repr(C)]
3524 #[cfg(feature = "Win32_Foundation")]
3525 pub struct NL_PATH_BANDWIDTH_ROD {
3526     pub Bandwidth: u64,
3527     pub Instability: u64,
3528     pub BandwidthPeaked: super::super::Foundation::BOOLEAN,
3529 }
3530 #[cfg(feature = "Win32_Foundation")]
3531 impl NL_PATH_BANDWIDTH_ROD {}
3532 #[cfg(feature = "Win32_Foundation")]
3533 impl ::std::default::Default for NL_PATH_BANDWIDTH_ROD {
default() -> Self3534     fn default() -> Self {
3535         unsafe { ::std::mem::zeroed() }
3536     }
3537 }
3538 #[cfg(feature = "Win32_Foundation")]
3539 impl ::std::fmt::Debug for NL_PATH_BANDWIDTH_ROD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3540     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3541         fmt.debug_struct("NL_PATH_BANDWIDTH_ROD").field("Bandwidth", &self.Bandwidth).field("Instability", &self.Instability).field("BandwidthPeaked", &self.BandwidthPeaked).finish()
3542     }
3543 }
3544 #[cfg(feature = "Win32_Foundation")]
3545 impl ::std::cmp::PartialEq for NL_PATH_BANDWIDTH_ROD {
eq(&self, other: &Self) -> bool3546     fn eq(&self, other: &Self) -> bool {
3547         self.Bandwidth == other.Bandwidth && self.Instability == other.Instability && self.BandwidthPeaked == other.BandwidthPeaked
3548     }
3549 }
3550 #[cfg(feature = "Win32_Foundation")]
3551 impl ::std::cmp::Eq for NL_PATH_BANDWIDTH_ROD {}
3552 #[cfg(feature = "Win32_Foundation")]
3553 unsafe impl ::windows::runtime::Abi for NL_PATH_BANDWIDTH_ROD {
3554     type Abi = Self;
3555     type DefaultType = Self;
3556 }
3557 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3558 #[repr(transparent)]
3559 pub struct NL_PREFIX_ORIGIN(pub i32);
3560 pub const IpPrefixOriginOther: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(0i32);
3561 pub const IpPrefixOriginManual: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(1i32);
3562 pub const IpPrefixOriginWellKnown: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(2i32);
3563 pub const IpPrefixOriginDhcp: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(3i32);
3564 pub const IpPrefixOriginRouterAdvertisement: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(4i32);
3565 pub const IpPrefixOriginUnchanged: NL_PREFIX_ORIGIN = NL_PREFIX_ORIGIN(16i32);
3566 impl ::std::convert::From<i32> for NL_PREFIX_ORIGIN {
from(value: i32) -> Self3567     fn from(value: i32) -> Self {
3568         Self(value)
3569     }
3570 }
3571 unsafe impl ::windows::runtime::Abi for NL_PREFIX_ORIGIN {
3572     type Abi = Self;
3573     type DefaultType = Self;
3574 }
3575 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3576 #[repr(transparent)]
3577 pub struct NL_ROUTER_DISCOVERY_BEHAVIOR(pub i32);
3578 pub const RouterDiscoveryDisabled: NL_ROUTER_DISCOVERY_BEHAVIOR = NL_ROUTER_DISCOVERY_BEHAVIOR(0i32);
3579 pub const RouterDiscoveryEnabled: NL_ROUTER_DISCOVERY_BEHAVIOR = NL_ROUTER_DISCOVERY_BEHAVIOR(1i32);
3580 pub const RouterDiscoveryDhcp: NL_ROUTER_DISCOVERY_BEHAVIOR = NL_ROUTER_DISCOVERY_BEHAVIOR(2i32);
3581 pub const RouterDiscoveryUnchanged: NL_ROUTER_DISCOVERY_BEHAVIOR = NL_ROUTER_DISCOVERY_BEHAVIOR(-1i32);
3582 impl ::std::convert::From<i32> for NL_ROUTER_DISCOVERY_BEHAVIOR {
from(value: i32) -> Self3583     fn from(value: i32) -> Self {
3584         Self(value)
3585     }
3586 }
3587 unsafe impl ::windows::runtime::Abi for NL_ROUTER_DISCOVERY_BEHAVIOR {
3588     type Abi = Self;
3589     type DefaultType = Self;
3590 }
3591 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3592 #[repr(transparent)]
3593 pub struct NL_ROUTE_ORIGIN(pub i32);
3594 pub const NlroManual: NL_ROUTE_ORIGIN = NL_ROUTE_ORIGIN(0i32);
3595 pub const NlroWellKnown: NL_ROUTE_ORIGIN = NL_ROUTE_ORIGIN(1i32);
3596 pub const NlroDHCP: NL_ROUTE_ORIGIN = NL_ROUTE_ORIGIN(2i32);
3597 pub const NlroRouterAdvertisement: NL_ROUTE_ORIGIN = NL_ROUTE_ORIGIN(3i32);
3598 pub const Nlro6to4: NL_ROUTE_ORIGIN = NL_ROUTE_ORIGIN(4i32);
3599 impl ::std::convert::From<i32> for NL_ROUTE_ORIGIN {
from(value: i32) -> Self3600     fn from(value: i32) -> Self {
3601         Self(value)
3602     }
3603 }
3604 unsafe impl ::windows::runtime::Abi for NL_ROUTE_ORIGIN {
3605     type Abi = Self;
3606     type DefaultType = Self;
3607 }
3608 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3609 #[repr(transparent)]
3610 pub struct NL_ROUTE_PROTOCOL(pub i32);
3611 pub const RouteProtocolOther: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(1i32);
3612 pub const RouteProtocolLocal: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(2i32);
3613 pub const RouteProtocolNetMgmt: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(3i32);
3614 pub const RouteProtocolIcmp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(4i32);
3615 pub const RouteProtocolEgp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(5i32);
3616 pub const RouteProtocolGgp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(6i32);
3617 pub const RouteProtocolHello: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(7i32);
3618 pub const RouteProtocolRip: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(8i32);
3619 pub const RouteProtocolIsIs: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(9i32);
3620 pub const RouteProtocolEsIs: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10i32);
3621 pub const RouteProtocolCisco: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(11i32);
3622 pub const RouteProtocolBbn: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(12i32);
3623 pub const RouteProtocolOspf: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(13i32);
3624 pub const RouteProtocolBgp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(14i32);
3625 pub const RouteProtocolIdpr: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(15i32);
3626 pub const RouteProtocolEigrp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(16i32);
3627 pub const RouteProtocolDvmrp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(17i32);
3628 pub const RouteProtocolRpl: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(18i32);
3629 pub const RouteProtocolDhcp: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(19i32);
3630 pub const MIB_IPPROTO_OTHER: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(1i32);
3631 pub const PROTO_IP_OTHER: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(1i32);
3632 pub const MIB_IPPROTO_LOCAL: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(2i32);
3633 pub const PROTO_IP_LOCAL: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(2i32);
3634 pub const MIB_IPPROTO_NETMGMT: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(3i32);
3635 pub const PROTO_IP_NETMGMT: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(3i32);
3636 pub const MIB_IPPROTO_ICMP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(4i32);
3637 pub const PROTO_IP_ICMP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(4i32);
3638 pub const MIB_IPPROTO_EGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(5i32);
3639 pub const PROTO_IP_EGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(5i32);
3640 pub const MIB_IPPROTO_GGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(6i32);
3641 pub const PROTO_IP_GGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(6i32);
3642 pub const MIB_IPPROTO_HELLO: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(7i32);
3643 pub const PROTO_IP_HELLO: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(7i32);
3644 pub const MIB_IPPROTO_RIP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(8i32);
3645 pub const PROTO_IP_RIP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(8i32);
3646 pub const MIB_IPPROTO_IS_IS: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(9i32);
3647 pub const PROTO_IP_IS_IS: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(9i32);
3648 pub const MIB_IPPROTO_ES_IS: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10i32);
3649 pub const PROTO_IP_ES_IS: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10i32);
3650 pub const MIB_IPPROTO_CISCO: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(11i32);
3651 pub const PROTO_IP_CISCO: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(11i32);
3652 pub const MIB_IPPROTO_BBN: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(12i32);
3653 pub const PROTO_IP_BBN: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(12i32);
3654 pub const MIB_IPPROTO_OSPF: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(13i32);
3655 pub const PROTO_IP_OSPF: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(13i32);
3656 pub const MIB_IPPROTO_BGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(14i32);
3657 pub const PROTO_IP_BGP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(14i32);
3658 pub const MIB_IPPROTO_IDPR: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(15i32);
3659 pub const PROTO_IP_IDPR: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(15i32);
3660 pub const MIB_IPPROTO_EIGRP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(16i32);
3661 pub const PROTO_IP_EIGRP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(16i32);
3662 pub const MIB_IPPROTO_DVMRP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(17i32);
3663 pub const PROTO_IP_DVMRP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(17i32);
3664 pub const MIB_IPPROTO_RPL: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(18i32);
3665 pub const PROTO_IP_RPL: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(18i32);
3666 pub const MIB_IPPROTO_DHCP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(19i32);
3667 pub const PROTO_IP_DHCP: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(19i32);
3668 pub const MIB_IPPROTO_NT_AUTOSTATIC: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10002i32);
3669 pub const PROTO_IP_NT_AUTOSTATIC: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10002i32);
3670 pub const MIB_IPPROTO_NT_STATIC: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10006i32);
3671 pub const PROTO_IP_NT_STATIC: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10006i32);
3672 pub const MIB_IPPROTO_NT_STATIC_NON_DOD: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10007i32);
3673 pub const PROTO_IP_NT_STATIC_NON_DOD: NL_ROUTE_PROTOCOL = NL_ROUTE_PROTOCOL(10007i32);
3674 impl ::std::convert::From<i32> for NL_ROUTE_PROTOCOL {
from(value: i32) -> Self3675     fn from(value: i32) -> Self {
3676         Self(value)
3677     }
3678 }
3679 unsafe impl ::windows::runtime::Abi for NL_ROUTE_PROTOCOL {
3680     type Abi = Self;
3681     type DefaultType = Self;
3682 }
3683 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3684 #[repr(transparent)]
3685 pub struct NL_SUFFIX_ORIGIN(pub i32);
3686 pub const NlsoOther: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(0i32);
3687 pub const NlsoManual: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(1i32);
3688 pub const NlsoWellKnown: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(2i32);
3689 pub const NlsoDhcp: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(3i32);
3690 pub const NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(4i32);
3691 pub const NlsoRandom: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(5i32);
3692 pub const IpSuffixOriginOther: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(0i32);
3693 pub const IpSuffixOriginManual: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(1i32);
3694 pub const IpSuffixOriginWellKnown: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(2i32);
3695 pub const IpSuffixOriginDhcp: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(3i32);
3696 pub const IpSuffixOriginLinkLayerAddress: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(4i32);
3697 pub const IpSuffixOriginRandom: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(5i32);
3698 pub const IpSuffixOriginUnchanged: NL_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN(16i32);
3699 impl ::std::convert::From<i32> for NL_SUFFIX_ORIGIN {
from(value: i32) -> Self3700     fn from(value: i32) -> Self {
3701         Self(value)
3702     }
3703 }
3704 unsafe impl ::windows::runtime::Abi for NL_SUFFIX_ORIGIN {
3705     type Abi = Self;
3706     type DefaultType = Self;
3707 }
3708 pub const NSPROTO_IPX: u32 = 1000u32;
3709 pub const NSPROTO_SPX: u32 = 1256u32;
3710 pub const NSPROTO_SPXII: u32 = 1257u32;
3711 #[derive(:: std :: clone :: Clone)]
3712 #[repr(C)]
3713 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3714 pub struct NSPV2_ROUTINE {
3715     pub cbSize: u32,
3716     pub dwMajorVersion: u32,
3717     pub dwMinorVersion: u32,
3718     pub NSPv2Startup: ::std::option::Option<LPNSPV2STARTUP>,
3719     pub NSPv2Cleanup: ::std::option::Option<LPNSPV2CLEANUP>,
3720     pub NSPv2LookupServiceBegin: ::std::option::Option<LPNSPV2LOOKUPSERVICEBEGIN>,
3721     pub NSPv2LookupServiceNextEx: ::std::option::Option<LPNSPV2LOOKUPSERVICENEXTEX>,
3722     pub NSPv2LookupServiceEnd: ::std::option::Option<LPNSPV2LOOKUPSERVICEEND>,
3723     pub NSPv2SetServiceEx: ::std::option::Option<LPNSPV2SETSERVICEEX>,
3724     pub NSPv2ClientSessionRundown: ::std::option::Option<LPNSPV2CLIENTSESSIONRUNDOWN>,
3725 }
3726 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3727 impl NSPV2_ROUTINE {}
3728 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3729 impl ::std::default::Default for NSPV2_ROUTINE {
default() -> Self3730     fn default() -> Self {
3731         unsafe { ::std::mem::zeroed() }
3732     }
3733 }
3734 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3735 impl ::std::fmt::Debug for NSPV2_ROUTINE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3736     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3737         fmt.debug_struct("NSPV2_ROUTINE").field("cbSize", &self.cbSize).field("dwMajorVersion", &self.dwMajorVersion).field("dwMinorVersion", &self.dwMinorVersion).finish()
3738     }
3739 }
3740 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3741 impl ::std::cmp::PartialEq for NSPV2_ROUTINE {
eq(&self, other: &Self) -> bool3742     fn eq(&self, other: &Self) -> bool {
3743         self.cbSize == other.cbSize
3744             && self.dwMajorVersion == other.dwMajorVersion
3745             && self.dwMinorVersion == other.dwMinorVersion
3746             && self.NSPv2Startup.map(|f| f as usize) == other.NSPv2Startup.map(|f| f as usize)
3747             && self.NSPv2Cleanup.map(|f| f as usize) == other.NSPv2Cleanup.map(|f| f as usize)
3748             && self.NSPv2LookupServiceBegin.map(|f| f as usize) == other.NSPv2LookupServiceBegin.map(|f| f as usize)
3749             && self.NSPv2LookupServiceNextEx.map(|f| f as usize) == other.NSPv2LookupServiceNextEx.map(|f| f as usize)
3750             && self.NSPv2LookupServiceEnd.map(|f| f as usize) == other.NSPv2LookupServiceEnd.map(|f| f as usize)
3751             && self.NSPv2SetServiceEx.map(|f| f as usize) == other.NSPv2SetServiceEx.map(|f| f as usize)
3752             && self.NSPv2ClientSessionRundown.map(|f| f as usize) == other.NSPv2ClientSessionRundown.map(|f| f as usize)
3753     }
3754 }
3755 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3756 impl ::std::cmp::Eq for NSPV2_ROUTINE {}
3757 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3758 unsafe impl ::windows::runtime::Abi for NSPV2_ROUTINE {
3759     type Abi = ::std::mem::ManuallyDrop<Self>;
3760     type DefaultType = Self;
3761 }
3762 #[derive(:: std :: clone :: Clone)]
3763 #[repr(C)]
3764 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3765 pub struct NSP_ROUTINE {
3766     pub cbSize: u32,
3767     pub dwMajorVersion: u32,
3768     pub dwMinorVersion: u32,
3769     pub NSPCleanup: ::std::option::Option<LPNSPCLEANUP>,
3770     pub NSPLookupServiceBegin: ::std::option::Option<LPNSPLOOKUPSERVICEBEGIN>,
3771     pub NSPLookupServiceNext: ::std::option::Option<LPNSPLOOKUPSERVICENEXT>,
3772     pub NSPLookupServiceEnd: ::std::option::Option<LPNSPLOOKUPSERVICEEND>,
3773     pub NSPSetService: ::std::option::Option<LPNSPSETSERVICE>,
3774     pub NSPInstallServiceClass: ::std::option::Option<LPNSPINSTALLSERVICECLASS>,
3775     pub NSPRemoveServiceClass: ::std::option::Option<LPNSPREMOVESERVICECLASS>,
3776     pub NSPGetServiceClassInfo: ::std::option::Option<LPNSPGETSERVICECLASSINFO>,
3777     pub NSPIoctl: ::std::option::Option<LPNSPIOCTL>,
3778 }
3779 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3780 impl NSP_ROUTINE {}
3781 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3782 impl ::std::default::Default for NSP_ROUTINE {
default() -> Self3783     fn default() -> Self {
3784         unsafe { ::std::mem::zeroed() }
3785     }
3786 }
3787 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3788 impl ::std::fmt::Debug for NSP_ROUTINE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3789     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3790         fmt.debug_struct("NSP_ROUTINE").field("cbSize", &self.cbSize).field("dwMajorVersion", &self.dwMajorVersion).field("dwMinorVersion", &self.dwMinorVersion).finish()
3791     }
3792 }
3793 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3794 impl ::std::cmp::PartialEq for NSP_ROUTINE {
eq(&self, other: &Self) -> bool3795     fn eq(&self, other: &Self) -> bool {
3796         self.cbSize == other.cbSize
3797             && self.dwMajorVersion == other.dwMajorVersion
3798             && self.dwMinorVersion == other.dwMinorVersion
3799             && self.NSPCleanup.map(|f| f as usize) == other.NSPCleanup.map(|f| f as usize)
3800             && self.NSPLookupServiceBegin.map(|f| f as usize) == other.NSPLookupServiceBegin.map(|f| f as usize)
3801             && self.NSPLookupServiceNext.map(|f| f as usize) == other.NSPLookupServiceNext.map(|f| f as usize)
3802             && self.NSPLookupServiceEnd.map(|f| f as usize) == other.NSPLookupServiceEnd.map(|f| f as usize)
3803             && self.NSPSetService.map(|f| f as usize) == other.NSPSetService.map(|f| f as usize)
3804             && self.NSPInstallServiceClass.map(|f| f as usize) == other.NSPInstallServiceClass.map(|f| f as usize)
3805             && self.NSPRemoveServiceClass.map(|f| f as usize) == other.NSPRemoveServiceClass.map(|f| f as usize)
3806             && self.NSPGetServiceClassInfo.map(|f| f as usize) == other.NSPGetServiceClassInfo.map(|f| f as usize)
3807             && self.NSPIoctl.map(|f| f as usize) == other.NSPIoctl.map(|f| f as usize)
3808     }
3809 }
3810 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3811 impl ::std::cmp::Eq for NSP_ROUTINE {}
3812 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
3813 unsafe impl ::windows::runtime::Abi for NSP_ROUTINE {
3814     type Abi = ::std::mem::ManuallyDrop<Self>;
3815     type DefaultType = Self;
3816 }
3817 pub const NSTYPE_DYNAMIC: u32 = 2u32;
3818 pub const NSTYPE_ENUMERABLE: u32 = 4u32;
3819 pub const NSTYPE_HIERARCHICAL: u32 = 1u32;
3820 pub const NSTYPE_WORKGROUP: u32 = 8u32;
3821 pub const NS_ALL: u32 = 0u32;
3822 pub const NS_DEFAULT: u32 = 0u32;
3823 pub const NS_DHCP: u32 = 6u32;
3824 pub const NS_DNS: u32 = 12u32;
3825 pub const NS_EMAIL: u32 = 37u32;
3826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3827 #[repr(C)]
3828 #[cfg(feature = "Win32_Foundation")]
3829 pub struct NS_INFOA {
3830     pub dwNameSpace: u32,
3831     pub dwNameSpaceFlags: u32,
3832     pub lpNameSpace: super::super::Foundation::PSTR,
3833 }
3834 #[cfg(feature = "Win32_Foundation")]
3835 impl NS_INFOA {}
3836 #[cfg(feature = "Win32_Foundation")]
3837 impl ::std::default::Default for NS_INFOA {
default() -> Self3838     fn default() -> Self {
3839         unsafe { ::std::mem::zeroed() }
3840     }
3841 }
3842 #[cfg(feature = "Win32_Foundation")]
3843 impl ::std::fmt::Debug for NS_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3844     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3845         fmt.debug_struct("NS_INFOA").field("dwNameSpace", &self.dwNameSpace).field("dwNameSpaceFlags", &self.dwNameSpaceFlags).field("lpNameSpace", &self.lpNameSpace).finish()
3846     }
3847 }
3848 #[cfg(feature = "Win32_Foundation")]
3849 impl ::std::cmp::PartialEq for NS_INFOA {
eq(&self, other: &Self) -> bool3850     fn eq(&self, other: &Self) -> bool {
3851         self.dwNameSpace == other.dwNameSpace && self.dwNameSpaceFlags == other.dwNameSpaceFlags && self.lpNameSpace == other.lpNameSpace
3852     }
3853 }
3854 #[cfg(feature = "Win32_Foundation")]
3855 impl ::std::cmp::Eq for NS_INFOA {}
3856 #[cfg(feature = "Win32_Foundation")]
3857 unsafe impl ::windows::runtime::Abi for NS_INFOA {
3858     type Abi = Self;
3859     type DefaultType = Self;
3860 }
3861 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3862 #[repr(C)]
3863 #[cfg(feature = "Win32_Foundation")]
3864 pub struct NS_INFOW {
3865     pub dwNameSpace: u32,
3866     pub dwNameSpaceFlags: u32,
3867     pub lpNameSpace: super::super::Foundation::PWSTR,
3868 }
3869 #[cfg(feature = "Win32_Foundation")]
3870 impl NS_INFOW {}
3871 #[cfg(feature = "Win32_Foundation")]
3872 impl ::std::default::Default for NS_INFOW {
default() -> Self3873     fn default() -> Self {
3874         unsafe { ::std::mem::zeroed() }
3875     }
3876 }
3877 #[cfg(feature = "Win32_Foundation")]
3878 impl ::std::fmt::Debug for NS_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3879     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3880         fmt.debug_struct("NS_INFOW").field("dwNameSpace", &self.dwNameSpace).field("dwNameSpaceFlags", &self.dwNameSpaceFlags).field("lpNameSpace", &self.lpNameSpace).finish()
3881     }
3882 }
3883 #[cfg(feature = "Win32_Foundation")]
3884 impl ::std::cmp::PartialEq for NS_INFOW {
eq(&self, other: &Self) -> bool3885     fn eq(&self, other: &Self) -> bool {
3886         self.dwNameSpace == other.dwNameSpace && self.dwNameSpaceFlags == other.dwNameSpaceFlags && self.lpNameSpace == other.lpNameSpace
3887     }
3888 }
3889 #[cfg(feature = "Win32_Foundation")]
3890 impl ::std::cmp::Eq for NS_INFOW {}
3891 #[cfg(feature = "Win32_Foundation")]
3892 unsafe impl ::windows::runtime::Abi for NS_INFOW {
3893     type Abi = Self;
3894     type DefaultType = Self;
3895 }
3896 pub const NS_LOCALNAME: u32 = 19u32;
3897 pub const NS_MS: u32 = 30u32;
3898 pub const NS_NBP: u32 = 20u32;
3899 pub const NS_NDS: u32 = 2u32;
3900 pub const NS_NETBT: u32 = 13u32;
3901 pub const NS_NETDES: u32 = 60u32;
3902 pub const NS_NIS: u32 = 41u32;
3903 pub const NS_NISPLUS: u32 = 42u32;
3904 pub const NS_NLA: u32 = 15u32;
3905 pub const NS_NTDS: u32 = 32u32;
3906 pub const NS_PEER_BROWSE: u32 = 3u32;
3907 pub const NS_SAP: u32 = 1u32;
3908 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3909 #[repr(C)]
3910 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3911 pub struct NS_SERVICE_INFOA {
3912     pub dwNameSpace: u32,
3913     pub ServiceInfo: SERVICE_INFOA,
3914 }
3915 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3916 impl NS_SERVICE_INFOA {}
3917 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3918 impl ::std::default::Default for NS_SERVICE_INFOA {
default() -> Self3919     fn default() -> Self {
3920         unsafe { ::std::mem::zeroed() }
3921     }
3922 }
3923 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3924 impl ::std::fmt::Debug for NS_SERVICE_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3925     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3926         fmt.debug_struct("NS_SERVICE_INFOA").field("dwNameSpace", &self.dwNameSpace).field("ServiceInfo", &self.ServiceInfo).finish()
3927     }
3928 }
3929 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3930 impl ::std::cmp::PartialEq for NS_SERVICE_INFOA {
eq(&self, other: &Self) -> bool3931     fn eq(&self, other: &Self) -> bool {
3932         self.dwNameSpace == other.dwNameSpace && self.ServiceInfo == other.ServiceInfo
3933     }
3934 }
3935 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3936 impl ::std::cmp::Eq for NS_SERVICE_INFOA {}
3937 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3938 unsafe impl ::windows::runtime::Abi for NS_SERVICE_INFOA {
3939     type Abi = Self;
3940     type DefaultType = Self;
3941 }
3942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3943 #[repr(C)]
3944 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3945 pub struct NS_SERVICE_INFOW {
3946     pub dwNameSpace: u32,
3947     pub ServiceInfo: SERVICE_INFOW,
3948 }
3949 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3950 impl NS_SERVICE_INFOW {}
3951 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3952 impl ::std::default::Default for NS_SERVICE_INFOW {
default() -> Self3953     fn default() -> Self {
3954         unsafe { ::std::mem::zeroed() }
3955     }
3956 }
3957 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3958 impl ::std::fmt::Debug for NS_SERVICE_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3959     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3960         fmt.debug_struct("NS_SERVICE_INFOW").field("dwNameSpace", &self.dwNameSpace).field("ServiceInfo", &self.ServiceInfo).finish()
3961     }
3962 }
3963 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3964 impl ::std::cmp::PartialEq for NS_SERVICE_INFOW {
eq(&self, other: &Self) -> bool3965     fn eq(&self, other: &Self) -> bool {
3966         self.dwNameSpace == other.dwNameSpace && self.ServiceInfo == other.ServiceInfo
3967     }
3968 }
3969 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3970 impl ::std::cmp::Eq for NS_SERVICE_INFOW {}
3971 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
3972 unsafe impl ::windows::runtime::Abi for NS_SERVICE_INFOW {
3973     type Abi = Self;
3974     type DefaultType = Self;
3975 }
3976 pub const NS_SLP: u32 = 5u32;
3977 pub const NS_STDA: u32 = 31u32;
3978 pub const NS_TCPIP_HOSTS: u32 = 11u32;
3979 pub const NS_TCPIP_LOCAL: u32 = 10u32;
3980 pub const NS_VNS: u32 = 50u32;
3981 pub const NS_WINS: u32 = 14u32;
3982 pub const NS_WRQ: u32 = 50u32;
3983 pub const NS_X500: u32 = 40u32;
3984 pub const PFL_HIDDEN: u32 = 4u32;
3985 pub const PFL_MATCHES_PROTOCOL_ZERO: u32 = 8u32;
3986 pub const PFL_MULTIPLE_PROTO_ENTRIES: u32 = 1u32;
3987 pub const PFL_NETWORKDIRECT_PROVIDER: u32 = 16u32;
3988 pub const PFL_RECOMMENDED_PROTO_ENTRY: u32 = 2u32;
3989 pub const PF_APPLETALK: u16 = 16u16;
3990 pub const PF_ATM: u16 = 22u16;
3991 pub const PF_BAN: u16 = 21u16;
3992 pub const PF_CCITT: u16 = 10u16;
3993 pub const PF_CHAOS: u16 = 5u16;
3994 pub const PF_DATAKIT: u16 = 9u16;
3995 pub const PF_DECnet: u16 = 12u16;
3996 pub const PF_DLI: u16 = 13u16;
3997 pub const PF_ECMA: u16 = 8u16;
3998 pub const PF_FIREFOX: u16 = 19u16;
3999 pub const PF_HYLINK: u16 = 15u16;
4000 pub const PF_IMPLINK: u16 = 3u16;
4001 pub const PF_IPX: u16 = 6u16;
4002 pub const PF_IRDA: u16 = 26u16;
4003 pub const PF_ISO: u16 = 7u16;
4004 pub const PF_LAT: u16 = 14u16;
4005 pub const PF_MAX: u16 = 29u16;
4006 pub const PF_NS: u16 = 6u16;
4007 pub const PF_OSI: u16 = 7u16;
4008 pub const PF_PUP: u16 = 4u16;
4009 pub const PF_SNA: u16 = 11u16;
4010 pub const PF_UNIX: u16 = 1u16;
4011 pub const PF_UNKNOWN1: u16 = 20u16;
4012 pub const PF_VOICEVIEW: u16 = 18u16;
4013 pub const PI_ALLOWED: u32 = 0u32;
4014 pub const PI_NUMBER_NOT_AVAILABLE: u32 = 128u32;
4015 pub const PI_RESTRICTED: u32 = 64u32;
4016 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4017 #[repr(transparent)]
4018 pub struct PMTUD_STATE(pub i32);
4019 pub const IP_PMTUDISC_NOT_SET: PMTUD_STATE = PMTUD_STATE(0i32);
4020 pub const IP_PMTUDISC_DO: PMTUD_STATE = PMTUD_STATE(1i32);
4021 pub const IP_PMTUDISC_DONT: PMTUD_STATE = PMTUD_STATE(2i32);
4022 pub const IP_PMTUDISC_PROBE: PMTUD_STATE = PMTUD_STATE(3i32);
4023 pub const IP_PMTUDISC_MAX: PMTUD_STATE = PMTUD_STATE(4i32);
4024 impl ::std::convert::From<i32> for PMTUD_STATE {
from(value: i32) -> Self4025     fn from(value: i32) -> Self {
4026         Self(value)
4027     }
4028 }
4029 unsafe impl ::windows::runtime::Abi for PMTUD_STATE {
4030     type Abi = Self;
4031     type DefaultType = Self;
4032 }
4033 pub const POLLERR: u32 = 1u32;
4034 pub const POLLHUP: u32 = 2u32;
4035 pub const POLLNVAL: u32 = 4u32;
4036 pub const POLLOUT: u32 = 16u32;
4037 pub const POLLPRI: u32 = 1024u32;
4038 pub const POLLRDBAND: u32 = 512u32;
4039 pub const POLLRDNORM: u32 = 256u32;
4040 pub const POLLWRBAND: u32 = 32u32;
4041 pub const POLLWRNORM: u32 = 16u32;
4042 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4043 #[repr(C)]
4044 pub struct PRIORITY_STATUS {
4045     pub Sender: SOCKET_PRIORITY_HINT,
4046     pub Receiver: SOCKET_PRIORITY_HINT,
4047 }
4048 impl PRIORITY_STATUS {}
4049 impl ::std::default::Default for PRIORITY_STATUS {
default() -> Self4050     fn default() -> Self {
4051         unsafe { ::std::mem::zeroed() }
4052     }
4053 }
4054 impl ::std::fmt::Debug for PRIORITY_STATUS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4055     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4056         fmt.debug_struct("PRIORITY_STATUS").field("Sender", &self.Sender).field("Receiver", &self.Receiver).finish()
4057     }
4058 }
4059 impl ::std::cmp::PartialEq for PRIORITY_STATUS {
eq(&self, other: &Self) -> bool4060     fn eq(&self, other: &Self) -> bool {
4061         self.Sender == other.Sender && self.Receiver == other.Receiver
4062     }
4063 }
4064 impl ::std::cmp::Eq for PRIORITY_STATUS {}
4065 unsafe impl ::windows::runtime::Abi for PRIORITY_STATUS {
4066     type Abi = Self;
4067     type DefaultType = Self;
4068 }
4069 pub const PROP_ADDRESSES: u32 = 256u32;
4070 pub const PROP_ALL: u32 = 2147483648u32;
4071 pub const PROP_COMMENT: u32 = 1u32;
4072 pub const PROP_DISPLAY_HINT: u32 = 4u32;
4073 pub const PROP_LOCALE: u32 = 2u32;
4074 pub const PROP_MACHINE: u32 = 32u32;
4075 pub const PROP_SD: u32 = 512u32;
4076 pub const PROP_START_TIME: u32 = 16u32;
4077 pub const PROP_VERSION: u32 = 8u32;
4078 pub const PROTECTION_LEVEL_DEFAULT: u32 = 20u32;
4079 pub const PROTECTION_LEVEL_EDGERESTRICTED: u32 = 20u32;
4080 pub const PROTECTION_LEVEL_RESTRICTED: u32 = 30u32;
4081 pub const PROTECTION_LEVEL_UNRESTRICTED: u32 = 10u32;
4082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4083 #[repr(C)]
4084 #[cfg(feature = "Win32_Foundation")]
4085 pub struct PROTOCOL_INFOA {
4086     pub dwServiceFlags: u32,
4087     pub iAddressFamily: i32,
4088     pub iMaxSockAddr: i32,
4089     pub iMinSockAddr: i32,
4090     pub iSocketType: i32,
4091     pub iProtocol: i32,
4092     pub dwMessageSize: u32,
4093     pub lpProtocol: super::super::Foundation::PSTR,
4094 }
4095 #[cfg(feature = "Win32_Foundation")]
4096 impl PROTOCOL_INFOA {}
4097 #[cfg(feature = "Win32_Foundation")]
4098 impl ::std::default::Default for PROTOCOL_INFOA {
default() -> Self4099     fn default() -> Self {
4100         unsafe { ::std::mem::zeroed() }
4101     }
4102 }
4103 #[cfg(feature = "Win32_Foundation")]
4104 impl ::std::fmt::Debug for PROTOCOL_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4105     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4106         fmt.debug_struct("PROTOCOL_INFOA")
4107             .field("dwServiceFlags", &self.dwServiceFlags)
4108             .field("iAddressFamily", &self.iAddressFamily)
4109             .field("iMaxSockAddr", &self.iMaxSockAddr)
4110             .field("iMinSockAddr", &self.iMinSockAddr)
4111             .field("iSocketType", &self.iSocketType)
4112             .field("iProtocol", &self.iProtocol)
4113             .field("dwMessageSize", &self.dwMessageSize)
4114             .field("lpProtocol", &self.lpProtocol)
4115             .finish()
4116     }
4117 }
4118 #[cfg(feature = "Win32_Foundation")]
4119 impl ::std::cmp::PartialEq for PROTOCOL_INFOA {
eq(&self, other: &Self) -> bool4120     fn eq(&self, other: &Self) -> bool {
4121         self.dwServiceFlags == other.dwServiceFlags && self.iAddressFamily == other.iAddressFamily && self.iMaxSockAddr == other.iMaxSockAddr && self.iMinSockAddr == other.iMinSockAddr && self.iSocketType == other.iSocketType && self.iProtocol == other.iProtocol && self.dwMessageSize == other.dwMessageSize && self.lpProtocol == other.lpProtocol
4122     }
4123 }
4124 #[cfg(feature = "Win32_Foundation")]
4125 impl ::std::cmp::Eq for PROTOCOL_INFOA {}
4126 #[cfg(feature = "Win32_Foundation")]
4127 unsafe impl ::windows::runtime::Abi for PROTOCOL_INFOA {
4128     type Abi = Self;
4129     type DefaultType = Self;
4130 }
4131 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4132 #[repr(C)]
4133 #[cfg(feature = "Win32_Foundation")]
4134 pub struct PROTOCOL_INFOW {
4135     pub dwServiceFlags: u32,
4136     pub iAddressFamily: i32,
4137     pub iMaxSockAddr: i32,
4138     pub iMinSockAddr: i32,
4139     pub iSocketType: i32,
4140     pub iProtocol: i32,
4141     pub dwMessageSize: u32,
4142     pub lpProtocol: super::super::Foundation::PWSTR,
4143 }
4144 #[cfg(feature = "Win32_Foundation")]
4145 impl PROTOCOL_INFOW {}
4146 #[cfg(feature = "Win32_Foundation")]
4147 impl ::std::default::Default for PROTOCOL_INFOW {
default() -> Self4148     fn default() -> Self {
4149         unsafe { ::std::mem::zeroed() }
4150     }
4151 }
4152 #[cfg(feature = "Win32_Foundation")]
4153 impl ::std::fmt::Debug for PROTOCOL_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4154     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4155         fmt.debug_struct("PROTOCOL_INFOW")
4156             .field("dwServiceFlags", &self.dwServiceFlags)
4157             .field("iAddressFamily", &self.iAddressFamily)
4158             .field("iMaxSockAddr", &self.iMaxSockAddr)
4159             .field("iMinSockAddr", &self.iMinSockAddr)
4160             .field("iSocketType", &self.iSocketType)
4161             .field("iProtocol", &self.iProtocol)
4162             .field("dwMessageSize", &self.dwMessageSize)
4163             .field("lpProtocol", &self.lpProtocol)
4164             .finish()
4165     }
4166 }
4167 #[cfg(feature = "Win32_Foundation")]
4168 impl ::std::cmp::PartialEq for PROTOCOL_INFOW {
eq(&self, other: &Self) -> bool4169     fn eq(&self, other: &Self) -> bool {
4170         self.dwServiceFlags == other.dwServiceFlags && self.iAddressFamily == other.iAddressFamily && self.iMaxSockAddr == other.iMaxSockAddr && self.iMinSockAddr == other.iMinSockAddr && self.iSocketType == other.iSocketType && self.iProtocol == other.iProtocol && self.dwMessageSize == other.dwMessageSize && self.lpProtocol == other.lpProtocol
4171     }
4172 }
4173 #[cfg(feature = "Win32_Foundation")]
4174 impl ::std::cmp::Eq for PROTOCOL_INFOW {}
4175 #[cfg(feature = "Win32_Foundation")]
4176 unsafe impl ::windows::runtime::Abi for PROTOCOL_INFOW {
4177     type Abi = Self;
4178     type DefaultType = Self;
4179 }
4180 pub const PVD_CONFIG: u32 = 12289u32;
4181 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
4182 #[inline]
ProcessSocketNotifications<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(completionport: Param0, registrationcount: u32, registrationinfos: *mut SOCK_NOTIFY_REGISTRATION, timeoutms: u32, completioncount: u32, completionportentries: *mut super::super::System::IO::OVERLAPPED_ENTRY, receivedentrycount: *mut u32) -> u324183 pub unsafe fn ProcessSocketNotifications<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(completionport: Param0, registrationcount: u32, registrationinfos: *mut SOCK_NOTIFY_REGISTRATION, timeoutms: u32, completioncount: u32, completionportentries: *mut super::super::System::IO::OVERLAPPED_ENTRY, receivedentrycount: *mut u32) -> u32 {
4184     #[cfg(windows)]
4185     {
4186         #[link(name = "windows")]
4187         extern "system" {
4188             fn ProcessSocketNotifications(completionport: super::super::Foundation::HANDLE, registrationcount: u32, registrationinfos: *mut SOCK_NOTIFY_REGISTRATION, timeoutms: u32, completioncount: u32, completionportentries: *mut super::super::System::IO::OVERLAPPED_ENTRY, receivedentrycount: *mut u32) -> u32;
4189         }
4190         ::std::mem::transmute(ProcessSocketNotifications(
4191             completionport.into_param().abi(),
4192             ::std::mem::transmute(registrationcount),
4193             ::std::mem::transmute(registrationinfos),
4194             ::std::mem::transmute(timeoutms),
4195             ::std::mem::transmute(completioncount),
4196             ::std::mem::transmute(completionportentries),
4197             ::std::mem::transmute(receivedentrycount),
4198         ))
4199     }
4200     #[cfg(not(windows))]
4201     unimplemented!("Unsupported target OS");
4202 }
4203 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4204 #[repr(C)]
4205 pub struct Q2931_IE {
4206     pub IEType: Q2931_IE_TYPE,
4207     pub IELength: u32,
4208     pub IE: [u8; 1],
4209 }
4210 impl Q2931_IE {}
4211 impl ::std::default::Default for Q2931_IE {
default() -> Self4212     fn default() -> Self {
4213         unsafe { ::std::mem::zeroed() }
4214     }
4215 }
4216 impl ::std::fmt::Debug for Q2931_IE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4217     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4218         fmt.debug_struct("Q2931_IE").field("IEType", &self.IEType).field("IELength", &self.IELength).field("IE", &self.IE).finish()
4219     }
4220 }
4221 impl ::std::cmp::PartialEq for Q2931_IE {
eq(&self, other: &Self) -> bool4222     fn eq(&self, other: &Self) -> bool {
4223         self.IEType == other.IEType && self.IELength == other.IELength && self.IE == other.IE
4224     }
4225 }
4226 impl ::std::cmp::Eq for Q2931_IE {}
4227 unsafe impl ::windows::runtime::Abi for Q2931_IE {
4228     type Abi = Self;
4229     type DefaultType = Self;
4230 }
4231 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4232 #[repr(transparent)]
4233 pub struct Q2931_IE_TYPE(pub i32);
4234 pub const IE_AALParameters: Q2931_IE_TYPE = Q2931_IE_TYPE(0i32);
4235 pub const IE_TrafficDescriptor: Q2931_IE_TYPE = Q2931_IE_TYPE(1i32);
4236 pub const IE_BroadbandBearerCapability: Q2931_IE_TYPE = Q2931_IE_TYPE(2i32);
4237 pub const IE_BHLI: Q2931_IE_TYPE = Q2931_IE_TYPE(3i32);
4238 pub const IE_BLLI: Q2931_IE_TYPE = Q2931_IE_TYPE(4i32);
4239 pub const IE_CalledPartyNumber: Q2931_IE_TYPE = Q2931_IE_TYPE(5i32);
4240 pub const IE_CalledPartySubaddress: Q2931_IE_TYPE = Q2931_IE_TYPE(6i32);
4241 pub const IE_CallingPartyNumber: Q2931_IE_TYPE = Q2931_IE_TYPE(7i32);
4242 pub const IE_CallingPartySubaddress: Q2931_IE_TYPE = Q2931_IE_TYPE(8i32);
4243 pub const IE_Cause: Q2931_IE_TYPE = Q2931_IE_TYPE(9i32);
4244 pub const IE_QOSClass: Q2931_IE_TYPE = Q2931_IE_TYPE(10i32);
4245 pub const IE_TransitNetworkSelection: Q2931_IE_TYPE = Q2931_IE_TYPE(11i32);
4246 impl ::std::convert::From<i32> for Q2931_IE_TYPE {
from(value: i32) -> Self4247     fn from(value: i32) -> Self {
4248         Self(value)
4249     }
4250 }
4251 unsafe impl ::windows::runtime::Abi for Q2931_IE_TYPE {
4252     type Abi = Self;
4253     type DefaultType = Self;
4254 }
4255 pub const QOS_CLASS0: u32 = 0u32;
4256 pub const QOS_CLASS1: u32 = 1u32;
4257 pub const QOS_CLASS2: u32 = 2u32;
4258 pub const QOS_CLASS3: u32 = 3u32;
4259 pub const QOS_CLASS4: u32 = 4u32;
4260 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4261 #[repr(C)]
4262 pub struct RCVALL_IF {
4263     pub Mode: RCVALL_VALUE,
4264     pub Interface: u32,
4265 }
4266 impl RCVALL_IF {}
4267 impl ::std::default::Default for RCVALL_IF {
default() -> Self4268     fn default() -> Self {
4269         unsafe { ::std::mem::zeroed() }
4270     }
4271 }
4272 impl ::std::fmt::Debug for RCVALL_IF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4273     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4274         fmt.debug_struct("RCVALL_IF").field("Mode", &self.Mode).field("Interface", &self.Interface).finish()
4275     }
4276 }
4277 impl ::std::cmp::PartialEq for RCVALL_IF {
eq(&self, other: &Self) -> bool4278     fn eq(&self, other: &Self) -> bool {
4279         self.Mode == other.Mode && self.Interface == other.Interface
4280     }
4281 }
4282 impl ::std::cmp::Eq for RCVALL_IF {}
4283 unsafe impl ::windows::runtime::Abi for RCVALL_IF {
4284     type Abi = Self;
4285     type DefaultType = Self;
4286 }
4287 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4288 #[repr(transparent)]
4289 pub struct RCVALL_VALUE(pub i32);
4290 pub const RCVALL_OFF: RCVALL_VALUE = RCVALL_VALUE(0i32);
4291 pub const RCVALL_ON: RCVALL_VALUE = RCVALL_VALUE(1i32);
4292 pub const RCVALL_SOCKETLEVELONLY: RCVALL_VALUE = RCVALL_VALUE(2i32);
4293 pub const RCVALL_IPLEVEL: RCVALL_VALUE = RCVALL_VALUE(3i32);
4294 impl ::std::convert::From<i32> for RCVALL_VALUE {
from(value: i32) -> Self4295     fn from(value: i32) -> Self {
4296         Self(value)
4297     }
4298 }
4299 unsafe impl ::windows::runtime::Abi for RCVALL_VALUE {
4300     type Abi = Self;
4301     type DefaultType = Self;
4302 }
4303 pub const REAL_TIME_NOTIFICATION_CAPABILITY: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1801027994, 23726, 18733, [169, 1, 42, 60, 44, 80, 22, 79]);
4304 pub const REAL_TIME_NOTIFICATION_CAPABILITY_EX: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1749277187, 5450, 17942, [165, 8, 68, 55, 18, 149, 249, 107]);
4305 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4306 #[repr(C)]
4307 pub struct REAL_TIME_NOTIFICATION_SETTING_INPUT {
4308     pub TransportSettingId: TRANSPORT_SETTING_ID,
4309     pub BrokerEventGuid: ::windows::runtime::GUID,
4310 }
4311 impl REAL_TIME_NOTIFICATION_SETTING_INPUT {}
4312 impl ::std::default::Default for REAL_TIME_NOTIFICATION_SETTING_INPUT {
default() -> Self4313     fn default() -> Self {
4314         unsafe { ::std::mem::zeroed() }
4315     }
4316 }
4317 impl ::std::fmt::Debug for REAL_TIME_NOTIFICATION_SETTING_INPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4318     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4319         fmt.debug_struct("REAL_TIME_NOTIFICATION_SETTING_INPUT").field("TransportSettingId", &self.TransportSettingId).field("BrokerEventGuid", &self.BrokerEventGuid).finish()
4320     }
4321 }
4322 impl ::std::cmp::PartialEq for REAL_TIME_NOTIFICATION_SETTING_INPUT {
eq(&self, other: &Self) -> bool4323     fn eq(&self, other: &Self) -> bool {
4324         self.TransportSettingId == other.TransportSettingId && self.BrokerEventGuid == other.BrokerEventGuid
4325     }
4326 }
4327 impl ::std::cmp::Eq for REAL_TIME_NOTIFICATION_SETTING_INPUT {}
4328 unsafe impl ::windows::runtime::Abi for REAL_TIME_NOTIFICATION_SETTING_INPUT {
4329     type Abi = Self;
4330     type DefaultType = Self;
4331 }
4332 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4333 #[repr(C)]
4334 #[cfg(feature = "Win32_Foundation")]
4335 pub struct REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {
4336     pub TransportSettingId: TRANSPORT_SETTING_ID,
4337     pub BrokerEventGuid: ::windows::runtime::GUID,
4338     pub Unmark: super::super::Foundation::BOOLEAN,
4339 }
4340 #[cfg(feature = "Win32_Foundation")]
4341 impl REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {}
4342 #[cfg(feature = "Win32_Foundation")]
4343 impl ::std::default::Default for REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {
default() -> Self4344     fn default() -> Self {
4345         unsafe { ::std::mem::zeroed() }
4346     }
4347 }
4348 #[cfg(feature = "Win32_Foundation")]
4349 impl ::std::fmt::Debug for REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4350     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4351         fmt.debug_struct("REAL_TIME_NOTIFICATION_SETTING_INPUT_EX").field("TransportSettingId", &self.TransportSettingId).field("BrokerEventGuid", &self.BrokerEventGuid).field("Unmark", &self.Unmark).finish()
4352     }
4353 }
4354 #[cfg(feature = "Win32_Foundation")]
4355 impl ::std::cmp::PartialEq for REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {
eq(&self, other: &Self) -> bool4356     fn eq(&self, other: &Self) -> bool {
4357         self.TransportSettingId == other.TransportSettingId && self.BrokerEventGuid == other.BrokerEventGuid && self.Unmark == other.Unmark
4358     }
4359 }
4360 #[cfg(feature = "Win32_Foundation")]
4361 impl ::std::cmp::Eq for REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {}
4362 #[cfg(feature = "Win32_Foundation")]
4363 unsafe impl ::windows::runtime::Abi for REAL_TIME_NOTIFICATION_SETTING_INPUT_EX {
4364     type Abi = Self;
4365     type DefaultType = Self;
4366 }
4367 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4368 #[repr(C)]
4369 pub struct REAL_TIME_NOTIFICATION_SETTING_OUTPUT {
4370     pub ChannelStatus: CONTROL_CHANNEL_TRIGGER_STATUS,
4371 }
4372 impl REAL_TIME_NOTIFICATION_SETTING_OUTPUT {}
4373 impl ::std::default::Default for REAL_TIME_NOTIFICATION_SETTING_OUTPUT {
default() -> Self4374     fn default() -> Self {
4375         unsafe { ::std::mem::zeroed() }
4376     }
4377 }
4378 impl ::std::fmt::Debug for REAL_TIME_NOTIFICATION_SETTING_OUTPUT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4379     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4380         fmt.debug_struct("REAL_TIME_NOTIFICATION_SETTING_OUTPUT").field("ChannelStatus", &self.ChannelStatus).finish()
4381     }
4382 }
4383 impl ::std::cmp::PartialEq for REAL_TIME_NOTIFICATION_SETTING_OUTPUT {
eq(&self, other: &Self) -> bool4384     fn eq(&self, other: &Self) -> bool {
4385         self.ChannelStatus == other.ChannelStatus
4386     }
4387 }
4388 impl ::std::cmp::Eq for REAL_TIME_NOTIFICATION_SETTING_OUTPUT {}
4389 unsafe impl ::windows::runtime::Abi for REAL_TIME_NOTIFICATION_SETTING_OUTPUT {
4390     type Abi = Self;
4391     type DefaultType = Self;
4392 }
4393 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4394 #[repr(transparent)]
4395 pub struct RESOURCE_DISPLAY_TYPE(pub u32);
4396 pub const RESOURCEDISPLAYTYPE_DOMAIN: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(1u32);
4397 pub const RESOURCEDISPLAYTYPE_FILE: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(4u32);
4398 pub const RESOURCEDISPLAYTYPE_GENERIC: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(0u32);
4399 pub const RESOURCEDISPLAYTYPE_GROUP: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(5u32);
4400 pub const RESOURCEDISPLAYTYPE_SERVER: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(2u32);
4401 pub const RESOURCEDISPLAYTYPE_SHARE: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(3u32);
4402 pub const RESOURCEDISPLAYTYPE_TREE: RESOURCE_DISPLAY_TYPE = RESOURCE_DISPLAY_TYPE(10u32);
4403 impl ::std::convert::From<u32> for RESOURCE_DISPLAY_TYPE {
from(value: u32) -> Self4404     fn from(value: u32) -> Self {
4405         Self(value)
4406     }
4407 }
4408 unsafe impl ::windows::runtime::Abi for RESOURCE_DISPLAY_TYPE {
4409     type Abi = Self;
4410     type DefaultType = Self;
4411 }
4412 impl ::std::ops::BitOr for RESOURCE_DISPLAY_TYPE {
4413     type Output = Self;
bitor(self, rhs: Self) -> Self4414     fn bitor(self, rhs: Self) -> Self {
4415         Self(self.0 | rhs.0)
4416     }
4417 }
4418 impl ::std::ops::BitAnd for RESOURCE_DISPLAY_TYPE {
4419     type Output = Self;
bitand(self, rhs: Self) -> Self4420     fn bitand(self, rhs: Self) -> Self {
4421         Self(self.0 & rhs.0)
4422     }
4423 }
4424 impl ::std::ops::BitOrAssign for RESOURCE_DISPLAY_TYPE {
bitor_assign(&mut self, rhs: Self)4425     fn bitor_assign(&mut self, rhs: Self) {
4426         self.0.bitor_assign(rhs.0)
4427     }
4428 }
4429 impl ::std::ops::BitAndAssign for RESOURCE_DISPLAY_TYPE {
bitand_assign(&mut self, rhs: Self)4430     fn bitand_assign(&mut self, rhs: Self) {
4431         self.0.bitand_assign(rhs.0)
4432     }
4433 }
4434 impl ::std::ops::Not for RESOURCE_DISPLAY_TYPE {
4435     type Output = Self;
not(self) -> Self4436     fn not(self) -> Self {
4437         Self(self.0.not())
4438     }
4439 }
4440 pub const RESULT_IS_ADDED: u32 = 16u32;
4441 pub const RESULT_IS_ALIAS: u32 = 1u32;
4442 pub const RESULT_IS_CHANGED: u32 = 32u32;
4443 pub const RESULT_IS_DELETED: u32 = 64u32;
4444 pub const RES_FIND_MULTIPLE: u32 = 2u32;
4445 pub const RES_FLUSH_CACHE: u32 = 2u32;
4446 pub const RES_SERVICE: u32 = 4u32;
4447 pub const RES_SOFT_SEARCH: u32 = 1u32;
4448 pub const RES_UNUSED_1: u32 = 1u32;
4449 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4450 #[repr(C)]
4451 pub struct RIORESULT {
4452     pub Status: i32,
4453     pub BytesTransferred: u32,
4454     pub SocketContext: u64,
4455     pub RequestContext: u64,
4456 }
4457 impl RIORESULT {}
4458 impl ::std::default::Default for RIORESULT {
default() -> Self4459     fn default() -> Self {
4460         unsafe { ::std::mem::zeroed() }
4461     }
4462 }
4463 impl ::std::fmt::Debug for RIORESULT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4464     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4465         fmt.debug_struct("RIORESULT").field("Status", &self.Status).field("BytesTransferred", &self.BytesTransferred).field("SocketContext", &self.SocketContext).field("RequestContext", &self.RequestContext).finish()
4466     }
4467 }
4468 impl ::std::cmp::PartialEq for RIORESULT {
eq(&self, other: &Self) -> bool4469     fn eq(&self, other: &Self) -> bool {
4470         self.Status == other.Status && self.BytesTransferred == other.BytesTransferred && self.SocketContext == other.SocketContext && self.RequestContext == other.RequestContext
4471     }
4472 }
4473 impl ::std::cmp::Eq for RIORESULT {}
4474 unsafe impl ::windows::runtime::Abi for RIORESULT {
4475     type Abi = Self;
4476     type DefaultType = Self;
4477 }
4478 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4479 #[repr(C)]
4480 pub struct RIO_BUF {
4481     pub BufferId: *mut RIO_BUFFERID_t,
4482     pub Offset: u32,
4483     pub Length: u32,
4484 }
4485 impl RIO_BUF {}
4486 impl ::std::default::Default for RIO_BUF {
default() -> Self4487     fn default() -> Self {
4488         unsafe { ::std::mem::zeroed() }
4489     }
4490 }
4491 impl ::std::fmt::Debug for RIO_BUF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4492     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4493         fmt.debug_struct("RIO_BUF").field("BufferId", &self.BufferId).field("Offset", &self.Offset).field("Length", &self.Length).finish()
4494     }
4495 }
4496 impl ::std::cmp::PartialEq for RIO_BUF {
eq(&self, other: &Self) -> bool4497     fn eq(&self, other: &Self) -> bool {
4498         self.BufferId == other.BufferId && self.Offset == other.Offset && self.Length == other.Length
4499     }
4500 }
4501 impl ::std::cmp::Eq for RIO_BUF {}
4502 unsafe impl ::windows::runtime::Abi for RIO_BUF {
4503     type Abi = Self;
4504     type DefaultType = Self;
4505 }
4506 #[repr(C)]
4507 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
4508 pub struct RIO_BUFFERID_t(pub u8);
4509 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4510 #[repr(C)]
4511 pub struct RIO_CMSG_BUFFER {
4512     pub TotalLength: u32,
4513 }
4514 impl RIO_CMSG_BUFFER {}
4515 impl ::std::default::Default for RIO_CMSG_BUFFER {
default() -> Self4516     fn default() -> Self {
4517         unsafe { ::std::mem::zeroed() }
4518     }
4519 }
4520 impl ::std::fmt::Debug for RIO_CMSG_BUFFER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4521     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4522         fmt.debug_struct("RIO_CMSG_BUFFER").field("TotalLength", &self.TotalLength).finish()
4523     }
4524 }
4525 impl ::std::cmp::PartialEq for RIO_CMSG_BUFFER {
eq(&self, other: &Self) -> bool4526     fn eq(&self, other: &Self) -> bool {
4527         self.TotalLength == other.TotalLength
4528     }
4529 }
4530 impl ::std::cmp::Eq for RIO_CMSG_BUFFER {}
4531 unsafe impl ::windows::runtime::Abi for RIO_CMSG_BUFFER {
4532     type Abi = Self;
4533     type DefaultType = Self;
4534 }
4535 pub const RIO_CORRUPT_CQ: u32 = 4294967295u32;
4536 #[repr(C)]
4537 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
4538 pub struct RIO_CQ_t(pub u8);
4539 #[derive(:: std :: clone :: Clone)]
4540 #[repr(C)]
4541 #[cfg(feature = "Win32_Foundation")]
4542 pub struct RIO_EXTENSION_FUNCTION_TABLE {
4543     pub cbSize: u32,
4544     pub RIOReceive: ::std::option::Option<LPFN_RIORECEIVE>,
4545     pub RIOReceiveEx: ::std::option::Option<LPFN_RIORECEIVEEX>,
4546     pub RIOSend: ::std::option::Option<LPFN_RIOSEND>,
4547     pub RIOSendEx: ::std::option::Option<LPFN_RIOSENDEX>,
4548     pub RIOCloseCompletionQueue: ::std::option::Option<LPFN_RIOCLOSECOMPLETIONQUEUE>,
4549     pub RIOCreateCompletionQueue: ::std::option::Option<LPFN_RIOCREATECOMPLETIONQUEUE>,
4550     pub RIOCreateRequestQueue: ::std::option::Option<LPFN_RIOCREATEREQUESTQUEUE>,
4551     pub RIODequeueCompletion: ::std::option::Option<LPFN_RIODEQUEUECOMPLETION>,
4552     pub RIODeregisterBuffer: ::std::option::Option<LPFN_RIODEREGISTERBUFFER>,
4553     pub RIONotify: ::std::option::Option<LPFN_RIONOTIFY>,
4554     pub RIORegisterBuffer: ::std::option::Option<LPFN_RIOREGISTERBUFFER>,
4555     pub RIOResizeCompletionQueue: ::std::option::Option<LPFN_RIORESIZECOMPLETIONQUEUE>,
4556     pub RIOResizeRequestQueue: ::std::option::Option<LPFN_RIORESIZEREQUESTQUEUE>,
4557 }
4558 #[cfg(feature = "Win32_Foundation")]
4559 impl RIO_EXTENSION_FUNCTION_TABLE {}
4560 #[cfg(feature = "Win32_Foundation")]
4561 impl ::std::default::Default for RIO_EXTENSION_FUNCTION_TABLE {
default() -> Self4562     fn default() -> Self {
4563         unsafe { ::std::mem::zeroed() }
4564     }
4565 }
4566 #[cfg(feature = "Win32_Foundation")]
4567 impl ::std::fmt::Debug for RIO_EXTENSION_FUNCTION_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4568     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4569         fmt.debug_struct("RIO_EXTENSION_FUNCTION_TABLE").field("cbSize", &self.cbSize).finish()
4570     }
4571 }
4572 #[cfg(feature = "Win32_Foundation")]
4573 impl ::std::cmp::PartialEq for RIO_EXTENSION_FUNCTION_TABLE {
eq(&self, other: &Self) -> bool4574     fn eq(&self, other: &Self) -> bool {
4575         self.cbSize == other.cbSize
4576             && self.RIOReceive.map(|f| f as usize) == other.RIOReceive.map(|f| f as usize)
4577             && self.RIOReceiveEx.map(|f| f as usize) == other.RIOReceiveEx.map(|f| f as usize)
4578             && self.RIOSend.map(|f| f as usize) == other.RIOSend.map(|f| f as usize)
4579             && self.RIOSendEx.map(|f| f as usize) == other.RIOSendEx.map(|f| f as usize)
4580             && self.RIOCloseCompletionQueue.map(|f| f as usize) == other.RIOCloseCompletionQueue.map(|f| f as usize)
4581             && self.RIOCreateCompletionQueue.map(|f| f as usize) == other.RIOCreateCompletionQueue.map(|f| f as usize)
4582             && self.RIOCreateRequestQueue.map(|f| f as usize) == other.RIOCreateRequestQueue.map(|f| f as usize)
4583             && self.RIODequeueCompletion.map(|f| f as usize) == other.RIODequeueCompletion.map(|f| f as usize)
4584             && self.RIODeregisterBuffer.map(|f| f as usize) == other.RIODeregisterBuffer.map(|f| f as usize)
4585             && self.RIONotify.map(|f| f as usize) == other.RIONotify.map(|f| f as usize)
4586             && self.RIORegisterBuffer.map(|f| f as usize) == other.RIORegisterBuffer.map(|f| f as usize)
4587             && self.RIOResizeCompletionQueue.map(|f| f as usize) == other.RIOResizeCompletionQueue.map(|f| f as usize)
4588             && self.RIOResizeRequestQueue.map(|f| f as usize) == other.RIOResizeRequestQueue.map(|f| f as usize)
4589     }
4590 }
4591 #[cfg(feature = "Win32_Foundation")]
4592 impl ::std::cmp::Eq for RIO_EXTENSION_FUNCTION_TABLE {}
4593 #[cfg(feature = "Win32_Foundation")]
4594 unsafe impl ::windows::runtime::Abi for RIO_EXTENSION_FUNCTION_TABLE {
4595     type Abi = ::std::mem::ManuallyDrop<Self>;
4596     type DefaultType = Self;
4597 }
4598 pub const RIO_MAX_CQ_SIZE: u32 = 134217728u32;
4599 pub const RIO_MSG_COMMIT_ONLY: u32 = 8u32;
4600 pub const RIO_MSG_DEFER: u32 = 2u32;
4601 pub const RIO_MSG_DONT_NOTIFY: u32 = 1u32;
4602 pub const RIO_MSG_WAITALL: u32 = 4u32;
4603 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4604 #[repr(C)]
4605 #[cfg(feature = "Win32_Foundation")]
4606 pub struct RIO_NOTIFICATION_COMPLETION {
4607     pub Type: RIO_NOTIFICATION_COMPLETION_TYPE,
4608     pub Anonymous: RIO_NOTIFICATION_COMPLETION_0,
4609 }
4610 #[cfg(feature = "Win32_Foundation")]
4611 impl RIO_NOTIFICATION_COMPLETION {}
4612 #[cfg(feature = "Win32_Foundation")]
4613 impl ::std::default::Default for RIO_NOTIFICATION_COMPLETION {
default() -> Self4614     fn default() -> Self {
4615         unsafe { ::std::mem::zeroed() }
4616     }
4617 }
4618 #[cfg(feature = "Win32_Foundation")]
4619 impl ::std::cmp::PartialEq for RIO_NOTIFICATION_COMPLETION {
eq(&self, _other: &Self) -> bool4620     fn eq(&self, _other: &Self) -> bool {
4621         unimplemented!()
4622     }
4623 }
4624 #[cfg(feature = "Win32_Foundation")]
4625 impl ::std::cmp::Eq for RIO_NOTIFICATION_COMPLETION {}
4626 #[cfg(feature = "Win32_Foundation")]
4627 unsafe impl ::windows::runtime::Abi for RIO_NOTIFICATION_COMPLETION {
4628     type Abi = Self;
4629     type DefaultType = Self;
4630 }
4631 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4632 #[repr(C)]
4633 #[cfg(feature = "Win32_Foundation")]
4634 pub union RIO_NOTIFICATION_COMPLETION_0 {
4635     pub Event: RIO_NOTIFICATION_COMPLETION_0_0,
4636     pub Iocp: RIO_NOTIFICATION_COMPLETION_0_1,
4637 }
4638 #[cfg(feature = "Win32_Foundation")]
4639 impl RIO_NOTIFICATION_COMPLETION_0 {}
4640 #[cfg(feature = "Win32_Foundation")]
4641 impl ::std::default::Default for RIO_NOTIFICATION_COMPLETION_0 {
default() -> Self4642     fn default() -> Self {
4643         unsafe { ::std::mem::zeroed() }
4644     }
4645 }
4646 #[cfg(feature = "Win32_Foundation")]
4647 impl ::std::cmp::PartialEq for RIO_NOTIFICATION_COMPLETION_0 {
eq(&self, _other: &Self) -> bool4648     fn eq(&self, _other: &Self) -> bool {
4649         unimplemented!()
4650     }
4651 }
4652 #[cfg(feature = "Win32_Foundation")]
4653 impl ::std::cmp::Eq for RIO_NOTIFICATION_COMPLETION_0 {}
4654 #[cfg(feature = "Win32_Foundation")]
4655 unsafe impl ::windows::runtime::Abi for RIO_NOTIFICATION_COMPLETION_0 {
4656     type Abi = Self;
4657     type DefaultType = Self;
4658 }
4659 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4660 #[repr(C)]
4661 #[cfg(feature = "Win32_Foundation")]
4662 pub struct RIO_NOTIFICATION_COMPLETION_0_0 {
4663     pub EventHandle: super::super::Foundation::HANDLE,
4664     pub NotifyReset: super::super::Foundation::BOOL,
4665 }
4666 #[cfg(feature = "Win32_Foundation")]
4667 impl RIO_NOTIFICATION_COMPLETION_0_0 {}
4668 #[cfg(feature = "Win32_Foundation")]
4669 impl ::std::default::Default for RIO_NOTIFICATION_COMPLETION_0_0 {
default() -> Self4670     fn default() -> Self {
4671         unsafe { ::std::mem::zeroed() }
4672     }
4673 }
4674 #[cfg(feature = "Win32_Foundation")]
4675 impl ::std::fmt::Debug for RIO_NOTIFICATION_COMPLETION_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4676     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4677         fmt.debug_struct("_Event_e__Struct").field("EventHandle", &self.EventHandle).field("NotifyReset", &self.NotifyReset).finish()
4678     }
4679 }
4680 #[cfg(feature = "Win32_Foundation")]
4681 impl ::std::cmp::PartialEq for RIO_NOTIFICATION_COMPLETION_0_0 {
eq(&self, other: &Self) -> bool4682     fn eq(&self, other: &Self) -> bool {
4683         self.EventHandle == other.EventHandle && self.NotifyReset == other.NotifyReset
4684     }
4685 }
4686 #[cfg(feature = "Win32_Foundation")]
4687 impl ::std::cmp::Eq for RIO_NOTIFICATION_COMPLETION_0_0 {}
4688 #[cfg(feature = "Win32_Foundation")]
4689 unsafe impl ::windows::runtime::Abi for RIO_NOTIFICATION_COMPLETION_0_0 {
4690     type Abi = Self;
4691     type DefaultType = Self;
4692 }
4693 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4694 #[repr(C)]
4695 #[cfg(feature = "Win32_Foundation")]
4696 pub struct RIO_NOTIFICATION_COMPLETION_0_1 {
4697     pub IocpHandle: super::super::Foundation::HANDLE,
4698     pub CompletionKey: *mut ::std::ffi::c_void,
4699     pub Overlapped: *mut ::std::ffi::c_void,
4700 }
4701 #[cfg(feature = "Win32_Foundation")]
4702 impl RIO_NOTIFICATION_COMPLETION_0_1 {}
4703 #[cfg(feature = "Win32_Foundation")]
4704 impl ::std::default::Default for RIO_NOTIFICATION_COMPLETION_0_1 {
default() -> Self4705     fn default() -> Self {
4706         unsafe { ::std::mem::zeroed() }
4707     }
4708 }
4709 #[cfg(feature = "Win32_Foundation")]
4710 impl ::std::fmt::Debug for RIO_NOTIFICATION_COMPLETION_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4711     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4712         fmt.debug_struct("_Iocp_e__Struct").field("IocpHandle", &self.IocpHandle).field("CompletionKey", &self.CompletionKey).field("Overlapped", &self.Overlapped).finish()
4713     }
4714 }
4715 #[cfg(feature = "Win32_Foundation")]
4716 impl ::std::cmp::PartialEq for RIO_NOTIFICATION_COMPLETION_0_1 {
eq(&self, other: &Self) -> bool4717     fn eq(&self, other: &Self) -> bool {
4718         self.IocpHandle == other.IocpHandle && self.CompletionKey == other.CompletionKey && self.Overlapped == other.Overlapped
4719     }
4720 }
4721 #[cfg(feature = "Win32_Foundation")]
4722 impl ::std::cmp::Eq for RIO_NOTIFICATION_COMPLETION_0_1 {}
4723 #[cfg(feature = "Win32_Foundation")]
4724 unsafe impl ::windows::runtime::Abi for RIO_NOTIFICATION_COMPLETION_0_1 {
4725     type Abi = Self;
4726     type DefaultType = Self;
4727 }
4728 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4729 #[repr(transparent)]
4730 pub struct RIO_NOTIFICATION_COMPLETION_TYPE(pub i32);
4731 pub const RIO_EVENT_COMPLETION: RIO_NOTIFICATION_COMPLETION_TYPE = RIO_NOTIFICATION_COMPLETION_TYPE(1i32);
4732 pub const RIO_IOCP_COMPLETION: RIO_NOTIFICATION_COMPLETION_TYPE = RIO_NOTIFICATION_COMPLETION_TYPE(2i32);
4733 impl ::std::convert::From<i32> for RIO_NOTIFICATION_COMPLETION_TYPE {
from(value: i32) -> Self4734     fn from(value: i32) -> Self {
4735         Self(value)
4736     }
4737 }
4738 unsafe impl ::windows::runtime::Abi for RIO_NOTIFICATION_COMPLETION_TYPE {
4739     type Abi = Self;
4740     type DefaultType = Self;
4741 }
4742 #[repr(C)]
4743 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
4744 pub struct RIO_RQ_t(pub u8);
4745 pub const RM_ADD_RECEIVE_IF: u32 = 1008u32;
4746 pub const RM_DEL_RECEIVE_IF: u32 = 1009u32;
4747 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4748 #[repr(C)]
4749 #[cfg(feature = "Win32_Foundation")]
4750 pub struct RM_FEC_INFO {
4751     pub FECBlockSize: u16,
4752     pub FECProActivePackets: u16,
4753     pub FECGroupSize: u8,
4754     pub fFECOnDemandParityEnabled: super::super::Foundation::BOOLEAN,
4755 }
4756 #[cfg(feature = "Win32_Foundation")]
4757 impl RM_FEC_INFO {}
4758 #[cfg(feature = "Win32_Foundation")]
4759 impl ::std::default::Default for RM_FEC_INFO {
default() -> Self4760     fn default() -> Self {
4761         unsafe { ::std::mem::zeroed() }
4762     }
4763 }
4764 #[cfg(feature = "Win32_Foundation")]
4765 impl ::std::fmt::Debug for RM_FEC_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4766     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4767         fmt.debug_struct("RM_FEC_INFO").field("FECBlockSize", &self.FECBlockSize).field("FECProActivePackets", &self.FECProActivePackets).field("FECGroupSize", &self.FECGroupSize).field("fFECOnDemandParityEnabled", &self.fFECOnDemandParityEnabled).finish()
4768     }
4769 }
4770 #[cfg(feature = "Win32_Foundation")]
4771 impl ::std::cmp::PartialEq for RM_FEC_INFO {
eq(&self, other: &Self) -> bool4772     fn eq(&self, other: &Self) -> bool {
4773         self.FECBlockSize == other.FECBlockSize && self.FECProActivePackets == other.FECProActivePackets && self.FECGroupSize == other.FECGroupSize && self.fFECOnDemandParityEnabled == other.fFECOnDemandParityEnabled
4774     }
4775 }
4776 #[cfg(feature = "Win32_Foundation")]
4777 impl ::std::cmp::Eq for RM_FEC_INFO {}
4778 #[cfg(feature = "Win32_Foundation")]
4779 unsafe impl ::windows::runtime::Abi for RM_FEC_INFO {
4780     type Abi = Self;
4781     type DefaultType = Self;
4782 }
4783 pub const RM_FLUSHCACHE: u32 = 1003u32;
4784 pub const RM_HIGH_SPEED_INTRANET_OPT: u32 = 1014u32;
4785 pub const RM_LATEJOIN: u32 = 1006u32;
4786 pub const RM_OPTIONSBASE: u32 = 1000u32;
4787 pub const RM_RATE_WINDOW_SIZE: u32 = 1001u32;
4788 pub const RM_RECEIVER_STATISTICS: u32 = 1013u32;
4789 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4790 #[repr(C)]
4791 pub struct RM_RECEIVER_STATS {
4792     pub NumODataPacketsReceived: u64,
4793     pub NumRDataPacketsReceived: u64,
4794     pub NumDuplicateDataPackets: u64,
4795     pub DataBytesReceived: u64,
4796     pub TotalBytesReceived: u64,
4797     pub RateKBitsPerSecOverall: u64,
4798     pub RateKBitsPerSecLast: u64,
4799     pub TrailingEdgeSeqId: u64,
4800     pub LeadingEdgeSeqId: u64,
4801     pub AverageSequencesInWindow: u64,
4802     pub MinSequencesInWindow: u64,
4803     pub MaxSequencesInWindow: u64,
4804     pub FirstNakSequenceNumber: u64,
4805     pub NumPendingNaks: u64,
4806     pub NumOutstandingNaks: u64,
4807     pub NumDataPacketsBuffered: u64,
4808     pub TotalSelectiveNaksSent: u64,
4809     pub TotalParityNaksSent: u64,
4810 }
4811 impl RM_RECEIVER_STATS {}
4812 impl ::std::default::Default for RM_RECEIVER_STATS {
default() -> Self4813     fn default() -> Self {
4814         unsafe { ::std::mem::zeroed() }
4815     }
4816 }
4817 impl ::std::fmt::Debug for RM_RECEIVER_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4818     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4819         fmt.debug_struct("RM_RECEIVER_STATS")
4820             .field("NumODataPacketsReceived", &self.NumODataPacketsReceived)
4821             .field("NumRDataPacketsReceived", &self.NumRDataPacketsReceived)
4822             .field("NumDuplicateDataPackets", &self.NumDuplicateDataPackets)
4823             .field("DataBytesReceived", &self.DataBytesReceived)
4824             .field("TotalBytesReceived", &self.TotalBytesReceived)
4825             .field("RateKBitsPerSecOverall", &self.RateKBitsPerSecOverall)
4826             .field("RateKBitsPerSecLast", &self.RateKBitsPerSecLast)
4827             .field("TrailingEdgeSeqId", &self.TrailingEdgeSeqId)
4828             .field("LeadingEdgeSeqId", &self.LeadingEdgeSeqId)
4829             .field("AverageSequencesInWindow", &self.AverageSequencesInWindow)
4830             .field("MinSequencesInWindow", &self.MinSequencesInWindow)
4831             .field("MaxSequencesInWindow", &self.MaxSequencesInWindow)
4832             .field("FirstNakSequenceNumber", &self.FirstNakSequenceNumber)
4833             .field("NumPendingNaks", &self.NumPendingNaks)
4834             .field("NumOutstandingNaks", &self.NumOutstandingNaks)
4835             .field("NumDataPacketsBuffered", &self.NumDataPacketsBuffered)
4836             .field("TotalSelectiveNaksSent", &self.TotalSelectiveNaksSent)
4837             .field("TotalParityNaksSent", &self.TotalParityNaksSent)
4838             .finish()
4839     }
4840 }
4841 impl ::std::cmp::PartialEq for RM_RECEIVER_STATS {
eq(&self, other: &Self) -> bool4842     fn eq(&self, other: &Self) -> bool {
4843         self.NumODataPacketsReceived == other.NumODataPacketsReceived
4844             && self.NumRDataPacketsReceived == other.NumRDataPacketsReceived
4845             && self.NumDuplicateDataPackets == other.NumDuplicateDataPackets
4846             && self.DataBytesReceived == other.DataBytesReceived
4847             && self.TotalBytesReceived == other.TotalBytesReceived
4848             && self.RateKBitsPerSecOverall == other.RateKBitsPerSecOverall
4849             && self.RateKBitsPerSecLast == other.RateKBitsPerSecLast
4850             && self.TrailingEdgeSeqId == other.TrailingEdgeSeqId
4851             && self.LeadingEdgeSeqId == other.LeadingEdgeSeqId
4852             && self.AverageSequencesInWindow == other.AverageSequencesInWindow
4853             && self.MinSequencesInWindow == other.MinSequencesInWindow
4854             && self.MaxSequencesInWindow == other.MaxSequencesInWindow
4855             && self.FirstNakSequenceNumber == other.FirstNakSequenceNumber
4856             && self.NumPendingNaks == other.NumPendingNaks
4857             && self.NumOutstandingNaks == other.NumOutstandingNaks
4858             && self.NumDataPacketsBuffered == other.NumDataPacketsBuffered
4859             && self.TotalSelectiveNaksSent == other.TotalSelectiveNaksSent
4860             && self.TotalParityNaksSent == other.TotalParityNaksSent
4861     }
4862 }
4863 impl ::std::cmp::Eq for RM_RECEIVER_STATS {}
4864 unsafe impl ::windows::runtime::Abi for RM_RECEIVER_STATS {
4865     type Abi = Self;
4866     type DefaultType = Self;
4867 }
4868 pub const RM_SENDER_STATISTICS: u32 = 1005u32;
4869 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4870 #[repr(C)]
4871 pub struct RM_SENDER_STATS {
4872     pub DataBytesSent: u64,
4873     pub TotalBytesSent: u64,
4874     pub NaksReceived: u64,
4875     pub NaksReceivedTooLate: u64,
4876     pub NumOutstandingNaks: u64,
4877     pub NumNaksAfterRData: u64,
4878     pub RepairPacketsSent: u64,
4879     pub BufferSpaceAvailable: u64,
4880     pub TrailingEdgeSeqId: u64,
4881     pub LeadingEdgeSeqId: u64,
4882     pub RateKBitsPerSecOverall: u64,
4883     pub RateKBitsPerSecLast: u64,
4884     pub TotalODataPacketsSent: u64,
4885 }
4886 impl RM_SENDER_STATS {}
4887 impl ::std::default::Default for RM_SENDER_STATS {
default() -> Self4888     fn default() -> Self {
4889         unsafe { ::std::mem::zeroed() }
4890     }
4891 }
4892 impl ::std::fmt::Debug for RM_SENDER_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4893     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4894         fmt.debug_struct("RM_SENDER_STATS")
4895             .field("DataBytesSent", &self.DataBytesSent)
4896             .field("TotalBytesSent", &self.TotalBytesSent)
4897             .field("NaksReceived", &self.NaksReceived)
4898             .field("NaksReceivedTooLate", &self.NaksReceivedTooLate)
4899             .field("NumOutstandingNaks", &self.NumOutstandingNaks)
4900             .field("NumNaksAfterRData", &self.NumNaksAfterRData)
4901             .field("RepairPacketsSent", &self.RepairPacketsSent)
4902             .field("BufferSpaceAvailable", &self.BufferSpaceAvailable)
4903             .field("TrailingEdgeSeqId", &self.TrailingEdgeSeqId)
4904             .field("LeadingEdgeSeqId", &self.LeadingEdgeSeqId)
4905             .field("RateKBitsPerSecOverall", &self.RateKBitsPerSecOverall)
4906             .field("RateKBitsPerSecLast", &self.RateKBitsPerSecLast)
4907             .field("TotalODataPacketsSent", &self.TotalODataPacketsSent)
4908             .finish()
4909     }
4910 }
4911 impl ::std::cmp::PartialEq for RM_SENDER_STATS {
eq(&self, other: &Self) -> bool4912     fn eq(&self, other: &Self) -> bool {
4913         self.DataBytesSent == other.DataBytesSent
4914             && self.TotalBytesSent == other.TotalBytesSent
4915             && self.NaksReceived == other.NaksReceived
4916             && self.NaksReceivedTooLate == other.NaksReceivedTooLate
4917             && self.NumOutstandingNaks == other.NumOutstandingNaks
4918             && self.NumNaksAfterRData == other.NumNaksAfterRData
4919             && self.RepairPacketsSent == other.RepairPacketsSent
4920             && self.BufferSpaceAvailable == other.BufferSpaceAvailable
4921             && self.TrailingEdgeSeqId == other.TrailingEdgeSeqId
4922             && self.LeadingEdgeSeqId == other.LeadingEdgeSeqId
4923             && self.RateKBitsPerSecOverall == other.RateKBitsPerSecOverall
4924             && self.RateKBitsPerSecLast == other.RateKBitsPerSecLast
4925             && self.TotalODataPacketsSent == other.TotalODataPacketsSent
4926     }
4927 }
4928 impl ::std::cmp::Eq for RM_SENDER_STATS {}
4929 unsafe impl ::windows::runtime::Abi for RM_SENDER_STATS {
4930     type Abi = Self;
4931     type DefaultType = Self;
4932 }
4933 pub const RM_SENDER_WINDOW_ADVANCE_METHOD: u32 = 1004u32;
4934 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4935 #[repr(C)]
4936 pub struct RM_SEND_WINDOW {
4937     pub RateKbitsPerSec: u32,
4938     pub WindowSizeInMSecs: u32,
4939     pub WindowSizeInBytes: u32,
4940 }
4941 impl RM_SEND_WINDOW {}
4942 impl ::std::default::Default for RM_SEND_WINDOW {
default() -> Self4943     fn default() -> Self {
4944         unsafe { ::std::mem::zeroed() }
4945     }
4946 }
4947 impl ::std::fmt::Debug for RM_SEND_WINDOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4948     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4949         fmt.debug_struct("RM_SEND_WINDOW").field("RateKbitsPerSec", &self.RateKbitsPerSec).field("WindowSizeInMSecs", &self.WindowSizeInMSecs).field("WindowSizeInBytes", &self.WindowSizeInBytes).finish()
4950     }
4951 }
4952 impl ::std::cmp::PartialEq for RM_SEND_WINDOW {
eq(&self, other: &Self) -> bool4953     fn eq(&self, other: &Self) -> bool {
4954         self.RateKbitsPerSec == other.RateKbitsPerSec && self.WindowSizeInMSecs == other.WindowSizeInMSecs && self.WindowSizeInBytes == other.WindowSizeInBytes
4955     }
4956 }
4957 impl ::std::cmp::Eq for RM_SEND_WINDOW {}
4958 unsafe impl ::windows::runtime::Abi for RM_SEND_WINDOW {
4959     type Abi = Self;
4960     type DefaultType = Self;
4961 }
4962 pub const RM_SEND_WINDOW_ADV_RATE: u32 = 1010u32;
4963 pub const RM_SET_MCAST_TTL: u32 = 1012u32;
4964 pub const RM_SET_MESSAGE_BOUNDARY: u32 = 1002u32;
4965 pub const RM_SET_SEND_IF: u32 = 1007u32;
4966 pub const RM_USE_FEC: u32 = 1011u32;
4967 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4968 #[repr(C)]
4969 #[cfg(feature = "Win32_Foundation")]
4970 pub struct RSS_SCALABILITY_INFO {
4971     pub RssEnabled: super::super::Foundation::BOOLEAN,
4972 }
4973 #[cfg(feature = "Win32_Foundation")]
4974 impl RSS_SCALABILITY_INFO {}
4975 #[cfg(feature = "Win32_Foundation")]
4976 impl ::std::default::Default for RSS_SCALABILITY_INFO {
default() -> Self4977     fn default() -> Self {
4978         unsafe { ::std::mem::zeroed() }
4979     }
4980 }
4981 #[cfg(feature = "Win32_Foundation")]
4982 impl ::std::fmt::Debug for RSS_SCALABILITY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4983     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4984         fmt.debug_struct("RSS_SCALABILITY_INFO").field("RssEnabled", &self.RssEnabled).finish()
4985     }
4986 }
4987 #[cfg(feature = "Win32_Foundation")]
4988 impl ::std::cmp::PartialEq for RSS_SCALABILITY_INFO {
eq(&self, other: &Self) -> bool4989     fn eq(&self, other: &Self) -> bool {
4990         self.RssEnabled == other.RssEnabled
4991     }
4992 }
4993 #[cfg(feature = "Win32_Foundation")]
4994 impl ::std::cmp::Eq for RSS_SCALABILITY_INFO {}
4995 #[cfg(feature = "Win32_Foundation")]
4996 unsafe impl ::windows::runtime::Abi for RSS_SCALABILITY_INFO {
4997     type Abi = Self;
4998     type DefaultType = Self;
4999 }
5000 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_WindowsFilteringPlatform"))]
5001 #[inline]
RtlEthernetAddressToStringA(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR5002 pub unsafe fn RtlEthernetAddressToStringA(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR {
5003     #[cfg(windows)]
5004     {
5005         #[link(name = "windows")]
5006         extern "system" {
5007             fn RtlEthernetAddressToStringA(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR;
5008         }
5009         ::std::mem::transmute(RtlEthernetAddressToStringA(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5010     }
5011     #[cfg(not(windows))]
5012     unimplemented!("Unsupported target OS");
5013 }
5014 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_WindowsFilteringPlatform"))]
5015 #[inline]
RtlEthernetAddressToStringW(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR5016 pub unsafe fn RtlEthernetAddressToStringW(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR {
5017     #[cfg(windows)]
5018     {
5019         #[link(name = "windows")]
5020         extern "system" {
5021             fn RtlEthernetAddressToStringW(addr: *const super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR;
5022         }
5023         ::std::mem::transmute(RtlEthernetAddressToStringW(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5024     }
5025     #[cfg(not(windows))]
5026     unimplemented!("Unsupported target OS");
5027 }
5028 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_WindowsFilteringPlatform"))]
5029 #[inline]
RtlEthernetStringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, terminator: *mut super::super::Foundation::PSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i325030 pub unsafe fn RtlEthernetStringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, terminator: *mut super::super::Foundation::PSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i32 {
5031     #[cfg(windows)]
5032     {
5033         #[link(name = "windows")]
5034         extern "system" {
5035             fn RtlEthernetStringToAddressA(s: super::super::Foundation::PSTR, terminator: *mut super::super::Foundation::PSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i32;
5036         }
5037         ::std::mem::transmute(RtlEthernetStringToAddressA(s.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5038     }
5039     #[cfg(not(windows))]
5040     unimplemented!("Unsupported target OS");
5041 }
5042 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_WindowsFilteringPlatform"))]
5043 #[inline]
RtlEthernetStringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(s: Param0, terminator: *mut super::super::Foundation::PWSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i325044 pub unsafe fn RtlEthernetStringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(s: Param0, terminator: *mut super::super::Foundation::PWSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i32 {
5045     #[cfg(windows)]
5046     {
5047         #[link(name = "windows")]
5048         extern "system" {
5049             fn RtlEthernetStringToAddressW(s: super::super::Foundation::PWSTR, terminator: *mut super::super::Foundation::PWSTR, addr: *mut super::super::NetworkManagement::WindowsFilteringPlatform::DL_EUI48) -> i32;
5050         }
5051         ::std::mem::transmute(RtlEthernetStringToAddressW(s.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5052     }
5053     #[cfg(not(windows))]
5054     unimplemented!("Unsupported target OS");
5055 }
5056 #[cfg(feature = "Win32_Foundation")]
5057 #[inline]
RtlIpv4AddressToStringA(addr: *const IN_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR5058 pub unsafe fn RtlIpv4AddressToStringA(addr: *const IN_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR {
5059     #[cfg(windows)]
5060     {
5061         #[link(name = "windows")]
5062         extern "system" {
5063             fn RtlIpv4AddressToStringA(addr: *const IN_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR;
5064         }
5065         ::std::mem::transmute(RtlIpv4AddressToStringA(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5066     }
5067     #[cfg(not(windows))]
5068     unimplemented!("Unsupported target OS");
5069 }
5070 #[cfg(feature = "Win32_Foundation")]
5071 #[inline]
RtlIpv4AddressToStringExA(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i325072 pub unsafe fn RtlIpv4AddressToStringExA(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i32 {
5073     #[cfg(windows)]
5074     {
5075         #[link(name = "windows")]
5076         extern "system" {
5077             fn RtlIpv4AddressToStringExA(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i32;
5078         }
5079         ::std::mem::transmute(RtlIpv4AddressToStringExA(::std::mem::transmute(address), ::std::mem::transmute(port), ::std::mem::transmute(addressstring), ::std::mem::transmute(addressstringlength)))
5080     }
5081     #[cfg(not(windows))]
5082     unimplemented!("Unsupported target OS");
5083 }
5084 #[cfg(feature = "Win32_Foundation")]
5085 #[inline]
RtlIpv4AddressToStringExW(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i325086 pub unsafe fn RtlIpv4AddressToStringExW(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i32 {
5087     #[cfg(windows)]
5088     {
5089         #[link(name = "windows")]
5090         extern "system" {
5091             fn RtlIpv4AddressToStringExW(address: *const IN_ADDR, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i32;
5092         }
5093         ::std::mem::transmute(RtlIpv4AddressToStringExW(::std::mem::transmute(address), ::std::mem::transmute(port), ::std::mem::transmute(addressstring), ::std::mem::transmute(addressstringlength)))
5094     }
5095     #[cfg(not(windows))]
5096     unimplemented!("Unsupported target OS");
5097 }
5098 #[cfg(feature = "Win32_Foundation")]
5099 #[inline]
RtlIpv4AddressToStringW(addr: *const IN_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR5100 pub unsafe fn RtlIpv4AddressToStringW(addr: *const IN_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR {
5101     #[cfg(windows)]
5102     {
5103         #[link(name = "windows")]
5104         extern "system" {
5105             fn RtlIpv4AddressToStringW(addr: *const IN_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR;
5106         }
5107         ::std::mem::transmute(RtlIpv4AddressToStringW(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5108     }
5109     #[cfg(not(windows))]
5110     unimplemented!("Unsupported target OS");
5111 }
5112 #[cfg(feature = "Win32_Foundation")]
5113 #[inline]
RtlIpv4StringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(s: Param0, strict: Param1, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN_ADDR) -> i325114 pub unsafe fn RtlIpv4StringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(s: Param0, strict: Param1, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN_ADDR) -> i32 {
5115     #[cfg(windows)]
5116     {
5117         #[link(name = "windows")]
5118         extern "system" {
5119             fn RtlIpv4StringToAddressA(s: super::super::Foundation::PSTR, strict: super::super::Foundation::BOOLEAN, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN_ADDR) -> i32;
5120         }
5121         ::std::mem::transmute(RtlIpv4StringToAddressA(s.into_param().abi(), strict.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5122     }
5123     #[cfg(not(windows))]
5124     unimplemented!("Unsupported target OS");
5125 }
5126 #[cfg(feature = "Win32_Foundation")]
5127 #[inline]
RtlIpv4StringToAddressExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(addressstring: Param0, strict: Param1, address: *mut IN_ADDR, port: *mut u16) -> i325128 pub unsafe fn RtlIpv4StringToAddressExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(addressstring: Param0, strict: Param1, address: *mut IN_ADDR, port: *mut u16) -> i32 {
5129     #[cfg(windows)]
5130     {
5131         #[link(name = "windows")]
5132         extern "system" {
5133             fn RtlIpv4StringToAddressExA(addressstring: super::super::Foundation::PSTR, strict: super::super::Foundation::BOOLEAN, address: *mut IN_ADDR, port: *mut u16) -> i32;
5134         }
5135         ::std::mem::transmute(RtlIpv4StringToAddressExA(addressstring.into_param().abi(), strict.into_param().abi(), ::std::mem::transmute(address), ::std::mem::transmute(port)))
5136     }
5137     #[cfg(not(windows))]
5138     unimplemented!("Unsupported target OS");
5139 }
5140 #[cfg(feature = "Win32_Foundation")]
5141 #[inline]
RtlIpv4StringToAddressExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(addressstring: Param0, strict: Param1, address: *mut IN_ADDR, port: *mut u16) -> i325142 pub unsafe fn RtlIpv4StringToAddressExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(addressstring: Param0, strict: Param1, address: *mut IN_ADDR, port: *mut u16) -> i32 {
5143     #[cfg(windows)]
5144     {
5145         #[link(name = "windows")]
5146         extern "system" {
5147             fn RtlIpv4StringToAddressExW(addressstring: super::super::Foundation::PWSTR, strict: super::super::Foundation::BOOLEAN, address: *mut IN_ADDR, port: *mut u16) -> i32;
5148         }
5149         ::std::mem::transmute(RtlIpv4StringToAddressExW(addressstring.into_param().abi(), strict.into_param().abi(), ::std::mem::transmute(address), ::std::mem::transmute(port)))
5150     }
5151     #[cfg(not(windows))]
5152     unimplemented!("Unsupported target OS");
5153 }
5154 #[cfg(feature = "Win32_Foundation")]
5155 #[inline]
RtlIpv4StringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(s: Param0, strict: Param1, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN_ADDR) -> i325156 pub unsafe fn RtlIpv4StringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOLEAN>>(s: Param0, strict: Param1, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN_ADDR) -> i32 {
5157     #[cfg(windows)]
5158     {
5159         #[link(name = "windows")]
5160         extern "system" {
5161             fn RtlIpv4StringToAddressW(s: super::super::Foundation::PWSTR, strict: super::super::Foundation::BOOLEAN, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN_ADDR) -> i32;
5162         }
5163         ::std::mem::transmute(RtlIpv4StringToAddressW(s.into_param().abi(), strict.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5164     }
5165     #[cfg(not(windows))]
5166     unimplemented!("Unsupported target OS");
5167 }
5168 #[cfg(feature = "Win32_Foundation")]
5169 #[inline]
RtlIpv6AddressToStringA(addr: *const IN6_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR5170 pub unsafe fn RtlIpv6AddressToStringA(addr: *const IN6_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR {
5171     #[cfg(windows)]
5172     {
5173         #[link(name = "windows")]
5174         extern "system" {
5175             fn RtlIpv6AddressToStringA(addr: *const IN6_ADDR, s: super::super::Foundation::PSTR) -> super::super::Foundation::PSTR;
5176         }
5177         ::std::mem::transmute(RtlIpv6AddressToStringA(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5178     }
5179     #[cfg(not(windows))]
5180     unimplemented!("Unsupported target OS");
5181 }
5182 #[cfg(feature = "Win32_Foundation")]
5183 #[inline]
RtlIpv6AddressToStringExA(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i325184 pub unsafe fn RtlIpv6AddressToStringExA(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i32 {
5185     #[cfg(windows)]
5186     {
5187         #[link(name = "windows")]
5188         extern "system" {
5189             fn RtlIpv6AddressToStringExA(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PSTR, addressstringlength: *mut u32) -> i32;
5190         }
5191         ::std::mem::transmute(RtlIpv6AddressToStringExA(::std::mem::transmute(address), ::std::mem::transmute(scopeid), ::std::mem::transmute(port), ::std::mem::transmute(addressstring), ::std::mem::transmute(addressstringlength)))
5192     }
5193     #[cfg(not(windows))]
5194     unimplemented!("Unsupported target OS");
5195 }
5196 #[cfg(feature = "Win32_Foundation")]
5197 #[inline]
RtlIpv6AddressToStringExW(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i325198 pub unsafe fn RtlIpv6AddressToStringExW(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i32 {
5199     #[cfg(windows)]
5200     {
5201         #[link(name = "windows")]
5202         extern "system" {
5203             fn RtlIpv6AddressToStringExW(address: *const IN6_ADDR, scopeid: u32, port: u16, addressstring: super::super::Foundation::PWSTR, addressstringlength: *mut u32) -> i32;
5204         }
5205         ::std::mem::transmute(RtlIpv6AddressToStringExW(::std::mem::transmute(address), ::std::mem::transmute(scopeid), ::std::mem::transmute(port), ::std::mem::transmute(addressstring), ::std::mem::transmute(addressstringlength)))
5206     }
5207     #[cfg(not(windows))]
5208     unimplemented!("Unsupported target OS");
5209 }
5210 #[cfg(feature = "Win32_Foundation")]
5211 #[inline]
RtlIpv6AddressToStringW(addr: *const IN6_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR5212 pub unsafe fn RtlIpv6AddressToStringW(addr: *const IN6_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR {
5213     #[cfg(windows)]
5214     {
5215         #[link(name = "windows")]
5216         extern "system" {
5217             fn RtlIpv6AddressToStringW(addr: *const IN6_ADDR, s: super::super::Foundation::PWSTR) -> super::super::Foundation::PWSTR;
5218         }
5219         ::std::mem::transmute(RtlIpv6AddressToStringW(::std::mem::transmute(addr), ::std::mem::transmute(s)))
5220     }
5221     #[cfg(not(windows))]
5222     unimplemented!("Unsupported target OS");
5223 }
5224 #[cfg(feature = "Win32_Foundation")]
5225 #[inline]
RtlIpv6StringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN6_ADDR) -> i325226 pub unsafe fn RtlIpv6StringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN6_ADDR) -> i32 {
5227     #[cfg(windows)]
5228     {
5229         #[link(name = "windows")]
5230         extern "system" {
5231             fn RtlIpv6StringToAddressA(s: super::super::Foundation::PSTR, terminator: *mut super::super::Foundation::PSTR, addr: *mut IN6_ADDR) -> i32;
5232         }
5233         ::std::mem::transmute(RtlIpv6StringToAddressA(s.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5234     }
5235     #[cfg(not(windows))]
5236     unimplemented!("Unsupported target OS");
5237 }
5238 #[cfg(feature = "Win32_Foundation")]
5239 #[inline]
RtlIpv6StringToAddressExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addressstring: Param0, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i325240 pub unsafe fn RtlIpv6StringToAddressExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addressstring: Param0, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i32 {
5241     #[cfg(windows)]
5242     {
5243         #[link(name = "windows")]
5244         extern "system" {
5245             fn RtlIpv6StringToAddressExA(addressstring: super::super::Foundation::PSTR, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i32;
5246         }
5247         ::std::mem::transmute(RtlIpv6StringToAddressExA(addressstring.into_param().abi(), ::std::mem::transmute(address), ::std::mem::transmute(scopeid), ::std::mem::transmute(port)))
5248     }
5249     #[cfg(not(windows))]
5250     unimplemented!("Unsupported target OS");
5251 }
5252 #[cfg(feature = "Win32_Foundation")]
5253 #[inline]
RtlIpv6StringToAddressExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(addressstring: Param0, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i325254 pub unsafe fn RtlIpv6StringToAddressExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(addressstring: Param0, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i32 {
5255     #[cfg(windows)]
5256     {
5257         #[link(name = "windows")]
5258         extern "system" {
5259             fn RtlIpv6StringToAddressExW(addressstring: super::super::Foundation::PWSTR, address: *mut IN6_ADDR, scopeid: *mut u32, port: *mut u16) -> i32;
5260         }
5261         ::std::mem::transmute(RtlIpv6StringToAddressExW(addressstring.into_param().abi(), ::std::mem::transmute(address), ::std::mem::transmute(scopeid), ::std::mem::transmute(port)))
5262     }
5263     #[cfg(not(windows))]
5264     unimplemented!("Unsupported target OS");
5265 }
5266 #[cfg(feature = "Win32_Foundation")]
5267 #[inline]
RtlIpv6StringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(s: Param0, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN6_ADDR) -> i325268 pub unsafe fn RtlIpv6StringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(s: Param0, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN6_ADDR) -> i32 {
5269     #[cfg(windows)]
5270     {
5271         #[link(name = "windows")]
5272         extern "system" {
5273             fn RtlIpv6StringToAddressW(s: super::super::Foundation::PWSTR, terminator: *mut super::super::Foundation::PWSTR, addr: *mut IN6_ADDR) -> i32;
5274         }
5275         ::std::mem::transmute(RtlIpv6StringToAddressW(s.into_param().abi(), ::std::mem::transmute(terminator), ::std::mem::transmute(addr)))
5276     }
5277     #[cfg(not(windows))]
5278     unimplemented!("Unsupported target OS");
5279 }
5280 pub const SAP_FIELD_ABSENT: u32 = 4294967294u32;
5281 pub const SAP_FIELD_ANY: u32 = 4294967295u32;
5282 pub const SAP_FIELD_ANY_AESA_REST: u32 = 4294967291u32;
5283 pub const SAP_FIELD_ANY_AESA_SEL: u32 = 4294967290u32;
5284 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5285 #[repr(C)]
5286 pub struct SCOPE_ID {
5287     pub Anonymous: SCOPE_ID_0,
5288 }
5289 impl SCOPE_ID {}
5290 impl ::std::default::Default for SCOPE_ID {
default() -> Self5291     fn default() -> Self {
5292         unsafe { ::std::mem::zeroed() }
5293     }
5294 }
5295 impl ::std::cmp::PartialEq for SCOPE_ID {
eq(&self, _other: &Self) -> bool5296     fn eq(&self, _other: &Self) -> bool {
5297         unimplemented!()
5298     }
5299 }
5300 impl ::std::cmp::Eq for SCOPE_ID {}
5301 unsafe impl ::windows::runtime::Abi for SCOPE_ID {
5302     type Abi = Self;
5303     type DefaultType = Self;
5304 }
5305 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5306 #[repr(C)]
5307 pub union SCOPE_ID_0 {
5308     pub Anonymous: SCOPE_ID_0_0,
5309     pub Value: u32,
5310 }
5311 impl SCOPE_ID_0 {}
5312 impl ::std::default::Default for SCOPE_ID_0 {
default() -> Self5313     fn default() -> Self {
5314         unsafe { ::std::mem::zeroed() }
5315     }
5316 }
5317 impl ::std::cmp::PartialEq for SCOPE_ID_0 {
eq(&self, _other: &Self) -> bool5318     fn eq(&self, _other: &Self) -> bool {
5319         unimplemented!()
5320     }
5321 }
5322 impl ::std::cmp::Eq for SCOPE_ID_0 {}
5323 unsafe impl ::windows::runtime::Abi for SCOPE_ID_0 {
5324     type Abi = Self;
5325     type DefaultType = Self;
5326 }
5327 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5328 #[repr(C)]
5329 pub struct SCOPE_ID_0_0 {
5330     pub _bitfield: u32,
5331 }
5332 impl SCOPE_ID_0_0 {}
5333 impl ::std::default::Default for SCOPE_ID_0_0 {
default() -> Self5334     fn default() -> Self {
5335         unsafe { ::std::mem::zeroed() }
5336     }
5337 }
5338 impl ::std::fmt::Debug for SCOPE_ID_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5339     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5340         fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
5341     }
5342 }
5343 impl ::std::cmp::PartialEq for SCOPE_ID_0_0 {
eq(&self, other: &Self) -> bool5344     fn eq(&self, other: &Self) -> bool {
5345         self._bitfield == other._bitfield
5346     }
5347 }
5348 impl ::std::cmp::Eq for SCOPE_ID_0_0 {}
5349 unsafe impl ::windows::runtime::Abi for SCOPE_ID_0_0 {
5350     type Abi = Self;
5351     type DefaultType = Self;
5352 }
5353 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5354 #[repr(transparent)]
5355 pub struct SCOPE_LEVEL(pub i32);
5356 pub const ScopeLevelInterface: SCOPE_LEVEL = SCOPE_LEVEL(1i32);
5357 pub const ScopeLevelLink: SCOPE_LEVEL = SCOPE_LEVEL(2i32);
5358 pub const ScopeLevelSubnet: SCOPE_LEVEL = SCOPE_LEVEL(3i32);
5359 pub const ScopeLevelAdmin: SCOPE_LEVEL = SCOPE_LEVEL(4i32);
5360 pub const ScopeLevelSite: SCOPE_LEVEL = SCOPE_LEVEL(5i32);
5361 pub const ScopeLevelOrganization: SCOPE_LEVEL = SCOPE_LEVEL(8i32);
5362 pub const ScopeLevelGlobal: SCOPE_LEVEL = SCOPE_LEVEL(14i32);
5363 pub const ScopeLevelCount: SCOPE_LEVEL = SCOPE_LEVEL(16i32);
5364 impl ::std::convert::From<i32> for SCOPE_LEVEL {
from(value: i32) -> Self5365     fn from(value: i32) -> Self {
5366         Self(value)
5367     }
5368 }
5369 unsafe impl ::windows::runtime::Abi for SCOPE_LEVEL {
5370     type Abi = Self;
5371     type DefaultType = Self;
5372 }
5373 pub const SD_BOTH: u32 = 2u32;
5374 pub const SD_RECEIVE: u32 = 0u32;
5375 pub const SD_SEND: u32 = 1u32;
5376 pub const SECURITY_PROTOCOL_NONE: u32 = 0u32;
5377 pub const SENDER_DEFAULT_LATE_JOINER_PERCENTAGE: u32 = 0u32;
5378 pub const SENDER_DEFAULT_RATE_KBITS_PER_SEC: u32 = 56u32;
5379 pub const SENDER_DEFAULT_WINDOW_ADV_PERCENTAGE: u32 = 15u32;
5380 pub const SENDER_MAX_LATE_JOINER_PERCENTAGE: u32 = 75u32;
5381 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5382 #[repr(transparent)]
5383 pub struct SEND_FLAGS(pub u32);
5384 pub const MSG_DONTROUTE: SEND_FLAGS = SEND_FLAGS(4u32);
5385 pub const MSG_OOB: SEND_FLAGS = SEND_FLAGS(1u32);
5386 impl ::std::convert::From<u32> for SEND_FLAGS {
from(value: u32) -> Self5387     fn from(value: u32) -> Self {
5388         Self(value)
5389     }
5390 }
5391 unsafe impl ::windows::runtime::Abi for SEND_FLAGS {
5392     type Abi = Self;
5393     type DefaultType = Self;
5394 }
5395 impl ::std::ops::BitOr for SEND_FLAGS {
5396     type Output = Self;
bitor(self, rhs: Self) -> Self5397     fn bitor(self, rhs: Self) -> Self {
5398         Self(self.0 | rhs.0)
5399     }
5400 }
5401 impl ::std::ops::BitAnd for SEND_FLAGS {
5402     type Output = Self;
bitand(self, rhs: Self) -> Self5403     fn bitand(self, rhs: Self) -> Self {
5404         Self(self.0 & rhs.0)
5405     }
5406 }
5407 impl ::std::ops::BitOrAssign for SEND_FLAGS {
bitor_assign(&mut self, rhs: Self)5408     fn bitor_assign(&mut self, rhs: Self) {
5409         self.0.bitor_assign(rhs.0)
5410     }
5411 }
5412 impl ::std::ops::BitAndAssign for SEND_FLAGS {
bitand_assign(&mut self, rhs: Self)5413     fn bitand_assign(&mut self, rhs: Self) {
5414         self.0.bitand_assign(rhs.0)
5415     }
5416 }
5417 impl ::std::ops::Not for SEND_FLAGS {
5418     type Output = Self;
not(self) -> Self5419     fn not(self) -> Self {
5420         Self(self.0.not())
5421     }
5422 }
5423 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5424 #[repr(C)]
5425 pub struct SERVICE_ADDRESS {
5426     pub dwAddressType: u32,
5427     pub dwAddressFlags: u32,
5428     pub dwAddressLength: u32,
5429     pub dwPrincipalLength: u32,
5430     pub lpAddress: *mut u8,
5431     pub lpPrincipal: *mut u8,
5432 }
5433 impl SERVICE_ADDRESS {}
5434 impl ::std::default::Default for SERVICE_ADDRESS {
default() -> Self5435     fn default() -> Self {
5436         unsafe { ::std::mem::zeroed() }
5437     }
5438 }
5439 impl ::std::fmt::Debug for SERVICE_ADDRESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5440     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5441         fmt.debug_struct("SERVICE_ADDRESS")
5442             .field("dwAddressType", &self.dwAddressType)
5443             .field("dwAddressFlags", &self.dwAddressFlags)
5444             .field("dwAddressLength", &self.dwAddressLength)
5445             .field("dwPrincipalLength", &self.dwPrincipalLength)
5446             .field("lpAddress", &self.lpAddress)
5447             .field("lpPrincipal", &self.lpPrincipal)
5448             .finish()
5449     }
5450 }
5451 impl ::std::cmp::PartialEq for SERVICE_ADDRESS {
eq(&self, other: &Self) -> bool5452     fn eq(&self, other: &Self) -> bool {
5453         self.dwAddressType == other.dwAddressType && self.dwAddressFlags == other.dwAddressFlags && self.dwAddressLength == other.dwAddressLength && self.dwPrincipalLength == other.dwPrincipalLength && self.lpAddress == other.lpAddress && self.lpPrincipal == other.lpPrincipal
5454     }
5455 }
5456 impl ::std::cmp::Eq for SERVICE_ADDRESS {}
5457 unsafe impl ::windows::runtime::Abi for SERVICE_ADDRESS {
5458     type Abi = Self;
5459     type DefaultType = Self;
5460 }
5461 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5462 #[repr(C)]
5463 pub struct SERVICE_ADDRESSES {
5464     pub dwAddressCount: u32,
5465     pub Addresses: [SERVICE_ADDRESS; 1],
5466 }
5467 impl SERVICE_ADDRESSES {}
5468 impl ::std::default::Default for SERVICE_ADDRESSES {
default() -> Self5469     fn default() -> Self {
5470         unsafe { ::std::mem::zeroed() }
5471     }
5472 }
5473 impl ::std::fmt::Debug for SERVICE_ADDRESSES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5474     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5475         fmt.debug_struct("SERVICE_ADDRESSES").field("dwAddressCount", &self.dwAddressCount).field("Addresses", &self.Addresses).finish()
5476     }
5477 }
5478 impl ::std::cmp::PartialEq for SERVICE_ADDRESSES {
eq(&self, other: &Self) -> bool5479     fn eq(&self, other: &Self) -> bool {
5480         self.dwAddressCount == other.dwAddressCount && self.Addresses == other.Addresses
5481     }
5482 }
5483 impl ::std::cmp::Eq for SERVICE_ADDRESSES {}
5484 unsafe impl ::windows::runtime::Abi for SERVICE_ADDRESSES {
5485     type Abi = Self;
5486     type DefaultType = Self;
5487 }
5488 pub const SERVICE_ADDRESS_FLAG_RPC_CN: u32 = 1u32;
5489 pub const SERVICE_ADDRESS_FLAG_RPC_DG: u32 = 2u32;
5490 pub const SERVICE_ADDRESS_FLAG_RPC_NB: u32 = 4u32;
5491 #[derive(:: std :: clone :: Clone)]
5492 #[repr(C)]
5493 #[cfg(feature = "Win32_Foundation")]
5494 pub struct SERVICE_ASYNC_INFO {
5495     pub lpServiceCallbackProc: ::std::option::Option<LPSERVICE_CALLBACK_PROC>,
5496     pub lParam: super::super::Foundation::LPARAM,
5497     pub hAsyncTaskHandle: super::super::Foundation::HANDLE,
5498 }
5499 #[cfg(feature = "Win32_Foundation")]
5500 impl SERVICE_ASYNC_INFO {}
5501 #[cfg(feature = "Win32_Foundation")]
5502 impl ::std::default::Default for SERVICE_ASYNC_INFO {
default() -> Self5503     fn default() -> Self {
5504         unsafe { ::std::mem::zeroed() }
5505     }
5506 }
5507 #[cfg(feature = "Win32_Foundation")]
5508 impl ::std::fmt::Debug for SERVICE_ASYNC_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5509     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5510         fmt.debug_struct("SERVICE_ASYNC_INFO").field("lParam", &self.lParam).field("hAsyncTaskHandle", &self.hAsyncTaskHandle).finish()
5511     }
5512 }
5513 #[cfg(feature = "Win32_Foundation")]
5514 impl ::std::cmp::PartialEq for SERVICE_ASYNC_INFO {
eq(&self, other: &Self) -> bool5515     fn eq(&self, other: &Self) -> bool {
5516         self.lpServiceCallbackProc.map(|f| f as usize) == other.lpServiceCallbackProc.map(|f| f as usize) && self.lParam == other.lParam && self.hAsyncTaskHandle == other.hAsyncTaskHandle
5517     }
5518 }
5519 #[cfg(feature = "Win32_Foundation")]
5520 impl ::std::cmp::Eq for SERVICE_ASYNC_INFO {}
5521 #[cfg(feature = "Win32_Foundation")]
5522 unsafe impl ::windows::runtime::Abi for SERVICE_ASYNC_INFO {
5523     type Abi = ::std::mem::ManuallyDrop<Self>;
5524     type DefaultType = Self;
5525 }
5526 pub const SERVICE_FLAG_DEFER: u32 = 1u32;
5527 pub const SERVICE_FLAG_HARD: u32 = 2u32;
5528 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5529 #[repr(C)]
5530 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5531 pub struct SERVICE_INFOA {
5532     pub lpServiceType: *mut ::windows::runtime::GUID,
5533     pub lpServiceName: super::super::Foundation::PSTR,
5534     pub lpComment: super::super::Foundation::PSTR,
5535     pub lpLocale: super::super::Foundation::PSTR,
5536     pub dwDisplayHint: RESOURCE_DISPLAY_TYPE,
5537     pub dwVersion: u32,
5538     pub dwTime: u32,
5539     pub lpMachineName: super::super::Foundation::PSTR,
5540     pub lpServiceAddress: *mut SERVICE_ADDRESSES,
5541     pub ServiceSpecificInfo: super::super::System::Com::BLOB,
5542 }
5543 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5544 impl SERVICE_INFOA {}
5545 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5546 impl ::std::default::Default for SERVICE_INFOA {
default() -> Self5547     fn default() -> Self {
5548         unsafe { ::std::mem::zeroed() }
5549     }
5550 }
5551 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5552 impl ::std::fmt::Debug for SERVICE_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5553     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5554         fmt.debug_struct("SERVICE_INFOA")
5555             .field("lpServiceType", &self.lpServiceType)
5556             .field("lpServiceName", &self.lpServiceName)
5557             .field("lpComment", &self.lpComment)
5558             .field("lpLocale", &self.lpLocale)
5559             .field("dwDisplayHint", &self.dwDisplayHint)
5560             .field("dwVersion", &self.dwVersion)
5561             .field("dwTime", &self.dwTime)
5562             .field("lpMachineName", &self.lpMachineName)
5563             .field("lpServiceAddress", &self.lpServiceAddress)
5564             .field("ServiceSpecificInfo", &self.ServiceSpecificInfo)
5565             .finish()
5566     }
5567 }
5568 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5569 impl ::std::cmp::PartialEq for SERVICE_INFOA {
eq(&self, other: &Self) -> bool5570     fn eq(&self, other: &Self) -> bool {
5571         self.lpServiceType == other.lpServiceType && self.lpServiceName == other.lpServiceName && self.lpComment == other.lpComment && self.lpLocale == other.lpLocale && self.dwDisplayHint == other.dwDisplayHint && self.dwVersion == other.dwVersion && self.dwTime == other.dwTime && self.lpMachineName == other.lpMachineName && self.lpServiceAddress == other.lpServiceAddress && self.ServiceSpecificInfo == other.ServiceSpecificInfo
5572     }
5573 }
5574 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5575 impl ::std::cmp::Eq for SERVICE_INFOA {}
5576 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5577 unsafe impl ::windows::runtime::Abi for SERVICE_INFOA {
5578     type Abi = Self;
5579     type DefaultType = Self;
5580 }
5581 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5582 #[repr(C)]
5583 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5584 pub struct SERVICE_INFOW {
5585     pub lpServiceType: *mut ::windows::runtime::GUID,
5586     pub lpServiceName: super::super::Foundation::PWSTR,
5587     pub lpComment: super::super::Foundation::PWSTR,
5588     pub lpLocale: super::super::Foundation::PWSTR,
5589     pub dwDisplayHint: RESOURCE_DISPLAY_TYPE,
5590     pub dwVersion: u32,
5591     pub dwTime: u32,
5592     pub lpMachineName: super::super::Foundation::PWSTR,
5593     pub lpServiceAddress: *mut SERVICE_ADDRESSES,
5594     pub ServiceSpecificInfo: super::super::System::Com::BLOB,
5595 }
5596 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5597 impl SERVICE_INFOW {}
5598 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5599 impl ::std::default::Default for SERVICE_INFOW {
default() -> Self5600     fn default() -> Self {
5601         unsafe { ::std::mem::zeroed() }
5602     }
5603 }
5604 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5605 impl ::std::fmt::Debug for SERVICE_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5606     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5607         fmt.debug_struct("SERVICE_INFOW")
5608             .field("lpServiceType", &self.lpServiceType)
5609             .field("lpServiceName", &self.lpServiceName)
5610             .field("lpComment", &self.lpComment)
5611             .field("lpLocale", &self.lpLocale)
5612             .field("dwDisplayHint", &self.dwDisplayHint)
5613             .field("dwVersion", &self.dwVersion)
5614             .field("dwTime", &self.dwTime)
5615             .field("lpMachineName", &self.lpMachineName)
5616             .field("lpServiceAddress", &self.lpServiceAddress)
5617             .field("ServiceSpecificInfo", &self.ServiceSpecificInfo)
5618             .finish()
5619     }
5620 }
5621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5622 impl ::std::cmp::PartialEq for SERVICE_INFOW {
eq(&self, other: &Self) -> bool5623     fn eq(&self, other: &Self) -> bool {
5624         self.lpServiceType == other.lpServiceType && self.lpServiceName == other.lpServiceName && self.lpComment == other.lpComment && self.lpLocale == other.lpLocale && self.dwDisplayHint == other.dwDisplayHint && self.dwVersion == other.dwVersion && self.dwTime == other.dwTime && self.lpMachineName == other.lpMachineName && self.lpServiceAddress == other.lpServiceAddress && self.ServiceSpecificInfo == other.ServiceSpecificInfo
5625     }
5626 }
5627 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5628 impl ::std::cmp::Eq for SERVICE_INFOW {}
5629 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
5630 unsafe impl ::windows::runtime::Abi for SERVICE_INFOW {
5631     type Abi = Self;
5632     type DefaultType = Self;
5633 }
5634 pub const SERVICE_LOCAL: u32 = 4u32;
5635 pub const SERVICE_MULTIPLE: u32 = 1u32;
5636 pub const SERVICE_RESOURCE: u32 = 1u32;
5637 pub const SERVICE_SERVICE: u32 = 2u32;
5638 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5639 #[repr(C)]
5640 pub struct SERVICE_TYPE_INFO {
5641     pub dwTypeNameOffset: u32,
5642     pub dwValueCount: u32,
5643     pub Values: [SERVICE_TYPE_VALUE; 1],
5644 }
5645 impl SERVICE_TYPE_INFO {}
5646 impl ::std::default::Default for SERVICE_TYPE_INFO {
default() -> Self5647     fn default() -> Self {
5648         unsafe { ::std::mem::zeroed() }
5649     }
5650 }
5651 impl ::std::fmt::Debug for SERVICE_TYPE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5652     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5653         fmt.debug_struct("SERVICE_TYPE_INFO").field("dwTypeNameOffset", &self.dwTypeNameOffset).field("dwValueCount", &self.dwValueCount).field("Values", &self.Values).finish()
5654     }
5655 }
5656 impl ::std::cmp::PartialEq for SERVICE_TYPE_INFO {
eq(&self, other: &Self) -> bool5657     fn eq(&self, other: &Self) -> bool {
5658         self.dwTypeNameOffset == other.dwTypeNameOffset && self.dwValueCount == other.dwValueCount && self.Values == other.Values
5659     }
5660 }
5661 impl ::std::cmp::Eq for SERVICE_TYPE_INFO {}
5662 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_INFO {
5663     type Abi = Self;
5664     type DefaultType = Self;
5665 }
5666 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5667 #[repr(C)]
5668 #[cfg(feature = "Win32_Foundation")]
5669 pub struct SERVICE_TYPE_INFO_ABSA {
5670     pub lpTypeName: super::super::Foundation::PSTR,
5671     pub dwValueCount: u32,
5672     pub Values: [SERVICE_TYPE_VALUE_ABSA; 1],
5673 }
5674 #[cfg(feature = "Win32_Foundation")]
5675 impl SERVICE_TYPE_INFO_ABSA {}
5676 #[cfg(feature = "Win32_Foundation")]
5677 impl ::std::default::Default for SERVICE_TYPE_INFO_ABSA {
default() -> Self5678     fn default() -> Self {
5679         unsafe { ::std::mem::zeroed() }
5680     }
5681 }
5682 #[cfg(feature = "Win32_Foundation")]
5683 impl ::std::fmt::Debug for SERVICE_TYPE_INFO_ABSA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5684     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5685         fmt.debug_struct("SERVICE_TYPE_INFO_ABSA").field("lpTypeName", &self.lpTypeName).field("dwValueCount", &self.dwValueCount).field("Values", &self.Values).finish()
5686     }
5687 }
5688 #[cfg(feature = "Win32_Foundation")]
5689 impl ::std::cmp::PartialEq for SERVICE_TYPE_INFO_ABSA {
eq(&self, other: &Self) -> bool5690     fn eq(&self, other: &Self) -> bool {
5691         self.lpTypeName == other.lpTypeName && self.dwValueCount == other.dwValueCount && self.Values == other.Values
5692     }
5693 }
5694 #[cfg(feature = "Win32_Foundation")]
5695 impl ::std::cmp::Eq for SERVICE_TYPE_INFO_ABSA {}
5696 #[cfg(feature = "Win32_Foundation")]
5697 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_INFO_ABSA {
5698     type Abi = Self;
5699     type DefaultType = Self;
5700 }
5701 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5702 #[repr(C)]
5703 #[cfg(feature = "Win32_Foundation")]
5704 pub struct SERVICE_TYPE_INFO_ABSW {
5705     pub lpTypeName: super::super::Foundation::PWSTR,
5706     pub dwValueCount: u32,
5707     pub Values: [SERVICE_TYPE_VALUE_ABSW; 1],
5708 }
5709 #[cfg(feature = "Win32_Foundation")]
5710 impl SERVICE_TYPE_INFO_ABSW {}
5711 #[cfg(feature = "Win32_Foundation")]
5712 impl ::std::default::Default for SERVICE_TYPE_INFO_ABSW {
default() -> Self5713     fn default() -> Self {
5714         unsafe { ::std::mem::zeroed() }
5715     }
5716 }
5717 #[cfg(feature = "Win32_Foundation")]
5718 impl ::std::fmt::Debug for SERVICE_TYPE_INFO_ABSW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5719     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5720         fmt.debug_struct("SERVICE_TYPE_INFO_ABSW").field("lpTypeName", &self.lpTypeName).field("dwValueCount", &self.dwValueCount).field("Values", &self.Values).finish()
5721     }
5722 }
5723 #[cfg(feature = "Win32_Foundation")]
5724 impl ::std::cmp::PartialEq for SERVICE_TYPE_INFO_ABSW {
eq(&self, other: &Self) -> bool5725     fn eq(&self, other: &Self) -> bool {
5726         self.lpTypeName == other.lpTypeName && self.dwValueCount == other.dwValueCount && self.Values == other.Values
5727     }
5728 }
5729 #[cfg(feature = "Win32_Foundation")]
5730 impl ::std::cmp::Eq for SERVICE_TYPE_INFO_ABSW {}
5731 #[cfg(feature = "Win32_Foundation")]
5732 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_INFO_ABSW {
5733     type Abi = Self;
5734     type DefaultType = Self;
5735 }
5736 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5737 #[repr(C)]
5738 pub struct SERVICE_TYPE_VALUE {
5739     pub dwNameSpace: u32,
5740     pub dwValueType: u32,
5741     pub dwValueSize: u32,
5742     pub dwValueNameOffset: u32,
5743     pub dwValueOffset: u32,
5744 }
5745 impl SERVICE_TYPE_VALUE {}
5746 impl ::std::default::Default for SERVICE_TYPE_VALUE {
default() -> Self5747     fn default() -> Self {
5748         unsafe { ::std::mem::zeroed() }
5749     }
5750 }
5751 impl ::std::fmt::Debug for SERVICE_TYPE_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5752     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5753         fmt.debug_struct("SERVICE_TYPE_VALUE").field("dwNameSpace", &self.dwNameSpace).field("dwValueType", &self.dwValueType).field("dwValueSize", &self.dwValueSize).field("dwValueNameOffset", &self.dwValueNameOffset).field("dwValueOffset", &self.dwValueOffset).finish()
5754     }
5755 }
5756 impl ::std::cmp::PartialEq for SERVICE_TYPE_VALUE {
eq(&self, other: &Self) -> bool5757     fn eq(&self, other: &Self) -> bool {
5758         self.dwNameSpace == other.dwNameSpace && self.dwValueType == other.dwValueType && self.dwValueSize == other.dwValueSize && self.dwValueNameOffset == other.dwValueNameOffset && self.dwValueOffset == other.dwValueOffset
5759     }
5760 }
5761 impl ::std::cmp::Eq for SERVICE_TYPE_VALUE {}
5762 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_VALUE {
5763     type Abi = Self;
5764     type DefaultType = Self;
5765 }
5766 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5767 #[repr(C)]
5768 #[cfg(feature = "Win32_Foundation")]
5769 pub struct SERVICE_TYPE_VALUE_ABSA {
5770     pub dwNameSpace: u32,
5771     pub dwValueType: u32,
5772     pub dwValueSize: u32,
5773     pub lpValueName: super::super::Foundation::PSTR,
5774     pub lpValue: *mut ::std::ffi::c_void,
5775 }
5776 #[cfg(feature = "Win32_Foundation")]
5777 impl SERVICE_TYPE_VALUE_ABSA {}
5778 #[cfg(feature = "Win32_Foundation")]
5779 impl ::std::default::Default for SERVICE_TYPE_VALUE_ABSA {
default() -> Self5780     fn default() -> Self {
5781         unsafe { ::std::mem::zeroed() }
5782     }
5783 }
5784 #[cfg(feature = "Win32_Foundation")]
5785 impl ::std::fmt::Debug for SERVICE_TYPE_VALUE_ABSA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5786     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5787         fmt.debug_struct("SERVICE_TYPE_VALUE_ABSA").field("dwNameSpace", &self.dwNameSpace).field("dwValueType", &self.dwValueType).field("dwValueSize", &self.dwValueSize).field("lpValueName", &self.lpValueName).field("lpValue", &self.lpValue).finish()
5788     }
5789 }
5790 #[cfg(feature = "Win32_Foundation")]
5791 impl ::std::cmp::PartialEq for SERVICE_TYPE_VALUE_ABSA {
eq(&self, other: &Self) -> bool5792     fn eq(&self, other: &Self) -> bool {
5793         self.dwNameSpace == other.dwNameSpace && self.dwValueType == other.dwValueType && self.dwValueSize == other.dwValueSize && self.lpValueName == other.lpValueName && self.lpValue == other.lpValue
5794     }
5795 }
5796 #[cfg(feature = "Win32_Foundation")]
5797 impl ::std::cmp::Eq for SERVICE_TYPE_VALUE_ABSA {}
5798 #[cfg(feature = "Win32_Foundation")]
5799 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_VALUE_ABSA {
5800     type Abi = Self;
5801     type DefaultType = Self;
5802 }
5803 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5804 #[repr(C)]
5805 #[cfg(feature = "Win32_Foundation")]
5806 pub struct SERVICE_TYPE_VALUE_ABSW {
5807     pub dwNameSpace: u32,
5808     pub dwValueType: u32,
5809     pub dwValueSize: u32,
5810     pub lpValueName: super::super::Foundation::PWSTR,
5811     pub lpValue: *mut ::std::ffi::c_void,
5812 }
5813 #[cfg(feature = "Win32_Foundation")]
5814 impl SERVICE_TYPE_VALUE_ABSW {}
5815 #[cfg(feature = "Win32_Foundation")]
5816 impl ::std::default::Default for SERVICE_TYPE_VALUE_ABSW {
default() -> Self5817     fn default() -> Self {
5818         unsafe { ::std::mem::zeroed() }
5819     }
5820 }
5821 #[cfg(feature = "Win32_Foundation")]
5822 impl ::std::fmt::Debug for SERVICE_TYPE_VALUE_ABSW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5823     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5824         fmt.debug_struct("SERVICE_TYPE_VALUE_ABSW").field("dwNameSpace", &self.dwNameSpace).field("dwValueType", &self.dwValueType).field("dwValueSize", &self.dwValueSize).field("lpValueName", &self.lpValueName).field("lpValue", &self.lpValue).finish()
5825     }
5826 }
5827 #[cfg(feature = "Win32_Foundation")]
5828 impl ::std::cmp::PartialEq for SERVICE_TYPE_VALUE_ABSW {
eq(&self, other: &Self) -> bool5829     fn eq(&self, other: &Self) -> bool {
5830         self.dwNameSpace == other.dwNameSpace && self.dwValueType == other.dwValueType && self.dwValueSize == other.dwValueSize && self.lpValueName == other.lpValueName && self.lpValue == other.lpValue
5831     }
5832 }
5833 #[cfg(feature = "Win32_Foundation")]
5834 impl ::std::cmp::Eq for SERVICE_TYPE_VALUE_ABSW {}
5835 #[cfg(feature = "Win32_Foundation")]
5836 unsafe impl ::windows::runtime::Abi for SERVICE_TYPE_VALUE_ABSW {
5837     type Abi = Self;
5838     type DefaultType = Self;
5839 }
5840 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5841 #[repr(transparent)]
5842 pub struct SET_SERVICE_OPERATION(pub u32);
5843 pub const SERVICE_REGISTER: SET_SERVICE_OPERATION = SET_SERVICE_OPERATION(1u32);
5844 pub const SERVICE_DEREGISTER: SET_SERVICE_OPERATION = SET_SERVICE_OPERATION(2u32);
5845 pub const SERVICE_FLUSH: SET_SERVICE_OPERATION = SET_SERVICE_OPERATION(3u32);
5846 pub const SERVICE_ADD_TYPE: SET_SERVICE_OPERATION = SET_SERVICE_OPERATION(4u32);
5847 pub const SERVICE_DELETE_TYPE: SET_SERVICE_OPERATION = SET_SERVICE_OPERATION(5u32);
5848 impl ::std::convert::From<u32> for SET_SERVICE_OPERATION {
from(value: u32) -> Self5849     fn from(value: u32) -> Self {
5850         Self(value)
5851     }
5852 }
5853 unsafe impl ::windows::runtime::Abi for SET_SERVICE_OPERATION {
5854     type Abi = Self;
5855     type DefaultType = Self;
5856 }
5857 impl ::std::ops::BitOr for SET_SERVICE_OPERATION {
5858     type Output = Self;
bitor(self, rhs: Self) -> Self5859     fn bitor(self, rhs: Self) -> Self {
5860         Self(self.0 | rhs.0)
5861     }
5862 }
5863 impl ::std::ops::BitAnd for SET_SERVICE_OPERATION {
5864     type Output = Self;
bitand(self, rhs: Self) -> Self5865     fn bitand(self, rhs: Self) -> Self {
5866         Self(self.0 & rhs.0)
5867     }
5868 }
5869 impl ::std::ops::BitOrAssign for SET_SERVICE_OPERATION {
bitor_assign(&mut self, rhs: Self)5870     fn bitor_assign(&mut self, rhs: Self) {
5871         self.0.bitor_assign(rhs.0)
5872     }
5873 }
5874 impl ::std::ops::BitAndAssign for SET_SERVICE_OPERATION {
bitand_assign(&mut self, rhs: Self)5875     fn bitand_assign(&mut self, rhs: Self) {
5876         self.0.bitand_assign(rhs.0)
5877     }
5878 }
5879 impl ::std::ops::Not for SET_SERVICE_OPERATION {
5880     type Output = Self;
not(self) -> Self5881     fn not(self) -> Self {
5882         Self(self.0.not())
5883     }
5884 }
5885 pub const SET_SERVICE_PARTIAL_SUCCESS: u32 = 1u32;
5886 pub const SG_CONSTRAINED_GROUP: u32 = 2u32;
5887 pub const SG_UNCONSTRAINED_GROUP: u32 = 1u32;
5888 pub const SIO_ASSOCIATE_PVC: u32 = 2417360899u32;
5889 pub const SIO_GET_ATM_ADDRESS: u32 = 3491102722u32;
5890 pub const SIO_GET_ATM_CONNECTION_ID: u32 = 1343619076u32;
5891 pub const SIO_GET_NUMBER_OF_ATM_DEVICES: u32 = 1343619073u32;
5892 pub const SI_NETWORK: u32 = 3u32;
5893 pub const SI_USER_FAILED: u32 = 2u32;
5894 pub const SI_USER_NOT_SCREENED: u32 = 0u32;
5895 pub const SI_USER_PASSED: u32 = 1u32;
5896 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5897 #[repr(C)]
5898 #[cfg(feature = "Win32_Foundation")]
5899 pub struct SOCKADDR {
5900     pub sa_family: u16,
5901     pub sa_data: [super::super::Foundation::CHAR; 14],
5902 }
5903 #[cfg(feature = "Win32_Foundation")]
5904 impl SOCKADDR {}
5905 #[cfg(feature = "Win32_Foundation")]
5906 impl ::std::default::Default for SOCKADDR {
default() -> Self5907     fn default() -> Self {
5908         unsafe { ::std::mem::zeroed() }
5909     }
5910 }
5911 #[cfg(feature = "Win32_Foundation")]
5912 impl ::std::fmt::Debug for SOCKADDR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5913     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5914         fmt.debug_struct("SOCKADDR").field("sa_family", &self.sa_family).field("sa_data", &self.sa_data).finish()
5915     }
5916 }
5917 #[cfg(feature = "Win32_Foundation")]
5918 impl ::std::cmp::PartialEq for SOCKADDR {
eq(&self, other: &Self) -> bool5919     fn eq(&self, other: &Self) -> bool {
5920         self.sa_family == other.sa_family && self.sa_data == other.sa_data
5921     }
5922 }
5923 #[cfg(feature = "Win32_Foundation")]
5924 impl ::std::cmp::Eq for SOCKADDR {}
5925 #[cfg(feature = "Win32_Foundation")]
5926 unsafe impl ::windows::runtime::Abi for SOCKADDR {
5927     type Abi = Self;
5928     type DefaultType = Self;
5929 }
5930 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5931 #[repr(C)]
5932 pub struct SOCKADDR_DL {
5933     pub sdl_family: u16,
5934     pub sdl_data: [u8; 8],
5935     pub sdl_zero: [u8; 4],
5936 }
5937 impl SOCKADDR_DL {}
5938 impl ::std::default::Default for SOCKADDR_DL {
default() -> Self5939     fn default() -> Self {
5940         unsafe { ::std::mem::zeroed() }
5941     }
5942 }
5943 impl ::std::fmt::Debug for SOCKADDR_DL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5944     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5945         fmt.debug_struct("SOCKADDR_DL").field("sdl_family", &self.sdl_family).field("sdl_data", &self.sdl_data).field("sdl_zero", &self.sdl_zero).finish()
5946     }
5947 }
5948 impl ::std::cmp::PartialEq for SOCKADDR_DL {
eq(&self, other: &Self) -> bool5949     fn eq(&self, other: &Self) -> bool {
5950         self.sdl_family == other.sdl_family && self.sdl_data == other.sdl_data && self.sdl_zero == other.sdl_zero
5951     }
5952 }
5953 impl ::std::cmp::Eq for SOCKADDR_DL {}
5954 unsafe impl ::windows::runtime::Abi for SOCKADDR_DL {
5955     type Abi = Self;
5956     type DefaultType = Self;
5957 }
5958 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5959 #[repr(C)]
5960 #[cfg(feature = "Win32_Foundation")]
5961 pub struct SOCKADDR_IN {
5962     pub sin_family: u16,
5963     pub sin_port: u16,
5964     pub sin_addr: IN_ADDR,
5965     pub sin_zero: [super::super::Foundation::CHAR; 8],
5966 }
5967 #[cfg(feature = "Win32_Foundation")]
5968 impl SOCKADDR_IN {}
5969 #[cfg(feature = "Win32_Foundation")]
5970 impl ::std::default::Default for SOCKADDR_IN {
default() -> Self5971     fn default() -> Self {
5972         unsafe { ::std::mem::zeroed() }
5973     }
5974 }
5975 #[cfg(feature = "Win32_Foundation")]
5976 impl ::std::cmp::PartialEq for SOCKADDR_IN {
eq(&self, _other: &Self) -> bool5977     fn eq(&self, _other: &Self) -> bool {
5978         unimplemented!()
5979     }
5980 }
5981 #[cfg(feature = "Win32_Foundation")]
5982 impl ::std::cmp::Eq for SOCKADDR_IN {}
5983 #[cfg(feature = "Win32_Foundation")]
5984 unsafe impl ::windows::runtime::Abi for SOCKADDR_IN {
5985     type Abi = Self;
5986     type DefaultType = Self;
5987 }
5988 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5989 #[repr(C)]
5990 pub struct SOCKADDR_IN6 {
5991     pub sin6_family: u16,
5992     pub sin6_port: u16,
5993     pub sin6_flowinfo: u32,
5994     pub sin6_addr: IN6_ADDR,
5995     pub Anonymous: SOCKADDR_IN6_0,
5996 }
5997 impl SOCKADDR_IN6 {}
5998 impl ::std::default::Default for SOCKADDR_IN6 {
default() -> Self5999     fn default() -> Self {
6000         unsafe { ::std::mem::zeroed() }
6001     }
6002 }
6003 impl ::std::cmp::PartialEq for SOCKADDR_IN6 {
eq(&self, _other: &Self) -> bool6004     fn eq(&self, _other: &Self) -> bool {
6005         unimplemented!()
6006     }
6007 }
6008 impl ::std::cmp::Eq for SOCKADDR_IN6 {}
6009 unsafe impl ::windows::runtime::Abi for SOCKADDR_IN6 {
6010     type Abi = Self;
6011     type DefaultType = Self;
6012 }
6013 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6014 #[repr(C)]
6015 pub union SOCKADDR_IN6_0 {
6016     pub sin6_scope_id: u32,
6017     pub sin6_scope_struct: SCOPE_ID,
6018 }
6019 impl SOCKADDR_IN6_0 {}
6020 impl ::std::default::Default for SOCKADDR_IN6_0 {
default() -> Self6021     fn default() -> Self {
6022         unsafe { ::std::mem::zeroed() }
6023     }
6024 }
6025 impl ::std::cmp::PartialEq for SOCKADDR_IN6_0 {
eq(&self, _other: &Self) -> bool6026     fn eq(&self, _other: &Self) -> bool {
6027         unimplemented!()
6028     }
6029 }
6030 impl ::std::cmp::Eq for SOCKADDR_IN6_0 {}
6031 unsafe impl ::windows::runtime::Abi for SOCKADDR_IN6_0 {
6032     type Abi = Self;
6033     type DefaultType = Self;
6034 }
6035 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6036 #[repr(C)]
6037 pub struct SOCKADDR_IN6_PAIR {
6038     pub SourceAddress: *mut SOCKADDR_IN6,
6039     pub DestinationAddress: *mut SOCKADDR_IN6,
6040 }
6041 impl SOCKADDR_IN6_PAIR {}
6042 impl ::std::default::Default for SOCKADDR_IN6_PAIR {
default() -> Self6043     fn default() -> Self {
6044         unsafe { ::std::mem::zeroed() }
6045     }
6046 }
6047 impl ::std::fmt::Debug for SOCKADDR_IN6_PAIR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6048     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6049         fmt.debug_struct("SOCKADDR_IN6_PAIR").field("SourceAddress", &self.SourceAddress).field("DestinationAddress", &self.DestinationAddress).finish()
6050     }
6051 }
6052 impl ::std::cmp::PartialEq for SOCKADDR_IN6_PAIR {
eq(&self, other: &Self) -> bool6053     fn eq(&self, other: &Self) -> bool {
6054         self.SourceAddress == other.SourceAddress && self.DestinationAddress == other.DestinationAddress
6055     }
6056 }
6057 impl ::std::cmp::Eq for SOCKADDR_IN6_PAIR {}
6058 unsafe impl ::windows::runtime::Abi for SOCKADDR_IN6_PAIR {
6059     type Abi = Self;
6060     type DefaultType = Self;
6061 }
6062 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6063 #[repr(C)]
6064 pub struct SOCKADDR_IN6_W2KSP1 {
6065     pub sin6_family: i16,
6066     pub sin6_port: u16,
6067     pub sin6_flowinfo: u32,
6068     pub sin6_addr: IN6_ADDR,
6069     pub sin6_scope_id: u32,
6070 }
6071 impl SOCKADDR_IN6_W2KSP1 {}
6072 impl ::std::default::Default for SOCKADDR_IN6_W2KSP1 {
default() -> Self6073     fn default() -> Self {
6074         unsafe { ::std::mem::zeroed() }
6075     }
6076 }
6077 impl ::std::cmp::PartialEq for SOCKADDR_IN6_W2KSP1 {
eq(&self, _other: &Self) -> bool6078     fn eq(&self, _other: &Self) -> bool {
6079         unimplemented!()
6080     }
6081 }
6082 impl ::std::cmp::Eq for SOCKADDR_IN6_W2KSP1 {}
6083 unsafe impl ::windows::runtime::Abi for SOCKADDR_IN6_W2KSP1 {
6084     type Abi = Self;
6085     type DefaultType = Self;
6086 }
6087 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6088 #[repr(C)]
6089 #[cfg(feature = "Win32_Foundation")]
6090 pub union SOCKADDR_INET {
6091     pub Ipv4: SOCKADDR_IN,
6092     pub Ipv6: SOCKADDR_IN6,
6093     pub si_family: u16,
6094 }
6095 #[cfg(feature = "Win32_Foundation")]
6096 impl SOCKADDR_INET {}
6097 #[cfg(feature = "Win32_Foundation")]
6098 impl ::std::default::Default for SOCKADDR_INET {
default() -> Self6099     fn default() -> Self {
6100         unsafe { ::std::mem::zeroed() }
6101     }
6102 }
6103 #[cfg(feature = "Win32_Foundation")]
6104 impl ::std::cmp::PartialEq for SOCKADDR_INET {
eq(&self, _other: &Self) -> bool6105     fn eq(&self, _other: &Self) -> bool {
6106         unimplemented!()
6107     }
6108 }
6109 #[cfg(feature = "Win32_Foundation")]
6110 impl ::std::cmp::Eq for SOCKADDR_INET {}
6111 #[cfg(feature = "Win32_Foundation")]
6112 unsafe impl ::windows::runtime::Abi for SOCKADDR_INET {
6113     type Abi = Self;
6114     type DefaultType = Self;
6115 }
6116 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6117 #[repr(C)]
6118 #[cfg(feature = "Win32_Foundation")]
6119 pub struct SOCKADDR_IRDA {
6120     pub irdaAddressFamily: u16,
6121     pub irdaDeviceID: [u8; 4],
6122     pub irdaServiceName: [super::super::Foundation::CHAR; 25],
6123 }
6124 #[cfg(feature = "Win32_Foundation")]
6125 impl SOCKADDR_IRDA {}
6126 #[cfg(feature = "Win32_Foundation")]
6127 impl ::std::default::Default for SOCKADDR_IRDA {
default() -> Self6128     fn default() -> Self {
6129         unsafe { ::std::mem::zeroed() }
6130     }
6131 }
6132 #[cfg(feature = "Win32_Foundation")]
6133 impl ::std::fmt::Debug for SOCKADDR_IRDA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6134     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6135         fmt.debug_struct("SOCKADDR_IRDA").field("irdaAddressFamily", &self.irdaAddressFamily).field("irdaDeviceID", &self.irdaDeviceID).field("irdaServiceName", &self.irdaServiceName).finish()
6136     }
6137 }
6138 #[cfg(feature = "Win32_Foundation")]
6139 impl ::std::cmp::PartialEq for SOCKADDR_IRDA {
eq(&self, other: &Self) -> bool6140     fn eq(&self, other: &Self) -> bool {
6141         self.irdaAddressFamily == other.irdaAddressFamily && self.irdaDeviceID == other.irdaDeviceID && self.irdaServiceName == other.irdaServiceName
6142     }
6143 }
6144 #[cfg(feature = "Win32_Foundation")]
6145 impl ::std::cmp::Eq for SOCKADDR_IRDA {}
6146 #[cfg(feature = "Win32_Foundation")]
6147 unsafe impl ::windows::runtime::Abi for SOCKADDR_IRDA {
6148     type Abi = Self;
6149     type DefaultType = Self;
6150 }
6151 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6152 #[repr(C)]
6153 #[cfg(feature = "Win32_Foundation")]
6154 pub struct SOCKADDR_STORAGE {
6155     pub ss_family: u16,
6156     pub __ss_pad1: [super::super::Foundation::CHAR; 6],
6157     pub __ss_align: i64,
6158     pub __ss_pad2: [super::super::Foundation::CHAR; 112],
6159 }
6160 #[cfg(feature = "Win32_Foundation")]
6161 impl SOCKADDR_STORAGE {}
6162 #[cfg(feature = "Win32_Foundation")]
6163 impl ::std::default::Default for SOCKADDR_STORAGE {
default() -> Self6164     fn default() -> Self {
6165         unsafe { ::std::mem::zeroed() }
6166     }
6167 }
6168 #[cfg(feature = "Win32_Foundation")]
6169 impl ::std::fmt::Debug for SOCKADDR_STORAGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6170     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6171         fmt.debug_struct("SOCKADDR_STORAGE").field("ss_family", &self.ss_family).field("__ss_pad1", &self.__ss_pad1).field("__ss_align", &self.__ss_align).field("__ss_pad2", &self.__ss_pad2).finish()
6172     }
6173 }
6174 #[cfg(feature = "Win32_Foundation")]
6175 impl ::std::cmp::PartialEq for SOCKADDR_STORAGE {
eq(&self, other: &Self) -> bool6176     fn eq(&self, other: &Self) -> bool {
6177         self.ss_family == other.ss_family && self.__ss_pad1 == other.__ss_pad1 && self.__ss_align == other.__ss_align && self.__ss_pad2 == other.__ss_pad2
6178     }
6179 }
6180 #[cfg(feature = "Win32_Foundation")]
6181 impl ::std::cmp::Eq for SOCKADDR_STORAGE {}
6182 #[cfg(feature = "Win32_Foundation")]
6183 unsafe impl ::windows::runtime::Abi for SOCKADDR_STORAGE {
6184     type Abi = Self;
6185     type DefaultType = Self;
6186 }
6187 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6188 #[repr(C)]
6189 #[cfg(feature = "Win32_Foundation")]
6190 pub struct SOCKADDR_STORAGE_XP {
6191     pub ss_family: i16,
6192     pub __ss_pad1: [super::super::Foundation::CHAR; 6],
6193     pub __ss_align: i64,
6194     pub __ss_pad2: [super::super::Foundation::CHAR; 112],
6195 }
6196 #[cfg(feature = "Win32_Foundation")]
6197 impl SOCKADDR_STORAGE_XP {}
6198 #[cfg(feature = "Win32_Foundation")]
6199 impl ::std::default::Default for SOCKADDR_STORAGE_XP {
default() -> Self6200     fn default() -> Self {
6201         unsafe { ::std::mem::zeroed() }
6202     }
6203 }
6204 #[cfg(feature = "Win32_Foundation")]
6205 impl ::std::fmt::Debug for SOCKADDR_STORAGE_XP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6206     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6207         fmt.debug_struct("SOCKADDR_STORAGE_XP").field("ss_family", &self.ss_family).field("__ss_pad1", &self.__ss_pad1).field("__ss_align", &self.__ss_align).field("__ss_pad2", &self.__ss_pad2).finish()
6208     }
6209 }
6210 #[cfg(feature = "Win32_Foundation")]
6211 impl ::std::cmp::PartialEq for SOCKADDR_STORAGE_XP {
eq(&self, other: &Self) -> bool6212     fn eq(&self, other: &Self) -> bool {
6213         self.ss_family == other.ss_family && self.__ss_pad1 == other.__ss_pad1 && self.__ss_align == other.__ss_align && self.__ss_pad2 == other.__ss_pad2
6214     }
6215 }
6216 #[cfg(feature = "Win32_Foundation")]
6217 impl ::std::cmp::Eq for SOCKADDR_STORAGE_XP {}
6218 #[cfg(feature = "Win32_Foundation")]
6219 unsafe impl ::windows::runtime::Abi for SOCKADDR_STORAGE_XP {
6220     type Abi = Self;
6221     type DefaultType = Self;
6222 }
6223 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
6224 #[repr(transparent)]
6225 pub struct SOCKET(pub usize);
6226 impl ::std::default::Default for SOCKET {
default() -> Self6227     fn default() -> Self {
6228         unsafe { ::std::mem::zeroed() }
6229     }
6230 }
6231 unsafe impl ::windows::runtime::Handle for SOCKET {}
6232 unsafe impl ::windows::runtime::Abi for SOCKET {
6233     type Abi = Self;
6234     type DefaultType = Self;
6235 }
6236 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6237 #[repr(C)]
6238 #[cfg(feature = "Win32_Foundation")]
6239 pub struct SOCKET_ADDRESS {
6240     pub lpSockaddr: *mut SOCKADDR,
6241     pub iSockaddrLength: i32,
6242 }
6243 #[cfg(feature = "Win32_Foundation")]
6244 impl SOCKET_ADDRESS {}
6245 #[cfg(feature = "Win32_Foundation")]
6246 impl ::std::default::Default for SOCKET_ADDRESS {
default() -> Self6247     fn default() -> Self {
6248         unsafe { ::std::mem::zeroed() }
6249     }
6250 }
6251 #[cfg(feature = "Win32_Foundation")]
6252 impl ::std::fmt::Debug for SOCKET_ADDRESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6253     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6254         fmt.debug_struct("SOCKET_ADDRESS").field("lpSockaddr", &self.lpSockaddr).field("iSockaddrLength", &self.iSockaddrLength).finish()
6255     }
6256 }
6257 #[cfg(feature = "Win32_Foundation")]
6258 impl ::std::cmp::PartialEq for SOCKET_ADDRESS {
eq(&self, other: &Self) -> bool6259     fn eq(&self, other: &Self) -> bool {
6260         self.lpSockaddr == other.lpSockaddr && self.iSockaddrLength == other.iSockaddrLength
6261     }
6262 }
6263 #[cfg(feature = "Win32_Foundation")]
6264 impl ::std::cmp::Eq for SOCKET_ADDRESS {}
6265 #[cfg(feature = "Win32_Foundation")]
6266 unsafe impl ::windows::runtime::Abi for SOCKET_ADDRESS {
6267     type Abi = Self;
6268     type DefaultType = Self;
6269 }
6270 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6271 #[repr(C)]
6272 #[cfg(feature = "Win32_Foundation")]
6273 pub struct SOCKET_ADDRESS_LIST {
6274     pub iAddressCount: i32,
6275     pub Address: [SOCKET_ADDRESS; 1],
6276 }
6277 #[cfg(feature = "Win32_Foundation")]
6278 impl SOCKET_ADDRESS_LIST {}
6279 #[cfg(feature = "Win32_Foundation")]
6280 impl ::std::default::Default for SOCKET_ADDRESS_LIST {
default() -> Self6281     fn default() -> Self {
6282         unsafe { ::std::mem::zeroed() }
6283     }
6284 }
6285 #[cfg(feature = "Win32_Foundation")]
6286 impl ::std::fmt::Debug for SOCKET_ADDRESS_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6287     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6288         fmt.debug_struct("SOCKET_ADDRESS_LIST").field("iAddressCount", &self.iAddressCount).field("Address", &self.Address).finish()
6289     }
6290 }
6291 #[cfg(feature = "Win32_Foundation")]
6292 impl ::std::cmp::PartialEq for SOCKET_ADDRESS_LIST {
eq(&self, other: &Self) -> bool6293     fn eq(&self, other: &Self) -> bool {
6294         self.iAddressCount == other.iAddressCount && self.Address == other.Address
6295     }
6296 }
6297 #[cfg(feature = "Win32_Foundation")]
6298 impl ::std::cmp::Eq for SOCKET_ADDRESS_LIST {}
6299 #[cfg(feature = "Win32_Foundation")]
6300 unsafe impl ::windows::runtime::Abi for SOCKET_ADDRESS_LIST {
6301     type Abi = Self;
6302     type DefaultType = Self;
6303 }
6304 pub const SOCKET_DEFAULT2_QM_POLICY: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2932010908, 14925, 19774, [136, 66, 35, 153, 66, 227, 154, 71]);
6305 pub const SOCKET_ERROR: i32 = -1i32;
6306 pub const SOCKET_INFO_CONNECTION_ENCRYPTED: u32 = 2u32;
6307 pub const SOCKET_INFO_CONNECTION_IMPERSONATED: u32 = 4u32;
6308 pub const SOCKET_INFO_CONNECTION_SECURED: u32 = 1u32;
6309 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6310 #[repr(C)]
6311 #[cfg(feature = "Win32_Foundation")]
6312 pub struct SOCKET_PEER_TARGET_NAME {
6313     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6314     pub PeerAddress: SOCKADDR_STORAGE,
6315     pub PeerTargetNameStringLen: u32,
6316     pub AllStrings: [u16; 1],
6317 }
6318 #[cfg(feature = "Win32_Foundation")]
6319 impl SOCKET_PEER_TARGET_NAME {}
6320 #[cfg(feature = "Win32_Foundation")]
6321 impl ::std::default::Default for SOCKET_PEER_TARGET_NAME {
default() -> Self6322     fn default() -> Self {
6323         unsafe { ::std::mem::zeroed() }
6324     }
6325 }
6326 #[cfg(feature = "Win32_Foundation")]
6327 impl ::std::fmt::Debug for SOCKET_PEER_TARGET_NAME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6328     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6329         fmt.debug_struct("SOCKET_PEER_TARGET_NAME").field("SecurityProtocol", &self.SecurityProtocol).field("PeerAddress", &self.PeerAddress).field("PeerTargetNameStringLen", &self.PeerTargetNameStringLen).field("AllStrings", &self.AllStrings).finish()
6330     }
6331 }
6332 #[cfg(feature = "Win32_Foundation")]
6333 impl ::std::cmp::PartialEq for SOCKET_PEER_TARGET_NAME {
eq(&self, other: &Self) -> bool6334     fn eq(&self, other: &Self) -> bool {
6335         self.SecurityProtocol == other.SecurityProtocol && self.PeerAddress == other.PeerAddress && self.PeerTargetNameStringLen == other.PeerTargetNameStringLen && self.AllStrings == other.AllStrings
6336     }
6337 }
6338 #[cfg(feature = "Win32_Foundation")]
6339 impl ::std::cmp::Eq for SOCKET_PEER_TARGET_NAME {}
6340 #[cfg(feature = "Win32_Foundation")]
6341 unsafe impl ::windows::runtime::Abi for SOCKET_PEER_TARGET_NAME {
6342     type Abi = Self;
6343     type DefaultType = Self;
6344 }
6345 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6346 #[repr(transparent)]
6347 pub struct SOCKET_PRIORITY_HINT(pub i32);
6348 pub const SocketPriorityHintVeryLow: SOCKET_PRIORITY_HINT = SOCKET_PRIORITY_HINT(0i32);
6349 pub const SocketPriorityHintLow: SOCKET_PRIORITY_HINT = SOCKET_PRIORITY_HINT(1i32);
6350 pub const SocketPriorityHintNormal: SOCKET_PRIORITY_HINT = SOCKET_PRIORITY_HINT(2i32);
6351 pub const SocketMaximumPriorityHintType: SOCKET_PRIORITY_HINT = SOCKET_PRIORITY_HINT(3i32);
6352 impl ::std::convert::From<i32> for SOCKET_PRIORITY_HINT {
from(value: i32) -> Self6353     fn from(value: i32) -> Self {
6354         Self(value)
6355     }
6356 }
6357 unsafe impl ::windows::runtime::Abi for SOCKET_PRIORITY_HINT {
6358     type Abi = Self;
6359     type DefaultType = Self;
6360 }
6361 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6362 #[repr(C)]
6363 #[cfg(feature = "Win32_System_Kernel")]
6364 pub struct SOCKET_PROCESSOR_AFFINITY {
6365     pub Processor: super::super::System::Kernel::PROCESSOR_NUMBER,
6366     pub NumaNodeId: u16,
6367     pub Reserved: u16,
6368 }
6369 #[cfg(feature = "Win32_System_Kernel")]
6370 impl SOCKET_PROCESSOR_AFFINITY {}
6371 #[cfg(feature = "Win32_System_Kernel")]
6372 impl ::std::default::Default for SOCKET_PROCESSOR_AFFINITY {
default() -> Self6373     fn default() -> Self {
6374         unsafe { ::std::mem::zeroed() }
6375     }
6376 }
6377 #[cfg(feature = "Win32_System_Kernel")]
6378 impl ::std::fmt::Debug for SOCKET_PROCESSOR_AFFINITY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6379     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6380         fmt.debug_struct("SOCKET_PROCESSOR_AFFINITY").field("Processor", &self.Processor).field("NumaNodeId", &self.NumaNodeId).field("Reserved", &self.Reserved).finish()
6381     }
6382 }
6383 #[cfg(feature = "Win32_System_Kernel")]
6384 impl ::std::cmp::PartialEq for SOCKET_PROCESSOR_AFFINITY {
eq(&self, other: &Self) -> bool6385     fn eq(&self, other: &Self) -> bool {
6386         self.Processor == other.Processor && self.NumaNodeId == other.NumaNodeId && self.Reserved == other.Reserved
6387     }
6388 }
6389 #[cfg(feature = "Win32_System_Kernel")]
6390 impl ::std::cmp::Eq for SOCKET_PROCESSOR_AFFINITY {}
6391 #[cfg(feature = "Win32_System_Kernel")]
6392 unsafe impl ::windows::runtime::Abi for SOCKET_PROCESSOR_AFFINITY {
6393     type Abi = Self;
6394     type DefaultType = Self;
6395 }
6396 pub const SOCKET_QUERY_IPSEC2_ABORT_CONNECTION_ON_FIELD_CHANGE: u32 = 1u32;
6397 pub const SOCKET_QUERY_IPSEC2_FIELD_MASK_MM_SA_ID: u32 = 1u32;
6398 pub const SOCKET_QUERY_IPSEC2_FIELD_MASK_QM_SA_ID: u32 = 2u32;
6399 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6400 #[repr(transparent)]
6401 pub struct SOCKET_SECURITY_PROTOCOL(pub i32);
6402 pub const SOCKET_SECURITY_PROTOCOL_DEFAULT: SOCKET_SECURITY_PROTOCOL = SOCKET_SECURITY_PROTOCOL(0i32);
6403 pub const SOCKET_SECURITY_PROTOCOL_IPSEC: SOCKET_SECURITY_PROTOCOL = SOCKET_SECURITY_PROTOCOL(1i32);
6404 pub const SOCKET_SECURITY_PROTOCOL_IPSEC2: SOCKET_SECURITY_PROTOCOL = SOCKET_SECURITY_PROTOCOL(2i32);
6405 pub const SOCKET_SECURITY_PROTOCOL_INVALID: SOCKET_SECURITY_PROTOCOL = SOCKET_SECURITY_PROTOCOL(3i32);
6406 impl ::std::convert::From<i32> for SOCKET_SECURITY_PROTOCOL {
from(value: i32) -> Self6407     fn from(value: i32) -> Self {
6408         Self(value)
6409     }
6410 }
6411 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_PROTOCOL {
6412     type Abi = Self;
6413     type DefaultType = Self;
6414 }
6415 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6416 #[repr(C)]
6417 pub struct SOCKET_SECURITY_QUERY_INFO {
6418     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6419     pub Flags: u32,
6420     pub PeerApplicationAccessTokenHandle: u64,
6421     pub PeerMachineAccessTokenHandle: u64,
6422 }
6423 impl SOCKET_SECURITY_QUERY_INFO {}
6424 impl ::std::default::Default for SOCKET_SECURITY_QUERY_INFO {
default() -> Self6425     fn default() -> Self {
6426         unsafe { ::std::mem::zeroed() }
6427     }
6428 }
6429 impl ::std::fmt::Debug for SOCKET_SECURITY_QUERY_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6430     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6431         fmt.debug_struct("SOCKET_SECURITY_QUERY_INFO").field("SecurityProtocol", &self.SecurityProtocol).field("Flags", &self.Flags).field("PeerApplicationAccessTokenHandle", &self.PeerApplicationAccessTokenHandle).field("PeerMachineAccessTokenHandle", &self.PeerMachineAccessTokenHandle).finish()
6432     }
6433 }
6434 impl ::std::cmp::PartialEq for SOCKET_SECURITY_QUERY_INFO {
eq(&self, other: &Self) -> bool6435     fn eq(&self, other: &Self) -> bool {
6436         self.SecurityProtocol == other.SecurityProtocol && self.Flags == other.Flags && self.PeerApplicationAccessTokenHandle == other.PeerApplicationAccessTokenHandle && self.PeerMachineAccessTokenHandle == other.PeerMachineAccessTokenHandle
6437     }
6438 }
6439 impl ::std::cmp::Eq for SOCKET_SECURITY_QUERY_INFO {}
6440 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_QUERY_INFO {
6441     type Abi = Self;
6442     type DefaultType = Self;
6443 }
6444 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6445 #[repr(C)]
6446 pub struct SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
6447     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6448     pub Flags: u32,
6449     pub PeerApplicationAccessTokenHandle: u64,
6450     pub PeerMachineAccessTokenHandle: u64,
6451     pub MmSaId: u64,
6452     pub QmSaId: u64,
6453     pub NegotiationWinerr: u32,
6454     pub SaLookupContext: ::windows::runtime::GUID,
6455 }
6456 impl SOCKET_SECURITY_QUERY_INFO_IPSEC2 {}
6457 impl ::std::default::Default for SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
default() -> Self6458     fn default() -> Self {
6459         unsafe { ::std::mem::zeroed() }
6460     }
6461 }
6462 impl ::std::fmt::Debug for SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6463     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6464         fmt.debug_struct("SOCKET_SECURITY_QUERY_INFO_IPSEC2")
6465             .field("SecurityProtocol", &self.SecurityProtocol)
6466             .field("Flags", &self.Flags)
6467             .field("PeerApplicationAccessTokenHandle", &self.PeerApplicationAccessTokenHandle)
6468             .field("PeerMachineAccessTokenHandle", &self.PeerMachineAccessTokenHandle)
6469             .field("MmSaId", &self.MmSaId)
6470             .field("QmSaId", &self.QmSaId)
6471             .field("NegotiationWinerr", &self.NegotiationWinerr)
6472             .field("SaLookupContext", &self.SaLookupContext)
6473             .finish()
6474     }
6475 }
6476 impl ::std::cmp::PartialEq for SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
eq(&self, other: &Self) -> bool6477     fn eq(&self, other: &Self) -> bool {
6478         self.SecurityProtocol == other.SecurityProtocol && self.Flags == other.Flags && self.PeerApplicationAccessTokenHandle == other.PeerApplicationAccessTokenHandle && self.PeerMachineAccessTokenHandle == other.PeerMachineAccessTokenHandle && self.MmSaId == other.MmSaId && self.QmSaId == other.QmSaId && self.NegotiationWinerr == other.NegotiationWinerr && self.SaLookupContext == other.SaLookupContext
6479     }
6480 }
6481 impl ::std::cmp::Eq for SOCKET_SECURITY_QUERY_INFO_IPSEC2 {}
6482 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_QUERY_INFO_IPSEC2 {
6483     type Abi = Self;
6484     type DefaultType = Self;
6485 }
6486 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6487 #[repr(C)]
6488 #[cfg(feature = "Win32_Foundation")]
6489 pub struct SOCKET_SECURITY_QUERY_TEMPLATE {
6490     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6491     pub PeerAddress: SOCKADDR_STORAGE,
6492     pub PeerTokenAccessMask: u32,
6493 }
6494 #[cfg(feature = "Win32_Foundation")]
6495 impl SOCKET_SECURITY_QUERY_TEMPLATE {}
6496 #[cfg(feature = "Win32_Foundation")]
6497 impl ::std::default::Default for SOCKET_SECURITY_QUERY_TEMPLATE {
default() -> Self6498     fn default() -> Self {
6499         unsafe { ::std::mem::zeroed() }
6500     }
6501 }
6502 #[cfg(feature = "Win32_Foundation")]
6503 impl ::std::fmt::Debug for SOCKET_SECURITY_QUERY_TEMPLATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6504     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6505         fmt.debug_struct("SOCKET_SECURITY_QUERY_TEMPLATE").field("SecurityProtocol", &self.SecurityProtocol).field("PeerAddress", &self.PeerAddress).field("PeerTokenAccessMask", &self.PeerTokenAccessMask).finish()
6506     }
6507 }
6508 #[cfg(feature = "Win32_Foundation")]
6509 impl ::std::cmp::PartialEq for SOCKET_SECURITY_QUERY_TEMPLATE {
eq(&self, other: &Self) -> bool6510     fn eq(&self, other: &Self) -> bool {
6511         self.SecurityProtocol == other.SecurityProtocol && self.PeerAddress == other.PeerAddress && self.PeerTokenAccessMask == other.PeerTokenAccessMask
6512     }
6513 }
6514 #[cfg(feature = "Win32_Foundation")]
6515 impl ::std::cmp::Eq for SOCKET_SECURITY_QUERY_TEMPLATE {}
6516 #[cfg(feature = "Win32_Foundation")]
6517 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_QUERY_TEMPLATE {
6518     type Abi = Self;
6519     type DefaultType = Self;
6520 }
6521 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6522 #[repr(C)]
6523 #[cfg(feature = "Win32_Foundation")]
6524 pub struct SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
6525     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6526     pub PeerAddress: SOCKADDR_STORAGE,
6527     pub PeerTokenAccessMask: u32,
6528     pub Flags: u32,
6529     pub FieldMask: u32,
6530 }
6531 #[cfg(feature = "Win32_Foundation")]
6532 impl SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {}
6533 #[cfg(feature = "Win32_Foundation")]
6534 impl ::std::default::Default for SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
default() -> Self6535     fn default() -> Self {
6536         unsafe { ::std::mem::zeroed() }
6537     }
6538 }
6539 #[cfg(feature = "Win32_Foundation")]
6540 impl ::std::fmt::Debug for SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6541     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6542         fmt.debug_struct("SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2").field("SecurityProtocol", &self.SecurityProtocol).field("PeerAddress", &self.PeerAddress).field("PeerTokenAccessMask", &self.PeerTokenAccessMask).field("Flags", &self.Flags).field("FieldMask", &self.FieldMask).finish()
6543     }
6544 }
6545 #[cfg(feature = "Win32_Foundation")]
6546 impl ::std::cmp::PartialEq for SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
eq(&self, other: &Self) -> bool6547     fn eq(&self, other: &Self) -> bool {
6548         self.SecurityProtocol == other.SecurityProtocol && self.PeerAddress == other.PeerAddress && self.PeerTokenAccessMask == other.PeerTokenAccessMask && self.Flags == other.Flags && self.FieldMask == other.FieldMask
6549     }
6550 }
6551 #[cfg(feature = "Win32_Foundation")]
6552 impl ::std::cmp::Eq for SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {}
6553 #[cfg(feature = "Win32_Foundation")]
6554 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_QUERY_TEMPLATE_IPSEC2 {
6555     type Abi = Self;
6556     type DefaultType = Self;
6557 }
6558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6559 #[repr(C)]
6560 pub struct SOCKET_SECURITY_SETTINGS {
6561     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6562     pub SecurityFlags: u32,
6563 }
6564 impl SOCKET_SECURITY_SETTINGS {}
6565 impl ::std::default::Default for SOCKET_SECURITY_SETTINGS {
default() -> Self6566     fn default() -> Self {
6567         unsafe { ::std::mem::zeroed() }
6568     }
6569 }
6570 impl ::std::fmt::Debug for SOCKET_SECURITY_SETTINGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6571     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6572         fmt.debug_struct("SOCKET_SECURITY_SETTINGS").field("SecurityProtocol", &self.SecurityProtocol).field("SecurityFlags", &self.SecurityFlags).finish()
6573     }
6574 }
6575 impl ::std::cmp::PartialEq for SOCKET_SECURITY_SETTINGS {
eq(&self, other: &Self) -> bool6576     fn eq(&self, other: &Self) -> bool {
6577         self.SecurityProtocol == other.SecurityProtocol && self.SecurityFlags == other.SecurityFlags
6578     }
6579 }
6580 impl ::std::cmp::Eq for SOCKET_SECURITY_SETTINGS {}
6581 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_SETTINGS {
6582     type Abi = Self;
6583     type DefaultType = Self;
6584 }
6585 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6586 #[repr(C)]
6587 pub struct SOCKET_SECURITY_SETTINGS_IPSEC {
6588     pub SecurityProtocol: SOCKET_SECURITY_PROTOCOL,
6589     pub SecurityFlags: u32,
6590     pub IpsecFlags: u32,
6591     pub AuthipMMPolicyKey: ::windows::runtime::GUID,
6592     pub AuthipQMPolicyKey: ::windows::runtime::GUID,
6593     pub Reserved: ::windows::runtime::GUID,
6594     pub Reserved2: u64,
6595     pub UserNameStringLen: u32,
6596     pub DomainNameStringLen: u32,
6597     pub PasswordStringLen: u32,
6598     pub AllStrings: [u16; 1],
6599 }
6600 impl SOCKET_SECURITY_SETTINGS_IPSEC {}
6601 impl ::std::default::Default for SOCKET_SECURITY_SETTINGS_IPSEC {
default() -> Self6602     fn default() -> Self {
6603         unsafe { ::std::mem::zeroed() }
6604     }
6605 }
6606 impl ::std::fmt::Debug for SOCKET_SECURITY_SETTINGS_IPSEC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6607     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6608         fmt.debug_struct("SOCKET_SECURITY_SETTINGS_IPSEC")
6609             .field("SecurityProtocol", &self.SecurityProtocol)
6610             .field("SecurityFlags", &self.SecurityFlags)
6611             .field("IpsecFlags", &self.IpsecFlags)
6612             .field("AuthipMMPolicyKey", &self.AuthipMMPolicyKey)
6613             .field("AuthipQMPolicyKey", &self.AuthipQMPolicyKey)
6614             .field("Reserved", &self.Reserved)
6615             .field("Reserved2", &self.Reserved2)
6616             .field("UserNameStringLen", &self.UserNameStringLen)
6617             .field("DomainNameStringLen", &self.DomainNameStringLen)
6618             .field("PasswordStringLen", &self.PasswordStringLen)
6619             .field("AllStrings", &self.AllStrings)
6620             .finish()
6621     }
6622 }
6623 impl ::std::cmp::PartialEq for SOCKET_SECURITY_SETTINGS_IPSEC {
eq(&self, other: &Self) -> bool6624     fn eq(&self, other: &Self) -> bool {
6625         self.SecurityProtocol == other.SecurityProtocol
6626             && self.SecurityFlags == other.SecurityFlags
6627             && self.IpsecFlags == other.IpsecFlags
6628             && self.AuthipMMPolicyKey == other.AuthipMMPolicyKey
6629             && self.AuthipQMPolicyKey == other.AuthipQMPolicyKey
6630             && self.Reserved == other.Reserved
6631             && self.Reserved2 == other.Reserved2
6632             && self.UserNameStringLen == other.UserNameStringLen
6633             && self.DomainNameStringLen == other.DomainNameStringLen
6634             && self.PasswordStringLen == other.PasswordStringLen
6635             && self.AllStrings == other.AllStrings
6636     }
6637 }
6638 impl ::std::cmp::Eq for SOCKET_SECURITY_SETTINGS_IPSEC {}
6639 unsafe impl ::windows::runtime::Abi for SOCKET_SECURITY_SETTINGS_IPSEC {
6640     type Abi = Self;
6641     type DefaultType = Self;
6642 }
6643 pub const SOCKET_SETTINGS_ALLOW_INSECURE: u32 = 2u32;
6644 pub const SOCKET_SETTINGS_GUARANTEE_ENCRYPTION: u32 = 1u32;
6645 pub const SOCKET_SETTINGS_IPSEC_ALLOW_FIRST_INBOUND_PKT_UNENCRYPTED: u32 = 4u32;
6646 pub const SOCKET_SETTINGS_IPSEC_OPTIONAL_PEER_NAME_VERIFICATION: u32 = 2u32;
6647 pub const SOCKET_SETTINGS_IPSEC_PEER_NAME_IS_RAW_FORMAT: u32 = 8u32;
6648 pub const SOCKET_SETTINGS_IPSEC_SKIP_FILTER_INSTANTIATION: u32 = 1u32;
6649 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6650 #[repr(transparent)]
6651 pub struct SOCKET_USAGE_TYPE(pub i32);
6652 pub const SYSTEM_CRITICAL_SOCKET: SOCKET_USAGE_TYPE = SOCKET_USAGE_TYPE(1i32);
6653 impl ::std::convert::From<i32> for SOCKET_USAGE_TYPE {
from(value: i32) -> Self6654     fn from(value: i32) -> Self {
6655         Self(value)
6656     }
6657 }
6658 unsafe impl ::windows::runtime::Abi for SOCKET_USAGE_TYPE {
6659     type Abi = Self;
6660     type DefaultType = Self;
6661 }
6662 pub const SOCK_DGRAM: u16 = 2u16;
6663 pub const SOCK_NOTIFY_EVENT_ERR: u32 = 64u32;
6664 pub const SOCK_NOTIFY_EVENT_HANGUP: u32 = 4u32;
6665 pub const SOCK_NOTIFY_EVENT_IN: u32 = 1u32;
6666 pub const SOCK_NOTIFY_EVENT_OUT: u32 = 2u32;
6667 pub const SOCK_NOTIFY_EVENT_REMOVE: u32 = 128u32;
6668 pub const SOCK_NOTIFY_OP_DISABLE: u32 = 2u32;
6669 pub const SOCK_NOTIFY_OP_ENABLE: u32 = 1u32;
6670 pub const SOCK_NOTIFY_OP_NONE: u32 = 0u32;
6671 pub const SOCK_NOTIFY_OP_REMOVE: u32 = 4u32;
6672 pub const SOCK_NOTIFY_REGISTER_EVENT_HANGUP: u32 = 4u32;
6673 pub const SOCK_NOTIFY_REGISTER_EVENT_IN: u32 = 1u32;
6674 pub const SOCK_NOTIFY_REGISTER_EVENT_NONE: u32 = 0u32;
6675 pub const SOCK_NOTIFY_REGISTER_EVENT_OUT: u32 = 2u32;
6676 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6677 #[repr(C)]
6678 pub struct SOCK_NOTIFY_REGISTRATION {
6679     pub socket: SOCKET,
6680     pub completionKey: *mut ::std::ffi::c_void,
6681     pub eventFilter: u16,
6682     pub operation: u8,
6683     pub triggerFlags: u8,
6684     pub registrationResult: u32,
6685 }
6686 impl SOCK_NOTIFY_REGISTRATION {}
6687 impl ::std::default::Default for SOCK_NOTIFY_REGISTRATION {
default() -> Self6688     fn default() -> Self {
6689         unsafe { ::std::mem::zeroed() }
6690     }
6691 }
6692 impl ::std::fmt::Debug for SOCK_NOTIFY_REGISTRATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6693     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6694         fmt.debug_struct("SOCK_NOTIFY_REGISTRATION").field("socket", &self.socket).field("completionKey", &self.completionKey).field("eventFilter", &self.eventFilter).field("operation", &self.operation).field("triggerFlags", &self.triggerFlags).field("registrationResult", &self.registrationResult).finish()
6695     }
6696 }
6697 impl ::std::cmp::PartialEq for SOCK_NOTIFY_REGISTRATION {
eq(&self, other: &Self) -> bool6698     fn eq(&self, other: &Self) -> bool {
6699         self.socket == other.socket && self.completionKey == other.completionKey && self.eventFilter == other.eventFilter && self.operation == other.operation && self.triggerFlags == other.triggerFlags && self.registrationResult == other.registrationResult
6700     }
6701 }
6702 impl ::std::cmp::Eq for SOCK_NOTIFY_REGISTRATION {}
6703 unsafe impl ::windows::runtime::Abi for SOCK_NOTIFY_REGISTRATION {
6704     type Abi = Self;
6705     type DefaultType = Self;
6706 }
6707 pub const SOCK_NOTIFY_TRIGGER_EDGE: u32 = 8u32;
6708 pub const SOCK_NOTIFY_TRIGGER_LEVEL: u32 = 4u32;
6709 pub const SOCK_NOTIFY_TRIGGER_ONESHOT: u32 = 1u32;
6710 pub const SOCK_NOTIFY_TRIGGER_PERSISTENT: u32 = 2u32;
6711 pub const SOCK_RAW: u16 = 3u16;
6712 pub const SOCK_RDM: u16 = 4u16;
6713 pub const SOCK_SEQPACKET: u16 = 5u16;
6714 pub const SOCK_STREAM: u16 = 1u16;
6715 pub const SOL_IRLMP: u32 = 255u32;
6716 pub const SOL_SOCKET: u32 = 65535u32;
6717 pub const SOMAXCONN: u32 = 5u32;
6718 pub const SO_ACCEPTCONN: u32 = 2u32;
6719 pub const SO_BROADCAST: u32 = 32u32;
6720 pub const SO_BSP_STATE: u32 = 4105u32;
6721 pub const SO_COMPARTMENT_ID: u32 = 12292u32;
6722 pub const SO_CONDITIONAL_ACCEPT: u32 = 12290u32;
6723 pub const SO_CONNDATA: u32 = 28672u32;
6724 pub const SO_CONNDATALEN: u32 = 28676u32;
6725 pub const SO_CONNECT_TIME: u32 = 28684u32;
6726 pub const SO_CONNOPT: u32 = 28673u32;
6727 pub const SO_CONNOPTLEN: u32 = 28677u32;
6728 pub const SO_DEBUG: u32 = 1u32;
6729 pub const SO_DISCDATA: u32 = 28674u32;
6730 pub const SO_DISCDATALEN: u32 = 28678u32;
6731 pub const SO_DISCOPT: u32 = 28675u32;
6732 pub const SO_DISCOPTLEN: u32 = 28679u32;
6733 pub const SO_DONTROUTE: u32 = 16u32;
6734 pub const SO_ERROR: u32 = 4103u32;
6735 pub const SO_GROUP_ID: u32 = 8193u32;
6736 pub const SO_GROUP_PRIORITY: u32 = 8194u32;
6737 pub const SO_KEEPALIVE: u32 = 8u32;
6738 pub const SO_LINGER: u32 = 128u32;
6739 pub const SO_MAXDG: u32 = 28681u32;
6740 pub const SO_MAXPATHDG: u32 = 28682u32;
6741 pub const SO_MAX_MSG_SIZE: u32 = 8195u32;
6742 pub const SO_OOBINLINE: u32 = 256u32;
6743 pub const SO_OPENTYPE: u32 = 28680u32;
6744 pub const SO_ORIGINAL_DST: u32 = 12303u32;
6745 pub const SO_PAUSE_ACCEPT: u32 = 12291u32;
6746 pub const SO_PORT_SCALABILITY: u32 = 12294u32;
6747 pub const SO_PROTOCOL_INFO: u32 = 8197u32;
6748 pub const SO_PROTOCOL_INFOA: u32 = 8196u32;
6749 pub const SO_PROTOCOL_INFOW: u32 = 8197u32;
6750 pub const SO_RANDOMIZE_PORT: u32 = 12293u32;
6751 pub const SO_RCVBUF: u32 = 4098u32;
6752 pub const SO_RCVLOWAT: u32 = 4100u32;
6753 pub const SO_RCVTIMEO: u32 = 4102u32;
6754 pub const SO_REUSEADDR: u32 = 4u32;
6755 pub const SO_REUSE_MULTICASTPORT: u32 = 12296u32;
6756 pub const SO_REUSE_UNICASTPORT: u32 = 12295u32;
6757 pub const SO_SNDBUF: u32 = 4097u32;
6758 pub const SO_SNDLOWAT: u32 = 4099u32;
6759 pub const SO_SNDTIMEO: u32 = 4101u32;
6760 pub const SO_SYNCHRONOUS_ALERT: u32 = 16u32;
6761 pub const SO_SYNCHRONOUS_NONALERT: u32 = 32u32;
6762 pub const SO_TIMESTAMP: u32 = 12298u32;
6763 pub const SO_TIMESTAMP_ID: u32 = 12299u32;
6764 pub const SO_TYPE: u32 = 4104u32;
6765 pub const SO_UPDATE_ACCEPT_CONTEXT: u32 = 28683u32;
6766 pub const SO_UPDATE_CONNECT_CONTEXT: u32 = 28688u32;
6767 pub const SO_USELOOPBACK: u32 = 64u32;
6768 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
6769 #[inline]
SetAddrInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( pname: Param0, pservicename: Param1, paddresses: *const SOCKET_ADDRESS, dwaddresscount: u32, lpblob: *const super::super::System::Com::BLOB, dwflags: u32, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>, lpnamehandle: *mut super::super::Foundation::HANDLE, ) -> i326770 pub unsafe fn SetAddrInfoExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
6771     pname: Param0,
6772     pservicename: Param1,
6773     paddresses: *const SOCKET_ADDRESS,
6774     dwaddresscount: u32,
6775     lpblob: *const super::super::System::Com::BLOB,
6776     dwflags: u32,
6777     dwnamespace: u32,
6778     lpnspid: *const ::windows::runtime::GUID,
6779     timeout: *const timeval,
6780     lpoverlapped: *const super::super::System::IO::OVERLAPPED,
6781     lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>,
6782     lpnamehandle: *mut super::super::Foundation::HANDLE,
6783 ) -> i32 {
6784     #[cfg(windows)]
6785     {
6786         #[link(name = "windows")]
6787         extern "system" {
6788             fn SetAddrInfoExA(pname: super::super::Foundation::PSTR, pservicename: super::super::Foundation::PSTR, paddresses: *const SOCKET_ADDRESS, dwaddresscount: u32, lpblob: *const super::super::System::Com::BLOB, dwflags: u32, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpnamehandle: *mut super::super::Foundation::HANDLE) -> i32;
6789         }
6790         ::std::mem::transmute(SetAddrInfoExA(
6791             pname.into_param().abi(),
6792             pservicename.into_param().abi(),
6793             ::std::mem::transmute(paddresses),
6794             ::std::mem::transmute(dwaddresscount),
6795             ::std::mem::transmute(lpblob),
6796             ::std::mem::transmute(dwflags),
6797             ::std::mem::transmute(dwnamespace),
6798             ::std::mem::transmute(lpnspid),
6799             ::std::mem::transmute(timeout),
6800             ::std::mem::transmute(lpoverlapped),
6801             ::std::mem::transmute(lpcompletionroutine),
6802             ::std::mem::transmute(lpnamehandle),
6803         ))
6804     }
6805     #[cfg(not(windows))]
6806     unimplemented!("Unsupported target OS");
6807 }
6808 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_IO"))]
6809 #[inline]
SetAddrInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( pname: Param0, pservicename: Param1, paddresses: *const SOCKET_ADDRESS, dwaddresscount: u32, lpblob: *const super::super::System::Com::BLOB, dwflags: u32, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>, lpnamehandle: *mut super::super::Foundation::HANDLE, ) -> i326810 pub unsafe fn SetAddrInfoExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
6811     pname: Param0,
6812     pservicename: Param1,
6813     paddresses: *const SOCKET_ADDRESS,
6814     dwaddresscount: u32,
6815     lpblob: *const super::super::System::Com::BLOB,
6816     dwflags: u32,
6817     dwnamespace: u32,
6818     lpnspid: *const ::windows::runtime::GUID,
6819     timeout: *const timeval,
6820     lpoverlapped: *const super::super::System::IO::OVERLAPPED,
6821     lpcompletionroutine: ::std::option::Option<LPLOOKUPSERVICE_COMPLETION_ROUTINE>,
6822     lpnamehandle: *mut super::super::Foundation::HANDLE,
6823 ) -> i32 {
6824     #[cfg(windows)]
6825     {
6826         #[link(name = "windows")]
6827         extern "system" {
6828             fn SetAddrInfoExW(pname: super::super::Foundation::PWSTR, pservicename: super::super::Foundation::PWSTR, paddresses: *const SOCKET_ADDRESS, dwaddresscount: u32, lpblob: *const super::super::System::Com::BLOB, dwflags: u32, dwnamespace: u32, lpnspid: *const ::windows::runtime::GUID, timeout: *const timeval, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr, lpnamehandle: *mut super::super::Foundation::HANDLE) -> i32;
6829         }
6830         ::std::mem::transmute(SetAddrInfoExW(
6831             pname.into_param().abi(),
6832             pservicename.into_param().abi(),
6833             ::std::mem::transmute(paddresses),
6834             ::std::mem::transmute(dwaddresscount),
6835             ::std::mem::transmute(lpblob),
6836             ::std::mem::transmute(dwflags),
6837             ::std::mem::transmute(dwnamespace),
6838             ::std::mem::transmute(lpnspid),
6839             ::std::mem::transmute(timeout),
6840             ::std::mem::transmute(lpoverlapped),
6841             ::std::mem::transmute(lpcompletionroutine),
6842             ::std::mem::transmute(lpnamehandle),
6843         ))
6844     }
6845     #[cfg(not(windows))]
6846     unimplemented!("Unsupported target OS");
6847 }
6848 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
6849 #[inline]
SetServiceA(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOA, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpdwstatusflags: *mut u32) -> i326850 pub unsafe fn SetServiceA(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOA, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpdwstatusflags: *mut u32) -> i32 {
6851     #[cfg(windows)]
6852     {
6853         #[link(name = "windows")]
6854         extern "system" {
6855             fn SetServiceA(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOA, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>, lpdwstatusflags: *mut u32) -> i32;
6856         }
6857         ::std::mem::transmute(SetServiceA(::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwoperation), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpserviceinfo), ::std::mem::transmute(lpserviceasyncinfo), ::std::mem::transmute(lpdwstatusflags)))
6858     }
6859     #[cfg(not(windows))]
6860     unimplemented!("Unsupported target OS");
6861 }
6862 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
6863 #[inline]
SetServiceW(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOW, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpdwstatusflags: *mut u32) -> i326864 pub unsafe fn SetServiceW(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOW, lpserviceasyncinfo: *const SERVICE_ASYNC_INFO, lpdwstatusflags: *mut u32) -> i32 {
6865     #[cfg(windows)]
6866     {
6867         #[link(name = "windows")]
6868         extern "system" {
6869             fn SetServiceW(dwnamespace: u32, dwoperation: SET_SERVICE_OPERATION, dwflags: u32, lpserviceinfo: *const SERVICE_INFOW, lpserviceasyncinfo: *const ::std::mem::ManuallyDrop<SERVICE_ASYNC_INFO>, lpdwstatusflags: *mut u32) -> i32;
6870         }
6871         ::std::mem::transmute(SetServiceW(::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwoperation), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpserviceinfo), ::std::mem::transmute(lpserviceasyncinfo), ::std::mem::transmute(lpdwstatusflags)))
6872     }
6873     #[cfg(not(windows))]
6874     unimplemented!("Unsupported target OS");
6875 }
6876 #[cfg(feature = "Win32_Foundation")]
6877 #[inline]
SetSocketMediaStreamingMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(value: Param0) -> ::windows::runtime::Result<()>6878 pub unsafe fn SetSocketMediaStreamingMode<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(value: Param0) -> ::windows::runtime::Result<()> {
6879     #[cfg(windows)]
6880     {
6881         #[link(name = "windows")]
6882         extern "system" {
6883             fn SetSocketMediaStreamingMode(value: super::super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
6884         }
6885         SetSocketMediaStreamingMode(value.into_param().abi()).ok()
6886     }
6887     #[cfg(not(windows))]
6888     unimplemented!("Unsupported target OS");
6889 }
6890 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6891 #[repr(transparent)]
6892 pub struct TCPSTATE(pub i32);
6893 pub const TCPSTATE_CLOSED: TCPSTATE = TCPSTATE(0i32);
6894 pub const TCPSTATE_LISTEN: TCPSTATE = TCPSTATE(1i32);
6895 pub const TCPSTATE_SYN_SENT: TCPSTATE = TCPSTATE(2i32);
6896 pub const TCPSTATE_SYN_RCVD: TCPSTATE = TCPSTATE(3i32);
6897 pub const TCPSTATE_ESTABLISHED: TCPSTATE = TCPSTATE(4i32);
6898 pub const TCPSTATE_FIN_WAIT_1: TCPSTATE = TCPSTATE(5i32);
6899 pub const TCPSTATE_FIN_WAIT_2: TCPSTATE = TCPSTATE(6i32);
6900 pub const TCPSTATE_CLOSE_WAIT: TCPSTATE = TCPSTATE(7i32);
6901 pub const TCPSTATE_CLOSING: TCPSTATE = TCPSTATE(8i32);
6902 pub const TCPSTATE_LAST_ACK: TCPSTATE = TCPSTATE(9i32);
6903 pub const TCPSTATE_TIME_WAIT: TCPSTATE = TCPSTATE(10i32);
6904 pub const TCPSTATE_MAX: TCPSTATE = TCPSTATE(11i32);
6905 impl ::std::convert::From<i32> for TCPSTATE {
from(value: i32) -> Self6906     fn from(value: i32) -> Self {
6907         Self(value)
6908     }
6909 }
6910 unsafe impl ::windows::runtime::Abi for TCPSTATE {
6911     type Abi = Self;
6912     type DefaultType = Self;
6913 }
6914 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6915 #[repr(C)]
6916 pub struct TCP_ACK_FREQUENCY_PARAMETERS {
6917     pub TcpDelayedAckFrequency: u8,
6918 }
6919 impl TCP_ACK_FREQUENCY_PARAMETERS {}
6920 impl ::std::default::Default for TCP_ACK_FREQUENCY_PARAMETERS {
default() -> Self6921     fn default() -> Self {
6922         unsafe { ::std::mem::zeroed() }
6923     }
6924 }
6925 impl ::std::fmt::Debug for TCP_ACK_FREQUENCY_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6926     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6927         fmt.debug_struct("TCP_ACK_FREQUENCY_PARAMETERS").field("TcpDelayedAckFrequency", &self.TcpDelayedAckFrequency).finish()
6928     }
6929 }
6930 impl ::std::cmp::PartialEq for TCP_ACK_FREQUENCY_PARAMETERS {
eq(&self, other: &Self) -> bool6931     fn eq(&self, other: &Self) -> bool {
6932         self.TcpDelayedAckFrequency == other.TcpDelayedAckFrequency
6933     }
6934 }
6935 impl ::std::cmp::Eq for TCP_ACK_FREQUENCY_PARAMETERS {}
6936 unsafe impl ::windows::runtime::Abi for TCP_ACK_FREQUENCY_PARAMETERS {
6937     type Abi = Self;
6938     type DefaultType = Self;
6939 }
6940 pub const TCP_ATMARK: u32 = 8u32;
6941 pub const TCP_BSDURGENT: u32 = 28672u32;
6942 pub const TCP_CONGESTION_ALGORITHM: u32 = 12u32;
6943 pub const TCP_DELAY_FIN_ACK: u32 = 13u32;
6944 pub const TCP_EXPEDITED_1122: u32 = 2u32;
6945 pub const TCP_FAIL_CONNECT_ON_ICMP_ERROR: u32 = 18u32;
6946 pub const TCP_FASTOPEN: u32 = 15u32;
6947 pub const TCP_ICMP_ERROR_INFO: u32 = 19u32;
6948 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6949 #[repr(transparent)]
6950 pub struct TCP_ICW_LEVEL(pub i32);
6951 pub const TCP_ICW_LEVEL_DEFAULT: TCP_ICW_LEVEL = TCP_ICW_LEVEL(0i32);
6952 pub const TCP_ICW_LEVEL_HIGH: TCP_ICW_LEVEL = TCP_ICW_LEVEL(1i32);
6953 pub const TCP_ICW_LEVEL_VERY_HIGH: TCP_ICW_LEVEL = TCP_ICW_LEVEL(2i32);
6954 pub const TCP_ICW_LEVEL_AGGRESSIVE: TCP_ICW_LEVEL = TCP_ICW_LEVEL(3i32);
6955 pub const TCP_ICW_LEVEL_EXPERIMENTAL: TCP_ICW_LEVEL = TCP_ICW_LEVEL(4i32);
6956 pub const TCP_ICW_LEVEL_COMPAT: TCP_ICW_LEVEL = TCP_ICW_LEVEL(254i32);
6957 pub const TCP_ICW_LEVEL_MAX: TCP_ICW_LEVEL = TCP_ICW_LEVEL(255i32);
6958 impl ::std::convert::From<i32> for TCP_ICW_LEVEL {
from(value: i32) -> Self6959     fn from(value: i32) -> Self {
6960         Self(value)
6961     }
6962 }
6963 unsafe impl ::windows::runtime::Abi for TCP_ICW_LEVEL {
6964     type Abi = Self;
6965     type DefaultType = Self;
6966 }
6967 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6968 #[repr(C)]
6969 pub struct TCP_ICW_PARAMETERS {
6970     pub Level: TCP_ICW_LEVEL,
6971 }
6972 impl TCP_ICW_PARAMETERS {}
6973 impl ::std::default::Default for TCP_ICW_PARAMETERS {
default() -> Self6974     fn default() -> Self {
6975         unsafe { ::std::mem::zeroed() }
6976     }
6977 }
6978 impl ::std::fmt::Debug for TCP_ICW_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6979     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6980         fmt.debug_struct("TCP_ICW_PARAMETERS").field("Level", &self.Level).finish()
6981     }
6982 }
6983 impl ::std::cmp::PartialEq for TCP_ICW_PARAMETERS {
eq(&self, other: &Self) -> bool6984     fn eq(&self, other: &Self) -> bool {
6985         self.Level == other.Level
6986     }
6987 }
6988 impl ::std::cmp::Eq for TCP_ICW_PARAMETERS {}
6989 unsafe impl ::windows::runtime::Abi for TCP_ICW_PARAMETERS {
6990     type Abi = Self;
6991     type DefaultType = Self;
6992 }
6993 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6994 #[repr(C)]
6995 #[cfg(feature = "Win32_Foundation")]
6996 pub struct TCP_INFO_v0 {
6997     pub State: TCPSTATE,
6998     pub Mss: u32,
6999     pub ConnectionTimeMs: u64,
7000     pub TimestampsEnabled: super::super::Foundation::BOOLEAN,
7001     pub RttUs: u32,
7002     pub MinRttUs: u32,
7003     pub BytesInFlight: u32,
7004     pub Cwnd: u32,
7005     pub SndWnd: u32,
7006     pub RcvWnd: u32,
7007     pub RcvBuf: u32,
7008     pub BytesOut: u64,
7009     pub BytesIn: u64,
7010     pub BytesReordered: u32,
7011     pub BytesRetrans: u32,
7012     pub FastRetrans: u32,
7013     pub DupAcksIn: u32,
7014     pub TimeoutEpisodes: u32,
7015     pub SynRetrans: u8,
7016 }
7017 #[cfg(feature = "Win32_Foundation")]
7018 impl TCP_INFO_v0 {}
7019 #[cfg(feature = "Win32_Foundation")]
7020 impl ::std::default::Default for TCP_INFO_v0 {
default() -> Self7021     fn default() -> Self {
7022         unsafe { ::std::mem::zeroed() }
7023     }
7024 }
7025 #[cfg(feature = "Win32_Foundation")]
7026 impl ::std::fmt::Debug for TCP_INFO_v0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7027     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7028         fmt.debug_struct("TCP_INFO_v0")
7029             .field("State", &self.State)
7030             .field("Mss", &self.Mss)
7031             .field("ConnectionTimeMs", &self.ConnectionTimeMs)
7032             .field("TimestampsEnabled", &self.TimestampsEnabled)
7033             .field("RttUs", &self.RttUs)
7034             .field("MinRttUs", &self.MinRttUs)
7035             .field("BytesInFlight", &self.BytesInFlight)
7036             .field("Cwnd", &self.Cwnd)
7037             .field("SndWnd", &self.SndWnd)
7038             .field("RcvWnd", &self.RcvWnd)
7039             .field("RcvBuf", &self.RcvBuf)
7040             .field("BytesOut", &self.BytesOut)
7041             .field("BytesIn", &self.BytesIn)
7042             .field("BytesReordered", &self.BytesReordered)
7043             .field("BytesRetrans", &self.BytesRetrans)
7044             .field("FastRetrans", &self.FastRetrans)
7045             .field("DupAcksIn", &self.DupAcksIn)
7046             .field("TimeoutEpisodes", &self.TimeoutEpisodes)
7047             .field("SynRetrans", &self.SynRetrans)
7048             .finish()
7049     }
7050 }
7051 #[cfg(feature = "Win32_Foundation")]
7052 impl ::std::cmp::PartialEq for TCP_INFO_v0 {
eq(&self, other: &Self) -> bool7053     fn eq(&self, other: &Self) -> bool {
7054         self.State == other.State
7055             && self.Mss == other.Mss
7056             && self.ConnectionTimeMs == other.ConnectionTimeMs
7057             && self.TimestampsEnabled == other.TimestampsEnabled
7058             && self.RttUs == other.RttUs
7059             && self.MinRttUs == other.MinRttUs
7060             && self.BytesInFlight == other.BytesInFlight
7061             && self.Cwnd == other.Cwnd
7062             && self.SndWnd == other.SndWnd
7063             && self.RcvWnd == other.RcvWnd
7064             && self.RcvBuf == other.RcvBuf
7065             && self.BytesOut == other.BytesOut
7066             && self.BytesIn == other.BytesIn
7067             && self.BytesReordered == other.BytesReordered
7068             && self.BytesRetrans == other.BytesRetrans
7069             && self.FastRetrans == other.FastRetrans
7070             && self.DupAcksIn == other.DupAcksIn
7071             && self.TimeoutEpisodes == other.TimeoutEpisodes
7072             && self.SynRetrans == other.SynRetrans
7073     }
7074 }
7075 #[cfg(feature = "Win32_Foundation")]
7076 impl ::std::cmp::Eq for TCP_INFO_v0 {}
7077 #[cfg(feature = "Win32_Foundation")]
7078 unsafe impl ::windows::runtime::Abi for TCP_INFO_v0 {
7079     type Abi = Self;
7080     type DefaultType = Self;
7081 }
7082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7083 #[repr(C)]
7084 #[cfg(feature = "Win32_Foundation")]
7085 pub struct TCP_INFO_v1 {
7086     pub State: TCPSTATE,
7087     pub Mss: u32,
7088     pub ConnectionTimeMs: u64,
7089     pub TimestampsEnabled: super::super::Foundation::BOOLEAN,
7090     pub RttUs: u32,
7091     pub MinRttUs: u32,
7092     pub BytesInFlight: u32,
7093     pub Cwnd: u32,
7094     pub SndWnd: u32,
7095     pub RcvWnd: u32,
7096     pub RcvBuf: u32,
7097     pub BytesOut: u64,
7098     pub BytesIn: u64,
7099     pub BytesReordered: u32,
7100     pub BytesRetrans: u32,
7101     pub FastRetrans: u32,
7102     pub DupAcksIn: u32,
7103     pub TimeoutEpisodes: u32,
7104     pub SynRetrans: u8,
7105     pub SndLimTransRwin: u32,
7106     pub SndLimTimeRwin: u32,
7107     pub SndLimBytesRwin: u64,
7108     pub SndLimTransCwnd: u32,
7109     pub SndLimTimeCwnd: u32,
7110     pub SndLimBytesCwnd: u64,
7111     pub SndLimTransSnd: u32,
7112     pub SndLimTimeSnd: u32,
7113     pub SndLimBytesSnd: u64,
7114 }
7115 #[cfg(feature = "Win32_Foundation")]
7116 impl TCP_INFO_v1 {}
7117 #[cfg(feature = "Win32_Foundation")]
7118 impl ::std::default::Default for TCP_INFO_v1 {
default() -> Self7119     fn default() -> Self {
7120         unsafe { ::std::mem::zeroed() }
7121     }
7122 }
7123 #[cfg(feature = "Win32_Foundation")]
7124 impl ::std::fmt::Debug for TCP_INFO_v1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7125     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7126         fmt.debug_struct("TCP_INFO_v1")
7127             .field("State", &self.State)
7128             .field("Mss", &self.Mss)
7129             .field("ConnectionTimeMs", &self.ConnectionTimeMs)
7130             .field("TimestampsEnabled", &self.TimestampsEnabled)
7131             .field("RttUs", &self.RttUs)
7132             .field("MinRttUs", &self.MinRttUs)
7133             .field("BytesInFlight", &self.BytesInFlight)
7134             .field("Cwnd", &self.Cwnd)
7135             .field("SndWnd", &self.SndWnd)
7136             .field("RcvWnd", &self.RcvWnd)
7137             .field("RcvBuf", &self.RcvBuf)
7138             .field("BytesOut", &self.BytesOut)
7139             .field("BytesIn", &self.BytesIn)
7140             .field("BytesReordered", &self.BytesReordered)
7141             .field("BytesRetrans", &self.BytesRetrans)
7142             .field("FastRetrans", &self.FastRetrans)
7143             .field("DupAcksIn", &self.DupAcksIn)
7144             .field("TimeoutEpisodes", &self.TimeoutEpisodes)
7145             .field("SynRetrans", &self.SynRetrans)
7146             .field("SndLimTransRwin", &self.SndLimTransRwin)
7147             .field("SndLimTimeRwin", &self.SndLimTimeRwin)
7148             .field("SndLimBytesRwin", &self.SndLimBytesRwin)
7149             .field("SndLimTransCwnd", &self.SndLimTransCwnd)
7150             .field("SndLimTimeCwnd", &self.SndLimTimeCwnd)
7151             .field("SndLimBytesCwnd", &self.SndLimBytesCwnd)
7152             .field("SndLimTransSnd", &self.SndLimTransSnd)
7153             .field("SndLimTimeSnd", &self.SndLimTimeSnd)
7154             .field("SndLimBytesSnd", &self.SndLimBytesSnd)
7155             .finish()
7156     }
7157 }
7158 #[cfg(feature = "Win32_Foundation")]
7159 impl ::std::cmp::PartialEq for TCP_INFO_v1 {
eq(&self, other: &Self) -> bool7160     fn eq(&self, other: &Self) -> bool {
7161         self.State == other.State
7162             && self.Mss == other.Mss
7163             && self.ConnectionTimeMs == other.ConnectionTimeMs
7164             && self.TimestampsEnabled == other.TimestampsEnabled
7165             && self.RttUs == other.RttUs
7166             && self.MinRttUs == other.MinRttUs
7167             && self.BytesInFlight == other.BytesInFlight
7168             && self.Cwnd == other.Cwnd
7169             && self.SndWnd == other.SndWnd
7170             && self.RcvWnd == other.RcvWnd
7171             && self.RcvBuf == other.RcvBuf
7172             && self.BytesOut == other.BytesOut
7173             && self.BytesIn == other.BytesIn
7174             && self.BytesReordered == other.BytesReordered
7175             && self.BytesRetrans == other.BytesRetrans
7176             && self.FastRetrans == other.FastRetrans
7177             && self.DupAcksIn == other.DupAcksIn
7178             && self.TimeoutEpisodes == other.TimeoutEpisodes
7179             && self.SynRetrans == other.SynRetrans
7180             && self.SndLimTransRwin == other.SndLimTransRwin
7181             && self.SndLimTimeRwin == other.SndLimTimeRwin
7182             && self.SndLimBytesRwin == other.SndLimBytesRwin
7183             && self.SndLimTransCwnd == other.SndLimTransCwnd
7184             && self.SndLimTimeCwnd == other.SndLimTimeCwnd
7185             && self.SndLimBytesCwnd == other.SndLimBytesCwnd
7186             && self.SndLimTransSnd == other.SndLimTransSnd
7187             && self.SndLimTimeSnd == other.SndLimTimeSnd
7188             && self.SndLimBytesSnd == other.SndLimBytesSnd
7189     }
7190 }
7191 #[cfg(feature = "Win32_Foundation")]
7192 impl ::std::cmp::Eq for TCP_INFO_v1 {}
7193 #[cfg(feature = "Win32_Foundation")]
7194 unsafe impl ::windows::runtime::Abi for TCP_INFO_v1 {
7195     type Abi = Self;
7196     type DefaultType = Self;
7197 }
7198 pub const TCP_INITIAL_RTO_DEFAULT_MAX_SYN_RETRANSMISSIONS: u32 = 0u32;
7199 pub const TCP_INITIAL_RTO_DEFAULT_RTT: u32 = 0u32;
7200 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7201 #[repr(C)]
7202 pub struct TCP_INITIAL_RTO_PARAMETERS {
7203     pub Rtt: u16,
7204     pub MaxSynRetransmissions: u8,
7205 }
7206 impl TCP_INITIAL_RTO_PARAMETERS {}
7207 impl ::std::default::Default for TCP_INITIAL_RTO_PARAMETERS {
default() -> Self7208     fn default() -> Self {
7209         unsafe { ::std::mem::zeroed() }
7210     }
7211 }
7212 impl ::std::fmt::Debug for TCP_INITIAL_RTO_PARAMETERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7213     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7214         fmt.debug_struct("TCP_INITIAL_RTO_PARAMETERS").field("Rtt", &self.Rtt).field("MaxSynRetransmissions", &self.MaxSynRetransmissions).finish()
7215     }
7216 }
7217 impl ::std::cmp::PartialEq for TCP_INITIAL_RTO_PARAMETERS {
eq(&self, other: &Self) -> bool7218     fn eq(&self, other: &Self) -> bool {
7219         self.Rtt == other.Rtt && self.MaxSynRetransmissions == other.MaxSynRetransmissions
7220     }
7221 }
7222 impl ::std::cmp::Eq for TCP_INITIAL_RTO_PARAMETERS {}
7223 unsafe impl ::windows::runtime::Abi for TCP_INITIAL_RTO_PARAMETERS {
7224     type Abi = Self;
7225     type DefaultType = Self;
7226 }
7227 pub const TCP_KEEPALIVE: u32 = 3u32;
7228 pub const TCP_KEEPCNT: u32 = 16u32;
7229 pub const TCP_KEEPIDLE: u32 = 3u32;
7230 pub const TCP_KEEPINTVL: u32 = 17u32;
7231 pub const TCP_MAXRT: u32 = 5u32;
7232 pub const TCP_MAXRTMS: u32 = 14u32;
7233 pub const TCP_MAXSEG: u32 = 4u32;
7234 pub const TCP_NODELAY: u32 = 1u32;
7235 pub const TCP_NOSYNRETRIES: u32 = 9u32;
7236 pub const TCP_NOURG: u32 = 7u32;
7237 pub const TCP_OFFLOAD_NOT_PREFERRED: u32 = 1u32;
7238 pub const TCP_OFFLOAD_NO_PREFERENCE: u32 = 0u32;
7239 pub const TCP_OFFLOAD_PREFERENCE: u32 = 11u32;
7240 pub const TCP_OFFLOAD_PREFERRED: u32 = 2u32;
7241 pub const TCP_STDURG: u32 = 6u32;
7242 pub const TCP_TIMESTAMPS: u32 = 10u32;
7243 pub const TF_DISCONNECT: u32 = 1u32;
7244 pub const TF_REUSE_SOCKET: u32 = 2u32;
7245 pub const TF_USE_DEFAULT_WORKER: u32 = 0u32;
7246 pub const TF_USE_KERNEL_APC: u32 = 32u32;
7247 pub const TF_USE_SYSTEM_THREAD: u32 = 16u32;
7248 pub const TF_WRITE_BEHIND: u32 = 4u32;
7249 pub const TH_NETDEV: u32 = 1u32;
7250 pub const TH_TAPI: u32 = 2u32;
7251 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7252 #[repr(C)]
7253 pub struct TIMESTAMPING_CONFIG {
7254     pub Flags: u32,
7255     pub TxTimestampsBuffered: u16,
7256 }
7257 impl TIMESTAMPING_CONFIG {}
7258 impl ::std::default::Default for TIMESTAMPING_CONFIG {
default() -> Self7259     fn default() -> Self {
7260         unsafe { ::std::mem::zeroed() }
7261     }
7262 }
7263 impl ::std::fmt::Debug for TIMESTAMPING_CONFIG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7264     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7265         fmt.debug_struct("TIMESTAMPING_CONFIG").field("Flags", &self.Flags).field("TxTimestampsBuffered", &self.TxTimestampsBuffered).finish()
7266     }
7267 }
7268 impl ::std::cmp::PartialEq for TIMESTAMPING_CONFIG {
eq(&self, other: &Self) -> bool7269     fn eq(&self, other: &Self) -> bool {
7270         self.Flags == other.Flags && self.TxTimestampsBuffered == other.TxTimestampsBuffered
7271     }
7272 }
7273 impl ::std::cmp::Eq for TIMESTAMPING_CONFIG {}
7274 unsafe impl ::windows::runtime::Abi for TIMESTAMPING_CONFIG {
7275     type Abi = Self;
7276     type DefaultType = Self;
7277 }
7278 pub const TIMESTAMPING_FLAG_RX: u32 = 1u32;
7279 pub const TIMESTAMPING_FLAG_TX: u32 = 2u32;
7280 pub const TNS_PLAN_CARRIER_ID_CODE: u32 = 1u32;
7281 pub const TNS_TYPE_NATIONAL: u32 = 64u32;
7282 pub const TP_DISCONNECT: u32 = 1u32;
7283 pub const TP_ELEMENT_EOP: u32 = 4u32;
7284 pub const TP_ELEMENT_FILE: u32 = 2u32;
7285 pub const TP_ELEMENT_MEMORY: u32 = 1u32;
7286 pub const TP_REUSE_SOCKET: u32 = 2u32;
7287 pub const TP_USE_DEFAULT_WORKER: u32 = 0u32;
7288 pub const TP_USE_KERNEL_APC: u32 = 32u32;
7289 pub const TP_USE_SYSTEM_THREAD: u32 = 16u32;
7290 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7291 #[repr(C)]
7292 pub struct TRANSMIT_FILE_BUFFERS {
7293     pub Head: *mut ::std::ffi::c_void,
7294     pub HeadLength: u32,
7295     pub Tail: *mut ::std::ffi::c_void,
7296     pub TailLength: u32,
7297 }
7298 impl TRANSMIT_FILE_BUFFERS {}
7299 impl ::std::default::Default for TRANSMIT_FILE_BUFFERS {
default() -> Self7300     fn default() -> Self {
7301         unsafe { ::std::mem::zeroed() }
7302     }
7303 }
7304 impl ::std::fmt::Debug for TRANSMIT_FILE_BUFFERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7305     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7306         fmt.debug_struct("TRANSMIT_FILE_BUFFERS").field("Head", &self.Head).field("HeadLength", &self.HeadLength).field("Tail", &self.Tail).field("TailLength", &self.TailLength).finish()
7307     }
7308 }
7309 impl ::std::cmp::PartialEq for TRANSMIT_FILE_BUFFERS {
eq(&self, other: &Self) -> bool7310     fn eq(&self, other: &Self) -> bool {
7311         self.Head == other.Head && self.HeadLength == other.HeadLength && self.Tail == other.Tail && self.TailLength == other.TailLength
7312     }
7313 }
7314 impl ::std::cmp::Eq for TRANSMIT_FILE_BUFFERS {}
7315 unsafe impl ::windows::runtime::Abi for TRANSMIT_FILE_BUFFERS {
7316     type Abi = Self;
7317     type DefaultType = Self;
7318 }
7319 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7320 #[repr(C)]
7321 #[cfg(feature = "Win32_Foundation")]
7322 pub struct TRANSMIT_PACKETS_ELEMENT {
7323     pub dwElFlags: u32,
7324     pub cLength: u32,
7325     pub Anonymous: TRANSMIT_PACKETS_ELEMENT_0,
7326 }
7327 #[cfg(feature = "Win32_Foundation")]
7328 impl TRANSMIT_PACKETS_ELEMENT {}
7329 #[cfg(feature = "Win32_Foundation")]
7330 impl ::std::default::Default for TRANSMIT_PACKETS_ELEMENT {
default() -> Self7331     fn default() -> Self {
7332         unsafe { ::std::mem::zeroed() }
7333     }
7334 }
7335 #[cfg(feature = "Win32_Foundation")]
7336 impl ::std::cmp::PartialEq for TRANSMIT_PACKETS_ELEMENT {
eq(&self, _other: &Self) -> bool7337     fn eq(&self, _other: &Self) -> bool {
7338         unimplemented!()
7339     }
7340 }
7341 #[cfg(feature = "Win32_Foundation")]
7342 impl ::std::cmp::Eq for TRANSMIT_PACKETS_ELEMENT {}
7343 #[cfg(feature = "Win32_Foundation")]
7344 unsafe impl ::windows::runtime::Abi for TRANSMIT_PACKETS_ELEMENT {
7345     type Abi = Self;
7346     type DefaultType = Self;
7347 }
7348 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7349 #[repr(C)]
7350 #[cfg(feature = "Win32_Foundation")]
7351 pub union TRANSMIT_PACKETS_ELEMENT_0 {
7352     pub Anonymous: TRANSMIT_PACKETS_ELEMENT_0_0,
7353     pub pBuffer: *mut ::std::ffi::c_void,
7354 }
7355 #[cfg(feature = "Win32_Foundation")]
7356 impl TRANSMIT_PACKETS_ELEMENT_0 {}
7357 #[cfg(feature = "Win32_Foundation")]
7358 impl ::std::default::Default for TRANSMIT_PACKETS_ELEMENT_0 {
default() -> Self7359     fn default() -> Self {
7360         unsafe { ::std::mem::zeroed() }
7361     }
7362 }
7363 #[cfg(feature = "Win32_Foundation")]
7364 impl ::std::cmp::PartialEq for TRANSMIT_PACKETS_ELEMENT_0 {
eq(&self, _other: &Self) -> bool7365     fn eq(&self, _other: &Self) -> bool {
7366         unimplemented!()
7367     }
7368 }
7369 #[cfg(feature = "Win32_Foundation")]
7370 impl ::std::cmp::Eq for TRANSMIT_PACKETS_ELEMENT_0 {}
7371 #[cfg(feature = "Win32_Foundation")]
7372 unsafe impl ::windows::runtime::Abi for TRANSMIT_PACKETS_ELEMENT_0 {
7373     type Abi = Self;
7374     type DefaultType = Self;
7375 }
7376 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7377 #[repr(C)]
7378 #[cfg(feature = "Win32_Foundation")]
7379 pub struct TRANSMIT_PACKETS_ELEMENT_0_0 {
7380     pub nFileOffset: i64,
7381     pub hFile: super::super::Foundation::HANDLE,
7382 }
7383 #[cfg(feature = "Win32_Foundation")]
7384 impl TRANSMIT_PACKETS_ELEMENT_0_0 {}
7385 #[cfg(feature = "Win32_Foundation")]
7386 impl ::std::default::Default for TRANSMIT_PACKETS_ELEMENT_0_0 {
default() -> Self7387     fn default() -> Self {
7388         unsafe { ::std::mem::zeroed() }
7389     }
7390 }
7391 #[cfg(feature = "Win32_Foundation")]
7392 impl ::std::fmt::Debug for TRANSMIT_PACKETS_ELEMENT_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7393     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7394         fmt.debug_struct("_Anonymous_e__Struct").field("nFileOffset", &self.nFileOffset).field("hFile", &self.hFile).finish()
7395     }
7396 }
7397 #[cfg(feature = "Win32_Foundation")]
7398 impl ::std::cmp::PartialEq for TRANSMIT_PACKETS_ELEMENT_0_0 {
eq(&self, other: &Self) -> bool7399     fn eq(&self, other: &Self) -> bool {
7400         self.nFileOffset == other.nFileOffset && self.hFile == other.hFile
7401     }
7402 }
7403 #[cfg(feature = "Win32_Foundation")]
7404 impl ::std::cmp::Eq for TRANSMIT_PACKETS_ELEMENT_0_0 {}
7405 #[cfg(feature = "Win32_Foundation")]
7406 unsafe impl ::windows::runtime::Abi for TRANSMIT_PACKETS_ELEMENT_0_0 {
7407     type Abi = Self;
7408     type DefaultType = Self;
7409 }
7410 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7411 #[repr(C)]
7412 pub struct TRANSPORT_SETTING_ID {
7413     pub Guid: ::windows::runtime::GUID,
7414 }
7415 impl TRANSPORT_SETTING_ID {}
7416 impl ::std::default::Default for TRANSPORT_SETTING_ID {
default() -> Self7417     fn default() -> Self {
7418         unsafe { ::std::mem::zeroed() }
7419     }
7420 }
7421 impl ::std::fmt::Debug for TRANSPORT_SETTING_ID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7422     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7423         fmt.debug_struct("TRANSPORT_SETTING_ID").field("Guid", &self.Guid).finish()
7424     }
7425 }
7426 impl ::std::cmp::PartialEq for TRANSPORT_SETTING_ID {
eq(&self, other: &Self) -> bool7427     fn eq(&self, other: &Self) -> bool {
7428         self.Guid == other.Guid
7429     }
7430 }
7431 impl ::std::cmp::Eq for TRANSPORT_SETTING_ID {}
7432 unsafe impl ::windows::runtime::Abi for TRANSPORT_SETTING_ID {
7433     type Abi = Self;
7434     type DefaultType = Self;
7435 }
7436 pub const TR_END_TO_END: u32 = 1u32;
7437 pub const TR_NOIND: u32 = 0u32;
7438 pub const TR_NO_END_TO_END: u32 = 2u32;
7439 pub const TT_CBR: u32 = 4u32;
7440 pub const TT_NOIND: u32 = 0u32;
7441 pub const TT_VBR: u32 = 8u32;
7442 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7443 #[inline]
TransmitFile<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hsocket: Param0, hfile: Param1, nnumberofbytestowrite: u32, nnumberofbytespersend: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lptransmitbuffers: *const TRANSMIT_FILE_BUFFERS, dwreserved: u32) -> super::super::Foundation::BOOL7444 pub unsafe fn TransmitFile<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hsocket: Param0, hfile: Param1, nnumberofbytestowrite: u32, nnumberofbytespersend: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lptransmitbuffers: *const TRANSMIT_FILE_BUFFERS, dwreserved: u32) -> super::super::Foundation::BOOL {
7445     #[cfg(windows)]
7446     {
7447         #[link(name = "windows")]
7448         extern "system" {
7449             fn TransmitFile(hsocket: SOCKET, hfile: super::super::Foundation::HANDLE, nnumberofbytestowrite: u32, nnumberofbytespersend: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lptransmitbuffers: *const TRANSMIT_FILE_BUFFERS, dwreserved: u32) -> super::super::Foundation::BOOL;
7450         }
7451         ::std::mem::transmute(TransmitFile(hsocket.into_param().abi(), hfile.into_param().abi(), ::std::mem::transmute(nnumberofbytestowrite), ::std::mem::transmute(nnumberofbytespersend), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lptransmitbuffers), ::std::mem::transmute(dwreserved)))
7452     }
7453     #[cfg(not(windows))]
7454     unimplemented!("Unsupported target OS");
7455 }
7456 pub const UDP_CHECKSUM_COVERAGE: u32 = 20u32;
7457 pub const UDP_COALESCED_INFO: u32 = 3u32;
7458 pub const UDP_NOCHECKSUM: u32 = 1u32;
7459 pub const UDP_RECV_MAX_COALESCED_SIZE: u32 = 3u32;
7460 pub const UDP_SEND_MSG_SIZE: u32 = 2u32;
7461 pub const UNIX_PATH_MAX: u32 = 108u32;
7462 pub const UP_P2MP: u32 = 1u32;
7463 pub const UP_P2P: u32 = 0u32;
7464 pub const VNSPROTO_IPC: u32 = 1u32;
7465 pub const VNSPROTO_RELIABLE_IPC: u32 = 2u32;
7466 pub const VNSPROTO_SPP: u32 = 3u32;
7467 pub const WCE_AF_IRDA: u32 = 22u32;
7468 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7469 #[repr(C)]
7470 #[cfg(feature = "Win32_Foundation")]
7471 pub struct WCE_DEVICELIST {
7472     pub numDevice: u32,
7473     pub Device: [WCE_IRDA_DEVICE_INFO; 1],
7474 }
7475 #[cfg(feature = "Win32_Foundation")]
7476 impl WCE_DEVICELIST {}
7477 #[cfg(feature = "Win32_Foundation")]
7478 impl ::std::default::Default for WCE_DEVICELIST {
default() -> Self7479     fn default() -> Self {
7480         unsafe { ::std::mem::zeroed() }
7481     }
7482 }
7483 #[cfg(feature = "Win32_Foundation")]
7484 impl ::std::fmt::Debug for WCE_DEVICELIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7485     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7486         fmt.debug_struct("WCE_DEVICELIST").field("numDevice", &self.numDevice).field("Device", &self.Device).finish()
7487     }
7488 }
7489 #[cfg(feature = "Win32_Foundation")]
7490 impl ::std::cmp::PartialEq for WCE_DEVICELIST {
eq(&self, other: &Self) -> bool7491     fn eq(&self, other: &Self) -> bool {
7492         self.numDevice == other.numDevice && self.Device == other.Device
7493     }
7494 }
7495 #[cfg(feature = "Win32_Foundation")]
7496 impl ::std::cmp::Eq for WCE_DEVICELIST {}
7497 #[cfg(feature = "Win32_Foundation")]
7498 unsafe impl ::windows::runtime::Abi for WCE_DEVICELIST {
7499     type Abi = Self;
7500     type DefaultType = Self;
7501 }
7502 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7503 #[repr(C)]
7504 #[cfg(feature = "Win32_Foundation")]
7505 pub struct WCE_IRDA_DEVICE_INFO {
7506     pub irdaDeviceID: [u8; 4],
7507     pub irdaDeviceName: [super::super::Foundation::CHAR; 22],
7508     pub Reserved: [u8; 2],
7509 }
7510 #[cfg(feature = "Win32_Foundation")]
7511 impl WCE_IRDA_DEVICE_INFO {}
7512 #[cfg(feature = "Win32_Foundation")]
7513 impl ::std::default::Default for WCE_IRDA_DEVICE_INFO {
default() -> Self7514     fn default() -> Self {
7515         unsafe { ::std::mem::zeroed() }
7516     }
7517 }
7518 #[cfg(feature = "Win32_Foundation")]
7519 impl ::std::fmt::Debug for WCE_IRDA_DEVICE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7520     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7521         fmt.debug_struct("WCE_IRDA_DEVICE_INFO").field("irdaDeviceID", &self.irdaDeviceID).field("irdaDeviceName", &self.irdaDeviceName).field("Reserved", &self.Reserved).finish()
7522     }
7523 }
7524 #[cfg(feature = "Win32_Foundation")]
7525 impl ::std::cmp::PartialEq for WCE_IRDA_DEVICE_INFO {
eq(&self, other: &Self) -> bool7526     fn eq(&self, other: &Self) -> bool {
7527         self.irdaDeviceID == other.irdaDeviceID && self.irdaDeviceName == other.irdaDeviceName && self.Reserved == other.Reserved
7528     }
7529 }
7530 #[cfg(feature = "Win32_Foundation")]
7531 impl ::std::cmp::Eq for WCE_IRDA_DEVICE_INFO {}
7532 #[cfg(feature = "Win32_Foundation")]
7533 unsafe impl ::windows::runtime::Abi for WCE_IRDA_DEVICE_INFO {
7534     type Abi = Self;
7535     type DefaultType = Self;
7536 }
7537 pub const WCE_PF_IRDA: u32 = 22u32;
7538 pub const WINDOWS_AF_IRDA: u32 = 26u32;
7539 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7540 #[repr(C)]
7541 #[cfg(feature = "Win32_Foundation")]
7542 pub struct WINDOWS_DEVICELIST {
7543     pub numDevice: u32,
7544     pub Device: [WINDOWS_IRDA_DEVICE_INFO; 1],
7545 }
7546 #[cfg(feature = "Win32_Foundation")]
7547 impl WINDOWS_DEVICELIST {}
7548 #[cfg(feature = "Win32_Foundation")]
7549 impl ::std::default::Default for WINDOWS_DEVICELIST {
default() -> Self7550     fn default() -> Self {
7551         unsafe { ::std::mem::zeroed() }
7552     }
7553 }
7554 #[cfg(feature = "Win32_Foundation")]
7555 impl ::std::fmt::Debug for WINDOWS_DEVICELIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7556     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7557         fmt.debug_struct("WINDOWS_DEVICELIST").field("numDevice", &self.numDevice).field("Device", &self.Device).finish()
7558     }
7559 }
7560 #[cfg(feature = "Win32_Foundation")]
7561 impl ::std::cmp::PartialEq for WINDOWS_DEVICELIST {
eq(&self, other: &Self) -> bool7562     fn eq(&self, other: &Self) -> bool {
7563         self.numDevice == other.numDevice && self.Device == other.Device
7564     }
7565 }
7566 #[cfg(feature = "Win32_Foundation")]
7567 impl ::std::cmp::Eq for WINDOWS_DEVICELIST {}
7568 #[cfg(feature = "Win32_Foundation")]
7569 unsafe impl ::windows::runtime::Abi for WINDOWS_DEVICELIST {
7570     type Abi = Self;
7571     type DefaultType = Self;
7572 }
7573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7574 #[repr(C)]
7575 #[cfg(feature = "Win32_Foundation")]
7576 pub struct WINDOWS_IAS_QUERY {
7577     pub irdaDeviceID: [u8; 4],
7578     pub irdaClassName: [super::super::Foundation::CHAR; 64],
7579     pub irdaAttribName: [super::super::Foundation::CHAR; 256],
7580     pub irdaAttribType: u32,
7581     pub irdaAttribute: WINDOWS_IAS_QUERY_0,
7582 }
7583 #[cfg(feature = "Win32_Foundation")]
7584 impl WINDOWS_IAS_QUERY {}
7585 #[cfg(feature = "Win32_Foundation")]
7586 impl ::std::default::Default for WINDOWS_IAS_QUERY {
default() -> Self7587     fn default() -> Self {
7588         unsafe { ::std::mem::zeroed() }
7589     }
7590 }
7591 #[cfg(feature = "Win32_Foundation")]
7592 impl ::std::cmp::PartialEq for WINDOWS_IAS_QUERY {
eq(&self, _other: &Self) -> bool7593     fn eq(&self, _other: &Self) -> bool {
7594         unimplemented!()
7595     }
7596 }
7597 #[cfg(feature = "Win32_Foundation")]
7598 impl ::std::cmp::Eq for WINDOWS_IAS_QUERY {}
7599 #[cfg(feature = "Win32_Foundation")]
7600 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_QUERY {
7601     type Abi = Self;
7602     type DefaultType = Self;
7603 }
7604 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7605 #[repr(C)]
7606 pub union WINDOWS_IAS_QUERY_0 {
7607     pub irdaAttribInt: i32,
7608     pub irdaAttribOctetSeq: WINDOWS_IAS_QUERY_0_0,
7609     pub irdaAttribUsrStr: WINDOWS_IAS_QUERY_0_1,
7610 }
7611 impl WINDOWS_IAS_QUERY_0 {}
7612 impl ::std::default::Default for WINDOWS_IAS_QUERY_0 {
default() -> Self7613     fn default() -> Self {
7614         unsafe { ::std::mem::zeroed() }
7615     }
7616 }
7617 impl ::std::cmp::PartialEq for WINDOWS_IAS_QUERY_0 {
eq(&self, _other: &Self) -> bool7618     fn eq(&self, _other: &Self) -> bool {
7619         unimplemented!()
7620     }
7621 }
7622 impl ::std::cmp::Eq for WINDOWS_IAS_QUERY_0 {}
7623 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_QUERY_0 {
7624     type Abi = Self;
7625     type DefaultType = Self;
7626 }
7627 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7628 #[repr(C)]
7629 pub struct WINDOWS_IAS_QUERY_0_0 {
7630     pub Len: u32,
7631     pub OctetSeq: [u8; 1024],
7632 }
7633 impl WINDOWS_IAS_QUERY_0_0 {}
7634 impl ::std::default::Default for WINDOWS_IAS_QUERY_0_0 {
default() -> Self7635     fn default() -> Self {
7636         unsafe { ::std::mem::zeroed() }
7637     }
7638 }
7639 impl ::std::fmt::Debug for WINDOWS_IAS_QUERY_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7640     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7641         fmt.debug_struct("_irdaAttribOctetSeq_e__Struct").field("Len", &self.Len).field("OctetSeq", &self.OctetSeq).finish()
7642     }
7643 }
7644 impl ::std::cmp::PartialEq for WINDOWS_IAS_QUERY_0_0 {
eq(&self, other: &Self) -> bool7645     fn eq(&self, other: &Self) -> bool {
7646         self.Len == other.Len && self.OctetSeq == other.OctetSeq
7647     }
7648 }
7649 impl ::std::cmp::Eq for WINDOWS_IAS_QUERY_0_0 {}
7650 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_QUERY_0_0 {
7651     type Abi = Self;
7652     type DefaultType = Self;
7653 }
7654 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7655 #[repr(C)]
7656 pub struct WINDOWS_IAS_QUERY_0_1 {
7657     pub Len: u32,
7658     pub CharSet: u32,
7659     pub UsrStr: [u8; 256],
7660 }
7661 impl WINDOWS_IAS_QUERY_0_1 {}
7662 impl ::std::default::Default for WINDOWS_IAS_QUERY_0_1 {
default() -> Self7663     fn default() -> Self {
7664         unsafe { ::std::mem::zeroed() }
7665     }
7666 }
7667 impl ::std::fmt::Debug for WINDOWS_IAS_QUERY_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7668     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7669         fmt.debug_struct("_irdaAttribUsrStr_e__Struct").field("Len", &self.Len).field("CharSet", &self.CharSet).field("UsrStr", &self.UsrStr).finish()
7670     }
7671 }
7672 impl ::std::cmp::PartialEq for WINDOWS_IAS_QUERY_0_1 {
eq(&self, other: &Self) -> bool7673     fn eq(&self, other: &Self) -> bool {
7674         self.Len == other.Len && self.CharSet == other.CharSet && self.UsrStr == other.UsrStr
7675     }
7676 }
7677 impl ::std::cmp::Eq for WINDOWS_IAS_QUERY_0_1 {}
7678 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_QUERY_0_1 {
7679     type Abi = Self;
7680     type DefaultType = Self;
7681 }
7682 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7683 #[repr(C)]
7684 #[cfg(feature = "Win32_Foundation")]
7685 pub struct WINDOWS_IAS_SET {
7686     pub irdaClassName: [super::super::Foundation::CHAR; 64],
7687     pub irdaAttribName: [super::super::Foundation::CHAR; 256],
7688     pub irdaAttribType: u32,
7689     pub irdaAttribute: WINDOWS_IAS_SET_0,
7690 }
7691 #[cfg(feature = "Win32_Foundation")]
7692 impl WINDOWS_IAS_SET {}
7693 #[cfg(feature = "Win32_Foundation")]
7694 impl ::std::default::Default for WINDOWS_IAS_SET {
default() -> Self7695     fn default() -> Self {
7696         unsafe { ::std::mem::zeroed() }
7697     }
7698 }
7699 #[cfg(feature = "Win32_Foundation")]
7700 impl ::std::cmp::PartialEq for WINDOWS_IAS_SET {
eq(&self, _other: &Self) -> bool7701     fn eq(&self, _other: &Self) -> bool {
7702         unimplemented!()
7703     }
7704 }
7705 #[cfg(feature = "Win32_Foundation")]
7706 impl ::std::cmp::Eq for WINDOWS_IAS_SET {}
7707 #[cfg(feature = "Win32_Foundation")]
7708 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_SET {
7709     type Abi = Self;
7710     type DefaultType = Self;
7711 }
7712 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7713 #[repr(C)]
7714 pub union WINDOWS_IAS_SET_0 {
7715     pub irdaAttribInt: i32,
7716     pub irdaAttribOctetSeq: WINDOWS_IAS_SET_0_0,
7717     pub irdaAttribUsrStr: WINDOWS_IAS_SET_0_1,
7718 }
7719 impl WINDOWS_IAS_SET_0 {}
7720 impl ::std::default::Default for WINDOWS_IAS_SET_0 {
default() -> Self7721     fn default() -> Self {
7722         unsafe { ::std::mem::zeroed() }
7723     }
7724 }
7725 impl ::std::cmp::PartialEq for WINDOWS_IAS_SET_0 {
eq(&self, _other: &Self) -> bool7726     fn eq(&self, _other: &Self) -> bool {
7727         unimplemented!()
7728     }
7729 }
7730 impl ::std::cmp::Eq for WINDOWS_IAS_SET_0 {}
7731 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_SET_0 {
7732     type Abi = Self;
7733     type DefaultType = Self;
7734 }
7735 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7736 #[repr(C)]
7737 pub struct WINDOWS_IAS_SET_0_0 {
7738     pub Len: u16,
7739     pub OctetSeq: [u8; 1024],
7740 }
7741 impl WINDOWS_IAS_SET_0_0 {}
7742 impl ::std::default::Default for WINDOWS_IAS_SET_0_0 {
default() -> Self7743     fn default() -> Self {
7744         unsafe { ::std::mem::zeroed() }
7745     }
7746 }
7747 impl ::std::fmt::Debug for WINDOWS_IAS_SET_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7748     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7749         fmt.debug_struct("_irdaAttribOctetSeq_e__Struct").field("Len", &self.Len).field("OctetSeq", &self.OctetSeq).finish()
7750     }
7751 }
7752 impl ::std::cmp::PartialEq for WINDOWS_IAS_SET_0_0 {
eq(&self, other: &Self) -> bool7753     fn eq(&self, other: &Self) -> bool {
7754         self.Len == other.Len && self.OctetSeq == other.OctetSeq
7755     }
7756 }
7757 impl ::std::cmp::Eq for WINDOWS_IAS_SET_0_0 {}
7758 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_SET_0_0 {
7759     type Abi = Self;
7760     type DefaultType = Self;
7761 }
7762 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7763 #[repr(C)]
7764 pub struct WINDOWS_IAS_SET_0_1 {
7765     pub Len: u8,
7766     pub CharSet: u8,
7767     pub UsrStr: [u8; 256],
7768 }
7769 impl WINDOWS_IAS_SET_0_1 {}
7770 impl ::std::default::Default for WINDOWS_IAS_SET_0_1 {
default() -> Self7771     fn default() -> Self {
7772         unsafe { ::std::mem::zeroed() }
7773     }
7774 }
7775 impl ::std::fmt::Debug for WINDOWS_IAS_SET_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7776     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7777         fmt.debug_struct("_irdaAttribUsrStr_e__Struct").field("Len", &self.Len).field("CharSet", &self.CharSet).field("UsrStr", &self.UsrStr).finish()
7778     }
7779 }
7780 impl ::std::cmp::PartialEq for WINDOWS_IAS_SET_0_1 {
eq(&self, other: &Self) -> bool7781     fn eq(&self, other: &Self) -> bool {
7782         self.Len == other.Len && self.CharSet == other.CharSet && self.UsrStr == other.UsrStr
7783     }
7784 }
7785 impl ::std::cmp::Eq for WINDOWS_IAS_SET_0_1 {}
7786 unsafe impl ::windows::runtime::Abi for WINDOWS_IAS_SET_0_1 {
7787     type Abi = Self;
7788     type DefaultType = Self;
7789 }
7790 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7791 #[repr(C)]
7792 #[cfg(feature = "Win32_Foundation")]
7793 pub struct WINDOWS_IRDA_DEVICE_INFO {
7794     pub irdaDeviceID: [u8; 4],
7795     pub irdaDeviceName: [super::super::Foundation::CHAR; 22],
7796     pub irdaDeviceHints1: u8,
7797     pub irdaDeviceHints2: u8,
7798     pub irdaCharSet: u8,
7799 }
7800 #[cfg(feature = "Win32_Foundation")]
7801 impl WINDOWS_IRDA_DEVICE_INFO {}
7802 #[cfg(feature = "Win32_Foundation")]
7803 impl ::std::default::Default for WINDOWS_IRDA_DEVICE_INFO {
default() -> Self7804     fn default() -> Self {
7805         unsafe { ::std::mem::zeroed() }
7806     }
7807 }
7808 #[cfg(feature = "Win32_Foundation")]
7809 impl ::std::fmt::Debug for WINDOWS_IRDA_DEVICE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result7810     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7811         fmt.debug_struct("WINDOWS_IRDA_DEVICE_INFO").field("irdaDeviceID", &self.irdaDeviceID).field("irdaDeviceName", &self.irdaDeviceName).field("irdaDeviceHints1", &self.irdaDeviceHints1).field("irdaDeviceHints2", &self.irdaDeviceHints2).field("irdaCharSet", &self.irdaCharSet).finish()
7812     }
7813 }
7814 #[cfg(feature = "Win32_Foundation")]
7815 impl ::std::cmp::PartialEq for WINDOWS_IRDA_DEVICE_INFO {
eq(&self, other: &Self) -> bool7816     fn eq(&self, other: &Self) -> bool {
7817         self.irdaDeviceID == other.irdaDeviceID && self.irdaDeviceName == other.irdaDeviceName && self.irdaDeviceHints1 == other.irdaDeviceHints1 && self.irdaDeviceHints2 == other.irdaDeviceHints2 && self.irdaCharSet == other.irdaCharSet
7818     }
7819 }
7820 #[cfg(feature = "Win32_Foundation")]
7821 impl ::std::cmp::Eq for WINDOWS_IRDA_DEVICE_INFO {}
7822 #[cfg(feature = "Win32_Foundation")]
7823 unsafe impl ::windows::runtime::Abi for WINDOWS_IRDA_DEVICE_INFO {
7824     type Abi = Self;
7825     type DefaultType = Self;
7826 }
7827 pub const WINDOWS_PF_IRDA: u32 = 26u32;
7828 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
7829 #[inline]
WPUCompleteOverlappedRequest<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwerror: u32, cbtransferred: u32, lperrno: *mut i32) -> i327830 pub unsafe fn WPUCompleteOverlappedRequest<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwerror: u32, cbtransferred: u32, lperrno: *mut i32) -> i32 {
7831     #[cfg(windows)]
7832     {
7833         #[link(name = "windows")]
7834         extern "system" {
7835             fn WPUCompleteOverlappedRequest(s: SOCKET, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, dwerror: u32, cbtransferred: u32, lperrno: *mut i32) -> i32;
7836         }
7837         ::std::mem::transmute(WPUCompleteOverlappedRequest(s.into_param().abi(), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(dwerror), ::std::mem::transmute(cbtransferred), ::std::mem::transmute(lperrno)))
7838     }
7839     #[cfg(not(windows))]
7840     unimplemented!("Unsupported target OS");
7841 }
7842 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
7843 #[inline]
WSAAccept<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, addr: *mut SOCKADDR, addrlen: *mut i32, lpfncondition: ::std::option::Option<LPCONDITIONPROC>, dwcallbackdata: usize) -> SOCKET7844 pub unsafe fn WSAAccept<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, addr: *mut SOCKADDR, addrlen: *mut i32, lpfncondition: ::std::option::Option<LPCONDITIONPROC>, dwcallbackdata: usize) -> SOCKET {
7845     #[cfg(windows)]
7846     {
7847         #[link(name = "windows")]
7848         extern "system" {
7849             fn WSAAccept(s: SOCKET, addr: *mut SOCKADDR, addrlen: *mut i32, lpfncondition: ::windows::runtime::RawPtr, dwcallbackdata: usize) -> SOCKET;
7850         }
7851         ::std::mem::transmute(WSAAccept(s.into_param().abi(), ::std::mem::transmute(addr), ::std::mem::transmute(addrlen), ::std::mem::transmute(lpfncondition), ::std::mem::transmute(dwcallbackdata)))
7852     }
7853     #[cfg(not(windows))]
7854     unimplemented!("Unsupported target OS");
7855 }
7856 #[cfg(feature = "Win32_Foundation")]
7857 #[inline]
WSAAddressToStringA(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpszaddressstring: super::super::Foundation::PSTR, lpdwaddressstringlength: *mut u32) -> i327858 pub unsafe fn WSAAddressToStringA(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpszaddressstring: super::super::Foundation::PSTR, lpdwaddressstringlength: *mut u32) -> i32 {
7859     #[cfg(windows)]
7860     {
7861         #[link(name = "windows")]
7862         extern "system" {
7863             fn WSAAddressToStringA(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpszaddressstring: super::super::Foundation::PSTR, lpdwaddressstringlength: *mut u32) -> i32;
7864         }
7865         ::std::mem::transmute(WSAAddressToStringA(::std::mem::transmute(lpsaaddress), ::std::mem::transmute(dwaddresslength), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(lpszaddressstring), ::std::mem::transmute(lpdwaddressstringlength)))
7866     }
7867     #[cfg(not(windows))]
7868     unimplemented!("Unsupported target OS");
7869 }
7870 #[cfg(feature = "Win32_Foundation")]
7871 #[inline]
WSAAddressToStringW(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpszaddressstring: super::super::Foundation::PWSTR, lpdwaddressstringlength: *mut u32) -> i327872 pub unsafe fn WSAAddressToStringW(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpszaddressstring: super::super::Foundation::PWSTR, lpdwaddressstringlength: *mut u32) -> i32 {
7873     #[cfg(windows)]
7874     {
7875         #[link(name = "windows")]
7876         extern "system" {
7877             fn WSAAddressToStringW(lpsaaddress: *const SOCKADDR, dwaddresslength: u32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpszaddressstring: super::super::Foundation::PWSTR, lpdwaddressstringlength: *mut u32) -> i32;
7878         }
7879         ::std::mem::transmute(WSAAddressToStringW(::std::mem::transmute(lpsaaddress), ::std::mem::transmute(dwaddresslength), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(lpszaddressstring), ::std::mem::transmute(lpdwaddressstringlength)))
7880     }
7881     #[cfg(not(windows))]
7882     unimplemented!("Unsupported target OS");
7883 }
7884 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
7885 #[inline]
WSAAdvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID, pnspv2routine: *const NSPV2_ROUTINE) -> i327886 pub unsafe fn WSAAdvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID, pnspv2routine: *const NSPV2_ROUTINE) -> i32 {
7887     #[cfg(windows)]
7888     {
7889         #[link(name = "windows")]
7890         extern "system" {
7891             fn WSAAdvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID, pnspv2routine: *const ::std::mem::ManuallyDrop<NSPV2_ROUTINE>) -> i32;
7892         }
7893         ::std::mem::transmute(WSAAdvertiseProvider(::std::mem::transmute(puuidproviderid), ::std::mem::transmute(pnspv2routine)))
7894     }
7895     #[cfg(not(windows))]
7896     unimplemented!("Unsupported target OS");
7897 }
7898 #[cfg(feature = "Win32_Foundation")]
7899 #[inline]
WSAAsyncGetHostByAddr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, addr: Param2, len: i32, r#type: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7900 pub unsafe fn WSAAsyncGetHostByAddr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, addr: Param2, len: i32, r#type: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7901     #[cfg(windows)]
7902     {
7903         #[link(name = "windows")]
7904         extern "system" {
7905             fn WSAAsyncGetHostByAddr(hwnd: super::super::Foundation::HWND, wmsg: u32, addr: super::super::Foundation::PSTR, len: i32, r#type: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7906         }
7907         ::std::mem::transmute(WSAAsyncGetHostByAddr(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), addr.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(r#type), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7908     }
7909     #[cfg(not(windows))]
7910     unimplemented!("Unsupported target OS");
7911 }
7912 #[cfg(feature = "Win32_Foundation")]
7913 #[inline]
WSAAsyncGetHostByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7914 pub unsafe fn WSAAsyncGetHostByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7915     #[cfg(windows)]
7916     {
7917         #[link(name = "windows")]
7918         extern "system" {
7919             fn WSAAsyncGetHostByName(hwnd: super::super::Foundation::HWND, wmsg: u32, name: super::super::Foundation::PSTR, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7920         }
7921         ::std::mem::transmute(WSAAsyncGetHostByName(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), name.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7922     }
7923     #[cfg(not(windows))]
7924     unimplemented!("Unsupported target OS");
7925 }
7926 #[cfg(feature = "Win32_Foundation")]
7927 #[inline]
WSAAsyncGetProtoByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7928 pub unsafe fn WSAAsyncGetProtoByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7929     #[cfg(windows)]
7930     {
7931         #[link(name = "windows")]
7932         extern "system" {
7933             fn WSAAsyncGetProtoByName(hwnd: super::super::Foundation::HWND, wmsg: u32, name: super::super::Foundation::PSTR, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7934         }
7935         ::std::mem::transmute(WSAAsyncGetProtoByName(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), name.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7936     }
7937     #[cfg(not(windows))]
7938     unimplemented!("Unsupported target OS");
7939 }
7940 #[cfg(feature = "Win32_Foundation")]
7941 #[inline]
WSAAsyncGetProtoByNumber<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, wmsg: u32, number: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7942 pub unsafe fn WSAAsyncGetProtoByNumber<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, wmsg: u32, number: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7943     #[cfg(windows)]
7944     {
7945         #[link(name = "windows")]
7946         extern "system" {
7947             fn WSAAsyncGetProtoByNumber(hwnd: super::super::Foundation::HWND, wmsg: u32, number: i32, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7948         }
7949         ::std::mem::transmute(WSAAsyncGetProtoByNumber(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), ::std::mem::transmute(number), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7950     }
7951     #[cfg(not(windows))]
7952     unimplemented!("Unsupported target OS");
7953 }
7954 #[cfg(feature = "Win32_Foundation")]
7955 #[inline]
WSAAsyncGetServByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, proto: Param3, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7956 pub unsafe fn WSAAsyncGetServByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, name: Param2, proto: Param3, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7957     #[cfg(windows)]
7958     {
7959         #[link(name = "windows")]
7960         extern "system" {
7961             fn WSAAsyncGetServByName(hwnd: super::super::Foundation::HWND, wmsg: u32, name: super::super::Foundation::PSTR, proto: super::super::Foundation::PSTR, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7962         }
7963         ::std::mem::transmute(WSAAsyncGetServByName(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), name.into_param().abi(), proto.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7964     }
7965     #[cfg(not(windows))]
7966     unimplemented!("Unsupported target OS");
7967 }
7968 #[cfg(feature = "Win32_Foundation")]
7969 #[inline]
WSAAsyncGetServByPort<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, port: i32, proto: Param3, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE7970 pub unsafe fn WSAAsyncGetServByPort<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(hwnd: Param0, wmsg: u32, port: i32, proto: Param3, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE {
7971     #[cfg(windows)]
7972     {
7973         #[link(name = "windows")]
7974         extern "system" {
7975             fn WSAAsyncGetServByPort(hwnd: super::super::Foundation::HWND, wmsg: u32, port: i32, proto: super::super::Foundation::PSTR, buf: super::super::Foundation::PSTR, buflen: i32) -> super::super::Foundation::HANDLE;
7976         }
7977         ::std::mem::transmute(WSAAsyncGetServByPort(hwnd.into_param().abi(), ::std::mem::transmute(wmsg), ::std::mem::transmute(port), proto.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(buflen)))
7978     }
7979     #[cfg(not(windows))]
7980     unimplemented!("Unsupported target OS");
7981 }
7982 #[cfg(feature = "Win32_Foundation")]
7983 #[inline]
WSAAsyncSelect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(s: Param0, hwnd: Param1, wmsg: u32, levent: i32) -> i327984 pub unsafe fn WSAAsyncSelect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(s: Param0, hwnd: Param1, wmsg: u32, levent: i32) -> i32 {
7985     #[cfg(windows)]
7986     {
7987         #[link(name = "windows")]
7988         extern "system" {
7989             fn WSAAsyncSelect(s: SOCKET, hwnd: super::super::Foundation::HWND, wmsg: u32, levent: i32) -> i32;
7990         }
7991         ::std::mem::transmute(WSAAsyncSelect(s.into_param().abi(), hwnd.into_param().abi(), ::std::mem::transmute(wmsg), ::std::mem::transmute(levent)))
7992     }
7993     #[cfg(not(windows))]
7994     unimplemented!("Unsupported target OS");
7995 }
7996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
7997 #[repr(C)]
7998 #[cfg(feature = "Win32_Foundation")]
7999 pub struct WSABUF {
8000     pub len: u32,
8001     pub buf: super::super::Foundation::PSTR,
8002 }
8003 #[cfg(feature = "Win32_Foundation")]
8004 impl WSABUF {}
8005 #[cfg(feature = "Win32_Foundation")]
8006 impl ::std::default::Default for WSABUF {
default() -> Self8007     fn default() -> Self {
8008         unsafe { ::std::mem::zeroed() }
8009     }
8010 }
8011 #[cfg(feature = "Win32_Foundation")]
8012 impl ::std::fmt::Debug for WSABUF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8013     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8014         fmt.debug_struct("WSABUF").field("len", &self.len).field("buf", &self.buf).finish()
8015     }
8016 }
8017 #[cfg(feature = "Win32_Foundation")]
8018 impl ::std::cmp::PartialEq for WSABUF {
eq(&self, other: &Self) -> bool8019     fn eq(&self, other: &Self) -> bool {
8020         self.len == other.len && self.buf == other.buf
8021     }
8022 }
8023 #[cfg(feature = "Win32_Foundation")]
8024 impl ::std::cmp::Eq for WSABUF {}
8025 #[cfg(feature = "Win32_Foundation")]
8026 unsafe impl ::windows::runtime::Abi for WSABUF {
8027     type Abi = Self;
8028     type DefaultType = Self;
8029 }
8030 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8031 impl ::std::clone::Clone for WSACOMPLETION {
clone(&self) -> Self8032     fn clone(&self) -> Self {
8033         unimplemented!()
8034     }
8035 }
8036 #[repr(C)]
8037 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8038 pub struct WSACOMPLETION {
8039     pub Type: WSACOMPLETIONTYPE,
8040     pub Parameters: WSACOMPLETION_0,
8041 }
8042 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8043 impl WSACOMPLETION {}
8044 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8045 impl ::std::default::Default for WSACOMPLETION {
default() -> Self8046     fn default() -> Self {
8047         unsafe { ::std::mem::zeroed() }
8048     }
8049 }
8050 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8051 impl ::std::cmp::PartialEq for WSACOMPLETION {
eq(&self, _other: &Self) -> bool8052     fn eq(&self, _other: &Self) -> bool {
8053         unimplemented!()
8054     }
8055 }
8056 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8057 impl ::std::cmp::Eq for WSACOMPLETION {}
8058 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8059 unsafe impl ::windows::runtime::Abi for WSACOMPLETION {
8060     type Abi = ::std::mem::ManuallyDrop<Self>;
8061     type DefaultType = Self;
8062 }
8063 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8064 impl ::std::clone::Clone for WSACOMPLETION_0 {
clone(&self) -> Self8065     fn clone(&self) -> Self {
8066         unimplemented!()
8067     }
8068 }
8069 #[repr(C)]
8070 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8071 pub union WSACOMPLETION_0 {
8072     pub WindowMessage: WSACOMPLETION_0_3,
8073     pub Event: WSACOMPLETION_0_1,
8074     pub Apc: ::std::mem::ManuallyDrop<WSACOMPLETION_0_0>,
8075     pub Port: WSACOMPLETION_0_2,
8076 }
8077 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8078 impl WSACOMPLETION_0 {}
8079 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8080 impl ::std::default::Default for WSACOMPLETION_0 {
default() -> Self8081     fn default() -> Self {
8082         unsafe { ::std::mem::zeroed() }
8083     }
8084 }
8085 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8086 impl ::std::cmp::PartialEq for WSACOMPLETION_0 {
eq(&self, _other: &Self) -> bool8087     fn eq(&self, _other: &Self) -> bool {
8088         unimplemented!()
8089     }
8090 }
8091 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8092 impl ::std::cmp::Eq for WSACOMPLETION_0 {}
8093 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8094 unsafe impl ::windows::runtime::Abi for WSACOMPLETION_0 {
8095     type Abi = ::std::mem::ManuallyDrop<Self>;
8096     type DefaultType = Self;
8097 }
8098 #[derive(:: std :: clone :: Clone)]
8099 #[repr(C)]
8100 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8101 pub struct WSACOMPLETION_0_0 {
8102     pub lpOverlapped: *mut super::super::System::IO::OVERLAPPED,
8103     pub lpfnCompletionProc: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>,
8104 }
8105 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8106 impl WSACOMPLETION_0_0 {}
8107 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8108 impl ::std::default::Default for WSACOMPLETION_0_0 {
default() -> Self8109     fn default() -> Self {
8110         unsafe { ::std::mem::zeroed() }
8111     }
8112 }
8113 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8114 impl ::std::fmt::Debug for WSACOMPLETION_0_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8115     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8116         fmt.debug_struct("_Apc_e__Struct").field("lpOverlapped", &self.lpOverlapped).finish()
8117     }
8118 }
8119 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8120 impl ::std::cmp::PartialEq for WSACOMPLETION_0_0 {
eq(&self, other: &Self) -> bool8121     fn eq(&self, other: &Self) -> bool {
8122         self.lpOverlapped == other.lpOverlapped && self.lpfnCompletionProc.map(|f| f as usize) == other.lpfnCompletionProc.map(|f| f as usize)
8123     }
8124 }
8125 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8126 impl ::std::cmp::Eq for WSACOMPLETION_0_0 {}
8127 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8128 unsafe impl ::windows::runtime::Abi for WSACOMPLETION_0_0 {
8129     type Abi = ::std::mem::ManuallyDrop<Self>;
8130     type DefaultType = Self;
8131 }
8132 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8133 #[repr(C)]
8134 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8135 pub struct WSACOMPLETION_0_1 {
8136     pub lpOverlapped: *mut super::super::System::IO::OVERLAPPED,
8137 }
8138 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8139 impl WSACOMPLETION_0_1 {}
8140 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8141 impl ::std::default::Default for WSACOMPLETION_0_1 {
default() -> Self8142     fn default() -> Self {
8143         unsafe { ::std::mem::zeroed() }
8144     }
8145 }
8146 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8147 impl ::std::fmt::Debug for WSACOMPLETION_0_1 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8148     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8149         fmt.debug_struct("_Event_e__Struct").field("lpOverlapped", &self.lpOverlapped).finish()
8150     }
8151 }
8152 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8153 impl ::std::cmp::PartialEq for WSACOMPLETION_0_1 {
eq(&self, other: &Self) -> bool8154     fn eq(&self, other: &Self) -> bool {
8155         self.lpOverlapped == other.lpOverlapped
8156     }
8157 }
8158 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8159 impl ::std::cmp::Eq for WSACOMPLETION_0_1 {}
8160 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8161 unsafe impl ::windows::runtime::Abi for WSACOMPLETION_0_1 {
8162     type Abi = Self;
8163     type DefaultType = Self;
8164 }
8165 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8166 #[repr(C)]
8167 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8168 pub struct WSACOMPLETION_0_2 {
8169     pub lpOverlapped: *mut super::super::System::IO::OVERLAPPED,
8170     pub hPort: super::super::Foundation::HANDLE,
8171     pub Key: usize,
8172 }
8173 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8174 impl WSACOMPLETION_0_2 {}
8175 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8176 impl ::std::default::Default for WSACOMPLETION_0_2 {
default() -> Self8177     fn default() -> Self {
8178         unsafe { ::std::mem::zeroed() }
8179     }
8180 }
8181 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8182 impl ::std::fmt::Debug for WSACOMPLETION_0_2 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8183     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8184         fmt.debug_struct("_Port_e__Struct").field("lpOverlapped", &self.lpOverlapped).field("hPort", &self.hPort).field("Key", &self.Key).finish()
8185     }
8186 }
8187 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8188 impl ::std::cmp::PartialEq for WSACOMPLETION_0_2 {
eq(&self, other: &Self) -> bool8189     fn eq(&self, other: &Self) -> bool {
8190         self.lpOverlapped == other.lpOverlapped && self.hPort == other.hPort && self.Key == other.Key
8191     }
8192 }
8193 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8194 impl ::std::cmp::Eq for WSACOMPLETION_0_2 {}
8195 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8196 unsafe impl ::windows::runtime::Abi for WSACOMPLETION_0_2 {
8197     type Abi = Self;
8198     type DefaultType = Self;
8199 }
8200 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8201 #[repr(C)]
8202 #[cfg(feature = "Win32_Foundation")]
8203 pub struct WSACOMPLETION_0_3 {
8204     pub hWnd: super::super::Foundation::HWND,
8205     pub uMsg: u32,
8206     pub context: super::super::Foundation::WPARAM,
8207 }
8208 #[cfg(feature = "Win32_Foundation")]
8209 impl WSACOMPLETION_0_3 {}
8210 #[cfg(feature = "Win32_Foundation")]
8211 impl ::std::default::Default for WSACOMPLETION_0_3 {
default() -> Self8212     fn default() -> Self {
8213         unsafe { ::std::mem::zeroed() }
8214     }
8215 }
8216 #[cfg(feature = "Win32_Foundation")]
8217 impl ::std::fmt::Debug for WSACOMPLETION_0_3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8218     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8219         fmt.debug_struct("_WindowMessage_e__Struct").field("hWnd", &self.hWnd).field("uMsg", &self.uMsg).field("context", &self.context).finish()
8220     }
8221 }
8222 #[cfg(feature = "Win32_Foundation")]
8223 impl ::std::cmp::PartialEq for WSACOMPLETION_0_3 {
eq(&self, other: &Self) -> bool8224     fn eq(&self, other: &Self) -> bool {
8225         self.hWnd == other.hWnd && self.uMsg == other.uMsg && self.context == other.context
8226     }
8227 }
8228 #[cfg(feature = "Win32_Foundation")]
8229 impl ::std::cmp::Eq for WSACOMPLETION_0_3 {}
8230 #[cfg(feature = "Win32_Foundation")]
8231 unsafe impl ::windows::runtime::Abi for WSACOMPLETION_0_3 {
8232     type Abi = Self;
8233     type DefaultType = Self;
8234 }
8235 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8236 #[repr(transparent)]
8237 pub struct WSACOMPLETIONTYPE(pub i32);
8238 pub const NSP_NOTIFY_IMMEDIATELY: WSACOMPLETIONTYPE = WSACOMPLETIONTYPE(0i32);
8239 pub const NSP_NOTIFY_HWND: WSACOMPLETIONTYPE = WSACOMPLETIONTYPE(1i32);
8240 pub const NSP_NOTIFY_EVENT: WSACOMPLETIONTYPE = WSACOMPLETIONTYPE(2i32);
8241 pub const NSP_NOTIFY_PORT: WSACOMPLETIONTYPE = WSACOMPLETIONTYPE(3i32);
8242 pub const NSP_NOTIFY_APC: WSACOMPLETIONTYPE = WSACOMPLETIONTYPE(4i32);
8243 impl ::std::convert::From<i32> for WSACOMPLETIONTYPE {
from(value: i32) -> Self8244     fn from(value: i32) -> Self {
8245         Self(value)
8246     }
8247 }
8248 unsafe impl ::windows::runtime::Abi for WSACOMPLETIONTYPE {
8249     type Abi = Self;
8250     type DefaultType = Self;
8251 }
8252 #[cfg(feature = "Win32_Foundation")]
8253 #[inline]
WSACancelAsyncRequest<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hasynctaskhandle: Param0) -> i328254 pub unsafe fn WSACancelAsyncRequest<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hasynctaskhandle: Param0) -> i32 {
8255     #[cfg(windows)]
8256     {
8257         #[link(name = "windows")]
8258         extern "system" {
8259             fn WSACancelAsyncRequest(hasynctaskhandle: super::super::Foundation::HANDLE) -> i32;
8260         }
8261         ::std::mem::transmute(WSACancelAsyncRequest(hasynctaskhandle.into_param().abi()))
8262     }
8263     #[cfg(not(windows))]
8264     unimplemented!("Unsupported target OS");
8265 }
8266 #[inline]
WSACancelBlockingCall() -> i328267 pub unsafe fn WSACancelBlockingCall() -> i32 {
8268     #[cfg(windows)]
8269     {
8270         #[link(name = "windows")]
8271         extern "system" {
8272             fn WSACancelBlockingCall() -> i32;
8273         }
8274         ::std::mem::transmute(WSACancelBlockingCall())
8275     }
8276     #[cfg(not(windows))]
8277     unimplemented!("Unsupported target OS");
8278 }
8279 #[inline]
WSACleanup() -> i328280 pub unsafe fn WSACleanup() -> i32 {
8281     #[cfg(windows)]
8282     {
8283         #[link(name = "windows")]
8284         extern "system" {
8285             fn WSACleanup() -> i32;
8286         }
8287         ::std::mem::transmute(WSACleanup())
8288     }
8289     #[cfg(not(windows))]
8290     unimplemented!("Unsupported target OS");
8291 }
8292 #[cfg(feature = "Win32_Foundation")]
8293 #[inline]
WSACloseEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL8294 pub unsafe fn WSACloseEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL {
8295     #[cfg(windows)]
8296     {
8297         #[link(name = "windows")]
8298         extern "system" {
8299             fn WSACloseEvent(hevent: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
8300         }
8301         ::std::mem::transmute(WSACloseEvent(hevent.into_param().abi()))
8302     }
8303     #[cfg(not(windows))]
8304     unimplemented!("Unsupported target OS");
8305 }
8306 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
8307 #[inline]
WSAConnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS) -> i328308 pub unsafe fn WSAConnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS) -> i32 {
8309     #[cfg(windows)]
8310     {
8311         #[link(name = "windows")]
8312         extern "system" {
8313             fn WSAConnect(s: SOCKET, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS) -> i32;
8314         }
8315         ::std::mem::transmute(WSAConnect(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen), ::std::mem::transmute(lpcallerdata), ::std::mem::transmute(lpcalleedata), ::std::mem::transmute(lpsqos), ::std::mem::transmute(lpgqos)))
8316     }
8317     #[cfg(not(windows))]
8318     unimplemented!("Unsupported target OS");
8319 }
8320 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8321 #[inline]
WSAConnectByList<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, socketaddress: *const SOCKET_ADDRESS_LIST, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL8322 pub unsafe fn WSAConnectByList<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, socketaddress: *const SOCKET_ADDRESS_LIST, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL {
8323     #[cfg(windows)]
8324     {
8325         #[link(name = "windows")]
8326         extern "system" {
8327             fn WSAConnectByList(s: SOCKET, socketaddress: *const SOCKET_ADDRESS_LIST, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
8328         }
8329         ::std::mem::transmute(WSAConnectByList(
8330             s.into_param().abi(),
8331             ::std::mem::transmute(socketaddress),
8332             ::std::mem::transmute(localaddresslength),
8333             ::std::mem::transmute(localaddress),
8334             ::std::mem::transmute(remoteaddresslength),
8335             ::std::mem::transmute(remoteaddress),
8336             ::std::mem::transmute(timeout),
8337             ::std::mem::transmute(reserved),
8338         ))
8339     }
8340     #[cfg(not(windows))]
8341     unimplemented!("Unsupported target OS");
8342 }
8343 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8344 #[inline]
WSAConnectByNameA<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>( s: Param0, nodename: Param1, servicename: Param2, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED, ) -> super::super::Foundation::BOOL8345 pub unsafe fn WSAConnectByNameA<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(
8346     s: Param0,
8347     nodename: Param1,
8348     servicename: Param2,
8349     localaddresslength: *mut u32,
8350     localaddress: *mut SOCKADDR,
8351     remoteaddresslength: *mut u32,
8352     remoteaddress: *mut SOCKADDR,
8353     timeout: *const timeval,
8354     reserved: *mut super::super::System::IO::OVERLAPPED,
8355 ) -> super::super::Foundation::BOOL {
8356     #[cfg(windows)]
8357     {
8358         #[link(name = "windows")]
8359         extern "system" {
8360             fn WSAConnectByNameA(s: SOCKET, nodename: super::super::Foundation::PSTR, servicename: super::super::Foundation::PSTR, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
8361         }
8362         ::std::mem::transmute(WSAConnectByNameA(
8363             s.into_param().abi(),
8364             nodename.into_param().abi(),
8365             servicename.into_param().abi(),
8366             ::std::mem::transmute(localaddresslength),
8367             ::std::mem::transmute(localaddress),
8368             ::std::mem::transmute(remoteaddresslength),
8369             ::std::mem::transmute(remoteaddress),
8370             ::std::mem::transmute(timeout),
8371             ::std::mem::transmute(reserved),
8372         ))
8373     }
8374     #[cfg(not(windows))]
8375     unimplemented!("Unsupported target OS");
8376 }
8377 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8378 #[inline]
WSAConnectByNameW<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( s: Param0, nodename: Param1, servicename: Param2, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED, ) -> super::super::Foundation::BOOL8379 pub unsafe fn WSAConnectByNameW<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
8380     s: Param0,
8381     nodename: Param1,
8382     servicename: Param2,
8383     localaddresslength: *mut u32,
8384     localaddress: *mut SOCKADDR,
8385     remoteaddresslength: *mut u32,
8386     remoteaddress: *mut SOCKADDR,
8387     timeout: *const timeval,
8388     reserved: *mut super::super::System::IO::OVERLAPPED,
8389 ) -> super::super::Foundation::BOOL {
8390     #[cfg(windows)]
8391     {
8392         #[link(name = "windows")]
8393         extern "system" {
8394             fn WSAConnectByNameW(s: SOCKET, nodename: super::super::Foundation::PWSTR, servicename: super::super::Foundation::PWSTR, localaddresslength: *mut u32, localaddress: *mut SOCKADDR, remoteaddresslength: *mut u32, remoteaddress: *mut SOCKADDR, timeout: *const timeval, reserved: *mut super::super::System::IO::OVERLAPPED) -> super::super::Foundation::BOOL;
8395         }
8396         ::std::mem::transmute(WSAConnectByNameW(
8397             s.into_param().abi(),
8398             nodename.into_param().abi(),
8399             servicename.into_param().abi(),
8400             ::std::mem::transmute(localaddresslength),
8401             ::std::mem::transmute(localaddress),
8402             ::std::mem::transmute(remoteaddresslength),
8403             ::std::mem::transmute(remoteaddress),
8404             ::std::mem::transmute(timeout),
8405             ::std::mem::transmute(reserved),
8406         ))
8407     }
8408     #[cfg(not(windows))]
8409     unimplemented!("Unsupported target OS");
8410 }
8411 #[cfg(feature = "Win32_Foundation")]
8412 #[inline]
WSACreateEvent() -> super::super::Foundation::HANDLE8413 pub unsafe fn WSACreateEvent() -> super::super::Foundation::HANDLE {
8414     #[cfg(windows)]
8415     {
8416         #[link(name = "windows")]
8417         extern "system" {
8418             fn WSACreateEvent() -> super::super::Foundation::HANDLE;
8419         }
8420         ::std::mem::transmute(WSACreateEvent())
8421     }
8422     #[cfg(not(windows))]
8423     unimplemented!("Unsupported target OS");
8424 }
8425 pub const WSADESCRIPTION_LEN: u32 = 256u32;
8426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8427 #[repr(C)]
8428 #[cfg(feature = "Win32_Foundation")]
8429 pub struct WSAData {
8430     pub wVersion: u16,
8431     pub wHighVersion: u16,
8432     pub iMaxSockets: u16,
8433     pub iMaxUdpDg: u16,
8434     pub lpVendorInfo: super::super::Foundation::PSTR,
8435     pub szDescription: [super::super::Foundation::CHAR; 257],
8436     pub szSystemStatus: [super::super::Foundation::CHAR; 129],
8437 }
8438 #[cfg(feature = "Win32_Foundation")]
8439 impl WSAData {}
8440 #[cfg(feature = "Win32_Foundation")]
8441 impl ::std::default::Default for WSAData {
default() -> Self8442     fn default() -> Self {
8443         unsafe { ::std::mem::zeroed() }
8444     }
8445 }
8446 #[cfg(feature = "Win32_Foundation")]
8447 impl ::std::fmt::Debug for WSAData {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8448     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8449         fmt.debug_struct("WSAData")
8450             .field("wVersion", &self.wVersion)
8451             .field("wHighVersion", &self.wHighVersion)
8452             .field("iMaxSockets", &self.iMaxSockets)
8453             .field("iMaxUdpDg", &self.iMaxUdpDg)
8454             .field("lpVendorInfo", &self.lpVendorInfo)
8455             .field("szDescription", &self.szDescription)
8456             .field("szSystemStatus", &self.szSystemStatus)
8457             .finish()
8458     }
8459 }
8460 #[cfg(feature = "Win32_Foundation")]
8461 impl ::std::cmp::PartialEq for WSAData {
eq(&self, other: &Self) -> bool8462     fn eq(&self, other: &Self) -> bool {
8463         self.wVersion == other.wVersion && self.wHighVersion == other.wHighVersion && self.iMaxSockets == other.iMaxSockets && self.iMaxUdpDg == other.iMaxUdpDg && self.lpVendorInfo == other.lpVendorInfo && self.szDescription == other.szDescription && self.szSystemStatus == other.szSystemStatus
8464     }
8465 }
8466 #[cfg(feature = "Win32_Foundation")]
8467 impl ::std::cmp::Eq for WSAData {}
8468 #[cfg(feature = "Win32_Foundation")]
8469 unsafe impl ::windows::runtime::Abi for WSAData {
8470     type Abi = Self;
8471     type DefaultType = Self;
8472 }
8473 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8474 #[inline]
WSADeleteSocketPeerTargetName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peeraddr: *const SOCKADDR, peeraddrlen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i328475 pub unsafe fn WSADeleteSocketPeerTargetName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peeraddr: *const SOCKADDR, peeraddrlen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
8476     #[cfg(windows)]
8477     {
8478         #[link(name = "windows")]
8479         extern "system" {
8480             fn WSADeleteSocketPeerTargetName(socket: SOCKET, peeraddr: *const SOCKADDR, peeraddrlen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::windows::runtime::RawPtr) -> i32;
8481         }
8482         ::std::mem::transmute(WSADeleteSocketPeerTargetName(socket.into_param().abi(), ::std::mem::transmute(peeraddr), ::std::mem::transmute(peeraddrlen), ::std::mem::transmute(overlapped), ::std::mem::transmute(completionroutine)))
8483     }
8484     #[cfg(not(windows))]
8485     unimplemented!("Unsupported target OS");
8486 }
8487 #[cfg(feature = "Win32_Foundation")]
8488 #[inline]
WSADuplicateSocketA<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOA) -> i328489 pub unsafe fn WSADuplicateSocketA<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOA) -> i32 {
8490     #[cfg(windows)]
8491     {
8492         #[link(name = "windows")]
8493         extern "system" {
8494             fn WSADuplicateSocketA(s: SOCKET, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOA) -> i32;
8495         }
8496         ::std::mem::transmute(WSADuplicateSocketA(s.into_param().abi(), ::std::mem::transmute(dwprocessid), ::std::mem::transmute(lpprotocolinfo)))
8497     }
8498     #[cfg(not(windows))]
8499     unimplemented!("Unsupported target OS");
8500 }
8501 #[inline]
WSADuplicateSocketW<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOW) -> i328502 pub unsafe fn WSADuplicateSocketW<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOW) -> i32 {
8503     #[cfg(windows)]
8504     {
8505         #[link(name = "windows")]
8506         extern "system" {
8507             fn WSADuplicateSocketW(s: SOCKET, dwprocessid: u32, lpprotocolinfo: *mut WSAPROTOCOL_INFOW) -> i32;
8508         }
8509         ::std::mem::transmute(WSADuplicateSocketW(s.into_param().abi(), ::std::mem::transmute(dwprocessid), ::std::mem::transmute(lpprotocolinfo)))
8510     }
8511     #[cfg(not(windows))]
8512     unimplemented!("Unsupported target OS");
8513 }
8514 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8515 #[repr(transparent)]
8516 pub struct WSAECOMPARATOR(pub i32);
8517 pub const COMP_EQUAL: WSAECOMPARATOR = WSAECOMPARATOR(0i32);
8518 pub const COMP_NOTLESS: WSAECOMPARATOR = WSAECOMPARATOR(1i32);
8519 impl ::std::convert::From<i32> for WSAECOMPARATOR {
from(value: i32) -> Self8520     fn from(value: i32) -> Self {
8521         Self(value)
8522     }
8523 }
8524 unsafe impl ::windows::runtime::Abi for WSAECOMPARATOR {
8525     type Abi = Self;
8526     type DefaultType = Self;
8527 }
8528 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8529 #[repr(transparent)]
8530 pub struct WSAESETSERVICEOP(pub i32);
8531 pub const RNRSERVICE_REGISTER: WSAESETSERVICEOP = WSAESETSERVICEOP(0i32);
8532 pub const RNRSERVICE_DEREGISTER: WSAESETSERVICEOP = WSAESETSERVICEOP(1i32);
8533 pub const RNRSERVICE_DELETE: WSAESETSERVICEOP = WSAESETSERVICEOP(2i32);
8534 impl ::std::convert::From<i32> for WSAESETSERVICEOP {
from(value: i32) -> Self8535     fn from(value: i32) -> Self {
8536         Self(value)
8537     }
8538 }
8539 unsafe impl ::windows::runtime::Abi for WSAESETSERVICEOP {
8540     type Abi = Self;
8541     type DefaultType = Self;
8542 }
8543 #[cfg(feature = "Win32_Foundation")]
8544 #[inline]
WSAEnumNameSpaceProvidersA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOA) -> i328545 pub unsafe fn WSAEnumNameSpaceProvidersA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOA) -> i32 {
8546     #[cfg(windows)]
8547     {
8548         #[link(name = "windows")]
8549         extern "system" {
8550             fn WSAEnumNameSpaceProvidersA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOA) -> i32;
8551         }
8552         ::std::mem::transmute(WSAEnumNameSpaceProvidersA(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
8553     }
8554     #[cfg(not(windows))]
8555     unimplemented!("Unsupported target OS");
8556 }
8557 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8558 #[inline]
WSAEnumNameSpaceProvidersExA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXA) -> i328559 pub unsafe fn WSAEnumNameSpaceProvidersExA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXA) -> i32 {
8560     #[cfg(windows)]
8561     {
8562         #[link(name = "windows")]
8563         extern "system" {
8564             fn WSAEnumNameSpaceProvidersExA(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXA) -> i32;
8565         }
8566         ::std::mem::transmute(WSAEnumNameSpaceProvidersExA(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
8567     }
8568     #[cfg(not(windows))]
8569     unimplemented!("Unsupported target OS");
8570 }
8571 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8572 #[inline]
WSAEnumNameSpaceProvidersExW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i328573 pub unsafe fn WSAEnumNameSpaceProvidersExW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i32 {
8574     #[cfg(windows)]
8575     {
8576         #[link(name = "windows")]
8577         extern "system" {
8578             fn WSAEnumNameSpaceProvidersExW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i32;
8579         }
8580         ::std::mem::transmute(WSAEnumNameSpaceProvidersExW(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
8581     }
8582     #[cfg(not(windows))]
8583     unimplemented!("Unsupported target OS");
8584 }
8585 #[cfg(feature = "Win32_Foundation")]
8586 #[inline]
WSAEnumNameSpaceProvidersW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i328587 pub unsafe fn WSAEnumNameSpaceProvidersW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i32 {
8588     #[cfg(windows)]
8589     {
8590         #[link(name = "windows")]
8591         extern "system" {
8592             fn WSAEnumNameSpaceProvidersW(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i32;
8593         }
8594         ::std::mem::transmute(WSAEnumNameSpaceProvidersW(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
8595     }
8596     #[cfg(not(windows))]
8597     unimplemented!("Unsupported target OS");
8598 }
8599 #[cfg(feature = "Win32_Foundation")]
8600 #[inline]
WSAEnumNetworkEvents<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(s: Param0, heventobject: Param1, lpnetworkevents: *mut WSANETWORKEVENTS) -> i328601 pub unsafe fn WSAEnumNetworkEvents<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(s: Param0, heventobject: Param1, lpnetworkevents: *mut WSANETWORKEVENTS) -> i32 {
8602     #[cfg(windows)]
8603     {
8604         #[link(name = "windows")]
8605         extern "system" {
8606             fn WSAEnumNetworkEvents(s: SOCKET, heventobject: super::super::Foundation::HANDLE, lpnetworkevents: *mut WSANETWORKEVENTS) -> i32;
8607         }
8608         ::std::mem::transmute(WSAEnumNetworkEvents(s.into_param().abi(), heventobject.into_param().abi(), ::std::mem::transmute(lpnetworkevents)))
8609     }
8610     #[cfg(not(windows))]
8611     unimplemented!("Unsupported target OS");
8612 }
8613 #[cfg(feature = "Win32_Foundation")]
8614 #[inline]
WSAEnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOA, lpdwbufferlength: *mut u32) -> i328615 pub unsafe fn WSAEnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOA, lpdwbufferlength: *mut u32) -> i32 {
8616     #[cfg(windows)]
8617     {
8618         #[link(name = "windows")]
8619         extern "system" {
8620             fn WSAEnumProtocolsA(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOA, lpdwbufferlength: *mut u32) -> i32;
8621         }
8622         ::std::mem::transmute(WSAEnumProtocolsA(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength)))
8623     }
8624     #[cfg(not(windows))]
8625     unimplemented!("Unsupported target OS");
8626 }
8627 #[inline]
WSAEnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32) -> i328628 pub unsafe fn WSAEnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32) -> i32 {
8629     #[cfg(windows)]
8630     {
8631         #[link(name = "windows")]
8632         extern "system" {
8633             fn WSAEnumProtocolsW(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32) -> i32;
8634         }
8635         ::std::mem::transmute(WSAEnumProtocolsW(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength)))
8636     }
8637     #[cfg(not(windows))]
8638     unimplemented!("Unsupported target OS");
8639 }
8640 #[cfg(feature = "Win32_Foundation")]
8641 #[inline]
WSAEventSelect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(s: Param0, heventobject: Param1, lnetworkevents: i32) -> i328642 pub unsafe fn WSAEventSelect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(s: Param0, heventobject: Param1, lnetworkevents: i32) -> i32 {
8643     #[cfg(windows)]
8644     {
8645         #[link(name = "windows")]
8646         extern "system" {
8647             fn WSAEventSelect(s: SOCKET, heventobject: super::super::Foundation::HANDLE, lnetworkevents: i32) -> i32;
8648         }
8649         ::std::mem::transmute(WSAEventSelect(s.into_param().abi(), heventobject.into_param().abi(), ::std::mem::transmute(lnetworkevents)))
8650     }
8651     #[cfg(not(windows))]
8652     unimplemented!("Unsupported target OS");
8653 }
8654 #[inline]
WSAGetLastError() -> WSA_ERROR8655 pub unsafe fn WSAGetLastError() -> WSA_ERROR {
8656     #[cfg(windows)]
8657     {
8658         #[link(name = "windows")]
8659         extern "system" {
8660             fn WSAGetLastError() -> WSA_ERROR;
8661         }
8662         ::std::mem::transmute(WSAGetLastError())
8663     }
8664     #[cfg(not(windows))]
8665     unimplemented!("Unsupported target OS");
8666 }
8667 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8668 #[inline]
WSAGetOverlappedResult<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(s: Param0, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcbtransfer: *mut u32, fwait: Param3, lpdwflags: *mut u32) -> super::super::Foundation::BOOL8669 pub unsafe fn WSAGetOverlappedResult<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(s: Param0, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcbtransfer: *mut u32, fwait: Param3, lpdwflags: *mut u32) -> super::super::Foundation::BOOL {
8670     #[cfg(windows)]
8671     {
8672         #[link(name = "windows")]
8673         extern "system" {
8674             fn WSAGetOverlappedResult(s: SOCKET, lpoverlapped: *const super::super::System::IO::OVERLAPPED, lpcbtransfer: *mut u32, fwait: super::super::Foundation::BOOL, lpdwflags: *mut u32) -> super::super::Foundation::BOOL;
8675         }
8676         ::std::mem::transmute(WSAGetOverlappedResult(s.into_param().abi(), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lpcbtransfer), fwait.into_param().abi(), ::std::mem::transmute(lpdwflags)))
8677     }
8678     #[cfg(not(windows))]
8679     unimplemented!("Unsupported target OS");
8680 }
8681 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
8682 #[inline]
WSAGetQOSByName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpqosname: *const WSABUF, lpqos: *mut super::super::NetworkManagement::QoS::QOS) -> super::super::Foundation::BOOL8683 pub unsafe fn WSAGetQOSByName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpqosname: *const WSABUF, lpqos: *mut super::super::NetworkManagement::QoS::QOS) -> super::super::Foundation::BOOL {
8684     #[cfg(windows)]
8685     {
8686         #[link(name = "windows")]
8687         extern "system" {
8688             fn WSAGetQOSByName(s: SOCKET, lpqosname: *const WSABUF, lpqos: *mut super::super::NetworkManagement::QoS::QOS) -> super::super::Foundation::BOOL;
8689         }
8690         ::std::mem::transmute(WSAGetQOSByName(s.into_param().abi(), ::std::mem::transmute(lpqosname), ::std::mem::transmute(lpqos)))
8691     }
8692     #[cfg(not(windows))]
8693     unimplemented!("Unsupported target OS");
8694 }
8695 #[cfg(feature = "Win32_Foundation")]
8696 #[inline]
WSAGetServiceClassInfoA(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOA) -> i328697 pub unsafe fn WSAGetServiceClassInfoA(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOA) -> i32 {
8698     #[cfg(windows)]
8699     {
8700         #[link(name = "windows")]
8701         extern "system" {
8702             fn WSAGetServiceClassInfoA(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOA) -> i32;
8703         }
8704         ::std::mem::transmute(WSAGetServiceClassInfoA(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpserviceclassid), ::std::mem::transmute(lpdwbufsize), ::std::mem::transmute(lpserviceclassinfo)))
8705     }
8706     #[cfg(not(windows))]
8707     unimplemented!("Unsupported target OS");
8708 }
8709 #[cfg(feature = "Win32_Foundation")]
8710 #[inline]
WSAGetServiceClassInfoW(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOW) -> i328711 pub unsafe fn WSAGetServiceClassInfoW(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOW) -> i32 {
8712     #[cfg(windows)]
8713     {
8714         #[link(name = "windows")]
8715         extern "system" {
8716             fn WSAGetServiceClassInfoW(lpproviderid: *const ::windows::runtime::GUID, lpserviceclassid: *const ::windows::runtime::GUID, lpdwbufsize: *mut u32, lpserviceclassinfo: *mut WSASERVICECLASSINFOW) -> i32;
8717         }
8718         ::std::mem::transmute(WSAGetServiceClassInfoW(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpserviceclassid), ::std::mem::transmute(lpdwbufsize), ::std::mem::transmute(lpserviceclassinfo)))
8719     }
8720     #[cfg(not(windows))]
8721     unimplemented!("Unsupported target OS");
8722 }
8723 #[cfg(feature = "Win32_Foundation")]
8724 #[inline]
WSAGetServiceClassNameByClassIdA(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PSTR, lpdwbufferlength: *mut u32) -> i328725 pub unsafe fn WSAGetServiceClassNameByClassIdA(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PSTR, lpdwbufferlength: *mut u32) -> i32 {
8726     #[cfg(windows)]
8727     {
8728         #[link(name = "windows")]
8729         extern "system" {
8730             fn WSAGetServiceClassNameByClassIdA(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PSTR, lpdwbufferlength: *mut u32) -> i32;
8731         }
8732         ::std::mem::transmute(WSAGetServiceClassNameByClassIdA(::std::mem::transmute(lpserviceclassid), ::std::mem::transmute(lpszserviceclassname), ::std::mem::transmute(lpdwbufferlength)))
8733     }
8734     #[cfg(not(windows))]
8735     unimplemented!("Unsupported target OS");
8736 }
8737 #[cfg(feature = "Win32_Foundation")]
8738 #[inline]
WSAGetServiceClassNameByClassIdW(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PWSTR, lpdwbufferlength: *mut u32) -> i328739 pub unsafe fn WSAGetServiceClassNameByClassIdW(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PWSTR, lpdwbufferlength: *mut u32) -> i32 {
8740     #[cfg(windows)]
8741     {
8742         #[link(name = "windows")]
8743         extern "system" {
8744             fn WSAGetServiceClassNameByClassIdW(lpserviceclassid: *const ::windows::runtime::GUID, lpszserviceclassname: super::super::Foundation::PWSTR, lpdwbufferlength: *mut u32) -> i32;
8745         }
8746         ::std::mem::transmute(WSAGetServiceClassNameByClassIdW(::std::mem::transmute(lpserviceclassid), ::std::mem::transmute(lpszserviceclassname), ::std::mem::transmute(lpdwbufferlength)))
8747     }
8748     #[cfg(not(windows))]
8749     unimplemented!("Unsupported target OS");
8750 }
8751 #[inline]
WSAHtonl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, hostlong: u32, lpnetlong: *mut u32) -> i328752 pub unsafe fn WSAHtonl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, hostlong: u32, lpnetlong: *mut u32) -> i32 {
8753     #[cfg(windows)]
8754     {
8755         #[link(name = "windows")]
8756         extern "system" {
8757             fn WSAHtonl(s: SOCKET, hostlong: u32, lpnetlong: *mut u32) -> i32;
8758         }
8759         ::std::mem::transmute(WSAHtonl(s.into_param().abi(), ::std::mem::transmute(hostlong), ::std::mem::transmute(lpnetlong)))
8760     }
8761     #[cfg(not(windows))]
8762     unimplemented!("Unsupported target OS");
8763 }
8764 #[inline]
WSAHtons<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, hostshort: u16, lpnetshort: *mut u16) -> i328765 pub unsafe fn WSAHtons<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, hostshort: u16, lpnetshort: *mut u16) -> i32 {
8766     #[cfg(windows)]
8767     {
8768         #[link(name = "windows")]
8769         extern "system" {
8770             fn WSAHtons(s: SOCKET, hostshort: u16, lpnetshort: *mut u16) -> i32;
8771         }
8772         ::std::mem::transmute(WSAHtons(s.into_param().abi(), ::std::mem::transmute(hostshort), ::std::mem::transmute(lpnetshort)))
8773     }
8774     #[cfg(not(windows))]
8775     unimplemented!("Unsupported target OS");
8776 }
8777 #[cfg(feature = "Win32_Foundation")]
8778 #[inline]
WSAImpersonateSocketPeer<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peeraddr: *const SOCKADDR, peeraddrlen: u32) -> i328779 pub unsafe fn WSAImpersonateSocketPeer<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peeraddr: *const SOCKADDR, peeraddrlen: u32) -> i32 {
8780     #[cfg(windows)]
8781     {
8782         #[link(name = "windows")]
8783         extern "system" {
8784             fn WSAImpersonateSocketPeer(socket: SOCKET, peeraddr: *const SOCKADDR, peeraddrlen: u32) -> i32;
8785         }
8786         ::std::mem::transmute(WSAImpersonateSocketPeer(socket.into_param().abi(), ::std::mem::transmute(peeraddr), ::std::mem::transmute(peeraddrlen)))
8787     }
8788     #[cfg(not(windows))]
8789     unimplemented!("Unsupported target OS");
8790 }
8791 #[cfg(feature = "Win32_Foundation")]
8792 #[inline]
WSAInstallServiceClassA(lpserviceclassinfo: *const WSASERVICECLASSINFOA) -> i328793 pub unsafe fn WSAInstallServiceClassA(lpserviceclassinfo: *const WSASERVICECLASSINFOA) -> i32 {
8794     #[cfg(windows)]
8795     {
8796         #[link(name = "windows")]
8797         extern "system" {
8798             fn WSAInstallServiceClassA(lpserviceclassinfo: *const WSASERVICECLASSINFOA) -> i32;
8799         }
8800         ::std::mem::transmute(WSAInstallServiceClassA(::std::mem::transmute(lpserviceclassinfo)))
8801     }
8802     #[cfg(not(windows))]
8803     unimplemented!("Unsupported target OS");
8804 }
8805 #[cfg(feature = "Win32_Foundation")]
8806 #[inline]
WSAInstallServiceClassW(lpserviceclassinfo: *const WSASERVICECLASSINFOW) -> i328807 pub unsafe fn WSAInstallServiceClassW(lpserviceclassinfo: *const WSASERVICECLASSINFOW) -> i32 {
8808     #[cfg(windows)]
8809     {
8810         #[link(name = "windows")]
8811         extern "system" {
8812             fn WSAInstallServiceClassW(lpserviceclassinfo: *const WSASERVICECLASSINFOW) -> i32;
8813         }
8814         ::std::mem::transmute(WSAInstallServiceClassW(::std::mem::transmute(lpserviceclassinfo)))
8815     }
8816     #[cfg(not(windows))]
8817     unimplemented!("Unsupported target OS");
8818 }
8819 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
8820 #[inline]
WSAIoctl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwiocontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i328821 pub unsafe fn WSAIoctl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, dwiocontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
8822     #[cfg(windows)]
8823     {
8824         #[link(name = "windows")]
8825         extern "system" {
8826             fn WSAIoctl(s: SOCKET, dwiocontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
8827         }
8828         ::std::mem::transmute(WSAIoctl(
8829             s.into_param().abi(),
8830             ::std::mem::transmute(dwiocontrolcode),
8831             ::std::mem::transmute(lpvinbuffer),
8832             ::std::mem::transmute(cbinbuffer),
8833             ::std::mem::transmute(lpvoutbuffer),
8834             ::std::mem::transmute(cboutbuffer),
8835             ::std::mem::transmute(lpcbbytesreturned),
8836             ::std::mem::transmute(lpoverlapped),
8837             ::std::mem::transmute(lpcompletionroutine),
8838         ))
8839     }
8840     #[cfg(not(windows))]
8841     unimplemented!("Unsupported target OS");
8842 }
8843 #[cfg(feature = "Win32_Foundation")]
8844 #[inline]
WSAIsBlocking() -> super::super::Foundation::BOOL8845 pub unsafe fn WSAIsBlocking() -> super::super::Foundation::BOOL {
8846     #[cfg(windows)]
8847     {
8848         #[link(name = "windows")]
8849         extern "system" {
8850             fn WSAIsBlocking() -> super::super::Foundation::BOOL;
8851         }
8852         ::std::mem::transmute(WSAIsBlocking())
8853     }
8854     #[cfg(not(windows))]
8855     unimplemented!("Unsupported target OS");
8856 }
8857 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS"))]
8858 #[inline]
WSAJoinLeaf<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS, dwflags: u32) -> SOCKET8859 pub unsafe fn WSAJoinLeaf<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS, dwflags: u32) -> SOCKET {
8860     #[cfg(windows)]
8861     {
8862         #[link(name = "windows")]
8863         extern "system" {
8864             fn WSAJoinLeaf(s: SOCKET, name: *const SOCKADDR, namelen: i32, lpcallerdata: *const WSABUF, lpcalleedata: *mut WSABUF, lpsqos: *const super::super::NetworkManagement::QoS::QOS, lpgqos: *const super::super::NetworkManagement::QoS::QOS, dwflags: u32) -> SOCKET;
8865         }
8866         ::std::mem::transmute(WSAJoinLeaf(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen), ::std::mem::transmute(lpcallerdata), ::std::mem::transmute(lpcalleedata), ::std::mem::transmute(lpsqos), ::std::mem::transmute(lpgqos), ::std::mem::transmute(dwflags)))
8867     }
8868     #[cfg(not(windows))]
8869     unimplemented!("Unsupported target OS");
8870 }
8871 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8872 #[inline]
WSALookupServiceBeginA(lpqsrestrictions: *const WSAQUERYSETA, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i328873 pub unsafe fn WSALookupServiceBeginA(lpqsrestrictions: *const WSAQUERYSETA, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i32 {
8874     #[cfg(windows)]
8875     {
8876         #[link(name = "windows")]
8877         extern "system" {
8878             fn WSALookupServiceBeginA(lpqsrestrictions: *const WSAQUERYSETA, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i32;
8879         }
8880         ::std::mem::transmute(WSALookupServiceBeginA(::std::mem::transmute(lpqsrestrictions), ::std::mem::transmute(dwcontrolflags), ::std::mem::transmute(lphlookup)))
8881     }
8882     #[cfg(not(windows))]
8883     unimplemented!("Unsupported target OS");
8884 }
8885 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8886 #[inline]
WSALookupServiceBeginW(lpqsrestrictions: *const WSAQUERYSETW, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i328887 pub unsafe fn WSALookupServiceBeginW(lpqsrestrictions: *const WSAQUERYSETW, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i32 {
8888     #[cfg(windows)]
8889     {
8890         #[link(name = "windows")]
8891         extern "system" {
8892             fn WSALookupServiceBeginW(lpqsrestrictions: *const WSAQUERYSETW, dwcontrolflags: u32, lphlookup: *mut super::super::Foundation::HANDLE) -> i32;
8893         }
8894         ::std::mem::transmute(WSALookupServiceBeginW(::std::mem::transmute(lpqsrestrictions), ::std::mem::transmute(dwcontrolflags), ::std::mem::transmute(lphlookup)))
8895     }
8896     #[cfg(not(windows))]
8897     unimplemented!("Unsupported target OS");
8898 }
8899 #[cfg(feature = "Win32_Foundation")]
8900 #[inline]
WSALookupServiceEnd<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0) -> i328901 pub unsafe fn WSALookupServiceEnd<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0) -> i32 {
8902     #[cfg(windows)]
8903     {
8904         #[link(name = "windows")]
8905         extern "system" {
8906             fn WSALookupServiceEnd(hlookup: super::super::Foundation::HANDLE) -> i32;
8907         }
8908         ::std::mem::transmute(WSALookupServiceEnd(hlookup.into_param().abi()))
8909     }
8910     #[cfg(not(windows))]
8911     unimplemented!("Unsupported target OS");
8912 }
8913 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8914 #[inline]
WSALookupServiceNextA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETA) -> i328915 pub unsafe fn WSALookupServiceNextA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETA) -> i32 {
8916     #[cfg(windows)]
8917     {
8918         #[link(name = "windows")]
8919         extern "system" {
8920             fn WSALookupServiceNextA(hlookup: super::super::Foundation::HANDLE, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETA) -> i32;
8921         }
8922         ::std::mem::transmute(WSALookupServiceNextA(hlookup.into_param().abi(), ::std::mem::transmute(dwcontrolflags), ::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpqsresults)))
8923     }
8924     #[cfg(not(windows))]
8925     unimplemented!("Unsupported target OS");
8926 }
8927 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
8928 #[inline]
WSALookupServiceNextW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETW) -> i328929 pub unsafe fn WSALookupServiceNextW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETW) -> i32 {
8930     #[cfg(windows)]
8931     {
8932         #[link(name = "windows")]
8933         extern "system" {
8934             fn WSALookupServiceNextW(hlookup: super::super::Foundation::HANDLE, dwcontrolflags: u32, lpdwbufferlength: *mut u32, lpqsresults: *mut WSAQUERYSETW) -> i32;
8935         }
8936         ::std::mem::transmute(WSALookupServiceNextW(hlookup.into_param().abi(), ::std::mem::transmute(dwcontrolflags), ::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpqsresults)))
8937     }
8938     #[cfg(not(windows))]
8939     unimplemented!("Unsupported target OS");
8940 }
8941 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8942 #[repr(C)]
8943 #[cfg(feature = "Win32_Foundation")]
8944 pub struct WSAMSG {
8945     pub name: *mut SOCKADDR,
8946     pub namelen: i32,
8947     pub lpBuffers: *mut WSABUF,
8948     pub dwBufferCount: u32,
8949     pub Control: WSABUF,
8950     pub dwFlags: u32,
8951 }
8952 #[cfg(feature = "Win32_Foundation")]
8953 impl WSAMSG {}
8954 #[cfg(feature = "Win32_Foundation")]
8955 impl ::std::default::Default for WSAMSG {
default() -> Self8956     fn default() -> Self {
8957         unsafe { ::std::mem::zeroed() }
8958     }
8959 }
8960 #[cfg(feature = "Win32_Foundation")]
8961 impl ::std::fmt::Debug for WSAMSG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8962     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8963         fmt.debug_struct("WSAMSG").field("name", &self.name).field("namelen", &self.namelen).field("lpBuffers", &self.lpBuffers).field("dwBufferCount", &self.dwBufferCount).field("Control", &self.Control).field("dwFlags", &self.dwFlags).finish()
8964     }
8965 }
8966 #[cfg(feature = "Win32_Foundation")]
8967 impl ::std::cmp::PartialEq for WSAMSG {
eq(&self, other: &Self) -> bool8968     fn eq(&self, other: &Self) -> bool {
8969         self.name == other.name && self.namelen == other.namelen && self.lpBuffers == other.lpBuffers && self.dwBufferCount == other.dwBufferCount && self.Control == other.Control && self.dwFlags == other.dwFlags
8970     }
8971 }
8972 #[cfg(feature = "Win32_Foundation")]
8973 impl ::std::cmp::Eq for WSAMSG {}
8974 #[cfg(feature = "Win32_Foundation")]
8975 unsafe impl ::windows::runtime::Abi for WSAMSG {
8976     type Abi = Self;
8977     type DefaultType = Self;
8978 }
8979 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8980 #[repr(C)]
8981 #[cfg(feature = "Win32_Foundation")]
8982 pub struct WSANAMESPACE_INFOA {
8983     pub NSProviderId: ::windows::runtime::GUID,
8984     pub dwNameSpace: u32,
8985     pub fActive: super::super::Foundation::BOOL,
8986     pub dwVersion: u32,
8987     pub lpszIdentifier: super::super::Foundation::PSTR,
8988 }
8989 #[cfg(feature = "Win32_Foundation")]
8990 impl WSANAMESPACE_INFOA {}
8991 #[cfg(feature = "Win32_Foundation")]
8992 impl ::std::default::Default for WSANAMESPACE_INFOA {
default() -> Self8993     fn default() -> Self {
8994         unsafe { ::std::mem::zeroed() }
8995     }
8996 }
8997 #[cfg(feature = "Win32_Foundation")]
8998 impl ::std::fmt::Debug for WSANAMESPACE_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8999     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9000         fmt.debug_struct("WSANAMESPACE_INFOA").field("NSProviderId", &self.NSProviderId).field("dwNameSpace", &self.dwNameSpace).field("fActive", &self.fActive).field("dwVersion", &self.dwVersion).field("lpszIdentifier", &self.lpszIdentifier).finish()
9001     }
9002 }
9003 #[cfg(feature = "Win32_Foundation")]
9004 impl ::std::cmp::PartialEq for WSANAMESPACE_INFOA {
eq(&self, other: &Self) -> bool9005     fn eq(&self, other: &Self) -> bool {
9006         self.NSProviderId == other.NSProviderId && self.dwNameSpace == other.dwNameSpace && self.fActive == other.fActive && self.dwVersion == other.dwVersion && self.lpszIdentifier == other.lpszIdentifier
9007     }
9008 }
9009 #[cfg(feature = "Win32_Foundation")]
9010 impl ::std::cmp::Eq for WSANAMESPACE_INFOA {}
9011 #[cfg(feature = "Win32_Foundation")]
9012 unsafe impl ::windows::runtime::Abi for WSANAMESPACE_INFOA {
9013     type Abi = Self;
9014     type DefaultType = Self;
9015 }
9016 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9017 #[repr(C)]
9018 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9019 pub struct WSANAMESPACE_INFOEXA {
9020     pub NSProviderId: ::windows::runtime::GUID,
9021     pub dwNameSpace: u32,
9022     pub fActive: super::super::Foundation::BOOL,
9023     pub dwVersion: u32,
9024     pub lpszIdentifier: super::super::Foundation::PSTR,
9025     pub ProviderSpecific: super::super::System::Com::BLOB,
9026 }
9027 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9028 impl WSANAMESPACE_INFOEXA {}
9029 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9030 impl ::std::default::Default for WSANAMESPACE_INFOEXA {
default() -> Self9031     fn default() -> Self {
9032         unsafe { ::std::mem::zeroed() }
9033     }
9034 }
9035 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9036 impl ::std::fmt::Debug for WSANAMESPACE_INFOEXA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9037     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9038         fmt.debug_struct("WSANAMESPACE_INFOEXA").field("NSProviderId", &self.NSProviderId).field("dwNameSpace", &self.dwNameSpace).field("fActive", &self.fActive).field("dwVersion", &self.dwVersion).field("lpszIdentifier", &self.lpszIdentifier).field("ProviderSpecific", &self.ProviderSpecific).finish()
9039     }
9040 }
9041 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9042 impl ::std::cmp::PartialEq for WSANAMESPACE_INFOEXA {
eq(&self, other: &Self) -> bool9043     fn eq(&self, other: &Self) -> bool {
9044         self.NSProviderId == other.NSProviderId && self.dwNameSpace == other.dwNameSpace && self.fActive == other.fActive && self.dwVersion == other.dwVersion && self.lpszIdentifier == other.lpszIdentifier && self.ProviderSpecific == other.ProviderSpecific
9045     }
9046 }
9047 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9048 impl ::std::cmp::Eq for WSANAMESPACE_INFOEXA {}
9049 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9050 unsafe impl ::windows::runtime::Abi for WSANAMESPACE_INFOEXA {
9051     type Abi = Self;
9052     type DefaultType = Self;
9053 }
9054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9055 #[repr(C)]
9056 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9057 pub struct WSANAMESPACE_INFOEXW {
9058     pub NSProviderId: ::windows::runtime::GUID,
9059     pub dwNameSpace: u32,
9060     pub fActive: super::super::Foundation::BOOL,
9061     pub dwVersion: u32,
9062     pub lpszIdentifier: super::super::Foundation::PWSTR,
9063     pub ProviderSpecific: super::super::System::Com::BLOB,
9064 }
9065 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9066 impl WSANAMESPACE_INFOEXW {}
9067 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9068 impl ::std::default::Default for WSANAMESPACE_INFOEXW {
default() -> Self9069     fn default() -> Self {
9070         unsafe { ::std::mem::zeroed() }
9071     }
9072 }
9073 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9074 impl ::std::fmt::Debug for WSANAMESPACE_INFOEXW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9075     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9076         fmt.debug_struct("WSANAMESPACE_INFOEXW").field("NSProviderId", &self.NSProviderId).field("dwNameSpace", &self.dwNameSpace).field("fActive", &self.fActive).field("dwVersion", &self.dwVersion).field("lpszIdentifier", &self.lpszIdentifier).field("ProviderSpecific", &self.ProviderSpecific).finish()
9077     }
9078 }
9079 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9080 impl ::std::cmp::PartialEq for WSANAMESPACE_INFOEXW {
eq(&self, other: &Self) -> bool9081     fn eq(&self, other: &Self) -> bool {
9082         self.NSProviderId == other.NSProviderId && self.dwNameSpace == other.dwNameSpace && self.fActive == other.fActive && self.dwVersion == other.dwVersion && self.lpszIdentifier == other.lpszIdentifier && self.ProviderSpecific == other.ProviderSpecific
9083     }
9084 }
9085 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9086 impl ::std::cmp::Eq for WSANAMESPACE_INFOEXW {}
9087 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9088 unsafe impl ::windows::runtime::Abi for WSANAMESPACE_INFOEXW {
9089     type Abi = Self;
9090     type DefaultType = Self;
9091 }
9092 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9093 #[repr(C)]
9094 #[cfg(feature = "Win32_Foundation")]
9095 pub struct WSANAMESPACE_INFOW {
9096     pub NSProviderId: ::windows::runtime::GUID,
9097     pub dwNameSpace: u32,
9098     pub fActive: super::super::Foundation::BOOL,
9099     pub dwVersion: u32,
9100     pub lpszIdentifier: super::super::Foundation::PWSTR,
9101 }
9102 #[cfg(feature = "Win32_Foundation")]
9103 impl WSANAMESPACE_INFOW {}
9104 #[cfg(feature = "Win32_Foundation")]
9105 impl ::std::default::Default for WSANAMESPACE_INFOW {
default() -> Self9106     fn default() -> Self {
9107         unsafe { ::std::mem::zeroed() }
9108     }
9109 }
9110 #[cfg(feature = "Win32_Foundation")]
9111 impl ::std::fmt::Debug for WSANAMESPACE_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9112     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9113         fmt.debug_struct("WSANAMESPACE_INFOW").field("NSProviderId", &self.NSProviderId).field("dwNameSpace", &self.dwNameSpace).field("fActive", &self.fActive).field("dwVersion", &self.dwVersion).field("lpszIdentifier", &self.lpszIdentifier).finish()
9114     }
9115 }
9116 #[cfg(feature = "Win32_Foundation")]
9117 impl ::std::cmp::PartialEq for WSANAMESPACE_INFOW {
eq(&self, other: &Self) -> bool9118     fn eq(&self, other: &Self) -> bool {
9119         self.NSProviderId == other.NSProviderId && self.dwNameSpace == other.dwNameSpace && self.fActive == other.fActive && self.dwVersion == other.dwVersion && self.lpszIdentifier == other.lpszIdentifier
9120     }
9121 }
9122 #[cfg(feature = "Win32_Foundation")]
9123 impl ::std::cmp::Eq for WSANAMESPACE_INFOW {}
9124 #[cfg(feature = "Win32_Foundation")]
9125 unsafe impl ::windows::runtime::Abi for WSANAMESPACE_INFOW {
9126     type Abi = Self;
9127     type DefaultType = Self;
9128 }
9129 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9130 #[repr(C)]
9131 pub struct WSANETWORKEVENTS {
9132     pub lNetworkEvents: i32,
9133     pub iErrorCode: [i32; 10],
9134 }
9135 impl WSANETWORKEVENTS {}
9136 impl ::std::default::Default for WSANETWORKEVENTS {
default() -> Self9137     fn default() -> Self {
9138         unsafe { ::std::mem::zeroed() }
9139     }
9140 }
9141 impl ::std::fmt::Debug for WSANETWORKEVENTS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9142     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9143         fmt.debug_struct("WSANETWORKEVENTS").field("lNetworkEvents", &self.lNetworkEvents).field("iErrorCode", &self.iErrorCode).finish()
9144     }
9145 }
9146 impl ::std::cmp::PartialEq for WSANETWORKEVENTS {
eq(&self, other: &Self) -> bool9147     fn eq(&self, other: &Self) -> bool {
9148         self.lNetworkEvents == other.lNetworkEvents && self.iErrorCode == other.iErrorCode
9149     }
9150 }
9151 impl ::std::cmp::Eq for WSANETWORKEVENTS {}
9152 unsafe impl ::windows::runtime::Abi for WSANETWORKEVENTS {
9153     type Abi = Self;
9154     type DefaultType = Self;
9155 }
9156 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9157 #[repr(C)]
9158 #[cfg(feature = "Win32_Foundation")]
9159 pub struct WSANSCLASSINFOA {
9160     pub lpszName: super::super::Foundation::PSTR,
9161     pub dwNameSpace: u32,
9162     pub dwValueType: u32,
9163     pub dwValueSize: u32,
9164     pub lpValue: *mut ::std::ffi::c_void,
9165 }
9166 #[cfg(feature = "Win32_Foundation")]
9167 impl WSANSCLASSINFOA {}
9168 #[cfg(feature = "Win32_Foundation")]
9169 impl ::std::default::Default for WSANSCLASSINFOA {
default() -> Self9170     fn default() -> Self {
9171         unsafe { ::std::mem::zeroed() }
9172     }
9173 }
9174 #[cfg(feature = "Win32_Foundation")]
9175 impl ::std::fmt::Debug for WSANSCLASSINFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9176     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9177         fmt.debug_struct("WSANSCLASSINFOA").field("lpszName", &self.lpszName).field("dwNameSpace", &self.dwNameSpace).field("dwValueType", &self.dwValueType).field("dwValueSize", &self.dwValueSize).field("lpValue", &self.lpValue).finish()
9178     }
9179 }
9180 #[cfg(feature = "Win32_Foundation")]
9181 impl ::std::cmp::PartialEq for WSANSCLASSINFOA {
eq(&self, other: &Self) -> bool9182     fn eq(&self, other: &Self) -> bool {
9183         self.lpszName == other.lpszName && self.dwNameSpace == other.dwNameSpace && self.dwValueType == other.dwValueType && self.dwValueSize == other.dwValueSize && self.lpValue == other.lpValue
9184     }
9185 }
9186 #[cfg(feature = "Win32_Foundation")]
9187 impl ::std::cmp::Eq for WSANSCLASSINFOA {}
9188 #[cfg(feature = "Win32_Foundation")]
9189 unsafe impl ::windows::runtime::Abi for WSANSCLASSINFOA {
9190     type Abi = Self;
9191     type DefaultType = Self;
9192 }
9193 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9194 #[repr(C)]
9195 #[cfg(feature = "Win32_Foundation")]
9196 pub struct WSANSCLASSINFOW {
9197     pub lpszName: super::super::Foundation::PWSTR,
9198     pub dwNameSpace: u32,
9199     pub dwValueType: u32,
9200     pub dwValueSize: u32,
9201     pub lpValue: *mut ::std::ffi::c_void,
9202 }
9203 #[cfg(feature = "Win32_Foundation")]
9204 impl WSANSCLASSINFOW {}
9205 #[cfg(feature = "Win32_Foundation")]
9206 impl ::std::default::Default for WSANSCLASSINFOW {
default() -> Self9207     fn default() -> Self {
9208         unsafe { ::std::mem::zeroed() }
9209     }
9210 }
9211 #[cfg(feature = "Win32_Foundation")]
9212 impl ::std::fmt::Debug for WSANSCLASSINFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9213     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9214         fmt.debug_struct("WSANSCLASSINFOW").field("lpszName", &self.lpszName).field("dwNameSpace", &self.dwNameSpace).field("dwValueType", &self.dwValueType).field("dwValueSize", &self.dwValueSize).field("lpValue", &self.lpValue).finish()
9215     }
9216 }
9217 #[cfg(feature = "Win32_Foundation")]
9218 impl ::std::cmp::PartialEq for WSANSCLASSINFOW {
eq(&self, other: &Self) -> bool9219     fn eq(&self, other: &Self) -> bool {
9220         self.lpszName == other.lpszName && self.dwNameSpace == other.dwNameSpace && self.dwValueType == other.dwValueType && self.dwValueSize == other.dwValueSize && self.lpValue == other.lpValue
9221     }
9222 }
9223 #[cfg(feature = "Win32_Foundation")]
9224 impl ::std::cmp::Eq for WSANSCLASSINFOW {}
9225 #[cfg(feature = "Win32_Foundation")]
9226 unsafe impl ::windows::runtime::Abi for WSANSCLASSINFOW {
9227     type Abi = Self;
9228     type DefaultType = Self;
9229 }
9230 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
9231 #[inline]
WSANSPIoctl<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpcompletion: *const WSACOMPLETION) -> i329232 pub unsafe fn WSANSPIoctl<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hlookup: Param0, dwcontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpcompletion: *const WSACOMPLETION) -> i32 {
9233     #[cfg(windows)]
9234     {
9235         #[link(name = "windows")]
9236         extern "system" {
9237             fn WSANSPIoctl(hlookup: super::super::Foundation::HANDLE, dwcontrolcode: u32, lpvinbuffer: *const ::std::ffi::c_void, cbinbuffer: u32, lpvoutbuffer: *mut ::std::ffi::c_void, cboutbuffer: u32, lpcbbytesreturned: *mut u32, lpcompletion: *const ::std::mem::ManuallyDrop<WSACOMPLETION>) -> i32;
9238         }
9239         ::std::mem::transmute(WSANSPIoctl(hlookup.into_param().abi(), ::std::mem::transmute(dwcontrolcode), ::std::mem::transmute(lpvinbuffer), ::std::mem::transmute(cbinbuffer), ::std::mem::transmute(lpvoutbuffer), ::std::mem::transmute(cboutbuffer), ::std::mem::transmute(lpcbbytesreturned), ::std::mem::transmute(lpcompletion)))
9240     }
9241     #[cfg(not(windows))]
9242     unimplemented!("Unsupported target OS");
9243 }
9244 #[inline]
WSANtohl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, netlong: u32, lphostlong: *mut u32) -> i329245 pub unsafe fn WSANtohl<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, netlong: u32, lphostlong: *mut u32) -> i32 {
9246     #[cfg(windows)]
9247     {
9248         #[link(name = "windows")]
9249         extern "system" {
9250             fn WSANtohl(s: SOCKET, netlong: u32, lphostlong: *mut u32) -> i32;
9251         }
9252         ::std::mem::transmute(WSANtohl(s.into_param().abi(), ::std::mem::transmute(netlong), ::std::mem::transmute(lphostlong)))
9253     }
9254     #[cfg(not(windows))]
9255     unimplemented!("Unsupported target OS");
9256 }
9257 #[inline]
WSANtohs<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, netshort: u16, lphostshort: *mut u16) -> i329258 pub unsafe fn WSANtohs<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, netshort: u16, lphostshort: *mut u16) -> i32 {
9259     #[cfg(windows)]
9260     {
9261         #[link(name = "windows")]
9262         extern "system" {
9263             fn WSANtohs(s: SOCKET, netshort: u16, lphostshort: *mut u16) -> i32;
9264         }
9265         ::std::mem::transmute(WSANtohs(s.into_param().abi(), ::std::mem::transmute(netshort), ::std::mem::transmute(lphostshort)))
9266     }
9267     #[cfg(not(windows))]
9268     unimplemented!("Unsupported target OS");
9269 }
9270 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9271 #[repr(C)]
9272 pub struct WSAPOLLDATA {
9273     pub result: i32,
9274     pub fds: u32,
9275     pub timeout: i32,
9276     pub fdArray: [WSAPOLLFD; 1],
9277 }
9278 impl WSAPOLLDATA {}
9279 impl ::std::default::Default for WSAPOLLDATA {
default() -> Self9280     fn default() -> Self {
9281         unsafe { ::std::mem::zeroed() }
9282     }
9283 }
9284 impl ::std::fmt::Debug for WSAPOLLDATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9285     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9286         fmt.debug_struct("WSAPOLLDATA").field("result", &self.result).field("fds", &self.fds).field("timeout", &self.timeout).field("fdArray", &self.fdArray).finish()
9287     }
9288 }
9289 impl ::std::cmp::PartialEq for WSAPOLLDATA {
eq(&self, other: &Self) -> bool9290     fn eq(&self, other: &Self) -> bool {
9291         self.result == other.result && self.fds == other.fds && self.timeout == other.timeout && self.fdArray == other.fdArray
9292     }
9293 }
9294 impl ::std::cmp::Eq for WSAPOLLDATA {}
9295 unsafe impl ::windows::runtime::Abi for WSAPOLLDATA {
9296     type Abi = Self;
9297     type DefaultType = Self;
9298 }
9299 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9300 #[repr(C)]
9301 pub struct WSAPOLLFD {
9302     pub fd: SOCKET,
9303     pub events: i16,
9304     pub revents: i16,
9305 }
9306 impl WSAPOLLFD {}
9307 impl ::std::default::Default for WSAPOLLFD {
default() -> Self9308     fn default() -> Self {
9309         unsafe { ::std::mem::zeroed() }
9310     }
9311 }
9312 impl ::std::fmt::Debug for WSAPOLLFD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9313     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9314         fmt.debug_struct("WSAPOLLFD").field("fd", &self.fd).field("events", &self.events).field("revents", &self.revents).finish()
9315     }
9316 }
9317 impl ::std::cmp::PartialEq for WSAPOLLFD {
eq(&self, other: &Self) -> bool9318     fn eq(&self, other: &Self) -> bool {
9319         self.fd == other.fd && self.events == other.events && self.revents == other.revents
9320     }
9321 }
9322 impl ::std::cmp::Eq for WSAPOLLFD {}
9323 unsafe impl ::windows::runtime::Abi for WSAPOLLFD {
9324     type Abi = Self;
9325     type DefaultType = Self;
9326 }
9327 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9328 #[repr(C)]
9329 pub struct WSAPROTOCOLCHAIN {
9330     pub ChainLen: i32,
9331     pub ChainEntries: [u32; 7],
9332 }
9333 impl WSAPROTOCOLCHAIN {}
9334 impl ::std::default::Default for WSAPROTOCOLCHAIN {
default() -> Self9335     fn default() -> Self {
9336         unsafe { ::std::mem::zeroed() }
9337     }
9338 }
9339 impl ::std::fmt::Debug for WSAPROTOCOLCHAIN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9340     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9341         fmt.debug_struct("WSAPROTOCOLCHAIN").field("ChainLen", &self.ChainLen).field("ChainEntries", &self.ChainEntries).finish()
9342     }
9343 }
9344 impl ::std::cmp::PartialEq for WSAPROTOCOLCHAIN {
eq(&self, other: &Self) -> bool9345     fn eq(&self, other: &Self) -> bool {
9346         self.ChainLen == other.ChainLen && self.ChainEntries == other.ChainEntries
9347     }
9348 }
9349 impl ::std::cmp::Eq for WSAPROTOCOLCHAIN {}
9350 unsafe impl ::windows::runtime::Abi for WSAPROTOCOLCHAIN {
9351     type Abi = Self;
9352     type DefaultType = Self;
9353 }
9354 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9355 #[repr(C)]
9356 #[cfg(feature = "Win32_Foundation")]
9357 pub struct WSAPROTOCOL_INFOA {
9358     pub dwServiceFlags1: u32,
9359     pub dwServiceFlags2: u32,
9360     pub dwServiceFlags3: u32,
9361     pub dwServiceFlags4: u32,
9362     pub dwProviderFlags: u32,
9363     pub ProviderId: ::windows::runtime::GUID,
9364     pub dwCatalogEntryId: u32,
9365     pub ProtocolChain: WSAPROTOCOLCHAIN,
9366     pub iVersion: i32,
9367     pub iAddressFamily: i32,
9368     pub iMaxSockAddr: i32,
9369     pub iMinSockAddr: i32,
9370     pub iSocketType: i32,
9371     pub iProtocol: i32,
9372     pub iProtocolMaxOffset: i32,
9373     pub iNetworkByteOrder: i32,
9374     pub iSecurityScheme: i32,
9375     pub dwMessageSize: u32,
9376     pub dwProviderReserved: u32,
9377     pub szProtocol: [super::super::Foundation::CHAR; 256],
9378 }
9379 #[cfg(feature = "Win32_Foundation")]
9380 impl WSAPROTOCOL_INFOA {}
9381 #[cfg(feature = "Win32_Foundation")]
9382 impl ::std::default::Default for WSAPROTOCOL_INFOA {
default() -> Self9383     fn default() -> Self {
9384         unsafe { ::std::mem::zeroed() }
9385     }
9386 }
9387 #[cfg(feature = "Win32_Foundation")]
9388 impl ::std::fmt::Debug for WSAPROTOCOL_INFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9389     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9390         fmt.debug_struct("WSAPROTOCOL_INFOA")
9391             .field("dwServiceFlags1", &self.dwServiceFlags1)
9392             .field("dwServiceFlags2", &self.dwServiceFlags2)
9393             .field("dwServiceFlags3", &self.dwServiceFlags3)
9394             .field("dwServiceFlags4", &self.dwServiceFlags4)
9395             .field("dwProviderFlags", &self.dwProviderFlags)
9396             .field("ProviderId", &self.ProviderId)
9397             .field("dwCatalogEntryId", &self.dwCatalogEntryId)
9398             .field("ProtocolChain", &self.ProtocolChain)
9399             .field("iVersion", &self.iVersion)
9400             .field("iAddressFamily", &self.iAddressFamily)
9401             .field("iMaxSockAddr", &self.iMaxSockAddr)
9402             .field("iMinSockAddr", &self.iMinSockAddr)
9403             .field("iSocketType", &self.iSocketType)
9404             .field("iProtocol", &self.iProtocol)
9405             .field("iProtocolMaxOffset", &self.iProtocolMaxOffset)
9406             .field("iNetworkByteOrder", &self.iNetworkByteOrder)
9407             .field("iSecurityScheme", &self.iSecurityScheme)
9408             .field("dwMessageSize", &self.dwMessageSize)
9409             .field("dwProviderReserved", &self.dwProviderReserved)
9410             .field("szProtocol", &self.szProtocol)
9411             .finish()
9412     }
9413 }
9414 #[cfg(feature = "Win32_Foundation")]
9415 impl ::std::cmp::PartialEq for WSAPROTOCOL_INFOA {
eq(&self, other: &Self) -> bool9416     fn eq(&self, other: &Self) -> bool {
9417         self.dwServiceFlags1 == other.dwServiceFlags1
9418             && self.dwServiceFlags2 == other.dwServiceFlags2
9419             && self.dwServiceFlags3 == other.dwServiceFlags3
9420             && self.dwServiceFlags4 == other.dwServiceFlags4
9421             && self.dwProviderFlags == other.dwProviderFlags
9422             && self.ProviderId == other.ProviderId
9423             && self.dwCatalogEntryId == other.dwCatalogEntryId
9424             && self.ProtocolChain == other.ProtocolChain
9425             && self.iVersion == other.iVersion
9426             && self.iAddressFamily == other.iAddressFamily
9427             && self.iMaxSockAddr == other.iMaxSockAddr
9428             && self.iMinSockAddr == other.iMinSockAddr
9429             && self.iSocketType == other.iSocketType
9430             && self.iProtocol == other.iProtocol
9431             && self.iProtocolMaxOffset == other.iProtocolMaxOffset
9432             && self.iNetworkByteOrder == other.iNetworkByteOrder
9433             && self.iSecurityScheme == other.iSecurityScheme
9434             && self.dwMessageSize == other.dwMessageSize
9435             && self.dwProviderReserved == other.dwProviderReserved
9436             && self.szProtocol == other.szProtocol
9437     }
9438 }
9439 #[cfg(feature = "Win32_Foundation")]
9440 impl ::std::cmp::Eq for WSAPROTOCOL_INFOA {}
9441 #[cfg(feature = "Win32_Foundation")]
9442 unsafe impl ::windows::runtime::Abi for WSAPROTOCOL_INFOA {
9443     type Abi = Self;
9444     type DefaultType = Self;
9445 }
9446 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9447 #[repr(C)]
9448 pub struct WSAPROTOCOL_INFOW {
9449     pub dwServiceFlags1: u32,
9450     pub dwServiceFlags2: u32,
9451     pub dwServiceFlags3: u32,
9452     pub dwServiceFlags4: u32,
9453     pub dwProviderFlags: u32,
9454     pub ProviderId: ::windows::runtime::GUID,
9455     pub dwCatalogEntryId: u32,
9456     pub ProtocolChain: WSAPROTOCOLCHAIN,
9457     pub iVersion: i32,
9458     pub iAddressFamily: i32,
9459     pub iMaxSockAddr: i32,
9460     pub iMinSockAddr: i32,
9461     pub iSocketType: i32,
9462     pub iProtocol: i32,
9463     pub iProtocolMaxOffset: i32,
9464     pub iNetworkByteOrder: i32,
9465     pub iSecurityScheme: i32,
9466     pub dwMessageSize: u32,
9467     pub dwProviderReserved: u32,
9468     pub szProtocol: [u16; 256],
9469 }
9470 impl WSAPROTOCOL_INFOW {}
9471 impl ::std::default::Default for WSAPROTOCOL_INFOW {
default() -> Self9472     fn default() -> Self {
9473         unsafe { ::std::mem::zeroed() }
9474     }
9475 }
9476 impl ::std::fmt::Debug for WSAPROTOCOL_INFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9477     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9478         fmt.debug_struct("WSAPROTOCOL_INFOW")
9479             .field("dwServiceFlags1", &self.dwServiceFlags1)
9480             .field("dwServiceFlags2", &self.dwServiceFlags2)
9481             .field("dwServiceFlags3", &self.dwServiceFlags3)
9482             .field("dwServiceFlags4", &self.dwServiceFlags4)
9483             .field("dwProviderFlags", &self.dwProviderFlags)
9484             .field("ProviderId", &self.ProviderId)
9485             .field("dwCatalogEntryId", &self.dwCatalogEntryId)
9486             .field("ProtocolChain", &self.ProtocolChain)
9487             .field("iVersion", &self.iVersion)
9488             .field("iAddressFamily", &self.iAddressFamily)
9489             .field("iMaxSockAddr", &self.iMaxSockAddr)
9490             .field("iMinSockAddr", &self.iMinSockAddr)
9491             .field("iSocketType", &self.iSocketType)
9492             .field("iProtocol", &self.iProtocol)
9493             .field("iProtocolMaxOffset", &self.iProtocolMaxOffset)
9494             .field("iNetworkByteOrder", &self.iNetworkByteOrder)
9495             .field("iSecurityScheme", &self.iSecurityScheme)
9496             .field("dwMessageSize", &self.dwMessageSize)
9497             .field("dwProviderReserved", &self.dwProviderReserved)
9498             .field("szProtocol", &self.szProtocol)
9499             .finish()
9500     }
9501 }
9502 impl ::std::cmp::PartialEq for WSAPROTOCOL_INFOW {
eq(&self, other: &Self) -> bool9503     fn eq(&self, other: &Self) -> bool {
9504         self.dwServiceFlags1 == other.dwServiceFlags1
9505             && self.dwServiceFlags2 == other.dwServiceFlags2
9506             && self.dwServiceFlags3 == other.dwServiceFlags3
9507             && self.dwServiceFlags4 == other.dwServiceFlags4
9508             && self.dwProviderFlags == other.dwProviderFlags
9509             && self.ProviderId == other.ProviderId
9510             && self.dwCatalogEntryId == other.dwCatalogEntryId
9511             && self.ProtocolChain == other.ProtocolChain
9512             && self.iVersion == other.iVersion
9513             && self.iAddressFamily == other.iAddressFamily
9514             && self.iMaxSockAddr == other.iMaxSockAddr
9515             && self.iMinSockAddr == other.iMinSockAddr
9516             && self.iSocketType == other.iSocketType
9517             && self.iProtocol == other.iProtocol
9518             && self.iProtocolMaxOffset == other.iProtocolMaxOffset
9519             && self.iNetworkByteOrder == other.iNetworkByteOrder
9520             && self.iSecurityScheme == other.iSecurityScheme
9521             && self.dwMessageSize == other.dwMessageSize
9522             && self.dwProviderReserved == other.dwProviderReserved
9523             && self.szProtocol == other.szProtocol
9524     }
9525 }
9526 impl ::std::cmp::Eq for WSAPROTOCOL_INFOW {}
9527 unsafe impl ::windows::runtime::Abi for WSAPROTOCOL_INFOW {
9528     type Abi = Self;
9529     type DefaultType = Self;
9530 }
9531 pub const WSAPROTOCOL_LEN: u32 = 255u32;
9532 #[inline]
WSAPoll(fdarray: *mut WSAPOLLFD, fds: u32, timeout: i32) -> i329533 pub unsafe fn WSAPoll(fdarray: *mut WSAPOLLFD, fds: u32, timeout: i32) -> i32 {
9534     #[cfg(windows)]
9535     {
9536         #[link(name = "windows")]
9537         extern "system" {
9538             fn WSAPoll(fdarray: *mut WSAPOLLFD, fds: u32, timeout: i32) -> i32;
9539         }
9540         ::std::mem::transmute(WSAPoll(::std::mem::transmute(fdarray), ::std::mem::transmute(fds), ::std::mem::transmute(timeout)))
9541     }
9542     #[cfg(not(windows))]
9543     unimplemented!("Unsupported target OS");
9544 }
9545 #[cfg(feature = "Win32_Foundation")]
9546 #[inline]
WSAProviderCompleteAsyncCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hasynccall: Param0, iretcode: i32) -> i329547 pub unsafe fn WSAProviderCompleteAsyncCall<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hasynccall: Param0, iretcode: i32) -> i32 {
9548     #[cfg(windows)]
9549     {
9550         #[link(name = "windows")]
9551         extern "system" {
9552             fn WSAProviderCompleteAsyncCall(hasynccall: super::super::Foundation::HANDLE, iretcode: i32) -> i32;
9553         }
9554         ::std::mem::transmute(WSAProviderCompleteAsyncCall(hasynccall.into_param().abi(), ::std::mem::transmute(iretcode)))
9555     }
9556     #[cfg(not(windows))]
9557     unimplemented!("Unsupported target OS");
9558 }
9559 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
9560 #[inline]
WSAProviderConfigChange(lpnotificationhandle: *mut super::super::Foundation::HANDLE, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i329561 pub unsafe fn WSAProviderConfigChange(lpnotificationhandle: *mut super::super::Foundation::HANDLE, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
9562     #[cfg(windows)]
9563     {
9564         #[link(name = "windows")]
9565         extern "system" {
9566             fn WSAProviderConfigChange(lpnotificationhandle: *mut super::super::Foundation::HANDLE, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
9567         }
9568         ::std::mem::transmute(WSAProviderConfigChange(::std::mem::transmute(lpnotificationhandle), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lpcompletionroutine)))
9569     }
9570     #[cfg(not(windows))]
9571     unimplemented!("Unsupported target OS");
9572 }
9573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9574 #[repr(C)]
9575 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9576 pub struct WSAQUERYSET2A {
9577     pub dwSize: u32,
9578     pub lpszServiceInstanceName: super::super::Foundation::PSTR,
9579     pub lpVersion: *mut WSAVERSION,
9580     pub lpszComment: super::super::Foundation::PSTR,
9581     pub dwNameSpace: u32,
9582     pub lpNSProviderId: *mut ::windows::runtime::GUID,
9583     pub lpszContext: super::super::Foundation::PSTR,
9584     pub dwNumberOfProtocols: u32,
9585     pub lpafpProtocols: *mut AFPROTOCOLS,
9586     pub lpszQueryString: super::super::Foundation::PSTR,
9587     pub dwNumberOfCsAddrs: u32,
9588     pub lpcsaBuffer: *mut CSADDR_INFO,
9589     pub dwOutputFlags: u32,
9590     pub lpBlob: *mut super::super::System::Com::BLOB,
9591 }
9592 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9593 impl WSAQUERYSET2A {}
9594 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9595 impl ::std::default::Default for WSAQUERYSET2A {
default() -> Self9596     fn default() -> Self {
9597         unsafe { ::std::mem::zeroed() }
9598     }
9599 }
9600 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9601 impl ::std::fmt::Debug for WSAQUERYSET2A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9602     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9603         fmt.debug_struct("WSAQUERYSET2A")
9604             .field("dwSize", &self.dwSize)
9605             .field("lpszServiceInstanceName", &self.lpszServiceInstanceName)
9606             .field("lpVersion", &self.lpVersion)
9607             .field("lpszComment", &self.lpszComment)
9608             .field("dwNameSpace", &self.dwNameSpace)
9609             .field("lpNSProviderId", &self.lpNSProviderId)
9610             .field("lpszContext", &self.lpszContext)
9611             .field("dwNumberOfProtocols", &self.dwNumberOfProtocols)
9612             .field("lpafpProtocols", &self.lpafpProtocols)
9613             .field("lpszQueryString", &self.lpszQueryString)
9614             .field("dwNumberOfCsAddrs", &self.dwNumberOfCsAddrs)
9615             .field("lpcsaBuffer", &self.lpcsaBuffer)
9616             .field("dwOutputFlags", &self.dwOutputFlags)
9617             .field("lpBlob", &self.lpBlob)
9618             .finish()
9619     }
9620 }
9621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9622 impl ::std::cmp::PartialEq for WSAQUERYSET2A {
eq(&self, other: &Self) -> bool9623     fn eq(&self, other: &Self) -> bool {
9624         self.dwSize == other.dwSize
9625             && self.lpszServiceInstanceName == other.lpszServiceInstanceName
9626             && self.lpVersion == other.lpVersion
9627             && self.lpszComment == other.lpszComment
9628             && self.dwNameSpace == other.dwNameSpace
9629             && self.lpNSProviderId == other.lpNSProviderId
9630             && self.lpszContext == other.lpszContext
9631             && self.dwNumberOfProtocols == other.dwNumberOfProtocols
9632             && self.lpafpProtocols == other.lpafpProtocols
9633             && self.lpszQueryString == other.lpszQueryString
9634             && self.dwNumberOfCsAddrs == other.dwNumberOfCsAddrs
9635             && self.lpcsaBuffer == other.lpcsaBuffer
9636             && self.dwOutputFlags == other.dwOutputFlags
9637             && self.lpBlob == other.lpBlob
9638     }
9639 }
9640 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9641 impl ::std::cmp::Eq for WSAQUERYSET2A {}
9642 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9643 unsafe impl ::windows::runtime::Abi for WSAQUERYSET2A {
9644     type Abi = Self;
9645     type DefaultType = Self;
9646 }
9647 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9648 #[repr(C)]
9649 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9650 pub struct WSAQUERYSET2W {
9651     pub dwSize: u32,
9652     pub lpszServiceInstanceName: super::super::Foundation::PWSTR,
9653     pub lpVersion: *mut WSAVERSION,
9654     pub lpszComment: super::super::Foundation::PWSTR,
9655     pub dwNameSpace: u32,
9656     pub lpNSProviderId: *mut ::windows::runtime::GUID,
9657     pub lpszContext: super::super::Foundation::PWSTR,
9658     pub dwNumberOfProtocols: u32,
9659     pub lpafpProtocols: *mut AFPROTOCOLS,
9660     pub lpszQueryString: super::super::Foundation::PWSTR,
9661     pub dwNumberOfCsAddrs: u32,
9662     pub lpcsaBuffer: *mut CSADDR_INFO,
9663     pub dwOutputFlags: u32,
9664     pub lpBlob: *mut super::super::System::Com::BLOB,
9665 }
9666 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9667 impl WSAQUERYSET2W {}
9668 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9669 impl ::std::default::Default for WSAQUERYSET2W {
default() -> Self9670     fn default() -> Self {
9671         unsafe { ::std::mem::zeroed() }
9672     }
9673 }
9674 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9675 impl ::std::fmt::Debug for WSAQUERYSET2W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9676     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9677         fmt.debug_struct("WSAQUERYSET2W")
9678             .field("dwSize", &self.dwSize)
9679             .field("lpszServiceInstanceName", &self.lpszServiceInstanceName)
9680             .field("lpVersion", &self.lpVersion)
9681             .field("lpszComment", &self.lpszComment)
9682             .field("dwNameSpace", &self.dwNameSpace)
9683             .field("lpNSProviderId", &self.lpNSProviderId)
9684             .field("lpszContext", &self.lpszContext)
9685             .field("dwNumberOfProtocols", &self.dwNumberOfProtocols)
9686             .field("lpafpProtocols", &self.lpafpProtocols)
9687             .field("lpszQueryString", &self.lpszQueryString)
9688             .field("dwNumberOfCsAddrs", &self.dwNumberOfCsAddrs)
9689             .field("lpcsaBuffer", &self.lpcsaBuffer)
9690             .field("dwOutputFlags", &self.dwOutputFlags)
9691             .field("lpBlob", &self.lpBlob)
9692             .finish()
9693     }
9694 }
9695 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9696 impl ::std::cmp::PartialEq for WSAQUERYSET2W {
eq(&self, other: &Self) -> bool9697     fn eq(&self, other: &Self) -> bool {
9698         self.dwSize == other.dwSize
9699             && self.lpszServiceInstanceName == other.lpszServiceInstanceName
9700             && self.lpVersion == other.lpVersion
9701             && self.lpszComment == other.lpszComment
9702             && self.dwNameSpace == other.dwNameSpace
9703             && self.lpNSProviderId == other.lpNSProviderId
9704             && self.lpszContext == other.lpszContext
9705             && self.dwNumberOfProtocols == other.dwNumberOfProtocols
9706             && self.lpafpProtocols == other.lpafpProtocols
9707             && self.lpszQueryString == other.lpszQueryString
9708             && self.dwNumberOfCsAddrs == other.dwNumberOfCsAddrs
9709             && self.lpcsaBuffer == other.lpcsaBuffer
9710             && self.dwOutputFlags == other.dwOutputFlags
9711             && self.lpBlob == other.lpBlob
9712     }
9713 }
9714 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9715 impl ::std::cmp::Eq for WSAQUERYSET2W {}
9716 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9717 unsafe impl ::windows::runtime::Abi for WSAQUERYSET2W {
9718     type Abi = Self;
9719     type DefaultType = Self;
9720 }
9721 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9722 #[repr(C)]
9723 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9724 pub struct WSAQUERYSETA {
9725     pub dwSize: u32,
9726     pub lpszServiceInstanceName: super::super::Foundation::PSTR,
9727     pub lpServiceClassId: *mut ::windows::runtime::GUID,
9728     pub lpVersion: *mut WSAVERSION,
9729     pub lpszComment: super::super::Foundation::PSTR,
9730     pub dwNameSpace: u32,
9731     pub lpNSProviderId: *mut ::windows::runtime::GUID,
9732     pub lpszContext: super::super::Foundation::PSTR,
9733     pub dwNumberOfProtocols: u32,
9734     pub lpafpProtocols: *mut AFPROTOCOLS,
9735     pub lpszQueryString: super::super::Foundation::PSTR,
9736     pub dwNumberOfCsAddrs: u32,
9737     pub lpcsaBuffer: *mut CSADDR_INFO,
9738     pub dwOutputFlags: u32,
9739     pub lpBlob: *mut super::super::System::Com::BLOB,
9740 }
9741 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9742 impl WSAQUERYSETA {}
9743 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9744 impl ::std::default::Default for WSAQUERYSETA {
default() -> Self9745     fn default() -> Self {
9746         unsafe { ::std::mem::zeroed() }
9747     }
9748 }
9749 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9750 impl ::std::fmt::Debug for WSAQUERYSETA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9751     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9752         fmt.debug_struct("WSAQUERYSETA")
9753             .field("dwSize", &self.dwSize)
9754             .field("lpszServiceInstanceName", &self.lpszServiceInstanceName)
9755             .field("lpServiceClassId", &self.lpServiceClassId)
9756             .field("lpVersion", &self.lpVersion)
9757             .field("lpszComment", &self.lpszComment)
9758             .field("dwNameSpace", &self.dwNameSpace)
9759             .field("lpNSProviderId", &self.lpNSProviderId)
9760             .field("lpszContext", &self.lpszContext)
9761             .field("dwNumberOfProtocols", &self.dwNumberOfProtocols)
9762             .field("lpafpProtocols", &self.lpafpProtocols)
9763             .field("lpszQueryString", &self.lpszQueryString)
9764             .field("dwNumberOfCsAddrs", &self.dwNumberOfCsAddrs)
9765             .field("lpcsaBuffer", &self.lpcsaBuffer)
9766             .field("dwOutputFlags", &self.dwOutputFlags)
9767             .field("lpBlob", &self.lpBlob)
9768             .finish()
9769     }
9770 }
9771 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9772 impl ::std::cmp::PartialEq for WSAQUERYSETA {
eq(&self, other: &Self) -> bool9773     fn eq(&self, other: &Self) -> bool {
9774         self.dwSize == other.dwSize
9775             && self.lpszServiceInstanceName == other.lpszServiceInstanceName
9776             && self.lpServiceClassId == other.lpServiceClassId
9777             && self.lpVersion == other.lpVersion
9778             && self.lpszComment == other.lpszComment
9779             && self.dwNameSpace == other.dwNameSpace
9780             && self.lpNSProviderId == other.lpNSProviderId
9781             && self.lpszContext == other.lpszContext
9782             && self.dwNumberOfProtocols == other.dwNumberOfProtocols
9783             && self.lpafpProtocols == other.lpafpProtocols
9784             && self.lpszQueryString == other.lpszQueryString
9785             && self.dwNumberOfCsAddrs == other.dwNumberOfCsAddrs
9786             && self.lpcsaBuffer == other.lpcsaBuffer
9787             && self.dwOutputFlags == other.dwOutputFlags
9788             && self.lpBlob == other.lpBlob
9789     }
9790 }
9791 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9792 impl ::std::cmp::Eq for WSAQUERYSETA {}
9793 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9794 unsafe impl ::windows::runtime::Abi for WSAQUERYSETA {
9795     type Abi = Self;
9796     type DefaultType = Self;
9797 }
9798 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9799 #[repr(C)]
9800 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9801 pub struct WSAQUERYSETW {
9802     pub dwSize: u32,
9803     pub lpszServiceInstanceName: super::super::Foundation::PWSTR,
9804     pub lpServiceClassId: *mut ::windows::runtime::GUID,
9805     pub lpVersion: *mut WSAVERSION,
9806     pub lpszComment: super::super::Foundation::PWSTR,
9807     pub dwNameSpace: u32,
9808     pub lpNSProviderId: *mut ::windows::runtime::GUID,
9809     pub lpszContext: super::super::Foundation::PWSTR,
9810     pub dwNumberOfProtocols: u32,
9811     pub lpafpProtocols: *mut AFPROTOCOLS,
9812     pub lpszQueryString: super::super::Foundation::PWSTR,
9813     pub dwNumberOfCsAddrs: u32,
9814     pub lpcsaBuffer: *mut CSADDR_INFO,
9815     pub dwOutputFlags: u32,
9816     pub lpBlob: *mut super::super::System::Com::BLOB,
9817 }
9818 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9819 impl WSAQUERYSETW {}
9820 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9821 impl ::std::default::Default for WSAQUERYSETW {
default() -> Self9822     fn default() -> Self {
9823         unsafe { ::std::mem::zeroed() }
9824     }
9825 }
9826 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9827 impl ::std::fmt::Debug for WSAQUERYSETW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9828     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9829         fmt.debug_struct("WSAQUERYSETW")
9830             .field("dwSize", &self.dwSize)
9831             .field("lpszServiceInstanceName", &self.lpszServiceInstanceName)
9832             .field("lpServiceClassId", &self.lpServiceClassId)
9833             .field("lpVersion", &self.lpVersion)
9834             .field("lpszComment", &self.lpszComment)
9835             .field("dwNameSpace", &self.dwNameSpace)
9836             .field("lpNSProviderId", &self.lpNSProviderId)
9837             .field("lpszContext", &self.lpszContext)
9838             .field("dwNumberOfProtocols", &self.dwNumberOfProtocols)
9839             .field("lpafpProtocols", &self.lpafpProtocols)
9840             .field("lpszQueryString", &self.lpszQueryString)
9841             .field("dwNumberOfCsAddrs", &self.dwNumberOfCsAddrs)
9842             .field("lpcsaBuffer", &self.lpcsaBuffer)
9843             .field("dwOutputFlags", &self.dwOutputFlags)
9844             .field("lpBlob", &self.lpBlob)
9845             .finish()
9846     }
9847 }
9848 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9849 impl ::std::cmp::PartialEq for WSAQUERYSETW {
eq(&self, other: &Self) -> bool9850     fn eq(&self, other: &Self) -> bool {
9851         self.dwSize == other.dwSize
9852             && self.lpszServiceInstanceName == other.lpszServiceInstanceName
9853             && self.lpServiceClassId == other.lpServiceClassId
9854             && self.lpVersion == other.lpVersion
9855             && self.lpszComment == other.lpszComment
9856             && self.dwNameSpace == other.dwNameSpace
9857             && self.lpNSProviderId == other.lpNSProviderId
9858             && self.lpszContext == other.lpszContext
9859             && self.dwNumberOfProtocols == other.dwNumberOfProtocols
9860             && self.lpafpProtocols == other.lpafpProtocols
9861             && self.lpszQueryString == other.lpszQueryString
9862             && self.dwNumberOfCsAddrs == other.dwNumberOfCsAddrs
9863             && self.lpcsaBuffer == other.lpcsaBuffer
9864             && self.dwOutputFlags == other.dwOutputFlags
9865             && self.lpBlob == other.lpBlob
9866     }
9867 }
9868 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9869 impl ::std::cmp::Eq for WSAQUERYSETW {}
9870 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
9871 unsafe impl ::windows::runtime::Abi for WSAQUERYSETW {
9872     type Abi = Self;
9873     type DefaultType = Self;
9874 }
9875 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
9876 #[inline]
WSAQuerySocketSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, securityquerytemplate: *const SOCKET_SECURITY_QUERY_TEMPLATE, securityquerytemplatelen: u32, securityqueryinfo: *mut SOCKET_SECURITY_QUERY_INFO, securityqueryinfolen: *mut u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i329877 pub unsafe fn WSAQuerySocketSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, securityquerytemplate: *const SOCKET_SECURITY_QUERY_TEMPLATE, securityquerytemplatelen: u32, securityqueryinfo: *mut SOCKET_SECURITY_QUERY_INFO, securityqueryinfolen: *mut u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
9878     #[cfg(windows)]
9879     {
9880         #[link(name = "windows")]
9881         extern "system" {
9882             fn WSAQuerySocketSecurity(socket: SOCKET, securityquerytemplate: *const SOCKET_SECURITY_QUERY_TEMPLATE, securityquerytemplatelen: u32, securityqueryinfo: *mut SOCKET_SECURITY_QUERY_INFO, securityqueryinfolen: *mut u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::windows::runtime::RawPtr) -> i32;
9883         }
9884         ::std::mem::transmute(WSAQuerySocketSecurity(
9885             socket.into_param().abi(),
9886             ::std::mem::transmute(securityquerytemplate),
9887             ::std::mem::transmute(securityquerytemplatelen),
9888             ::std::mem::transmute(securityqueryinfo),
9889             ::std::mem::transmute(securityqueryinfolen),
9890             ::std::mem::transmute(overlapped),
9891             ::std::mem::transmute(completionroutine),
9892         ))
9893     }
9894     #[cfg(not(windows))]
9895     unimplemented!("Unsupported target OS");
9896 }
9897 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
9898 #[inline]
WSARecv<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i329899 pub unsafe fn WSARecv<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
9900     #[cfg(windows)]
9901     {
9902         #[link(name = "windows")]
9903         extern "system" {
9904             fn WSARecv(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
9905         }
9906         ::std::mem::transmute(WSARecv(s.into_param().abi(), ::std::mem::transmute(lpbuffers), ::std::mem::transmute(dwbuffercount), ::std::mem::transmute(lpnumberofbytesrecvd), ::std::mem::transmute(lpflags), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lpcompletionroutine)))
9907     }
9908     #[cfg(not(windows))]
9909     unimplemented!("Unsupported target OS");
9910 }
9911 #[cfg(feature = "Win32_Foundation")]
9912 #[inline]
WSARecvDisconnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpinbounddisconnectdata: *const WSABUF) -> i329913 pub unsafe fn WSARecvDisconnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpinbounddisconnectdata: *const WSABUF) -> i32 {
9914     #[cfg(windows)]
9915     {
9916         #[link(name = "windows")]
9917         extern "system" {
9918             fn WSARecvDisconnect(s: SOCKET, lpinbounddisconnectdata: *const WSABUF) -> i32;
9919         }
9920         ::std::mem::transmute(WSARecvDisconnect(s.into_param().abi(), ::std::mem::transmute(lpinbounddisconnectdata)))
9921     }
9922     #[cfg(not(windows))]
9923     unimplemented!("Unsupported target OS");
9924 }
9925 #[cfg(feature = "Win32_Foundation")]
9926 #[inline]
WSARecvEx<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: *mut i32) -> i329927 pub unsafe fn WSARecvEx<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: *mut i32) -> i32 {
9928     #[cfg(windows)]
9929     {
9930         #[link(name = "windows")]
9931         extern "system" {
9932             fn WSARecvEx(s: SOCKET, buf: super::super::Foundation::PSTR, len: i32, flags: *mut i32) -> i32;
9933         }
9934         ::std::mem::transmute(WSARecvEx(s.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(len), ::std::mem::transmute(flags)))
9935     }
9936     #[cfg(not(windows))]
9937     unimplemented!("Unsupported target OS");
9938 }
9939 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
9940 #[inline]
WSARecvFrom<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpfrom: *mut SOCKADDR, lpfromlen: *mut i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i329941 pub unsafe fn WSARecvFrom<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpfrom: *mut SOCKADDR, lpfromlen: *mut i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
9942     #[cfg(windows)]
9943     {
9944         #[link(name = "windows")]
9945         extern "system" {
9946             fn WSARecvFrom(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytesrecvd: *mut u32, lpflags: *mut u32, lpfrom: *mut SOCKADDR, lpfromlen: *mut i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
9947         }
9948         ::std::mem::transmute(WSARecvFrom(
9949             s.into_param().abi(),
9950             ::std::mem::transmute(lpbuffers),
9951             ::std::mem::transmute(dwbuffercount),
9952             ::std::mem::transmute(lpnumberofbytesrecvd),
9953             ::std::mem::transmute(lpflags),
9954             ::std::mem::transmute(lpfrom),
9955             ::std::mem::transmute(lpfromlen),
9956             ::std::mem::transmute(lpoverlapped),
9957             ::std::mem::transmute(lpcompletionroutine),
9958         ))
9959     }
9960     #[cfg(not(windows))]
9961     unimplemented!("Unsupported target OS");
9962 }
9963 #[inline]
WSARemoveServiceClass(lpserviceclassid: *const ::windows::runtime::GUID) -> i329964 pub unsafe fn WSARemoveServiceClass(lpserviceclassid: *const ::windows::runtime::GUID) -> i32 {
9965     #[cfg(windows)]
9966     {
9967         #[link(name = "windows")]
9968         extern "system" {
9969             fn WSARemoveServiceClass(lpserviceclassid: *const ::windows::runtime::GUID) -> i32;
9970         }
9971         ::std::mem::transmute(WSARemoveServiceClass(::std::mem::transmute(lpserviceclassid)))
9972     }
9973     #[cfg(not(windows))]
9974     unimplemented!("Unsupported target OS");
9975 }
9976 #[cfg(feature = "Win32_Foundation")]
9977 #[inline]
WSAResetEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL9978 pub unsafe fn WSAResetEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL {
9979     #[cfg(windows)]
9980     {
9981         #[link(name = "windows")]
9982         extern "system" {
9983             fn WSAResetEvent(hevent: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
9984         }
9985         ::std::mem::transmute(WSAResetEvent(hevent.into_param().abi()))
9986     }
9987     #[cfg(not(windows))]
9988     unimplemented!("Unsupported target OS");
9989 }
9990 #[inline]
WSARevertImpersonation() -> i329991 pub unsafe fn WSARevertImpersonation() -> i32 {
9992     #[cfg(windows)]
9993     {
9994         #[link(name = "windows")]
9995         extern "system" {
9996             fn WSARevertImpersonation() -> i32;
9997         }
9998         ::std::mem::transmute(WSARevertImpersonation())
9999     }
10000     #[cfg(not(windows))]
10001     unimplemented!("Unsupported target OS");
10002 }
10003 #[derive(:: std :: clone :: Clone)]
10004 #[repr(C)]
10005 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10006 pub struct WSASENDMSG {
10007     pub lpMsg: *mut WSAMSG,
10008     pub dwFlags: u32,
10009     pub lpNumberOfBytesSent: *mut u32,
10010     pub lpOverlapped: *mut super::super::System::IO::OVERLAPPED,
10011     pub lpCompletionRoutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>,
10012 }
10013 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10014 impl WSASENDMSG {}
10015 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10016 impl ::std::default::Default for WSASENDMSG {
default() -> Self10017     fn default() -> Self {
10018         unsafe { ::std::mem::zeroed() }
10019     }
10020 }
10021 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10022 impl ::std::fmt::Debug for WSASENDMSG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10023     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10024         fmt.debug_struct("WSASENDMSG").field("lpMsg", &self.lpMsg).field("dwFlags", &self.dwFlags).field("lpNumberOfBytesSent", &self.lpNumberOfBytesSent).field("lpOverlapped", &self.lpOverlapped).finish()
10025     }
10026 }
10027 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10028 impl ::std::cmp::PartialEq for WSASENDMSG {
eq(&self, other: &Self) -> bool10029     fn eq(&self, other: &Self) -> bool {
10030         self.lpMsg == other.lpMsg && self.dwFlags == other.dwFlags && self.lpNumberOfBytesSent == other.lpNumberOfBytesSent && self.lpOverlapped == other.lpOverlapped && self.lpCompletionRoutine.map(|f| f as usize) == other.lpCompletionRoutine.map(|f| f as usize)
10031     }
10032 }
10033 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10034 impl ::std::cmp::Eq for WSASENDMSG {}
10035 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10036 unsafe impl ::windows::runtime::Abi for WSASENDMSG {
10037     type Abi = ::std::mem::ManuallyDrop<Self>;
10038     type DefaultType = Self;
10039 }
10040 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10041 #[repr(C)]
10042 #[cfg(feature = "Win32_Foundation")]
10043 pub struct WSASERVICECLASSINFOA {
10044     pub lpServiceClassId: *mut ::windows::runtime::GUID,
10045     pub lpszServiceClassName: super::super::Foundation::PSTR,
10046     pub dwCount: u32,
10047     pub lpClassInfos: *mut WSANSCLASSINFOA,
10048 }
10049 #[cfg(feature = "Win32_Foundation")]
10050 impl WSASERVICECLASSINFOA {}
10051 #[cfg(feature = "Win32_Foundation")]
10052 impl ::std::default::Default for WSASERVICECLASSINFOA {
default() -> Self10053     fn default() -> Self {
10054         unsafe { ::std::mem::zeroed() }
10055     }
10056 }
10057 #[cfg(feature = "Win32_Foundation")]
10058 impl ::std::fmt::Debug for WSASERVICECLASSINFOA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10059     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10060         fmt.debug_struct("WSASERVICECLASSINFOA").field("lpServiceClassId", &self.lpServiceClassId).field("lpszServiceClassName", &self.lpszServiceClassName).field("dwCount", &self.dwCount).field("lpClassInfos", &self.lpClassInfos).finish()
10061     }
10062 }
10063 #[cfg(feature = "Win32_Foundation")]
10064 impl ::std::cmp::PartialEq for WSASERVICECLASSINFOA {
eq(&self, other: &Self) -> bool10065     fn eq(&self, other: &Self) -> bool {
10066         self.lpServiceClassId == other.lpServiceClassId && self.lpszServiceClassName == other.lpszServiceClassName && self.dwCount == other.dwCount && self.lpClassInfos == other.lpClassInfos
10067     }
10068 }
10069 #[cfg(feature = "Win32_Foundation")]
10070 impl ::std::cmp::Eq for WSASERVICECLASSINFOA {}
10071 #[cfg(feature = "Win32_Foundation")]
10072 unsafe impl ::windows::runtime::Abi for WSASERVICECLASSINFOA {
10073     type Abi = Self;
10074     type DefaultType = Self;
10075 }
10076 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10077 #[repr(C)]
10078 #[cfg(feature = "Win32_Foundation")]
10079 pub struct WSASERVICECLASSINFOW {
10080     pub lpServiceClassId: *mut ::windows::runtime::GUID,
10081     pub lpszServiceClassName: super::super::Foundation::PWSTR,
10082     pub dwCount: u32,
10083     pub lpClassInfos: *mut WSANSCLASSINFOW,
10084 }
10085 #[cfg(feature = "Win32_Foundation")]
10086 impl WSASERVICECLASSINFOW {}
10087 #[cfg(feature = "Win32_Foundation")]
10088 impl ::std::default::Default for WSASERVICECLASSINFOW {
default() -> Self10089     fn default() -> Self {
10090         unsafe { ::std::mem::zeroed() }
10091     }
10092 }
10093 #[cfg(feature = "Win32_Foundation")]
10094 impl ::std::fmt::Debug for WSASERVICECLASSINFOW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10095     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10096         fmt.debug_struct("WSASERVICECLASSINFOW").field("lpServiceClassId", &self.lpServiceClassId).field("lpszServiceClassName", &self.lpszServiceClassName).field("dwCount", &self.dwCount).field("lpClassInfos", &self.lpClassInfos).finish()
10097     }
10098 }
10099 #[cfg(feature = "Win32_Foundation")]
10100 impl ::std::cmp::PartialEq for WSASERVICECLASSINFOW {
eq(&self, other: &Self) -> bool10101     fn eq(&self, other: &Self) -> bool {
10102         self.lpServiceClassId == other.lpServiceClassId && self.lpszServiceClassName == other.lpszServiceClassName && self.dwCount == other.dwCount && self.lpClassInfos == other.lpClassInfos
10103     }
10104 }
10105 #[cfg(feature = "Win32_Foundation")]
10106 impl ::std::cmp::Eq for WSASERVICECLASSINFOW {}
10107 #[cfg(feature = "Win32_Foundation")]
10108 unsafe impl ::windows::runtime::Abi for WSASERVICECLASSINFOW {
10109     type Abi = Self;
10110     type DefaultType = Self;
10111 }
10112 pub const WSASYS_STATUS_LEN: u32 = 128u32;
10113 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10114 #[inline]
WSASend<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i3210115 pub unsafe fn WSASend<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
10116     #[cfg(windows)]
10117     {
10118         #[link(name = "windows")]
10119         extern "system" {
10120             fn WSASend(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
10121         }
10122         ::std::mem::transmute(WSASend(s.into_param().abi(), ::std::mem::transmute(lpbuffers), ::std::mem::transmute(dwbuffercount), ::std::mem::transmute(lpnumberofbytessent), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lpcompletionroutine)))
10123     }
10124     #[cfg(not(windows))]
10125     unimplemented!("Unsupported target OS");
10126 }
10127 #[cfg(feature = "Win32_Foundation")]
10128 #[inline]
WSASendDisconnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpoutbounddisconnectdata: *const WSABUF) -> i3210129 pub unsafe fn WSASendDisconnect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpoutbounddisconnectdata: *const WSABUF) -> i32 {
10130     #[cfg(windows)]
10131     {
10132         #[link(name = "windows")]
10133         extern "system" {
10134             fn WSASendDisconnect(s: SOCKET, lpoutbounddisconnectdata: *const WSABUF) -> i32;
10135         }
10136         ::std::mem::transmute(WSASendDisconnect(s.into_param().abi(), ::std::mem::transmute(lpoutbounddisconnectdata)))
10137     }
10138     #[cfg(not(windows))]
10139     unimplemented!("Unsupported target OS");
10140 }
10141 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10142 #[inline]
WSASendMsg<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(handle: Param0, lpmsg: *const WSAMSG, dwflags: u32, lpnumberofbytessent: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i3210143 pub unsafe fn WSASendMsg<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(handle: Param0, lpmsg: *const WSAMSG, dwflags: u32, lpnumberofbytessent: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
10144     #[cfg(windows)]
10145     {
10146         #[link(name = "windows")]
10147         extern "system" {
10148             fn WSASendMsg(handle: SOCKET, lpmsg: *const WSAMSG, dwflags: u32, lpnumberofbytessent: *mut u32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
10149         }
10150         ::std::mem::transmute(WSASendMsg(handle.into_param().abi(), ::std::mem::transmute(lpmsg), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpnumberofbytessent), ::std::mem::transmute(lpoverlapped), ::std::mem::transmute(lpcompletionroutine)))
10151     }
10152     #[cfg(not(windows))]
10153     unimplemented!("Unsupported target OS");
10154 }
10155 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10156 #[inline]
WSASendTo<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpto: *const SOCKADDR, itolen: i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i3210157 pub unsafe fn WSASendTo<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpto: *const SOCKADDR, itolen: i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
10158     #[cfg(windows)]
10159     {
10160         #[link(name = "windows")]
10161         extern "system" {
10162             fn WSASendTo(s: SOCKET, lpbuffers: *const WSABUF, dwbuffercount: u32, lpnumberofbytessent: *mut u32, dwflags: u32, lpto: *const SOCKADDR, itolen: i32, lpoverlapped: *mut super::super::System::IO::OVERLAPPED, lpcompletionroutine: ::windows::runtime::RawPtr) -> i32;
10163         }
10164         ::std::mem::transmute(WSASendTo(
10165             s.into_param().abi(),
10166             ::std::mem::transmute(lpbuffers),
10167             ::std::mem::transmute(dwbuffercount),
10168             ::std::mem::transmute(lpnumberofbytessent),
10169             ::std::mem::transmute(dwflags),
10170             ::std::mem::transmute(lpto),
10171             ::std::mem::transmute(itolen),
10172             ::std::mem::transmute(lpoverlapped),
10173             ::std::mem::transmute(lpcompletionroutine),
10174         ))
10175     }
10176     #[cfg(not(windows))]
10177     unimplemented!("Unsupported target OS");
10178 }
10179 #[cfg(feature = "Win32_Foundation")]
10180 #[inline]
WSASetBlockingHook(lpblockfunc: ::std::option::Option<super::super::Foundation::FARPROC>) -> ::std::option::Option<super::super::Foundation::FARPROC>10181 pub unsafe fn WSASetBlockingHook(lpblockfunc: ::std::option::Option<super::super::Foundation::FARPROC>) -> ::std::option::Option<super::super::Foundation::FARPROC> {
10182     #[cfg(windows)]
10183     {
10184         #[link(name = "windows")]
10185         extern "system" {
10186             fn WSASetBlockingHook(lpblockfunc: ::windows::runtime::RawPtr) -> ::std::option::Option<super::super::Foundation::FARPROC>;
10187         }
10188         ::std::mem::transmute(WSASetBlockingHook(::std::mem::transmute(lpblockfunc)))
10189     }
10190     #[cfg(not(windows))]
10191     unimplemented!("Unsupported target OS");
10192 }
10193 #[cfg(feature = "Win32_Foundation")]
10194 #[inline]
WSASetEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL10195 pub unsafe fn WSASetEvent<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hevent: Param0) -> super::super::Foundation::BOOL {
10196     #[cfg(windows)]
10197     {
10198         #[link(name = "windows")]
10199         extern "system" {
10200             fn WSASetEvent(hevent: super::super::Foundation::HANDLE) -> super::super::Foundation::BOOL;
10201         }
10202         ::std::mem::transmute(WSASetEvent(hevent.into_param().abi()))
10203     }
10204     #[cfg(not(windows))]
10205     unimplemented!("Unsupported target OS");
10206 }
10207 #[inline]
WSASetLastError(ierror: i32)10208 pub unsafe fn WSASetLastError(ierror: i32) {
10209     #[cfg(windows)]
10210     {
10211         #[link(name = "windows")]
10212         extern "system" {
10213             fn WSASetLastError(ierror: i32);
10214         }
10215         ::std::mem::transmute(WSASetLastError(::std::mem::transmute(ierror)))
10216     }
10217     #[cfg(not(windows))]
10218     unimplemented!("Unsupported target OS");
10219 }
10220 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
10221 #[inline]
WSASetServiceA(lpqsreginfo: *const WSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i3210222 pub unsafe fn WSASetServiceA(lpqsreginfo: *const WSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i32 {
10223     #[cfg(windows)]
10224     {
10225         #[link(name = "windows")]
10226         extern "system" {
10227             fn WSASetServiceA(lpqsreginfo: *const WSAQUERYSETA, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i32;
10228         }
10229         ::std::mem::transmute(WSASetServiceA(::std::mem::transmute(lpqsreginfo), ::std::mem::transmute(essoperation), ::std::mem::transmute(dwcontrolflags)))
10230     }
10231     #[cfg(not(windows))]
10232     unimplemented!("Unsupported target OS");
10233 }
10234 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
10235 #[inline]
WSASetServiceW(lpqsreginfo: *const WSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i3210236 pub unsafe fn WSASetServiceW(lpqsreginfo: *const WSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i32 {
10237     #[cfg(windows)]
10238     {
10239         #[link(name = "windows")]
10240         extern "system" {
10241             fn WSASetServiceW(lpqsreginfo: *const WSAQUERYSETW, essoperation: WSAESETSERVICEOP, dwcontrolflags: u32) -> i32;
10242         }
10243         ::std::mem::transmute(WSASetServiceW(::std::mem::transmute(lpqsreginfo), ::std::mem::transmute(essoperation), ::std::mem::transmute(dwcontrolflags)))
10244     }
10245     #[cfg(not(windows))]
10246     unimplemented!("Unsupported target OS");
10247 }
10248 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10249 #[inline]
WSASetSocketPeerTargetName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peertargetname: *const SOCKET_PEER_TARGET_NAME, peertargetnamelen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i3210250 pub unsafe fn WSASetSocketPeerTargetName<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, peertargetname: *const SOCKET_PEER_TARGET_NAME, peertargetnamelen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
10251     #[cfg(windows)]
10252     {
10253         #[link(name = "windows")]
10254         extern "system" {
10255             fn WSASetSocketPeerTargetName(socket: SOCKET, peertargetname: *const SOCKET_PEER_TARGET_NAME, peertargetnamelen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::windows::runtime::RawPtr) -> i32;
10256         }
10257         ::std::mem::transmute(WSASetSocketPeerTargetName(socket.into_param().abi(), ::std::mem::transmute(peertargetname), ::std::mem::transmute(peertargetnamelen), ::std::mem::transmute(overlapped), ::std::mem::transmute(completionroutine)))
10258     }
10259     #[cfg(not(windows))]
10260     unimplemented!("Unsupported target OS");
10261 }
10262 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_IO"))]
10263 #[inline]
WSASetSocketSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, securitysettings: *const SOCKET_SECURITY_SETTINGS, securitysettingslen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i3210264 pub unsafe fn WSASetSocketSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(socket: Param0, securitysettings: *const SOCKET_SECURITY_SETTINGS, securitysettingslen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::std::option::Option<LPWSAOVERLAPPED_COMPLETION_ROUTINE>) -> i32 {
10265     #[cfg(windows)]
10266     {
10267         #[link(name = "windows")]
10268         extern "system" {
10269             fn WSASetSocketSecurity(socket: SOCKET, securitysettings: *const SOCKET_SECURITY_SETTINGS, securitysettingslen: u32, overlapped: *const super::super::System::IO::OVERLAPPED, completionroutine: ::windows::runtime::RawPtr) -> i32;
10270         }
10271         ::std::mem::transmute(WSASetSocketSecurity(socket.into_param().abi(), ::std::mem::transmute(securitysettings), ::std::mem::transmute(securitysettingslen), ::std::mem::transmute(overlapped), ::std::mem::transmute(completionroutine)))
10272     }
10273     #[cfg(not(windows))]
10274     unimplemented!("Unsupported target OS");
10275 }
10276 #[cfg(feature = "Win32_Foundation")]
10277 #[inline]
WSASocketA(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, g: u32, dwflags: u32) -> SOCKET10278 pub unsafe fn WSASocketA(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, g: u32, dwflags: u32) -> SOCKET {
10279     #[cfg(windows)]
10280     {
10281         #[link(name = "windows")]
10282         extern "system" {
10283             fn WSASocketA(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, g: u32, dwflags: u32) -> SOCKET;
10284         }
10285         ::std::mem::transmute(WSASocketA(::std::mem::transmute(af), ::std::mem::transmute(r#type), ::std::mem::transmute(protocol), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(g), ::std::mem::transmute(dwflags)))
10286     }
10287     #[cfg(not(windows))]
10288     unimplemented!("Unsupported target OS");
10289 }
10290 #[inline]
WSASocketW(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, g: u32, dwflags: u32) -> SOCKET10291 pub unsafe fn WSASocketW(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, g: u32, dwflags: u32) -> SOCKET {
10292     #[cfg(windows)]
10293     {
10294         #[link(name = "windows")]
10295         extern "system" {
10296             fn WSASocketW(af: i32, r#type: i32, protocol: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, g: u32, dwflags: u32) -> SOCKET;
10297         }
10298         ::std::mem::transmute(WSASocketW(::std::mem::transmute(af), ::std::mem::transmute(r#type), ::std::mem::transmute(protocol), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(g), ::std::mem::transmute(dwflags)))
10299     }
10300     #[cfg(not(windows))]
10301     unimplemented!("Unsupported target OS");
10302 }
10303 #[cfg(feature = "Win32_Foundation")]
10304 #[inline]
WSAStartup(wversionrequested: u16, lpwsadata: *mut WSAData) -> i3210305 pub unsafe fn WSAStartup(wversionrequested: u16, lpwsadata: *mut WSAData) -> i32 {
10306     #[cfg(windows)]
10307     {
10308         #[link(name = "windows")]
10309         extern "system" {
10310             fn WSAStartup(wversionrequested: u16, lpwsadata: *mut WSAData) -> i32;
10311         }
10312         ::std::mem::transmute(WSAStartup(::std::mem::transmute(wversionrequested), ::std::mem::transmute(lpwsadata)))
10313     }
10314     #[cfg(not(windows))]
10315     unimplemented!("Unsupported target OS");
10316 }
10317 #[cfg(feature = "Win32_Foundation")]
10318 #[inline]
WSAStringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addressstring: Param0, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i3210319 pub unsafe fn WSAStringToAddressA<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addressstring: Param0, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i32 {
10320     #[cfg(windows)]
10321     {
10322         #[link(name = "windows")]
10323         extern "system" {
10324             fn WSAStringToAddressA(addressstring: super::super::Foundation::PSTR, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOA, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i32;
10325         }
10326         ::std::mem::transmute(WSAStringToAddressA(addressstring.into_param().abi(), ::std::mem::transmute(addressfamily), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(lpaddress), ::std::mem::transmute(lpaddresslength)))
10327     }
10328     #[cfg(not(windows))]
10329     unimplemented!("Unsupported target OS");
10330 }
10331 #[cfg(feature = "Win32_Foundation")]
10332 #[inline]
WSAStringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(addressstring: Param0, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i3210333 pub unsafe fn WSAStringToAddressW<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(addressstring: Param0, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i32 {
10334     #[cfg(windows)]
10335     {
10336         #[link(name = "windows")]
10337         extern "system" {
10338             fn WSAStringToAddressW(addressstring: super::super::Foundation::PWSTR, addressfamily: i32, lpprotocolinfo: *const WSAPROTOCOL_INFOW, lpaddress: *mut SOCKADDR, lpaddresslength: *mut i32) -> i32;
10339         }
10340         ::std::mem::transmute(WSAStringToAddressW(addressstring.into_param().abi(), ::std::mem::transmute(addressfamily), ::std::mem::transmute(lpprotocolinfo), ::std::mem::transmute(lpaddress), ::std::mem::transmute(lpaddresslength)))
10341     }
10342     #[cfg(not(windows))]
10343     unimplemented!("Unsupported target OS");
10344 }
10345 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10346 #[repr(C)]
10347 #[cfg(feature = "Win32_Foundation")]
10348 pub struct WSATHREADID {
10349     pub ThreadHandle: super::super::Foundation::HANDLE,
10350     pub Reserved: usize,
10351 }
10352 #[cfg(feature = "Win32_Foundation")]
10353 impl WSATHREADID {}
10354 #[cfg(feature = "Win32_Foundation")]
10355 impl ::std::default::Default for WSATHREADID {
default() -> Self10356     fn default() -> Self {
10357         unsafe { ::std::mem::zeroed() }
10358     }
10359 }
10360 #[cfg(feature = "Win32_Foundation")]
10361 impl ::std::fmt::Debug for WSATHREADID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10362     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10363         fmt.debug_struct("WSATHREADID").field("ThreadHandle", &self.ThreadHandle).field("Reserved", &self.Reserved).finish()
10364     }
10365 }
10366 #[cfg(feature = "Win32_Foundation")]
10367 impl ::std::cmp::PartialEq for WSATHREADID {
eq(&self, other: &Self) -> bool10368     fn eq(&self, other: &Self) -> bool {
10369         self.ThreadHandle == other.ThreadHandle && self.Reserved == other.Reserved
10370     }
10371 }
10372 #[cfg(feature = "Win32_Foundation")]
10373 impl ::std::cmp::Eq for WSATHREADID {}
10374 #[cfg(feature = "Win32_Foundation")]
10375 unsafe impl ::windows::runtime::Abi for WSATHREADID {
10376     type Abi = Self;
10377     type DefaultType = Self;
10378 }
10379 #[inline]
WSAUnadvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID) -> i3210380 pub unsafe fn WSAUnadvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID) -> i32 {
10381     #[cfg(windows)]
10382     {
10383         #[link(name = "windows")]
10384         extern "system" {
10385             fn WSAUnadvertiseProvider(puuidproviderid: *const ::windows::runtime::GUID) -> i32;
10386         }
10387         ::std::mem::transmute(WSAUnadvertiseProvider(::std::mem::transmute(puuidproviderid)))
10388     }
10389     #[cfg(not(windows))]
10390     unimplemented!("Unsupported target OS");
10391 }
10392 #[inline]
WSAUnhookBlockingHook() -> i3210393 pub unsafe fn WSAUnhookBlockingHook() -> i32 {
10394     #[cfg(windows)]
10395     {
10396         #[link(name = "windows")]
10397         extern "system" {
10398             fn WSAUnhookBlockingHook() -> i32;
10399         }
10400         ::std::mem::transmute(WSAUnhookBlockingHook())
10401     }
10402     #[cfg(not(windows))]
10403     unimplemented!("Unsupported target OS");
10404 }
10405 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10406 #[repr(C)]
10407 pub struct WSAVERSION {
10408     pub dwVersion: u32,
10409     pub ecHow: WSAECOMPARATOR,
10410 }
10411 impl WSAVERSION {}
10412 impl ::std::default::Default for WSAVERSION {
default() -> Self10413     fn default() -> Self {
10414         unsafe { ::std::mem::zeroed() }
10415     }
10416 }
10417 impl ::std::fmt::Debug for WSAVERSION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10418     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10419         fmt.debug_struct("WSAVERSION").field("dwVersion", &self.dwVersion).field("ecHow", &self.ecHow).finish()
10420     }
10421 }
10422 impl ::std::cmp::PartialEq for WSAVERSION {
eq(&self, other: &Self) -> bool10423     fn eq(&self, other: &Self) -> bool {
10424         self.dwVersion == other.dwVersion && self.ecHow == other.ecHow
10425     }
10426 }
10427 impl ::std::cmp::Eq for WSAVERSION {}
10428 unsafe impl ::windows::runtime::Abi for WSAVERSION {
10429     type Abi = Self;
10430     type DefaultType = Self;
10431 }
10432 #[cfg(feature = "Win32_Foundation")]
10433 #[inline]
WSAWaitForMultipleEvents<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(cevents: u32, lphevents: *const super::super::Foundation::HANDLE, fwaitall: Param2, dwtimeout: u32, falertable: Param4) -> u3210434 pub unsafe fn WSAWaitForMultipleEvents<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(cevents: u32, lphevents: *const super::super::Foundation::HANDLE, fwaitall: Param2, dwtimeout: u32, falertable: Param4) -> u32 {
10435     #[cfg(windows)]
10436     {
10437         #[link(name = "windows")]
10438         extern "system" {
10439             fn WSAWaitForMultipleEvents(cevents: u32, lphevents: *const super::super::Foundation::HANDLE, fwaitall: super::super::Foundation::BOOL, dwtimeout: u32, falertable: super::super::Foundation::BOOL) -> u32;
10440         }
10441         ::std::mem::transmute(WSAWaitForMultipleEvents(::std::mem::transmute(cevents), ::std::mem::transmute(lphevents), fwaitall.into_param().abi(), ::std::mem::transmute(dwtimeout), falertable.into_param().abi()))
10442     }
10443     #[cfg(not(windows))]
10444     unimplemented!("Unsupported target OS");
10445 }
10446 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10447 #[repr(transparent)]
10448 pub struct WSA_COMPATIBILITY_BEHAVIOR_ID(pub i32);
10449 pub const WsaBehaviorAll: WSA_COMPATIBILITY_BEHAVIOR_ID = WSA_COMPATIBILITY_BEHAVIOR_ID(0i32);
10450 pub const WsaBehaviorReceiveBuffering: WSA_COMPATIBILITY_BEHAVIOR_ID = WSA_COMPATIBILITY_BEHAVIOR_ID(1i32);
10451 pub const WsaBehaviorAutoTuning: WSA_COMPATIBILITY_BEHAVIOR_ID = WSA_COMPATIBILITY_BEHAVIOR_ID(2i32);
10452 impl ::std::convert::From<i32> for WSA_COMPATIBILITY_BEHAVIOR_ID {
from(value: i32) -> Self10453     fn from(value: i32) -> Self {
10454         Self(value)
10455     }
10456 }
10457 unsafe impl ::windows::runtime::Abi for WSA_COMPATIBILITY_BEHAVIOR_ID {
10458     type Abi = Self;
10459     type DefaultType = Self;
10460 }
10461 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10462 #[repr(C)]
10463 pub struct WSA_COMPATIBILITY_MODE {
10464     pub BehaviorId: WSA_COMPATIBILITY_BEHAVIOR_ID,
10465     pub TargetOsVersion: u32,
10466 }
10467 impl WSA_COMPATIBILITY_MODE {}
10468 impl ::std::default::Default for WSA_COMPATIBILITY_MODE {
default() -> Self10469     fn default() -> Self {
10470         unsafe { ::std::mem::zeroed() }
10471     }
10472 }
10473 impl ::std::fmt::Debug for WSA_COMPATIBILITY_MODE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10474     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10475         fmt.debug_struct("WSA_COMPATIBILITY_MODE").field("BehaviorId", &self.BehaviorId).field("TargetOsVersion", &self.TargetOsVersion).finish()
10476     }
10477 }
10478 impl ::std::cmp::PartialEq for WSA_COMPATIBILITY_MODE {
eq(&self, other: &Self) -> bool10479     fn eq(&self, other: &Self) -> bool {
10480         self.BehaviorId == other.BehaviorId && self.TargetOsVersion == other.TargetOsVersion
10481     }
10482 }
10483 impl ::std::cmp::Eq for WSA_COMPATIBILITY_MODE {}
10484 unsafe impl ::windows::runtime::Abi for WSA_COMPATIBILITY_MODE {
10485     type Abi = Self;
10486     type DefaultType = Self;
10487 }
10488 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10489 #[repr(transparent)]
10490 pub struct WSA_ERROR(pub i32);
10491 pub const WSA_IO_PENDING: WSA_ERROR = WSA_ERROR(997i32);
10492 pub const WSA_IO_INCOMPLETE: WSA_ERROR = WSA_ERROR(996i32);
10493 pub const WSA_INVALID_HANDLE: WSA_ERROR = WSA_ERROR(6i32);
10494 pub const WSA_INVALID_PARAMETER: WSA_ERROR = WSA_ERROR(87i32);
10495 pub const WSA_NOT_ENOUGH_MEMORY: WSA_ERROR = WSA_ERROR(8i32);
10496 pub const WSA_OPERATION_ABORTED: WSA_ERROR = WSA_ERROR(995i32);
10497 pub const WSABASEERR: WSA_ERROR = WSA_ERROR(10000i32);
10498 pub const WSAEINTR: WSA_ERROR = WSA_ERROR(10004i32);
10499 pub const WSAEBADF: WSA_ERROR = WSA_ERROR(10009i32);
10500 pub const WSAEACCES: WSA_ERROR = WSA_ERROR(10013i32);
10501 pub const WSAEFAULT: WSA_ERROR = WSA_ERROR(10014i32);
10502 pub const WSAEINVAL: WSA_ERROR = WSA_ERROR(10022i32);
10503 pub const WSAEMFILE: WSA_ERROR = WSA_ERROR(10024i32);
10504 pub const WSAEWOULDBLOCK: WSA_ERROR = WSA_ERROR(10035i32);
10505 pub const WSAEINPROGRESS: WSA_ERROR = WSA_ERROR(10036i32);
10506 pub const WSAEALREADY: WSA_ERROR = WSA_ERROR(10037i32);
10507 pub const WSAENOTSOCK: WSA_ERROR = WSA_ERROR(10038i32);
10508 pub const WSAEDESTADDRREQ: WSA_ERROR = WSA_ERROR(10039i32);
10509 pub const WSAEMSGSIZE: WSA_ERROR = WSA_ERROR(10040i32);
10510 pub const WSAEPROTOTYPE: WSA_ERROR = WSA_ERROR(10041i32);
10511 pub const WSAENOPROTOOPT: WSA_ERROR = WSA_ERROR(10042i32);
10512 pub const WSAEPROTONOSUPPORT: WSA_ERROR = WSA_ERROR(10043i32);
10513 pub const WSAESOCKTNOSUPPORT: WSA_ERROR = WSA_ERROR(10044i32);
10514 pub const WSAEOPNOTSUPP: WSA_ERROR = WSA_ERROR(10045i32);
10515 pub const WSAEPFNOSUPPORT: WSA_ERROR = WSA_ERROR(10046i32);
10516 pub const WSAEAFNOSUPPORT: WSA_ERROR = WSA_ERROR(10047i32);
10517 pub const WSAEADDRINUSE: WSA_ERROR = WSA_ERROR(10048i32);
10518 pub const WSAEADDRNOTAVAIL: WSA_ERROR = WSA_ERROR(10049i32);
10519 pub const WSAENETDOWN: WSA_ERROR = WSA_ERROR(10050i32);
10520 pub const WSAENETUNREACH: WSA_ERROR = WSA_ERROR(10051i32);
10521 pub const WSAENETRESET: WSA_ERROR = WSA_ERROR(10052i32);
10522 pub const WSAECONNABORTED: WSA_ERROR = WSA_ERROR(10053i32);
10523 pub const WSAECONNRESET: WSA_ERROR = WSA_ERROR(10054i32);
10524 pub const WSAENOBUFS: WSA_ERROR = WSA_ERROR(10055i32);
10525 pub const WSAEISCONN: WSA_ERROR = WSA_ERROR(10056i32);
10526 pub const WSAENOTCONN: WSA_ERROR = WSA_ERROR(10057i32);
10527 pub const WSAESHUTDOWN: WSA_ERROR = WSA_ERROR(10058i32);
10528 pub const WSAETOOMANYREFS: WSA_ERROR = WSA_ERROR(10059i32);
10529 pub const WSAETIMEDOUT: WSA_ERROR = WSA_ERROR(10060i32);
10530 pub const WSAECONNREFUSED: WSA_ERROR = WSA_ERROR(10061i32);
10531 pub const WSAELOOP: WSA_ERROR = WSA_ERROR(10062i32);
10532 pub const WSAENAMETOOLONG: WSA_ERROR = WSA_ERROR(10063i32);
10533 pub const WSAEHOSTDOWN: WSA_ERROR = WSA_ERROR(10064i32);
10534 pub const WSAEHOSTUNREACH: WSA_ERROR = WSA_ERROR(10065i32);
10535 pub const WSAENOTEMPTY: WSA_ERROR = WSA_ERROR(10066i32);
10536 pub const WSAEPROCLIM: WSA_ERROR = WSA_ERROR(10067i32);
10537 pub const WSAEUSERS: WSA_ERROR = WSA_ERROR(10068i32);
10538 pub const WSAEDQUOT: WSA_ERROR = WSA_ERROR(10069i32);
10539 pub const WSAESTALE: WSA_ERROR = WSA_ERROR(10070i32);
10540 pub const WSAEREMOTE: WSA_ERROR = WSA_ERROR(10071i32);
10541 pub const WSASYSNOTREADY: WSA_ERROR = WSA_ERROR(10091i32);
10542 pub const WSAVERNOTSUPPORTED: WSA_ERROR = WSA_ERROR(10092i32);
10543 pub const WSANOTINITIALISED: WSA_ERROR = WSA_ERROR(10093i32);
10544 pub const WSAEDISCON: WSA_ERROR = WSA_ERROR(10101i32);
10545 pub const WSAENOMORE: WSA_ERROR = WSA_ERROR(10102i32);
10546 pub const WSAECANCELLED: WSA_ERROR = WSA_ERROR(10103i32);
10547 pub const WSAEINVALIDPROCTABLE: WSA_ERROR = WSA_ERROR(10104i32);
10548 pub const WSAEINVALIDPROVIDER: WSA_ERROR = WSA_ERROR(10105i32);
10549 pub const WSAEPROVIDERFAILEDINIT: WSA_ERROR = WSA_ERROR(10106i32);
10550 pub const WSASYSCALLFAILURE: WSA_ERROR = WSA_ERROR(10107i32);
10551 pub const WSASERVICE_NOT_FOUND: WSA_ERROR = WSA_ERROR(10108i32);
10552 pub const WSATYPE_NOT_FOUND: WSA_ERROR = WSA_ERROR(10109i32);
10553 pub const WSA_E_NO_MORE: WSA_ERROR = WSA_ERROR(10110i32);
10554 pub const WSA_E_CANCELLED: WSA_ERROR = WSA_ERROR(10111i32);
10555 pub const WSAEREFUSED: WSA_ERROR = WSA_ERROR(10112i32);
10556 pub const WSAHOST_NOT_FOUND: WSA_ERROR = WSA_ERROR(11001i32);
10557 pub const WSATRY_AGAIN: WSA_ERROR = WSA_ERROR(11002i32);
10558 pub const WSANO_RECOVERY: WSA_ERROR = WSA_ERROR(11003i32);
10559 pub const WSANO_DATA: WSA_ERROR = WSA_ERROR(11004i32);
10560 pub const WSA_QOS_RECEIVERS: WSA_ERROR = WSA_ERROR(11005i32);
10561 pub const WSA_QOS_SENDERS: WSA_ERROR = WSA_ERROR(11006i32);
10562 pub const WSA_QOS_NO_SENDERS: WSA_ERROR = WSA_ERROR(11007i32);
10563 pub const WSA_QOS_NO_RECEIVERS: WSA_ERROR = WSA_ERROR(11008i32);
10564 pub const WSA_QOS_REQUEST_CONFIRMED: WSA_ERROR = WSA_ERROR(11009i32);
10565 pub const WSA_QOS_ADMISSION_FAILURE: WSA_ERROR = WSA_ERROR(11010i32);
10566 pub const WSA_QOS_POLICY_FAILURE: WSA_ERROR = WSA_ERROR(11011i32);
10567 pub const WSA_QOS_BAD_STYLE: WSA_ERROR = WSA_ERROR(11012i32);
10568 pub const WSA_QOS_BAD_OBJECT: WSA_ERROR = WSA_ERROR(11013i32);
10569 pub const WSA_QOS_TRAFFIC_CTRL_ERROR: WSA_ERROR = WSA_ERROR(11014i32);
10570 pub const WSA_QOS_GENERIC_ERROR: WSA_ERROR = WSA_ERROR(11015i32);
10571 pub const WSA_QOS_ESERVICETYPE: WSA_ERROR = WSA_ERROR(11016i32);
10572 pub const WSA_QOS_EFLOWSPEC: WSA_ERROR = WSA_ERROR(11017i32);
10573 pub const WSA_QOS_EPROVSPECBUF: WSA_ERROR = WSA_ERROR(11018i32);
10574 pub const WSA_QOS_EFILTERSTYLE: WSA_ERROR = WSA_ERROR(11019i32);
10575 pub const WSA_QOS_EFILTERTYPE: WSA_ERROR = WSA_ERROR(11020i32);
10576 pub const WSA_QOS_EFILTERCOUNT: WSA_ERROR = WSA_ERROR(11021i32);
10577 pub const WSA_QOS_EOBJLENGTH: WSA_ERROR = WSA_ERROR(11022i32);
10578 pub const WSA_QOS_EFLOWCOUNT: WSA_ERROR = WSA_ERROR(11023i32);
10579 pub const WSA_QOS_EUNKOWNPSOBJ: WSA_ERROR = WSA_ERROR(11024i32);
10580 pub const WSA_QOS_EPOLICYOBJ: WSA_ERROR = WSA_ERROR(11025i32);
10581 pub const WSA_QOS_EFLOWDESC: WSA_ERROR = WSA_ERROR(11026i32);
10582 pub const WSA_QOS_EPSFLOWSPEC: WSA_ERROR = WSA_ERROR(11027i32);
10583 pub const WSA_QOS_EPSFILTERSPEC: WSA_ERROR = WSA_ERROR(11028i32);
10584 pub const WSA_QOS_ESDMODEOBJ: WSA_ERROR = WSA_ERROR(11029i32);
10585 pub const WSA_QOS_ESHAPERATEOBJ: WSA_ERROR = WSA_ERROR(11030i32);
10586 pub const WSA_QOS_RESERVED_PETYPE: WSA_ERROR = WSA_ERROR(11031i32);
10587 pub const WSA_SECURE_HOST_NOT_FOUND: WSA_ERROR = WSA_ERROR(11032i32);
10588 pub const WSA_IPSEC_NAME_POLICY_ERROR: WSA_ERROR = WSA_ERROR(11033i32);
10589 impl ::std::convert::From<i32> for WSA_ERROR {
from(value: i32) -> Self10590     fn from(value: i32) -> Self {
10591         Self(value)
10592     }
10593 }
10594 unsafe impl ::windows::runtime::Abi for WSA_ERROR {
10595     type Abi = Self;
10596     type DefaultType = Self;
10597 }
10598 pub const WSA_FLAG_ACCESS_SYSTEM_SECURITY: u32 = 64u32;
10599 pub const WSA_FLAG_MULTIPOINT_C_LEAF: u32 = 4u32;
10600 pub const WSA_FLAG_MULTIPOINT_C_ROOT: u32 = 2u32;
10601 pub const WSA_FLAG_MULTIPOINT_D_LEAF: u32 = 16u32;
10602 pub const WSA_FLAG_MULTIPOINT_D_ROOT: u32 = 8u32;
10603 pub const WSA_FLAG_NO_HANDLE_INHERIT: u32 = 128u32;
10604 pub const WSA_FLAG_OVERLAPPED: u32 = 1u32;
10605 pub const WSA_FLAG_REGISTERED_IO: u32 = 256u32;
10606 pub const WSA_INFINITE: u32 = 4294967295u32;
10607 pub const WSA_MAXIMUM_WAIT_EVENTS: u32 = 64u32;
10608 pub const WSA_WAIT_EVENT_0: u32 = 0u32;
10609 pub const WSA_WAIT_FAILED: u32 = 4294967295u32;
10610 pub const WSA_WAIT_IO_COMPLETION: u32 = 192u32;
10611 #[inline]
WSCDeinstallProvider(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i3210612 pub unsafe fn WSCDeinstallProvider(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i32 {
10613     #[cfg(windows)]
10614     {
10615         #[link(name = "windows")]
10616         extern "system" {
10617             fn WSCDeinstallProvider(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i32;
10618         }
10619         ::std::mem::transmute(WSCDeinstallProvider(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lperrno)))
10620     }
10621     #[cfg(not(windows))]
10622     unimplemented!("Unsupported target OS");
10623 }
10624 #[inline]
WSCDeinstallProvider32(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i3210625 pub unsafe fn WSCDeinstallProvider32(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i32 {
10626     #[cfg(windows)]
10627     {
10628         #[link(name = "windows")]
10629         extern "system" {
10630             fn WSCDeinstallProvider32(lpproviderid: *const ::windows::runtime::GUID, lperrno: *mut i32) -> i32;
10631         }
10632         ::std::mem::transmute(WSCDeinstallProvider32(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lperrno)))
10633     }
10634     #[cfg(not(windows))]
10635     unimplemented!("Unsupported target OS");
10636 }
10637 #[cfg(feature = "Win32_Foundation")]
10638 #[inline]
WSCEnableNSProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(lpproviderid: *const ::windows::runtime::GUID, fenable: Param1) -> i3210639 pub unsafe fn WSCEnableNSProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(lpproviderid: *const ::windows::runtime::GUID, fenable: Param1) -> i32 {
10640     #[cfg(windows)]
10641     {
10642         #[link(name = "windows")]
10643         extern "system" {
10644             fn WSCEnableNSProvider(lpproviderid: *const ::windows::runtime::GUID, fenable: super::super::Foundation::BOOL) -> i32;
10645         }
10646         ::std::mem::transmute(WSCEnableNSProvider(::std::mem::transmute(lpproviderid), fenable.into_param().abi()))
10647     }
10648     #[cfg(not(windows))]
10649     unimplemented!("Unsupported target OS");
10650 }
10651 #[cfg(feature = "Win32_Foundation")]
10652 #[inline]
WSCEnableNSProvider32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(lpproviderid: *const ::windows::runtime::GUID, fenable: Param1) -> i3210653 pub unsafe fn WSCEnableNSProvider32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(lpproviderid: *const ::windows::runtime::GUID, fenable: Param1) -> i32 {
10654     #[cfg(windows)]
10655     {
10656         #[link(name = "windows")]
10657         extern "system" {
10658             fn WSCEnableNSProvider32(lpproviderid: *const ::windows::runtime::GUID, fenable: super::super::Foundation::BOOL) -> i32;
10659         }
10660         ::std::mem::transmute(WSCEnableNSProvider32(::std::mem::transmute(lpproviderid), fenable.into_param().abi()))
10661     }
10662     #[cfg(not(windows))]
10663     unimplemented!("Unsupported target OS");
10664 }
10665 #[cfg(feature = "Win32_Foundation")]
10666 #[inline]
WSCEnumNameSpaceProviders32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i3210667 pub unsafe fn WSCEnumNameSpaceProviders32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i32 {
10668     #[cfg(windows)]
10669     {
10670         #[link(name = "windows")]
10671         extern "system" {
10672             fn WSCEnumNameSpaceProviders32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOW) -> i32;
10673         }
10674         ::std::mem::transmute(WSCEnumNameSpaceProviders32(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
10675     }
10676     #[cfg(not(windows))]
10677     unimplemented!("Unsupported target OS");
10678 }
10679 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
10680 #[inline]
WSCEnumNameSpaceProvidersEx32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i3210681 pub unsafe fn WSCEnumNameSpaceProvidersEx32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i32 {
10682     #[cfg(windows)]
10683     {
10684         #[link(name = "windows")]
10685         extern "system" {
10686             fn WSCEnumNameSpaceProvidersEx32(lpdwbufferlength: *mut u32, lpnspbuffer: *mut WSANAMESPACE_INFOEXW) -> i32;
10687         }
10688         ::std::mem::transmute(WSCEnumNameSpaceProvidersEx32(::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lpnspbuffer)))
10689     }
10690     #[cfg(not(windows))]
10691     unimplemented!("Unsupported target OS");
10692 }
10693 #[inline]
WSCEnumProtocols(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i3210694 pub unsafe fn WSCEnumProtocols(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i32 {
10695     #[cfg(windows)]
10696     {
10697         #[link(name = "windows")]
10698         extern "system" {
10699             fn WSCEnumProtocols(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i32;
10700         }
10701         ::std::mem::transmute(WSCEnumProtocols(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lperrno)))
10702     }
10703     #[cfg(not(windows))]
10704     unimplemented!("Unsupported target OS");
10705 }
10706 #[inline]
WSCEnumProtocols32(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i3210707 pub unsafe fn WSCEnumProtocols32(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i32 {
10708     #[cfg(windows)]
10709     {
10710         #[link(name = "windows")]
10711         extern "system" {
10712             fn WSCEnumProtocols32(lpiprotocols: *const i32, lpprotocolbuffer: *mut WSAPROTOCOL_INFOW, lpdwbufferlength: *mut u32, lperrno: *mut i32) -> i32;
10713         }
10714         ::std::mem::transmute(WSCEnumProtocols32(::std::mem::transmute(lpiprotocols), ::std::mem::transmute(lpprotocolbuffer), ::std::mem::transmute(lpdwbufferlength), ::std::mem::transmute(lperrno)))
10715     }
10716     #[cfg(not(windows))]
10717     unimplemented!("Unsupported target OS");
10718 }
10719 #[cfg(feature = "Win32_Foundation")]
10720 #[inline]
WSCGetApplicationCategory<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(path: Param0, pathlength: u32, extra: Param2, extralength: u32, ppermittedlspcategories: *mut u32, lperrno: *mut i32) -> i3210721 pub unsafe fn WSCGetApplicationCategory<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(path: Param0, pathlength: u32, extra: Param2, extralength: u32, ppermittedlspcategories: *mut u32, lperrno: *mut i32) -> i32 {
10722     #[cfg(windows)]
10723     {
10724         #[link(name = "windows")]
10725         extern "system" {
10726             fn WSCGetApplicationCategory(path: super::super::Foundation::PWSTR, pathlength: u32, extra: super::super::Foundation::PWSTR, extralength: u32, ppermittedlspcategories: *mut u32, lperrno: *mut i32) -> i32;
10727         }
10728         ::std::mem::transmute(WSCGetApplicationCategory(path.into_param().abi(), ::std::mem::transmute(pathlength), extra.into_param().abi(), ::std::mem::transmute(extralength), ::std::mem::transmute(ppermittedlspcategories), ::std::mem::transmute(lperrno)))
10729     }
10730     #[cfg(not(windows))]
10731     unimplemented!("Unsupported target OS");
10732 }
10733 #[inline]
WSCGetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i3210734 pub unsafe fn WSCGetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i32 {
10735     #[cfg(windows)]
10736     {
10737         #[link(name = "windows")]
10738         extern "system" {
10739             fn WSCGetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i32;
10740         }
10741         ::std::mem::transmute(WSCGetProviderInfo(::std::mem::transmute(lpproviderid), ::std::mem::transmute(infotype), ::std::mem::transmute(info), ::std::mem::transmute(infosize), ::std::mem::transmute(flags), ::std::mem::transmute(lperrno)))
10742     }
10743     #[cfg(not(windows))]
10744     unimplemented!("Unsupported target OS");
10745 }
10746 #[inline]
WSCGetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i3210747 pub unsafe fn WSCGetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i32 {
10748     #[cfg(windows)]
10749     {
10750         #[link(name = "windows")]
10751         extern "system" {
10752             fn WSCGetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *mut u8, infosize: *mut usize, flags: u32, lperrno: *mut i32) -> i32;
10753         }
10754         ::std::mem::transmute(WSCGetProviderInfo32(::std::mem::transmute(lpproviderid), ::std::mem::transmute(infotype), ::std::mem::transmute(info), ::std::mem::transmute(infosize), ::std::mem::transmute(flags), ::std::mem::transmute(lperrno)))
10755     }
10756     #[cfg(not(windows))]
10757     unimplemented!("Unsupported target OS");
10758 }
10759 #[cfg(feature = "Win32_Foundation")]
10760 #[inline]
WSCGetProviderPath(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i3210761 pub unsafe fn WSCGetProviderPath(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32 {
10762     #[cfg(windows)]
10763     {
10764         #[link(name = "windows")]
10765         extern "system" {
10766             fn WSCGetProviderPath(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32;
10767         }
10768         ::std::mem::transmute(WSCGetProviderPath(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpszproviderdllpath), ::std::mem::transmute(lpproviderdllpathlen), ::std::mem::transmute(lperrno)))
10769     }
10770     #[cfg(not(windows))]
10771     unimplemented!("Unsupported target OS");
10772 }
10773 #[cfg(feature = "Win32_Foundation")]
10774 #[inline]
WSCGetProviderPath32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i3210775 pub unsafe fn WSCGetProviderPath32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32 {
10776     #[cfg(windows)]
10777     {
10778         #[link(name = "windows")]
10779         extern "system" {
10780             fn WSCGetProviderPath32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpproviderdllpathlen: *mut i32, lperrno: *mut i32) -> i32;
10781         }
10782         ::std::mem::transmute(WSCGetProviderPath32(::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpszproviderdllpath), ::std::mem::transmute(lpproviderdllpathlen), ::std::mem::transmute(lperrno)))
10783     }
10784     #[cfg(not(windows))]
10785     unimplemented!("Unsupported target OS");
10786 }
10787 #[cfg(feature = "Win32_Foundation")]
10788 #[inline]
WSCInstallNameSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i3210789 pub unsafe fn WSCInstallNameSpace<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i32 {
10790     #[cfg(windows)]
10791     {
10792         #[link(name = "windows")]
10793         extern "system" {
10794             fn WSCInstallNameSpace(lpszidentifier: super::super::Foundation::PWSTR, lpszpathname: super::super::Foundation::PWSTR, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i32;
10795         }
10796         ::std::mem::transmute(WSCInstallNameSpace(lpszidentifier.into_param().abi(), lpszpathname.into_param().abi(), ::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwversion), ::std::mem::transmute(lpproviderid)))
10797     }
10798     #[cfg(not(windows))]
10799     unimplemented!("Unsupported target OS");
10800 }
10801 #[cfg(feature = "Win32_Foundation")]
10802 #[inline]
WSCInstallNameSpace32<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i3210803 pub unsafe fn WSCInstallNameSpace32<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i32 {
10804     #[cfg(windows)]
10805     {
10806         #[link(name = "windows")]
10807         extern "system" {
10808             fn WSCInstallNameSpace32(lpszidentifier: super::super::Foundation::PWSTR, lpszpathname: super::super::Foundation::PWSTR, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID) -> i32;
10809         }
10810         ::std::mem::transmute(WSCInstallNameSpace32(lpszidentifier.into_param().abi(), lpszpathname.into_param().abi(), ::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwversion), ::std::mem::transmute(lpproviderid)))
10811     }
10812     #[cfg(not(windows))]
10813     unimplemented!("Unsupported target OS");
10814 }
10815 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
10816 #[inline]
WSCInstallNameSpaceEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i3210817 pub unsafe fn WSCInstallNameSpaceEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i32 {
10818     #[cfg(windows)]
10819     {
10820         #[link(name = "windows")]
10821         extern "system" {
10822             fn WSCInstallNameSpaceEx(lpszidentifier: super::super::Foundation::PWSTR, lpszpathname: super::super::Foundation::PWSTR, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i32;
10823         }
10824         ::std::mem::transmute(WSCInstallNameSpaceEx(lpszidentifier.into_param().abi(), lpszpathname.into_param().abi(), ::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwversion), ::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpproviderspecific)))
10825     }
10826     #[cfg(not(windows))]
10827     unimplemented!("Unsupported target OS");
10828 }
10829 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
10830 #[inline]
WSCInstallNameSpaceEx32<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i3210831 pub unsafe fn WSCInstallNameSpaceEx32<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpszidentifier: Param0, lpszpathname: Param1, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i32 {
10832     #[cfg(windows)]
10833     {
10834         #[link(name = "windows")]
10835         extern "system" {
10836             fn WSCInstallNameSpaceEx32(lpszidentifier: super::super::Foundation::PWSTR, lpszpathname: super::super::Foundation::PWSTR, dwnamespace: u32, dwversion: u32, lpproviderid: *const ::windows::runtime::GUID, lpproviderspecific: *const super::super::System::Com::BLOB) -> i32;
10837         }
10838         ::std::mem::transmute(WSCInstallNameSpaceEx32(lpszidentifier.into_param().abi(), lpszpathname.into_param().abi(), ::std::mem::transmute(dwnamespace), ::std::mem::transmute(dwversion), ::std::mem::transmute(lpproviderid), ::std::mem::transmute(lpproviderspecific)))
10839     }
10840     #[cfg(not(windows))]
10841     unimplemented!("Unsupported target OS");
10842 }
10843 #[cfg(feature = "Win32_Foundation")]
10844 #[inline]
WSCInstallProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i3210845 pub unsafe fn WSCInstallProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32 {
10846     #[cfg(windows)]
10847     {
10848         #[link(name = "windows")]
10849         extern "system" {
10850             fn WSCInstallProvider(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
10851         }
10852         ::std::mem::transmute(WSCInstallProvider(::std::mem::transmute(lpproviderid), lpszproviderdllpath.into_param().abi(), ::std::mem::transmute(lpprotocolinfolist), ::std::mem::transmute(dwnumberofentries), ::std::mem::transmute(lperrno)))
10853     }
10854     #[cfg(not(windows))]
10855     unimplemented!("Unsupported target OS");
10856 }
10857 #[cfg(feature = "Win32_Foundation")]
10858 #[inline]
WSCInstallProvider64_32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i3210859 pub unsafe fn WSCInstallProvider64_32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32 {
10860     #[cfg(windows)]
10861     {
10862         #[link(name = "windows")]
10863         extern "system" {
10864             fn WSCInstallProvider64_32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
10865         }
10866         ::std::mem::transmute(WSCInstallProvider64_32(::std::mem::transmute(lpproviderid), lpszproviderdllpath.into_param().abi(), ::std::mem::transmute(lpprotocolinfolist), ::std::mem::transmute(dwnumberofentries), ::std::mem::transmute(lperrno)))
10867     }
10868     #[cfg(not(windows))]
10869     unimplemented!("Unsupported target OS");
10870 }
10871 #[cfg(feature = "Win32_Foundation")]
10872 #[inline]
WSCInstallProviderAndChains64_32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpszproviderdllpath32: Param2, lpszlspname: Param3, dwserviceflags: u32, lpprotocolinfolist: *mut WSAPROTOCOL_INFOW, dwnumberofentries: u32, lpdwcatalogentryid: *mut u32, lperrno: *mut i32, ) -> i3210873 pub unsafe fn WSCInstallProviderAndChains64_32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
10874     lpproviderid: *const ::windows::runtime::GUID,
10875     lpszproviderdllpath: Param1,
10876     lpszproviderdllpath32: Param2,
10877     lpszlspname: Param3,
10878     dwserviceflags: u32,
10879     lpprotocolinfolist: *mut WSAPROTOCOL_INFOW,
10880     dwnumberofentries: u32,
10881     lpdwcatalogentryid: *mut u32,
10882     lperrno: *mut i32,
10883 ) -> i32 {
10884     #[cfg(windows)]
10885     {
10886         #[link(name = "windows")]
10887         extern "system" {
10888             fn WSCInstallProviderAndChains64_32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpszproviderdllpath32: super::super::Foundation::PWSTR, lpszlspname: super::super::Foundation::PWSTR, dwserviceflags: u32, lpprotocolinfolist: *mut WSAPROTOCOL_INFOW, dwnumberofentries: u32, lpdwcatalogentryid: *mut u32, lperrno: *mut i32) -> i32;
10889         }
10890         ::std::mem::transmute(WSCInstallProviderAndChains64_32(
10891             ::std::mem::transmute(lpproviderid),
10892             lpszproviderdllpath.into_param().abi(),
10893             lpszproviderdllpath32.into_param().abi(),
10894             lpszlspname.into_param().abi(),
10895             ::std::mem::transmute(dwserviceflags),
10896             ::std::mem::transmute(lpprotocolinfolist),
10897             ::std::mem::transmute(dwnumberofentries),
10898             ::std::mem::transmute(lpdwcatalogentryid),
10899             ::std::mem::transmute(lperrno),
10900         ))
10901     }
10902     #[cfg(not(windows))]
10903     unimplemented!("Unsupported target OS");
10904 }
10905 #[cfg(feature = "Win32_Foundation")]
10906 #[inline]
WSCSetApplicationCategory<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(path: Param0, pathlength: u32, extra: Param2, extralength: u32, permittedlspcategories: u32, pprevpermlspcat: *mut u32, lperrno: *mut i32) -> i3210907 pub unsafe fn WSCSetApplicationCategory<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(path: Param0, pathlength: u32, extra: Param2, extralength: u32, permittedlspcategories: u32, pprevpermlspcat: *mut u32, lperrno: *mut i32) -> i32 {
10908     #[cfg(windows)]
10909     {
10910         #[link(name = "windows")]
10911         extern "system" {
10912             fn WSCSetApplicationCategory(path: super::super::Foundation::PWSTR, pathlength: u32, extra: super::super::Foundation::PWSTR, extralength: u32, permittedlspcategories: u32, pprevpermlspcat: *mut u32, lperrno: *mut i32) -> i32;
10913         }
10914         ::std::mem::transmute(WSCSetApplicationCategory(path.into_param().abi(), ::std::mem::transmute(pathlength), extra.into_param().abi(), ::std::mem::transmute(extralength), ::std::mem::transmute(permittedlspcategories), ::std::mem::transmute(pprevpermlspcat), ::std::mem::transmute(lperrno)))
10915     }
10916     #[cfg(not(windows))]
10917     unimplemented!("Unsupported target OS");
10918 }
10919 #[inline]
WSCSetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i3210920 pub unsafe fn WSCSetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i32 {
10921     #[cfg(windows)]
10922     {
10923         #[link(name = "windows")]
10924         extern "system" {
10925             fn WSCSetProviderInfo(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i32;
10926         }
10927         ::std::mem::transmute(WSCSetProviderInfo(::std::mem::transmute(lpproviderid), ::std::mem::transmute(infotype), ::std::mem::transmute(info), ::std::mem::transmute(infosize), ::std::mem::transmute(flags), ::std::mem::transmute(lperrno)))
10928     }
10929     #[cfg(not(windows))]
10930     unimplemented!("Unsupported target OS");
10931 }
10932 #[inline]
WSCSetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i3210933 pub unsafe fn WSCSetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i32 {
10934     #[cfg(windows)]
10935     {
10936         #[link(name = "windows")]
10937         extern "system" {
10938             fn WSCSetProviderInfo32(lpproviderid: *const ::windows::runtime::GUID, infotype: WSC_PROVIDER_INFO_TYPE, info: *const u8, infosize: usize, flags: u32, lperrno: *mut i32) -> i32;
10939         }
10940         ::std::mem::transmute(WSCSetProviderInfo32(::std::mem::transmute(lpproviderid), ::std::mem::transmute(infotype), ::std::mem::transmute(info), ::std::mem::transmute(infosize), ::std::mem::transmute(flags), ::std::mem::transmute(lperrno)))
10941     }
10942     #[cfg(not(windows))]
10943     unimplemented!("Unsupported target OS");
10944 }
10945 #[inline]
WSCUnInstallNameSpace(lpproviderid: *const ::windows::runtime::GUID) -> i3210946 pub unsafe fn WSCUnInstallNameSpace(lpproviderid: *const ::windows::runtime::GUID) -> i32 {
10947     #[cfg(windows)]
10948     {
10949         #[link(name = "windows")]
10950         extern "system" {
10951             fn WSCUnInstallNameSpace(lpproviderid: *const ::windows::runtime::GUID) -> i32;
10952         }
10953         ::std::mem::transmute(WSCUnInstallNameSpace(::std::mem::transmute(lpproviderid)))
10954     }
10955     #[cfg(not(windows))]
10956     unimplemented!("Unsupported target OS");
10957 }
10958 #[inline]
WSCUnInstallNameSpace32(lpproviderid: *const ::windows::runtime::GUID) -> i3210959 pub unsafe fn WSCUnInstallNameSpace32(lpproviderid: *const ::windows::runtime::GUID) -> i32 {
10960     #[cfg(windows)]
10961     {
10962         #[link(name = "windows")]
10963         extern "system" {
10964             fn WSCUnInstallNameSpace32(lpproviderid: *const ::windows::runtime::GUID) -> i32;
10965         }
10966         ::std::mem::transmute(WSCUnInstallNameSpace32(::std::mem::transmute(lpproviderid)))
10967     }
10968     #[cfg(not(windows))]
10969     unimplemented!("Unsupported target OS");
10970 }
10971 #[cfg(feature = "Win32_Foundation")]
10972 #[inline]
WSCUpdateProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i3210973 pub unsafe fn WSCUpdateProvider<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32 {
10974     #[cfg(windows)]
10975     {
10976         #[link(name = "windows")]
10977         extern "system" {
10978             fn WSCUpdateProvider(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
10979         }
10980         ::std::mem::transmute(WSCUpdateProvider(::std::mem::transmute(lpproviderid), lpszproviderdllpath.into_param().abi(), ::std::mem::transmute(lpprotocolinfolist), ::std::mem::transmute(dwnumberofentries), ::std::mem::transmute(lperrno)))
10981     }
10982     #[cfg(not(windows))]
10983     unimplemented!("Unsupported target OS");
10984 }
10985 #[cfg(feature = "Win32_Foundation")]
10986 #[inline]
WSCUpdateProvider32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i3210987 pub unsafe fn WSCUpdateProvider32<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: Param1, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32 {
10988     #[cfg(windows)]
10989     {
10990         #[link(name = "windows")]
10991         extern "system" {
10992             fn WSCUpdateProvider32(lpproviderid: *const ::windows::runtime::GUID, lpszproviderdllpath: super::super::Foundation::PWSTR, lpprotocolinfolist: *const WSAPROTOCOL_INFOW, dwnumberofentries: u32, lperrno: *mut i32) -> i32;
10993         }
10994         ::std::mem::transmute(WSCUpdateProvider32(::std::mem::transmute(lpproviderid), lpszproviderdllpath.into_param().abi(), ::std::mem::transmute(lpprotocolinfolist), ::std::mem::transmute(dwnumberofentries), ::std::mem::transmute(lperrno)))
10995     }
10996     #[cfg(not(windows))]
10997     unimplemented!("Unsupported target OS");
10998 }
10999 #[inline]
WSCWriteNameSpaceOrder(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i3211000 pub unsafe fn WSCWriteNameSpaceOrder(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i32 {
11001     #[cfg(windows)]
11002     {
11003         #[link(name = "windows")]
11004         extern "system" {
11005             fn WSCWriteNameSpaceOrder(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i32;
11006         }
11007         ::std::mem::transmute(WSCWriteNameSpaceOrder(::std::mem::transmute(lpproviderid), ::std::mem::transmute(dwnumberofentries)))
11008     }
11009     #[cfg(not(windows))]
11010     unimplemented!("Unsupported target OS");
11011 }
11012 #[inline]
WSCWriteNameSpaceOrder32(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i3211013 pub unsafe fn WSCWriteNameSpaceOrder32(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i32 {
11014     #[cfg(windows)]
11015     {
11016         #[link(name = "windows")]
11017         extern "system" {
11018             fn WSCWriteNameSpaceOrder32(lpproviderid: *mut ::windows::runtime::GUID, dwnumberofentries: u32) -> i32;
11019         }
11020         ::std::mem::transmute(WSCWriteNameSpaceOrder32(::std::mem::transmute(lpproviderid), ::std::mem::transmute(dwnumberofentries)))
11021     }
11022     #[cfg(not(windows))]
11023     unimplemented!("Unsupported target OS");
11024 }
11025 #[inline]
WSCWriteProviderOrder(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i3211026 pub unsafe fn WSCWriteProviderOrder(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i32 {
11027     #[cfg(windows)]
11028     {
11029         #[link(name = "windows")]
11030         extern "system" {
11031             fn WSCWriteProviderOrder(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i32;
11032         }
11033         ::std::mem::transmute(WSCWriteProviderOrder(::std::mem::transmute(lpwdcatalogentryid), ::std::mem::transmute(dwnumberofentries)))
11034     }
11035     #[cfg(not(windows))]
11036     unimplemented!("Unsupported target OS");
11037 }
11038 #[inline]
WSCWriteProviderOrder32(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i3211039 pub unsafe fn WSCWriteProviderOrder32(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i32 {
11040     #[cfg(windows)]
11041     {
11042         #[link(name = "windows")]
11043         extern "system" {
11044             fn WSCWriteProviderOrder32(lpwdcatalogentryid: *mut u32, dwnumberofentries: u32) -> i32;
11045         }
11046         ::std::mem::transmute(WSCWriteProviderOrder32(::std::mem::transmute(lpwdcatalogentryid), ::std::mem::transmute(dwnumberofentries)))
11047     }
11048     #[cfg(not(windows))]
11049     unimplemented!("Unsupported target OS");
11050 }
11051 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11052 #[repr(C)]
11053 pub struct WSC_PROVIDER_AUDIT_INFO {
11054     pub RecordSize: u32,
11055     pub Reserved: *mut ::std::ffi::c_void,
11056 }
11057 impl WSC_PROVIDER_AUDIT_INFO {}
11058 impl ::std::default::Default for WSC_PROVIDER_AUDIT_INFO {
default() -> Self11059     fn default() -> Self {
11060         unsafe { ::std::mem::zeroed() }
11061     }
11062 }
11063 impl ::std::fmt::Debug for WSC_PROVIDER_AUDIT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11064     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11065         fmt.debug_struct("WSC_PROVIDER_AUDIT_INFO").field("RecordSize", &self.RecordSize).field("Reserved", &self.Reserved).finish()
11066     }
11067 }
11068 impl ::std::cmp::PartialEq for WSC_PROVIDER_AUDIT_INFO {
eq(&self, other: &Self) -> bool11069     fn eq(&self, other: &Self) -> bool {
11070         self.RecordSize == other.RecordSize && self.Reserved == other.Reserved
11071     }
11072 }
11073 impl ::std::cmp::Eq for WSC_PROVIDER_AUDIT_INFO {}
11074 unsafe impl ::windows::runtime::Abi for WSC_PROVIDER_AUDIT_INFO {
11075     type Abi = Self;
11076     type DefaultType = Self;
11077 }
11078 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11079 #[repr(transparent)]
11080 pub struct WSC_PROVIDER_INFO_TYPE(pub i32);
11081 pub const ProviderInfoLspCategories: WSC_PROVIDER_INFO_TYPE = WSC_PROVIDER_INFO_TYPE(0i32);
11082 pub const ProviderInfoAudit: WSC_PROVIDER_INFO_TYPE = WSC_PROVIDER_INFO_TYPE(1i32);
11083 impl ::std::convert::From<i32> for WSC_PROVIDER_INFO_TYPE {
from(value: i32) -> Self11084     fn from(value: i32) -> Self {
11085         Self(value)
11086     }
11087 }
11088 unsafe impl ::windows::runtime::Abi for WSC_PROVIDER_INFO_TYPE {
11089     type Abi = Self;
11090     type DefaultType = Self;
11091 }
11092 pub const WSK_SO_BASE: u32 = 16384u32;
11093 pub const WSPDESCRIPTION_LEN: u32 = 255u32;
11094 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11095 #[repr(C)]
11096 pub struct WSPData {
11097     pub wVersion: u16,
11098     pub wHighVersion: u16,
11099     pub szDescription: [u16; 256],
11100 }
11101 impl WSPData {}
11102 impl ::std::default::Default for WSPData {
default() -> Self11103     fn default() -> Self {
11104         unsafe { ::std::mem::zeroed() }
11105     }
11106 }
11107 impl ::std::fmt::Debug for WSPData {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11108     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11109         fmt.debug_struct("WSPData").field("wVersion", &self.wVersion).field("wHighVersion", &self.wHighVersion).field("szDescription", &self.szDescription).finish()
11110     }
11111 }
11112 impl ::std::cmp::PartialEq for WSPData {
eq(&self, other: &Self) -> bool11113     fn eq(&self, other: &Self) -> bool {
11114         self.wVersion == other.wVersion && self.wHighVersion == other.wHighVersion && self.szDescription == other.szDescription
11115     }
11116 }
11117 impl ::std::cmp::Eq for WSPData {}
11118 unsafe impl ::windows::runtime::Abi for WSPData {
11119     type Abi = Self;
11120     type DefaultType = Self;
11121 }
11122 #[derive(:: std :: clone :: Clone)]
11123 #[repr(C)]
11124 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11125 pub struct WSPPROC_TABLE {
11126     pub lpWSPAccept: ::std::option::Option<LPWSPACCEPT>,
11127     pub lpWSPAddressToString: ::std::option::Option<LPWSPADDRESSTOSTRING>,
11128     pub lpWSPAsyncSelect: ::std::option::Option<LPWSPASYNCSELECT>,
11129     pub lpWSPBind: ::std::option::Option<LPWSPBIND>,
11130     pub lpWSPCancelBlockingCall: ::std::option::Option<LPWSPCANCELBLOCKINGCALL>,
11131     pub lpWSPCleanup: ::std::option::Option<LPWSPCLEANUP>,
11132     pub lpWSPCloseSocket: ::std::option::Option<LPWSPCLOSESOCKET>,
11133     pub lpWSPConnect: ::std::option::Option<LPWSPCONNECT>,
11134     pub lpWSPDuplicateSocket: ::std::option::Option<LPWSPDUPLICATESOCKET>,
11135     pub lpWSPEnumNetworkEvents: ::std::option::Option<LPWSPENUMNETWORKEVENTS>,
11136     pub lpWSPEventSelect: ::std::option::Option<LPWSPEVENTSELECT>,
11137     pub lpWSPGetOverlappedResult: ::std::option::Option<LPWSPGETOVERLAPPEDRESULT>,
11138     pub lpWSPGetPeerName: ::std::option::Option<LPWSPGETPEERNAME>,
11139     pub lpWSPGetSockName: ::std::option::Option<LPWSPGETSOCKNAME>,
11140     pub lpWSPGetSockOpt: ::std::option::Option<LPWSPGETSOCKOPT>,
11141     pub lpWSPGetQOSByName: ::std::option::Option<LPWSPGETQOSBYNAME>,
11142     pub lpWSPIoctl: ::std::option::Option<LPWSPIOCTL>,
11143     pub lpWSPJoinLeaf: ::std::option::Option<LPWSPJOINLEAF>,
11144     pub lpWSPListen: ::std::option::Option<LPWSPLISTEN>,
11145     pub lpWSPRecv: ::std::option::Option<LPWSPRECV>,
11146     pub lpWSPRecvDisconnect: ::std::option::Option<LPWSPRECVDISCONNECT>,
11147     pub lpWSPRecvFrom: ::std::option::Option<LPWSPRECVFROM>,
11148     pub lpWSPSelect: ::std::option::Option<LPWSPSELECT>,
11149     pub lpWSPSend: ::std::option::Option<LPWSPSEND>,
11150     pub lpWSPSendDisconnect: ::std::option::Option<LPWSPSENDDISCONNECT>,
11151     pub lpWSPSendTo: ::std::option::Option<LPWSPSENDTO>,
11152     pub lpWSPSetSockOpt: ::std::option::Option<LPWSPSETSOCKOPT>,
11153     pub lpWSPShutdown: ::std::option::Option<LPWSPSHUTDOWN>,
11154     pub lpWSPSocket: ::std::option::Option<LPWSPSOCKET>,
11155     pub lpWSPStringToAddress: ::std::option::Option<LPWSPSTRINGTOADDRESS>,
11156 }
11157 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11158 impl WSPPROC_TABLE {}
11159 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11160 impl ::std::default::Default for WSPPROC_TABLE {
default() -> Self11161     fn default() -> Self {
11162         unsafe { ::std::mem::zeroed() }
11163     }
11164 }
11165 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11166 impl ::std::fmt::Debug for WSPPROC_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11167     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11168         fmt.debug_struct("WSPPROC_TABLE").finish()
11169     }
11170 }
11171 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11172 impl ::std::cmp::PartialEq for WSPPROC_TABLE {
eq(&self, other: &Self) -> bool11173     fn eq(&self, other: &Self) -> bool {
11174         self.lpWSPAccept.map(|f| f as usize) == other.lpWSPAccept.map(|f| f as usize)
11175             && self.lpWSPAddressToString.map(|f| f as usize) == other.lpWSPAddressToString.map(|f| f as usize)
11176             && self.lpWSPAsyncSelect.map(|f| f as usize) == other.lpWSPAsyncSelect.map(|f| f as usize)
11177             && self.lpWSPBind.map(|f| f as usize) == other.lpWSPBind.map(|f| f as usize)
11178             && self.lpWSPCancelBlockingCall.map(|f| f as usize) == other.lpWSPCancelBlockingCall.map(|f| f as usize)
11179             && self.lpWSPCleanup.map(|f| f as usize) == other.lpWSPCleanup.map(|f| f as usize)
11180             && self.lpWSPCloseSocket.map(|f| f as usize) == other.lpWSPCloseSocket.map(|f| f as usize)
11181             && self.lpWSPConnect.map(|f| f as usize) == other.lpWSPConnect.map(|f| f as usize)
11182             && self.lpWSPDuplicateSocket.map(|f| f as usize) == other.lpWSPDuplicateSocket.map(|f| f as usize)
11183             && self.lpWSPEnumNetworkEvents.map(|f| f as usize) == other.lpWSPEnumNetworkEvents.map(|f| f as usize)
11184             && self.lpWSPEventSelect.map(|f| f as usize) == other.lpWSPEventSelect.map(|f| f as usize)
11185             && self.lpWSPGetOverlappedResult.map(|f| f as usize) == other.lpWSPGetOverlappedResult.map(|f| f as usize)
11186             && self.lpWSPGetPeerName.map(|f| f as usize) == other.lpWSPGetPeerName.map(|f| f as usize)
11187             && self.lpWSPGetSockName.map(|f| f as usize) == other.lpWSPGetSockName.map(|f| f as usize)
11188             && self.lpWSPGetSockOpt.map(|f| f as usize) == other.lpWSPGetSockOpt.map(|f| f as usize)
11189             && self.lpWSPGetQOSByName.map(|f| f as usize) == other.lpWSPGetQOSByName.map(|f| f as usize)
11190             && self.lpWSPIoctl.map(|f| f as usize) == other.lpWSPIoctl.map(|f| f as usize)
11191             && self.lpWSPJoinLeaf.map(|f| f as usize) == other.lpWSPJoinLeaf.map(|f| f as usize)
11192             && self.lpWSPListen.map(|f| f as usize) == other.lpWSPListen.map(|f| f as usize)
11193             && self.lpWSPRecv.map(|f| f as usize) == other.lpWSPRecv.map(|f| f as usize)
11194             && self.lpWSPRecvDisconnect.map(|f| f as usize) == other.lpWSPRecvDisconnect.map(|f| f as usize)
11195             && self.lpWSPRecvFrom.map(|f| f as usize) == other.lpWSPRecvFrom.map(|f| f as usize)
11196             && self.lpWSPSelect.map(|f| f as usize) == other.lpWSPSelect.map(|f| f as usize)
11197             && self.lpWSPSend.map(|f| f as usize) == other.lpWSPSend.map(|f| f as usize)
11198             && self.lpWSPSendDisconnect.map(|f| f as usize) == other.lpWSPSendDisconnect.map(|f| f as usize)
11199             && self.lpWSPSendTo.map(|f| f as usize) == other.lpWSPSendTo.map(|f| f as usize)
11200             && self.lpWSPSetSockOpt.map(|f| f as usize) == other.lpWSPSetSockOpt.map(|f| f as usize)
11201             && self.lpWSPShutdown.map(|f| f as usize) == other.lpWSPShutdown.map(|f| f as usize)
11202             && self.lpWSPSocket.map(|f| f as usize) == other.lpWSPSocket.map(|f| f as usize)
11203             && self.lpWSPStringToAddress.map(|f| f as usize) == other.lpWSPStringToAddress.map(|f| f as usize)
11204     }
11205 }
11206 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11207 impl ::std::cmp::Eq for WSPPROC_TABLE {}
11208 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_NetworkManagement_QoS", feature = "Win32_System_IO"))]
11209 unsafe impl ::windows::runtime::Abi for WSPPROC_TABLE {
11210     type Abi = ::std::mem::ManuallyDrop<Self>;
11211     type DefaultType = Self;
11212 }
11213 #[derive(:: std :: clone :: Clone)]
11214 #[repr(C)]
11215 #[cfg(feature = "Win32_Foundation")]
11216 pub struct WSPUPCALLTABLE {
11217     pub lpWPUCloseEvent: ::std::option::Option<LPWPUCLOSEEVENT>,
11218     pub lpWPUCloseSocketHandle: ::std::option::Option<LPWPUCLOSESOCKETHANDLE>,
11219     pub lpWPUCreateEvent: ::std::option::Option<LPWPUCREATEEVENT>,
11220     pub lpWPUCreateSocketHandle: ::std::option::Option<LPWPUCREATESOCKETHANDLE>,
11221     pub lpWPUFDIsSet: ::std::option::Option<LPWPUFDISSET>,
11222     pub lpWPUGetProviderPath: ::std::option::Option<LPWPUGETPROVIDERPATH>,
11223     pub lpWPUModifyIFSHandle: ::std::option::Option<LPWPUMODIFYIFSHANDLE>,
11224     pub lpWPUPostMessage: ::std::option::Option<LPWPUPOSTMESSAGE>,
11225     pub lpWPUQueryBlockingCallback: ::std::option::Option<LPWPUQUERYBLOCKINGCALLBACK>,
11226     pub lpWPUQuerySocketHandleContext: ::std::option::Option<LPWPUQUERYSOCKETHANDLECONTEXT>,
11227     pub lpWPUQueueApc: ::std::option::Option<LPWPUQUEUEAPC>,
11228     pub lpWPUResetEvent: ::std::option::Option<LPWPURESETEVENT>,
11229     pub lpWPUSetEvent: ::std::option::Option<LPWPUSETEVENT>,
11230     pub lpWPUOpenCurrentThread: ::std::option::Option<LPWPUOPENCURRENTTHREAD>,
11231     pub lpWPUCloseThread: ::std::option::Option<LPWPUCLOSETHREAD>,
11232 }
11233 #[cfg(feature = "Win32_Foundation")]
11234 impl WSPUPCALLTABLE {}
11235 #[cfg(feature = "Win32_Foundation")]
11236 impl ::std::default::Default for WSPUPCALLTABLE {
default() -> Self11237     fn default() -> Self {
11238         unsafe { ::std::mem::zeroed() }
11239     }
11240 }
11241 #[cfg(feature = "Win32_Foundation")]
11242 impl ::std::fmt::Debug for WSPUPCALLTABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11243     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11244         fmt.debug_struct("WSPUPCALLTABLE").finish()
11245     }
11246 }
11247 #[cfg(feature = "Win32_Foundation")]
11248 impl ::std::cmp::PartialEq for WSPUPCALLTABLE {
eq(&self, other: &Self) -> bool11249     fn eq(&self, other: &Self) -> bool {
11250         self.lpWPUCloseEvent.map(|f| f as usize) == other.lpWPUCloseEvent.map(|f| f as usize)
11251             && self.lpWPUCloseSocketHandle.map(|f| f as usize) == other.lpWPUCloseSocketHandle.map(|f| f as usize)
11252             && self.lpWPUCreateEvent.map(|f| f as usize) == other.lpWPUCreateEvent.map(|f| f as usize)
11253             && self.lpWPUCreateSocketHandle.map(|f| f as usize) == other.lpWPUCreateSocketHandle.map(|f| f as usize)
11254             && self.lpWPUFDIsSet.map(|f| f as usize) == other.lpWPUFDIsSet.map(|f| f as usize)
11255             && self.lpWPUGetProviderPath.map(|f| f as usize) == other.lpWPUGetProviderPath.map(|f| f as usize)
11256             && self.lpWPUModifyIFSHandle.map(|f| f as usize) == other.lpWPUModifyIFSHandle.map(|f| f as usize)
11257             && self.lpWPUPostMessage.map(|f| f as usize) == other.lpWPUPostMessage.map(|f| f as usize)
11258             && self.lpWPUQueryBlockingCallback.map(|f| f as usize) == other.lpWPUQueryBlockingCallback.map(|f| f as usize)
11259             && self.lpWPUQuerySocketHandleContext.map(|f| f as usize) == other.lpWPUQuerySocketHandleContext.map(|f| f as usize)
11260             && self.lpWPUQueueApc.map(|f| f as usize) == other.lpWPUQueueApc.map(|f| f as usize)
11261             && self.lpWPUResetEvent.map(|f| f as usize) == other.lpWPUResetEvent.map(|f| f as usize)
11262             && self.lpWPUSetEvent.map(|f| f as usize) == other.lpWPUSetEvent.map(|f| f as usize)
11263             && self.lpWPUOpenCurrentThread.map(|f| f as usize) == other.lpWPUOpenCurrentThread.map(|f| f as usize)
11264             && self.lpWPUCloseThread.map(|f| f as usize) == other.lpWPUCloseThread.map(|f| f as usize)
11265     }
11266 }
11267 #[cfg(feature = "Win32_Foundation")]
11268 impl ::std::cmp::Eq for WSPUPCALLTABLE {}
11269 #[cfg(feature = "Win32_Foundation")]
11270 unsafe impl ::windows::runtime::Abi for WSPUPCALLTABLE {
11271     type Abi = ::std::mem::ManuallyDrop<Self>;
11272     type DefaultType = Self;
11273 }
11274 pub const WSS_OPERATION_IN_PROGRESS: i32 = 259i32;
11275 pub const XP1_CONNECTIONLESS: u32 = 1u32;
11276 pub const XP1_CONNECT_DATA: u32 = 128u32;
11277 pub const XP1_DISCONNECT_DATA: u32 = 256u32;
11278 pub const XP1_EXPEDITED_DATA: u32 = 64u32;
11279 pub const XP1_GRACEFUL_CLOSE: u32 = 32u32;
11280 pub const XP1_GUARANTEED_DELIVERY: u32 = 2u32;
11281 pub const XP1_GUARANTEED_ORDER: u32 = 4u32;
11282 pub const XP1_IFS_HANDLES: u32 = 131072u32;
11283 pub const XP1_INTERRUPT: u32 = 16384u32;
11284 pub const XP1_MESSAGE_ORIENTED: u32 = 8u32;
11285 pub const XP1_MULTIPOINT_CONTROL_PLANE: u32 = 2048u32;
11286 pub const XP1_MULTIPOINT_DATA_PLANE: u32 = 4096u32;
11287 pub const XP1_PARTIAL_MESSAGE: u32 = 262144u32;
11288 pub const XP1_PSEUDO_STREAM: u32 = 16u32;
11289 pub const XP1_QOS_SUPPORTED: u32 = 8192u32;
11290 pub const XP1_SAN_SUPPORT_SDP: u32 = 524288u32;
11291 pub const XP1_SUPPORT_BROADCAST: u32 = 512u32;
11292 pub const XP1_SUPPORT_MULTIPOINT: u32 = 1024u32;
11293 pub const XP1_UNI_RECV: u32 = 65536u32;
11294 pub const XP1_UNI_SEND: u32 = 32768u32;
11295 pub const XP_BANDWIDTH_ALLOCATION: u32 = 2048u32;
11296 pub const XP_CONNECTIONLESS: u32 = 1u32;
11297 pub const XP_CONNECT_DATA: u32 = 128u32;
11298 pub const XP_DISCONNECT_DATA: u32 = 256u32;
11299 pub const XP_ENCRYPTS: u32 = 8192u32;
11300 pub const XP_EXPEDITED_DATA: u32 = 64u32;
11301 pub const XP_FRAGMENTATION: u32 = 4096u32;
11302 pub const XP_GRACEFUL_CLOSE: u32 = 32u32;
11303 pub const XP_GUARANTEED_DELIVERY: u32 = 2u32;
11304 pub const XP_GUARANTEED_ORDER: u32 = 4u32;
11305 pub const XP_MESSAGE_ORIENTED: u32 = 8u32;
11306 pub const XP_PSEUDO_STREAM: u32 = 16u32;
11307 pub const XP_SUPPORTS_BROADCAST: u32 = 512u32;
11308 pub const XP_SUPPORTS_MULTICAST: u32 = 1024u32;
11309 pub const _SS_MAXSIZE: u32 = 128u32;
11310 #[inline]
__WSAFDIsSet<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(fd: Param0, param1: *mut fd_set) -> i3211311 pub unsafe fn __WSAFDIsSet<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(fd: Param0, param1: *mut fd_set) -> i32 {
11312     #[cfg(windows)]
11313     {
11314         #[link(name = "windows")]
11315         extern "system" {
11316             fn __WSAFDIsSet(fd: SOCKET, param1: *mut fd_set) -> i32;
11317         }
11318         ::std::mem::transmute(__WSAFDIsSet(fd.into_param().abi(), ::std::mem::transmute(param1)))
11319     }
11320     #[cfg(not(windows))]
11321     unimplemented!("Unsupported target OS");
11322 }
11323 #[cfg(feature = "Win32_Foundation")]
11324 #[inline]
accept<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, addr: *mut SOCKADDR, addrlen: *mut i32) -> SOCKET11325 pub unsafe fn accept<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, addr: *mut SOCKADDR, addrlen: *mut i32) -> SOCKET {
11326     #[cfg(windows)]
11327     {
11328         #[link(name = "windows")]
11329         extern "system" {
11330             fn accept(s: SOCKET, addr: *mut SOCKADDR, addrlen: *mut i32) -> SOCKET;
11331         }
11332         ::std::mem::transmute(accept(s.into_param().abi(), ::std::mem::transmute(addr), ::std::mem::transmute(addrlen)))
11333     }
11334     #[cfg(not(windows))]
11335     unimplemented!("Unsupported target OS");
11336 }
11337 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11338 #[repr(C)]
11339 #[cfg(feature = "Win32_Foundation")]
11340 pub struct addrinfoW {
11341     pub ai_flags: i32,
11342     pub ai_family: i32,
11343     pub ai_socktype: i32,
11344     pub ai_protocol: i32,
11345     pub ai_addrlen: usize,
11346     pub ai_canonname: super::super::Foundation::PWSTR,
11347     pub ai_addr: *mut SOCKADDR,
11348     pub ai_next: *mut addrinfoW,
11349 }
11350 #[cfg(feature = "Win32_Foundation")]
11351 impl addrinfoW {}
11352 #[cfg(feature = "Win32_Foundation")]
11353 impl ::std::default::Default for addrinfoW {
default() -> Self11354     fn default() -> Self {
11355         unsafe { ::std::mem::zeroed() }
11356     }
11357 }
11358 #[cfg(feature = "Win32_Foundation")]
11359 impl ::std::fmt::Debug for addrinfoW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11360     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11361         fmt.debug_struct("addrinfoW")
11362             .field("ai_flags", &self.ai_flags)
11363             .field("ai_family", &self.ai_family)
11364             .field("ai_socktype", &self.ai_socktype)
11365             .field("ai_protocol", &self.ai_protocol)
11366             .field("ai_addrlen", &self.ai_addrlen)
11367             .field("ai_canonname", &self.ai_canonname)
11368             .field("ai_addr", &self.ai_addr)
11369             .field("ai_next", &self.ai_next)
11370             .finish()
11371     }
11372 }
11373 #[cfg(feature = "Win32_Foundation")]
11374 impl ::std::cmp::PartialEq for addrinfoW {
eq(&self, other: &Self) -> bool11375     fn eq(&self, other: &Self) -> bool {
11376         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_next == other.ai_next
11377     }
11378 }
11379 #[cfg(feature = "Win32_Foundation")]
11380 impl ::std::cmp::Eq for addrinfoW {}
11381 #[cfg(feature = "Win32_Foundation")]
11382 unsafe impl ::windows::runtime::Abi for addrinfoW {
11383     type Abi = Self;
11384     type DefaultType = Self;
11385 }
11386 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11387 #[repr(C)]
11388 #[cfg(feature = "Win32_Foundation")]
11389 pub struct addrinfo_dns_server {
11390     pub ai_servertype: u32,
11391     pub ai_flags: u64,
11392     pub ai_addrlen: u32,
11393     pub ai_addr: *mut SOCKADDR,
11394     pub Anonymous: addrinfo_dns_server_0,
11395 }
11396 #[cfg(feature = "Win32_Foundation")]
11397 impl addrinfo_dns_server {}
11398 #[cfg(feature = "Win32_Foundation")]
11399 impl ::std::default::Default for addrinfo_dns_server {
default() -> Self11400     fn default() -> Self {
11401         unsafe { ::std::mem::zeroed() }
11402     }
11403 }
11404 #[cfg(feature = "Win32_Foundation")]
11405 impl ::std::cmp::PartialEq for addrinfo_dns_server {
eq(&self, _other: &Self) -> bool11406     fn eq(&self, _other: &Self) -> bool {
11407         unimplemented!()
11408     }
11409 }
11410 #[cfg(feature = "Win32_Foundation")]
11411 impl ::std::cmp::Eq for addrinfo_dns_server {}
11412 #[cfg(feature = "Win32_Foundation")]
11413 unsafe impl ::windows::runtime::Abi for addrinfo_dns_server {
11414     type Abi = Self;
11415     type DefaultType = Self;
11416 }
11417 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11418 #[repr(C)]
11419 #[cfg(feature = "Win32_Foundation")]
11420 pub union addrinfo_dns_server_0 {
11421     pub ai_template: super::super::Foundation::PWSTR,
11422 }
11423 #[cfg(feature = "Win32_Foundation")]
11424 impl addrinfo_dns_server_0 {}
11425 #[cfg(feature = "Win32_Foundation")]
11426 impl ::std::default::Default for addrinfo_dns_server_0 {
default() -> Self11427     fn default() -> Self {
11428         unsafe { ::std::mem::zeroed() }
11429     }
11430 }
11431 #[cfg(feature = "Win32_Foundation")]
11432 impl ::std::cmp::PartialEq for addrinfo_dns_server_0 {
eq(&self, _other: &Self) -> bool11433     fn eq(&self, _other: &Self) -> bool {
11434         unimplemented!()
11435     }
11436 }
11437 #[cfg(feature = "Win32_Foundation")]
11438 impl ::std::cmp::Eq for addrinfo_dns_server_0 {}
11439 #[cfg(feature = "Win32_Foundation")]
11440 unsafe impl ::windows::runtime::Abi for addrinfo_dns_server_0 {
11441     type Abi = Self;
11442     type DefaultType = Self;
11443 }
11444 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11445 #[repr(C)]
11446 #[cfg(feature = "Win32_Foundation")]
11447 pub struct addrinfoex2A {
11448     pub ai_flags: i32,
11449     pub ai_family: i32,
11450     pub ai_socktype: i32,
11451     pub ai_protocol: i32,
11452     pub ai_addrlen: usize,
11453     pub ai_canonname: super::super::Foundation::PSTR,
11454     pub ai_addr: *mut SOCKADDR,
11455     pub ai_blob: *mut ::std::ffi::c_void,
11456     pub ai_bloblen: usize,
11457     pub ai_provider: *mut ::windows::runtime::GUID,
11458     pub ai_next: *mut addrinfoex2A,
11459     pub ai_version: i32,
11460     pub ai_fqdn: super::super::Foundation::PSTR,
11461 }
11462 #[cfg(feature = "Win32_Foundation")]
11463 impl addrinfoex2A {}
11464 #[cfg(feature = "Win32_Foundation")]
11465 impl ::std::default::Default for addrinfoex2A {
default() -> Self11466     fn default() -> Self {
11467         unsafe { ::std::mem::zeroed() }
11468     }
11469 }
11470 #[cfg(feature = "Win32_Foundation")]
11471 impl ::std::fmt::Debug for addrinfoex2A {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11472     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11473         fmt.debug_struct("addrinfoex2A")
11474             .field("ai_flags", &self.ai_flags)
11475             .field("ai_family", &self.ai_family)
11476             .field("ai_socktype", &self.ai_socktype)
11477             .field("ai_protocol", &self.ai_protocol)
11478             .field("ai_addrlen", &self.ai_addrlen)
11479             .field("ai_canonname", &self.ai_canonname)
11480             .field("ai_addr", &self.ai_addr)
11481             .field("ai_blob", &self.ai_blob)
11482             .field("ai_bloblen", &self.ai_bloblen)
11483             .field("ai_provider", &self.ai_provider)
11484             .field("ai_next", &self.ai_next)
11485             .field("ai_version", &self.ai_version)
11486             .field("ai_fqdn", &self.ai_fqdn)
11487             .finish()
11488     }
11489 }
11490 #[cfg(feature = "Win32_Foundation")]
11491 impl ::std::cmp::PartialEq for addrinfoex2A {
eq(&self, other: &Self) -> bool11492     fn eq(&self, other: &Self) -> bool {
11493         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_blob == other.ai_blob && self.ai_bloblen == other.ai_bloblen && self.ai_provider == other.ai_provider && self.ai_next == other.ai_next && self.ai_version == other.ai_version && self.ai_fqdn == other.ai_fqdn
11494     }
11495 }
11496 #[cfg(feature = "Win32_Foundation")]
11497 impl ::std::cmp::Eq for addrinfoex2A {}
11498 #[cfg(feature = "Win32_Foundation")]
11499 unsafe impl ::windows::runtime::Abi for addrinfoex2A {
11500     type Abi = Self;
11501     type DefaultType = Self;
11502 }
11503 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11504 #[repr(C)]
11505 #[cfg(feature = "Win32_Foundation")]
11506 pub struct addrinfoex2W {
11507     pub ai_flags: i32,
11508     pub ai_family: i32,
11509     pub ai_socktype: i32,
11510     pub ai_protocol: i32,
11511     pub ai_addrlen: usize,
11512     pub ai_canonname: super::super::Foundation::PWSTR,
11513     pub ai_addr: *mut SOCKADDR,
11514     pub ai_blob: *mut ::std::ffi::c_void,
11515     pub ai_bloblen: usize,
11516     pub ai_provider: *mut ::windows::runtime::GUID,
11517     pub ai_next: *mut addrinfoex2W,
11518     pub ai_version: i32,
11519     pub ai_fqdn: super::super::Foundation::PWSTR,
11520 }
11521 #[cfg(feature = "Win32_Foundation")]
11522 impl addrinfoex2W {}
11523 #[cfg(feature = "Win32_Foundation")]
11524 impl ::std::default::Default for addrinfoex2W {
default() -> Self11525     fn default() -> Self {
11526         unsafe { ::std::mem::zeroed() }
11527     }
11528 }
11529 #[cfg(feature = "Win32_Foundation")]
11530 impl ::std::fmt::Debug for addrinfoex2W {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11531     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11532         fmt.debug_struct("addrinfoex2W")
11533             .field("ai_flags", &self.ai_flags)
11534             .field("ai_family", &self.ai_family)
11535             .field("ai_socktype", &self.ai_socktype)
11536             .field("ai_protocol", &self.ai_protocol)
11537             .field("ai_addrlen", &self.ai_addrlen)
11538             .field("ai_canonname", &self.ai_canonname)
11539             .field("ai_addr", &self.ai_addr)
11540             .field("ai_blob", &self.ai_blob)
11541             .field("ai_bloblen", &self.ai_bloblen)
11542             .field("ai_provider", &self.ai_provider)
11543             .field("ai_next", &self.ai_next)
11544             .field("ai_version", &self.ai_version)
11545             .field("ai_fqdn", &self.ai_fqdn)
11546             .finish()
11547     }
11548 }
11549 #[cfg(feature = "Win32_Foundation")]
11550 impl ::std::cmp::PartialEq for addrinfoex2W {
eq(&self, other: &Self) -> bool11551     fn eq(&self, other: &Self) -> bool {
11552         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_blob == other.ai_blob && self.ai_bloblen == other.ai_bloblen && self.ai_provider == other.ai_provider && self.ai_next == other.ai_next && self.ai_version == other.ai_version && self.ai_fqdn == other.ai_fqdn
11553     }
11554 }
11555 #[cfg(feature = "Win32_Foundation")]
11556 impl ::std::cmp::Eq for addrinfoex2W {}
11557 #[cfg(feature = "Win32_Foundation")]
11558 unsafe impl ::windows::runtime::Abi for addrinfoex2W {
11559     type Abi = Self;
11560     type DefaultType = Self;
11561 }
11562 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11563 #[repr(C)]
11564 #[cfg(feature = "Win32_Foundation")]
11565 pub struct addrinfoex3 {
11566     pub ai_flags: i32,
11567     pub ai_family: i32,
11568     pub ai_socktype: i32,
11569     pub ai_protocol: i32,
11570     pub ai_addrlen: usize,
11571     pub ai_canonname: super::super::Foundation::PWSTR,
11572     pub ai_addr: *mut SOCKADDR,
11573     pub ai_blob: *mut ::std::ffi::c_void,
11574     pub ai_bloblen: usize,
11575     pub ai_provider: *mut ::windows::runtime::GUID,
11576     pub ai_next: *mut addrinfoex3,
11577     pub ai_version: i32,
11578     pub ai_fqdn: super::super::Foundation::PWSTR,
11579     pub ai_interfaceindex: i32,
11580 }
11581 #[cfg(feature = "Win32_Foundation")]
11582 impl addrinfoex3 {}
11583 #[cfg(feature = "Win32_Foundation")]
11584 impl ::std::default::Default for addrinfoex3 {
default() -> Self11585     fn default() -> Self {
11586         unsafe { ::std::mem::zeroed() }
11587     }
11588 }
11589 #[cfg(feature = "Win32_Foundation")]
11590 impl ::std::fmt::Debug for addrinfoex3 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11591     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11592         fmt.debug_struct("addrinfoex3")
11593             .field("ai_flags", &self.ai_flags)
11594             .field("ai_family", &self.ai_family)
11595             .field("ai_socktype", &self.ai_socktype)
11596             .field("ai_protocol", &self.ai_protocol)
11597             .field("ai_addrlen", &self.ai_addrlen)
11598             .field("ai_canonname", &self.ai_canonname)
11599             .field("ai_addr", &self.ai_addr)
11600             .field("ai_blob", &self.ai_blob)
11601             .field("ai_bloblen", &self.ai_bloblen)
11602             .field("ai_provider", &self.ai_provider)
11603             .field("ai_next", &self.ai_next)
11604             .field("ai_version", &self.ai_version)
11605             .field("ai_fqdn", &self.ai_fqdn)
11606             .field("ai_interfaceindex", &self.ai_interfaceindex)
11607             .finish()
11608     }
11609 }
11610 #[cfg(feature = "Win32_Foundation")]
11611 impl ::std::cmp::PartialEq for addrinfoex3 {
eq(&self, other: &Self) -> bool11612     fn eq(&self, other: &Self) -> bool {
11613         self.ai_flags == other.ai_flags
11614             && self.ai_family == other.ai_family
11615             && self.ai_socktype == other.ai_socktype
11616             && self.ai_protocol == other.ai_protocol
11617             && self.ai_addrlen == other.ai_addrlen
11618             && self.ai_canonname == other.ai_canonname
11619             && self.ai_addr == other.ai_addr
11620             && self.ai_blob == other.ai_blob
11621             && self.ai_bloblen == other.ai_bloblen
11622             && self.ai_provider == other.ai_provider
11623             && self.ai_next == other.ai_next
11624             && self.ai_version == other.ai_version
11625             && self.ai_fqdn == other.ai_fqdn
11626             && self.ai_interfaceindex == other.ai_interfaceindex
11627     }
11628 }
11629 #[cfg(feature = "Win32_Foundation")]
11630 impl ::std::cmp::Eq for addrinfoex3 {}
11631 #[cfg(feature = "Win32_Foundation")]
11632 unsafe impl ::windows::runtime::Abi for addrinfoex3 {
11633     type Abi = Self;
11634     type DefaultType = Self;
11635 }
11636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11637 #[repr(C)]
11638 #[cfg(feature = "Win32_Foundation")]
11639 pub struct addrinfoex4 {
11640     pub ai_flags: i32,
11641     pub ai_family: i32,
11642     pub ai_socktype: i32,
11643     pub ai_protocol: i32,
11644     pub ai_addrlen: usize,
11645     pub ai_canonname: super::super::Foundation::PWSTR,
11646     pub ai_addr: *mut SOCKADDR,
11647     pub ai_blob: *mut ::std::ffi::c_void,
11648     pub ai_bloblen: usize,
11649     pub ai_provider: *mut ::windows::runtime::GUID,
11650     pub ai_next: *mut addrinfoex4,
11651     pub ai_version: i32,
11652     pub ai_fqdn: super::super::Foundation::PWSTR,
11653     pub ai_interfaceindex: i32,
11654     pub ai_resolutionhandle: super::super::Foundation::HANDLE,
11655 }
11656 #[cfg(feature = "Win32_Foundation")]
11657 impl addrinfoex4 {}
11658 #[cfg(feature = "Win32_Foundation")]
11659 impl ::std::default::Default for addrinfoex4 {
default() -> Self11660     fn default() -> Self {
11661         unsafe { ::std::mem::zeroed() }
11662     }
11663 }
11664 #[cfg(feature = "Win32_Foundation")]
11665 impl ::std::fmt::Debug for addrinfoex4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11666     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11667         fmt.debug_struct("addrinfoex4")
11668             .field("ai_flags", &self.ai_flags)
11669             .field("ai_family", &self.ai_family)
11670             .field("ai_socktype", &self.ai_socktype)
11671             .field("ai_protocol", &self.ai_protocol)
11672             .field("ai_addrlen", &self.ai_addrlen)
11673             .field("ai_canonname", &self.ai_canonname)
11674             .field("ai_addr", &self.ai_addr)
11675             .field("ai_blob", &self.ai_blob)
11676             .field("ai_bloblen", &self.ai_bloblen)
11677             .field("ai_provider", &self.ai_provider)
11678             .field("ai_next", &self.ai_next)
11679             .field("ai_version", &self.ai_version)
11680             .field("ai_fqdn", &self.ai_fqdn)
11681             .field("ai_interfaceindex", &self.ai_interfaceindex)
11682             .field("ai_resolutionhandle", &self.ai_resolutionhandle)
11683             .finish()
11684     }
11685 }
11686 #[cfg(feature = "Win32_Foundation")]
11687 impl ::std::cmp::PartialEq for addrinfoex4 {
eq(&self, other: &Self) -> bool11688     fn eq(&self, other: &Self) -> bool {
11689         self.ai_flags == other.ai_flags
11690             && self.ai_family == other.ai_family
11691             && self.ai_socktype == other.ai_socktype
11692             && self.ai_protocol == other.ai_protocol
11693             && self.ai_addrlen == other.ai_addrlen
11694             && self.ai_canonname == other.ai_canonname
11695             && self.ai_addr == other.ai_addr
11696             && self.ai_blob == other.ai_blob
11697             && self.ai_bloblen == other.ai_bloblen
11698             && self.ai_provider == other.ai_provider
11699             && self.ai_next == other.ai_next
11700             && self.ai_version == other.ai_version
11701             && self.ai_fqdn == other.ai_fqdn
11702             && self.ai_interfaceindex == other.ai_interfaceindex
11703             && self.ai_resolutionhandle == other.ai_resolutionhandle
11704     }
11705 }
11706 #[cfg(feature = "Win32_Foundation")]
11707 impl ::std::cmp::Eq for addrinfoex4 {}
11708 #[cfg(feature = "Win32_Foundation")]
11709 unsafe impl ::windows::runtime::Abi for addrinfoex4 {
11710     type Abi = Self;
11711     type DefaultType = Self;
11712 }
11713 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11714 #[repr(C)]
11715 #[cfg(feature = "Win32_Foundation")]
11716 pub struct addrinfoex5 {
11717     pub ai_flags: i32,
11718     pub ai_family: i32,
11719     pub ai_socktype: i32,
11720     pub ai_protocol: i32,
11721     pub ai_addrlen: usize,
11722     pub ai_canonname: super::super::Foundation::PWSTR,
11723     pub ai_addr: *mut SOCKADDR,
11724     pub ai_blob: *mut ::std::ffi::c_void,
11725     pub ai_bloblen: usize,
11726     pub ai_provider: *mut ::windows::runtime::GUID,
11727     pub ai_next: *mut addrinfoex5,
11728     pub ai_version: i32,
11729     pub ai_fqdn: super::super::Foundation::PWSTR,
11730     pub ai_interfaceindex: i32,
11731     pub ai_resolutionhandle: super::super::Foundation::HANDLE,
11732     pub ai_ttl: u32,
11733 }
11734 #[cfg(feature = "Win32_Foundation")]
11735 impl addrinfoex5 {}
11736 #[cfg(feature = "Win32_Foundation")]
11737 impl ::std::default::Default for addrinfoex5 {
default() -> Self11738     fn default() -> Self {
11739         unsafe { ::std::mem::zeroed() }
11740     }
11741 }
11742 #[cfg(feature = "Win32_Foundation")]
11743 impl ::std::fmt::Debug for addrinfoex5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11744     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11745         fmt.debug_struct("addrinfoex5")
11746             .field("ai_flags", &self.ai_flags)
11747             .field("ai_family", &self.ai_family)
11748             .field("ai_socktype", &self.ai_socktype)
11749             .field("ai_protocol", &self.ai_protocol)
11750             .field("ai_addrlen", &self.ai_addrlen)
11751             .field("ai_canonname", &self.ai_canonname)
11752             .field("ai_addr", &self.ai_addr)
11753             .field("ai_blob", &self.ai_blob)
11754             .field("ai_bloblen", &self.ai_bloblen)
11755             .field("ai_provider", &self.ai_provider)
11756             .field("ai_next", &self.ai_next)
11757             .field("ai_version", &self.ai_version)
11758             .field("ai_fqdn", &self.ai_fqdn)
11759             .field("ai_interfaceindex", &self.ai_interfaceindex)
11760             .field("ai_resolutionhandle", &self.ai_resolutionhandle)
11761             .field("ai_ttl", &self.ai_ttl)
11762             .finish()
11763     }
11764 }
11765 #[cfg(feature = "Win32_Foundation")]
11766 impl ::std::cmp::PartialEq for addrinfoex5 {
eq(&self, other: &Self) -> bool11767     fn eq(&self, other: &Self) -> bool {
11768         self.ai_flags == other.ai_flags
11769             && self.ai_family == other.ai_family
11770             && self.ai_socktype == other.ai_socktype
11771             && self.ai_protocol == other.ai_protocol
11772             && self.ai_addrlen == other.ai_addrlen
11773             && self.ai_canonname == other.ai_canonname
11774             && self.ai_addr == other.ai_addr
11775             && self.ai_blob == other.ai_blob
11776             && self.ai_bloblen == other.ai_bloblen
11777             && self.ai_provider == other.ai_provider
11778             && self.ai_next == other.ai_next
11779             && self.ai_version == other.ai_version
11780             && self.ai_fqdn == other.ai_fqdn
11781             && self.ai_interfaceindex == other.ai_interfaceindex
11782             && self.ai_resolutionhandle == other.ai_resolutionhandle
11783             && self.ai_ttl == other.ai_ttl
11784     }
11785 }
11786 #[cfg(feature = "Win32_Foundation")]
11787 impl ::std::cmp::Eq for addrinfoex5 {}
11788 #[cfg(feature = "Win32_Foundation")]
11789 unsafe impl ::windows::runtime::Abi for addrinfoex5 {
11790     type Abi = Self;
11791     type DefaultType = Self;
11792 }
11793 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11794 #[repr(C)]
11795 #[cfg(feature = "Win32_Foundation")]
11796 pub struct addrinfoex6 {
11797     pub ai_flags: i32,
11798     pub ai_family: i32,
11799     pub ai_socktype: i32,
11800     pub ai_protocol: i32,
11801     pub ai_addrlen: usize,
11802     pub ai_canonname: super::super::Foundation::PWSTR,
11803     pub ai_addr: *mut SOCKADDR,
11804     pub ai_blob: *mut ::std::ffi::c_void,
11805     pub ai_bloblen: usize,
11806     pub ai_provider: *mut ::windows::runtime::GUID,
11807     pub ai_next: *mut addrinfoex5,
11808     pub ai_version: i32,
11809     pub ai_fqdn: super::super::Foundation::PWSTR,
11810     pub ai_interfaceindex: i32,
11811     pub ai_resolutionhandle: super::super::Foundation::HANDLE,
11812     pub ai_ttl: u32,
11813     pub ai_numservers: u32,
11814     pub ai_servers: *mut addrinfo_dns_server,
11815     pub ai_responseflags: u64,
11816 }
11817 #[cfg(feature = "Win32_Foundation")]
11818 impl addrinfoex6 {}
11819 #[cfg(feature = "Win32_Foundation")]
11820 impl ::std::default::Default for addrinfoex6 {
default() -> Self11821     fn default() -> Self {
11822         unsafe { ::std::mem::zeroed() }
11823     }
11824 }
11825 #[cfg(feature = "Win32_Foundation")]
11826 impl ::std::fmt::Debug for addrinfoex6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11827     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11828         fmt.debug_struct("addrinfoex6")
11829             .field("ai_flags", &self.ai_flags)
11830             .field("ai_family", &self.ai_family)
11831             .field("ai_socktype", &self.ai_socktype)
11832             .field("ai_protocol", &self.ai_protocol)
11833             .field("ai_addrlen", &self.ai_addrlen)
11834             .field("ai_canonname", &self.ai_canonname)
11835             .field("ai_addr", &self.ai_addr)
11836             .field("ai_blob", &self.ai_blob)
11837             .field("ai_bloblen", &self.ai_bloblen)
11838             .field("ai_provider", &self.ai_provider)
11839             .field("ai_next", &self.ai_next)
11840             .field("ai_version", &self.ai_version)
11841             .field("ai_fqdn", &self.ai_fqdn)
11842             .field("ai_interfaceindex", &self.ai_interfaceindex)
11843             .field("ai_resolutionhandle", &self.ai_resolutionhandle)
11844             .field("ai_ttl", &self.ai_ttl)
11845             .field("ai_numservers", &self.ai_numservers)
11846             .field("ai_servers", &self.ai_servers)
11847             .field("ai_responseflags", &self.ai_responseflags)
11848             .finish()
11849     }
11850 }
11851 #[cfg(feature = "Win32_Foundation")]
11852 impl ::std::cmp::PartialEq for addrinfoex6 {
eq(&self, other: &Self) -> bool11853     fn eq(&self, other: &Self) -> bool {
11854         self.ai_flags == other.ai_flags
11855             && self.ai_family == other.ai_family
11856             && self.ai_socktype == other.ai_socktype
11857             && self.ai_protocol == other.ai_protocol
11858             && self.ai_addrlen == other.ai_addrlen
11859             && self.ai_canonname == other.ai_canonname
11860             && self.ai_addr == other.ai_addr
11861             && self.ai_blob == other.ai_blob
11862             && self.ai_bloblen == other.ai_bloblen
11863             && self.ai_provider == other.ai_provider
11864             && self.ai_next == other.ai_next
11865             && self.ai_version == other.ai_version
11866             && self.ai_fqdn == other.ai_fqdn
11867             && self.ai_interfaceindex == other.ai_interfaceindex
11868             && self.ai_resolutionhandle == other.ai_resolutionhandle
11869             && self.ai_ttl == other.ai_ttl
11870             && self.ai_numservers == other.ai_numservers
11871             && self.ai_servers == other.ai_servers
11872             && self.ai_responseflags == other.ai_responseflags
11873     }
11874 }
11875 #[cfg(feature = "Win32_Foundation")]
11876 impl ::std::cmp::Eq for addrinfoex6 {}
11877 #[cfg(feature = "Win32_Foundation")]
11878 unsafe impl ::windows::runtime::Abi for addrinfoex6 {
11879     type Abi = Self;
11880     type DefaultType = Self;
11881 }
11882 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11883 #[repr(C)]
11884 #[cfg(feature = "Win32_Foundation")]
11885 pub struct addrinfoexA {
11886     pub ai_flags: i32,
11887     pub ai_family: i32,
11888     pub ai_socktype: i32,
11889     pub ai_protocol: i32,
11890     pub ai_addrlen: usize,
11891     pub ai_canonname: super::super::Foundation::PSTR,
11892     pub ai_addr: *mut SOCKADDR,
11893     pub ai_blob: *mut ::std::ffi::c_void,
11894     pub ai_bloblen: usize,
11895     pub ai_provider: *mut ::windows::runtime::GUID,
11896     pub ai_next: *mut addrinfoexA,
11897 }
11898 #[cfg(feature = "Win32_Foundation")]
11899 impl addrinfoexA {}
11900 #[cfg(feature = "Win32_Foundation")]
11901 impl ::std::default::Default for addrinfoexA {
default() -> Self11902     fn default() -> Self {
11903         unsafe { ::std::mem::zeroed() }
11904     }
11905 }
11906 #[cfg(feature = "Win32_Foundation")]
11907 impl ::std::fmt::Debug for addrinfoexA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11908     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11909         fmt.debug_struct("addrinfoexA")
11910             .field("ai_flags", &self.ai_flags)
11911             .field("ai_family", &self.ai_family)
11912             .field("ai_socktype", &self.ai_socktype)
11913             .field("ai_protocol", &self.ai_protocol)
11914             .field("ai_addrlen", &self.ai_addrlen)
11915             .field("ai_canonname", &self.ai_canonname)
11916             .field("ai_addr", &self.ai_addr)
11917             .field("ai_blob", &self.ai_blob)
11918             .field("ai_bloblen", &self.ai_bloblen)
11919             .field("ai_provider", &self.ai_provider)
11920             .field("ai_next", &self.ai_next)
11921             .finish()
11922     }
11923 }
11924 #[cfg(feature = "Win32_Foundation")]
11925 impl ::std::cmp::PartialEq for addrinfoexA {
eq(&self, other: &Self) -> bool11926     fn eq(&self, other: &Self) -> bool {
11927         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_blob == other.ai_blob && self.ai_bloblen == other.ai_bloblen && self.ai_provider == other.ai_provider && self.ai_next == other.ai_next
11928     }
11929 }
11930 #[cfg(feature = "Win32_Foundation")]
11931 impl ::std::cmp::Eq for addrinfoexA {}
11932 #[cfg(feature = "Win32_Foundation")]
11933 unsafe impl ::windows::runtime::Abi for addrinfoexA {
11934     type Abi = Self;
11935     type DefaultType = Self;
11936 }
11937 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11938 #[repr(C)]
11939 #[cfg(feature = "Win32_Foundation")]
11940 pub struct addrinfoexW {
11941     pub ai_flags: i32,
11942     pub ai_family: i32,
11943     pub ai_socktype: i32,
11944     pub ai_protocol: i32,
11945     pub ai_addrlen: usize,
11946     pub ai_canonname: super::super::Foundation::PWSTR,
11947     pub ai_addr: *mut SOCKADDR,
11948     pub ai_blob: *mut ::std::ffi::c_void,
11949     pub ai_bloblen: usize,
11950     pub ai_provider: *mut ::windows::runtime::GUID,
11951     pub ai_next: *mut addrinfoexW,
11952 }
11953 #[cfg(feature = "Win32_Foundation")]
11954 impl addrinfoexW {}
11955 #[cfg(feature = "Win32_Foundation")]
11956 impl ::std::default::Default for addrinfoexW {
default() -> Self11957     fn default() -> Self {
11958         unsafe { ::std::mem::zeroed() }
11959     }
11960 }
11961 #[cfg(feature = "Win32_Foundation")]
11962 impl ::std::fmt::Debug for addrinfoexW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11963     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11964         fmt.debug_struct("addrinfoexW")
11965             .field("ai_flags", &self.ai_flags)
11966             .field("ai_family", &self.ai_family)
11967             .field("ai_socktype", &self.ai_socktype)
11968             .field("ai_protocol", &self.ai_protocol)
11969             .field("ai_addrlen", &self.ai_addrlen)
11970             .field("ai_canonname", &self.ai_canonname)
11971             .field("ai_addr", &self.ai_addr)
11972             .field("ai_blob", &self.ai_blob)
11973             .field("ai_bloblen", &self.ai_bloblen)
11974             .field("ai_provider", &self.ai_provider)
11975             .field("ai_next", &self.ai_next)
11976             .finish()
11977     }
11978 }
11979 #[cfg(feature = "Win32_Foundation")]
11980 impl ::std::cmp::PartialEq for addrinfoexW {
eq(&self, other: &Self) -> bool11981     fn eq(&self, other: &Self) -> bool {
11982         self.ai_flags == other.ai_flags && self.ai_family == other.ai_family && self.ai_socktype == other.ai_socktype && self.ai_protocol == other.ai_protocol && self.ai_addrlen == other.ai_addrlen && self.ai_canonname == other.ai_canonname && self.ai_addr == other.ai_addr && self.ai_blob == other.ai_blob && self.ai_bloblen == other.ai_bloblen && self.ai_provider == other.ai_provider && self.ai_next == other.ai_next
11983     }
11984 }
11985 #[cfg(feature = "Win32_Foundation")]
11986 impl ::std::cmp::Eq for addrinfoexW {}
11987 #[cfg(feature = "Win32_Foundation")]
11988 unsafe impl ::windows::runtime::Abi for addrinfoexW {
11989     type Abi = Self;
11990     type DefaultType = Self;
11991 }
11992 #[cfg(feature = "Win32_Foundation")]
11993 #[inline]
bind<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32) -> i3211994 pub unsafe fn bind<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32) -> i32 {
11995     #[cfg(windows)]
11996     {
11997         #[link(name = "windows")]
11998         extern "system" {
11999             fn bind(s: SOCKET, name: *const SOCKADDR, namelen: i32) -> i32;
12000         }
12001         ::std::mem::transmute(bind(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen)))
12002     }
12003     #[cfg(not(windows))]
12004     unimplemented!("Unsupported target OS");
12005 }
12006 #[inline]
closesocket<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0) -> i3212007 pub unsafe fn closesocket<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0) -> i32 {
12008     #[cfg(windows)]
12009     {
12010         #[link(name = "windows")]
12011         extern "system" {
12012             fn closesocket(s: SOCKET) -> i32;
12013         }
12014         ::std::mem::transmute(closesocket(s.into_param().abi()))
12015     }
12016     #[cfg(not(windows))]
12017     unimplemented!("Unsupported target OS");
12018 }
12019 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12020 #[repr(C)]
12021 pub struct cmsghdr {
12022     pub cmsg_len: usize,
12023     pub cmsg_level: i32,
12024     pub cmsg_type: i32,
12025 }
12026 impl cmsghdr {}
12027 impl ::std::default::Default for cmsghdr {
default() -> Self12028     fn default() -> Self {
12029         unsafe { ::std::mem::zeroed() }
12030     }
12031 }
12032 impl ::std::fmt::Debug for cmsghdr {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12033     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12034         fmt.debug_struct("cmsghdr").field("cmsg_len", &self.cmsg_len).field("cmsg_level", &self.cmsg_level).field("cmsg_type", &self.cmsg_type).finish()
12035     }
12036 }
12037 impl ::std::cmp::PartialEq for cmsghdr {
eq(&self, other: &Self) -> bool12038     fn eq(&self, other: &Self) -> bool {
12039         self.cmsg_len == other.cmsg_len && self.cmsg_level == other.cmsg_level && self.cmsg_type == other.cmsg_type
12040     }
12041 }
12042 impl ::std::cmp::Eq for cmsghdr {}
12043 unsafe impl ::windows::runtime::Abi for cmsghdr {
12044     type Abi = Self;
12045     type DefaultType = Self;
12046 }
12047 #[cfg(feature = "Win32_Foundation")]
12048 #[inline]
connect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32) -> i3212049 pub unsafe fn connect<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *const SOCKADDR, namelen: i32) -> i32 {
12050     #[cfg(windows)]
12051     {
12052         #[link(name = "windows")]
12053         extern "system" {
12054             fn connect(s: SOCKET, name: *const SOCKADDR, namelen: i32) -> i32;
12055         }
12056         ::std::mem::transmute(connect(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen)))
12057     }
12058     #[cfg(not(windows))]
12059     unimplemented!("Unsupported target OS");
12060 }
12061 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12062 #[repr(transparent)]
12063 pub struct eWINDOW_ADVANCE_METHOD(pub i32);
12064 pub const E_WINDOW_ADVANCE_BY_TIME: eWINDOW_ADVANCE_METHOD = eWINDOW_ADVANCE_METHOD(1i32);
12065 pub const E_WINDOW_USE_AS_DATA_CACHE: eWINDOW_ADVANCE_METHOD = eWINDOW_ADVANCE_METHOD(2i32);
12066 impl ::std::convert::From<i32> for eWINDOW_ADVANCE_METHOD {
from(value: i32) -> Self12067     fn from(value: i32) -> Self {
12068         Self(value)
12069     }
12070 }
12071 unsafe impl ::windows::runtime::Abi for eWINDOW_ADVANCE_METHOD {
12072     type Abi = Self;
12073     type DefaultType = Self;
12074 }
12075 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12076 #[repr(C)]
12077 pub struct fd_set {
12078     pub fd_count: u32,
12079     pub fd_array: [SOCKET; 64],
12080 }
12081 impl fd_set {}
12082 impl ::std::default::Default for fd_set {
default() -> Self12083     fn default() -> Self {
12084         unsafe { ::std::mem::zeroed() }
12085     }
12086 }
12087 impl ::std::fmt::Debug for fd_set {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12088     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12089         fmt.debug_struct("fd_set").field("fd_count", &self.fd_count).field("fd_array", &self.fd_array).finish()
12090     }
12091 }
12092 impl ::std::cmp::PartialEq for fd_set {
eq(&self, other: &Self) -> bool12093     fn eq(&self, other: &Self) -> bool {
12094         self.fd_count == other.fd_count && self.fd_array == other.fd_array
12095     }
12096 }
12097 impl ::std::cmp::Eq for fd_set {}
12098 unsafe impl ::windows::runtime::Abi for fd_set {
12099     type Abi = Self;
12100     type DefaultType = Self;
12101 }
12102 #[cfg(feature = "Win32_Foundation")]
12103 #[inline]
freeaddrinfo(paddrinfo: *const ADDRINFOA)12104 pub unsafe fn freeaddrinfo(paddrinfo: *const ADDRINFOA) {
12105     #[cfg(windows)]
12106     {
12107         #[link(name = "windows")]
12108         extern "system" {
12109             fn freeaddrinfo(paddrinfo: *const ADDRINFOA);
12110         }
12111         ::std::mem::transmute(freeaddrinfo(::std::mem::transmute(paddrinfo)))
12112     }
12113     #[cfg(not(windows))]
12114     unimplemented!("Unsupported target OS");
12115 }
12116 #[cfg(feature = "Win32_Foundation")]
12117 #[inline]
getaddrinfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pnodename: Param0, pservicename: Param1, phints: *const ADDRINFOA, ppresult: *mut *mut ADDRINFOA) -> i3212118 pub unsafe fn getaddrinfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pnodename: Param0, pservicename: Param1, phints: *const ADDRINFOA, ppresult: *mut *mut ADDRINFOA) -> i32 {
12119     #[cfg(windows)]
12120     {
12121         #[link(name = "windows")]
12122         extern "system" {
12123             fn getaddrinfo(pnodename: super::super::Foundation::PSTR, pservicename: super::super::Foundation::PSTR, phints: *const ADDRINFOA, ppresult: *mut *mut ADDRINFOA) -> i32;
12124         }
12125         ::std::mem::transmute(getaddrinfo(pnodename.into_param().abi(), pservicename.into_param().abi(), ::std::mem::transmute(phints), ::std::mem::transmute(ppresult)))
12126     }
12127     #[cfg(not(windows))]
12128     unimplemented!("Unsupported target OS");
12129 }
12130 #[cfg(feature = "Win32_Foundation")]
12131 #[inline]
gethostbyaddr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addr: Param0, len: i32, r#type: i32) -> *mut hostent12132 pub unsafe fn gethostbyaddr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(addr: Param0, len: i32, r#type: i32) -> *mut hostent {
12133     #[cfg(windows)]
12134     {
12135         #[link(name = "windows")]
12136         extern "system" {
12137             fn gethostbyaddr(addr: super::super::Foundation::PSTR, len: i32, r#type: i32) -> *mut hostent;
12138         }
12139         ::std::mem::transmute(gethostbyaddr(addr.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(r#type)))
12140     }
12141     #[cfg(not(windows))]
12142     unimplemented!("Unsupported target OS");
12143 }
12144 #[cfg(feature = "Win32_Foundation")]
12145 #[inline]
gethostbyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0) -> *mut hostent12146 pub unsafe fn gethostbyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0) -> *mut hostent {
12147     #[cfg(windows)]
12148     {
12149         #[link(name = "windows")]
12150         extern "system" {
12151             fn gethostbyname(name: super::super::Foundation::PSTR) -> *mut hostent;
12152         }
12153         ::std::mem::transmute(gethostbyname(name.into_param().abi()))
12154     }
12155     #[cfg(not(windows))]
12156     unimplemented!("Unsupported target OS");
12157 }
12158 #[cfg(feature = "Win32_Foundation")]
12159 #[inline]
gethostname(name: super::super::Foundation::PSTR, namelen: i32) -> i3212160 pub unsafe fn gethostname(name: super::super::Foundation::PSTR, namelen: i32) -> i32 {
12161     #[cfg(windows)]
12162     {
12163         #[link(name = "windows")]
12164         extern "system" {
12165             fn gethostname(name: super::super::Foundation::PSTR, namelen: i32) -> i32;
12166         }
12167         ::std::mem::transmute(gethostname(::std::mem::transmute(name), ::std::mem::transmute(namelen)))
12168     }
12169     #[cfg(not(windows))]
12170     unimplemented!("Unsupported target OS");
12171 }
12172 #[cfg(feature = "Win32_Foundation")]
12173 #[inline]
getnameinfo(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PSTR, servicebuffersize: u32, flags: i32) -> i3212174 pub unsafe fn getnameinfo(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PSTR, servicebuffersize: u32, flags: i32) -> i32 {
12175     #[cfg(windows)]
12176     {
12177         #[link(name = "windows")]
12178         extern "system" {
12179             fn getnameinfo(psockaddr: *const SOCKADDR, sockaddrlength: i32, pnodebuffer: super::super::Foundation::PSTR, nodebuffersize: u32, pservicebuffer: super::super::Foundation::PSTR, servicebuffersize: u32, flags: i32) -> i32;
12180         }
12181         ::std::mem::transmute(getnameinfo(::std::mem::transmute(psockaddr), ::std::mem::transmute(sockaddrlength), ::std::mem::transmute(pnodebuffer), ::std::mem::transmute(nodebuffersize), ::std::mem::transmute(pservicebuffer), ::std::mem::transmute(servicebuffersize), ::std::mem::transmute(flags)))
12182     }
12183     #[cfg(not(windows))]
12184     unimplemented!("Unsupported target OS");
12185 }
12186 #[cfg(feature = "Win32_Foundation")]
12187 #[inline]
getpeername<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *mut SOCKADDR, namelen: *mut i32) -> i3212188 pub unsafe fn getpeername<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *mut SOCKADDR, namelen: *mut i32) -> i32 {
12189     #[cfg(windows)]
12190     {
12191         #[link(name = "windows")]
12192         extern "system" {
12193             fn getpeername(s: SOCKET, name: *mut SOCKADDR, namelen: *mut i32) -> i32;
12194         }
12195         ::std::mem::transmute(getpeername(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen)))
12196     }
12197     #[cfg(not(windows))]
12198     unimplemented!("Unsupported target OS");
12199 }
12200 #[cfg(feature = "Win32_Foundation")]
12201 #[inline]
getprotobyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0) -> *mut protoent12202 pub unsafe fn getprotobyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0) -> *mut protoent {
12203     #[cfg(windows)]
12204     {
12205         #[link(name = "windows")]
12206         extern "system" {
12207             fn getprotobyname(name: super::super::Foundation::PSTR) -> *mut protoent;
12208         }
12209         ::std::mem::transmute(getprotobyname(name.into_param().abi()))
12210     }
12211     #[cfg(not(windows))]
12212     unimplemented!("Unsupported target OS");
12213 }
12214 #[cfg(feature = "Win32_Foundation")]
12215 #[inline]
getprotobynumber(number: i32) -> *mut protoent12216 pub unsafe fn getprotobynumber(number: i32) -> *mut protoent {
12217     #[cfg(windows)]
12218     {
12219         #[link(name = "windows")]
12220         extern "system" {
12221             fn getprotobynumber(number: i32) -> *mut protoent;
12222         }
12223         ::std::mem::transmute(getprotobynumber(::std::mem::transmute(number)))
12224     }
12225     #[cfg(not(windows))]
12226     unimplemented!("Unsupported target OS");
12227 }
12228 #[cfg(feature = "Win32_Foundation")]
12229 #[inline]
getservbyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0, proto: Param1) -> *mut servent12230 pub unsafe fn getservbyname<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(name: Param0, proto: Param1) -> *mut servent {
12231     #[cfg(windows)]
12232     {
12233         #[link(name = "windows")]
12234         extern "system" {
12235             fn getservbyname(name: super::super::Foundation::PSTR, proto: super::super::Foundation::PSTR) -> *mut servent;
12236         }
12237         ::std::mem::transmute(getservbyname(name.into_param().abi(), proto.into_param().abi()))
12238     }
12239     #[cfg(not(windows))]
12240     unimplemented!("Unsupported target OS");
12241 }
12242 #[cfg(feature = "Win32_Foundation")]
12243 #[inline]
getservbyport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(port: i32, proto: Param1) -> *mut servent12244 pub unsafe fn getservbyport<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(port: i32, proto: Param1) -> *mut servent {
12245     #[cfg(windows)]
12246     {
12247         #[link(name = "windows")]
12248         extern "system" {
12249             fn getservbyport(port: i32, proto: super::super::Foundation::PSTR) -> *mut servent;
12250         }
12251         ::std::mem::transmute(getservbyport(::std::mem::transmute(port), proto.into_param().abi()))
12252     }
12253     #[cfg(not(windows))]
12254     unimplemented!("Unsupported target OS");
12255 }
12256 #[cfg(feature = "Win32_Foundation")]
12257 #[inline]
getsockname<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *mut SOCKADDR, namelen: *mut i32) -> i3212258 pub unsafe fn getsockname<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, name: *mut SOCKADDR, namelen: *mut i32) -> i32 {
12259     #[cfg(windows)]
12260     {
12261         #[link(name = "windows")]
12262         extern "system" {
12263             fn getsockname(s: SOCKET, name: *mut SOCKADDR, namelen: *mut i32) -> i32;
12264         }
12265         ::std::mem::transmute(getsockname(s.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(namelen)))
12266     }
12267     #[cfg(not(windows))]
12268     unimplemented!("Unsupported target OS");
12269 }
12270 #[cfg(feature = "Win32_Foundation")]
12271 #[inline]
getsockopt<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: *mut i32) -> i3212272 pub unsafe fn getsockopt<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: *mut i32) -> i32 {
12273     #[cfg(windows)]
12274     {
12275         #[link(name = "windows")]
12276         extern "system" {
12277             fn getsockopt(s: SOCKET, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: *mut i32) -> i32;
12278         }
12279         ::std::mem::transmute(getsockopt(s.into_param().abi(), ::std::mem::transmute(level), ::std::mem::transmute(optname), ::std::mem::transmute(optval), ::std::mem::transmute(optlen)))
12280     }
12281     #[cfg(not(windows))]
12282     unimplemented!("Unsupported target OS");
12283 }
12284 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12285 #[repr(C)]
12286 #[cfg(feature = "Win32_Foundation")]
12287 pub struct hostent {
12288     pub h_name: super::super::Foundation::PSTR,
12289     pub h_aliases: *mut *mut i8,
12290     pub h_addrtype: i16,
12291     pub h_length: i16,
12292     pub h_addr_list: *mut *mut i8,
12293 }
12294 #[cfg(feature = "Win32_Foundation")]
12295 impl hostent {}
12296 #[cfg(feature = "Win32_Foundation")]
12297 impl ::std::default::Default for hostent {
default() -> Self12298     fn default() -> Self {
12299         unsafe { ::std::mem::zeroed() }
12300     }
12301 }
12302 #[cfg(feature = "Win32_Foundation")]
12303 impl ::std::fmt::Debug for hostent {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12304     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12305         fmt.debug_struct("hostent").field("h_name", &self.h_name).field("h_aliases", &self.h_aliases).field("h_addrtype", &self.h_addrtype).field("h_length", &self.h_length).field("h_addr_list", &self.h_addr_list).finish()
12306     }
12307 }
12308 #[cfg(feature = "Win32_Foundation")]
12309 impl ::std::cmp::PartialEq for hostent {
eq(&self, other: &Self) -> bool12310     fn eq(&self, other: &Self) -> bool {
12311         self.h_name == other.h_name && self.h_aliases == other.h_aliases && self.h_addrtype == other.h_addrtype && self.h_length == other.h_length && self.h_addr_list == other.h_addr_list
12312     }
12313 }
12314 #[cfg(feature = "Win32_Foundation")]
12315 impl ::std::cmp::Eq for hostent {}
12316 #[cfg(feature = "Win32_Foundation")]
12317 unsafe impl ::windows::runtime::Abi for hostent {
12318     type Abi = Self;
12319     type DefaultType = Self;
12320 }
12321 #[inline]
htonl(hostlong: u32) -> u3212322 pub unsafe fn htonl(hostlong: u32) -> u32 {
12323     #[cfg(windows)]
12324     {
12325         #[link(name = "windows")]
12326         extern "system" {
12327             fn htonl(hostlong: u32) -> u32;
12328         }
12329         ::std::mem::transmute(htonl(::std::mem::transmute(hostlong)))
12330     }
12331     #[cfg(not(windows))]
12332     unimplemented!("Unsupported target OS");
12333 }
12334 #[inline]
htons(hostshort: u16) -> u1612335 pub unsafe fn htons(hostshort: u16) -> u16 {
12336     #[cfg(windows)]
12337     {
12338         #[link(name = "windows")]
12339         extern "system" {
12340             fn htons(hostshort: u16) -> u16;
12341         }
12342         ::std::mem::transmute(htons(::std::mem::transmute(hostshort)))
12343     }
12344     #[cfg(not(windows))]
12345     unimplemented!("Unsupported target OS");
12346 }
12347 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12348 #[repr(C)]
12349 pub struct in6_pktinfo_ex {
12350     pub pkt_info: IN6_PKTINFO,
12351     pub scope_id: SCOPE_ID,
12352 }
12353 impl in6_pktinfo_ex {}
12354 impl ::std::default::Default for in6_pktinfo_ex {
default() -> Self12355     fn default() -> Self {
12356         unsafe { ::std::mem::zeroed() }
12357     }
12358 }
12359 impl ::std::cmp::PartialEq for in6_pktinfo_ex {
eq(&self, _other: &Self) -> bool12360     fn eq(&self, _other: &Self) -> bool {
12361         unimplemented!()
12362     }
12363 }
12364 impl ::std::cmp::Eq for in6_pktinfo_ex {}
12365 unsafe impl ::windows::runtime::Abi for in6_pktinfo_ex {
12366     type Abi = Self;
12367     type DefaultType = Self;
12368 }
12369 #[cfg(feature = "Win32_Foundation")]
12370 #[inline]
inet_addr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(cp: Param0) -> u3212371 pub unsafe fn inet_addr<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(cp: Param0) -> u32 {
12372     #[cfg(windows)]
12373     {
12374         #[link(name = "windows")]
12375         extern "system" {
12376             fn inet_addr(cp: super::super::Foundation::PSTR) -> u32;
12377         }
12378         ::std::mem::transmute(inet_addr(cp.into_param().abi()))
12379     }
12380     #[cfg(not(windows))]
12381     unimplemented!("Unsupported target OS");
12382 }
12383 #[cfg(feature = "Win32_Foundation")]
12384 #[inline]
inet_ntoa<'a, Param0: ::windows::runtime::IntoParam<'a, IN_ADDR>>(r#in: Param0) -> super::super::Foundation::PSTR12385 pub unsafe fn inet_ntoa<'a, Param0: ::windows::runtime::IntoParam<'a, IN_ADDR>>(r#in: Param0) -> super::super::Foundation::PSTR {
12386     #[cfg(windows)]
12387     {
12388         #[link(name = "windows")]
12389         extern "system" {
12390             fn inet_ntoa(r#in: IN_ADDR) -> super::super::Foundation::PSTR;
12391         }
12392         ::std::mem::transmute(inet_ntoa(r#in.into_param().abi()))
12393     }
12394     #[cfg(not(windows))]
12395     unimplemented!("Unsupported target OS");
12396 }
12397 #[cfg(feature = "Win32_Foundation")]
12398 #[inline]
inet_ntop(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PSTR, stringbufsize: usize) -> super::super::Foundation::PSTR12399 pub unsafe fn inet_ntop(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PSTR, stringbufsize: usize) -> super::super::Foundation::PSTR {
12400     #[cfg(windows)]
12401     {
12402         #[link(name = "windows")]
12403         extern "system" {
12404             fn inet_ntop(family: i32, paddr: *const ::std::ffi::c_void, pstringbuf: super::super::Foundation::PSTR, stringbufsize: usize) -> super::super::Foundation::PSTR;
12405         }
12406         ::std::mem::transmute(inet_ntop(::std::mem::transmute(family), ::std::mem::transmute(paddr), ::std::mem::transmute(pstringbuf), ::std::mem::transmute(stringbufsize)))
12407     }
12408     #[cfg(not(windows))]
12409     unimplemented!("Unsupported target OS");
12410 }
12411 #[cfg(feature = "Win32_Foundation")]
12412 #[inline]
inet_pton<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(family: i32, pszaddrstring: Param1, paddrbuf: *mut ::std::ffi::c_void) -> i3212413 pub unsafe fn inet_pton<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(family: i32, pszaddrstring: Param1, paddrbuf: *mut ::std::ffi::c_void) -> i32 {
12414     #[cfg(windows)]
12415     {
12416         #[link(name = "windows")]
12417         extern "system" {
12418             fn inet_pton(family: i32, pszaddrstring: super::super::Foundation::PSTR, paddrbuf: *mut ::std::ffi::c_void) -> i32;
12419         }
12420         ::std::mem::transmute(inet_pton(::std::mem::transmute(family), pszaddrstring.into_param().abi(), ::std::mem::transmute(paddrbuf)))
12421     }
12422     #[cfg(not(windows))]
12423     unimplemented!("Unsupported target OS");
12424 }
12425 #[inline]
ioctlsocket<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, cmd: i32, argp: *mut u32) -> i3212426 pub unsafe fn ioctlsocket<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, cmd: i32, argp: *mut u32) -> i32 {
12427     #[cfg(windows)]
12428     {
12429         #[link(name = "windows")]
12430         extern "system" {
12431             fn ioctlsocket(s: SOCKET, cmd: i32, argp: *mut u32) -> i32;
12432         }
12433         ::std::mem::transmute(ioctlsocket(s.into_param().abi(), ::std::mem::transmute(cmd), ::std::mem::transmute(argp)))
12434     }
12435     #[cfg(not(windows))]
12436     unimplemented!("Unsupported target OS");
12437 }
12438 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12439 #[repr(C)]
12440 pub struct linger {
12441     pub l_onoff: u16,
12442     pub l_linger: u16,
12443 }
12444 impl linger {}
12445 impl ::std::default::Default for linger {
default() -> Self12446     fn default() -> Self {
12447         unsafe { ::std::mem::zeroed() }
12448     }
12449 }
12450 impl ::std::fmt::Debug for linger {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12451     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12452         fmt.debug_struct("linger").field("l_onoff", &self.l_onoff).field("l_linger", &self.l_linger).finish()
12453     }
12454 }
12455 impl ::std::cmp::PartialEq for linger {
eq(&self, other: &Self) -> bool12456     fn eq(&self, other: &Self) -> bool {
12457         self.l_onoff == other.l_onoff && self.l_linger == other.l_linger
12458     }
12459 }
12460 impl ::std::cmp::Eq for linger {}
12461 unsafe impl ::windows::runtime::Abi for linger {
12462     type Abi = Self;
12463     type DefaultType = Self;
12464 }
12465 #[inline]
listen<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, backlog: i32) -> i3212466 pub unsafe fn listen<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, backlog: i32) -> i32 {
12467     #[cfg(windows)]
12468     {
12469         #[link(name = "windows")]
12470         extern "system" {
12471             fn listen(s: SOCKET, backlog: i32) -> i32;
12472         }
12473         ::std::mem::transmute(listen(s.into_param().abi(), ::std::mem::transmute(backlog)))
12474     }
12475     #[cfg(not(windows))]
12476     unimplemented!("Unsupported target OS");
12477 }
12478 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12479 #[repr(C)]
12480 #[cfg(feature = "Win32_Foundation")]
12481 pub struct netent {
12482     pub n_name: super::super::Foundation::PSTR,
12483     pub n_aliases: *mut *mut i8,
12484     pub n_addrtype: i16,
12485     pub n_net: u32,
12486 }
12487 #[cfg(feature = "Win32_Foundation")]
12488 impl netent {}
12489 #[cfg(feature = "Win32_Foundation")]
12490 impl ::std::default::Default for netent {
default() -> Self12491     fn default() -> Self {
12492         unsafe { ::std::mem::zeroed() }
12493     }
12494 }
12495 #[cfg(feature = "Win32_Foundation")]
12496 impl ::std::fmt::Debug for netent {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12497     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12498         fmt.debug_struct("netent").field("n_name", &self.n_name).field("n_aliases", &self.n_aliases).field("n_addrtype", &self.n_addrtype).field("n_net", &self.n_net).finish()
12499     }
12500 }
12501 #[cfg(feature = "Win32_Foundation")]
12502 impl ::std::cmp::PartialEq for netent {
eq(&self, other: &Self) -> bool12503     fn eq(&self, other: &Self) -> bool {
12504         self.n_name == other.n_name && self.n_aliases == other.n_aliases && self.n_addrtype == other.n_addrtype && self.n_net == other.n_net
12505     }
12506 }
12507 #[cfg(feature = "Win32_Foundation")]
12508 impl ::std::cmp::Eq for netent {}
12509 #[cfg(feature = "Win32_Foundation")]
12510 unsafe impl ::windows::runtime::Abi for netent {
12511     type Abi = Self;
12512     type DefaultType = Self;
12513 }
12514 #[inline]
ntohl(netlong: u32) -> u3212515 pub unsafe fn ntohl(netlong: u32) -> u32 {
12516     #[cfg(windows)]
12517     {
12518         #[link(name = "windows")]
12519         extern "system" {
12520             fn ntohl(netlong: u32) -> u32;
12521         }
12522         ::std::mem::transmute(ntohl(::std::mem::transmute(netlong)))
12523     }
12524     #[cfg(not(windows))]
12525     unimplemented!("Unsupported target OS");
12526 }
12527 #[inline]
ntohs(netshort: u16) -> u1612528 pub unsafe fn ntohs(netshort: u16) -> u16 {
12529     #[cfg(windows)]
12530     {
12531         #[link(name = "windows")]
12532         extern "system" {
12533             fn ntohs(netshort: u16) -> u16;
12534         }
12535         ::std::mem::transmute(ntohs(::std::mem::transmute(netshort)))
12536     }
12537     #[cfg(not(windows))]
12538     unimplemented!("Unsupported target OS");
12539 }
12540 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12541 #[repr(C)]
12542 #[cfg(feature = "Win32_Foundation")]
12543 pub struct protoent {
12544     pub p_name: super::super::Foundation::PSTR,
12545     pub p_aliases: *mut *mut i8,
12546     pub p_proto: i16,
12547 }
12548 #[cfg(feature = "Win32_Foundation")]
12549 impl protoent {}
12550 #[cfg(feature = "Win32_Foundation")]
12551 impl ::std::default::Default for protoent {
default() -> Self12552     fn default() -> Self {
12553         unsafe { ::std::mem::zeroed() }
12554     }
12555 }
12556 #[cfg(feature = "Win32_Foundation")]
12557 impl ::std::fmt::Debug for protoent {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12558     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12559         fmt.debug_struct("protoent").field("p_name", &self.p_name).field("p_aliases", &self.p_aliases).field("p_proto", &self.p_proto).finish()
12560     }
12561 }
12562 #[cfg(feature = "Win32_Foundation")]
12563 impl ::std::cmp::PartialEq for protoent {
eq(&self, other: &Self) -> bool12564     fn eq(&self, other: &Self) -> bool {
12565         self.p_name == other.p_name && self.p_aliases == other.p_aliases && self.p_proto == other.p_proto
12566     }
12567 }
12568 #[cfg(feature = "Win32_Foundation")]
12569 impl ::std::cmp::Eq for protoent {}
12570 #[cfg(feature = "Win32_Foundation")]
12571 unsafe impl ::windows::runtime::Abi for protoent {
12572     type Abi = Self;
12573     type DefaultType = Self;
12574 }
12575 #[cfg(feature = "Win32_Foundation")]
12576 #[inline]
recv<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: i32) -> i3212577 pub unsafe fn recv<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: i32) -> i32 {
12578     #[cfg(windows)]
12579     {
12580         #[link(name = "windows")]
12581         extern "system" {
12582             fn recv(s: SOCKET, buf: super::super::Foundation::PSTR, len: i32, flags: i32) -> i32;
12583         }
12584         ::std::mem::transmute(recv(s.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(len), ::std::mem::transmute(flags)))
12585     }
12586     #[cfg(not(windows))]
12587     unimplemented!("Unsupported target OS");
12588 }
12589 #[cfg(feature = "Win32_Foundation")]
12590 #[inline]
recvfrom<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: i32, from: *mut SOCKADDR, fromlen: *mut i32) -> i3212591 pub unsafe fn recvfrom<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, buf: super::super::Foundation::PSTR, len: i32, flags: i32, from: *mut SOCKADDR, fromlen: *mut i32) -> i32 {
12592     #[cfg(windows)]
12593     {
12594         #[link(name = "windows")]
12595         extern "system" {
12596             fn recvfrom(s: SOCKET, buf: super::super::Foundation::PSTR, len: i32, flags: i32, from: *mut SOCKADDR, fromlen: *mut i32) -> i32;
12597         }
12598         ::std::mem::transmute(recvfrom(s.into_param().abi(), ::std::mem::transmute(buf), ::std::mem::transmute(len), ::std::mem::transmute(flags), ::std::mem::transmute(from), ::std::mem::transmute(fromlen)))
12599     }
12600     #[cfg(not(windows))]
12601     unimplemented!("Unsupported target OS");
12602 }
12603 #[inline]
select(nfds: i32, readfds: *mut fd_set, writefds: *mut fd_set, exceptfds: *mut fd_set, timeout: *const timeval) -> i3212604 pub unsafe fn select(nfds: i32, readfds: *mut fd_set, writefds: *mut fd_set, exceptfds: *mut fd_set, timeout: *const timeval) -> i32 {
12605     #[cfg(windows)]
12606     {
12607         #[link(name = "windows")]
12608         extern "system" {
12609             fn select(nfds: i32, readfds: *mut fd_set, writefds: *mut fd_set, exceptfds: *mut fd_set, timeout: *const timeval) -> i32;
12610         }
12611         ::std::mem::transmute(select(::std::mem::transmute(nfds), ::std::mem::transmute(readfds), ::std::mem::transmute(writefds), ::std::mem::transmute(exceptfds), ::std::mem::transmute(timeout)))
12612     }
12613     #[cfg(not(windows))]
12614     unimplemented!("Unsupported target OS");
12615 }
12616 #[cfg(feature = "Win32_Foundation")]
12617 #[inline]
send<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, buf: Param1, len: i32, flags: SEND_FLAGS) -> i3212618 pub unsafe fn send<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, buf: Param1, len: i32, flags: SEND_FLAGS) -> i32 {
12619     #[cfg(windows)]
12620     {
12621         #[link(name = "windows")]
12622         extern "system" {
12623             fn send(s: SOCKET, buf: super::super::Foundation::PSTR, len: i32, flags: SEND_FLAGS) -> i32;
12624         }
12625         ::std::mem::transmute(send(s.into_param().abi(), buf.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(flags)))
12626     }
12627     #[cfg(not(windows))]
12628     unimplemented!("Unsupported target OS");
12629 }
12630 #[cfg(feature = "Win32_Foundation")]
12631 #[inline]
sendto<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, buf: Param1, len: i32, flags: i32, to: *const SOCKADDR, tolen: i32) -> i3212632 pub unsafe fn sendto<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, buf: Param1, len: i32, flags: i32, to: *const SOCKADDR, tolen: i32) -> i32 {
12633     #[cfg(windows)]
12634     {
12635         #[link(name = "windows")]
12636         extern "system" {
12637             fn sendto(s: SOCKET, buf: super::super::Foundation::PSTR, len: i32, flags: i32, to: *const SOCKADDR, tolen: i32) -> i32;
12638         }
12639         ::std::mem::transmute(sendto(s.into_param().abi(), buf.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(flags), ::std::mem::transmute(to), ::std::mem::transmute(tolen)))
12640     }
12641     #[cfg(not(windows))]
12642     unimplemented!("Unsupported target OS");
12643 }
12644 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12645 #[repr(C)]
12646 #[cfg(feature = "Win32_Foundation")]
12647 pub struct servent {
12648     pub s_name: super::super::Foundation::PSTR,
12649     pub s_aliases: *mut *mut i8,
12650     pub s_proto: super::super::Foundation::PSTR,
12651     pub s_port: i16,
12652 }
12653 #[cfg(feature = "Win32_Foundation")]
12654 impl servent {}
12655 #[cfg(feature = "Win32_Foundation")]
12656 impl ::std::default::Default for servent {
default() -> Self12657     fn default() -> Self {
12658         unsafe { ::std::mem::zeroed() }
12659     }
12660 }
12661 #[cfg(feature = "Win32_Foundation")]
12662 impl ::std::fmt::Debug for servent {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12663     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12664         fmt.debug_struct("servent").field("s_name", &self.s_name).field("s_aliases", &self.s_aliases).field("s_proto", &self.s_proto).field("s_port", &self.s_port).finish()
12665     }
12666 }
12667 #[cfg(feature = "Win32_Foundation")]
12668 impl ::std::cmp::PartialEq for servent {
eq(&self, other: &Self) -> bool12669     fn eq(&self, other: &Self) -> bool {
12670         self.s_name == other.s_name && self.s_aliases == other.s_aliases && self.s_proto == other.s_proto && self.s_port == other.s_port
12671     }
12672 }
12673 #[cfg(feature = "Win32_Foundation")]
12674 impl ::std::cmp::Eq for servent {}
12675 #[cfg(feature = "Win32_Foundation")]
12676 unsafe impl ::windows::runtime::Abi for servent {
12677     type Abi = Self;
12678     type DefaultType = Self;
12679 }
12680 #[cfg(feature = "Win32_Foundation")]
12681 #[inline]
setsockopt<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, level: i32, optname: i32, optval: Param3, optlen: i32) -> i3212682 pub unsafe fn setsockopt<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(s: Param0, level: i32, optname: i32, optval: Param3, optlen: i32) -> i32 {
12683     #[cfg(windows)]
12684     {
12685         #[link(name = "windows")]
12686         extern "system" {
12687             fn setsockopt(s: SOCKET, level: i32, optname: i32, optval: super::super::Foundation::PSTR, optlen: i32) -> i32;
12688         }
12689         ::std::mem::transmute(setsockopt(s.into_param().abi(), ::std::mem::transmute(level), ::std::mem::transmute(optname), optval.into_param().abi(), ::std::mem::transmute(optlen)))
12690     }
12691     #[cfg(not(windows))]
12692     unimplemented!("Unsupported target OS");
12693 }
12694 #[inline]
shutdown<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, how: i32) -> i3212695 pub unsafe fn shutdown<'a, Param0: ::windows::runtime::IntoParam<'a, SOCKET>>(s: Param0, how: i32) -> i32 {
12696     #[cfg(windows)]
12697     {
12698         #[link(name = "windows")]
12699         extern "system" {
12700             fn shutdown(s: SOCKET, how: i32) -> i32;
12701         }
12702         ::std::mem::transmute(shutdown(s.into_param().abi(), ::std::mem::transmute(how)))
12703     }
12704     #[cfg(not(windows))]
12705     unimplemented!("Unsupported target OS");
12706 }
12707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12708 #[repr(C)]
12709 pub struct sockaddr_atm {
12710     pub satm_family: u16,
12711     pub satm_number: ATM_ADDRESS,
12712     pub satm_blli: ATM_BLLI,
12713     pub satm_bhli: ATM_BHLI,
12714 }
12715 impl sockaddr_atm {}
12716 impl ::std::default::Default for sockaddr_atm {
default() -> Self12717     fn default() -> Self {
12718         unsafe { ::std::mem::zeroed() }
12719     }
12720 }
12721 impl ::std::fmt::Debug for sockaddr_atm {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12722     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12723         fmt.debug_struct("sockaddr_atm").field("satm_family", &self.satm_family).field("satm_number", &self.satm_number).field("satm_blli", &self.satm_blli).field("satm_bhli", &self.satm_bhli).finish()
12724     }
12725 }
12726 impl ::std::cmp::PartialEq for sockaddr_atm {
eq(&self, other: &Self) -> bool12727     fn eq(&self, other: &Self) -> bool {
12728         self.satm_family == other.satm_family && self.satm_number == other.satm_number && self.satm_blli == other.satm_blli && self.satm_bhli == other.satm_bhli
12729     }
12730 }
12731 impl ::std::cmp::Eq for sockaddr_atm {}
12732 unsafe impl ::windows::runtime::Abi for sockaddr_atm {
12733     type Abi = Self;
12734     type DefaultType = Self;
12735 }
12736 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12737 #[repr(C)]
12738 #[cfg(feature = "Win32_Foundation")]
12739 pub union sockaddr_gen {
12740     pub Address: SOCKADDR,
12741     pub AddressIn: SOCKADDR_IN,
12742     pub AddressIn6: sockaddr_in6_old,
12743 }
12744 #[cfg(feature = "Win32_Foundation")]
12745 impl sockaddr_gen {}
12746 #[cfg(feature = "Win32_Foundation")]
12747 impl ::std::default::Default for sockaddr_gen {
default() -> Self12748     fn default() -> Self {
12749         unsafe { ::std::mem::zeroed() }
12750     }
12751 }
12752 #[cfg(feature = "Win32_Foundation")]
12753 impl ::std::cmp::PartialEq for sockaddr_gen {
eq(&self, _other: &Self) -> bool12754     fn eq(&self, _other: &Self) -> bool {
12755         unimplemented!()
12756     }
12757 }
12758 #[cfg(feature = "Win32_Foundation")]
12759 impl ::std::cmp::Eq for sockaddr_gen {}
12760 #[cfg(feature = "Win32_Foundation")]
12761 unsafe impl ::windows::runtime::Abi for sockaddr_gen {
12762     type Abi = Self;
12763     type DefaultType = Self;
12764 }
12765 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12766 #[repr(C)]
12767 pub struct sockaddr_in6_old {
12768     pub sin6_family: i16,
12769     pub sin6_port: u16,
12770     pub sin6_flowinfo: u32,
12771     pub sin6_addr: IN6_ADDR,
12772 }
12773 impl sockaddr_in6_old {}
12774 impl ::std::default::Default for sockaddr_in6_old {
default() -> Self12775     fn default() -> Self {
12776         unsafe { ::std::mem::zeroed() }
12777     }
12778 }
12779 impl ::std::cmp::PartialEq for sockaddr_in6_old {
eq(&self, _other: &Self) -> bool12780     fn eq(&self, _other: &Self) -> bool {
12781         unimplemented!()
12782     }
12783 }
12784 impl ::std::cmp::Eq for sockaddr_in6_old {}
12785 unsafe impl ::windows::runtime::Abi for sockaddr_in6_old {
12786     type Abi = Self;
12787     type DefaultType = Self;
12788 }
12789 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12790 #[repr(C)]
12791 #[cfg(feature = "Win32_Foundation")]
12792 pub struct sockaddr_ipx {
12793     pub sa_family: i16,
12794     pub sa_netnum: [super::super::Foundation::CHAR; 4],
12795     pub sa_nodenum: [super::super::Foundation::CHAR; 6],
12796     pub sa_socket: u16,
12797 }
12798 #[cfg(feature = "Win32_Foundation")]
12799 impl sockaddr_ipx {}
12800 #[cfg(feature = "Win32_Foundation")]
12801 impl ::std::default::Default for sockaddr_ipx {
default() -> Self12802     fn default() -> Self {
12803         unsafe { ::std::mem::zeroed() }
12804     }
12805 }
12806 #[cfg(feature = "Win32_Foundation")]
12807 impl ::std::fmt::Debug for sockaddr_ipx {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12808     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12809         fmt.debug_struct("sockaddr_ipx").field("sa_family", &self.sa_family).field("sa_netnum", &self.sa_netnum).field("sa_nodenum", &self.sa_nodenum).field("sa_socket", &self.sa_socket).finish()
12810     }
12811 }
12812 #[cfg(feature = "Win32_Foundation")]
12813 impl ::std::cmp::PartialEq for sockaddr_ipx {
eq(&self, other: &Self) -> bool12814     fn eq(&self, other: &Self) -> bool {
12815         self.sa_family == other.sa_family && self.sa_netnum == other.sa_netnum && self.sa_nodenum == other.sa_nodenum && self.sa_socket == other.sa_socket
12816     }
12817 }
12818 #[cfg(feature = "Win32_Foundation")]
12819 impl ::std::cmp::Eq for sockaddr_ipx {}
12820 #[cfg(feature = "Win32_Foundation")]
12821 unsafe impl ::windows::runtime::Abi for sockaddr_ipx {
12822     type Abi = Self;
12823     type DefaultType = Self;
12824 }
12825 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12826 #[repr(C)]
12827 #[cfg(feature = "Win32_Foundation")]
12828 pub struct sockaddr_nb {
12829     pub snb_family: i16,
12830     pub snb_type: u16,
12831     pub snb_name: [super::super::Foundation::CHAR; 16],
12832 }
12833 #[cfg(feature = "Win32_Foundation")]
12834 impl sockaddr_nb {}
12835 #[cfg(feature = "Win32_Foundation")]
12836 impl ::std::default::Default for sockaddr_nb {
default() -> Self12837     fn default() -> Self {
12838         unsafe { ::std::mem::zeroed() }
12839     }
12840 }
12841 #[cfg(feature = "Win32_Foundation")]
12842 impl ::std::fmt::Debug for sockaddr_nb {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12843     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12844         fmt.debug_struct("sockaddr_nb").field("snb_family", &self.snb_family).field("snb_type", &self.snb_type).field("snb_name", &self.snb_name).finish()
12845     }
12846 }
12847 #[cfg(feature = "Win32_Foundation")]
12848 impl ::std::cmp::PartialEq for sockaddr_nb {
eq(&self, other: &Self) -> bool12849     fn eq(&self, other: &Self) -> bool {
12850         self.snb_family == other.snb_family && self.snb_type == other.snb_type && self.snb_name == other.snb_name
12851     }
12852 }
12853 #[cfg(feature = "Win32_Foundation")]
12854 impl ::std::cmp::Eq for sockaddr_nb {}
12855 #[cfg(feature = "Win32_Foundation")]
12856 unsafe impl ::windows::runtime::Abi for sockaddr_nb {
12857     type Abi = Self;
12858     type DefaultType = Self;
12859 }
12860 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12861 #[repr(C)]
12862 pub struct sockaddr_tp {
12863     pub tp_family: u16,
12864     pub tp_addr_type: u16,
12865     pub tp_taddr_len: u16,
12866     pub tp_tsel_len: u16,
12867     pub tp_addr: [u8; 64],
12868 }
12869 impl sockaddr_tp {}
12870 impl ::std::default::Default for sockaddr_tp {
default() -> Self12871     fn default() -> Self {
12872         unsafe { ::std::mem::zeroed() }
12873     }
12874 }
12875 impl ::std::fmt::Debug for sockaddr_tp {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12876     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12877         fmt.debug_struct("sockaddr_tp").field("tp_family", &self.tp_family).field("tp_addr_type", &self.tp_addr_type).field("tp_taddr_len", &self.tp_taddr_len).field("tp_tsel_len", &self.tp_tsel_len).field("tp_addr", &self.tp_addr).finish()
12878     }
12879 }
12880 impl ::std::cmp::PartialEq for sockaddr_tp {
eq(&self, other: &Self) -> bool12881     fn eq(&self, other: &Self) -> bool {
12882         self.tp_family == other.tp_family && self.tp_addr_type == other.tp_addr_type && self.tp_taddr_len == other.tp_taddr_len && self.tp_tsel_len == other.tp_tsel_len && self.tp_addr == other.tp_addr
12883     }
12884 }
12885 impl ::std::cmp::Eq for sockaddr_tp {}
12886 unsafe impl ::windows::runtime::Abi for sockaddr_tp {
12887     type Abi = Self;
12888     type DefaultType = Self;
12889 }
12890 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12891 #[repr(C)]
12892 #[cfg(feature = "Win32_Foundation")]
12893 pub struct sockaddr_un {
12894     pub sun_family: u16,
12895     pub sun_path: [super::super::Foundation::CHAR; 108],
12896 }
12897 #[cfg(feature = "Win32_Foundation")]
12898 impl sockaddr_un {}
12899 #[cfg(feature = "Win32_Foundation")]
12900 impl ::std::default::Default for sockaddr_un {
default() -> Self12901     fn default() -> Self {
12902         unsafe { ::std::mem::zeroed() }
12903     }
12904 }
12905 #[cfg(feature = "Win32_Foundation")]
12906 impl ::std::fmt::Debug for sockaddr_un {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12907     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12908         fmt.debug_struct("sockaddr_un").field("sun_family", &self.sun_family).field("sun_path", &self.sun_path).finish()
12909     }
12910 }
12911 #[cfg(feature = "Win32_Foundation")]
12912 impl ::std::cmp::PartialEq for sockaddr_un {
eq(&self, other: &Self) -> bool12913     fn eq(&self, other: &Self) -> bool {
12914         self.sun_family == other.sun_family && self.sun_path == other.sun_path
12915     }
12916 }
12917 #[cfg(feature = "Win32_Foundation")]
12918 impl ::std::cmp::Eq for sockaddr_un {}
12919 #[cfg(feature = "Win32_Foundation")]
12920 unsafe impl ::windows::runtime::Abi for sockaddr_un {
12921     type Abi = Self;
12922     type DefaultType = Self;
12923 }
12924 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12925 #[repr(C)]
12926 pub struct sockaddr_vns {
12927     pub sin_family: u16,
12928     pub net_address: [u8; 4],
12929     pub subnet_addr: [u8; 2],
12930     pub port: [u8; 2],
12931     pub hops: u8,
12932     pub filler: [u8; 5],
12933 }
12934 impl sockaddr_vns {}
12935 impl ::std::default::Default for sockaddr_vns {
default() -> Self12936     fn default() -> Self {
12937         unsafe { ::std::mem::zeroed() }
12938     }
12939 }
12940 impl ::std::fmt::Debug for sockaddr_vns {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12941     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12942         fmt.debug_struct("sockaddr_vns").field("sin_family", &self.sin_family).field("net_address", &self.net_address).field("subnet_addr", &self.subnet_addr).field("port", &self.port).field("hops", &self.hops).field("filler", &self.filler).finish()
12943     }
12944 }
12945 impl ::std::cmp::PartialEq for sockaddr_vns {
eq(&self, other: &Self) -> bool12946     fn eq(&self, other: &Self) -> bool {
12947         self.sin_family == other.sin_family && self.net_address == other.net_address && self.subnet_addr == other.subnet_addr && self.port == other.port && self.hops == other.hops && self.filler == other.filler
12948     }
12949 }
12950 impl ::std::cmp::Eq for sockaddr_vns {}
12951 unsafe impl ::windows::runtime::Abi for sockaddr_vns {
12952     type Abi = Self;
12953     type DefaultType = Self;
12954 }
12955 #[inline]
socket(af: i32, r#type: i32, protocol: i32) -> SOCKET12956 pub unsafe fn socket(af: i32, r#type: i32, protocol: i32) -> SOCKET {
12957     #[cfg(windows)]
12958     {
12959         #[link(name = "windows")]
12960         extern "system" {
12961             fn socket(af: i32, r#type: i32, protocol: i32) -> SOCKET;
12962         }
12963         ::std::mem::transmute(socket(::std::mem::transmute(af), ::std::mem::transmute(r#type), ::std::mem::transmute(protocol)))
12964     }
12965     #[cfg(not(windows))]
12966     unimplemented!("Unsupported target OS");
12967 }
12968 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12969 #[repr(C)]
12970 pub struct sockproto {
12971     pub sp_family: u16,
12972     pub sp_protocol: u16,
12973 }
12974 impl sockproto {}
12975 impl ::std::default::Default for sockproto {
default() -> Self12976     fn default() -> Self {
12977         unsafe { ::std::mem::zeroed() }
12978     }
12979 }
12980 impl ::std::fmt::Debug for sockproto {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12981     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12982         fmt.debug_struct("sockproto").field("sp_family", &self.sp_family).field("sp_protocol", &self.sp_protocol).finish()
12983     }
12984 }
12985 impl ::std::cmp::PartialEq for sockproto {
eq(&self, other: &Self) -> bool12986     fn eq(&self, other: &Self) -> bool {
12987         self.sp_family == other.sp_family && self.sp_protocol == other.sp_protocol
12988     }
12989 }
12990 impl ::std::cmp::Eq for sockproto {}
12991 unsafe impl ::windows::runtime::Abi for sockproto {
12992     type Abi = Self;
12993     type DefaultType = Self;
12994 }
12995 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12996 #[repr(C)]
12997 pub struct tcp_keepalive {
12998     pub onoff: u32,
12999     pub keepalivetime: u32,
13000     pub keepaliveinterval: u32,
13001 }
13002 impl tcp_keepalive {}
13003 impl ::std::default::Default for tcp_keepalive {
default() -> Self13004     fn default() -> Self {
13005         unsafe { ::std::mem::zeroed() }
13006     }
13007 }
13008 impl ::std::fmt::Debug for tcp_keepalive {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13009     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13010         fmt.debug_struct("tcp_keepalive").field("onoff", &self.onoff).field("keepalivetime", &self.keepalivetime).field("keepaliveinterval", &self.keepaliveinterval).finish()
13011     }
13012 }
13013 impl ::std::cmp::PartialEq for tcp_keepalive {
eq(&self, other: &Self) -> bool13014     fn eq(&self, other: &Self) -> bool {
13015         self.onoff == other.onoff && self.keepalivetime == other.keepalivetime && self.keepaliveinterval == other.keepaliveinterval
13016     }
13017 }
13018 impl ::std::cmp::Eq for tcp_keepalive {}
13019 unsafe impl ::windows::runtime::Abi for tcp_keepalive {
13020     type Abi = Self;
13021     type DefaultType = Self;
13022 }
13023 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
13024 #[repr(C)]
13025 pub struct timeval {
13026     pub tv_sec: i32,
13027     pub tv_usec: i32,
13028 }
13029 impl timeval {}
13030 impl ::std::default::Default for timeval {
default() -> Self13031     fn default() -> Self {
13032         unsafe { ::std::mem::zeroed() }
13033     }
13034 }
13035 impl ::std::fmt::Debug for timeval {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result13036     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
13037         fmt.debug_struct("timeval").field("tv_sec", &self.tv_sec).field("tv_usec", &self.tv_usec).finish()
13038     }
13039 }
13040 impl ::std::cmp::PartialEq for timeval {
eq(&self, other: &Self) -> bool13041     fn eq(&self, other: &Self) -> bool {
13042         self.tv_sec == other.tv_sec && self.tv_usec == other.tv_usec
13043     }
13044 }
13045 impl ::std::cmp::Eq for timeval {}
13046 unsafe impl ::windows::runtime::Abi for timeval {
13047     type Abi = Self;
13048     type DefaultType = Self;
13049 }
13050