1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const ADDRESS_TYPE_IANA: u32 = 0u32;
3 pub const ADDRESS_TYPE_IATA: u32 = 1u32;
4 pub const CHANGESTATE: u32 = 4u32;
5 pub const CLIENT_TYPE_BOOTP: u32 = 2u32;
6 pub const CLIENT_TYPE_DHCP: u32 = 1u32;
7 pub const CLIENT_TYPE_NONE: u32 = 100u32;
8 pub const CLIENT_TYPE_RESERVATION_FLAG: u32 = 4u32;
9 pub const CLIENT_TYPE_UNSPECIFIED: u32 = 0u32;
10 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11 #[repr(C)]
12 pub struct DATE_TIME {
13 pub dwLowDateTime: u32,
14 pub dwHighDateTime: u32,
15 }
16 impl DATE_TIME {}
17 impl ::std::default::Default for DATE_TIME {
default() -> Self18 fn default() -> Self {
19 unsafe { ::std::mem::zeroed() }
20 }
21 }
22 impl ::std::fmt::Debug for DATE_TIME {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result23 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
24 fmt.debug_struct("DATE_TIME").field("dwLowDateTime", &self.dwLowDateTime).field("dwHighDateTime", &self.dwHighDateTime).finish()
25 }
26 }
27 impl ::std::cmp::PartialEq for DATE_TIME {
eq(&self, other: &Self) -> bool28 fn eq(&self, other: &Self) -> bool {
29 self.dwLowDateTime == other.dwLowDateTime && self.dwHighDateTime == other.dwHighDateTime
30 }
31 }
32 impl ::std::cmp::Eq for DATE_TIME {}
33 unsafe impl ::windows::runtime::Abi for DATE_TIME {
34 type Abi = Self;
35 type DefaultType = Self;
36 }
37 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
38 #[repr(C)]
39 #[cfg(feature = "Win32_Foundation")]
40 pub struct DHCPAPI_PARAMS {
41 pub Flags: u32,
42 pub OptionId: u32,
43 pub IsVendor: super::super::Foundation::BOOL,
44 pub Data: *mut u8,
45 pub nBytesData: u32,
46 }
47 #[cfg(feature = "Win32_Foundation")]
48 impl DHCPAPI_PARAMS {}
49 #[cfg(feature = "Win32_Foundation")]
50 impl ::std::default::Default for DHCPAPI_PARAMS {
default() -> Self51 fn default() -> Self {
52 unsafe { ::std::mem::zeroed() }
53 }
54 }
55 #[cfg(feature = "Win32_Foundation")]
56 impl ::std::fmt::Debug for DHCPAPI_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result57 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
58 fmt.debug_struct("DHCPAPI_PARAMS").field("Flags", &self.Flags).field("OptionId", &self.OptionId).field("IsVendor", &self.IsVendor).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
59 }
60 }
61 #[cfg(feature = "Win32_Foundation")]
62 impl ::std::cmp::PartialEq for DHCPAPI_PARAMS {
eq(&self, other: &Self) -> bool63 fn eq(&self, other: &Self) -> bool {
64 self.Flags == other.Flags && self.OptionId == other.OptionId && self.IsVendor == other.IsVendor && self.Data == other.Data && self.nBytesData == other.nBytesData
65 }
66 }
67 #[cfg(feature = "Win32_Foundation")]
68 impl ::std::cmp::Eq for DHCPAPI_PARAMS {}
69 #[cfg(feature = "Win32_Foundation")]
70 unsafe impl ::windows::runtime::Abi for DHCPAPI_PARAMS {
71 type Abi = Self;
72 type DefaultType = Self;
73 }
74 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
75 #[repr(C)]
76 pub struct DHCPCAPI_CLASSID {
77 pub Flags: u32,
78 pub Data: *mut u8,
79 pub nBytesData: u32,
80 }
81 impl DHCPCAPI_CLASSID {}
82 impl ::std::default::Default for DHCPCAPI_CLASSID {
default() -> Self83 fn default() -> Self {
84 unsafe { ::std::mem::zeroed() }
85 }
86 }
87 impl ::std::fmt::Debug for DHCPCAPI_CLASSID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result88 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
89 fmt.debug_struct("DHCPCAPI_CLASSID").field("Flags", &self.Flags).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
90 }
91 }
92 impl ::std::cmp::PartialEq for DHCPCAPI_CLASSID {
eq(&self, other: &Self) -> bool93 fn eq(&self, other: &Self) -> bool {
94 self.Flags == other.Flags && self.Data == other.Data && self.nBytesData == other.nBytesData
95 }
96 }
97 impl ::std::cmp::Eq for DHCPCAPI_CLASSID {}
98 unsafe impl ::windows::runtime::Abi for DHCPCAPI_CLASSID {
99 type Abi = Self;
100 type DefaultType = Self;
101 }
102 pub const DHCPCAPI_DEREGISTER_HANDLE_EVENT: u32 = 1u32;
103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
104 #[repr(C)]
105 #[cfg(feature = "Win32_Foundation")]
106 pub struct DHCPCAPI_PARAMS_ARRAY {
107 pub nParams: u32,
108 pub Params: *mut DHCPAPI_PARAMS,
109 }
110 #[cfg(feature = "Win32_Foundation")]
111 impl DHCPCAPI_PARAMS_ARRAY {}
112 #[cfg(feature = "Win32_Foundation")]
113 impl ::std::default::Default for DHCPCAPI_PARAMS_ARRAY {
default() -> Self114 fn default() -> Self {
115 unsafe { ::std::mem::zeroed() }
116 }
117 }
118 #[cfg(feature = "Win32_Foundation")]
119 impl ::std::fmt::Debug for DHCPCAPI_PARAMS_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result120 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
121 fmt.debug_struct("DHCPCAPI_PARAMS_ARRAY").field("nParams", &self.nParams).field("Params", &self.Params).finish()
122 }
123 }
124 #[cfg(feature = "Win32_Foundation")]
125 impl ::std::cmp::PartialEq for DHCPCAPI_PARAMS_ARRAY {
eq(&self, other: &Self) -> bool126 fn eq(&self, other: &Self) -> bool {
127 self.nParams == other.nParams && self.Params == other.Params
128 }
129 }
130 #[cfg(feature = "Win32_Foundation")]
131 impl ::std::cmp::Eq for DHCPCAPI_PARAMS_ARRAY {}
132 #[cfg(feature = "Win32_Foundation")]
133 unsafe impl ::windows::runtime::Abi for DHCPCAPI_PARAMS_ARRAY {
134 type Abi = Self;
135 type DefaultType = Self;
136 }
137 pub const DHCPCAPI_REGISTER_HANDLE_EVENT: u32 = 1u32;
138 pub const DHCPCAPI_REQUEST_ASYNCHRONOUS: u32 = 4u32;
139 pub const DHCPCAPI_REQUEST_CANCEL: u32 = 8u32;
140 pub const DHCPCAPI_REQUEST_MASK: u32 = 15u32;
141 pub const DHCPCAPI_REQUEST_PERSISTENT: u32 = 1u32;
142 pub const DHCPCAPI_REQUEST_SYNCHRONOUS: u32 = 2u32;
143 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
144 #[repr(C)]
145 #[cfg(feature = "Win32_Foundation")]
146 pub struct DHCPDS_SERVER {
147 pub Version: u32,
148 pub ServerName: super::super::Foundation::PWSTR,
149 pub ServerAddress: u32,
150 pub Flags: u32,
151 pub State: u32,
152 pub DsLocation: super::super::Foundation::PWSTR,
153 pub DsLocType: u32,
154 }
155 #[cfg(feature = "Win32_Foundation")]
156 impl DHCPDS_SERVER {}
157 #[cfg(feature = "Win32_Foundation")]
158 impl ::std::default::Default for DHCPDS_SERVER {
default() -> Self159 fn default() -> Self {
160 unsafe { ::std::mem::zeroed() }
161 }
162 }
163 #[cfg(feature = "Win32_Foundation")]
164 impl ::std::fmt::Debug for DHCPDS_SERVER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result165 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
166 fmt.debug_struct("DHCPDS_SERVER").field("Version", &self.Version).field("ServerName", &self.ServerName).field("ServerAddress", &self.ServerAddress).field("Flags", &self.Flags).field("State", &self.State).field("DsLocation", &self.DsLocation).field("DsLocType", &self.DsLocType).finish()
167 }
168 }
169 #[cfg(feature = "Win32_Foundation")]
170 impl ::std::cmp::PartialEq for DHCPDS_SERVER {
eq(&self, other: &Self) -> bool171 fn eq(&self, other: &Self) -> bool {
172 self.Version == other.Version && self.ServerName == other.ServerName && self.ServerAddress == other.ServerAddress && self.Flags == other.Flags && self.State == other.State && self.DsLocation == other.DsLocation && self.DsLocType == other.DsLocType
173 }
174 }
175 #[cfg(feature = "Win32_Foundation")]
176 impl ::std::cmp::Eq for DHCPDS_SERVER {}
177 #[cfg(feature = "Win32_Foundation")]
178 unsafe impl ::windows::runtime::Abi for DHCPDS_SERVER {
179 type Abi = Self;
180 type DefaultType = Self;
181 }
182 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
183 #[repr(C)]
184 #[cfg(feature = "Win32_Foundation")]
185 pub struct DHCPDS_SERVERS {
186 pub Flags: u32,
187 pub NumElements: u32,
188 pub Servers: *mut DHCPDS_SERVER,
189 }
190 #[cfg(feature = "Win32_Foundation")]
191 impl DHCPDS_SERVERS {}
192 #[cfg(feature = "Win32_Foundation")]
193 impl ::std::default::Default for DHCPDS_SERVERS {
default() -> Self194 fn default() -> Self {
195 unsafe { ::std::mem::zeroed() }
196 }
197 }
198 #[cfg(feature = "Win32_Foundation")]
199 impl ::std::fmt::Debug for DHCPDS_SERVERS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result200 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
201 fmt.debug_struct("DHCPDS_SERVERS").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Servers", &self.Servers).finish()
202 }
203 }
204 #[cfg(feature = "Win32_Foundation")]
205 impl ::std::cmp::PartialEq for DHCPDS_SERVERS {
eq(&self, other: &Self) -> bool206 fn eq(&self, other: &Self) -> bool {
207 self.Flags == other.Flags && self.NumElements == other.NumElements && self.Servers == other.Servers
208 }
209 }
210 #[cfg(feature = "Win32_Foundation")]
211 impl ::std::cmp::Eq for DHCPDS_SERVERS {}
212 #[cfg(feature = "Win32_Foundation")]
213 unsafe impl ::windows::runtime::Abi for DHCPDS_SERVERS {
214 type Abi = Self;
215 type DefaultType = Self;
216 }
217 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
218 #[repr(C)]
219 #[cfg(feature = "Win32_Foundation")]
220 pub struct DHCPV4_FAILOVER_CLIENT_INFO {
221 pub ClientIpAddress: u32,
222 pub SubnetMask: u32,
223 pub ClientHardwareAddress: DHCP_BINARY_DATA,
224 pub ClientName: super::super::Foundation::PWSTR,
225 pub ClientComment: super::super::Foundation::PWSTR,
226 pub ClientLeaseExpires: DATE_TIME,
227 pub OwnerHost: DHCP_HOST_INFO,
228 pub bClientType: u8,
229 pub AddressState: u8,
230 pub Status: QuarantineStatus,
231 pub ProbationEnds: DATE_TIME,
232 pub QuarantineCapable: super::super::Foundation::BOOL,
233 pub SentPotExpTime: u32,
234 pub AckPotExpTime: u32,
235 pub RecvPotExpTime: u32,
236 pub StartTime: u32,
237 pub CltLastTransTime: u32,
238 pub LastBndUpdTime: u32,
239 pub BndMsgStatus: u32,
240 pub PolicyName: super::super::Foundation::PWSTR,
241 pub Flags: u8,
242 }
243 #[cfg(feature = "Win32_Foundation")]
244 impl DHCPV4_FAILOVER_CLIENT_INFO {}
245 #[cfg(feature = "Win32_Foundation")]
246 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO {
default() -> Self247 fn default() -> Self {
248 unsafe { ::std::mem::zeroed() }
249 }
250 }
251 #[cfg(feature = "Win32_Foundation")]
252 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result253 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
254 fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO")
255 .field("ClientIpAddress", &self.ClientIpAddress)
256 .field("SubnetMask", &self.SubnetMask)
257 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
258 .field("ClientName", &self.ClientName)
259 .field("ClientComment", &self.ClientComment)
260 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
261 .field("OwnerHost", &self.OwnerHost)
262 .field("bClientType", &self.bClientType)
263 .field("AddressState", &self.AddressState)
264 .field("Status", &self.Status)
265 .field("ProbationEnds", &self.ProbationEnds)
266 .field("QuarantineCapable", &self.QuarantineCapable)
267 .field("SentPotExpTime", &self.SentPotExpTime)
268 .field("AckPotExpTime", &self.AckPotExpTime)
269 .field("RecvPotExpTime", &self.RecvPotExpTime)
270 .field("StartTime", &self.StartTime)
271 .field("CltLastTransTime", &self.CltLastTransTime)
272 .field("LastBndUpdTime", &self.LastBndUpdTime)
273 .field("BndMsgStatus", &self.BndMsgStatus)
274 .field("PolicyName", &self.PolicyName)
275 .field("Flags", &self.Flags)
276 .finish()
277 }
278 }
279 #[cfg(feature = "Win32_Foundation")]
280 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO {
eq(&self, other: &Self) -> bool281 fn eq(&self, other: &Self) -> bool {
282 self.ClientIpAddress == other.ClientIpAddress
283 && self.SubnetMask == other.SubnetMask
284 && self.ClientHardwareAddress == other.ClientHardwareAddress
285 && self.ClientName == other.ClientName
286 && self.ClientComment == other.ClientComment
287 && self.ClientLeaseExpires == other.ClientLeaseExpires
288 && self.OwnerHost == other.OwnerHost
289 && self.bClientType == other.bClientType
290 && self.AddressState == other.AddressState
291 && self.Status == other.Status
292 && self.ProbationEnds == other.ProbationEnds
293 && self.QuarantineCapable == other.QuarantineCapable
294 && self.SentPotExpTime == other.SentPotExpTime
295 && self.AckPotExpTime == other.AckPotExpTime
296 && self.RecvPotExpTime == other.RecvPotExpTime
297 && self.StartTime == other.StartTime
298 && self.CltLastTransTime == other.CltLastTransTime
299 && self.LastBndUpdTime == other.LastBndUpdTime
300 && self.BndMsgStatus == other.BndMsgStatus
301 && self.PolicyName == other.PolicyName
302 && self.Flags == other.Flags
303 }
304 }
305 #[cfg(feature = "Win32_Foundation")]
306 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO {}
307 #[cfg(feature = "Win32_Foundation")]
308 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO {
309 type Abi = Self;
310 type DefaultType = Self;
311 }
312 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
313 #[repr(C)]
314 #[cfg(feature = "Win32_Foundation")]
315 pub struct DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
316 pub NumElements: u32,
317 pub Clients: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO,
318 }
319 #[cfg(feature = "Win32_Foundation")]
320 impl DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {}
321 #[cfg(feature = "Win32_Foundation")]
322 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
default() -> Self323 fn default() -> Self {
324 unsafe { ::std::mem::zeroed() }
325 }
326 }
327 #[cfg(feature = "Win32_Foundation")]
328 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result329 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
330 fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
331 }
332 }
333 #[cfg(feature = "Win32_Foundation")]
334 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool335 fn eq(&self, other: &Self) -> bool {
336 self.NumElements == other.NumElements && self.Clients == other.Clients
337 }
338 }
339 #[cfg(feature = "Win32_Foundation")]
340 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {}
341 #[cfg(feature = "Win32_Foundation")]
342 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO_ARRAY {
343 type Abi = Self;
344 type DefaultType = Self;
345 }
346 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
347 #[repr(C)]
348 #[cfg(feature = "Win32_Foundation")]
349 pub struct DHCPV4_FAILOVER_CLIENT_INFO_EX {
350 pub ClientIpAddress: u32,
351 pub SubnetMask: u32,
352 pub ClientHardwareAddress: DHCP_BINARY_DATA,
353 pub ClientName: super::super::Foundation::PWSTR,
354 pub ClientComment: super::super::Foundation::PWSTR,
355 pub ClientLeaseExpires: DATE_TIME,
356 pub OwnerHost: DHCP_HOST_INFO,
357 pub bClientType: u8,
358 pub AddressState: u8,
359 pub Status: QuarantineStatus,
360 pub ProbationEnds: DATE_TIME,
361 pub QuarantineCapable: super::super::Foundation::BOOL,
362 pub SentPotExpTime: u32,
363 pub AckPotExpTime: u32,
364 pub RecvPotExpTime: u32,
365 pub StartTime: u32,
366 pub CltLastTransTime: u32,
367 pub LastBndUpdTime: u32,
368 pub BndMsgStatus: u32,
369 pub PolicyName: super::super::Foundation::PWSTR,
370 pub Flags: u8,
371 pub AddressStateEx: u32,
372 }
373 #[cfg(feature = "Win32_Foundation")]
374 impl DHCPV4_FAILOVER_CLIENT_INFO_EX {}
375 #[cfg(feature = "Win32_Foundation")]
376 impl ::std::default::Default for DHCPV4_FAILOVER_CLIENT_INFO_EX {
default() -> Self377 fn default() -> Self {
378 unsafe { ::std::mem::zeroed() }
379 }
380 }
381 #[cfg(feature = "Win32_Foundation")]
382 impl ::std::fmt::Debug for DHCPV4_FAILOVER_CLIENT_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result383 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
384 fmt.debug_struct("DHCPV4_FAILOVER_CLIENT_INFO_EX")
385 .field("ClientIpAddress", &self.ClientIpAddress)
386 .field("SubnetMask", &self.SubnetMask)
387 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
388 .field("ClientName", &self.ClientName)
389 .field("ClientComment", &self.ClientComment)
390 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
391 .field("OwnerHost", &self.OwnerHost)
392 .field("bClientType", &self.bClientType)
393 .field("AddressState", &self.AddressState)
394 .field("Status", &self.Status)
395 .field("ProbationEnds", &self.ProbationEnds)
396 .field("QuarantineCapable", &self.QuarantineCapable)
397 .field("SentPotExpTime", &self.SentPotExpTime)
398 .field("AckPotExpTime", &self.AckPotExpTime)
399 .field("RecvPotExpTime", &self.RecvPotExpTime)
400 .field("StartTime", &self.StartTime)
401 .field("CltLastTransTime", &self.CltLastTransTime)
402 .field("LastBndUpdTime", &self.LastBndUpdTime)
403 .field("BndMsgStatus", &self.BndMsgStatus)
404 .field("PolicyName", &self.PolicyName)
405 .field("Flags", &self.Flags)
406 .field("AddressStateEx", &self.AddressStateEx)
407 .finish()
408 }
409 }
410 #[cfg(feature = "Win32_Foundation")]
411 impl ::std::cmp::PartialEq for DHCPV4_FAILOVER_CLIENT_INFO_EX {
eq(&self, other: &Self) -> bool412 fn eq(&self, other: &Self) -> bool {
413 self.ClientIpAddress == other.ClientIpAddress
414 && self.SubnetMask == other.SubnetMask
415 && self.ClientHardwareAddress == other.ClientHardwareAddress
416 && self.ClientName == other.ClientName
417 && self.ClientComment == other.ClientComment
418 && self.ClientLeaseExpires == other.ClientLeaseExpires
419 && self.OwnerHost == other.OwnerHost
420 && self.bClientType == other.bClientType
421 && self.AddressState == other.AddressState
422 && self.Status == other.Status
423 && self.ProbationEnds == other.ProbationEnds
424 && self.QuarantineCapable == other.QuarantineCapable
425 && self.SentPotExpTime == other.SentPotExpTime
426 && self.AckPotExpTime == other.AckPotExpTime
427 && self.RecvPotExpTime == other.RecvPotExpTime
428 && self.StartTime == other.StartTime
429 && self.CltLastTransTime == other.CltLastTransTime
430 && self.LastBndUpdTime == other.LastBndUpdTime
431 && self.BndMsgStatus == other.BndMsgStatus
432 && self.PolicyName == other.PolicyName
433 && self.Flags == other.Flags
434 && self.AddressStateEx == other.AddressStateEx
435 }
436 }
437 #[cfg(feature = "Win32_Foundation")]
438 impl ::std::cmp::Eq for DHCPV4_FAILOVER_CLIENT_INFO_EX {}
439 #[cfg(feature = "Win32_Foundation")]
440 unsafe impl ::windows::runtime::Abi for DHCPV4_FAILOVER_CLIENT_INFO_EX {
441 type Abi = Self;
442 type DefaultType = Self;
443 }
444 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
445 #[repr(C)]
446 pub struct DHCPV6CAPI_CLASSID {
447 pub Flags: u32,
448 pub Data: *mut u8,
449 pub nBytesData: u32,
450 }
451 impl DHCPV6CAPI_CLASSID {}
452 impl ::std::default::Default for DHCPV6CAPI_CLASSID {
default() -> Self453 fn default() -> Self {
454 unsafe { ::std::mem::zeroed() }
455 }
456 }
457 impl ::std::fmt::Debug for DHCPV6CAPI_CLASSID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result458 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
459 fmt.debug_struct("DHCPV6CAPI_CLASSID").field("Flags", &self.Flags).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
460 }
461 }
462 impl ::std::cmp::PartialEq for DHCPV6CAPI_CLASSID {
eq(&self, other: &Self) -> bool463 fn eq(&self, other: &Self) -> bool {
464 self.Flags == other.Flags && self.Data == other.Data && self.nBytesData == other.nBytesData
465 }
466 }
467 impl ::std::cmp::Eq for DHCPV6CAPI_CLASSID {}
468 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_CLASSID {
469 type Abi = Self;
470 type DefaultType = Self;
471 }
472 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
473 #[repr(C)]
474 #[cfg(feature = "Win32_Foundation")]
475 pub struct DHCPV6CAPI_PARAMS {
476 pub Flags: u32,
477 pub OptionId: u32,
478 pub IsVendor: super::super::Foundation::BOOL,
479 pub Data: *mut u8,
480 pub nBytesData: u32,
481 }
482 #[cfg(feature = "Win32_Foundation")]
483 impl DHCPV6CAPI_PARAMS {}
484 #[cfg(feature = "Win32_Foundation")]
485 impl ::std::default::Default for DHCPV6CAPI_PARAMS {
default() -> Self486 fn default() -> Self {
487 unsafe { ::std::mem::zeroed() }
488 }
489 }
490 #[cfg(feature = "Win32_Foundation")]
491 impl ::std::fmt::Debug for DHCPV6CAPI_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result492 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
493 fmt.debug_struct("DHCPV6CAPI_PARAMS").field("Flags", &self.Flags).field("OptionId", &self.OptionId).field("IsVendor", &self.IsVendor).field("Data", &self.Data).field("nBytesData", &self.nBytesData).finish()
494 }
495 }
496 #[cfg(feature = "Win32_Foundation")]
497 impl ::std::cmp::PartialEq for DHCPV6CAPI_PARAMS {
eq(&self, other: &Self) -> bool498 fn eq(&self, other: &Self) -> bool {
499 self.Flags == other.Flags && self.OptionId == other.OptionId && self.IsVendor == other.IsVendor && self.Data == other.Data && self.nBytesData == other.nBytesData
500 }
501 }
502 #[cfg(feature = "Win32_Foundation")]
503 impl ::std::cmp::Eq for DHCPV6CAPI_PARAMS {}
504 #[cfg(feature = "Win32_Foundation")]
505 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_PARAMS {
506 type Abi = Self;
507 type DefaultType = Self;
508 }
509 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
510 #[repr(C)]
511 #[cfg(feature = "Win32_Foundation")]
512 pub struct DHCPV6CAPI_PARAMS_ARRAY {
513 pub nParams: u32,
514 pub Params: *mut DHCPV6CAPI_PARAMS,
515 }
516 #[cfg(feature = "Win32_Foundation")]
517 impl DHCPV6CAPI_PARAMS_ARRAY {}
518 #[cfg(feature = "Win32_Foundation")]
519 impl ::std::default::Default for DHCPV6CAPI_PARAMS_ARRAY {
default() -> Self520 fn default() -> Self {
521 unsafe { ::std::mem::zeroed() }
522 }
523 }
524 #[cfg(feature = "Win32_Foundation")]
525 impl ::std::fmt::Debug for DHCPV6CAPI_PARAMS_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result526 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
527 fmt.debug_struct("DHCPV6CAPI_PARAMS_ARRAY").field("nParams", &self.nParams).field("Params", &self.Params).finish()
528 }
529 }
530 #[cfg(feature = "Win32_Foundation")]
531 impl ::std::cmp::PartialEq for DHCPV6CAPI_PARAMS_ARRAY {
eq(&self, other: &Self) -> bool532 fn eq(&self, other: &Self) -> bool {
533 self.nParams == other.nParams && self.Params == other.Params
534 }
535 }
536 #[cfg(feature = "Win32_Foundation")]
537 impl ::std::cmp::Eq for DHCPV6CAPI_PARAMS_ARRAY {}
538 #[cfg(feature = "Win32_Foundation")]
539 unsafe impl ::windows::runtime::Abi for DHCPV6CAPI_PARAMS_ARRAY {
540 type Abi = Self;
541 type DefaultType = Self;
542 }
543 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
544 #[repr(C)]
545 pub struct DHCPV6Prefix {
546 pub prefix: [u8; 16],
547 pub prefixLength: u32,
548 pub preferredLifeTime: u32,
549 pub validLifeTime: u32,
550 pub status: StatusCode,
551 }
552 impl DHCPV6Prefix {}
553 impl ::std::default::Default for DHCPV6Prefix {
default() -> Self554 fn default() -> Self {
555 unsafe { ::std::mem::zeroed() }
556 }
557 }
558 impl ::std::fmt::Debug for DHCPV6Prefix {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result559 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
560 fmt.debug_struct("DHCPV6Prefix").field("prefix", &self.prefix).field("prefixLength", &self.prefixLength).field("preferredLifeTime", &self.preferredLifeTime).field("validLifeTime", &self.validLifeTime).field("status", &self.status).finish()
561 }
562 }
563 impl ::std::cmp::PartialEq for DHCPV6Prefix {
eq(&self, other: &Self) -> bool564 fn eq(&self, other: &Self) -> bool {
565 self.prefix == other.prefix && self.prefixLength == other.prefixLength && self.preferredLifeTime == other.preferredLifeTime && self.validLifeTime == other.validLifeTime && self.status == other.status
566 }
567 }
568 impl ::std::cmp::Eq for DHCPV6Prefix {}
569 unsafe impl ::windows::runtime::Abi for DHCPV6Prefix {
570 type Abi = Self;
571 type DefaultType = Self;
572 }
573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
574 #[repr(C)]
575 pub struct DHCPV6PrefixLeaseInformation {
576 pub nPrefixes: u32,
577 pub prefixArray: *mut DHCPV6Prefix,
578 pub iaid: u32,
579 pub T1: i64,
580 pub T2: i64,
581 pub MaxLeaseExpirationTime: i64,
582 pub LastRenewalTime: i64,
583 pub status: StatusCode,
584 pub ServerId: *mut u8,
585 pub ServerIdLen: u32,
586 }
587 impl DHCPV6PrefixLeaseInformation {}
588 impl ::std::default::Default for DHCPV6PrefixLeaseInformation {
default() -> Self589 fn default() -> Self {
590 unsafe { ::std::mem::zeroed() }
591 }
592 }
593 impl ::std::fmt::Debug for DHCPV6PrefixLeaseInformation {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result594 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
595 fmt.debug_struct("DHCPV6PrefixLeaseInformation")
596 .field("nPrefixes", &self.nPrefixes)
597 .field("prefixArray", &self.prefixArray)
598 .field("iaid", &self.iaid)
599 .field("T1", &self.T1)
600 .field("T2", &self.T2)
601 .field("MaxLeaseExpirationTime", &self.MaxLeaseExpirationTime)
602 .field("LastRenewalTime", &self.LastRenewalTime)
603 .field("status", &self.status)
604 .field("ServerId", &self.ServerId)
605 .field("ServerIdLen", &self.ServerIdLen)
606 .finish()
607 }
608 }
609 impl ::std::cmp::PartialEq for DHCPV6PrefixLeaseInformation {
eq(&self, other: &Self) -> bool610 fn eq(&self, other: &Self) -> bool {
611 self.nPrefixes == other.nPrefixes && self.prefixArray == other.prefixArray && self.iaid == other.iaid && self.T1 == other.T1 && self.T2 == other.T2 && self.MaxLeaseExpirationTime == other.MaxLeaseExpirationTime && self.LastRenewalTime == other.LastRenewalTime && self.status == other.status && self.ServerId == other.ServerId && self.ServerIdLen == other.ServerIdLen
612 }
613 }
614 impl ::std::cmp::Eq for DHCPV6PrefixLeaseInformation {}
615 unsafe impl ::windows::runtime::Abi for DHCPV6PrefixLeaseInformation {
616 type Abi = Self;
617 type DefaultType = Self;
618 }
619 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
620 #[repr(C)]
621 #[cfg(feature = "Win32_Foundation")]
622 pub struct DHCPV6_BIND_ELEMENT {
623 pub Flags: u32,
624 pub fBoundToDHCPServer: super::super::Foundation::BOOL,
625 pub AdapterPrimaryAddress: DHCP_IPV6_ADDRESS,
626 pub AdapterSubnetAddress: DHCP_IPV6_ADDRESS,
627 pub IfDescription: super::super::Foundation::PWSTR,
628 pub IpV6IfIndex: u32,
629 pub IfIdSize: u32,
630 pub IfId: *mut u8,
631 }
632 #[cfg(feature = "Win32_Foundation")]
633 impl DHCPV6_BIND_ELEMENT {}
634 #[cfg(feature = "Win32_Foundation")]
635 impl ::std::default::Default for DHCPV6_BIND_ELEMENT {
default() -> Self636 fn default() -> Self {
637 unsafe { ::std::mem::zeroed() }
638 }
639 }
640 #[cfg(feature = "Win32_Foundation")]
641 impl ::std::fmt::Debug for DHCPV6_BIND_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result642 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
643 fmt.debug_struct("DHCPV6_BIND_ELEMENT")
644 .field("Flags", &self.Flags)
645 .field("fBoundToDHCPServer", &self.fBoundToDHCPServer)
646 .field("AdapterPrimaryAddress", &self.AdapterPrimaryAddress)
647 .field("AdapterSubnetAddress", &self.AdapterSubnetAddress)
648 .field("IfDescription", &self.IfDescription)
649 .field("IpV6IfIndex", &self.IpV6IfIndex)
650 .field("IfIdSize", &self.IfIdSize)
651 .field("IfId", &self.IfId)
652 .finish()
653 }
654 }
655 #[cfg(feature = "Win32_Foundation")]
656 impl ::std::cmp::PartialEq for DHCPV6_BIND_ELEMENT {
eq(&self, other: &Self) -> bool657 fn eq(&self, other: &Self) -> bool {
658 self.Flags == other.Flags && self.fBoundToDHCPServer == other.fBoundToDHCPServer && self.AdapterPrimaryAddress == other.AdapterPrimaryAddress && self.AdapterSubnetAddress == other.AdapterSubnetAddress && self.IfDescription == other.IfDescription && self.IpV6IfIndex == other.IpV6IfIndex && self.IfIdSize == other.IfIdSize && self.IfId == other.IfId
659 }
660 }
661 #[cfg(feature = "Win32_Foundation")]
662 impl ::std::cmp::Eq for DHCPV6_BIND_ELEMENT {}
663 #[cfg(feature = "Win32_Foundation")]
664 unsafe impl ::windows::runtime::Abi for DHCPV6_BIND_ELEMENT {
665 type Abi = Self;
666 type DefaultType = Self;
667 }
668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
669 #[repr(C)]
670 #[cfg(feature = "Win32_Foundation")]
671 pub struct DHCPV6_BIND_ELEMENT_ARRAY {
672 pub NumElements: u32,
673 pub Elements: *mut DHCPV6_BIND_ELEMENT,
674 }
675 #[cfg(feature = "Win32_Foundation")]
676 impl DHCPV6_BIND_ELEMENT_ARRAY {}
677 #[cfg(feature = "Win32_Foundation")]
678 impl ::std::default::Default for DHCPV6_BIND_ELEMENT_ARRAY {
default() -> Self679 fn default() -> Self {
680 unsafe { ::std::mem::zeroed() }
681 }
682 }
683 #[cfg(feature = "Win32_Foundation")]
684 impl ::std::fmt::Debug for DHCPV6_BIND_ELEMENT_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result685 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
686 fmt.debug_struct("DHCPV6_BIND_ELEMENT_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
687 }
688 }
689 #[cfg(feature = "Win32_Foundation")]
690 impl ::std::cmp::PartialEq for DHCPV6_BIND_ELEMENT_ARRAY {
eq(&self, other: &Self) -> bool691 fn eq(&self, other: &Self) -> bool {
692 self.NumElements == other.NumElements && self.Elements == other.Elements
693 }
694 }
695 #[cfg(feature = "Win32_Foundation")]
696 impl ::std::cmp::Eq for DHCPV6_BIND_ELEMENT_ARRAY {}
697 #[cfg(feature = "Win32_Foundation")]
698 unsafe impl ::windows::runtime::Abi for DHCPV6_BIND_ELEMENT_ARRAY {
699 type Abi = Self;
700 type DefaultType = Self;
701 }
702 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
703 #[repr(C)]
704 pub struct DHCPV6_IP_ARRAY {
705 pub NumElements: u32,
706 pub Elements: *mut DHCP_IPV6_ADDRESS,
707 }
708 impl DHCPV6_IP_ARRAY {}
709 impl ::std::default::Default for DHCPV6_IP_ARRAY {
default() -> Self710 fn default() -> Self {
711 unsafe { ::std::mem::zeroed() }
712 }
713 }
714 impl ::std::fmt::Debug for DHCPV6_IP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result715 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
716 fmt.debug_struct("DHCPV6_IP_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
717 }
718 }
719 impl ::std::cmp::PartialEq for DHCPV6_IP_ARRAY {
eq(&self, other: &Self) -> bool720 fn eq(&self, other: &Self) -> bool {
721 self.NumElements == other.NumElements && self.Elements == other.Elements
722 }
723 }
724 impl ::std::cmp::Eq for DHCPV6_IP_ARRAY {}
725 unsafe impl ::windows::runtime::Abi for DHCPV6_IP_ARRAY {
726 type Abi = Self;
727 type DefaultType = Self;
728 }
729 pub const DHCPV6_OPTION_CLIENTID: u32 = 1u32;
730 pub const DHCPV6_OPTION_DNS_SERVERS: u32 = 23u32;
731 pub const DHCPV6_OPTION_DOMAIN_LIST: u32 = 24u32;
732 pub const DHCPV6_OPTION_IA_NA: u32 = 3u32;
733 pub const DHCPV6_OPTION_IA_PD: u32 = 25u32;
734 pub const DHCPV6_OPTION_IA_TA: u32 = 4u32;
735 pub const DHCPV6_OPTION_NISP_DOMAIN_NAME: u32 = 30u32;
736 pub const DHCPV6_OPTION_NISP_SERVERS: u32 = 28u32;
737 pub const DHCPV6_OPTION_NIS_DOMAIN_NAME: u32 = 29u32;
738 pub const DHCPV6_OPTION_NIS_SERVERS: u32 = 27u32;
739 pub const DHCPV6_OPTION_ORO: u32 = 6u32;
740 pub const DHCPV6_OPTION_PREFERENCE: u32 = 7u32;
741 pub const DHCPV6_OPTION_RAPID_COMMIT: u32 = 14u32;
742 pub const DHCPV6_OPTION_RECONF_MSG: u32 = 19u32;
743 pub const DHCPV6_OPTION_SERVERID: u32 = 2u32;
744 pub const DHCPV6_OPTION_SIP_SERVERS_ADDRS: u32 = 22u32;
745 pub const DHCPV6_OPTION_SIP_SERVERS_NAMES: u32 = 21u32;
746 pub const DHCPV6_OPTION_UNICAST: u32 = 12u32;
747 pub const DHCPV6_OPTION_USER_CLASS: u32 = 15u32;
748 pub const DHCPV6_OPTION_VENDOR_CLASS: u32 = 16u32;
749 pub const DHCPV6_OPTION_VENDOR_OPTS: u32 = 17u32;
750 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
751 #[repr(C)]
752 #[cfg(feature = "Win32_Foundation")]
753 pub struct DHCPV6_STATELESS_PARAMS {
754 pub Status: super::super::Foundation::BOOL,
755 pub PurgeInterval: u32,
756 }
757 #[cfg(feature = "Win32_Foundation")]
758 impl DHCPV6_STATELESS_PARAMS {}
759 #[cfg(feature = "Win32_Foundation")]
760 impl ::std::default::Default for DHCPV6_STATELESS_PARAMS {
default() -> Self761 fn default() -> Self {
762 unsafe { ::std::mem::zeroed() }
763 }
764 }
765 #[cfg(feature = "Win32_Foundation")]
766 impl ::std::fmt::Debug for DHCPV6_STATELESS_PARAMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result767 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
768 fmt.debug_struct("DHCPV6_STATELESS_PARAMS").field("Status", &self.Status).field("PurgeInterval", &self.PurgeInterval).finish()
769 }
770 }
771 #[cfg(feature = "Win32_Foundation")]
772 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_PARAMS {
eq(&self, other: &Self) -> bool773 fn eq(&self, other: &Self) -> bool {
774 self.Status == other.Status && self.PurgeInterval == other.PurgeInterval
775 }
776 }
777 #[cfg(feature = "Win32_Foundation")]
778 impl ::std::cmp::Eq for DHCPV6_STATELESS_PARAMS {}
779 #[cfg(feature = "Win32_Foundation")]
780 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_PARAMS {
781 type Abi = Self;
782 type DefaultType = Self;
783 }
784 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
785 #[repr(transparent)]
786 pub struct DHCPV6_STATELESS_PARAM_TYPE(pub i32);
787 pub const DhcpStatelessPurgeInterval: DHCPV6_STATELESS_PARAM_TYPE = DHCPV6_STATELESS_PARAM_TYPE(1i32);
788 pub const DhcpStatelessStatus: DHCPV6_STATELESS_PARAM_TYPE = DHCPV6_STATELESS_PARAM_TYPE(2i32);
789 impl ::std::convert::From<i32> for DHCPV6_STATELESS_PARAM_TYPE {
from(value: i32) -> Self790 fn from(value: i32) -> Self {
791 Self(value)
792 }
793 }
794 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_PARAM_TYPE {
795 type Abi = Self;
796 type DefaultType = Self;
797 }
798 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
799 #[repr(C)]
800 pub struct DHCPV6_STATELESS_SCOPE_STATS {
801 pub SubnetAddress: DHCP_IPV6_ADDRESS,
802 pub NumStatelessClientsAdded: u64,
803 pub NumStatelessClientsRemoved: u64,
804 }
805 impl DHCPV6_STATELESS_SCOPE_STATS {}
806 impl ::std::default::Default for DHCPV6_STATELESS_SCOPE_STATS {
default() -> Self807 fn default() -> Self {
808 unsafe { ::std::mem::zeroed() }
809 }
810 }
811 impl ::std::fmt::Debug for DHCPV6_STATELESS_SCOPE_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result812 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
813 fmt.debug_struct("DHCPV6_STATELESS_SCOPE_STATS").field("SubnetAddress", &self.SubnetAddress).field("NumStatelessClientsAdded", &self.NumStatelessClientsAdded).field("NumStatelessClientsRemoved", &self.NumStatelessClientsRemoved).finish()
814 }
815 }
816 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_SCOPE_STATS {
eq(&self, other: &Self) -> bool817 fn eq(&self, other: &Self) -> bool {
818 self.SubnetAddress == other.SubnetAddress && self.NumStatelessClientsAdded == other.NumStatelessClientsAdded && self.NumStatelessClientsRemoved == other.NumStatelessClientsRemoved
819 }
820 }
821 impl ::std::cmp::Eq for DHCPV6_STATELESS_SCOPE_STATS {}
822 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_SCOPE_STATS {
823 type Abi = Self;
824 type DefaultType = Self;
825 }
826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
827 #[repr(C)]
828 pub struct DHCPV6_STATELESS_STATS {
829 pub NumScopes: u32,
830 pub ScopeStats: *mut DHCPV6_STATELESS_SCOPE_STATS,
831 }
832 impl DHCPV6_STATELESS_STATS {}
833 impl ::std::default::Default for DHCPV6_STATELESS_STATS {
default() -> Self834 fn default() -> Self {
835 unsafe { ::std::mem::zeroed() }
836 }
837 }
838 impl ::std::fmt::Debug for DHCPV6_STATELESS_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result839 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
840 fmt.debug_struct("DHCPV6_STATELESS_STATS").field("NumScopes", &self.NumScopes).field("ScopeStats", &self.ScopeStats).finish()
841 }
842 }
843 impl ::std::cmp::PartialEq for DHCPV6_STATELESS_STATS {
eq(&self, other: &Self) -> bool844 fn eq(&self, other: &Self) -> bool {
845 self.NumScopes == other.NumScopes && self.ScopeStats == other.ScopeStats
846 }
847 }
848 impl ::std::cmp::Eq for DHCPV6_STATELESS_STATS {}
849 unsafe impl ::windows::runtime::Abi for DHCPV6_STATELESS_STATS {
850 type Abi = Self;
851 type DefaultType = Self;
852 }
853 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
854 #[repr(C)]
855 #[cfg(feature = "Win32_Foundation")]
856 pub struct DHCP_ADDR_PATTERN {
857 pub MatchHWType: super::super::Foundation::BOOL,
858 pub HWType: u8,
859 pub IsWildcard: super::super::Foundation::BOOL,
860 pub Length: u8,
861 pub Pattern: [u8; 255],
862 }
863 #[cfg(feature = "Win32_Foundation")]
864 impl DHCP_ADDR_PATTERN {}
865 #[cfg(feature = "Win32_Foundation")]
866 impl ::std::default::Default for DHCP_ADDR_PATTERN {
default() -> Self867 fn default() -> Self {
868 unsafe { ::std::mem::zeroed() }
869 }
870 }
871 #[cfg(feature = "Win32_Foundation")]
872 impl ::std::fmt::Debug for DHCP_ADDR_PATTERN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result873 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
874 fmt.debug_struct("DHCP_ADDR_PATTERN").field("MatchHWType", &self.MatchHWType).field("HWType", &self.HWType).field("IsWildcard", &self.IsWildcard).field("Length", &self.Length).field("Pattern", &self.Pattern).finish()
875 }
876 }
877 #[cfg(feature = "Win32_Foundation")]
878 impl ::std::cmp::PartialEq for DHCP_ADDR_PATTERN {
eq(&self, other: &Self) -> bool879 fn eq(&self, other: &Self) -> bool {
880 self.MatchHWType == other.MatchHWType && self.HWType == other.HWType && self.IsWildcard == other.IsWildcard && self.Length == other.Length && self.Pattern == other.Pattern
881 }
882 }
883 #[cfg(feature = "Win32_Foundation")]
884 impl ::std::cmp::Eq for DHCP_ADDR_PATTERN {}
885 #[cfg(feature = "Win32_Foundation")]
886 unsafe impl ::windows::runtime::Abi for DHCP_ADDR_PATTERN {
887 type Abi = Self;
888 type DefaultType = Self;
889 }
890 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
891 #[repr(C)]
892 #[cfg(feature = "Win32_Foundation")]
893 pub struct DHCP_ALL_OPTIONS {
894 pub Flags: u32,
895 pub NonVendorOptions: *mut DHCP_OPTION_ARRAY,
896 pub NumVendorOptions: u32,
897 pub VendorOptions: *mut DHCP_ALL_OPTIONS_0,
898 }
899 #[cfg(feature = "Win32_Foundation")]
900 impl DHCP_ALL_OPTIONS {}
901 #[cfg(feature = "Win32_Foundation")]
902 impl ::std::default::Default for DHCP_ALL_OPTIONS {
default() -> Self903 fn default() -> Self {
904 unsafe { ::std::mem::zeroed() }
905 }
906 }
907 #[cfg(feature = "Win32_Foundation")]
908 impl ::std::fmt::Debug for DHCP_ALL_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result909 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
910 fmt.debug_struct("DHCP_ALL_OPTIONS").field("Flags", &self.Flags).field("NonVendorOptions", &self.NonVendorOptions).field("NumVendorOptions", &self.NumVendorOptions).field("VendorOptions", &self.VendorOptions).finish()
911 }
912 }
913 #[cfg(feature = "Win32_Foundation")]
914 impl ::std::cmp::PartialEq for DHCP_ALL_OPTIONS {
eq(&self, other: &Self) -> bool915 fn eq(&self, other: &Self) -> bool {
916 self.Flags == other.Flags && self.NonVendorOptions == other.NonVendorOptions && self.NumVendorOptions == other.NumVendorOptions && self.VendorOptions == other.VendorOptions
917 }
918 }
919 #[cfg(feature = "Win32_Foundation")]
920 impl ::std::cmp::Eq for DHCP_ALL_OPTIONS {}
921 #[cfg(feature = "Win32_Foundation")]
922 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTIONS {
923 type Abi = Self;
924 type DefaultType = Self;
925 }
926 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
927 #[repr(C)]
928 #[cfg(feature = "Win32_Foundation")]
929 pub struct DHCP_ALL_OPTIONS_0 {
930 pub Option: DHCP_OPTION,
931 pub VendorName: super::super::Foundation::PWSTR,
932 pub ClassName: super::super::Foundation::PWSTR,
933 }
934 #[cfg(feature = "Win32_Foundation")]
935 impl DHCP_ALL_OPTIONS_0 {}
936 #[cfg(feature = "Win32_Foundation")]
937 impl ::std::default::Default for DHCP_ALL_OPTIONS_0 {
default() -> Self938 fn default() -> Self {
939 unsafe { ::std::mem::zeroed() }
940 }
941 }
942 #[cfg(feature = "Win32_Foundation")]
943 impl ::std::fmt::Debug for DHCP_ALL_OPTIONS_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result944 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
945 fmt.debug_struct("_Anonymous_e__Struct").field("Option", &self.Option).field("VendorName", &self.VendorName).field("ClassName", &self.ClassName).finish()
946 }
947 }
948 #[cfg(feature = "Win32_Foundation")]
949 impl ::std::cmp::PartialEq for DHCP_ALL_OPTIONS_0 {
eq(&self, other: &Self) -> bool950 fn eq(&self, other: &Self) -> bool {
951 self.Option == other.Option && self.VendorName == other.VendorName && self.ClassName == other.ClassName
952 }
953 }
954 #[cfg(feature = "Win32_Foundation")]
955 impl ::std::cmp::Eq for DHCP_ALL_OPTIONS_0 {}
956 #[cfg(feature = "Win32_Foundation")]
957 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTIONS_0 {
958 type Abi = Self;
959 type DefaultType = Self;
960 }
961 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
962 #[repr(C)]
963 #[cfg(feature = "Win32_Foundation")]
964 pub struct DHCP_ALL_OPTION_VALUES {
965 pub Flags: u32,
966 pub NumElements: u32,
967 pub Options: *mut DHCP_ALL_OPTION_VALUES_0,
968 }
969 #[cfg(feature = "Win32_Foundation")]
970 impl DHCP_ALL_OPTION_VALUES {}
971 #[cfg(feature = "Win32_Foundation")]
972 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES {
default() -> Self973 fn default() -> Self {
974 unsafe { ::std::mem::zeroed() }
975 }
976 }
977 #[cfg(feature = "Win32_Foundation")]
978 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result979 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
980 fmt.debug_struct("DHCP_ALL_OPTION_VALUES").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
981 }
982 }
983 #[cfg(feature = "Win32_Foundation")]
984 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES {
eq(&self, other: &Self) -> bool985 fn eq(&self, other: &Self) -> bool {
986 self.Flags == other.Flags && self.NumElements == other.NumElements && self.Options == other.Options
987 }
988 }
989 #[cfg(feature = "Win32_Foundation")]
990 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES {}
991 #[cfg(feature = "Win32_Foundation")]
992 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES {
993 type Abi = Self;
994 type DefaultType = Self;
995 }
996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
997 #[repr(C)]
998 #[cfg(feature = "Win32_Foundation")]
999 pub struct DHCP_ALL_OPTION_VALUES_0 {
1000 pub ClassName: super::super::Foundation::PWSTR,
1001 pub VendorName: super::super::Foundation::PWSTR,
1002 pub IsVendor: super::super::Foundation::BOOL,
1003 pub OptionsArray: *mut DHCP_OPTION_VALUE_ARRAY,
1004 }
1005 #[cfg(feature = "Win32_Foundation")]
1006 impl DHCP_ALL_OPTION_VALUES_0 {}
1007 #[cfg(feature = "Win32_Foundation")]
1008 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_0 {
default() -> Self1009 fn default() -> Self {
1010 unsafe { ::std::mem::zeroed() }
1011 }
1012 }
1013 #[cfg(feature = "Win32_Foundation")]
1014 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1015 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1016 fmt.debug_struct("_Anonymous_e__Struct").field("ClassName", &self.ClassName).field("VendorName", &self.VendorName).field("IsVendor", &self.IsVendor).field("OptionsArray", &self.OptionsArray).finish()
1017 }
1018 }
1019 #[cfg(feature = "Win32_Foundation")]
1020 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_0 {
eq(&self, other: &Self) -> bool1021 fn eq(&self, other: &Self) -> bool {
1022 self.ClassName == other.ClassName && self.VendorName == other.VendorName && self.IsVendor == other.IsVendor && self.OptionsArray == other.OptionsArray
1023 }
1024 }
1025 #[cfg(feature = "Win32_Foundation")]
1026 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_0 {}
1027 #[cfg(feature = "Win32_Foundation")]
1028 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_0 {
1029 type Abi = Self;
1030 type DefaultType = Self;
1031 }
1032 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1033 #[repr(C)]
1034 #[cfg(feature = "Win32_Foundation")]
1035 pub struct DHCP_ALL_OPTION_VALUES_PB {
1036 pub Flags: u32,
1037 pub NumElements: u32,
1038 pub Options: *mut DHCP_ALL_OPTION_VALUES_PB_0,
1039 }
1040 #[cfg(feature = "Win32_Foundation")]
1041 impl DHCP_ALL_OPTION_VALUES_PB {}
1042 #[cfg(feature = "Win32_Foundation")]
1043 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_PB {
default() -> Self1044 fn default() -> Self {
1045 unsafe { ::std::mem::zeroed() }
1046 }
1047 }
1048 #[cfg(feature = "Win32_Foundation")]
1049 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_PB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1050 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1051 fmt.debug_struct("DHCP_ALL_OPTION_VALUES_PB").field("Flags", &self.Flags).field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
1052 }
1053 }
1054 #[cfg(feature = "Win32_Foundation")]
1055 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_PB {
eq(&self, other: &Self) -> bool1056 fn eq(&self, other: &Self) -> bool {
1057 self.Flags == other.Flags && self.NumElements == other.NumElements && self.Options == other.Options
1058 }
1059 }
1060 #[cfg(feature = "Win32_Foundation")]
1061 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_PB {}
1062 #[cfg(feature = "Win32_Foundation")]
1063 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_PB {
1064 type Abi = Self;
1065 type DefaultType = Self;
1066 }
1067 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1068 #[repr(C)]
1069 #[cfg(feature = "Win32_Foundation")]
1070 pub struct DHCP_ALL_OPTION_VALUES_PB_0 {
1071 pub PolicyName: super::super::Foundation::PWSTR,
1072 pub VendorName: super::super::Foundation::PWSTR,
1073 pub IsVendor: super::super::Foundation::BOOL,
1074 pub OptionsArray: *mut DHCP_OPTION_VALUE_ARRAY,
1075 }
1076 #[cfg(feature = "Win32_Foundation")]
1077 impl DHCP_ALL_OPTION_VALUES_PB_0 {}
1078 #[cfg(feature = "Win32_Foundation")]
1079 impl ::std::default::Default for DHCP_ALL_OPTION_VALUES_PB_0 {
default() -> Self1080 fn default() -> Self {
1081 unsafe { ::std::mem::zeroed() }
1082 }
1083 }
1084 #[cfg(feature = "Win32_Foundation")]
1085 impl ::std::fmt::Debug for DHCP_ALL_OPTION_VALUES_PB_0 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1086 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1087 fmt.debug_struct("_Anonymous_e__Struct").field("PolicyName", &self.PolicyName).field("VendorName", &self.VendorName).field("IsVendor", &self.IsVendor).field("OptionsArray", &self.OptionsArray).finish()
1088 }
1089 }
1090 #[cfg(feature = "Win32_Foundation")]
1091 impl ::std::cmp::PartialEq for DHCP_ALL_OPTION_VALUES_PB_0 {
eq(&self, other: &Self) -> bool1092 fn eq(&self, other: &Self) -> bool {
1093 self.PolicyName == other.PolicyName && self.VendorName == other.VendorName && self.IsVendor == other.IsVendor && self.OptionsArray == other.OptionsArray
1094 }
1095 }
1096 #[cfg(feature = "Win32_Foundation")]
1097 impl ::std::cmp::Eq for DHCP_ALL_OPTION_VALUES_PB_0 {}
1098 #[cfg(feature = "Win32_Foundation")]
1099 unsafe impl ::windows::runtime::Abi for DHCP_ALL_OPTION_VALUES_PB_0 {
1100 type Abi = Self;
1101 type DefaultType = Self;
1102 }
1103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1104 #[repr(C)]
1105 #[cfg(feature = "Win32_Foundation")]
1106 pub struct DHCP_ATTRIB {
1107 pub DhcpAttribId: u32,
1108 pub DhcpAttribType: u32,
1109 pub Anonymous: DHCP_ATTRIB_0,
1110 }
1111 #[cfg(feature = "Win32_Foundation")]
1112 impl DHCP_ATTRIB {}
1113 #[cfg(feature = "Win32_Foundation")]
1114 impl ::std::default::Default for DHCP_ATTRIB {
default() -> Self1115 fn default() -> Self {
1116 unsafe { ::std::mem::zeroed() }
1117 }
1118 }
1119 #[cfg(feature = "Win32_Foundation")]
1120 impl ::std::cmp::PartialEq for DHCP_ATTRIB {
eq(&self, _other: &Self) -> bool1121 fn eq(&self, _other: &Self) -> bool {
1122 unimplemented!()
1123 }
1124 }
1125 #[cfg(feature = "Win32_Foundation")]
1126 impl ::std::cmp::Eq for DHCP_ATTRIB {}
1127 #[cfg(feature = "Win32_Foundation")]
1128 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB {
1129 type Abi = Self;
1130 type DefaultType = Self;
1131 }
1132 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1133 #[repr(C)]
1134 #[cfg(feature = "Win32_Foundation")]
1135 pub union DHCP_ATTRIB_0 {
1136 pub DhcpAttribBool: super::super::Foundation::BOOL,
1137 pub DhcpAttribUlong: u32,
1138 }
1139 #[cfg(feature = "Win32_Foundation")]
1140 impl DHCP_ATTRIB_0 {}
1141 #[cfg(feature = "Win32_Foundation")]
1142 impl ::std::default::Default for DHCP_ATTRIB_0 {
default() -> Self1143 fn default() -> Self {
1144 unsafe { ::std::mem::zeroed() }
1145 }
1146 }
1147 #[cfg(feature = "Win32_Foundation")]
1148 impl ::std::cmp::PartialEq for DHCP_ATTRIB_0 {
eq(&self, _other: &Self) -> bool1149 fn eq(&self, _other: &Self) -> bool {
1150 unimplemented!()
1151 }
1152 }
1153 #[cfg(feature = "Win32_Foundation")]
1154 impl ::std::cmp::Eq for DHCP_ATTRIB_0 {}
1155 #[cfg(feature = "Win32_Foundation")]
1156 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB_0 {
1157 type Abi = Self;
1158 type DefaultType = Self;
1159 }
1160 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1161 #[repr(C)]
1162 #[cfg(feature = "Win32_Foundation")]
1163 pub struct DHCP_ATTRIB_ARRAY {
1164 pub NumElements: u32,
1165 pub DhcpAttribs: *mut DHCP_ATTRIB,
1166 }
1167 #[cfg(feature = "Win32_Foundation")]
1168 impl DHCP_ATTRIB_ARRAY {}
1169 #[cfg(feature = "Win32_Foundation")]
1170 impl ::std::default::Default for DHCP_ATTRIB_ARRAY {
default() -> Self1171 fn default() -> Self {
1172 unsafe { ::std::mem::zeroed() }
1173 }
1174 }
1175 #[cfg(feature = "Win32_Foundation")]
1176 impl ::std::fmt::Debug for DHCP_ATTRIB_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1177 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1178 fmt.debug_struct("DHCP_ATTRIB_ARRAY").field("NumElements", &self.NumElements).field("DhcpAttribs", &self.DhcpAttribs).finish()
1179 }
1180 }
1181 #[cfg(feature = "Win32_Foundation")]
1182 impl ::std::cmp::PartialEq for DHCP_ATTRIB_ARRAY {
eq(&self, other: &Self) -> bool1183 fn eq(&self, other: &Self) -> bool {
1184 self.NumElements == other.NumElements && self.DhcpAttribs == other.DhcpAttribs
1185 }
1186 }
1187 #[cfg(feature = "Win32_Foundation")]
1188 impl ::std::cmp::Eq for DHCP_ATTRIB_ARRAY {}
1189 #[cfg(feature = "Win32_Foundation")]
1190 unsafe impl ::windows::runtime::Abi for DHCP_ATTRIB_ARRAY {
1191 type Abi = Self;
1192 type DefaultType = Self;
1193 }
1194 pub const DHCP_ATTRIB_BOOL_IS_ADMIN: u32 = 5u32;
1195 pub const DHCP_ATTRIB_BOOL_IS_BINDING_AWARE: u32 = 4u32;
1196 pub const DHCP_ATTRIB_BOOL_IS_DYNBOOTP: u32 = 2u32;
1197 pub const DHCP_ATTRIB_BOOL_IS_PART_OF_DSDC: u32 = 3u32;
1198 pub const DHCP_ATTRIB_BOOL_IS_ROGUE: u32 = 1u32;
1199 pub const DHCP_ATTRIB_TYPE_BOOL: u32 = 1u32;
1200 pub const DHCP_ATTRIB_TYPE_ULONG: u32 = 2u32;
1201 pub const DHCP_ATTRIB_ULONG_RESTORE_STATUS: u32 = 6u32;
1202 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1203 #[repr(C)]
1204 pub struct DHCP_BINARY_DATA {
1205 pub DataLength: u32,
1206 pub Data: *mut u8,
1207 }
1208 impl DHCP_BINARY_DATA {}
1209 impl ::std::default::Default for DHCP_BINARY_DATA {
default() -> Self1210 fn default() -> Self {
1211 unsafe { ::std::mem::zeroed() }
1212 }
1213 }
1214 impl ::std::fmt::Debug for DHCP_BINARY_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1215 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1216 fmt.debug_struct("DHCP_BINARY_DATA").field("DataLength", &self.DataLength).field("Data", &self.Data).finish()
1217 }
1218 }
1219 impl ::std::cmp::PartialEq for DHCP_BINARY_DATA {
eq(&self, other: &Self) -> bool1220 fn eq(&self, other: &Self) -> bool {
1221 self.DataLength == other.DataLength && self.Data == other.Data
1222 }
1223 }
1224 impl ::std::cmp::Eq for DHCP_BINARY_DATA {}
1225 unsafe impl ::windows::runtime::Abi for DHCP_BINARY_DATA {
1226 type Abi = Self;
1227 type DefaultType = Self;
1228 }
1229 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1230 #[repr(C)]
1231 #[cfg(feature = "Win32_Foundation")]
1232 pub struct DHCP_BIND_ELEMENT {
1233 pub Flags: u32,
1234 pub fBoundToDHCPServer: super::super::Foundation::BOOL,
1235 pub AdapterPrimaryAddress: u32,
1236 pub AdapterSubnetAddress: u32,
1237 pub IfDescription: super::super::Foundation::PWSTR,
1238 pub IfIdSize: u32,
1239 pub IfId: *mut u8,
1240 }
1241 #[cfg(feature = "Win32_Foundation")]
1242 impl DHCP_BIND_ELEMENT {}
1243 #[cfg(feature = "Win32_Foundation")]
1244 impl ::std::default::Default for DHCP_BIND_ELEMENT {
default() -> Self1245 fn default() -> Self {
1246 unsafe { ::std::mem::zeroed() }
1247 }
1248 }
1249 #[cfg(feature = "Win32_Foundation")]
1250 impl ::std::fmt::Debug for DHCP_BIND_ELEMENT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1251 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1252 fmt.debug_struct("DHCP_BIND_ELEMENT")
1253 .field("Flags", &self.Flags)
1254 .field("fBoundToDHCPServer", &self.fBoundToDHCPServer)
1255 .field("AdapterPrimaryAddress", &self.AdapterPrimaryAddress)
1256 .field("AdapterSubnetAddress", &self.AdapterSubnetAddress)
1257 .field("IfDescription", &self.IfDescription)
1258 .field("IfIdSize", &self.IfIdSize)
1259 .field("IfId", &self.IfId)
1260 .finish()
1261 }
1262 }
1263 #[cfg(feature = "Win32_Foundation")]
1264 impl ::std::cmp::PartialEq for DHCP_BIND_ELEMENT {
eq(&self, other: &Self) -> bool1265 fn eq(&self, other: &Self) -> bool {
1266 self.Flags == other.Flags && self.fBoundToDHCPServer == other.fBoundToDHCPServer && self.AdapterPrimaryAddress == other.AdapterPrimaryAddress && self.AdapterSubnetAddress == other.AdapterSubnetAddress && self.IfDescription == other.IfDescription && self.IfIdSize == other.IfIdSize && self.IfId == other.IfId
1267 }
1268 }
1269 #[cfg(feature = "Win32_Foundation")]
1270 impl ::std::cmp::Eq for DHCP_BIND_ELEMENT {}
1271 #[cfg(feature = "Win32_Foundation")]
1272 unsafe impl ::windows::runtime::Abi for DHCP_BIND_ELEMENT {
1273 type Abi = Self;
1274 type DefaultType = Self;
1275 }
1276 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1277 #[repr(C)]
1278 #[cfg(feature = "Win32_Foundation")]
1279 pub struct DHCP_BIND_ELEMENT_ARRAY {
1280 pub NumElements: u32,
1281 pub Elements: *mut DHCP_BIND_ELEMENT,
1282 }
1283 #[cfg(feature = "Win32_Foundation")]
1284 impl DHCP_BIND_ELEMENT_ARRAY {}
1285 #[cfg(feature = "Win32_Foundation")]
1286 impl ::std::default::Default for DHCP_BIND_ELEMENT_ARRAY {
default() -> Self1287 fn default() -> Self {
1288 unsafe { ::std::mem::zeroed() }
1289 }
1290 }
1291 #[cfg(feature = "Win32_Foundation")]
1292 impl ::std::fmt::Debug for DHCP_BIND_ELEMENT_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1293 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1294 fmt.debug_struct("DHCP_BIND_ELEMENT_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
1295 }
1296 }
1297 #[cfg(feature = "Win32_Foundation")]
1298 impl ::std::cmp::PartialEq for DHCP_BIND_ELEMENT_ARRAY {
eq(&self, other: &Self) -> bool1299 fn eq(&self, other: &Self) -> bool {
1300 self.NumElements == other.NumElements && self.Elements == other.Elements
1301 }
1302 }
1303 #[cfg(feature = "Win32_Foundation")]
1304 impl ::std::cmp::Eq for DHCP_BIND_ELEMENT_ARRAY {}
1305 #[cfg(feature = "Win32_Foundation")]
1306 unsafe impl ::windows::runtime::Abi for DHCP_BIND_ELEMENT_ARRAY {
1307 type Abi = Self;
1308 type DefaultType = Self;
1309 }
1310 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1311 #[repr(C)]
1312 pub struct DHCP_BOOTP_IP_RANGE {
1313 pub StartAddress: u32,
1314 pub EndAddress: u32,
1315 pub BootpAllocated: u32,
1316 pub MaxBootpAllowed: u32,
1317 }
1318 impl DHCP_BOOTP_IP_RANGE {}
1319 impl ::std::default::Default for DHCP_BOOTP_IP_RANGE {
default() -> Self1320 fn default() -> Self {
1321 unsafe { ::std::mem::zeroed() }
1322 }
1323 }
1324 impl ::std::fmt::Debug for DHCP_BOOTP_IP_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1325 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1326 fmt.debug_struct("DHCP_BOOTP_IP_RANGE").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).field("BootpAllocated", &self.BootpAllocated).field("MaxBootpAllowed", &self.MaxBootpAllowed).finish()
1327 }
1328 }
1329 impl ::std::cmp::PartialEq for DHCP_BOOTP_IP_RANGE {
eq(&self, other: &Self) -> bool1330 fn eq(&self, other: &Self) -> bool {
1331 self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress && self.BootpAllocated == other.BootpAllocated && self.MaxBootpAllowed == other.MaxBootpAllowed
1332 }
1333 }
1334 impl ::std::cmp::Eq for DHCP_BOOTP_IP_RANGE {}
1335 unsafe impl ::windows::runtime::Abi for DHCP_BOOTP_IP_RANGE {
1336 type Abi = Self;
1337 type DefaultType = Self;
1338 }
1339 #[derive(:: std :: clone :: Clone)]
1340 #[repr(C)]
1341 #[cfg(feature = "Win32_Foundation")]
1342 pub struct DHCP_CALLOUT_TABLE {
1343 pub DhcpControlHook: ::std::option::Option<LPDHCP_CONTROL>,
1344 pub DhcpNewPktHook: ::std::option::Option<LPDHCP_NEWPKT>,
1345 pub DhcpPktDropHook: ::std::option::Option<LPDHCP_DROP_SEND>,
1346 pub DhcpPktSendHook: ::std::option::Option<LPDHCP_DROP_SEND>,
1347 pub DhcpAddressDelHook: ::std::option::Option<LPDHCP_PROB>,
1348 pub DhcpAddressOfferHook: ::std::option::Option<LPDHCP_GIVE_ADDRESS>,
1349 pub DhcpHandleOptionsHook: ::std::option::Option<LPDHCP_HANDLE_OPTIONS>,
1350 pub DhcpDeleteClientHook: ::std::option::Option<LPDHCP_DELETE_CLIENT>,
1351 pub DhcpExtensionHook: *mut ::std::ffi::c_void,
1352 pub DhcpReservedHook: *mut ::std::ffi::c_void,
1353 }
1354 #[cfg(feature = "Win32_Foundation")]
1355 impl DHCP_CALLOUT_TABLE {}
1356 #[cfg(feature = "Win32_Foundation")]
1357 impl ::std::default::Default for DHCP_CALLOUT_TABLE {
default() -> Self1358 fn default() -> Self {
1359 unsafe { ::std::mem::zeroed() }
1360 }
1361 }
1362 #[cfg(feature = "Win32_Foundation")]
1363 impl ::std::fmt::Debug for DHCP_CALLOUT_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1364 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1365 fmt.debug_struct("DHCP_CALLOUT_TABLE").field("DhcpExtensionHook", &self.DhcpExtensionHook).field("DhcpReservedHook", &self.DhcpReservedHook).finish()
1366 }
1367 }
1368 #[cfg(feature = "Win32_Foundation")]
1369 impl ::std::cmp::PartialEq for DHCP_CALLOUT_TABLE {
eq(&self, other: &Self) -> bool1370 fn eq(&self, other: &Self) -> bool {
1371 self.DhcpControlHook.map(|f| f as usize) == other.DhcpControlHook.map(|f| f as usize)
1372 && self.DhcpNewPktHook.map(|f| f as usize) == other.DhcpNewPktHook.map(|f| f as usize)
1373 && self.DhcpPktDropHook.map(|f| f as usize) == other.DhcpPktDropHook.map(|f| f as usize)
1374 && self.DhcpPktSendHook.map(|f| f as usize) == other.DhcpPktSendHook.map(|f| f as usize)
1375 && self.DhcpAddressDelHook.map(|f| f as usize) == other.DhcpAddressDelHook.map(|f| f as usize)
1376 && self.DhcpAddressOfferHook.map(|f| f as usize) == other.DhcpAddressOfferHook.map(|f| f as usize)
1377 && self.DhcpHandleOptionsHook.map(|f| f as usize) == other.DhcpHandleOptionsHook.map(|f| f as usize)
1378 && self.DhcpDeleteClientHook.map(|f| f as usize) == other.DhcpDeleteClientHook.map(|f| f as usize)
1379 && self.DhcpExtensionHook == other.DhcpExtensionHook
1380 && self.DhcpReservedHook == other.DhcpReservedHook
1381 }
1382 }
1383 #[cfg(feature = "Win32_Foundation")]
1384 impl ::std::cmp::Eq for DHCP_CALLOUT_TABLE {}
1385 #[cfg(feature = "Win32_Foundation")]
1386 unsafe impl ::windows::runtime::Abi for DHCP_CALLOUT_TABLE {
1387 type Abi = ::std::mem::ManuallyDrop<Self>;
1388 type DefaultType = Self;
1389 }
1390 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1391 #[repr(C)]
1392 #[cfg(feature = "Win32_Foundation")]
1393 pub struct DHCP_CLASS_INFO {
1394 pub ClassName: super::super::Foundation::PWSTR,
1395 pub ClassComment: super::super::Foundation::PWSTR,
1396 pub ClassDataLength: u32,
1397 pub IsVendor: super::super::Foundation::BOOL,
1398 pub Flags: u32,
1399 pub ClassData: *mut u8,
1400 }
1401 #[cfg(feature = "Win32_Foundation")]
1402 impl DHCP_CLASS_INFO {}
1403 #[cfg(feature = "Win32_Foundation")]
1404 impl ::std::default::Default for DHCP_CLASS_INFO {
default() -> Self1405 fn default() -> Self {
1406 unsafe { ::std::mem::zeroed() }
1407 }
1408 }
1409 #[cfg(feature = "Win32_Foundation")]
1410 impl ::std::fmt::Debug for DHCP_CLASS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1411 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1412 fmt.debug_struct("DHCP_CLASS_INFO").field("ClassName", &self.ClassName).field("ClassComment", &self.ClassComment).field("ClassDataLength", &self.ClassDataLength).field("IsVendor", &self.IsVendor).field("Flags", &self.Flags).field("ClassData", &self.ClassData).finish()
1413 }
1414 }
1415 #[cfg(feature = "Win32_Foundation")]
1416 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO {
eq(&self, other: &Self) -> bool1417 fn eq(&self, other: &Self) -> bool {
1418 self.ClassName == other.ClassName && self.ClassComment == other.ClassComment && self.ClassDataLength == other.ClassDataLength && self.IsVendor == other.IsVendor && self.Flags == other.Flags && self.ClassData == other.ClassData
1419 }
1420 }
1421 #[cfg(feature = "Win32_Foundation")]
1422 impl ::std::cmp::Eq for DHCP_CLASS_INFO {}
1423 #[cfg(feature = "Win32_Foundation")]
1424 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO {
1425 type Abi = Self;
1426 type DefaultType = Self;
1427 }
1428 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1429 #[repr(C)]
1430 #[cfg(feature = "Win32_Foundation")]
1431 pub struct DHCP_CLASS_INFO_ARRAY {
1432 pub NumElements: u32,
1433 pub Classes: *mut DHCP_CLASS_INFO,
1434 }
1435 #[cfg(feature = "Win32_Foundation")]
1436 impl DHCP_CLASS_INFO_ARRAY {}
1437 #[cfg(feature = "Win32_Foundation")]
1438 impl ::std::default::Default for DHCP_CLASS_INFO_ARRAY {
default() -> Self1439 fn default() -> Self {
1440 unsafe { ::std::mem::zeroed() }
1441 }
1442 }
1443 #[cfg(feature = "Win32_Foundation")]
1444 impl ::std::fmt::Debug for DHCP_CLASS_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1445 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1446 fmt.debug_struct("DHCP_CLASS_INFO_ARRAY").field("NumElements", &self.NumElements).field("Classes", &self.Classes).finish()
1447 }
1448 }
1449 #[cfg(feature = "Win32_Foundation")]
1450 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_ARRAY {
eq(&self, other: &Self) -> bool1451 fn eq(&self, other: &Self) -> bool {
1452 self.NumElements == other.NumElements && self.Classes == other.Classes
1453 }
1454 }
1455 #[cfg(feature = "Win32_Foundation")]
1456 impl ::std::cmp::Eq for DHCP_CLASS_INFO_ARRAY {}
1457 #[cfg(feature = "Win32_Foundation")]
1458 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_ARRAY {
1459 type Abi = Self;
1460 type DefaultType = Self;
1461 }
1462 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1463 #[repr(C)]
1464 #[cfg(feature = "Win32_Foundation")]
1465 pub struct DHCP_CLASS_INFO_ARRAY_V6 {
1466 pub NumElements: u32,
1467 pub Classes: *mut DHCP_CLASS_INFO_V6,
1468 }
1469 #[cfg(feature = "Win32_Foundation")]
1470 impl DHCP_CLASS_INFO_ARRAY_V6 {}
1471 #[cfg(feature = "Win32_Foundation")]
1472 impl ::std::default::Default for DHCP_CLASS_INFO_ARRAY_V6 {
default() -> Self1473 fn default() -> Self {
1474 unsafe { ::std::mem::zeroed() }
1475 }
1476 }
1477 #[cfg(feature = "Win32_Foundation")]
1478 impl ::std::fmt::Debug for DHCP_CLASS_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1479 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1480 fmt.debug_struct("DHCP_CLASS_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Classes", &self.Classes).finish()
1481 }
1482 }
1483 #[cfg(feature = "Win32_Foundation")]
1484 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool1485 fn eq(&self, other: &Self) -> bool {
1486 self.NumElements == other.NumElements && self.Classes == other.Classes
1487 }
1488 }
1489 #[cfg(feature = "Win32_Foundation")]
1490 impl ::std::cmp::Eq for DHCP_CLASS_INFO_ARRAY_V6 {}
1491 #[cfg(feature = "Win32_Foundation")]
1492 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_ARRAY_V6 {
1493 type Abi = Self;
1494 type DefaultType = Self;
1495 }
1496 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1497 #[repr(C)]
1498 #[cfg(feature = "Win32_Foundation")]
1499 pub struct DHCP_CLASS_INFO_V6 {
1500 pub ClassName: super::super::Foundation::PWSTR,
1501 pub ClassComment: super::super::Foundation::PWSTR,
1502 pub ClassDataLength: u32,
1503 pub IsVendor: super::super::Foundation::BOOL,
1504 pub EnterpriseNumber: u32,
1505 pub Flags: u32,
1506 pub ClassData: *mut u8,
1507 }
1508 #[cfg(feature = "Win32_Foundation")]
1509 impl DHCP_CLASS_INFO_V6 {}
1510 #[cfg(feature = "Win32_Foundation")]
1511 impl ::std::default::Default for DHCP_CLASS_INFO_V6 {
default() -> Self1512 fn default() -> Self {
1513 unsafe { ::std::mem::zeroed() }
1514 }
1515 }
1516 #[cfg(feature = "Win32_Foundation")]
1517 impl ::std::fmt::Debug for DHCP_CLASS_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1518 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1519 fmt.debug_struct("DHCP_CLASS_INFO_V6")
1520 .field("ClassName", &self.ClassName)
1521 .field("ClassComment", &self.ClassComment)
1522 .field("ClassDataLength", &self.ClassDataLength)
1523 .field("IsVendor", &self.IsVendor)
1524 .field("EnterpriseNumber", &self.EnterpriseNumber)
1525 .field("Flags", &self.Flags)
1526 .field("ClassData", &self.ClassData)
1527 .finish()
1528 }
1529 }
1530 #[cfg(feature = "Win32_Foundation")]
1531 impl ::std::cmp::PartialEq for DHCP_CLASS_INFO_V6 {
eq(&self, other: &Self) -> bool1532 fn eq(&self, other: &Self) -> bool {
1533 self.ClassName == other.ClassName && self.ClassComment == other.ClassComment && self.ClassDataLength == other.ClassDataLength && self.IsVendor == other.IsVendor && self.EnterpriseNumber == other.EnterpriseNumber && self.Flags == other.Flags && self.ClassData == other.ClassData
1534 }
1535 }
1536 #[cfg(feature = "Win32_Foundation")]
1537 impl ::std::cmp::Eq for DHCP_CLASS_INFO_V6 {}
1538 #[cfg(feature = "Win32_Foundation")]
1539 unsafe impl ::windows::runtime::Abi for DHCP_CLASS_INFO_V6 {
1540 type Abi = Self;
1541 type DefaultType = Self;
1542 }
1543 pub const DHCP_CLIENT_BOOTP: u32 = 805306371u32;
1544 pub const DHCP_CLIENT_DHCP: u32 = 805306372u32;
1545 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1546 #[repr(C)]
1547 #[cfg(feature = "Win32_Foundation")]
1548 pub struct DHCP_CLIENT_FILTER_STATUS_INFO {
1549 pub ClientIpAddress: u32,
1550 pub SubnetMask: u32,
1551 pub ClientHardwareAddress: DHCP_BINARY_DATA,
1552 pub ClientName: super::super::Foundation::PWSTR,
1553 pub ClientComment: super::super::Foundation::PWSTR,
1554 pub ClientLeaseExpires: DATE_TIME,
1555 pub OwnerHost: DHCP_HOST_INFO,
1556 pub bClientType: u8,
1557 pub AddressState: u8,
1558 pub Status: QuarantineStatus,
1559 pub ProbationEnds: DATE_TIME,
1560 pub QuarantineCapable: super::super::Foundation::BOOL,
1561 pub FilterStatus: u32,
1562 }
1563 #[cfg(feature = "Win32_Foundation")]
1564 impl DHCP_CLIENT_FILTER_STATUS_INFO {}
1565 #[cfg(feature = "Win32_Foundation")]
1566 impl ::std::default::Default for DHCP_CLIENT_FILTER_STATUS_INFO {
default() -> Self1567 fn default() -> Self {
1568 unsafe { ::std::mem::zeroed() }
1569 }
1570 }
1571 #[cfg(feature = "Win32_Foundation")]
1572 impl ::std::fmt::Debug for DHCP_CLIENT_FILTER_STATUS_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1573 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1574 fmt.debug_struct("DHCP_CLIENT_FILTER_STATUS_INFO")
1575 .field("ClientIpAddress", &self.ClientIpAddress)
1576 .field("SubnetMask", &self.SubnetMask)
1577 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1578 .field("ClientName", &self.ClientName)
1579 .field("ClientComment", &self.ClientComment)
1580 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1581 .field("OwnerHost", &self.OwnerHost)
1582 .field("bClientType", &self.bClientType)
1583 .field("AddressState", &self.AddressState)
1584 .field("Status", &self.Status)
1585 .field("ProbationEnds", &self.ProbationEnds)
1586 .field("QuarantineCapable", &self.QuarantineCapable)
1587 .field("FilterStatus", &self.FilterStatus)
1588 .finish()
1589 }
1590 }
1591 #[cfg(feature = "Win32_Foundation")]
1592 impl ::std::cmp::PartialEq for DHCP_CLIENT_FILTER_STATUS_INFO {
eq(&self, other: &Self) -> bool1593 fn eq(&self, other: &Self) -> bool {
1594 self.ClientIpAddress == other.ClientIpAddress
1595 && self.SubnetMask == other.SubnetMask
1596 && self.ClientHardwareAddress == other.ClientHardwareAddress
1597 && self.ClientName == other.ClientName
1598 && self.ClientComment == other.ClientComment
1599 && self.ClientLeaseExpires == other.ClientLeaseExpires
1600 && self.OwnerHost == other.OwnerHost
1601 && self.bClientType == other.bClientType
1602 && self.AddressState == other.AddressState
1603 && self.Status == other.Status
1604 && self.ProbationEnds == other.ProbationEnds
1605 && self.QuarantineCapable == other.QuarantineCapable
1606 && self.FilterStatus == other.FilterStatus
1607 }
1608 }
1609 #[cfg(feature = "Win32_Foundation")]
1610 impl ::std::cmp::Eq for DHCP_CLIENT_FILTER_STATUS_INFO {}
1611 #[cfg(feature = "Win32_Foundation")]
1612 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_FILTER_STATUS_INFO {
1613 type Abi = Self;
1614 type DefaultType = Self;
1615 }
1616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1617 #[repr(C)]
1618 #[cfg(feature = "Win32_Foundation")]
1619 pub struct DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
1620 pub NumElements: u32,
1621 pub Clients: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO,
1622 }
1623 #[cfg(feature = "Win32_Foundation")]
1624 impl DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {}
1625 #[cfg(feature = "Win32_Foundation")]
1626 impl ::std::default::Default for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
default() -> Self1627 fn default() -> Self {
1628 unsafe { ::std::mem::zeroed() }
1629 }
1630 }
1631 #[cfg(feature = "Win32_Foundation")]
1632 impl ::std::fmt::Debug for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1633 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1634 fmt.debug_struct("DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1635 }
1636 }
1637 #[cfg(feature = "Win32_Foundation")]
1638 impl ::std::cmp::PartialEq for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
eq(&self, other: &Self) -> bool1639 fn eq(&self, other: &Self) -> bool {
1640 self.NumElements == other.NumElements && self.Clients == other.Clients
1641 }
1642 }
1643 #[cfg(feature = "Win32_Foundation")]
1644 impl ::std::cmp::Eq for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {}
1645 #[cfg(feature = "Win32_Foundation")]
1646 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY {
1647 type Abi = Self;
1648 type DefaultType = Self;
1649 }
1650 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1651 #[repr(C)]
1652 #[cfg(feature = "Win32_Foundation")]
1653 pub struct DHCP_CLIENT_INFO {
1654 pub ClientIpAddress: u32,
1655 pub SubnetMask: u32,
1656 pub ClientHardwareAddress: DHCP_BINARY_DATA,
1657 pub ClientName: super::super::Foundation::PWSTR,
1658 pub ClientComment: super::super::Foundation::PWSTR,
1659 pub ClientLeaseExpires: DATE_TIME,
1660 pub OwnerHost: DHCP_HOST_INFO,
1661 }
1662 #[cfg(feature = "Win32_Foundation")]
1663 impl DHCP_CLIENT_INFO {}
1664 #[cfg(feature = "Win32_Foundation")]
1665 impl ::std::default::Default for DHCP_CLIENT_INFO {
default() -> Self1666 fn default() -> Self {
1667 unsafe { ::std::mem::zeroed() }
1668 }
1669 }
1670 #[cfg(feature = "Win32_Foundation")]
1671 impl ::std::fmt::Debug for DHCP_CLIENT_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1672 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1673 fmt.debug_struct("DHCP_CLIENT_INFO")
1674 .field("ClientIpAddress", &self.ClientIpAddress)
1675 .field("SubnetMask", &self.SubnetMask)
1676 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1677 .field("ClientName", &self.ClientName)
1678 .field("ClientComment", &self.ClientComment)
1679 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1680 .field("OwnerHost", &self.OwnerHost)
1681 .finish()
1682 }
1683 }
1684 #[cfg(feature = "Win32_Foundation")]
1685 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO {
eq(&self, other: &Self) -> bool1686 fn eq(&self, other: &Self) -> bool {
1687 self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost
1688 }
1689 }
1690 #[cfg(feature = "Win32_Foundation")]
1691 impl ::std::cmp::Eq for DHCP_CLIENT_INFO {}
1692 #[cfg(feature = "Win32_Foundation")]
1693 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO {
1694 type Abi = Self;
1695 type DefaultType = Self;
1696 }
1697 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1698 #[repr(C)]
1699 #[cfg(feature = "Win32_Foundation")]
1700 pub struct DHCP_CLIENT_INFO_ARRAY {
1701 pub NumElements: u32,
1702 pub Clients: *mut *mut DHCP_CLIENT_INFO,
1703 }
1704 #[cfg(feature = "Win32_Foundation")]
1705 impl DHCP_CLIENT_INFO_ARRAY {}
1706 #[cfg(feature = "Win32_Foundation")]
1707 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY {
default() -> Self1708 fn default() -> Self {
1709 unsafe { ::std::mem::zeroed() }
1710 }
1711 }
1712 #[cfg(feature = "Win32_Foundation")]
1713 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1714 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1715 fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1716 }
1717 }
1718 #[cfg(feature = "Win32_Foundation")]
1719 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool1720 fn eq(&self, other: &Self) -> bool {
1721 self.NumElements == other.NumElements && self.Clients == other.Clients
1722 }
1723 }
1724 #[cfg(feature = "Win32_Foundation")]
1725 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY {}
1726 #[cfg(feature = "Win32_Foundation")]
1727 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY {
1728 type Abi = Self;
1729 type DefaultType = Self;
1730 }
1731 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1732 #[repr(C)]
1733 #[cfg(feature = "Win32_Foundation")]
1734 pub struct DHCP_CLIENT_INFO_ARRAY_V4 {
1735 pub NumElements: u32,
1736 pub Clients: *mut *mut DHCP_CLIENT_INFO_V4,
1737 }
1738 #[cfg(feature = "Win32_Foundation")]
1739 impl DHCP_CLIENT_INFO_ARRAY_V4 {}
1740 #[cfg(feature = "Win32_Foundation")]
1741 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V4 {
default() -> Self1742 fn default() -> Self {
1743 unsafe { ::std::mem::zeroed() }
1744 }
1745 }
1746 #[cfg(feature = "Win32_Foundation")]
1747 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1748 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1749 fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V4").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1750 }
1751 }
1752 #[cfg(feature = "Win32_Foundation")]
1753 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V4 {
eq(&self, other: &Self) -> bool1754 fn eq(&self, other: &Self) -> bool {
1755 self.NumElements == other.NumElements && self.Clients == other.Clients
1756 }
1757 }
1758 #[cfg(feature = "Win32_Foundation")]
1759 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V4 {}
1760 #[cfg(feature = "Win32_Foundation")]
1761 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V4 {
1762 type Abi = Self;
1763 type DefaultType = Self;
1764 }
1765 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1766 #[repr(C)]
1767 #[cfg(feature = "Win32_Foundation")]
1768 pub struct DHCP_CLIENT_INFO_ARRAY_V5 {
1769 pub NumElements: u32,
1770 pub Clients: *mut *mut DHCP_CLIENT_INFO_V5,
1771 }
1772 #[cfg(feature = "Win32_Foundation")]
1773 impl DHCP_CLIENT_INFO_ARRAY_V5 {}
1774 #[cfg(feature = "Win32_Foundation")]
1775 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V5 {
default() -> Self1776 fn default() -> Self {
1777 unsafe { ::std::mem::zeroed() }
1778 }
1779 }
1780 #[cfg(feature = "Win32_Foundation")]
1781 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1782 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1783 fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V5").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1784 }
1785 }
1786 #[cfg(feature = "Win32_Foundation")]
1787 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V5 {
eq(&self, other: &Self) -> bool1788 fn eq(&self, other: &Self) -> bool {
1789 self.NumElements == other.NumElements && self.Clients == other.Clients
1790 }
1791 }
1792 #[cfg(feature = "Win32_Foundation")]
1793 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V5 {}
1794 #[cfg(feature = "Win32_Foundation")]
1795 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V5 {
1796 type Abi = Self;
1797 type DefaultType = Self;
1798 }
1799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1800 #[repr(C)]
1801 #[cfg(feature = "Win32_Foundation")]
1802 pub struct DHCP_CLIENT_INFO_ARRAY_V6 {
1803 pub NumElements: u32,
1804 pub Clients: *mut *mut DHCP_CLIENT_INFO_V6,
1805 }
1806 #[cfg(feature = "Win32_Foundation")]
1807 impl DHCP_CLIENT_INFO_ARRAY_V6 {}
1808 #[cfg(feature = "Win32_Foundation")]
1809 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_V6 {
default() -> Self1810 fn default() -> Self {
1811 unsafe { ::std::mem::zeroed() }
1812 }
1813 }
1814 #[cfg(feature = "Win32_Foundation")]
1815 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1816 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1817 fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1818 }
1819 }
1820 #[cfg(feature = "Win32_Foundation")]
1821 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool1822 fn eq(&self, other: &Self) -> bool {
1823 self.NumElements == other.NumElements && self.Clients == other.Clients
1824 }
1825 }
1826 #[cfg(feature = "Win32_Foundation")]
1827 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_V6 {}
1828 #[cfg(feature = "Win32_Foundation")]
1829 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_V6 {
1830 type Abi = Self;
1831 type DefaultType = Self;
1832 }
1833 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1834 #[repr(C)]
1835 #[cfg(feature = "Win32_Foundation")]
1836 pub struct DHCP_CLIENT_INFO_ARRAY_VQ {
1837 pub NumElements: u32,
1838 pub Clients: *mut *mut DHCP_CLIENT_INFO_VQ,
1839 }
1840 #[cfg(feature = "Win32_Foundation")]
1841 impl DHCP_CLIENT_INFO_ARRAY_VQ {}
1842 #[cfg(feature = "Win32_Foundation")]
1843 impl ::std::default::Default for DHCP_CLIENT_INFO_ARRAY_VQ {
default() -> Self1844 fn default() -> Self {
1845 unsafe { ::std::mem::zeroed() }
1846 }
1847 }
1848 #[cfg(feature = "Win32_Foundation")]
1849 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_ARRAY_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1850 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1851 fmt.debug_struct("DHCP_CLIENT_INFO_ARRAY_VQ").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1852 }
1853 }
1854 #[cfg(feature = "Win32_Foundation")]
1855 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_ARRAY_VQ {
eq(&self, other: &Self) -> bool1856 fn eq(&self, other: &Self) -> bool {
1857 self.NumElements == other.NumElements && self.Clients == other.Clients
1858 }
1859 }
1860 #[cfg(feature = "Win32_Foundation")]
1861 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_ARRAY_VQ {}
1862 #[cfg(feature = "Win32_Foundation")]
1863 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_ARRAY_VQ {
1864 type Abi = Self;
1865 type DefaultType = Self;
1866 }
1867 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1868 #[repr(C)]
1869 #[cfg(feature = "Win32_Foundation")]
1870 pub struct DHCP_CLIENT_INFO_EX {
1871 pub ClientIpAddress: u32,
1872 pub SubnetMask: u32,
1873 pub ClientHardwareAddress: DHCP_BINARY_DATA,
1874 pub ClientName: super::super::Foundation::PWSTR,
1875 pub ClientComment: super::super::Foundation::PWSTR,
1876 pub ClientLeaseExpires: DATE_TIME,
1877 pub OwnerHost: DHCP_HOST_INFO,
1878 pub bClientType: u8,
1879 pub AddressState: u8,
1880 pub Status: QuarantineStatus,
1881 pub ProbationEnds: DATE_TIME,
1882 pub QuarantineCapable: super::super::Foundation::BOOL,
1883 pub FilterStatus: u32,
1884 pub PolicyName: super::super::Foundation::PWSTR,
1885 pub Properties: *mut DHCP_PROPERTY_ARRAY,
1886 }
1887 #[cfg(feature = "Win32_Foundation")]
1888 impl DHCP_CLIENT_INFO_EX {}
1889 #[cfg(feature = "Win32_Foundation")]
1890 impl ::std::default::Default for DHCP_CLIENT_INFO_EX {
default() -> Self1891 fn default() -> Self {
1892 unsafe { ::std::mem::zeroed() }
1893 }
1894 }
1895 #[cfg(feature = "Win32_Foundation")]
1896 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1897 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1898 fmt.debug_struct("DHCP_CLIENT_INFO_EX")
1899 .field("ClientIpAddress", &self.ClientIpAddress)
1900 .field("SubnetMask", &self.SubnetMask)
1901 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
1902 .field("ClientName", &self.ClientName)
1903 .field("ClientComment", &self.ClientComment)
1904 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
1905 .field("OwnerHost", &self.OwnerHost)
1906 .field("bClientType", &self.bClientType)
1907 .field("AddressState", &self.AddressState)
1908 .field("Status", &self.Status)
1909 .field("ProbationEnds", &self.ProbationEnds)
1910 .field("QuarantineCapable", &self.QuarantineCapable)
1911 .field("FilterStatus", &self.FilterStatus)
1912 .field("PolicyName", &self.PolicyName)
1913 .field("Properties", &self.Properties)
1914 .finish()
1915 }
1916 }
1917 #[cfg(feature = "Win32_Foundation")]
1918 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_EX {
eq(&self, other: &Self) -> bool1919 fn eq(&self, other: &Self) -> bool {
1920 self.ClientIpAddress == other.ClientIpAddress
1921 && self.SubnetMask == other.SubnetMask
1922 && self.ClientHardwareAddress == other.ClientHardwareAddress
1923 && self.ClientName == other.ClientName
1924 && self.ClientComment == other.ClientComment
1925 && self.ClientLeaseExpires == other.ClientLeaseExpires
1926 && self.OwnerHost == other.OwnerHost
1927 && self.bClientType == other.bClientType
1928 && self.AddressState == other.AddressState
1929 && self.Status == other.Status
1930 && self.ProbationEnds == other.ProbationEnds
1931 && self.QuarantineCapable == other.QuarantineCapable
1932 && self.FilterStatus == other.FilterStatus
1933 && self.PolicyName == other.PolicyName
1934 && self.Properties == other.Properties
1935 }
1936 }
1937 #[cfg(feature = "Win32_Foundation")]
1938 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_EX {}
1939 #[cfg(feature = "Win32_Foundation")]
1940 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_EX {
1941 type Abi = Self;
1942 type DefaultType = Self;
1943 }
1944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1945 #[repr(C)]
1946 #[cfg(feature = "Win32_Foundation")]
1947 pub struct DHCP_CLIENT_INFO_EX_ARRAY {
1948 pub NumElements: u32,
1949 pub Clients: *mut *mut DHCP_CLIENT_INFO_EX,
1950 }
1951 #[cfg(feature = "Win32_Foundation")]
1952 impl DHCP_CLIENT_INFO_EX_ARRAY {}
1953 #[cfg(feature = "Win32_Foundation")]
1954 impl ::std::default::Default for DHCP_CLIENT_INFO_EX_ARRAY {
default() -> Self1955 fn default() -> Self {
1956 unsafe { ::std::mem::zeroed() }
1957 }
1958 }
1959 #[cfg(feature = "Win32_Foundation")]
1960 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_EX_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1961 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1962 fmt.debug_struct("DHCP_CLIENT_INFO_EX_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
1963 }
1964 }
1965 #[cfg(feature = "Win32_Foundation")]
1966 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_EX_ARRAY {
eq(&self, other: &Self) -> bool1967 fn eq(&self, other: &Self) -> bool {
1968 self.NumElements == other.NumElements && self.Clients == other.Clients
1969 }
1970 }
1971 #[cfg(feature = "Win32_Foundation")]
1972 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_EX_ARRAY {}
1973 #[cfg(feature = "Win32_Foundation")]
1974 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_EX_ARRAY {
1975 type Abi = Self;
1976 type DefaultType = Self;
1977 }
1978 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1979 #[repr(C)]
1980 #[cfg(feature = "Win32_Foundation")]
1981 pub struct DHCP_CLIENT_INFO_PB {
1982 pub ClientIpAddress: u32,
1983 pub SubnetMask: u32,
1984 pub ClientHardwareAddress: DHCP_BINARY_DATA,
1985 pub ClientName: super::super::Foundation::PWSTR,
1986 pub ClientComment: super::super::Foundation::PWSTR,
1987 pub ClientLeaseExpires: DATE_TIME,
1988 pub OwnerHost: DHCP_HOST_INFO,
1989 pub bClientType: u8,
1990 pub AddressState: u8,
1991 pub Status: QuarantineStatus,
1992 pub ProbationEnds: DATE_TIME,
1993 pub QuarantineCapable: super::super::Foundation::BOOL,
1994 pub FilterStatus: u32,
1995 pub PolicyName: super::super::Foundation::PWSTR,
1996 }
1997 #[cfg(feature = "Win32_Foundation")]
1998 impl DHCP_CLIENT_INFO_PB {}
1999 #[cfg(feature = "Win32_Foundation")]
2000 impl ::std::default::Default for DHCP_CLIENT_INFO_PB {
default() -> Self2001 fn default() -> Self {
2002 unsafe { ::std::mem::zeroed() }
2003 }
2004 }
2005 #[cfg(feature = "Win32_Foundation")]
2006 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_PB {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2007 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2008 fmt.debug_struct("DHCP_CLIENT_INFO_PB")
2009 .field("ClientIpAddress", &self.ClientIpAddress)
2010 .field("SubnetMask", &self.SubnetMask)
2011 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2012 .field("ClientName", &self.ClientName)
2013 .field("ClientComment", &self.ClientComment)
2014 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2015 .field("OwnerHost", &self.OwnerHost)
2016 .field("bClientType", &self.bClientType)
2017 .field("AddressState", &self.AddressState)
2018 .field("Status", &self.Status)
2019 .field("ProbationEnds", &self.ProbationEnds)
2020 .field("QuarantineCapable", &self.QuarantineCapable)
2021 .field("FilterStatus", &self.FilterStatus)
2022 .field("PolicyName", &self.PolicyName)
2023 .finish()
2024 }
2025 }
2026 #[cfg(feature = "Win32_Foundation")]
2027 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_PB {
eq(&self, other: &Self) -> bool2028 fn eq(&self, other: &Self) -> bool {
2029 self.ClientIpAddress == other.ClientIpAddress
2030 && self.SubnetMask == other.SubnetMask
2031 && self.ClientHardwareAddress == other.ClientHardwareAddress
2032 && self.ClientName == other.ClientName
2033 && self.ClientComment == other.ClientComment
2034 && self.ClientLeaseExpires == other.ClientLeaseExpires
2035 && self.OwnerHost == other.OwnerHost
2036 && self.bClientType == other.bClientType
2037 && self.AddressState == other.AddressState
2038 && self.Status == other.Status
2039 && self.ProbationEnds == other.ProbationEnds
2040 && self.QuarantineCapable == other.QuarantineCapable
2041 && self.FilterStatus == other.FilterStatus
2042 && self.PolicyName == other.PolicyName
2043 }
2044 }
2045 #[cfg(feature = "Win32_Foundation")]
2046 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_PB {}
2047 #[cfg(feature = "Win32_Foundation")]
2048 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_PB {
2049 type Abi = Self;
2050 type DefaultType = Self;
2051 }
2052 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2053 #[repr(C)]
2054 #[cfg(feature = "Win32_Foundation")]
2055 pub struct DHCP_CLIENT_INFO_PB_ARRAY {
2056 pub NumElements: u32,
2057 pub Clients: *mut *mut DHCP_CLIENT_INFO_PB,
2058 }
2059 #[cfg(feature = "Win32_Foundation")]
2060 impl DHCP_CLIENT_INFO_PB_ARRAY {}
2061 #[cfg(feature = "Win32_Foundation")]
2062 impl ::std::default::Default for DHCP_CLIENT_INFO_PB_ARRAY {
default() -> Self2063 fn default() -> Self {
2064 unsafe { ::std::mem::zeroed() }
2065 }
2066 }
2067 #[cfg(feature = "Win32_Foundation")]
2068 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_PB_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2069 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2070 fmt.debug_struct("DHCP_CLIENT_INFO_PB_ARRAY").field("NumElements", &self.NumElements).field("Clients", &self.Clients).finish()
2071 }
2072 }
2073 #[cfg(feature = "Win32_Foundation")]
2074 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_PB_ARRAY {
eq(&self, other: &Self) -> bool2075 fn eq(&self, other: &Self) -> bool {
2076 self.NumElements == other.NumElements && self.Clients == other.Clients
2077 }
2078 }
2079 #[cfg(feature = "Win32_Foundation")]
2080 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_PB_ARRAY {}
2081 #[cfg(feature = "Win32_Foundation")]
2082 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_PB_ARRAY {
2083 type Abi = Self;
2084 type DefaultType = Self;
2085 }
2086 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2087 #[repr(C)]
2088 #[cfg(feature = "Win32_Foundation")]
2089 pub struct DHCP_CLIENT_INFO_V4 {
2090 pub ClientIpAddress: u32,
2091 pub SubnetMask: u32,
2092 pub ClientHardwareAddress: DHCP_BINARY_DATA,
2093 pub ClientName: super::super::Foundation::PWSTR,
2094 pub ClientComment: super::super::Foundation::PWSTR,
2095 pub ClientLeaseExpires: DATE_TIME,
2096 pub OwnerHost: DHCP_HOST_INFO,
2097 pub bClientType: u8,
2098 }
2099 #[cfg(feature = "Win32_Foundation")]
2100 impl DHCP_CLIENT_INFO_V4 {}
2101 #[cfg(feature = "Win32_Foundation")]
2102 impl ::std::default::Default for DHCP_CLIENT_INFO_V4 {
default() -> Self2103 fn default() -> Self {
2104 unsafe { ::std::mem::zeroed() }
2105 }
2106 }
2107 #[cfg(feature = "Win32_Foundation")]
2108 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2109 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2110 fmt.debug_struct("DHCP_CLIENT_INFO_V4")
2111 .field("ClientIpAddress", &self.ClientIpAddress)
2112 .field("SubnetMask", &self.SubnetMask)
2113 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2114 .field("ClientName", &self.ClientName)
2115 .field("ClientComment", &self.ClientComment)
2116 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2117 .field("OwnerHost", &self.OwnerHost)
2118 .field("bClientType", &self.bClientType)
2119 .finish()
2120 }
2121 }
2122 #[cfg(feature = "Win32_Foundation")]
2123 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V4 {
eq(&self, other: &Self) -> bool2124 fn eq(&self, other: &Self) -> bool {
2125 self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost && self.bClientType == other.bClientType
2126 }
2127 }
2128 #[cfg(feature = "Win32_Foundation")]
2129 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V4 {}
2130 #[cfg(feature = "Win32_Foundation")]
2131 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V4 {
2132 type Abi = Self;
2133 type DefaultType = Self;
2134 }
2135 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2136 #[repr(C)]
2137 #[cfg(feature = "Win32_Foundation")]
2138 pub struct DHCP_CLIENT_INFO_V5 {
2139 pub ClientIpAddress: u32,
2140 pub SubnetMask: u32,
2141 pub ClientHardwareAddress: DHCP_BINARY_DATA,
2142 pub ClientName: super::super::Foundation::PWSTR,
2143 pub ClientComment: super::super::Foundation::PWSTR,
2144 pub ClientLeaseExpires: DATE_TIME,
2145 pub OwnerHost: DHCP_HOST_INFO,
2146 pub bClientType: u8,
2147 pub AddressState: u8,
2148 }
2149 #[cfg(feature = "Win32_Foundation")]
2150 impl DHCP_CLIENT_INFO_V5 {}
2151 #[cfg(feature = "Win32_Foundation")]
2152 impl ::std::default::Default for DHCP_CLIENT_INFO_V5 {
default() -> Self2153 fn default() -> Self {
2154 unsafe { ::std::mem::zeroed() }
2155 }
2156 }
2157 #[cfg(feature = "Win32_Foundation")]
2158 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2159 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2160 fmt.debug_struct("DHCP_CLIENT_INFO_V5")
2161 .field("ClientIpAddress", &self.ClientIpAddress)
2162 .field("SubnetMask", &self.SubnetMask)
2163 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2164 .field("ClientName", &self.ClientName)
2165 .field("ClientComment", &self.ClientComment)
2166 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2167 .field("OwnerHost", &self.OwnerHost)
2168 .field("bClientType", &self.bClientType)
2169 .field("AddressState", &self.AddressState)
2170 .finish()
2171 }
2172 }
2173 #[cfg(feature = "Win32_Foundation")]
2174 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V5 {
eq(&self, other: &Self) -> bool2175 fn eq(&self, other: &Self) -> bool {
2176 self.ClientIpAddress == other.ClientIpAddress && self.SubnetMask == other.SubnetMask && self.ClientHardwareAddress == other.ClientHardwareAddress && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientLeaseExpires == other.ClientLeaseExpires && self.OwnerHost == other.OwnerHost && self.bClientType == other.bClientType && self.AddressState == other.AddressState
2177 }
2178 }
2179 #[cfg(feature = "Win32_Foundation")]
2180 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V5 {}
2181 #[cfg(feature = "Win32_Foundation")]
2182 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V5 {
2183 type Abi = Self;
2184 type DefaultType = Self;
2185 }
2186 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2187 #[repr(C)]
2188 #[cfg(feature = "Win32_Foundation")]
2189 pub struct DHCP_CLIENT_INFO_V6 {
2190 pub ClientIpAddress: DHCP_IPV6_ADDRESS,
2191 pub ClientDUID: DHCP_BINARY_DATA,
2192 pub AddressType: u32,
2193 pub IAID: u32,
2194 pub ClientName: super::super::Foundation::PWSTR,
2195 pub ClientComment: super::super::Foundation::PWSTR,
2196 pub ClientValidLeaseExpires: DATE_TIME,
2197 pub ClientPrefLeaseExpires: DATE_TIME,
2198 pub OwnerHost: DHCP_HOST_INFO_V6,
2199 }
2200 #[cfg(feature = "Win32_Foundation")]
2201 impl DHCP_CLIENT_INFO_V6 {}
2202 #[cfg(feature = "Win32_Foundation")]
2203 impl ::std::default::Default for DHCP_CLIENT_INFO_V6 {
default() -> Self2204 fn default() -> Self {
2205 unsafe { ::std::mem::zeroed() }
2206 }
2207 }
2208 #[cfg(feature = "Win32_Foundation")]
2209 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2210 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2211 fmt.debug_struct("DHCP_CLIENT_INFO_V6")
2212 .field("ClientIpAddress", &self.ClientIpAddress)
2213 .field("ClientDUID", &self.ClientDUID)
2214 .field("AddressType", &self.AddressType)
2215 .field("IAID", &self.IAID)
2216 .field("ClientName", &self.ClientName)
2217 .field("ClientComment", &self.ClientComment)
2218 .field("ClientValidLeaseExpires", &self.ClientValidLeaseExpires)
2219 .field("ClientPrefLeaseExpires", &self.ClientPrefLeaseExpires)
2220 .field("OwnerHost", &self.OwnerHost)
2221 .finish()
2222 }
2223 }
2224 #[cfg(feature = "Win32_Foundation")]
2225 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_V6 {
eq(&self, other: &Self) -> bool2226 fn eq(&self, other: &Self) -> bool {
2227 self.ClientIpAddress == other.ClientIpAddress && self.ClientDUID == other.ClientDUID && self.AddressType == other.AddressType && self.IAID == other.IAID && self.ClientName == other.ClientName && self.ClientComment == other.ClientComment && self.ClientValidLeaseExpires == other.ClientValidLeaseExpires && self.ClientPrefLeaseExpires == other.ClientPrefLeaseExpires && self.OwnerHost == other.OwnerHost
2228 }
2229 }
2230 #[cfg(feature = "Win32_Foundation")]
2231 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_V6 {}
2232 #[cfg(feature = "Win32_Foundation")]
2233 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_V6 {
2234 type Abi = Self;
2235 type DefaultType = Self;
2236 }
2237 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2238 #[repr(C)]
2239 #[cfg(feature = "Win32_Foundation")]
2240 pub struct DHCP_CLIENT_INFO_VQ {
2241 pub ClientIpAddress: u32,
2242 pub SubnetMask: u32,
2243 pub ClientHardwareAddress: DHCP_BINARY_DATA,
2244 pub ClientName: super::super::Foundation::PWSTR,
2245 pub ClientComment: super::super::Foundation::PWSTR,
2246 pub ClientLeaseExpires: DATE_TIME,
2247 pub OwnerHost: DHCP_HOST_INFO,
2248 pub bClientType: u8,
2249 pub AddressState: u8,
2250 pub Status: QuarantineStatus,
2251 pub ProbationEnds: DATE_TIME,
2252 pub QuarantineCapable: super::super::Foundation::BOOL,
2253 }
2254 #[cfg(feature = "Win32_Foundation")]
2255 impl DHCP_CLIENT_INFO_VQ {}
2256 #[cfg(feature = "Win32_Foundation")]
2257 impl ::std::default::Default for DHCP_CLIENT_INFO_VQ {
default() -> Self2258 fn default() -> Self {
2259 unsafe { ::std::mem::zeroed() }
2260 }
2261 }
2262 #[cfg(feature = "Win32_Foundation")]
2263 impl ::std::fmt::Debug for DHCP_CLIENT_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2264 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2265 fmt.debug_struct("DHCP_CLIENT_INFO_VQ")
2266 .field("ClientIpAddress", &self.ClientIpAddress)
2267 .field("SubnetMask", &self.SubnetMask)
2268 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
2269 .field("ClientName", &self.ClientName)
2270 .field("ClientComment", &self.ClientComment)
2271 .field("ClientLeaseExpires", &self.ClientLeaseExpires)
2272 .field("OwnerHost", &self.OwnerHost)
2273 .field("bClientType", &self.bClientType)
2274 .field("AddressState", &self.AddressState)
2275 .field("Status", &self.Status)
2276 .field("ProbationEnds", &self.ProbationEnds)
2277 .field("QuarantineCapable", &self.QuarantineCapable)
2278 .finish()
2279 }
2280 }
2281 #[cfg(feature = "Win32_Foundation")]
2282 impl ::std::cmp::PartialEq for DHCP_CLIENT_INFO_VQ {
eq(&self, other: &Self) -> bool2283 fn eq(&self, other: &Self) -> bool {
2284 self.ClientIpAddress == other.ClientIpAddress
2285 && self.SubnetMask == other.SubnetMask
2286 && self.ClientHardwareAddress == other.ClientHardwareAddress
2287 && self.ClientName == other.ClientName
2288 && self.ClientComment == other.ClientComment
2289 && self.ClientLeaseExpires == other.ClientLeaseExpires
2290 && self.OwnerHost == other.OwnerHost
2291 && self.bClientType == other.bClientType
2292 && self.AddressState == other.AddressState
2293 && self.Status == other.Status
2294 && self.ProbationEnds == other.ProbationEnds
2295 && self.QuarantineCapable == other.QuarantineCapable
2296 }
2297 }
2298 #[cfg(feature = "Win32_Foundation")]
2299 impl ::std::cmp::Eq for DHCP_CLIENT_INFO_VQ {}
2300 #[cfg(feature = "Win32_Foundation")]
2301 unsafe impl ::windows::runtime::Abi for DHCP_CLIENT_INFO_VQ {
2302 type Abi = Self;
2303 type DefaultType = Self;
2304 }
2305 #[repr(C)]
2306 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
2307 pub struct DHCP_CLIENT_SEARCH_UNION(pub u8);
2308 pub const DHCP_CONTROL_CONTINUE: u32 = 4u32;
2309 pub const DHCP_CONTROL_PAUSE: u32 = 3u32;
2310 pub const DHCP_CONTROL_START: u32 = 1u32;
2311 pub const DHCP_CONTROL_STOP: u32 = 2u32;
2312 pub const DHCP_DROP_DUPLICATE: u32 = 1u32;
2313 pub const DHCP_DROP_GEN_FAILURE: u32 = 256u32;
2314 pub const DHCP_DROP_INTERNAL_ERROR: u32 = 3u32;
2315 pub const DHCP_DROP_INVALID: u32 = 8u32;
2316 pub const DHCP_DROP_NOADDRESS: u32 = 10u32;
2317 pub const DHCP_DROP_NOMEM: u32 = 2u32;
2318 pub const DHCP_DROP_NO_SUBNETS: u32 = 7u32;
2319 pub const DHCP_DROP_PAUSED: u32 = 6u32;
2320 pub const DHCP_DROP_PROCESSED: u32 = 11u32;
2321 pub const DHCP_DROP_TIMEOUT: u32 = 4u32;
2322 pub const DHCP_DROP_UNAUTH: u32 = 5u32;
2323 pub const DHCP_DROP_WRONG_SERVER: u32 = 9u32;
2324 pub const DHCP_ENDPOINT_FLAG_CANT_MODIFY: u32 = 1u32;
2325 pub const DHCP_FAILOVER_DELETE_SCOPES: u32 = 1u32;
2326 pub const DHCP_FAILOVER_MAX_NUM_ADD_SCOPES: u32 = 400u32;
2327 pub const DHCP_FAILOVER_MAX_NUM_REL: u32 = 31u32;
2328 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2329 #[repr(transparent)]
2330 pub struct DHCP_FAILOVER_MODE(pub i32);
2331 pub const LoadBalance: DHCP_FAILOVER_MODE = DHCP_FAILOVER_MODE(0i32);
2332 pub const HotStandby: DHCP_FAILOVER_MODE = DHCP_FAILOVER_MODE(1i32);
2333 impl ::std::convert::From<i32> for DHCP_FAILOVER_MODE {
from(value: i32) -> Self2334 fn from(value: i32) -> Self {
2335 Self(value)
2336 }
2337 }
2338 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_MODE {
2339 type Abi = Self;
2340 type DefaultType = Self;
2341 }
2342 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2343 #[repr(C)]
2344 #[cfg(feature = "Win32_Foundation")]
2345 pub struct DHCP_FAILOVER_RELATIONSHIP {
2346 pub PrimaryServer: u32,
2347 pub SecondaryServer: u32,
2348 pub Mode: DHCP_FAILOVER_MODE,
2349 pub ServerType: DHCP_FAILOVER_SERVER,
2350 pub State: FSM_STATE,
2351 pub PrevState: FSM_STATE,
2352 pub Mclt: u32,
2353 pub SafePeriod: u32,
2354 pub RelationshipName: super::super::Foundation::PWSTR,
2355 pub PrimaryServerName: super::super::Foundation::PWSTR,
2356 pub SecondaryServerName: super::super::Foundation::PWSTR,
2357 pub pScopes: *mut DHCP_IP_ARRAY,
2358 pub Percentage: u8,
2359 pub SharedSecret: super::super::Foundation::PWSTR,
2360 }
2361 #[cfg(feature = "Win32_Foundation")]
2362 impl DHCP_FAILOVER_RELATIONSHIP {}
2363 #[cfg(feature = "Win32_Foundation")]
2364 impl ::std::default::Default for DHCP_FAILOVER_RELATIONSHIP {
default() -> Self2365 fn default() -> Self {
2366 unsafe { ::std::mem::zeroed() }
2367 }
2368 }
2369 #[cfg(feature = "Win32_Foundation")]
2370 impl ::std::fmt::Debug for DHCP_FAILOVER_RELATIONSHIP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2371 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2372 fmt.debug_struct("DHCP_FAILOVER_RELATIONSHIP")
2373 .field("PrimaryServer", &self.PrimaryServer)
2374 .field("SecondaryServer", &self.SecondaryServer)
2375 .field("Mode", &self.Mode)
2376 .field("ServerType", &self.ServerType)
2377 .field("State", &self.State)
2378 .field("PrevState", &self.PrevState)
2379 .field("Mclt", &self.Mclt)
2380 .field("SafePeriod", &self.SafePeriod)
2381 .field("RelationshipName", &self.RelationshipName)
2382 .field("PrimaryServerName", &self.PrimaryServerName)
2383 .field("SecondaryServerName", &self.SecondaryServerName)
2384 .field("pScopes", &self.pScopes)
2385 .field("Percentage", &self.Percentage)
2386 .field("SharedSecret", &self.SharedSecret)
2387 .finish()
2388 }
2389 }
2390 #[cfg(feature = "Win32_Foundation")]
2391 impl ::std::cmp::PartialEq for DHCP_FAILOVER_RELATIONSHIP {
eq(&self, other: &Self) -> bool2392 fn eq(&self, other: &Self) -> bool {
2393 self.PrimaryServer == other.PrimaryServer
2394 && self.SecondaryServer == other.SecondaryServer
2395 && self.Mode == other.Mode
2396 && self.ServerType == other.ServerType
2397 && self.State == other.State
2398 && self.PrevState == other.PrevState
2399 && self.Mclt == other.Mclt
2400 && self.SafePeriod == other.SafePeriod
2401 && self.RelationshipName == other.RelationshipName
2402 && self.PrimaryServerName == other.PrimaryServerName
2403 && self.SecondaryServerName == other.SecondaryServerName
2404 && self.pScopes == other.pScopes
2405 && self.Percentage == other.Percentage
2406 && self.SharedSecret == other.SharedSecret
2407 }
2408 }
2409 #[cfg(feature = "Win32_Foundation")]
2410 impl ::std::cmp::Eq for DHCP_FAILOVER_RELATIONSHIP {}
2411 #[cfg(feature = "Win32_Foundation")]
2412 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_RELATIONSHIP {
2413 type Abi = Self;
2414 type DefaultType = Self;
2415 }
2416 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2417 #[repr(C)]
2418 #[cfg(feature = "Win32_Foundation")]
2419 pub struct DHCP_FAILOVER_RELATIONSHIP_ARRAY {
2420 pub NumElements: u32,
2421 pub pRelationships: *mut DHCP_FAILOVER_RELATIONSHIP,
2422 }
2423 #[cfg(feature = "Win32_Foundation")]
2424 impl DHCP_FAILOVER_RELATIONSHIP_ARRAY {}
2425 #[cfg(feature = "Win32_Foundation")]
2426 impl ::std::default::Default for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
default() -> Self2427 fn default() -> Self {
2428 unsafe { ::std::mem::zeroed() }
2429 }
2430 }
2431 #[cfg(feature = "Win32_Foundation")]
2432 impl ::std::fmt::Debug for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2433 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2434 fmt.debug_struct("DHCP_FAILOVER_RELATIONSHIP_ARRAY").field("NumElements", &self.NumElements).field("pRelationships", &self.pRelationships).finish()
2435 }
2436 }
2437 #[cfg(feature = "Win32_Foundation")]
2438 impl ::std::cmp::PartialEq for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
eq(&self, other: &Self) -> bool2439 fn eq(&self, other: &Self) -> bool {
2440 self.NumElements == other.NumElements && self.pRelationships == other.pRelationships
2441 }
2442 }
2443 #[cfg(feature = "Win32_Foundation")]
2444 impl ::std::cmp::Eq for DHCP_FAILOVER_RELATIONSHIP_ARRAY {}
2445 #[cfg(feature = "Win32_Foundation")]
2446 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_RELATIONSHIP_ARRAY {
2447 type Abi = Self;
2448 type DefaultType = Self;
2449 }
2450 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2451 #[repr(transparent)]
2452 pub struct DHCP_FAILOVER_SERVER(pub i32);
2453 pub const PrimaryServer: DHCP_FAILOVER_SERVER = DHCP_FAILOVER_SERVER(0i32);
2454 pub const SecondaryServer: DHCP_FAILOVER_SERVER = DHCP_FAILOVER_SERVER(1i32);
2455 impl ::std::convert::From<i32> for DHCP_FAILOVER_SERVER {
from(value: i32) -> Self2456 fn from(value: i32) -> Self {
2457 Self(value)
2458 }
2459 }
2460 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_SERVER {
2461 type Abi = Self;
2462 type DefaultType = Self;
2463 }
2464 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2465 #[repr(C)]
2466 pub struct DHCP_FAILOVER_STATISTICS {
2467 pub NumAddr: u32,
2468 pub AddrFree: u32,
2469 pub AddrInUse: u32,
2470 pub PartnerAddrFree: u32,
2471 pub ThisAddrFree: u32,
2472 pub PartnerAddrInUse: u32,
2473 pub ThisAddrInUse: u32,
2474 }
2475 impl DHCP_FAILOVER_STATISTICS {}
2476 impl ::std::default::Default for DHCP_FAILOVER_STATISTICS {
default() -> Self2477 fn default() -> Self {
2478 unsafe { ::std::mem::zeroed() }
2479 }
2480 }
2481 impl ::std::fmt::Debug for DHCP_FAILOVER_STATISTICS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2482 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2483 fmt.debug_struct("DHCP_FAILOVER_STATISTICS")
2484 .field("NumAddr", &self.NumAddr)
2485 .field("AddrFree", &self.AddrFree)
2486 .field("AddrInUse", &self.AddrInUse)
2487 .field("PartnerAddrFree", &self.PartnerAddrFree)
2488 .field("ThisAddrFree", &self.ThisAddrFree)
2489 .field("PartnerAddrInUse", &self.PartnerAddrInUse)
2490 .field("ThisAddrInUse", &self.ThisAddrInUse)
2491 .finish()
2492 }
2493 }
2494 impl ::std::cmp::PartialEq for DHCP_FAILOVER_STATISTICS {
eq(&self, other: &Self) -> bool2495 fn eq(&self, other: &Self) -> bool {
2496 self.NumAddr == other.NumAddr && self.AddrFree == other.AddrFree && self.AddrInUse == other.AddrInUse && self.PartnerAddrFree == other.PartnerAddrFree && self.ThisAddrFree == other.ThisAddrFree && self.PartnerAddrInUse == other.PartnerAddrInUse && self.ThisAddrInUse == other.ThisAddrInUse
2497 }
2498 }
2499 impl ::std::cmp::Eq for DHCP_FAILOVER_STATISTICS {}
2500 unsafe impl ::windows::runtime::Abi for DHCP_FAILOVER_STATISTICS {
2501 type Abi = Self;
2502 type DefaultType = Self;
2503 }
2504 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2505 #[repr(C)]
2506 #[cfg(feature = "Win32_Foundation")]
2507 pub struct DHCP_FILTER_ADD_INFO {
2508 pub AddrPatt: DHCP_ADDR_PATTERN,
2509 pub Comment: super::super::Foundation::PWSTR,
2510 pub ListType: DHCP_FILTER_LIST_TYPE,
2511 }
2512 #[cfg(feature = "Win32_Foundation")]
2513 impl DHCP_FILTER_ADD_INFO {}
2514 #[cfg(feature = "Win32_Foundation")]
2515 impl ::std::default::Default for DHCP_FILTER_ADD_INFO {
default() -> Self2516 fn default() -> Self {
2517 unsafe { ::std::mem::zeroed() }
2518 }
2519 }
2520 #[cfg(feature = "Win32_Foundation")]
2521 impl ::std::fmt::Debug for DHCP_FILTER_ADD_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2522 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2523 fmt.debug_struct("DHCP_FILTER_ADD_INFO").field("AddrPatt", &self.AddrPatt).field("Comment", &self.Comment).field("ListType", &self.ListType).finish()
2524 }
2525 }
2526 #[cfg(feature = "Win32_Foundation")]
2527 impl ::std::cmp::PartialEq for DHCP_FILTER_ADD_INFO {
eq(&self, other: &Self) -> bool2528 fn eq(&self, other: &Self) -> bool {
2529 self.AddrPatt == other.AddrPatt && self.Comment == other.Comment && self.ListType == other.ListType
2530 }
2531 }
2532 #[cfg(feature = "Win32_Foundation")]
2533 impl ::std::cmp::Eq for DHCP_FILTER_ADD_INFO {}
2534 #[cfg(feature = "Win32_Foundation")]
2535 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_ADD_INFO {
2536 type Abi = Self;
2537 type DefaultType = Self;
2538 }
2539 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2540 #[repr(C)]
2541 #[cfg(feature = "Win32_Foundation")]
2542 pub struct DHCP_FILTER_ENUM_INFO {
2543 pub NumElements: u32,
2544 pub pEnumRecords: *mut DHCP_FILTER_RECORD,
2545 }
2546 #[cfg(feature = "Win32_Foundation")]
2547 impl DHCP_FILTER_ENUM_INFO {}
2548 #[cfg(feature = "Win32_Foundation")]
2549 impl ::std::default::Default for DHCP_FILTER_ENUM_INFO {
default() -> Self2550 fn default() -> Self {
2551 unsafe { ::std::mem::zeroed() }
2552 }
2553 }
2554 #[cfg(feature = "Win32_Foundation")]
2555 impl ::std::fmt::Debug for DHCP_FILTER_ENUM_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2556 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2557 fmt.debug_struct("DHCP_FILTER_ENUM_INFO").field("NumElements", &self.NumElements).field("pEnumRecords", &self.pEnumRecords).finish()
2558 }
2559 }
2560 #[cfg(feature = "Win32_Foundation")]
2561 impl ::std::cmp::PartialEq for DHCP_FILTER_ENUM_INFO {
eq(&self, other: &Self) -> bool2562 fn eq(&self, other: &Self) -> bool {
2563 self.NumElements == other.NumElements && self.pEnumRecords == other.pEnumRecords
2564 }
2565 }
2566 #[cfg(feature = "Win32_Foundation")]
2567 impl ::std::cmp::Eq for DHCP_FILTER_ENUM_INFO {}
2568 #[cfg(feature = "Win32_Foundation")]
2569 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_ENUM_INFO {
2570 type Abi = Self;
2571 type DefaultType = Self;
2572 }
2573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2574 #[repr(C)]
2575 #[cfg(feature = "Win32_Foundation")]
2576 pub struct DHCP_FILTER_GLOBAL_INFO {
2577 pub EnforceAllowList: super::super::Foundation::BOOL,
2578 pub EnforceDenyList: super::super::Foundation::BOOL,
2579 }
2580 #[cfg(feature = "Win32_Foundation")]
2581 impl DHCP_FILTER_GLOBAL_INFO {}
2582 #[cfg(feature = "Win32_Foundation")]
2583 impl ::std::default::Default for DHCP_FILTER_GLOBAL_INFO {
default() -> Self2584 fn default() -> Self {
2585 unsafe { ::std::mem::zeroed() }
2586 }
2587 }
2588 #[cfg(feature = "Win32_Foundation")]
2589 impl ::std::fmt::Debug for DHCP_FILTER_GLOBAL_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2590 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2591 fmt.debug_struct("DHCP_FILTER_GLOBAL_INFO").field("EnforceAllowList", &self.EnforceAllowList).field("EnforceDenyList", &self.EnforceDenyList).finish()
2592 }
2593 }
2594 #[cfg(feature = "Win32_Foundation")]
2595 impl ::std::cmp::PartialEq for DHCP_FILTER_GLOBAL_INFO {
eq(&self, other: &Self) -> bool2596 fn eq(&self, other: &Self) -> bool {
2597 self.EnforceAllowList == other.EnforceAllowList && self.EnforceDenyList == other.EnforceDenyList
2598 }
2599 }
2600 #[cfg(feature = "Win32_Foundation")]
2601 impl ::std::cmp::Eq for DHCP_FILTER_GLOBAL_INFO {}
2602 #[cfg(feature = "Win32_Foundation")]
2603 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_GLOBAL_INFO {
2604 type Abi = Self;
2605 type DefaultType = Self;
2606 }
2607 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2608 #[repr(transparent)]
2609 pub struct DHCP_FILTER_LIST_TYPE(pub i32);
2610 pub const Deny: DHCP_FILTER_LIST_TYPE = DHCP_FILTER_LIST_TYPE(0i32);
2611 pub const Allow: DHCP_FILTER_LIST_TYPE = DHCP_FILTER_LIST_TYPE(1i32);
2612 impl ::std::convert::From<i32> for DHCP_FILTER_LIST_TYPE {
from(value: i32) -> Self2613 fn from(value: i32) -> Self {
2614 Self(value)
2615 }
2616 }
2617 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_LIST_TYPE {
2618 type Abi = Self;
2619 type DefaultType = Self;
2620 }
2621 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2622 #[repr(C)]
2623 #[cfg(feature = "Win32_Foundation")]
2624 pub struct DHCP_FILTER_RECORD {
2625 pub AddrPatt: DHCP_ADDR_PATTERN,
2626 pub Comment: super::super::Foundation::PWSTR,
2627 }
2628 #[cfg(feature = "Win32_Foundation")]
2629 impl DHCP_FILTER_RECORD {}
2630 #[cfg(feature = "Win32_Foundation")]
2631 impl ::std::default::Default for DHCP_FILTER_RECORD {
default() -> Self2632 fn default() -> Self {
2633 unsafe { ::std::mem::zeroed() }
2634 }
2635 }
2636 #[cfg(feature = "Win32_Foundation")]
2637 impl ::std::fmt::Debug for DHCP_FILTER_RECORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2638 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2639 fmt.debug_struct("DHCP_FILTER_RECORD").field("AddrPatt", &self.AddrPatt).field("Comment", &self.Comment).finish()
2640 }
2641 }
2642 #[cfg(feature = "Win32_Foundation")]
2643 impl ::std::cmp::PartialEq for DHCP_FILTER_RECORD {
eq(&self, other: &Self) -> bool2644 fn eq(&self, other: &Self) -> bool {
2645 self.AddrPatt == other.AddrPatt && self.Comment == other.Comment
2646 }
2647 }
2648 #[cfg(feature = "Win32_Foundation")]
2649 impl ::std::cmp::Eq for DHCP_FILTER_RECORD {}
2650 #[cfg(feature = "Win32_Foundation")]
2651 unsafe impl ::windows::runtime::Abi for DHCP_FILTER_RECORD {
2652 type Abi = Self;
2653 type DefaultType = Self;
2654 }
2655 pub const DHCP_FLAGS_DONT_ACCESS_DS: u32 = 1u32;
2656 pub const DHCP_FLAGS_DONT_DO_RPC: u32 = 2u32;
2657 pub const DHCP_FLAGS_OPTION_IS_VENDOR: u32 = 3u32;
2658 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2659 #[repr(transparent)]
2660 pub struct DHCP_FORCE_FLAG(pub i32);
2661 pub const DhcpFullForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(0i32);
2662 pub const DhcpNoForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(1i32);
2663 pub const DhcpFailoverForce: DHCP_FORCE_FLAG = DHCP_FORCE_FLAG(2i32);
2664 impl ::std::convert::From<i32> for DHCP_FORCE_FLAG {
from(value: i32) -> Self2665 fn from(value: i32) -> Self {
2666 Self(value)
2667 }
2668 }
2669 unsafe impl ::windows::runtime::Abi for DHCP_FORCE_FLAG {
2670 type Abi = Self;
2671 type DefaultType = Self;
2672 }
2673 pub const DHCP_GIVE_ADDRESS_NEW: u32 = 805306369u32;
2674 pub const DHCP_GIVE_ADDRESS_OLD: u32 = 805306370u32;
2675 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2676 #[repr(C)]
2677 #[cfg(feature = "Win32_Foundation")]
2678 pub struct DHCP_HOST_INFO {
2679 pub IpAddress: u32,
2680 pub NetBiosName: super::super::Foundation::PWSTR,
2681 pub HostName: super::super::Foundation::PWSTR,
2682 }
2683 #[cfg(feature = "Win32_Foundation")]
2684 impl DHCP_HOST_INFO {}
2685 #[cfg(feature = "Win32_Foundation")]
2686 impl ::std::default::Default for DHCP_HOST_INFO {
default() -> Self2687 fn default() -> Self {
2688 unsafe { ::std::mem::zeroed() }
2689 }
2690 }
2691 #[cfg(feature = "Win32_Foundation")]
2692 impl ::std::fmt::Debug for DHCP_HOST_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2693 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2694 fmt.debug_struct("DHCP_HOST_INFO").field("IpAddress", &self.IpAddress).field("NetBiosName", &self.NetBiosName).field("HostName", &self.HostName).finish()
2695 }
2696 }
2697 #[cfg(feature = "Win32_Foundation")]
2698 impl ::std::cmp::PartialEq for DHCP_HOST_INFO {
eq(&self, other: &Self) -> bool2699 fn eq(&self, other: &Self) -> bool {
2700 self.IpAddress == other.IpAddress && self.NetBiosName == other.NetBiosName && self.HostName == other.HostName
2701 }
2702 }
2703 #[cfg(feature = "Win32_Foundation")]
2704 impl ::std::cmp::Eq for DHCP_HOST_INFO {}
2705 #[cfg(feature = "Win32_Foundation")]
2706 unsafe impl ::windows::runtime::Abi for DHCP_HOST_INFO {
2707 type Abi = Self;
2708 type DefaultType = Self;
2709 }
2710 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2711 #[repr(C)]
2712 #[cfg(feature = "Win32_Foundation")]
2713 pub struct DHCP_HOST_INFO_V6 {
2714 pub IpAddress: DHCP_IPV6_ADDRESS,
2715 pub NetBiosName: super::super::Foundation::PWSTR,
2716 pub HostName: super::super::Foundation::PWSTR,
2717 }
2718 #[cfg(feature = "Win32_Foundation")]
2719 impl DHCP_HOST_INFO_V6 {}
2720 #[cfg(feature = "Win32_Foundation")]
2721 impl ::std::default::Default for DHCP_HOST_INFO_V6 {
default() -> Self2722 fn default() -> Self {
2723 unsafe { ::std::mem::zeroed() }
2724 }
2725 }
2726 #[cfg(feature = "Win32_Foundation")]
2727 impl ::std::fmt::Debug for DHCP_HOST_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2728 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2729 fmt.debug_struct("DHCP_HOST_INFO_V6").field("IpAddress", &self.IpAddress).field("NetBiosName", &self.NetBiosName).field("HostName", &self.HostName).finish()
2730 }
2731 }
2732 #[cfg(feature = "Win32_Foundation")]
2733 impl ::std::cmp::PartialEq for DHCP_HOST_INFO_V6 {
eq(&self, other: &Self) -> bool2734 fn eq(&self, other: &Self) -> bool {
2735 self.IpAddress == other.IpAddress && self.NetBiosName == other.NetBiosName && self.HostName == other.HostName
2736 }
2737 }
2738 #[cfg(feature = "Win32_Foundation")]
2739 impl ::std::cmp::Eq for DHCP_HOST_INFO_V6 {}
2740 #[cfg(feature = "Win32_Foundation")]
2741 unsafe impl ::windows::runtime::Abi for DHCP_HOST_INFO_V6 {
2742 type Abi = Self;
2743 type DefaultType = Self;
2744 }
2745 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2746 #[repr(C)]
2747 pub struct DHCP_IPV6_ADDRESS {
2748 pub HighOrderBits: u64,
2749 pub LowOrderBits: u64,
2750 }
2751 impl DHCP_IPV6_ADDRESS {}
2752 impl ::std::default::Default for DHCP_IPV6_ADDRESS {
default() -> Self2753 fn default() -> Self {
2754 unsafe { ::std::mem::zeroed() }
2755 }
2756 }
2757 impl ::std::fmt::Debug for DHCP_IPV6_ADDRESS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2758 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2759 fmt.debug_struct("DHCP_IPV6_ADDRESS").field("HighOrderBits", &self.HighOrderBits).field("LowOrderBits", &self.LowOrderBits).finish()
2760 }
2761 }
2762 impl ::std::cmp::PartialEq for DHCP_IPV6_ADDRESS {
eq(&self, other: &Self) -> bool2763 fn eq(&self, other: &Self) -> bool {
2764 self.HighOrderBits == other.HighOrderBits && self.LowOrderBits == other.LowOrderBits
2765 }
2766 }
2767 impl ::std::cmp::Eq for DHCP_IPV6_ADDRESS {}
2768 unsafe impl ::windows::runtime::Abi for DHCP_IPV6_ADDRESS {
2769 type Abi = Self;
2770 type DefaultType = Self;
2771 }
2772 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2773 #[repr(C)]
2774 pub struct DHCP_IP_ARRAY {
2775 pub NumElements: u32,
2776 pub Elements: *mut u32,
2777 }
2778 impl DHCP_IP_ARRAY {}
2779 impl ::std::default::Default for DHCP_IP_ARRAY {
default() -> Self2780 fn default() -> Self {
2781 unsafe { ::std::mem::zeroed() }
2782 }
2783 }
2784 impl ::std::fmt::Debug for DHCP_IP_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2785 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2786 fmt.debug_struct("DHCP_IP_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
2787 }
2788 }
2789 impl ::std::cmp::PartialEq for DHCP_IP_ARRAY {
eq(&self, other: &Self) -> bool2790 fn eq(&self, other: &Self) -> bool {
2791 self.NumElements == other.NumElements && self.Elements == other.Elements
2792 }
2793 }
2794 impl ::std::cmp::Eq for DHCP_IP_ARRAY {}
2795 unsafe impl ::windows::runtime::Abi for DHCP_IP_ARRAY {
2796 type Abi = Self;
2797 type DefaultType = Self;
2798 }
2799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2800 #[repr(C)]
2801 pub struct DHCP_IP_CLUSTER {
2802 pub ClusterAddress: u32,
2803 pub ClusterMask: u32,
2804 }
2805 impl DHCP_IP_CLUSTER {}
2806 impl ::std::default::Default for DHCP_IP_CLUSTER {
default() -> Self2807 fn default() -> Self {
2808 unsafe { ::std::mem::zeroed() }
2809 }
2810 }
2811 impl ::std::fmt::Debug for DHCP_IP_CLUSTER {
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("DHCP_IP_CLUSTER").field("ClusterAddress", &self.ClusterAddress).field("ClusterMask", &self.ClusterMask).finish()
2814 }
2815 }
2816 impl ::std::cmp::PartialEq for DHCP_IP_CLUSTER {
eq(&self, other: &Self) -> bool2817 fn eq(&self, other: &Self) -> bool {
2818 self.ClusterAddress == other.ClusterAddress && self.ClusterMask == other.ClusterMask
2819 }
2820 }
2821 impl ::std::cmp::Eq for DHCP_IP_CLUSTER {}
2822 unsafe impl ::windows::runtime::Abi for DHCP_IP_CLUSTER {
2823 type Abi = Self;
2824 type DefaultType = Self;
2825 }
2826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2827 #[repr(C)]
2828 pub struct DHCP_IP_RANGE {
2829 pub StartAddress: u32,
2830 pub EndAddress: u32,
2831 }
2832 impl DHCP_IP_RANGE {}
2833 impl ::std::default::Default for DHCP_IP_RANGE {
default() -> Self2834 fn default() -> Self {
2835 unsafe { ::std::mem::zeroed() }
2836 }
2837 }
2838 impl ::std::fmt::Debug for DHCP_IP_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2839 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2840 fmt.debug_struct("DHCP_IP_RANGE").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).finish()
2841 }
2842 }
2843 impl ::std::cmp::PartialEq for DHCP_IP_RANGE {
eq(&self, other: &Self) -> bool2844 fn eq(&self, other: &Self) -> bool {
2845 self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress
2846 }
2847 }
2848 impl ::std::cmp::Eq for DHCP_IP_RANGE {}
2849 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE {
2850 type Abi = Self;
2851 type DefaultType = Self;
2852 }
2853 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2854 #[repr(C)]
2855 pub struct DHCP_IP_RANGE_ARRAY {
2856 pub NumElements: u32,
2857 pub Elements: *mut DHCP_IP_RANGE,
2858 }
2859 impl DHCP_IP_RANGE_ARRAY {}
2860 impl ::std::default::Default for DHCP_IP_RANGE_ARRAY {
default() -> Self2861 fn default() -> Self {
2862 unsafe { ::std::mem::zeroed() }
2863 }
2864 }
2865 impl ::std::fmt::Debug for DHCP_IP_RANGE_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2866 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2867 fmt.debug_struct("DHCP_IP_RANGE_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
2868 }
2869 }
2870 impl ::std::cmp::PartialEq for DHCP_IP_RANGE_ARRAY {
eq(&self, other: &Self) -> bool2871 fn eq(&self, other: &Self) -> bool {
2872 self.NumElements == other.NumElements && self.Elements == other.Elements
2873 }
2874 }
2875 impl ::std::cmp::Eq for DHCP_IP_RANGE_ARRAY {}
2876 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE_ARRAY {
2877 type Abi = Self;
2878 type DefaultType = Self;
2879 }
2880 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2881 #[repr(C)]
2882 pub struct DHCP_IP_RANGE_V6 {
2883 pub StartAddress: DHCP_IPV6_ADDRESS,
2884 pub EndAddress: DHCP_IPV6_ADDRESS,
2885 }
2886 impl DHCP_IP_RANGE_V6 {}
2887 impl ::std::default::Default for DHCP_IP_RANGE_V6 {
default() -> Self2888 fn default() -> Self {
2889 unsafe { ::std::mem::zeroed() }
2890 }
2891 }
2892 impl ::std::fmt::Debug for DHCP_IP_RANGE_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2893 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2894 fmt.debug_struct("DHCP_IP_RANGE_V6").field("StartAddress", &self.StartAddress).field("EndAddress", &self.EndAddress).finish()
2895 }
2896 }
2897 impl ::std::cmp::PartialEq for DHCP_IP_RANGE_V6 {
eq(&self, other: &Self) -> bool2898 fn eq(&self, other: &Self) -> bool {
2899 self.StartAddress == other.StartAddress && self.EndAddress == other.EndAddress
2900 }
2901 }
2902 impl ::std::cmp::Eq for DHCP_IP_RANGE_V6 {}
2903 unsafe impl ::windows::runtime::Abi for DHCP_IP_RANGE_V6 {
2904 type Abi = Self;
2905 type DefaultType = Self;
2906 }
2907 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2908 #[repr(C)]
2909 pub struct DHCP_IP_RESERVATION {
2910 pub ReservedIpAddress: u32,
2911 pub ReservedForClient: *mut DHCP_BINARY_DATA,
2912 }
2913 impl DHCP_IP_RESERVATION {}
2914 impl ::std::default::Default for DHCP_IP_RESERVATION {
default() -> Self2915 fn default() -> Self {
2916 unsafe { ::std::mem::zeroed() }
2917 }
2918 }
2919 impl ::std::fmt::Debug for DHCP_IP_RESERVATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2920 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2921 fmt.debug_struct("DHCP_IP_RESERVATION").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).finish()
2922 }
2923 }
2924 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION {
eq(&self, other: &Self) -> bool2925 fn eq(&self, other: &Self) -> bool {
2926 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient
2927 }
2928 }
2929 impl ::std::cmp::Eq for DHCP_IP_RESERVATION {}
2930 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION {
2931 type Abi = Self;
2932 type DefaultType = Self;
2933 }
2934 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2935 #[repr(C)]
2936 #[cfg(feature = "Win32_Foundation")]
2937 pub struct DHCP_IP_RESERVATION_INFO {
2938 pub ReservedIpAddress: u32,
2939 pub ReservedForClient: DHCP_BINARY_DATA,
2940 pub ReservedClientName: super::super::Foundation::PWSTR,
2941 pub ReservedClientDesc: super::super::Foundation::PWSTR,
2942 pub bAllowedClientTypes: u8,
2943 pub fOptionsPresent: u8,
2944 }
2945 #[cfg(feature = "Win32_Foundation")]
2946 impl DHCP_IP_RESERVATION_INFO {}
2947 #[cfg(feature = "Win32_Foundation")]
2948 impl ::std::default::Default for DHCP_IP_RESERVATION_INFO {
default() -> Self2949 fn default() -> Self {
2950 unsafe { ::std::mem::zeroed() }
2951 }
2952 }
2953 #[cfg(feature = "Win32_Foundation")]
2954 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2955 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2956 fmt.debug_struct("DHCP_IP_RESERVATION_INFO")
2957 .field("ReservedIpAddress", &self.ReservedIpAddress)
2958 .field("ReservedForClient", &self.ReservedForClient)
2959 .field("ReservedClientName", &self.ReservedClientName)
2960 .field("ReservedClientDesc", &self.ReservedClientDesc)
2961 .field("bAllowedClientTypes", &self.bAllowedClientTypes)
2962 .field("fOptionsPresent", &self.fOptionsPresent)
2963 .finish()
2964 }
2965 }
2966 #[cfg(feature = "Win32_Foundation")]
2967 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_INFO {
eq(&self, other: &Self) -> bool2968 fn eq(&self, other: &Self) -> bool {
2969 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.ReservedClientName == other.ReservedClientName && self.ReservedClientDesc == other.ReservedClientDesc && self.bAllowedClientTypes == other.bAllowedClientTypes && self.fOptionsPresent == other.fOptionsPresent
2970 }
2971 }
2972 #[cfg(feature = "Win32_Foundation")]
2973 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_INFO {}
2974 #[cfg(feature = "Win32_Foundation")]
2975 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_INFO {
2976 type Abi = Self;
2977 type DefaultType = Self;
2978 }
2979 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2980 #[repr(C)]
2981 pub struct DHCP_IP_RESERVATION_V4 {
2982 pub ReservedIpAddress: u32,
2983 pub ReservedForClient: *mut DHCP_BINARY_DATA,
2984 pub bAllowedClientTypes: u8,
2985 }
2986 impl DHCP_IP_RESERVATION_V4 {}
2987 impl ::std::default::Default for DHCP_IP_RESERVATION_V4 {
default() -> Self2988 fn default() -> Self {
2989 unsafe { ::std::mem::zeroed() }
2990 }
2991 }
2992 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2993 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2994 fmt.debug_struct("DHCP_IP_RESERVATION_V4").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).field("bAllowedClientTypes", &self.bAllowedClientTypes).finish()
2995 }
2996 }
2997 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_V4 {
eq(&self, other: &Self) -> bool2998 fn eq(&self, other: &Self) -> bool {
2999 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.bAllowedClientTypes == other.bAllowedClientTypes
3000 }
3001 }
3002 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_V4 {}
3003 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_V4 {
3004 type Abi = Self;
3005 type DefaultType = Self;
3006 }
3007 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3008 #[repr(C)]
3009 pub struct DHCP_IP_RESERVATION_V6 {
3010 pub ReservedIpAddress: DHCP_IPV6_ADDRESS,
3011 pub ReservedForClient: *mut DHCP_BINARY_DATA,
3012 pub InterfaceId: u32,
3013 }
3014 impl DHCP_IP_RESERVATION_V6 {}
3015 impl ::std::default::Default for DHCP_IP_RESERVATION_V6 {
default() -> Self3016 fn default() -> Self {
3017 unsafe { ::std::mem::zeroed() }
3018 }
3019 }
3020 impl ::std::fmt::Debug for DHCP_IP_RESERVATION_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3021 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3022 fmt.debug_struct("DHCP_IP_RESERVATION_V6").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedForClient", &self.ReservedForClient).field("InterfaceId", &self.InterfaceId).finish()
3023 }
3024 }
3025 impl ::std::cmp::PartialEq for DHCP_IP_RESERVATION_V6 {
eq(&self, other: &Self) -> bool3026 fn eq(&self, other: &Self) -> bool {
3027 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedForClient == other.ReservedForClient && self.InterfaceId == other.InterfaceId
3028 }
3029 }
3030 impl ::std::cmp::Eq for DHCP_IP_RESERVATION_V6 {}
3031 unsafe impl ::windows::runtime::Abi for DHCP_IP_RESERVATION_V6 {
3032 type Abi = Self;
3033 type DefaultType = Self;
3034 }
3035 pub const DHCP_MAX_DELAY: u32 = 1000u32;
3036 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3037 #[repr(C)]
3038 pub struct DHCP_MIB_INFO {
3039 pub Discovers: u32,
3040 pub Offers: u32,
3041 pub Requests: u32,
3042 pub Acks: u32,
3043 pub Naks: u32,
3044 pub Declines: u32,
3045 pub Releases: u32,
3046 pub ServerStartTime: DATE_TIME,
3047 pub Scopes: u32,
3048 pub ScopeInfo: *mut SCOPE_MIB_INFO,
3049 }
3050 impl DHCP_MIB_INFO {}
3051 impl ::std::default::Default for DHCP_MIB_INFO {
default() -> Self3052 fn default() -> Self {
3053 unsafe { ::std::mem::zeroed() }
3054 }
3055 }
3056 impl ::std::fmt::Debug for DHCP_MIB_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3057 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3058 fmt.debug_struct("DHCP_MIB_INFO")
3059 .field("Discovers", &self.Discovers)
3060 .field("Offers", &self.Offers)
3061 .field("Requests", &self.Requests)
3062 .field("Acks", &self.Acks)
3063 .field("Naks", &self.Naks)
3064 .field("Declines", &self.Declines)
3065 .field("Releases", &self.Releases)
3066 .field("ServerStartTime", &self.ServerStartTime)
3067 .field("Scopes", &self.Scopes)
3068 .field("ScopeInfo", &self.ScopeInfo)
3069 .finish()
3070 }
3071 }
3072 impl ::std::cmp::PartialEq for DHCP_MIB_INFO {
eq(&self, other: &Self) -> bool3073 fn eq(&self, other: &Self) -> bool {
3074 self.Discovers == other.Discovers && self.Offers == other.Offers && self.Requests == other.Requests && self.Acks == other.Acks && self.Naks == other.Naks && self.Declines == other.Declines && self.Releases == other.Releases && self.ServerStartTime == other.ServerStartTime && self.Scopes == other.Scopes && self.ScopeInfo == other.ScopeInfo
3075 }
3076 }
3077 impl ::std::cmp::Eq for DHCP_MIB_INFO {}
3078 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO {
3079 type Abi = Self;
3080 type DefaultType = Self;
3081 }
3082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3083 #[repr(C)]
3084 pub struct DHCP_MIB_INFO_V5 {
3085 pub Discovers: u32,
3086 pub Offers: u32,
3087 pub Requests: u32,
3088 pub Acks: u32,
3089 pub Naks: u32,
3090 pub Declines: u32,
3091 pub Releases: u32,
3092 pub ServerStartTime: DATE_TIME,
3093 pub QtnNumLeases: u32,
3094 pub QtnPctQtnLeases: u32,
3095 pub QtnProbationLeases: u32,
3096 pub QtnNonQtnLeases: u32,
3097 pub QtnExemptLeases: u32,
3098 pub QtnCapableClients: u32,
3099 pub QtnIASErrors: u32,
3100 pub DelayedOffers: u32,
3101 pub ScopesWithDelayedOffers: u32,
3102 pub Scopes: u32,
3103 pub ScopeInfo: *mut SCOPE_MIB_INFO_V5,
3104 }
3105 impl DHCP_MIB_INFO_V5 {}
3106 impl ::std::default::Default for DHCP_MIB_INFO_V5 {
default() -> Self3107 fn default() -> Self {
3108 unsafe { ::std::mem::zeroed() }
3109 }
3110 }
3111 impl ::std::fmt::Debug for DHCP_MIB_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3112 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3113 fmt.debug_struct("DHCP_MIB_INFO_V5")
3114 .field("Discovers", &self.Discovers)
3115 .field("Offers", &self.Offers)
3116 .field("Requests", &self.Requests)
3117 .field("Acks", &self.Acks)
3118 .field("Naks", &self.Naks)
3119 .field("Declines", &self.Declines)
3120 .field("Releases", &self.Releases)
3121 .field("ServerStartTime", &self.ServerStartTime)
3122 .field("QtnNumLeases", &self.QtnNumLeases)
3123 .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
3124 .field("QtnProbationLeases", &self.QtnProbationLeases)
3125 .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
3126 .field("QtnExemptLeases", &self.QtnExemptLeases)
3127 .field("QtnCapableClients", &self.QtnCapableClients)
3128 .field("QtnIASErrors", &self.QtnIASErrors)
3129 .field("DelayedOffers", &self.DelayedOffers)
3130 .field("ScopesWithDelayedOffers", &self.ScopesWithDelayedOffers)
3131 .field("Scopes", &self.Scopes)
3132 .field("ScopeInfo", &self.ScopeInfo)
3133 .finish()
3134 }
3135 }
3136 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_V5 {
eq(&self, other: &Self) -> bool3137 fn eq(&self, other: &Self) -> bool {
3138 self.Discovers == other.Discovers
3139 && self.Offers == other.Offers
3140 && self.Requests == other.Requests
3141 && self.Acks == other.Acks
3142 && self.Naks == other.Naks
3143 && self.Declines == other.Declines
3144 && self.Releases == other.Releases
3145 && self.ServerStartTime == other.ServerStartTime
3146 && self.QtnNumLeases == other.QtnNumLeases
3147 && self.QtnPctQtnLeases == other.QtnPctQtnLeases
3148 && self.QtnProbationLeases == other.QtnProbationLeases
3149 && self.QtnNonQtnLeases == other.QtnNonQtnLeases
3150 && self.QtnExemptLeases == other.QtnExemptLeases
3151 && self.QtnCapableClients == other.QtnCapableClients
3152 && self.QtnIASErrors == other.QtnIASErrors
3153 && self.DelayedOffers == other.DelayedOffers
3154 && self.ScopesWithDelayedOffers == other.ScopesWithDelayedOffers
3155 && self.Scopes == other.Scopes
3156 && self.ScopeInfo == other.ScopeInfo
3157 }
3158 }
3159 impl ::std::cmp::Eq for DHCP_MIB_INFO_V5 {}
3160 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_V5 {
3161 type Abi = Self;
3162 type DefaultType = Self;
3163 }
3164 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3165 #[repr(C)]
3166 pub struct DHCP_MIB_INFO_V6 {
3167 pub Solicits: u32,
3168 pub Advertises: u32,
3169 pub Requests: u32,
3170 pub Renews: u32,
3171 pub Rebinds: u32,
3172 pub Replies: u32,
3173 pub Confirms: u32,
3174 pub Declines: u32,
3175 pub Releases: u32,
3176 pub Informs: u32,
3177 pub ServerStartTime: DATE_TIME,
3178 pub Scopes: u32,
3179 pub ScopeInfo: *mut SCOPE_MIB_INFO_V6,
3180 }
3181 impl DHCP_MIB_INFO_V6 {}
3182 impl ::std::default::Default for DHCP_MIB_INFO_V6 {
default() -> Self3183 fn default() -> Self {
3184 unsafe { ::std::mem::zeroed() }
3185 }
3186 }
3187 impl ::std::fmt::Debug for DHCP_MIB_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3188 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3189 fmt.debug_struct("DHCP_MIB_INFO_V6")
3190 .field("Solicits", &self.Solicits)
3191 .field("Advertises", &self.Advertises)
3192 .field("Requests", &self.Requests)
3193 .field("Renews", &self.Renews)
3194 .field("Rebinds", &self.Rebinds)
3195 .field("Replies", &self.Replies)
3196 .field("Confirms", &self.Confirms)
3197 .field("Declines", &self.Declines)
3198 .field("Releases", &self.Releases)
3199 .field("Informs", &self.Informs)
3200 .field("ServerStartTime", &self.ServerStartTime)
3201 .field("Scopes", &self.Scopes)
3202 .field("ScopeInfo", &self.ScopeInfo)
3203 .finish()
3204 }
3205 }
3206 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_V6 {
eq(&self, other: &Self) -> bool3207 fn eq(&self, other: &Self) -> bool {
3208 self.Solicits == other.Solicits && self.Advertises == other.Advertises && self.Requests == other.Requests && self.Renews == other.Renews && self.Rebinds == other.Rebinds && self.Replies == other.Replies && self.Confirms == other.Confirms && self.Declines == other.Declines && self.Releases == other.Releases && self.Informs == other.Informs && self.ServerStartTime == other.ServerStartTime && self.Scopes == other.Scopes && self.ScopeInfo == other.ScopeInfo
3209 }
3210 }
3211 impl ::std::cmp::Eq for DHCP_MIB_INFO_V6 {}
3212 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_V6 {
3213 type Abi = Self;
3214 type DefaultType = Self;
3215 }
3216 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3217 #[repr(C)]
3218 pub struct DHCP_MIB_INFO_VQ {
3219 pub Discovers: u32,
3220 pub Offers: u32,
3221 pub Requests: u32,
3222 pub Acks: u32,
3223 pub Naks: u32,
3224 pub Declines: u32,
3225 pub Releases: u32,
3226 pub ServerStartTime: DATE_TIME,
3227 pub QtnNumLeases: u32,
3228 pub QtnPctQtnLeases: u32,
3229 pub QtnProbationLeases: u32,
3230 pub QtnNonQtnLeases: u32,
3231 pub QtnExemptLeases: u32,
3232 pub QtnCapableClients: u32,
3233 pub QtnIASErrors: u32,
3234 pub Scopes: u32,
3235 pub ScopeInfo: *mut SCOPE_MIB_INFO_VQ,
3236 }
3237 impl DHCP_MIB_INFO_VQ {}
3238 impl ::std::default::Default for DHCP_MIB_INFO_VQ {
default() -> Self3239 fn default() -> Self {
3240 unsafe { ::std::mem::zeroed() }
3241 }
3242 }
3243 impl ::std::fmt::Debug for DHCP_MIB_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3244 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3245 fmt.debug_struct("DHCP_MIB_INFO_VQ")
3246 .field("Discovers", &self.Discovers)
3247 .field("Offers", &self.Offers)
3248 .field("Requests", &self.Requests)
3249 .field("Acks", &self.Acks)
3250 .field("Naks", &self.Naks)
3251 .field("Declines", &self.Declines)
3252 .field("Releases", &self.Releases)
3253 .field("ServerStartTime", &self.ServerStartTime)
3254 .field("QtnNumLeases", &self.QtnNumLeases)
3255 .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
3256 .field("QtnProbationLeases", &self.QtnProbationLeases)
3257 .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
3258 .field("QtnExemptLeases", &self.QtnExemptLeases)
3259 .field("QtnCapableClients", &self.QtnCapableClients)
3260 .field("QtnIASErrors", &self.QtnIASErrors)
3261 .field("Scopes", &self.Scopes)
3262 .field("ScopeInfo", &self.ScopeInfo)
3263 .finish()
3264 }
3265 }
3266 impl ::std::cmp::PartialEq for DHCP_MIB_INFO_VQ {
eq(&self, other: &Self) -> bool3267 fn eq(&self, other: &Self) -> bool {
3268 self.Discovers == other.Discovers
3269 && self.Offers == other.Offers
3270 && self.Requests == other.Requests
3271 && self.Acks == other.Acks
3272 && self.Naks == other.Naks
3273 && self.Declines == other.Declines
3274 && self.Releases == other.Releases
3275 && self.ServerStartTime == other.ServerStartTime
3276 && self.QtnNumLeases == other.QtnNumLeases
3277 && self.QtnPctQtnLeases == other.QtnPctQtnLeases
3278 && self.QtnProbationLeases == other.QtnProbationLeases
3279 && self.QtnNonQtnLeases == other.QtnNonQtnLeases
3280 && self.QtnExemptLeases == other.QtnExemptLeases
3281 && self.QtnCapableClients == other.QtnCapableClients
3282 && self.QtnIASErrors == other.QtnIASErrors
3283 && self.Scopes == other.Scopes
3284 && self.ScopeInfo == other.ScopeInfo
3285 }
3286 }
3287 impl ::std::cmp::Eq for DHCP_MIB_INFO_VQ {}
3288 unsafe impl ::windows::runtime::Abi for DHCP_MIB_INFO_VQ {
3289 type Abi = Self;
3290 type DefaultType = Self;
3291 }
3292 pub const DHCP_MIN_DELAY: u32 = 0u32;
3293 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3294 #[repr(C)]
3295 #[cfg(feature = "Win32_Foundation")]
3296 pub struct DHCP_OPTION {
3297 pub OptionID: u32,
3298 pub OptionName: super::super::Foundation::PWSTR,
3299 pub OptionComment: super::super::Foundation::PWSTR,
3300 pub DefaultValue: DHCP_OPTION_DATA,
3301 pub OptionType: DHCP_OPTION_TYPE,
3302 }
3303 #[cfg(feature = "Win32_Foundation")]
3304 impl DHCP_OPTION {}
3305 #[cfg(feature = "Win32_Foundation")]
3306 impl ::std::default::Default for DHCP_OPTION {
default() -> Self3307 fn default() -> Self {
3308 unsafe { ::std::mem::zeroed() }
3309 }
3310 }
3311 #[cfg(feature = "Win32_Foundation")]
3312 impl ::std::fmt::Debug for DHCP_OPTION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3313 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3314 fmt.debug_struct("DHCP_OPTION").field("OptionID", &self.OptionID).field("OptionName", &self.OptionName).field("OptionComment", &self.OptionComment).field("DefaultValue", &self.DefaultValue).field("OptionType", &self.OptionType).finish()
3315 }
3316 }
3317 #[cfg(feature = "Win32_Foundation")]
3318 impl ::std::cmp::PartialEq for DHCP_OPTION {
eq(&self, other: &Self) -> bool3319 fn eq(&self, other: &Self) -> bool {
3320 self.OptionID == other.OptionID && self.OptionName == other.OptionName && self.OptionComment == other.OptionComment && self.DefaultValue == other.DefaultValue && self.OptionType == other.OptionType
3321 }
3322 }
3323 #[cfg(feature = "Win32_Foundation")]
3324 impl ::std::cmp::Eq for DHCP_OPTION {}
3325 #[cfg(feature = "Win32_Foundation")]
3326 unsafe impl ::windows::runtime::Abi for DHCP_OPTION {
3327 type Abi = Self;
3328 type DefaultType = Self;
3329 }
3330 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3331 #[repr(C)]
3332 #[cfg(feature = "Win32_Foundation")]
3333 pub struct DHCP_OPTION_ARRAY {
3334 pub NumElements: u32,
3335 pub Options: *mut DHCP_OPTION,
3336 }
3337 #[cfg(feature = "Win32_Foundation")]
3338 impl DHCP_OPTION_ARRAY {}
3339 #[cfg(feature = "Win32_Foundation")]
3340 impl ::std::default::Default for DHCP_OPTION_ARRAY {
default() -> Self3341 fn default() -> Self {
3342 unsafe { ::std::mem::zeroed() }
3343 }
3344 }
3345 #[cfg(feature = "Win32_Foundation")]
3346 impl ::std::fmt::Debug for DHCP_OPTION_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3347 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3348 fmt.debug_struct("DHCP_OPTION_ARRAY").field("NumElements", &self.NumElements).field("Options", &self.Options).finish()
3349 }
3350 }
3351 #[cfg(feature = "Win32_Foundation")]
3352 impl ::std::cmp::PartialEq for DHCP_OPTION_ARRAY {
eq(&self, other: &Self) -> bool3353 fn eq(&self, other: &Self) -> bool {
3354 self.NumElements == other.NumElements && self.Options == other.Options
3355 }
3356 }
3357 #[cfg(feature = "Win32_Foundation")]
3358 impl ::std::cmp::Eq for DHCP_OPTION_ARRAY {}
3359 #[cfg(feature = "Win32_Foundation")]
3360 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_ARRAY {
3361 type Abi = Self;
3362 type DefaultType = Self;
3363 }
3364 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3365 #[repr(C)]
3366 #[cfg(feature = "Win32_Foundation")]
3367 pub struct DHCP_OPTION_DATA {
3368 pub NumElements: u32,
3369 pub Elements: *mut DHCP_OPTION_DATA_ELEMENT,
3370 }
3371 #[cfg(feature = "Win32_Foundation")]
3372 impl DHCP_OPTION_DATA {}
3373 #[cfg(feature = "Win32_Foundation")]
3374 impl ::std::default::Default for DHCP_OPTION_DATA {
default() -> Self3375 fn default() -> Self {
3376 unsafe { ::std::mem::zeroed() }
3377 }
3378 }
3379 #[cfg(feature = "Win32_Foundation")]
3380 impl ::std::fmt::Debug for DHCP_OPTION_DATA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3381 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3382 fmt.debug_struct("DHCP_OPTION_DATA").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3383 }
3384 }
3385 #[cfg(feature = "Win32_Foundation")]
3386 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA {
eq(&self, other: &Self) -> bool3387 fn eq(&self, other: &Self) -> bool {
3388 self.NumElements == other.NumElements && self.Elements == other.Elements
3389 }
3390 }
3391 #[cfg(feature = "Win32_Foundation")]
3392 impl ::std::cmp::Eq for DHCP_OPTION_DATA {}
3393 #[cfg(feature = "Win32_Foundation")]
3394 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA {
3395 type Abi = Self;
3396 type DefaultType = Self;
3397 }
3398 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3399 #[repr(C)]
3400 #[cfg(feature = "Win32_Foundation")]
3401 pub struct DHCP_OPTION_DATA_ELEMENT {
3402 pub OptionType: DHCP_OPTION_DATA_TYPE,
3403 pub Element: DHCP_OPTION_DATA_ELEMENT_0,
3404 }
3405 #[cfg(feature = "Win32_Foundation")]
3406 impl DHCP_OPTION_DATA_ELEMENT {}
3407 #[cfg(feature = "Win32_Foundation")]
3408 impl ::std::default::Default for DHCP_OPTION_DATA_ELEMENT {
default() -> Self3409 fn default() -> Self {
3410 unsafe { ::std::mem::zeroed() }
3411 }
3412 }
3413 #[cfg(feature = "Win32_Foundation")]
3414 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA_ELEMENT {
eq(&self, _other: &Self) -> bool3415 fn eq(&self, _other: &Self) -> bool {
3416 unimplemented!()
3417 }
3418 }
3419 #[cfg(feature = "Win32_Foundation")]
3420 impl ::std::cmp::Eq for DHCP_OPTION_DATA_ELEMENT {}
3421 #[cfg(feature = "Win32_Foundation")]
3422 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_ELEMENT {
3423 type Abi = Self;
3424 type DefaultType = Self;
3425 }
3426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3427 #[repr(C)]
3428 #[cfg(feature = "Win32_Foundation")]
3429 pub union DHCP_OPTION_DATA_ELEMENT_0 {
3430 pub ByteOption: u8,
3431 pub WordOption: u16,
3432 pub DWordOption: u32,
3433 pub DWordDWordOption: DWORD_DWORD,
3434 pub IpAddressOption: u32,
3435 pub StringDataOption: super::super::Foundation::PWSTR,
3436 pub BinaryDataOption: DHCP_BINARY_DATA,
3437 pub EncapsulatedDataOption: DHCP_BINARY_DATA,
3438 pub Ipv6AddressDataOption: super::super::Foundation::PWSTR,
3439 }
3440 #[cfg(feature = "Win32_Foundation")]
3441 impl DHCP_OPTION_DATA_ELEMENT_0 {}
3442 #[cfg(feature = "Win32_Foundation")]
3443 impl ::std::default::Default for DHCP_OPTION_DATA_ELEMENT_0 {
default() -> Self3444 fn default() -> Self {
3445 unsafe { ::std::mem::zeroed() }
3446 }
3447 }
3448 #[cfg(feature = "Win32_Foundation")]
3449 impl ::std::cmp::PartialEq for DHCP_OPTION_DATA_ELEMENT_0 {
eq(&self, _other: &Self) -> bool3450 fn eq(&self, _other: &Self) -> bool {
3451 unimplemented!()
3452 }
3453 }
3454 #[cfg(feature = "Win32_Foundation")]
3455 impl ::std::cmp::Eq for DHCP_OPTION_DATA_ELEMENT_0 {}
3456 #[cfg(feature = "Win32_Foundation")]
3457 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_ELEMENT_0 {
3458 type Abi = Self;
3459 type DefaultType = Self;
3460 }
3461 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3462 #[repr(transparent)]
3463 pub struct DHCP_OPTION_DATA_TYPE(pub i32);
3464 pub const DhcpByteOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(0i32);
3465 pub const DhcpWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(1i32);
3466 pub const DhcpDWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(2i32);
3467 pub const DhcpDWordDWordOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(3i32);
3468 pub const DhcpIpAddressOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(4i32);
3469 pub const DhcpStringDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(5i32);
3470 pub const DhcpBinaryDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(6i32);
3471 pub const DhcpEncapsulatedDataOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(7i32);
3472 pub const DhcpIpv6AddressOption: DHCP_OPTION_DATA_TYPE = DHCP_OPTION_DATA_TYPE(8i32);
3473 impl ::std::convert::From<i32> for DHCP_OPTION_DATA_TYPE {
from(value: i32) -> Self3474 fn from(value: i32) -> Self {
3475 Self(value)
3476 }
3477 }
3478 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_DATA_TYPE {
3479 type Abi = Self;
3480 type DefaultType = Self;
3481 }
3482 #[repr(C)]
3483 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
3484 pub struct DHCP_OPTION_ELEMENT_UNION(pub u8);
3485 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3486 #[repr(C)]
3487 #[cfg(feature = "Win32_Foundation")]
3488 pub struct DHCP_OPTION_LIST {
3489 pub NumOptions: u32,
3490 pub Options: *mut DHCP_OPTION_VALUE,
3491 }
3492 #[cfg(feature = "Win32_Foundation")]
3493 impl DHCP_OPTION_LIST {}
3494 #[cfg(feature = "Win32_Foundation")]
3495 impl ::std::default::Default for DHCP_OPTION_LIST {
default() -> Self3496 fn default() -> Self {
3497 unsafe { ::std::mem::zeroed() }
3498 }
3499 }
3500 #[cfg(feature = "Win32_Foundation")]
3501 impl ::std::fmt::Debug for DHCP_OPTION_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3502 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3503 fmt.debug_struct("DHCP_OPTION_LIST").field("NumOptions", &self.NumOptions).field("Options", &self.Options).finish()
3504 }
3505 }
3506 #[cfg(feature = "Win32_Foundation")]
3507 impl ::std::cmp::PartialEq for DHCP_OPTION_LIST {
eq(&self, other: &Self) -> bool3508 fn eq(&self, other: &Self) -> bool {
3509 self.NumOptions == other.NumOptions && self.Options == other.Options
3510 }
3511 }
3512 #[cfg(feature = "Win32_Foundation")]
3513 impl ::std::cmp::Eq for DHCP_OPTION_LIST {}
3514 #[cfg(feature = "Win32_Foundation")]
3515 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_LIST {
3516 type Abi = Self;
3517 type DefaultType = Self;
3518 }
3519 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3520 #[repr(C)]
3521 #[cfg(feature = "Win32_Foundation")]
3522 pub struct DHCP_OPTION_SCOPE_INFO {
3523 pub ScopeType: DHCP_OPTION_SCOPE_TYPE,
3524 pub ScopeInfo: DHCP_OPTION_SCOPE_INFO_0,
3525 }
3526 #[cfg(feature = "Win32_Foundation")]
3527 impl DHCP_OPTION_SCOPE_INFO {}
3528 #[cfg(feature = "Win32_Foundation")]
3529 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO {
default() -> Self3530 fn default() -> Self {
3531 unsafe { ::std::mem::zeroed() }
3532 }
3533 }
3534 #[cfg(feature = "Win32_Foundation")]
3535 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO {
eq(&self, _other: &Self) -> bool3536 fn eq(&self, _other: &Self) -> bool {
3537 unimplemented!()
3538 }
3539 }
3540 #[cfg(feature = "Win32_Foundation")]
3541 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO {}
3542 #[cfg(feature = "Win32_Foundation")]
3543 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO {
3544 type Abi = Self;
3545 type DefaultType = Self;
3546 }
3547 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3548 #[repr(C)]
3549 #[cfg(feature = "Win32_Foundation")]
3550 pub union DHCP_OPTION_SCOPE_INFO_0 {
3551 pub DefaultScopeInfo: *mut ::std::ffi::c_void,
3552 pub GlobalScopeInfo: *mut ::std::ffi::c_void,
3553 pub SubnetScopeInfo: u32,
3554 pub ReservedScopeInfo: DHCP_RESERVED_SCOPE,
3555 pub MScopeInfo: super::super::Foundation::PWSTR,
3556 }
3557 #[cfg(feature = "Win32_Foundation")]
3558 impl DHCP_OPTION_SCOPE_INFO_0 {}
3559 #[cfg(feature = "Win32_Foundation")]
3560 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO_0 {
default() -> Self3561 fn default() -> Self {
3562 unsafe { ::std::mem::zeroed() }
3563 }
3564 }
3565 #[cfg(feature = "Win32_Foundation")]
3566 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO_0 {
eq(&self, _other: &Self) -> bool3567 fn eq(&self, _other: &Self) -> bool {
3568 unimplemented!()
3569 }
3570 }
3571 #[cfg(feature = "Win32_Foundation")]
3572 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO_0 {}
3573 #[cfg(feature = "Win32_Foundation")]
3574 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO_0 {
3575 type Abi = Self;
3576 type DefaultType = Self;
3577 }
3578 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3579 #[repr(C)]
3580 pub struct DHCP_OPTION_SCOPE_INFO6 {
3581 pub ScopeType: DHCP_OPTION_SCOPE_TYPE6,
3582 pub ScopeInfo: DHCP_OPTION_SCOPE_INFO6_0,
3583 }
3584 impl DHCP_OPTION_SCOPE_INFO6 {}
3585 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO6 {
default() -> Self3586 fn default() -> Self {
3587 unsafe { ::std::mem::zeroed() }
3588 }
3589 }
3590 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO6 {
eq(&self, _other: &Self) -> bool3591 fn eq(&self, _other: &Self) -> bool {
3592 unimplemented!()
3593 }
3594 }
3595 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO6 {}
3596 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO6 {
3597 type Abi = Self;
3598 type DefaultType = Self;
3599 }
3600 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3601 #[repr(C)]
3602 pub union DHCP_OPTION_SCOPE_INFO6_0 {
3603 pub DefaultScopeInfo: *mut ::std::ffi::c_void,
3604 pub SubnetScopeInfo: DHCP_IPV6_ADDRESS,
3605 pub ReservedScopeInfo: DHCP_RESERVED_SCOPE6,
3606 }
3607 impl DHCP_OPTION_SCOPE_INFO6_0 {}
3608 impl ::std::default::Default for DHCP_OPTION_SCOPE_INFO6_0 {
default() -> Self3609 fn default() -> Self {
3610 unsafe { ::std::mem::zeroed() }
3611 }
3612 }
3613 impl ::std::cmp::PartialEq for DHCP_OPTION_SCOPE_INFO6_0 {
eq(&self, _other: &Self) -> bool3614 fn eq(&self, _other: &Self) -> bool {
3615 unimplemented!()
3616 }
3617 }
3618 impl ::std::cmp::Eq for DHCP_OPTION_SCOPE_INFO6_0 {}
3619 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_INFO6_0 {
3620 type Abi = Self;
3621 type DefaultType = Self;
3622 }
3623 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3624 #[repr(transparent)]
3625 pub struct DHCP_OPTION_SCOPE_TYPE(pub i32);
3626 pub const DhcpDefaultOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(0i32);
3627 pub const DhcpGlobalOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(1i32);
3628 pub const DhcpSubnetOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(2i32);
3629 pub const DhcpReservedOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(3i32);
3630 pub const DhcpMScopeOptions: DHCP_OPTION_SCOPE_TYPE = DHCP_OPTION_SCOPE_TYPE(4i32);
3631 impl ::std::convert::From<i32> for DHCP_OPTION_SCOPE_TYPE {
from(value: i32) -> Self3632 fn from(value: i32) -> Self {
3633 Self(value)
3634 }
3635 }
3636 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_TYPE {
3637 type Abi = Self;
3638 type DefaultType = Self;
3639 }
3640 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3641 #[repr(transparent)]
3642 pub struct DHCP_OPTION_SCOPE_TYPE6(pub i32);
3643 pub const DhcpDefaultOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(0i32);
3644 pub const DhcpScopeOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(1i32);
3645 pub const DhcpReservedOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(2i32);
3646 pub const DhcpGlobalOptions6: DHCP_OPTION_SCOPE_TYPE6 = DHCP_OPTION_SCOPE_TYPE6(3i32);
3647 impl ::std::convert::From<i32> for DHCP_OPTION_SCOPE_TYPE6 {
from(value: i32) -> Self3648 fn from(value: i32) -> Self {
3649 Self(value)
3650 }
3651 }
3652 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_SCOPE_TYPE6 {
3653 type Abi = Self;
3654 type DefaultType = Self;
3655 }
3656 #[repr(C)]
3657 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
3658 pub struct DHCP_OPTION_SCOPE_UNION6(pub u8);
3659 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3660 #[repr(transparent)]
3661 pub struct DHCP_OPTION_TYPE(pub i32);
3662 pub const DhcpUnaryElementTypeOption: DHCP_OPTION_TYPE = DHCP_OPTION_TYPE(0i32);
3663 pub const DhcpArrayTypeOption: DHCP_OPTION_TYPE = DHCP_OPTION_TYPE(1i32);
3664 impl ::std::convert::From<i32> for DHCP_OPTION_TYPE {
from(value: i32) -> Self3665 fn from(value: i32) -> Self {
3666 Self(value)
3667 }
3668 }
3669 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_TYPE {
3670 type Abi = Self;
3671 type DefaultType = Self;
3672 }
3673 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3674 #[repr(C)]
3675 #[cfg(feature = "Win32_Foundation")]
3676 pub struct DHCP_OPTION_VALUE {
3677 pub OptionID: u32,
3678 pub Value: DHCP_OPTION_DATA,
3679 }
3680 #[cfg(feature = "Win32_Foundation")]
3681 impl DHCP_OPTION_VALUE {}
3682 #[cfg(feature = "Win32_Foundation")]
3683 impl ::std::default::Default for DHCP_OPTION_VALUE {
default() -> Self3684 fn default() -> Self {
3685 unsafe { ::std::mem::zeroed() }
3686 }
3687 }
3688 #[cfg(feature = "Win32_Foundation")]
3689 impl ::std::fmt::Debug for DHCP_OPTION_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3690 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3691 fmt.debug_struct("DHCP_OPTION_VALUE").field("OptionID", &self.OptionID).field("Value", &self.Value).finish()
3692 }
3693 }
3694 #[cfg(feature = "Win32_Foundation")]
3695 impl ::std::cmp::PartialEq for DHCP_OPTION_VALUE {
eq(&self, other: &Self) -> bool3696 fn eq(&self, other: &Self) -> bool {
3697 self.OptionID == other.OptionID && self.Value == other.Value
3698 }
3699 }
3700 #[cfg(feature = "Win32_Foundation")]
3701 impl ::std::cmp::Eq for DHCP_OPTION_VALUE {}
3702 #[cfg(feature = "Win32_Foundation")]
3703 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_VALUE {
3704 type Abi = Self;
3705 type DefaultType = Self;
3706 }
3707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3708 #[repr(C)]
3709 #[cfg(feature = "Win32_Foundation")]
3710 pub struct DHCP_OPTION_VALUE_ARRAY {
3711 pub NumElements: u32,
3712 pub Values: *mut DHCP_OPTION_VALUE,
3713 }
3714 #[cfg(feature = "Win32_Foundation")]
3715 impl DHCP_OPTION_VALUE_ARRAY {}
3716 #[cfg(feature = "Win32_Foundation")]
3717 impl ::std::default::Default for DHCP_OPTION_VALUE_ARRAY {
default() -> Self3718 fn default() -> Self {
3719 unsafe { ::std::mem::zeroed() }
3720 }
3721 }
3722 #[cfg(feature = "Win32_Foundation")]
3723 impl ::std::fmt::Debug for DHCP_OPTION_VALUE_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3724 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3725 fmt.debug_struct("DHCP_OPTION_VALUE_ARRAY").field("NumElements", &self.NumElements).field("Values", &self.Values).finish()
3726 }
3727 }
3728 #[cfg(feature = "Win32_Foundation")]
3729 impl ::std::cmp::PartialEq for DHCP_OPTION_VALUE_ARRAY {
eq(&self, other: &Self) -> bool3730 fn eq(&self, other: &Self) -> bool {
3731 self.NumElements == other.NumElements && self.Values == other.Values
3732 }
3733 }
3734 #[cfg(feature = "Win32_Foundation")]
3735 impl ::std::cmp::Eq for DHCP_OPTION_VALUE_ARRAY {}
3736 #[cfg(feature = "Win32_Foundation")]
3737 unsafe impl ::windows::runtime::Abi for DHCP_OPTION_VALUE_ARRAY {
3738 type Abi = Self;
3739 type DefaultType = Self;
3740 }
3741 pub const DHCP_OPT_ENUM_IGNORE_VENDOR: u32 = 1u32;
3742 pub const DHCP_OPT_ENUM_USE_CLASSNAME: u32 = 2u32;
3743 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3744 #[repr(C)]
3745 pub struct DHCP_PERF_STATS {
3746 pub dwNumPacketsReceived: u32,
3747 pub dwNumPacketsDuplicate: u32,
3748 pub dwNumPacketsExpired: u32,
3749 pub dwNumMilliSecondsProcessed: u32,
3750 pub dwNumPacketsInActiveQueue: u32,
3751 pub dwNumPacketsInPingQueue: u32,
3752 pub dwNumDiscoversReceived: u32,
3753 pub dwNumOffersSent: u32,
3754 pub dwNumRequestsReceived: u32,
3755 pub dwNumInformsReceived: u32,
3756 pub dwNumAcksSent: u32,
3757 pub dwNumNacksSent: u32,
3758 pub dwNumDeclinesReceived: u32,
3759 pub dwNumReleasesReceived: u32,
3760 pub dwNumDelayedOfferInQueue: u32,
3761 pub dwNumPacketsProcessed: u32,
3762 pub dwNumPacketsInQuarWaitingQueue: u32,
3763 pub dwNumPacketsInQuarReadyQueue: u32,
3764 pub dwNumPacketsInQuarDecisionQueue: u32,
3765 }
3766 impl DHCP_PERF_STATS {}
3767 impl ::std::default::Default for DHCP_PERF_STATS {
default() -> Self3768 fn default() -> Self {
3769 unsafe { ::std::mem::zeroed() }
3770 }
3771 }
3772 impl ::std::fmt::Debug for DHCP_PERF_STATS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3773 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3774 fmt.debug_struct("DHCP_PERF_STATS")
3775 .field("dwNumPacketsReceived", &self.dwNumPacketsReceived)
3776 .field("dwNumPacketsDuplicate", &self.dwNumPacketsDuplicate)
3777 .field("dwNumPacketsExpired", &self.dwNumPacketsExpired)
3778 .field("dwNumMilliSecondsProcessed", &self.dwNumMilliSecondsProcessed)
3779 .field("dwNumPacketsInActiveQueue", &self.dwNumPacketsInActiveQueue)
3780 .field("dwNumPacketsInPingQueue", &self.dwNumPacketsInPingQueue)
3781 .field("dwNumDiscoversReceived", &self.dwNumDiscoversReceived)
3782 .field("dwNumOffersSent", &self.dwNumOffersSent)
3783 .field("dwNumRequestsReceived", &self.dwNumRequestsReceived)
3784 .field("dwNumInformsReceived", &self.dwNumInformsReceived)
3785 .field("dwNumAcksSent", &self.dwNumAcksSent)
3786 .field("dwNumNacksSent", &self.dwNumNacksSent)
3787 .field("dwNumDeclinesReceived", &self.dwNumDeclinesReceived)
3788 .field("dwNumReleasesReceived", &self.dwNumReleasesReceived)
3789 .field("dwNumDelayedOfferInQueue", &self.dwNumDelayedOfferInQueue)
3790 .field("dwNumPacketsProcessed", &self.dwNumPacketsProcessed)
3791 .field("dwNumPacketsInQuarWaitingQueue", &self.dwNumPacketsInQuarWaitingQueue)
3792 .field("dwNumPacketsInQuarReadyQueue", &self.dwNumPacketsInQuarReadyQueue)
3793 .field("dwNumPacketsInQuarDecisionQueue", &self.dwNumPacketsInQuarDecisionQueue)
3794 .finish()
3795 }
3796 }
3797 impl ::std::cmp::PartialEq for DHCP_PERF_STATS {
eq(&self, other: &Self) -> bool3798 fn eq(&self, other: &Self) -> bool {
3799 self.dwNumPacketsReceived == other.dwNumPacketsReceived
3800 && self.dwNumPacketsDuplicate == other.dwNumPacketsDuplicate
3801 && self.dwNumPacketsExpired == other.dwNumPacketsExpired
3802 && self.dwNumMilliSecondsProcessed == other.dwNumMilliSecondsProcessed
3803 && self.dwNumPacketsInActiveQueue == other.dwNumPacketsInActiveQueue
3804 && self.dwNumPacketsInPingQueue == other.dwNumPacketsInPingQueue
3805 && self.dwNumDiscoversReceived == other.dwNumDiscoversReceived
3806 && self.dwNumOffersSent == other.dwNumOffersSent
3807 && self.dwNumRequestsReceived == other.dwNumRequestsReceived
3808 && self.dwNumInformsReceived == other.dwNumInformsReceived
3809 && self.dwNumAcksSent == other.dwNumAcksSent
3810 && self.dwNumNacksSent == other.dwNumNacksSent
3811 && self.dwNumDeclinesReceived == other.dwNumDeclinesReceived
3812 && self.dwNumReleasesReceived == other.dwNumReleasesReceived
3813 && self.dwNumDelayedOfferInQueue == other.dwNumDelayedOfferInQueue
3814 && self.dwNumPacketsProcessed == other.dwNumPacketsProcessed
3815 && self.dwNumPacketsInQuarWaitingQueue == other.dwNumPacketsInQuarWaitingQueue
3816 && self.dwNumPacketsInQuarReadyQueue == other.dwNumPacketsInQuarReadyQueue
3817 && self.dwNumPacketsInQuarDecisionQueue == other.dwNumPacketsInQuarDecisionQueue
3818 }
3819 }
3820 impl ::std::cmp::Eq for DHCP_PERF_STATS {}
3821 unsafe impl ::windows::runtime::Abi for DHCP_PERF_STATS {
3822 type Abi = Self;
3823 type DefaultType = Self;
3824 }
3825 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3826 #[repr(C)]
3827 #[cfg(feature = "Win32_Foundation")]
3828 pub struct DHCP_POLICY {
3829 pub PolicyName: super::super::Foundation::PWSTR,
3830 pub IsGlobalPolicy: super::super::Foundation::BOOL,
3831 pub Subnet: u32,
3832 pub ProcessingOrder: u32,
3833 pub Conditions: *mut DHCP_POL_COND_ARRAY,
3834 pub Expressions: *mut DHCP_POL_EXPR_ARRAY,
3835 pub Ranges: *mut DHCP_IP_RANGE_ARRAY,
3836 pub Description: super::super::Foundation::PWSTR,
3837 pub Enabled: super::super::Foundation::BOOL,
3838 }
3839 #[cfg(feature = "Win32_Foundation")]
3840 impl DHCP_POLICY {}
3841 #[cfg(feature = "Win32_Foundation")]
3842 impl ::std::default::Default for DHCP_POLICY {
default() -> Self3843 fn default() -> Self {
3844 unsafe { ::std::mem::zeroed() }
3845 }
3846 }
3847 #[cfg(feature = "Win32_Foundation")]
3848 impl ::std::fmt::Debug for DHCP_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3849 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3850 fmt.debug_struct("DHCP_POLICY")
3851 .field("PolicyName", &self.PolicyName)
3852 .field("IsGlobalPolicy", &self.IsGlobalPolicy)
3853 .field("Subnet", &self.Subnet)
3854 .field("ProcessingOrder", &self.ProcessingOrder)
3855 .field("Conditions", &self.Conditions)
3856 .field("Expressions", &self.Expressions)
3857 .field("Ranges", &self.Ranges)
3858 .field("Description", &self.Description)
3859 .field("Enabled", &self.Enabled)
3860 .finish()
3861 }
3862 }
3863 #[cfg(feature = "Win32_Foundation")]
3864 impl ::std::cmp::PartialEq for DHCP_POLICY {
eq(&self, other: &Self) -> bool3865 fn eq(&self, other: &Self) -> bool {
3866 self.PolicyName == other.PolicyName && self.IsGlobalPolicy == other.IsGlobalPolicy && self.Subnet == other.Subnet && self.ProcessingOrder == other.ProcessingOrder && self.Conditions == other.Conditions && self.Expressions == other.Expressions && self.Ranges == other.Ranges && self.Description == other.Description && self.Enabled == other.Enabled
3867 }
3868 }
3869 #[cfg(feature = "Win32_Foundation")]
3870 impl ::std::cmp::Eq for DHCP_POLICY {}
3871 #[cfg(feature = "Win32_Foundation")]
3872 unsafe impl ::windows::runtime::Abi for DHCP_POLICY {
3873 type Abi = Self;
3874 type DefaultType = Self;
3875 }
3876 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3877 #[repr(C)]
3878 #[cfg(feature = "Win32_Foundation")]
3879 pub struct DHCP_POLICY_ARRAY {
3880 pub NumElements: u32,
3881 pub Elements: *mut DHCP_POLICY,
3882 }
3883 #[cfg(feature = "Win32_Foundation")]
3884 impl DHCP_POLICY_ARRAY {}
3885 #[cfg(feature = "Win32_Foundation")]
3886 impl ::std::default::Default for DHCP_POLICY_ARRAY {
default() -> Self3887 fn default() -> Self {
3888 unsafe { ::std::mem::zeroed() }
3889 }
3890 }
3891 #[cfg(feature = "Win32_Foundation")]
3892 impl ::std::fmt::Debug for DHCP_POLICY_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3893 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3894 fmt.debug_struct("DHCP_POLICY_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3895 }
3896 }
3897 #[cfg(feature = "Win32_Foundation")]
3898 impl ::std::cmp::PartialEq for DHCP_POLICY_ARRAY {
eq(&self, other: &Self) -> bool3899 fn eq(&self, other: &Self) -> bool {
3900 self.NumElements == other.NumElements && self.Elements == other.Elements
3901 }
3902 }
3903 #[cfg(feature = "Win32_Foundation")]
3904 impl ::std::cmp::Eq for DHCP_POLICY_ARRAY {}
3905 #[cfg(feature = "Win32_Foundation")]
3906 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_ARRAY {
3907 type Abi = Self;
3908 type DefaultType = Self;
3909 }
3910 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3911 #[repr(C)]
3912 #[cfg(feature = "Win32_Foundation")]
3913 pub struct DHCP_POLICY_EX {
3914 pub PolicyName: super::super::Foundation::PWSTR,
3915 pub IsGlobalPolicy: super::super::Foundation::BOOL,
3916 pub Subnet: u32,
3917 pub ProcessingOrder: u32,
3918 pub Conditions: *mut DHCP_POL_COND_ARRAY,
3919 pub Expressions: *mut DHCP_POL_EXPR_ARRAY,
3920 pub Ranges: *mut DHCP_IP_RANGE_ARRAY,
3921 pub Description: super::super::Foundation::PWSTR,
3922 pub Enabled: super::super::Foundation::BOOL,
3923 pub Properties: *mut DHCP_PROPERTY_ARRAY,
3924 }
3925 #[cfg(feature = "Win32_Foundation")]
3926 impl DHCP_POLICY_EX {}
3927 #[cfg(feature = "Win32_Foundation")]
3928 impl ::std::default::Default for DHCP_POLICY_EX {
default() -> Self3929 fn default() -> Self {
3930 unsafe { ::std::mem::zeroed() }
3931 }
3932 }
3933 #[cfg(feature = "Win32_Foundation")]
3934 impl ::std::fmt::Debug for DHCP_POLICY_EX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3935 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3936 fmt.debug_struct("DHCP_POLICY_EX")
3937 .field("PolicyName", &self.PolicyName)
3938 .field("IsGlobalPolicy", &self.IsGlobalPolicy)
3939 .field("Subnet", &self.Subnet)
3940 .field("ProcessingOrder", &self.ProcessingOrder)
3941 .field("Conditions", &self.Conditions)
3942 .field("Expressions", &self.Expressions)
3943 .field("Ranges", &self.Ranges)
3944 .field("Description", &self.Description)
3945 .field("Enabled", &self.Enabled)
3946 .field("Properties", &self.Properties)
3947 .finish()
3948 }
3949 }
3950 #[cfg(feature = "Win32_Foundation")]
3951 impl ::std::cmp::PartialEq for DHCP_POLICY_EX {
eq(&self, other: &Self) -> bool3952 fn eq(&self, other: &Self) -> bool {
3953 self.PolicyName == other.PolicyName && self.IsGlobalPolicy == other.IsGlobalPolicy && self.Subnet == other.Subnet && self.ProcessingOrder == other.ProcessingOrder && self.Conditions == other.Conditions && self.Expressions == other.Expressions && self.Ranges == other.Ranges && self.Description == other.Description && self.Enabled == other.Enabled && self.Properties == other.Properties
3954 }
3955 }
3956 #[cfg(feature = "Win32_Foundation")]
3957 impl ::std::cmp::Eq for DHCP_POLICY_EX {}
3958 #[cfg(feature = "Win32_Foundation")]
3959 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_EX {
3960 type Abi = Self;
3961 type DefaultType = Self;
3962 }
3963 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3964 #[repr(C)]
3965 #[cfg(feature = "Win32_Foundation")]
3966 pub struct DHCP_POLICY_EX_ARRAY {
3967 pub NumElements: u32,
3968 pub Elements: *mut DHCP_POLICY_EX,
3969 }
3970 #[cfg(feature = "Win32_Foundation")]
3971 impl DHCP_POLICY_EX_ARRAY {}
3972 #[cfg(feature = "Win32_Foundation")]
3973 impl ::std::default::Default for DHCP_POLICY_EX_ARRAY {
default() -> Self3974 fn default() -> Self {
3975 unsafe { ::std::mem::zeroed() }
3976 }
3977 }
3978 #[cfg(feature = "Win32_Foundation")]
3979 impl ::std::fmt::Debug for DHCP_POLICY_EX_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3980 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3981 fmt.debug_struct("DHCP_POLICY_EX_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
3982 }
3983 }
3984 #[cfg(feature = "Win32_Foundation")]
3985 impl ::std::cmp::PartialEq for DHCP_POLICY_EX_ARRAY {
eq(&self, other: &Self) -> bool3986 fn eq(&self, other: &Self) -> bool {
3987 self.NumElements == other.NumElements && self.Elements == other.Elements
3988 }
3989 }
3990 #[cfg(feature = "Win32_Foundation")]
3991 impl ::std::cmp::Eq for DHCP_POLICY_EX_ARRAY {}
3992 #[cfg(feature = "Win32_Foundation")]
3993 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_EX_ARRAY {
3994 type Abi = Self;
3995 type DefaultType = Self;
3996 }
3997 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3998 #[repr(transparent)]
3999 pub struct DHCP_POLICY_FIELDS_TO_UPDATE(pub i32);
4000 pub const DhcpUpdatePolicyName: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(1i32);
4001 pub const DhcpUpdatePolicyOrder: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(2i32);
4002 pub const DhcpUpdatePolicyExpr: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(4i32);
4003 pub const DhcpUpdatePolicyRanges: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(8i32);
4004 pub const DhcpUpdatePolicyDescr: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(16i32);
4005 pub const DhcpUpdatePolicyStatus: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(32i32);
4006 pub const DhcpUpdatePolicyDnsSuffix: DHCP_POLICY_FIELDS_TO_UPDATE = DHCP_POLICY_FIELDS_TO_UPDATE(64i32);
4007 impl ::std::convert::From<i32> for DHCP_POLICY_FIELDS_TO_UPDATE {
from(value: i32) -> Self4008 fn from(value: i32) -> Self {
4009 Self(value)
4010 }
4011 }
4012 unsafe impl ::windows::runtime::Abi for DHCP_POLICY_FIELDS_TO_UPDATE {
4013 type Abi = Self;
4014 type DefaultType = Self;
4015 }
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 DHCP_POL_ATTR_TYPE(pub i32);
4019 pub const DhcpAttrHWAddr: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(0i32);
4020 pub const DhcpAttrOption: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(1i32);
4021 pub const DhcpAttrSubOption: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(2i32);
4022 pub const DhcpAttrFqdn: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(3i32);
4023 pub const DhcpAttrFqdnSingleLabel: DHCP_POL_ATTR_TYPE = DHCP_POL_ATTR_TYPE(4i32);
4024 impl ::std::convert::From<i32> for DHCP_POL_ATTR_TYPE {
from(value: i32) -> Self4025 fn from(value: i32) -> Self {
4026 Self(value)
4027 }
4028 }
4029 unsafe impl ::windows::runtime::Abi for DHCP_POL_ATTR_TYPE {
4030 type Abi = Self;
4031 type DefaultType = Self;
4032 }
4033 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4034 #[repr(transparent)]
4035 pub struct DHCP_POL_COMPARATOR(pub i32);
4036 pub const DhcpCompEqual: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(0i32);
4037 pub const DhcpCompNotEqual: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(1i32);
4038 pub const DhcpCompBeginsWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(2i32);
4039 pub const DhcpCompNotBeginWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(3i32);
4040 pub const DhcpCompEndsWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(4i32);
4041 pub const DhcpCompNotEndWith: DHCP_POL_COMPARATOR = DHCP_POL_COMPARATOR(5i32);
4042 impl ::std::convert::From<i32> for DHCP_POL_COMPARATOR {
from(value: i32) -> Self4043 fn from(value: i32) -> Self {
4044 Self(value)
4045 }
4046 }
4047 unsafe impl ::windows::runtime::Abi for DHCP_POL_COMPARATOR {
4048 type Abi = Self;
4049 type DefaultType = Self;
4050 }
4051 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4052 #[repr(C)]
4053 #[cfg(feature = "Win32_Foundation")]
4054 pub struct DHCP_POL_COND {
4055 pub ParentExpr: u32,
4056 pub Type: DHCP_POL_ATTR_TYPE,
4057 pub OptionID: u32,
4058 pub SubOptionID: u32,
4059 pub VendorName: super::super::Foundation::PWSTR,
4060 pub Operator: DHCP_POL_COMPARATOR,
4061 pub Value: *mut u8,
4062 pub ValueLength: u32,
4063 }
4064 #[cfg(feature = "Win32_Foundation")]
4065 impl DHCP_POL_COND {}
4066 #[cfg(feature = "Win32_Foundation")]
4067 impl ::std::default::Default for DHCP_POL_COND {
default() -> Self4068 fn default() -> Self {
4069 unsafe { ::std::mem::zeroed() }
4070 }
4071 }
4072 #[cfg(feature = "Win32_Foundation")]
4073 impl ::std::fmt::Debug for DHCP_POL_COND {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4074 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4075 fmt.debug_struct("DHCP_POL_COND")
4076 .field("ParentExpr", &self.ParentExpr)
4077 .field("Type", &self.Type)
4078 .field("OptionID", &self.OptionID)
4079 .field("SubOptionID", &self.SubOptionID)
4080 .field("VendorName", &self.VendorName)
4081 .field("Operator", &self.Operator)
4082 .field("Value", &self.Value)
4083 .field("ValueLength", &self.ValueLength)
4084 .finish()
4085 }
4086 }
4087 #[cfg(feature = "Win32_Foundation")]
4088 impl ::std::cmp::PartialEq for DHCP_POL_COND {
eq(&self, other: &Self) -> bool4089 fn eq(&self, other: &Self) -> bool {
4090 self.ParentExpr == other.ParentExpr && self.Type == other.Type && self.OptionID == other.OptionID && self.SubOptionID == other.SubOptionID && self.VendorName == other.VendorName && self.Operator == other.Operator && self.Value == other.Value && self.ValueLength == other.ValueLength
4091 }
4092 }
4093 #[cfg(feature = "Win32_Foundation")]
4094 impl ::std::cmp::Eq for DHCP_POL_COND {}
4095 #[cfg(feature = "Win32_Foundation")]
4096 unsafe impl ::windows::runtime::Abi for DHCP_POL_COND {
4097 type Abi = Self;
4098 type DefaultType = Self;
4099 }
4100 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4101 #[repr(C)]
4102 #[cfg(feature = "Win32_Foundation")]
4103 pub struct DHCP_POL_COND_ARRAY {
4104 pub NumElements: u32,
4105 pub Elements: *mut DHCP_POL_COND,
4106 }
4107 #[cfg(feature = "Win32_Foundation")]
4108 impl DHCP_POL_COND_ARRAY {}
4109 #[cfg(feature = "Win32_Foundation")]
4110 impl ::std::default::Default for DHCP_POL_COND_ARRAY {
default() -> Self4111 fn default() -> Self {
4112 unsafe { ::std::mem::zeroed() }
4113 }
4114 }
4115 #[cfg(feature = "Win32_Foundation")]
4116 impl ::std::fmt::Debug for DHCP_POL_COND_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4117 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4118 fmt.debug_struct("DHCP_POL_COND_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4119 }
4120 }
4121 #[cfg(feature = "Win32_Foundation")]
4122 impl ::std::cmp::PartialEq for DHCP_POL_COND_ARRAY {
eq(&self, other: &Self) -> bool4123 fn eq(&self, other: &Self) -> bool {
4124 self.NumElements == other.NumElements && self.Elements == other.Elements
4125 }
4126 }
4127 #[cfg(feature = "Win32_Foundation")]
4128 impl ::std::cmp::Eq for DHCP_POL_COND_ARRAY {}
4129 #[cfg(feature = "Win32_Foundation")]
4130 unsafe impl ::windows::runtime::Abi for DHCP_POL_COND_ARRAY {
4131 type Abi = Self;
4132 type DefaultType = Self;
4133 }
4134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4135 #[repr(C)]
4136 pub struct DHCP_POL_EXPR {
4137 pub ParentExpr: u32,
4138 pub Operator: DHCP_POL_LOGIC_OPER,
4139 }
4140 impl DHCP_POL_EXPR {}
4141 impl ::std::default::Default for DHCP_POL_EXPR {
default() -> Self4142 fn default() -> Self {
4143 unsafe { ::std::mem::zeroed() }
4144 }
4145 }
4146 impl ::std::fmt::Debug for DHCP_POL_EXPR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4147 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4148 fmt.debug_struct("DHCP_POL_EXPR").field("ParentExpr", &self.ParentExpr).field("Operator", &self.Operator).finish()
4149 }
4150 }
4151 impl ::std::cmp::PartialEq for DHCP_POL_EXPR {
eq(&self, other: &Self) -> bool4152 fn eq(&self, other: &Self) -> bool {
4153 self.ParentExpr == other.ParentExpr && self.Operator == other.Operator
4154 }
4155 }
4156 impl ::std::cmp::Eq for DHCP_POL_EXPR {}
4157 unsafe impl ::windows::runtime::Abi for DHCP_POL_EXPR {
4158 type Abi = Self;
4159 type DefaultType = Self;
4160 }
4161 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4162 #[repr(C)]
4163 pub struct DHCP_POL_EXPR_ARRAY {
4164 pub NumElements: u32,
4165 pub Elements: *mut DHCP_POL_EXPR,
4166 }
4167 impl DHCP_POL_EXPR_ARRAY {}
4168 impl ::std::default::Default for DHCP_POL_EXPR_ARRAY {
default() -> Self4169 fn default() -> Self {
4170 unsafe { ::std::mem::zeroed() }
4171 }
4172 }
4173 impl ::std::fmt::Debug for DHCP_POL_EXPR_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4174 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4175 fmt.debug_struct("DHCP_POL_EXPR_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4176 }
4177 }
4178 impl ::std::cmp::PartialEq for DHCP_POL_EXPR_ARRAY {
eq(&self, other: &Self) -> bool4179 fn eq(&self, other: &Self) -> bool {
4180 self.NumElements == other.NumElements && self.Elements == other.Elements
4181 }
4182 }
4183 impl ::std::cmp::Eq for DHCP_POL_EXPR_ARRAY {}
4184 unsafe impl ::windows::runtime::Abi for DHCP_POL_EXPR_ARRAY {
4185 type Abi = Self;
4186 type DefaultType = Self;
4187 }
4188 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4189 #[repr(transparent)]
4190 pub struct DHCP_POL_LOGIC_OPER(pub i32);
4191 pub const DhcpLogicalOr: DHCP_POL_LOGIC_OPER = DHCP_POL_LOGIC_OPER(0i32);
4192 pub const DhcpLogicalAnd: DHCP_POL_LOGIC_OPER = DHCP_POL_LOGIC_OPER(1i32);
4193 impl ::std::convert::From<i32> for DHCP_POL_LOGIC_OPER {
from(value: i32) -> Self4194 fn from(value: i32) -> Self {
4195 Self(value)
4196 }
4197 }
4198 unsafe impl ::windows::runtime::Abi for DHCP_POL_LOGIC_OPER {
4199 type Abi = Self;
4200 type DefaultType = Self;
4201 }
4202 pub const DHCP_PROB_CONFLICT: u32 = 536870913u32;
4203 pub const DHCP_PROB_DECLINE: u32 = 536870914u32;
4204 pub const DHCP_PROB_NACKED: u32 = 536870916u32;
4205 pub const DHCP_PROB_RELEASE: u32 = 536870915u32;
4206 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4207 #[repr(C)]
4208 #[cfg(feature = "Win32_Foundation")]
4209 pub struct DHCP_PROPERTY {
4210 pub ID: DHCP_PROPERTY_ID,
4211 pub Type: DHCP_PROPERTY_TYPE,
4212 pub Value: DHCP_PROPERTY_0,
4213 }
4214 #[cfg(feature = "Win32_Foundation")]
4215 impl DHCP_PROPERTY {}
4216 #[cfg(feature = "Win32_Foundation")]
4217 impl ::std::default::Default for DHCP_PROPERTY {
default() -> Self4218 fn default() -> Self {
4219 unsafe { ::std::mem::zeroed() }
4220 }
4221 }
4222 #[cfg(feature = "Win32_Foundation")]
4223 impl ::std::cmp::PartialEq for DHCP_PROPERTY {
eq(&self, _other: &Self) -> bool4224 fn eq(&self, _other: &Self) -> bool {
4225 unimplemented!()
4226 }
4227 }
4228 #[cfg(feature = "Win32_Foundation")]
4229 impl ::std::cmp::Eq for DHCP_PROPERTY {}
4230 #[cfg(feature = "Win32_Foundation")]
4231 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY {
4232 type Abi = Self;
4233 type DefaultType = Self;
4234 }
4235 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4236 #[repr(C)]
4237 #[cfg(feature = "Win32_Foundation")]
4238 pub union DHCP_PROPERTY_0 {
4239 pub ByteValue: u8,
4240 pub WordValue: u16,
4241 pub DWordValue: u32,
4242 pub StringValue: super::super::Foundation::PWSTR,
4243 pub BinaryValue: DHCP_BINARY_DATA,
4244 }
4245 #[cfg(feature = "Win32_Foundation")]
4246 impl DHCP_PROPERTY_0 {}
4247 #[cfg(feature = "Win32_Foundation")]
4248 impl ::std::default::Default for DHCP_PROPERTY_0 {
default() -> Self4249 fn default() -> Self {
4250 unsafe { ::std::mem::zeroed() }
4251 }
4252 }
4253 #[cfg(feature = "Win32_Foundation")]
4254 impl ::std::cmp::PartialEq for DHCP_PROPERTY_0 {
eq(&self, _other: &Self) -> bool4255 fn eq(&self, _other: &Self) -> bool {
4256 unimplemented!()
4257 }
4258 }
4259 #[cfg(feature = "Win32_Foundation")]
4260 impl ::std::cmp::Eq for DHCP_PROPERTY_0 {}
4261 #[cfg(feature = "Win32_Foundation")]
4262 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_0 {
4263 type Abi = Self;
4264 type DefaultType = Self;
4265 }
4266 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4267 #[repr(C)]
4268 #[cfg(feature = "Win32_Foundation")]
4269 pub struct DHCP_PROPERTY_ARRAY {
4270 pub NumElements: u32,
4271 pub Elements: *mut DHCP_PROPERTY,
4272 }
4273 #[cfg(feature = "Win32_Foundation")]
4274 impl DHCP_PROPERTY_ARRAY {}
4275 #[cfg(feature = "Win32_Foundation")]
4276 impl ::std::default::Default for DHCP_PROPERTY_ARRAY {
default() -> Self4277 fn default() -> Self {
4278 unsafe { ::std::mem::zeroed() }
4279 }
4280 }
4281 #[cfg(feature = "Win32_Foundation")]
4282 impl ::std::fmt::Debug for DHCP_PROPERTY_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4283 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4284 fmt.debug_struct("DHCP_PROPERTY_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4285 }
4286 }
4287 #[cfg(feature = "Win32_Foundation")]
4288 impl ::std::cmp::PartialEq for DHCP_PROPERTY_ARRAY {
eq(&self, other: &Self) -> bool4289 fn eq(&self, other: &Self) -> bool {
4290 self.NumElements == other.NumElements && self.Elements == other.Elements
4291 }
4292 }
4293 #[cfg(feature = "Win32_Foundation")]
4294 impl ::std::cmp::Eq for DHCP_PROPERTY_ARRAY {}
4295 #[cfg(feature = "Win32_Foundation")]
4296 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_ARRAY {
4297 type Abi = Self;
4298 type DefaultType = Self;
4299 }
4300 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4301 #[repr(transparent)]
4302 pub struct DHCP_PROPERTY_ID(pub i32);
4303 pub const DhcpPropIdPolicyDnsSuffix: DHCP_PROPERTY_ID = DHCP_PROPERTY_ID(0i32);
4304 pub const DhcpPropIdClientAddressStateEx: DHCP_PROPERTY_ID = DHCP_PROPERTY_ID(1i32);
4305 impl ::std::convert::From<i32> for DHCP_PROPERTY_ID {
from(value: i32) -> Self4306 fn from(value: i32) -> Self {
4307 Self(value)
4308 }
4309 }
4310 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_ID {
4311 type Abi = Self;
4312 type DefaultType = Self;
4313 }
4314 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4315 #[repr(transparent)]
4316 pub struct DHCP_PROPERTY_TYPE(pub i32);
4317 pub const DhcpPropTypeByte: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(0i32);
4318 pub const DhcpPropTypeWord: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(1i32);
4319 pub const DhcpPropTypeDword: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(2i32);
4320 pub const DhcpPropTypeString: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(3i32);
4321 pub const DhcpPropTypeBinary: DHCP_PROPERTY_TYPE = DHCP_PROPERTY_TYPE(4i32);
4322 impl ::std::convert::From<i32> for DHCP_PROPERTY_TYPE {
from(value: i32) -> Self4323 fn from(value: i32) -> Self {
4324 Self(value)
4325 }
4326 }
4327 unsafe impl ::windows::runtime::Abi for DHCP_PROPERTY_TYPE {
4328 type Abi = Self;
4329 type DefaultType = Self;
4330 }
4331 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4332 #[repr(C)]
4333 #[cfg(feature = "Win32_Foundation")]
4334 pub struct DHCP_RESERVATION_INFO_ARRAY {
4335 pub NumElements: u32,
4336 pub Elements: *mut *mut DHCP_IP_RESERVATION_INFO,
4337 }
4338 #[cfg(feature = "Win32_Foundation")]
4339 impl DHCP_RESERVATION_INFO_ARRAY {}
4340 #[cfg(feature = "Win32_Foundation")]
4341 impl ::std::default::Default for DHCP_RESERVATION_INFO_ARRAY {
default() -> Self4342 fn default() -> Self {
4343 unsafe { ::std::mem::zeroed() }
4344 }
4345 }
4346 #[cfg(feature = "Win32_Foundation")]
4347 impl ::std::fmt::Debug for DHCP_RESERVATION_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4348 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4349 fmt.debug_struct("DHCP_RESERVATION_INFO_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
4350 }
4351 }
4352 #[cfg(feature = "Win32_Foundation")]
4353 impl ::std::cmp::PartialEq for DHCP_RESERVATION_INFO_ARRAY {
eq(&self, other: &Self) -> bool4354 fn eq(&self, other: &Self) -> bool {
4355 self.NumElements == other.NumElements && self.Elements == other.Elements
4356 }
4357 }
4358 #[cfg(feature = "Win32_Foundation")]
4359 impl ::std::cmp::Eq for DHCP_RESERVATION_INFO_ARRAY {}
4360 #[cfg(feature = "Win32_Foundation")]
4361 unsafe impl ::windows::runtime::Abi for DHCP_RESERVATION_INFO_ARRAY {
4362 type Abi = Self;
4363 type DefaultType = Self;
4364 }
4365 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4366 #[repr(C)]
4367 pub struct DHCP_RESERVED_SCOPE {
4368 pub ReservedIpAddress: u32,
4369 pub ReservedIpSubnetAddress: u32,
4370 }
4371 impl DHCP_RESERVED_SCOPE {}
4372 impl ::std::default::Default for DHCP_RESERVED_SCOPE {
default() -> Self4373 fn default() -> Self {
4374 unsafe { ::std::mem::zeroed() }
4375 }
4376 }
4377 impl ::std::fmt::Debug for DHCP_RESERVED_SCOPE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4378 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4379 fmt.debug_struct("DHCP_RESERVED_SCOPE").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedIpSubnetAddress", &self.ReservedIpSubnetAddress).finish()
4380 }
4381 }
4382 impl ::std::cmp::PartialEq for DHCP_RESERVED_SCOPE {
eq(&self, other: &Self) -> bool4383 fn eq(&self, other: &Self) -> bool {
4384 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedIpSubnetAddress == other.ReservedIpSubnetAddress
4385 }
4386 }
4387 impl ::std::cmp::Eq for DHCP_RESERVED_SCOPE {}
4388 unsafe impl ::windows::runtime::Abi for DHCP_RESERVED_SCOPE {
4389 type Abi = Self;
4390 type DefaultType = Self;
4391 }
4392 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4393 #[repr(C)]
4394 pub struct DHCP_RESERVED_SCOPE6 {
4395 pub ReservedIpAddress: DHCP_IPV6_ADDRESS,
4396 pub ReservedIpSubnetAddress: DHCP_IPV6_ADDRESS,
4397 }
4398 impl DHCP_RESERVED_SCOPE6 {}
4399 impl ::std::default::Default for DHCP_RESERVED_SCOPE6 {
default() -> Self4400 fn default() -> Self {
4401 unsafe { ::std::mem::zeroed() }
4402 }
4403 }
4404 impl ::std::fmt::Debug for DHCP_RESERVED_SCOPE6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4405 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4406 fmt.debug_struct("DHCP_RESERVED_SCOPE6").field("ReservedIpAddress", &self.ReservedIpAddress).field("ReservedIpSubnetAddress", &self.ReservedIpSubnetAddress).finish()
4407 }
4408 }
4409 impl ::std::cmp::PartialEq for DHCP_RESERVED_SCOPE6 {
eq(&self, other: &Self) -> bool4410 fn eq(&self, other: &Self) -> bool {
4411 self.ReservedIpAddress == other.ReservedIpAddress && self.ReservedIpSubnetAddress == other.ReservedIpSubnetAddress
4412 }
4413 }
4414 impl ::std::cmp::Eq for DHCP_RESERVED_SCOPE6 {}
4415 unsafe impl ::windows::runtime::Abi for DHCP_RESERVED_SCOPE6 {
4416 type Abi = Self;
4417 type DefaultType = Self;
4418 }
4419 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4420 #[repr(transparent)]
4421 pub struct DHCP_SCAN_FLAG(pub i32);
4422 pub const DhcpRegistryFix: DHCP_SCAN_FLAG = DHCP_SCAN_FLAG(0i32);
4423 pub const DhcpDatabaseFix: DHCP_SCAN_FLAG = DHCP_SCAN_FLAG(1i32);
4424 impl ::std::convert::From<i32> for DHCP_SCAN_FLAG {
from(value: i32) -> Self4425 fn from(value: i32) -> Self {
4426 Self(value)
4427 }
4428 }
4429 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_FLAG {
4430 type Abi = Self;
4431 type DefaultType = Self;
4432 }
4433 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4434 #[repr(C)]
4435 pub struct DHCP_SCAN_ITEM {
4436 pub IpAddress: u32,
4437 pub ScanFlag: DHCP_SCAN_FLAG,
4438 }
4439 impl DHCP_SCAN_ITEM {}
4440 impl ::std::default::Default for DHCP_SCAN_ITEM {
default() -> Self4441 fn default() -> Self {
4442 unsafe { ::std::mem::zeroed() }
4443 }
4444 }
4445 impl ::std::fmt::Debug for DHCP_SCAN_ITEM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4446 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4447 fmt.debug_struct("DHCP_SCAN_ITEM").field("IpAddress", &self.IpAddress).field("ScanFlag", &self.ScanFlag).finish()
4448 }
4449 }
4450 impl ::std::cmp::PartialEq for DHCP_SCAN_ITEM {
eq(&self, other: &Self) -> bool4451 fn eq(&self, other: &Self) -> bool {
4452 self.IpAddress == other.IpAddress && self.ScanFlag == other.ScanFlag
4453 }
4454 }
4455 impl ::std::cmp::Eq for DHCP_SCAN_ITEM {}
4456 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_ITEM {
4457 type Abi = Self;
4458 type DefaultType = Self;
4459 }
4460 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4461 #[repr(C)]
4462 pub struct DHCP_SCAN_LIST {
4463 pub NumScanItems: u32,
4464 pub ScanItems: *mut DHCP_SCAN_ITEM,
4465 }
4466 impl DHCP_SCAN_LIST {}
4467 impl ::std::default::Default for DHCP_SCAN_LIST {
default() -> Self4468 fn default() -> Self {
4469 unsafe { ::std::mem::zeroed() }
4470 }
4471 }
4472 impl ::std::fmt::Debug for DHCP_SCAN_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4473 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4474 fmt.debug_struct("DHCP_SCAN_LIST").field("NumScanItems", &self.NumScanItems).field("ScanItems", &self.ScanItems).finish()
4475 }
4476 }
4477 impl ::std::cmp::PartialEq for DHCP_SCAN_LIST {
eq(&self, other: &Self) -> bool4478 fn eq(&self, other: &Self) -> bool {
4479 self.NumScanItems == other.NumScanItems && self.ScanItems == other.ScanItems
4480 }
4481 }
4482 impl ::std::cmp::Eq for DHCP_SCAN_LIST {}
4483 unsafe impl ::windows::runtime::Abi for DHCP_SCAN_LIST {
4484 type Abi = Self;
4485 type DefaultType = Self;
4486 }
4487 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4488 #[repr(C)]
4489 #[cfg(feature = "Win32_Foundation")]
4490 pub struct DHCP_SEARCH_INFO {
4491 pub SearchType: DHCP_SEARCH_INFO_TYPE,
4492 pub SearchInfo: DHCP_SEARCH_INFO_0,
4493 }
4494 #[cfg(feature = "Win32_Foundation")]
4495 impl DHCP_SEARCH_INFO {}
4496 #[cfg(feature = "Win32_Foundation")]
4497 impl ::std::default::Default for DHCP_SEARCH_INFO {
default() -> Self4498 fn default() -> Self {
4499 unsafe { ::std::mem::zeroed() }
4500 }
4501 }
4502 #[cfg(feature = "Win32_Foundation")]
4503 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO {
eq(&self, _other: &Self) -> bool4504 fn eq(&self, _other: &Self) -> bool {
4505 unimplemented!()
4506 }
4507 }
4508 #[cfg(feature = "Win32_Foundation")]
4509 impl ::std::cmp::Eq for DHCP_SEARCH_INFO {}
4510 #[cfg(feature = "Win32_Foundation")]
4511 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO {
4512 type Abi = Self;
4513 type DefaultType = Self;
4514 }
4515 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4516 #[repr(C)]
4517 #[cfg(feature = "Win32_Foundation")]
4518 pub union DHCP_SEARCH_INFO_0 {
4519 pub ClientIpAddress: u32,
4520 pub ClientHardwareAddress: DHCP_BINARY_DATA,
4521 pub ClientName: super::super::Foundation::PWSTR,
4522 }
4523 #[cfg(feature = "Win32_Foundation")]
4524 impl DHCP_SEARCH_INFO_0 {}
4525 #[cfg(feature = "Win32_Foundation")]
4526 impl ::std::default::Default for DHCP_SEARCH_INFO_0 {
default() -> Self4527 fn default() -> Self {
4528 unsafe { ::std::mem::zeroed() }
4529 }
4530 }
4531 #[cfg(feature = "Win32_Foundation")]
4532 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_0 {
eq(&self, _other: &Self) -> bool4533 fn eq(&self, _other: &Self) -> bool {
4534 unimplemented!()
4535 }
4536 }
4537 #[cfg(feature = "Win32_Foundation")]
4538 impl ::std::cmp::Eq for DHCP_SEARCH_INFO_0 {}
4539 #[cfg(feature = "Win32_Foundation")]
4540 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_0 {
4541 type Abi = Self;
4542 type DefaultType = Self;
4543 }
4544 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4545 #[repr(transparent)]
4546 pub struct DHCP_SEARCH_INFO_TYPE(pub i32);
4547 pub const DhcpClientIpAddress: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(0i32);
4548 pub const DhcpClientHardwareAddress: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(1i32);
4549 pub const DhcpClientName: DHCP_SEARCH_INFO_TYPE = DHCP_SEARCH_INFO_TYPE(2i32);
4550 impl ::std::convert::From<i32> for DHCP_SEARCH_INFO_TYPE {
from(value: i32) -> Self4551 fn from(value: i32) -> Self {
4552 Self(value)
4553 }
4554 }
4555 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_TYPE {
4556 type Abi = Self;
4557 type DefaultType = Self;
4558 }
4559 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4560 #[repr(transparent)]
4561 pub struct DHCP_SEARCH_INFO_TYPE_V6(pub i32);
4562 pub const Dhcpv6ClientIpAddress: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(0i32);
4563 pub const Dhcpv6ClientDUID: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(1i32);
4564 pub const Dhcpv6ClientName: DHCP_SEARCH_INFO_TYPE_V6 = DHCP_SEARCH_INFO_TYPE_V6(2i32);
4565 impl ::std::convert::From<i32> for DHCP_SEARCH_INFO_TYPE_V6 {
from(value: i32) -> Self4566 fn from(value: i32) -> Self {
4567 Self(value)
4568 }
4569 }
4570 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_TYPE_V6 {
4571 type Abi = Self;
4572 type DefaultType = Self;
4573 }
4574 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4575 #[repr(C)]
4576 #[cfg(feature = "Win32_Foundation")]
4577 pub struct DHCP_SEARCH_INFO_V6 {
4578 pub SearchType: DHCP_SEARCH_INFO_TYPE_V6,
4579 pub SearchInfo: DHCP_SEARCH_INFO_V6_0,
4580 }
4581 #[cfg(feature = "Win32_Foundation")]
4582 impl DHCP_SEARCH_INFO_V6 {}
4583 #[cfg(feature = "Win32_Foundation")]
4584 impl ::std::default::Default for DHCP_SEARCH_INFO_V6 {
default() -> Self4585 fn default() -> Self {
4586 unsafe { ::std::mem::zeroed() }
4587 }
4588 }
4589 #[cfg(feature = "Win32_Foundation")]
4590 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_V6 {
eq(&self, _other: &Self) -> bool4591 fn eq(&self, _other: &Self) -> bool {
4592 unimplemented!()
4593 }
4594 }
4595 #[cfg(feature = "Win32_Foundation")]
4596 impl ::std::cmp::Eq for DHCP_SEARCH_INFO_V6 {}
4597 #[cfg(feature = "Win32_Foundation")]
4598 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_V6 {
4599 type Abi = Self;
4600 type DefaultType = Self;
4601 }
4602 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4603 #[repr(C)]
4604 #[cfg(feature = "Win32_Foundation")]
4605 pub union DHCP_SEARCH_INFO_V6_0 {
4606 pub ClientIpAddress: DHCP_IPV6_ADDRESS,
4607 pub ClientDUID: DHCP_BINARY_DATA,
4608 pub ClientName: super::super::Foundation::PWSTR,
4609 }
4610 #[cfg(feature = "Win32_Foundation")]
4611 impl DHCP_SEARCH_INFO_V6_0 {}
4612 #[cfg(feature = "Win32_Foundation")]
4613 impl ::std::default::Default for DHCP_SEARCH_INFO_V6_0 {
default() -> Self4614 fn default() -> Self {
4615 unsafe { ::std::mem::zeroed() }
4616 }
4617 }
4618 #[cfg(feature = "Win32_Foundation")]
4619 impl ::std::cmp::PartialEq for DHCP_SEARCH_INFO_V6_0 {
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 DHCP_SEARCH_INFO_V6_0 {}
4626 #[cfg(feature = "Win32_Foundation")]
4627 unsafe impl ::windows::runtime::Abi for DHCP_SEARCH_INFO_V6_0 {
4628 type Abi = Self;
4629 type DefaultType = Self;
4630 }
4631 pub const DHCP_SEND_PACKET: u32 = 268435456u32;
4632 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4633 #[repr(C)]
4634 #[cfg(feature = "Win32_Foundation")]
4635 pub struct DHCP_SERVER_CONFIG_INFO {
4636 pub APIProtocolSupport: u32,
4637 pub DatabaseName: super::super::Foundation::PWSTR,
4638 pub DatabasePath: super::super::Foundation::PWSTR,
4639 pub BackupPath: super::super::Foundation::PWSTR,
4640 pub BackupInterval: u32,
4641 pub DatabaseLoggingFlag: u32,
4642 pub RestoreFlag: u32,
4643 pub DatabaseCleanupInterval: u32,
4644 pub DebugFlag: u32,
4645 }
4646 #[cfg(feature = "Win32_Foundation")]
4647 impl DHCP_SERVER_CONFIG_INFO {}
4648 #[cfg(feature = "Win32_Foundation")]
4649 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO {
default() -> Self4650 fn default() -> Self {
4651 unsafe { ::std::mem::zeroed() }
4652 }
4653 }
4654 #[cfg(feature = "Win32_Foundation")]
4655 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4656 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4657 fmt.debug_struct("DHCP_SERVER_CONFIG_INFO")
4658 .field("APIProtocolSupport", &self.APIProtocolSupport)
4659 .field("DatabaseName", &self.DatabaseName)
4660 .field("DatabasePath", &self.DatabasePath)
4661 .field("BackupPath", &self.BackupPath)
4662 .field("BackupInterval", &self.BackupInterval)
4663 .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4664 .field("RestoreFlag", &self.RestoreFlag)
4665 .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4666 .field("DebugFlag", &self.DebugFlag)
4667 .finish()
4668 }
4669 }
4670 #[cfg(feature = "Win32_Foundation")]
4671 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO {
eq(&self, other: &Self) -> bool4672 fn eq(&self, other: &Self) -> bool {
4673 self.APIProtocolSupport == other.APIProtocolSupport && self.DatabaseName == other.DatabaseName && self.DatabasePath == other.DatabasePath && self.BackupPath == other.BackupPath && self.BackupInterval == other.BackupInterval && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag && self.RestoreFlag == other.RestoreFlag && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval && self.DebugFlag == other.DebugFlag
4674 }
4675 }
4676 #[cfg(feature = "Win32_Foundation")]
4677 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO {}
4678 #[cfg(feature = "Win32_Foundation")]
4679 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO {
4680 type Abi = Self;
4681 type DefaultType = Self;
4682 }
4683 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4684 #[repr(C)]
4685 #[cfg(feature = "Win32_Foundation")]
4686 pub struct DHCP_SERVER_CONFIG_INFO_V4 {
4687 pub APIProtocolSupport: u32,
4688 pub DatabaseName: super::super::Foundation::PWSTR,
4689 pub DatabasePath: super::super::Foundation::PWSTR,
4690 pub BackupPath: super::super::Foundation::PWSTR,
4691 pub BackupInterval: u32,
4692 pub DatabaseLoggingFlag: u32,
4693 pub RestoreFlag: u32,
4694 pub DatabaseCleanupInterval: u32,
4695 pub DebugFlag: u32,
4696 pub dwPingRetries: u32,
4697 pub cbBootTableString: u32,
4698 pub wszBootTableString: super::super::Foundation::PWSTR,
4699 pub fAuditLog: super::super::Foundation::BOOL,
4700 }
4701 #[cfg(feature = "Win32_Foundation")]
4702 impl DHCP_SERVER_CONFIG_INFO_V4 {}
4703 #[cfg(feature = "Win32_Foundation")]
4704 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_V4 {
default() -> Self4705 fn default() -> Self {
4706 unsafe { ::std::mem::zeroed() }
4707 }
4708 }
4709 #[cfg(feature = "Win32_Foundation")]
4710 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_V4 {
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("DHCP_SERVER_CONFIG_INFO_V4")
4713 .field("APIProtocolSupport", &self.APIProtocolSupport)
4714 .field("DatabaseName", &self.DatabaseName)
4715 .field("DatabasePath", &self.DatabasePath)
4716 .field("BackupPath", &self.BackupPath)
4717 .field("BackupInterval", &self.BackupInterval)
4718 .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4719 .field("RestoreFlag", &self.RestoreFlag)
4720 .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4721 .field("DebugFlag", &self.DebugFlag)
4722 .field("dwPingRetries", &self.dwPingRetries)
4723 .field("cbBootTableString", &self.cbBootTableString)
4724 .field("wszBootTableString", &self.wszBootTableString)
4725 .field("fAuditLog", &self.fAuditLog)
4726 .finish()
4727 }
4728 }
4729 #[cfg(feature = "Win32_Foundation")]
4730 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_V4 {
eq(&self, other: &Self) -> bool4731 fn eq(&self, other: &Self) -> bool {
4732 self.APIProtocolSupport == other.APIProtocolSupport
4733 && self.DatabaseName == other.DatabaseName
4734 && self.DatabasePath == other.DatabasePath
4735 && self.BackupPath == other.BackupPath
4736 && self.BackupInterval == other.BackupInterval
4737 && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag
4738 && self.RestoreFlag == other.RestoreFlag
4739 && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval
4740 && self.DebugFlag == other.DebugFlag
4741 && self.dwPingRetries == other.dwPingRetries
4742 && self.cbBootTableString == other.cbBootTableString
4743 && self.wszBootTableString == other.wszBootTableString
4744 && self.fAuditLog == other.fAuditLog
4745 }
4746 }
4747 #[cfg(feature = "Win32_Foundation")]
4748 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_V4 {}
4749 #[cfg(feature = "Win32_Foundation")]
4750 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_V4 {
4751 type Abi = Self;
4752 type DefaultType = Self;
4753 }
4754 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4755 #[repr(C)]
4756 #[cfg(feature = "Win32_Foundation")]
4757 pub struct DHCP_SERVER_CONFIG_INFO_V6 {
4758 pub UnicastFlag: super::super::Foundation::BOOL,
4759 pub RapidCommitFlag: super::super::Foundation::BOOL,
4760 pub PreferredLifetime: u32,
4761 pub ValidLifetime: u32,
4762 pub T1: u32,
4763 pub T2: u32,
4764 pub PreferredLifetimeIATA: u32,
4765 pub ValidLifetimeIATA: u32,
4766 pub fAuditLog: super::super::Foundation::BOOL,
4767 }
4768 #[cfg(feature = "Win32_Foundation")]
4769 impl DHCP_SERVER_CONFIG_INFO_V6 {}
4770 #[cfg(feature = "Win32_Foundation")]
4771 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_V6 {
default() -> Self4772 fn default() -> Self {
4773 unsafe { ::std::mem::zeroed() }
4774 }
4775 }
4776 #[cfg(feature = "Win32_Foundation")]
4777 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4778 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4779 fmt.debug_struct("DHCP_SERVER_CONFIG_INFO_V6")
4780 .field("UnicastFlag", &self.UnicastFlag)
4781 .field("RapidCommitFlag", &self.RapidCommitFlag)
4782 .field("PreferredLifetime", &self.PreferredLifetime)
4783 .field("ValidLifetime", &self.ValidLifetime)
4784 .field("T1", &self.T1)
4785 .field("T2", &self.T2)
4786 .field("PreferredLifetimeIATA", &self.PreferredLifetimeIATA)
4787 .field("ValidLifetimeIATA", &self.ValidLifetimeIATA)
4788 .field("fAuditLog", &self.fAuditLog)
4789 .finish()
4790 }
4791 }
4792 #[cfg(feature = "Win32_Foundation")]
4793 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_V6 {
eq(&self, other: &Self) -> bool4794 fn eq(&self, other: &Self) -> bool {
4795 self.UnicastFlag == other.UnicastFlag && self.RapidCommitFlag == other.RapidCommitFlag && self.PreferredLifetime == other.PreferredLifetime && self.ValidLifetime == other.ValidLifetime && self.T1 == other.T1 && self.T2 == other.T2 && self.PreferredLifetimeIATA == other.PreferredLifetimeIATA && self.ValidLifetimeIATA == other.ValidLifetimeIATA && self.fAuditLog == other.fAuditLog
4796 }
4797 }
4798 #[cfg(feature = "Win32_Foundation")]
4799 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_V6 {}
4800 #[cfg(feature = "Win32_Foundation")]
4801 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_V6 {
4802 type Abi = Self;
4803 type DefaultType = Self;
4804 }
4805 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4806 #[repr(C)]
4807 #[cfg(feature = "Win32_Foundation")]
4808 pub struct DHCP_SERVER_CONFIG_INFO_VQ {
4809 pub APIProtocolSupport: u32,
4810 pub DatabaseName: super::super::Foundation::PWSTR,
4811 pub DatabasePath: super::super::Foundation::PWSTR,
4812 pub BackupPath: super::super::Foundation::PWSTR,
4813 pub BackupInterval: u32,
4814 pub DatabaseLoggingFlag: u32,
4815 pub RestoreFlag: u32,
4816 pub DatabaseCleanupInterval: u32,
4817 pub DebugFlag: u32,
4818 pub dwPingRetries: u32,
4819 pub cbBootTableString: u32,
4820 pub wszBootTableString: super::super::Foundation::PWSTR,
4821 pub fAuditLog: super::super::Foundation::BOOL,
4822 pub QuarantineOn: super::super::Foundation::BOOL,
4823 pub QuarDefFail: u32,
4824 pub QuarRuntimeStatus: super::super::Foundation::BOOL,
4825 }
4826 #[cfg(feature = "Win32_Foundation")]
4827 impl DHCP_SERVER_CONFIG_INFO_VQ {}
4828 #[cfg(feature = "Win32_Foundation")]
4829 impl ::std::default::Default for DHCP_SERVER_CONFIG_INFO_VQ {
default() -> Self4830 fn default() -> Self {
4831 unsafe { ::std::mem::zeroed() }
4832 }
4833 }
4834 #[cfg(feature = "Win32_Foundation")]
4835 impl ::std::fmt::Debug for DHCP_SERVER_CONFIG_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4836 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4837 fmt.debug_struct("DHCP_SERVER_CONFIG_INFO_VQ")
4838 .field("APIProtocolSupport", &self.APIProtocolSupport)
4839 .field("DatabaseName", &self.DatabaseName)
4840 .field("DatabasePath", &self.DatabasePath)
4841 .field("BackupPath", &self.BackupPath)
4842 .field("BackupInterval", &self.BackupInterval)
4843 .field("DatabaseLoggingFlag", &self.DatabaseLoggingFlag)
4844 .field("RestoreFlag", &self.RestoreFlag)
4845 .field("DatabaseCleanupInterval", &self.DatabaseCleanupInterval)
4846 .field("DebugFlag", &self.DebugFlag)
4847 .field("dwPingRetries", &self.dwPingRetries)
4848 .field("cbBootTableString", &self.cbBootTableString)
4849 .field("wszBootTableString", &self.wszBootTableString)
4850 .field("fAuditLog", &self.fAuditLog)
4851 .field("QuarantineOn", &self.QuarantineOn)
4852 .field("QuarDefFail", &self.QuarDefFail)
4853 .field("QuarRuntimeStatus", &self.QuarRuntimeStatus)
4854 .finish()
4855 }
4856 }
4857 #[cfg(feature = "Win32_Foundation")]
4858 impl ::std::cmp::PartialEq for DHCP_SERVER_CONFIG_INFO_VQ {
eq(&self, other: &Self) -> bool4859 fn eq(&self, other: &Self) -> bool {
4860 self.APIProtocolSupport == other.APIProtocolSupport
4861 && self.DatabaseName == other.DatabaseName
4862 && self.DatabasePath == other.DatabasePath
4863 && self.BackupPath == other.BackupPath
4864 && self.BackupInterval == other.BackupInterval
4865 && self.DatabaseLoggingFlag == other.DatabaseLoggingFlag
4866 && self.RestoreFlag == other.RestoreFlag
4867 && self.DatabaseCleanupInterval == other.DatabaseCleanupInterval
4868 && self.DebugFlag == other.DebugFlag
4869 && self.dwPingRetries == other.dwPingRetries
4870 && self.cbBootTableString == other.cbBootTableString
4871 && self.wszBootTableString == other.wszBootTableString
4872 && self.fAuditLog == other.fAuditLog
4873 && self.QuarantineOn == other.QuarantineOn
4874 && self.QuarDefFail == other.QuarDefFail
4875 && self.QuarRuntimeStatus == other.QuarRuntimeStatus
4876 }
4877 }
4878 #[cfg(feature = "Win32_Foundation")]
4879 impl ::std::cmp::Eq for DHCP_SERVER_CONFIG_INFO_VQ {}
4880 #[cfg(feature = "Win32_Foundation")]
4881 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_CONFIG_INFO_VQ {
4882 type Abi = Self;
4883 type DefaultType = Self;
4884 }
4885 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4886 #[repr(C)]
4887 #[cfg(feature = "Win32_Foundation")]
4888 pub struct DHCP_SERVER_OPTIONS {
4889 pub MessageType: *mut u8,
4890 pub SubnetMask: *mut u32,
4891 pub RequestedAddress: *mut u32,
4892 pub RequestLeaseTime: *mut u32,
4893 pub OverlayFields: *mut u8,
4894 pub RouterAddress: *mut u32,
4895 pub Server: *mut u32,
4896 pub ParameterRequestList: *mut u8,
4897 pub ParameterRequestListLength: u32,
4898 pub MachineName: super::super::Foundation::PSTR,
4899 pub MachineNameLength: u32,
4900 pub ClientHardwareAddressType: u8,
4901 pub ClientHardwareAddressLength: u8,
4902 pub ClientHardwareAddress: *mut u8,
4903 pub ClassIdentifier: super::super::Foundation::PSTR,
4904 pub ClassIdentifierLength: u32,
4905 pub VendorClass: *mut u8,
4906 pub VendorClassLength: u32,
4907 pub DNSFlags: u32,
4908 pub DNSNameLength: u32,
4909 pub DNSName: *mut u8,
4910 pub DSDomainNameRequested: super::super::Foundation::BOOLEAN,
4911 pub DSDomainName: super::super::Foundation::PSTR,
4912 pub DSDomainNameLen: u32,
4913 pub ScopeId: *mut u32,
4914 }
4915 #[cfg(feature = "Win32_Foundation")]
4916 impl DHCP_SERVER_OPTIONS {}
4917 #[cfg(feature = "Win32_Foundation")]
4918 impl ::std::default::Default for DHCP_SERVER_OPTIONS {
default() -> Self4919 fn default() -> Self {
4920 unsafe { ::std::mem::zeroed() }
4921 }
4922 }
4923 #[cfg(feature = "Win32_Foundation")]
4924 impl ::std::fmt::Debug for DHCP_SERVER_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4925 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4926 fmt.debug_struct("DHCP_SERVER_OPTIONS")
4927 .field("MessageType", &self.MessageType)
4928 .field("SubnetMask", &self.SubnetMask)
4929 .field("RequestedAddress", &self.RequestedAddress)
4930 .field("RequestLeaseTime", &self.RequestLeaseTime)
4931 .field("OverlayFields", &self.OverlayFields)
4932 .field("RouterAddress", &self.RouterAddress)
4933 .field("Server", &self.Server)
4934 .field("ParameterRequestList", &self.ParameterRequestList)
4935 .field("ParameterRequestListLength", &self.ParameterRequestListLength)
4936 .field("MachineName", &self.MachineName)
4937 .field("MachineNameLength", &self.MachineNameLength)
4938 .field("ClientHardwareAddressType", &self.ClientHardwareAddressType)
4939 .field("ClientHardwareAddressLength", &self.ClientHardwareAddressLength)
4940 .field("ClientHardwareAddress", &self.ClientHardwareAddress)
4941 .field("ClassIdentifier", &self.ClassIdentifier)
4942 .field("ClassIdentifierLength", &self.ClassIdentifierLength)
4943 .field("VendorClass", &self.VendorClass)
4944 .field("VendorClassLength", &self.VendorClassLength)
4945 .field("DNSFlags", &self.DNSFlags)
4946 .field("DNSNameLength", &self.DNSNameLength)
4947 .field("DNSName", &self.DNSName)
4948 .field("DSDomainNameRequested", &self.DSDomainNameRequested)
4949 .field("DSDomainName", &self.DSDomainName)
4950 .field("DSDomainNameLen", &self.DSDomainNameLen)
4951 .field("ScopeId", &self.ScopeId)
4952 .finish()
4953 }
4954 }
4955 #[cfg(feature = "Win32_Foundation")]
4956 impl ::std::cmp::PartialEq for DHCP_SERVER_OPTIONS {
eq(&self, other: &Self) -> bool4957 fn eq(&self, other: &Self) -> bool {
4958 self.MessageType == other.MessageType
4959 && self.SubnetMask == other.SubnetMask
4960 && self.RequestedAddress == other.RequestedAddress
4961 && self.RequestLeaseTime == other.RequestLeaseTime
4962 && self.OverlayFields == other.OverlayFields
4963 && self.RouterAddress == other.RouterAddress
4964 && self.Server == other.Server
4965 && self.ParameterRequestList == other.ParameterRequestList
4966 && self.ParameterRequestListLength == other.ParameterRequestListLength
4967 && self.MachineName == other.MachineName
4968 && self.MachineNameLength == other.MachineNameLength
4969 && self.ClientHardwareAddressType == other.ClientHardwareAddressType
4970 && self.ClientHardwareAddressLength == other.ClientHardwareAddressLength
4971 && self.ClientHardwareAddress == other.ClientHardwareAddress
4972 && self.ClassIdentifier == other.ClassIdentifier
4973 && self.ClassIdentifierLength == other.ClassIdentifierLength
4974 && self.VendorClass == other.VendorClass
4975 && self.VendorClassLength == other.VendorClassLength
4976 && self.DNSFlags == other.DNSFlags
4977 && self.DNSNameLength == other.DNSNameLength
4978 && self.DNSName == other.DNSName
4979 && self.DSDomainNameRequested == other.DSDomainNameRequested
4980 && self.DSDomainName == other.DSDomainName
4981 && self.DSDomainNameLen == other.DSDomainNameLen
4982 && self.ScopeId == other.ScopeId
4983 }
4984 }
4985 #[cfg(feature = "Win32_Foundation")]
4986 impl ::std::cmp::Eq for DHCP_SERVER_OPTIONS {}
4987 #[cfg(feature = "Win32_Foundation")]
4988 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_OPTIONS {
4989 type Abi = Self;
4990 type DefaultType = Self;
4991 }
4992 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4993 #[repr(C)]
4994 #[cfg(feature = "Win32_Foundation")]
4995 pub struct DHCP_SERVER_SPECIFIC_STRINGS {
4996 pub DefaultVendorClassName: super::super::Foundation::PWSTR,
4997 pub DefaultUserClassName: super::super::Foundation::PWSTR,
4998 }
4999 #[cfg(feature = "Win32_Foundation")]
5000 impl DHCP_SERVER_SPECIFIC_STRINGS {}
5001 #[cfg(feature = "Win32_Foundation")]
5002 impl ::std::default::Default for DHCP_SERVER_SPECIFIC_STRINGS {
default() -> Self5003 fn default() -> Self {
5004 unsafe { ::std::mem::zeroed() }
5005 }
5006 }
5007 #[cfg(feature = "Win32_Foundation")]
5008 impl ::std::fmt::Debug for DHCP_SERVER_SPECIFIC_STRINGS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5009 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5010 fmt.debug_struct("DHCP_SERVER_SPECIFIC_STRINGS").field("DefaultVendorClassName", &self.DefaultVendorClassName).field("DefaultUserClassName", &self.DefaultUserClassName).finish()
5011 }
5012 }
5013 #[cfg(feature = "Win32_Foundation")]
5014 impl ::std::cmp::PartialEq for DHCP_SERVER_SPECIFIC_STRINGS {
eq(&self, other: &Self) -> bool5015 fn eq(&self, other: &Self) -> bool {
5016 self.DefaultVendorClassName == other.DefaultVendorClassName && self.DefaultUserClassName == other.DefaultUserClassName
5017 }
5018 }
5019 #[cfg(feature = "Win32_Foundation")]
5020 impl ::std::cmp::Eq for DHCP_SERVER_SPECIFIC_STRINGS {}
5021 #[cfg(feature = "Win32_Foundation")]
5022 unsafe impl ::windows::runtime::Abi for DHCP_SERVER_SPECIFIC_STRINGS {
5023 type Abi = Self;
5024 type DefaultType = Self;
5025 }
5026 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5027 #[repr(C)]
5028 #[cfg(feature = "Win32_Foundation")]
5029 pub struct DHCP_SUBNET_ELEMENT_DATA {
5030 pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5031 pub Element: DHCP_SUBNET_ELEMENT_DATA_0,
5032 }
5033 #[cfg(feature = "Win32_Foundation")]
5034 impl DHCP_SUBNET_ELEMENT_DATA {}
5035 #[cfg(feature = "Win32_Foundation")]
5036 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA {
default() -> Self5037 fn default() -> Self {
5038 unsafe { ::std::mem::zeroed() }
5039 }
5040 }
5041 #[cfg(feature = "Win32_Foundation")]
5042 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA {
eq(&self, _other: &Self) -> bool5043 fn eq(&self, _other: &Self) -> bool {
5044 unimplemented!()
5045 }
5046 }
5047 #[cfg(feature = "Win32_Foundation")]
5048 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA {}
5049 #[cfg(feature = "Win32_Foundation")]
5050 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA {
5051 type Abi = Self;
5052 type DefaultType = Self;
5053 }
5054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5055 #[repr(C)]
5056 #[cfg(feature = "Win32_Foundation")]
5057 pub union DHCP_SUBNET_ELEMENT_DATA_0 {
5058 pub IpRange: *mut DHCP_IP_RANGE,
5059 pub SecondaryHost: *mut DHCP_HOST_INFO,
5060 pub ReservedIp: *mut DHCP_IP_RESERVATION,
5061 pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5062 pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5063 }
5064 #[cfg(feature = "Win32_Foundation")]
5065 impl DHCP_SUBNET_ELEMENT_DATA_0 {}
5066 #[cfg(feature = "Win32_Foundation")]
5067 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_0 {
default() -> Self5068 fn default() -> Self {
5069 unsafe { ::std::mem::zeroed() }
5070 }
5071 }
5072 #[cfg(feature = "Win32_Foundation")]
5073 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_0 {
eq(&self, _other: &Self) -> bool5074 fn eq(&self, _other: &Self) -> bool {
5075 unimplemented!()
5076 }
5077 }
5078 #[cfg(feature = "Win32_Foundation")]
5079 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_0 {}
5080 #[cfg(feature = "Win32_Foundation")]
5081 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_0 {
5082 type Abi = Self;
5083 type DefaultType = Self;
5084 }
5085 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5086 #[repr(C)]
5087 #[cfg(feature = "Win32_Foundation")]
5088 pub struct DHCP_SUBNET_ELEMENT_DATA_V4 {
5089 pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5090 pub Element: DHCP_SUBNET_ELEMENT_DATA_V4_0,
5091 }
5092 #[cfg(feature = "Win32_Foundation")]
5093 impl DHCP_SUBNET_ELEMENT_DATA_V4 {}
5094 #[cfg(feature = "Win32_Foundation")]
5095 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V4 {
default() -> Self5096 fn default() -> Self {
5097 unsafe { ::std::mem::zeroed() }
5098 }
5099 }
5100 #[cfg(feature = "Win32_Foundation")]
5101 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V4 {
eq(&self, _other: &Self) -> bool5102 fn eq(&self, _other: &Self) -> bool {
5103 unimplemented!()
5104 }
5105 }
5106 #[cfg(feature = "Win32_Foundation")]
5107 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V4 {}
5108 #[cfg(feature = "Win32_Foundation")]
5109 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V4 {
5110 type Abi = Self;
5111 type DefaultType = Self;
5112 }
5113 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5114 #[repr(C)]
5115 #[cfg(feature = "Win32_Foundation")]
5116 pub union DHCP_SUBNET_ELEMENT_DATA_V4_0 {
5117 pub IpRange: *mut DHCP_IP_RANGE,
5118 pub SecondaryHost: *mut DHCP_HOST_INFO,
5119 pub ReservedIp: *mut DHCP_IP_RESERVATION_V4,
5120 pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5121 pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5122 }
5123 #[cfg(feature = "Win32_Foundation")]
5124 impl DHCP_SUBNET_ELEMENT_DATA_V4_0 {}
5125 #[cfg(feature = "Win32_Foundation")]
5126 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
default() -> Self5127 fn default() -> Self {
5128 unsafe { ::std::mem::zeroed() }
5129 }
5130 }
5131 #[cfg(feature = "Win32_Foundation")]
5132 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
eq(&self, _other: &Self) -> bool5133 fn eq(&self, _other: &Self) -> bool {
5134 unimplemented!()
5135 }
5136 }
5137 #[cfg(feature = "Win32_Foundation")]
5138 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V4_0 {}
5139 #[cfg(feature = "Win32_Foundation")]
5140 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V4_0 {
5141 type Abi = Self;
5142 type DefaultType = Self;
5143 }
5144 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5145 #[repr(C)]
5146 #[cfg(feature = "Win32_Foundation")]
5147 pub struct DHCP_SUBNET_ELEMENT_DATA_V5 {
5148 pub ElementType: DHCP_SUBNET_ELEMENT_TYPE,
5149 pub Element: DHCP_SUBNET_ELEMENT_DATA_V5_0,
5150 }
5151 #[cfg(feature = "Win32_Foundation")]
5152 impl DHCP_SUBNET_ELEMENT_DATA_V5 {}
5153 #[cfg(feature = "Win32_Foundation")]
5154 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V5 {
default() -> Self5155 fn default() -> Self {
5156 unsafe { ::std::mem::zeroed() }
5157 }
5158 }
5159 #[cfg(feature = "Win32_Foundation")]
5160 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V5 {
eq(&self, _other: &Self) -> bool5161 fn eq(&self, _other: &Self) -> bool {
5162 unimplemented!()
5163 }
5164 }
5165 #[cfg(feature = "Win32_Foundation")]
5166 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V5 {}
5167 #[cfg(feature = "Win32_Foundation")]
5168 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V5 {
5169 type Abi = Self;
5170 type DefaultType = Self;
5171 }
5172 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5173 #[repr(C)]
5174 #[cfg(feature = "Win32_Foundation")]
5175 pub union DHCP_SUBNET_ELEMENT_DATA_V5_0 {
5176 pub IpRange: *mut DHCP_BOOTP_IP_RANGE,
5177 pub SecondaryHost: *mut DHCP_HOST_INFO,
5178 pub ReservedIp: *mut DHCP_IP_RESERVATION_V4,
5179 pub ExcludeIpRange: *mut DHCP_IP_RANGE,
5180 pub IpUsedCluster: *mut DHCP_IP_CLUSTER,
5181 }
5182 #[cfg(feature = "Win32_Foundation")]
5183 impl DHCP_SUBNET_ELEMENT_DATA_V5_0 {}
5184 #[cfg(feature = "Win32_Foundation")]
5185 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
default() -> Self5186 fn default() -> Self {
5187 unsafe { ::std::mem::zeroed() }
5188 }
5189 }
5190 #[cfg(feature = "Win32_Foundation")]
5191 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
eq(&self, _other: &Self) -> bool5192 fn eq(&self, _other: &Self) -> bool {
5193 unimplemented!()
5194 }
5195 }
5196 #[cfg(feature = "Win32_Foundation")]
5197 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V5_0 {}
5198 #[cfg(feature = "Win32_Foundation")]
5199 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V5_0 {
5200 type Abi = Self;
5201 type DefaultType = Self;
5202 }
5203 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5204 #[repr(C)]
5205 pub struct DHCP_SUBNET_ELEMENT_DATA_V6 {
5206 pub ElementType: DHCP_SUBNET_ELEMENT_TYPE_V6,
5207 pub Element: DHCP_SUBNET_ELEMENT_DATA_V6_0,
5208 }
5209 impl DHCP_SUBNET_ELEMENT_DATA_V6 {}
5210 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V6 {
default() -> Self5211 fn default() -> Self {
5212 unsafe { ::std::mem::zeroed() }
5213 }
5214 }
5215 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V6 {
eq(&self, _other: &Self) -> bool5216 fn eq(&self, _other: &Self) -> bool {
5217 unimplemented!()
5218 }
5219 }
5220 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V6 {}
5221 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V6 {
5222 type Abi = Self;
5223 type DefaultType = Self;
5224 }
5225 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5226 #[repr(C)]
5227 pub union DHCP_SUBNET_ELEMENT_DATA_V6_0 {
5228 pub IpRange: *mut DHCP_IP_RANGE_V6,
5229 pub ReservedIp: *mut DHCP_IP_RESERVATION_V6,
5230 pub ExcludeIpRange: *mut DHCP_IP_RANGE_V6,
5231 }
5232 impl DHCP_SUBNET_ELEMENT_DATA_V6_0 {}
5233 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
default() -> Self5234 fn default() -> Self {
5235 unsafe { ::std::mem::zeroed() }
5236 }
5237 }
5238 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
eq(&self, _other: &Self) -> bool5239 fn eq(&self, _other: &Self) -> bool {
5240 unimplemented!()
5241 }
5242 }
5243 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_DATA_V6_0 {}
5244 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_DATA_V6_0 {
5245 type Abi = Self;
5246 type DefaultType = Self;
5247 }
5248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5249 #[repr(C)]
5250 #[cfg(feature = "Win32_Foundation")]
5251 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY {
5252 pub NumElements: u32,
5253 pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA,
5254 }
5255 #[cfg(feature = "Win32_Foundation")]
5256 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY {}
5257 #[cfg(feature = "Win32_Foundation")]
5258 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
default() -> Self5259 fn default() -> Self {
5260 unsafe { ::std::mem::zeroed() }
5261 }
5262 }
5263 #[cfg(feature = "Win32_Foundation")]
5264 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5265 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5266 fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5267 }
5268 }
5269 #[cfg(feature = "Win32_Foundation")]
5270 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
eq(&self, other: &Self) -> bool5271 fn eq(&self, other: &Self) -> bool {
5272 self.NumElements == other.NumElements && self.Elements == other.Elements
5273 }
5274 }
5275 #[cfg(feature = "Win32_Foundation")]
5276 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY {}
5277 #[cfg(feature = "Win32_Foundation")]
5278 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY {
5279 type Abi = Self;
5280 type DefaultType = Self;
5281 }
5282 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5283 #[repr(C)]
5284 #[cfg(feature = "Win32_Foundation")]
5285 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
5286 pub NumElements: u32,
5287 pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V4,
5288 }
5289 #[cfg(feature = "Win32_Foundation")]
5290 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {}
5291 #[cfg(feature = "Win32_Foundation")]
5292 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
default() -> Self5293 fn default() -> Self {
5294 unsafe { ::std::mem::zeroed() }
5295 }
5296 }
5297 #[cfg(feature = "Win32_Foundation")]
5298 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5299 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5300 fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5301 }
5302 }
5303 #[cfg(feature = "Win32_Foundation")]
5304 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
eq(&self, other: &Self) -> bool5305 fn eq(&self, other: &Self) -> bool {
5306 self.NumElements == other.NumElements && self.Elements == other.Elements
5307 }
5308 }
5309 #[cfg(feature = "Win32_Foundation")]
5310 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {}
5311 #[cfg(feature = "Win32_Foundation")]
5312 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4 {
5313 type Abi = Self;
5314 type DefaultType = Self;
5315 }
5316 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5317 #[repr(C)]
5318 #[cfg(feature = "Win32_Foundation")]
5319 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
5320 pub NumElements: u32,
5321 pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V5,
5322 }
5323 #[cfg(feature = "Win32_Foundation")]
5324 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {}
5325 #[cfg(feature = "Win32_Foundation")]
5326 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
default() -> Self5327 fn default() -> Self {
5328 unsafe { ::std::mem::zeroed() }
5329 }
5330 }
5331 #[cfg(feature = "Win32_Foundation")]
5332 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5333 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5334 fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5335 }
5336 }
5337 #[cfg(feature = "Win32_Foundation")]
5338 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
eq(&self, other: &Self) -> bool5339 fn eq(&self, other: &Self) -> bool {
5340 self.NumElements == other.NumElements && self.Elements == other.Elements
5341 }
5342 }
5343 #[cfg(feature = "Win32_Foundation")]
5344 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {}
5345 #[cfg(feature = "Win32_Foundation")]
5346 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5 {
5347 type Abi = Self;
5348 type DefaultType = Self;
5349 }
5350 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5351 #[repr(C)]
5352 pub struct DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
5353 pub NumElements: u32,
5354 pub Elements: *mut DHCP_SUBNET_ELEMENT_DATA_V6,
5355 }
5356 impl DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {}
5357 impl ::std::default::Default for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
default() -> Self5358 fn default() -> Self {
5359 unsafe { ::std::mem::zeroed() }
5360 }
5361 }
5362 impl ::std::fmt::Debug for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5363 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5364 fmt.debug_struct("DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6").field("NumElements", &self.NumElements).field("Elements", &self.Elements).finish()
5365 }
5366 }
5367 impl ::std::cmp::PartialEq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
eq(&self, other: &Self) -> bool5368 fn eq(&self, other: &Self) -> bool {
5369 self.NumElements == other.NumElements && self.Elements == other.Elements
5370 }
5371 }
5372 impl ::std::cmp::Eq for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {}
5373 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6 {
5374 type Abi = Self;
5375 type DefaultType = Self;
5376 }
5377 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5378 #[repr(transparent)]
5379 pub struct DHCP_SUBNET_ELEMENT_TYPE(pub i32);
5380 pub const DhcpIpRanges: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(0i32);
5381 pub const DhcpSecondaryHosts: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(1i32);
5382 pub const DhcpReservedIps: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(2i32);
5383 pub const DhcpExcludedIpRanges: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(3i32);
5384 pub const DhcpIpUsedClusters: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(4i32);
5385 pub const DhcpIpRangesDhcpOnly: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(5i32);
5386 pub const DhcpIpRangesDhcpBootp: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(6i32);
5387 pub const DhcpIpRangesBootpOnly: DHCP_SUBNET_ELEMENT_TYPE = DHCP_SUBNET_ELEMENT_TYPE(7i32);
5388 impl ::std::convert::From<i32> for DHCP_SUBNET_ELEMENT_TYPE {
from(value: i32) -> Self5389 fn from(value: i32) -> Self {
5390 Self(value)
5391 }
5392 }
5393 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_TYPE {
5394 type Abi = Self;
5395 type DefaultType = Self;
5396 }
5397 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5398 #[repr(transparent)]
5399 pub struct DHCP_SUBNET_ELEMENT_TYPE_V6(pub i32);
5400 pub const Dhcpv6IpRanges: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(0i32);
5401 pub const Dhcpv6ReservedIps: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(1i32);
5402 pub const Dhcpv6ExcludedIpRanges: DHCP_SUBNET_ELEMENT_TYPE_V6 = DHCP_SUBNET_ELEMENT_TYPE_V6(2i32);
5403 impl ::std::convert::From<i32> for DHCP_SUBNET_ELEMENT_TYPE_V6 {
from(value: i32) -> Self5404 fn from(value: i32) -> Self {
5405 Self(value)
5406 }
5407 }
5408 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_ELEMENT_TYPE_V6 {
5409 type Abi = Self;
5410 type DefaultType = Self;
5411 }
5412 #[repr(C)]
5413 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5414 pub struct DHCP_SUBNET_ELEMENT_UNION(pub u8);
5415 #[repr(C)]
5416 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5417 pub struct DHCP_SUBNET_ELEMENT_UNION_V4(pub u8);
5418 #[repr(C)]
5419 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
5420 pub struct DHCP_SUBNET_ELEMENT_UNION_V6(pub u8);
5421 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5422 #[repr(C)]
5423 #[cfg(feature = "Win32_Foundation")]
5424 pub struct DHCP_SUBNET_INFO {
5425 pub SubnetAddress: u32,
5426 pub SubnetMask: u32,
5427 pub SubnetName: super::super::Foundation::PWSTR,
5428 pub SubnetComment: super::super::Foundation::PWSTR,
5429 pub PrimaryHost: DHCP_HOST_INFO,
5430 pub SubnetState: DHCP_SUBNET_STATE,
5431 }
5432 #[cfg(feature = "Win32_Foundation")]
5433 impl DHCP_SUBNET_INFO {}
5434 #[cfg(feature = "Win32_Foundation")]
5435 impl ::std::default::Default for DHCP_SUBNET_INFO {
default() -> Self5436 fn default() -> Self {
5437 unsafe { ::std::mem::zeroed() }
5438 }
5439 }
5440 #[cfg(feature = "Win32_Foundation")]
5441 impl ::std::fmt::Debug for DHCP_SUBNET_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5442 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5443 fmt.debug_struct("DHCP_SUBNET_INFO").field("SubnetAddress", &self.SubnetAddress).field("SubnetMask", &self.SubnetMask).field("SubnetName", &self.SubnetName).field("SubnetComment", &self.SubnetComment).field("PrimaryHost", &self.PrimaryHost).field("SubnetState", &self.SubnetState).finish()
5444 }
5445 }
5446 #[cfg(feature = "Win32_Foundation")]
5447 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO {
eq(&self, other: &Self) -> bool5448 fn eq(&self, other: &Self) -> bool {
5449 self.SubnetAddress == other.SubnetAddress && self.SubnetMask == other.SubnetMask && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.PrimaryHost == other.PrimaryHost && self.SubnetState == other.SubnetState
5450 }
5451 }
5452 #[cfg(feature = "Win32_Foundation")]
5453 impl ::std::cmp::Eq for DHCP_SUBNET_INFO {}
5454 #[cfg(feature = "Win32_Foundation")]
5455 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO {
5456 type Abi = Self;
5457 type DefaultType = Self;
5458 }
5459 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5460 #[repr(C)]
5461 #[cfg(feature = "Win32_Foundation")]
5462 pub struct DHCP_SUBNET_INFO_V6 {
5463 pub SubnetAddress: DHCP_IPV6_ADDRESS,
5464 pub Prefix: u32,
5465 pub Preference: u16,
5466 pub SubnetName: super::super::Foundation::PWSTR,
5467 pub SubnetComment: super::super::Foundation::PWSTR,
5468 pub State: u32,
5469 pub ScopeId: u32,
5470 }
5471 #[cfg(feature = "Win32_Foundation")]
5472 impl DHCP_SUBNET_INFO_V6 {}
5473 #[cfg(feature = "Win32_Foundation")]
5474 impl ::std::default::Default for DHCP_SUBNET_INFO_V6 {
default() -> Self5475 fn default() -> Self {
5476 unsafe { ::std::mem::zeroed() }
5477 }
5478 }
5479 #[cfg(feature = "Win32_Foundation")]
5480 impl ::std::fmt::Debug for DHCP_SUBNET_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5481 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5482 fmt.debug_struct("DHCP_SUBNET_INFO_V6")
5483 .field("SubnetAddress", &self.SubnetAddress)
5484 .field("Prefix", &self.Prefix)
5485 .field("Preference", &self.Preference)
5486 .field("SubnetName", &self.SubnetName)
5487 .field("SubnetComment", &self.SubnetComment)
5488 .field("State", &self.State)
5489 .field("ScopeId", &self.ScopeId)
5490 .finish()
5491 }
5492 }
5493 #[cfg(feature = "Win32_Foundation")]
5494 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO_V6 {
eq(&self, other: &Self) -> bool5495 fn eq(&self, other: &Self) -> bool {
5496 self.SubnetAddress == other.SubnetAddress && self.Prefix == other.Prefix && self.Preference == other.Preference && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.State == other.State && self.ScopeId == other.ScopeId
5497 }
5498 }
5499 #[cfg(feature = "Win32_Foundation")]
5500 impl ::std::cmp::Eq for DHCP_SUBNET_INFO_V6 {}
5501 #[cfg(feature = "Win32_Foundation")]
5502 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO_V6 {
5503 type Abi = Self;
5504 type DefaultType = Self;
5505 }
5506 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5507 #[repr(C)]
5508 #[cfg(feature = "Win32_Foundation")]
5509 pub struct DHCP_SUBNET_INFO_VQ {
5510 pub SubnetAddress: u32,
5511 pub SubnetMask: u32,
5512 pub SubnetName: super::super::Foundation::PWSTR,
5513 pub SubnetComment: super::super::Foundation::PWSTR,
5514 pub PrimaryHost: DHCP_HOST_INFO,
5515 pub SubnetState: DHCP_SUBNET_STATE,
5516 pub QuarantineOn: u32,
5517 pub Reserved1: u32,
5518 pub Reserved2: u32,
5519 pub Reserved3: i64,
5520 pub Reserved4: i64,
5521 }
5522 #[cfg(feature = "Win32_Foundation")]
5523 impl DHCP_SUBNET_INFO_VQ {}
5524 #[cfg(feature = "Win32_Foundation")]
5525 impl ::std::default::Default for DHCP_SUBNET_INFO_VQ {
default() -> Self5526 fn default() -> Self {
5527 unsafe { ::std::mem::zeroed() }
5528 }
5529 }
5530 #[cfg(feature = "Win32_Foundation")]
5531 impl ::std::fmt::Debug for DHCP_SUBNET_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5532 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5533 fmt.debug_struct("DHCP_SUBNET_INFO_VQ")
5534 .field("SubnetAddress", &self.SubnetAddress)
5535 .field("SubnetMask", &self.SubnetMask)
5536 .field("SubnetName", &self.SubnetName)
5537 .field("SubnetComment", &self.SubnetComment)
5538 .field("PrimaryHost", &self.PrimaryHost)
5539 .field("SubnetState", &self.SubnetState)
5540 .field("QuarantineOn", &self.QuarantineOn)
5541 .field("Reserved1", &self.Reserved1)
5542 .field("Reserved2", &self.Reserved2)
5543 .field("Reserved3", &self.Reserved3)
5544 .field("Reserved4", &self.Reserved4)
5545 .finish()
5546 }
5547 }
5548 #[cfg(feature = "Win32_Foundation")]
5549 impl ::std::cmp::PartialEq for DHCP_SUBNET_INFO_VQ {
eq(&self, other: &Self) -> bool5550 fn eq(&self, other: &Self) -> bool {
5551 self.SubnetAddress == other.SubnetAddress && self.SubnetMask == other.SubnetMask && self.SubnetName == other.SubnetName && self.SubnetComment == other.SubnetComment && self.PrimaryHost == other.PrimaryHost && self.SubnetState == other.SubnetState && self.QuarantineOn == other.QuarantineOn && self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2 && self.Reserved3 == other.Reserved3 && self.Reserved4 == other.Reserved4
5552 }
5553 }
5554 #[cfg(feature = "Win32_Foundation")]
5555 impl ::std::cmp::Eq for DHCP_SUBNET_INFO_VQ {}
5556 #[cfg(feature = "Win32_Foundation")]
5557 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_INFO_VQ {
5558 type Abi = Self;
5559 type DefaultType = Self;
5560 }
5561 pub const DHCP_SUBNET_INFO_VQ_FLAG_QUARANTINE: u32 = 1u32;
5562 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5563 #[repr(transparent)]
5564 pub struct DHCP_SUBNET_STATE(pub i32);
5565 pub const DhcpSubnetEnabled: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(0i32);
5566 pub const DhcpSubnetDisabled: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(1i32);
5567 pub const DhcpSubnetEnabledSwitched: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(2i32);
5568 pub const DhcpSubnetDisabledSwitched: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(3i32);
5569 pub const DhcpSubnetInvalidState: DHCP_SUBNET_STATE = DHCP_SUBNET_STATE(4i32);
5570 impl ::std::convert::From<i32> for DHCP_SUBNET_STATE {
from(value: i32) -> Self5571 fn from(value: i32) -> Self {
5572 Self(value)
5573 }
5574 }
5575 unsafe impl ::windows::runtime::Abi for DHCP_SUBNET_STATE {
5576 type Abi = Self;
5577 type DefaultType = Self;
5578 }
5579 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5580 #[repr(C)]
5581 #[cfg(feature = "Win32_Foundation")]
5582 pub struct DHCP_SUPER_SCOPE_TABLE {
5583 pub cEntries: u32,
5584 pub pEntries: *mut DHCP_SUPER_SCOPE_TABLE_ENTRY,
5585 }
5586 #[cfg(feature = "Win32_Foundation")]
5587 impl DHCP_SUPER_SCOPE_TABLE {}
5588 #[cfg(feature = "Win32_Foundation")]
5589 impl ::std::default::Default for DHCP_SUPER_SCOPE_TABLE {
default() -> Self5590 fn default() -> Self {
5591 unsafe { ::std::mem::zeroed() }
5592 }
5593 }
5594 #[cfg(feature = "Win32_Foundation")]
5595 impl ::std::fmt::Debug for DHCP_SUPER_SCOPE_TABLE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5596 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5597 fmt.debug_struct("DHCP_SUPER_SCOPE_TABLE").field("cEntries", &self.cEntries).field("pEntries", &self.pEntries).finish()
5598 }
5599 }
5600 #[cfg(feature = "Win32_Foundation")]
5601 impl ::std::cmp::PartialEq for DHCP_SUPER_SCOPE_TABLE {
eq(&self, other: &Self) -> bool5602 fn eq(&self, other: &Self) -> bool {
5603 self.cEntries == other.cEntries && self.pEntries == other.pEntries
5604 }
5605 }
5606 #[cfg(feature = "Win32_Foundation")]
5607 impl ::std::cmp::Eq for DHCP_SUPER_SCOPE_TABLE {}
5608 #[cfg(feature = "Win32_Foundation")]
5609 unsafe impl ::windows::runtime::Abi for DHCP_SUPER_SCOPE_TABLE {
5610 type Abi = Self;
5611 type DefaultType = Self;
5612 }
5613 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5614 #[repr(C)]
5615 #[cfg(feature = "Win32_Foundation")]
5616 pub struct DHCP_SUPER_SCOPE_TABLE_ENTRY {
5617 pub SubnetAddress: u32,
5618 pub SuperScopeNumber: u32,
5619 pub NextInSuperScope: u32,
5620 pub SuperScopeName: super::super::Foundation::PWSTR,
5621 }
5622 #[cfg(feature = "Win32_Foundation")]
5623 impl DHCP_SUPER_SCOPE_TABLE_ENTRY {}
5624 #[cfg(feature = "Win32_Foundation")]
5625 impl ::std::default::Default for DHCP_SUPER_SCOPE_TABLE_ENTRY {
default() -> Self5626 fn default() -> Self {
5627 unsafe { ::std::mem::zeroed() }
5628 }
5629 }
5630 #[cfg(feature = "Win32_Foundation")]
5631 impl ::std::fmt::Debug for DHCP_SUPER_SCOPE_TABLE_ENTRY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5632 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5633 fmt.debug_struct("DHCP_SUPER_SCOPE_TABLE_ENTRY").field("SubnetAddress", &self.SubnetAddress).field("SuperScopeNumber", &self.SuperScopeNumber).field("NextInSuperScope", &self.NextInSuperScope).field("SuperScopeName", &self.SuperScopeName).finish()
5634 }
5635 }
5636 #[cfg(feature = "Win32_Foundation")]
5637 impl ::std::cmp::PartialEq for DHCP_SUPER_SCOPE_TABLE_ENTRY {
eq(&self, other: &Self) -> bool5638 fn eq(&self, other: &Self) -> bool {
5639 self.SubnetAddress == other.SubnetAddress && self.SuperScopeNumber == other.SuperScopeNumber && self.NextInSuperScope == other.NextInSuperScope && self.SuperScopeName == other.SuperScopeName
5640 }
5641 }
5642 #[cfg(feature = "Win32_Foundation")]
5643 impl ::std::cmp::Eq for DHCP_SUPER_SCOPE_TABLE_ENTRY {}
5644 #[cfg(feature = "Win32_Foundation")]
5645 unsafe impl ::windows::runtime::Abi for DHCP_SUPER_SCOPE_TABLE_ENTRY {
5646 type Abi = Self;
5647 type DefaultType = Self;
5648 }
5649 pub const DNS_FLAG_CLEANUP_EXPIRED: u32 = 4u32;
5650 pub const DNS_FLAG_DISABLE_PTR_UPDATE: u32 = 64u32;
5651 pub const DNS_FLAG_ENABLED: u32 = 1u32;
5652 pub const DNS_FLAG_HAS_DNS_SUFFIX: u32 = 128u32;
5653 pub const DNS_FLAG_UPDATE_BOTH_ALWAYS: u32 = 16u32;
5654 pub const DNS_FLAG_UPDATE_DHCID: u32 = 32u32;
5655 pub const DNS_FLAG_UPDATE_DOWNLEVEL: u32 = 2u32;
5656 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5657 #[repr(C)]
5658 pub struct DWORD_DWORD {
5659 pub DWord1: u32,
5660 pub DWord2: u32,
5661 }
5662 impl DWORD_DWORD {}
5663 impl ::std::default::Default for DWORD_DWORD {
default() -> Self5664 fn default() -> Self {
5665 unsafe { ::std::mem::zeroed() }
5666 }
5667 }
5668 impl ::std::fmt::Debug for DWORD_DWORD {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5669 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5670 fmt.debug_struct("DWORD_DWORD").field("DWord1", &self.DWord1).field("DWord2", &self.DWord2).finish()
5671 }
5672 }
5673 impl ::std::cmp::PartialEq for DWORD_DWORD {
eq(&self, other: &Self) -> bool5674 fn eq(&self, other: &Self) -> bool {
5675 self.DWord1 == other.DWord1 && self.DWord2 == other.DWord2
5676 }
5677 }
5678 impl ::std::cmp::Eq for DWORD_DWORD {}
5679 unsafe impl ::windows::runtime::Abi for DWORD_DWORD {
5680 type Abi = Self;
5681 type DefaultType = Self;
5682 }
5683 #[cfg(feature = "Win32_Foundation")]
5684 #[inline]
DhcpAddFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: Param2) -> u325685 pub unsafe fn DhcpAddFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: Param2) -> u32 {
5686 #[cfg(windows)]
5687 {
5688 #[link(name = "windows")]
5689 extern "system" {
5690 fn DhcpAddFilterV4(serveripaddress: super::super::Foundation::PWSTR, addfilterinfo: *const DHCP_FILTER_ADD_INFO, forceflag: super::super::Foundation::BOOL) -> u32;
5691 }
5692 ::std::mem::transmute(DhcpAddFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(addfilterinfo), forceflag.into_param().abi()))
5693 }
5694 #[cfg(not(windows))]
5695 unimplemented!("Unsupported target OS");
5696 }
5697 #[cfg(feature = "Win32_Foundation")]
5698 #[inline]
DhcpAddSecurityGroup<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pserver: Param0) -> u325699 pub unsafe fn DhcpAddSecurityGroup<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(pserver: Param0) -> u32 {
5700 #[cfg(windows)]
5701 {
5702 #[link(name = "windows")]
5703 extern "system" {
5704 fn DhcpAddSecurityGroup(pserver: super::super::Foundation::PWSTR) -> u32;
5705 }
5706 ::std::mem::transmute(DhcpAddSecurityGroup(pserver.into_param().abi()))
5707 }
5708 #[cfg(not(windows))]
5709 unimplemented!("Unsupported target OS");
5710 }
5711 #[cfg(feature = "Win32_Foundation")]
5712 #[inline]
DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u325713 pub unsafe fn DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
5714 #[cfg(windows)]
5715 {
5716 #[link(name = "windows")]
5717 extern "system" {
5718 fn DhcpAddServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
5719 }
5720 ::std::mem::transmute(DhcpAddServer(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(newserver), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
5721 }
5722 #[cfg(not(windows))]
5723 unimplemented!("Unsupported target OS");
5724 }
5725 #[cfg(feature = "Win32_Foundation")]
5726 #[inline]
DhcpAddSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u325727 pub unsafe fn DhcpAddSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u32 {
5728 #[cfg(windows)]
5729 {
5730 #[link(name = "windows")]
5731 extern "system" {
5732 fn DhcpAddSubnetElement(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA) -> u32;
5733 }
5734 ::std::mem::transmute(DhcpAddSubnetElement(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5735 }
5736 #[cfg(not(windows))]
5737 unimplemented!("Unsupported target OS");
5738 }
5739 #[cfg(feature = "Win32_Foundation")]
5740 #[inline]
DhcpAddSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u325741 pub unsafe fn DhcpAddSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u32 {
5742 #[cfg(windows)]
5743 {
5744 #[link(name = "windows")]
5745 extern "system" {
5746 fn DhcpAddSubnetElementV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4) -> u32;
5747 }
5748 ::std::mem::transmute(DhcpAddSubnetElementV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5749 }
5750 #[cfg(not(windows))]
5751 unimplemented!("Unsupported target OS");
5752 }
5753 #[cfg(feature = "Win32_Foundation")]
5754 #[inline]
DhcpAddSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u325755 pub unsafe fn DhcpAddSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u32 {
5756 #[cfg(windows)]
5757 {
5758 #[link(name = "windows")]
5759 extern "system" {
5760 fn DhcpAddSubnetElementV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, addelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5) -> u32;
5761 }
5762 ::std::mem::transmute(DhcpAddSubnetElementV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(addelementinfo)))
5763 }
5764 #[cfg(not(windows))]
5765 unimplemented!("Unsupported target OS");
5766 }
5767 #[cfg(feature = "Win32_Foundation")]
5768 #[inline]
DhcpAddSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u325769 pub unsafe fn DhcpAddSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u32 {
5770 #[cfg(windows)]
5771 {
5772 #[link(name = "windows")]
5773 extern "system" {
5774 fn DhcpAddSubnetElementV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, addelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6) -> u32;
5775 }
5776 ::std::mem::transmute(DhcpAddSubnetElementV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(addelementinfo)))
5777 }
5778 #[cfg(not(windows))]
5779 unimplemented!("Unsupported target OS");
5780 }
5781 #[cfg(feature = "Win32_Foundation")]
5782 #[inline]
DhcpAuditLogGetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u325783 pub unsafe fn DhcpAuditLogGetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u32 {
5784 #[cfg(windows)]
5785 {
5786 #[link(name = "windows")]
5787 extern "system" {
5788 fn DhcpAuditLogGetParams(serveripaddress: super::super::Foundation::PWSTR, flags: u32, auditlogdir: *mut super::super::Foundation::PWSTR, diskcheckinterval: *mut u32, maxlogfilessize: *mut u32, minspaceondisk: *mut u32) -> u32;
5789 }
5790 ::std::mem::transmute(DhcpAuditLogGetParams(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(auditlogdir), ::std::mem::transmute(diskcheckinterval), ::std::mem::transmute(maxlogfilessize), ::std::mem::transmute(minspaceondisk)))
5791 }
5792 #[cfg(not(windows))]
5793 unimplemented!("Unsupported target OS");
5794 }
5795 #[cfg(feature = "Win32_Foundation")]
5796 #[inline]
DhcpAuditLogSetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: Param2, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u325797 pub unsafe fn DhcpAuditLogSetParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, auditlogdir: Param2, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u32 {
5798 #[cfg(windows)]
5799 {
5800 #[link(name = "windows")]
5801 extern "system" {
5802 fn DhcpAuditLogSetParams(serveripaddress: super::super::Foundation::PWSTR, flags: u32, auditlogdir: super::super::Foundation::PWSTR, diskcheckinterval: u32, maxlogfilessize: u32, minspaceondisk: u32) -> u32;
5803 }
5804 ::std::mem::transmute(DhcpAuditLogSetParams(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), auditlogdir.into_param().abi(), ::std::mem::transmute(diskcheckinterval), ::std::mem::transmute(maxlogfilessize), ::std::mem::transmute(minspaceondisk)))
5805 }
5806 #[cfg(not(windows))]
5807 unimplemented!("Unsupported target OS");
5808 }
5809 #[inline]
DhcpCApiCleanup()5810 pub unsafe fn DhcpCApiCleanup() {
5811 #[cfg(windows)]
5812 {
5813 #[link(name = "windows")]
5814 extern "system" {
5815 fn DhcpCApiCleanup();
5816 }
5817 ::std::mem::transmute(DhcpCApiCleanup())
5818 }
5819 #[cfg(not(windows))]
5820 unimplemented!("Unsupported target OS");
5821 }
5822 #[inline]
DhcpCApiInitialize(version: *mut u32) -> u325823 pub unsafe fn DhcpCApiInitialize(version: *mut u32) -> u32 {
5824 #[cfg(windows)]
5825 {
5826 #[link(name = "windows")]
5827 extern "system" {
5828 fn DhcpCApiInitialize(version: *mut u32) -> u32;
5829 }
5830 ::std::mem::transmute(DhcpCApiInitialize(::std::mem::transmute(version)))
5831 }
5832 #[cfg(not(windows))]
5833 unimplemented!("Unsupported target OS");
5834 }
5835 #[cfg(feature = "Win32_Foundation")]
5836 #[inline]
DhcpCreateClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u325837 pub unsafe fn DhcpCreateClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32 {
5838 #[cfg(windows)]
5839 {
5840 #[link(name = "windows")]
5841 extern "system" {
5842 fn DhcpCreateClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32;
5843 }
5844 ::std::mem::transmute(DhcpCreateClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
5845 }
5846 #[cfg(not(windows))]
5847 unimplemented!("Unsupported target OS");
5848 }
5849 #[cfg(feature = "Win32_Foundation")]
5850 #[inline]
DhcpCreateClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u325851 pub unsafe fn DhcpCreateClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32 {
5852 #[cfg(windows)]
5853 {
5854 #[link(name = "windows")]
5855 extern "system" {
5856 fn DhcpCreateClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32;
5857 }
5858 ::std::mem::transmute(DhcpCreateClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
5859 }
5860 #[cfg(not(windows))]
5861 unimplemented!("Unsupported target OS");
5862 }
5863 #[cfg(feature = "Win32_Foundation")]
5864 #[inline]
DhcpCreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u325865 pub unsafe fn DhcpCreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u32 {
5866 #[cfg(windows)]
5867 {
5868 #[link(name = "windows")]
5869 extern "system" {
5870 fn DhcpCreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO) -> u32;
5871 }
5872 ::std::mem::transmute(DhcpCreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5873 }
5874 #[cfg(not(windows))]
5875 unimplemented!("Unsupported target OS");
5876 }
5877 #[cfg(feature = "Win32_Foundation")]
5878 #[inline]
DhcpCreateClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u325879 pub unsafe fn DhcpCreateClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32 {
5880 #[cfg(windows)]
5881 {
5882 #[link(name = "windows")]
5883 extern "system" {
5884 fn DhcpCreateClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32;
5885 }
5886 ::std::mem::transmute(DhcpCreateClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5887 }
5888 #[cfg(not(windows))]
5889 unimplemented!("Unsupported target OS");
5890 }
5891 #[cfg(feature = "Win32_Foundation")]
5892 #[inline]
DhcpCreateClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u325893 pub unsafe fn DhcpCreateClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32 {
5894 #[cfg(windows)]
5895 {
5896 #[link(name = "windows")]
5897 extern "system" {
5898 fn DhcpCreateClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32;
5899 }
5900 ::std::mem::transmute(DhcpCreateClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
5901 }
5902 #[cfg(not(windows))]
5903 unimplemented!("Unsupported target OS");
5904 }
5905 #[cfg(feature = "Win32_Foundation")]
5906 #[inline]
DhcpCreateOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u325907 pub unsafe fn DhcpCreateOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32 {
5908 #[cfg(windows)]
5909 {
5910 #[link(name = "windows")]
5911 extern "system" {
5912 fn DhcpCreateOption(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32;
5913 }
5914 ::std::mem::transmute(DhcpCreateOption(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
5915 }
5916 #[cfg(not(windows))]
5917 unimplemented!("Unsupported target OS");
5918 }
5919 #[cfg(feature = "Win32_Foundation")]
5920 #[inline]
DhcpCreateOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u325921 pub unsafe fn DhcpCreateOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
5922 #[cfg(windows)]
5923 {
5924 #[link(name = "windows")]
5925 extern "system" {
5926 fn DhcpCreateOptionV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
5927 }
5928 ::std::mem::transmute(DhcpCreateOptionV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
5929 }
5930 #[cfg(not(windows))]
5931 unimplemented!("Unsupported target OS");
5932 }
5933 #[cfg(feature = "Win32_Foundation")]
5934 #[inline]
DhcpCreateOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u325935 pub unsafe fn DhcpCreateOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
5936 #[cfg(windows)]
5937 {
5938 #[link(name = "windows")]
5939 extern "system" {
5940 fn DhcpCreateOptionV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
5941 }
5942 ::std::mem::transmute(DhcpCreateOptionV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
5943 }
5944 #[cfg(not(windows))]
5945 unimplemented!("Unsupported target OS");
5946 }
5947 #[cfg(feature = "Win32_Foundation")]
5948 #[inline]
DhcpCreateSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u325949 pub unsafe fn DhcpCreateSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32 {
5950 #[cfg(windows)]
5951 {
5952 #[link(name = "windows")]
5953 extern "system" {
5954 fn DhcpCreateSubnet(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32;
5955 }
5956 ::std::mem::transmute(DhcpCreateSubnet(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
5957 }
5958 #[cfg(not(windows))]
5959 unimplemented!("Unsupported target OS");
5960 }
5961 #[cfg(feature = "Win32_Foundation")]
5962 #[inline]
DhcpCreateSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u325963 pub unsafe fn DhcpCreateSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32 {
5964 #[cfg(windows)]
5965 {
5966 #[link(name = "windows")]
5967 extern "system" {
5968 fn DhcpCreateSubnetV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32;
5969 }
5970 ::std::mem::transmute(DhcpCreateSubnetV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
5971 }
5972 #[cfg(not(windows))]
5973 unimplemented!("Unsupported target OS");
5974 }
5975 #[cfg(feature = "Win32_Foundation")]
5976 #[inline]
DhcpCreateSubnetVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u325977 pub unsafe fn DhcpCreateSubnetVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32 {
5978 #[cfg(windows)]
5979 {
5980 #[link(name = "windows")]
5981 extern "system" {
5982 fn DhcpCreateSubnetVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32;
5983 }
5984 ::std::mem::transmute(DhcpCreateSubnetVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
5985 }
5986 #[cfg(not(windows))]
5987 unimplemented!("Unsupported target OS");
5988 }
5989 #[inline]
DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u325990 pub unsafe fn DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u32 {
5991 #[cfg(windows)]
5992 {
5993 #[link(name = "windows")]
5994 extern "system" {
5995 fn DhcpDeRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, event: *mut ::std::ffi::c_void) -> u32;
5996 }
5997 ::std::mem::transmute(DhcpDeRegisterParamChange(::std::mem::transmute(flags), ::std::mem::transmute(reserved), ::std::mem::transmute(event)))
5998 }
5999 #[cfg(not(windows))]
6000 unimplemented!("Unsupported target OS");
6001 }
6002 #[cfg(feature = "Win32_Foundation")]
6003 #[inline]
DhcpDeleteClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u326004 pub unsafe fn DhcpDeleteClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u32 {
6005 #[cfg(windows)]
6006 {
6007 #[link(name = "windows")]
6008 extern "system" {
6009 fn DhcpDeleteClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classname: super::super::Foundation::PWSTR) -> u32;
6010 }
6011 ::std::mem::transmute(DhcpDeleteClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), classname.into_param().abi()))
6012 }
6013 #[cfg(not(windows))]
6014 unimplemented!("Unsupported target OS");
6015 }
6016 #[cfg(feature = "Win32_Foundation")]
6017 #[inline]
DhcpDeleteClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u326018 pub unsafe fn DhcpDeleteClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classname: Param2) -> u32 {
6019 #[cfg(windows)]
6020 {
6021 #[link(name = "windows")]
6022 extern "system" {
6023 fn DhcpDeleteClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classname: super::super::Foundation::PWSTR) -> u32;
6024 }
6025 ::std::mem::transmute(DhcpDeleteClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), classname.into_param().abi()))
6026 }
6027 #[cfg(not(windows))]
6028 unimplemented!("Unsupported target OS");
6029 }
6030 #[cfg(feature = "Win32_Foundation")]
6031 #[inline]
DhcpDeleteClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO) -> u326032 pub unsafe fn DhcpDeleteClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO) -> u32 {
6033 #[cfg(windows)]
6034 {
6035 #[link(name = "windows")]
6036 extern "system" {
6037 fn DhcpDeleteClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_SEARCH_INFO) -> u32;
6038 }
6039 ::std::mem::transmute(DhcpDeleteClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
6040 }
6041 #[cfg(not(windows))]
6042 unimplemented!("Unsupported target OS");
6043 }
6044 #[cfg(feature = "Win32_Foundation")]
6045 #[inline]
DhcpDeleteClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u326046 pub unsafe fn DhcpDeleteClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u32 {
6047 #[cfg(windows)]
6048 {
6049 #[link(name = "windows")]
6050 extern "system" {
6051 fn DhcpDeleteClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_SEARCH_INFO_V6) -> u32;
6052 }
6053 ::std::mem::transmute(DhcpDeleteClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
6054 }
6055 #[cfg(not(windows))]
6056 unimplemented!("Unsupported target OS");
6057 }
6058 #[cfg(feature = "Win32_Foundation")]
6059 #[inline]
DhcpDeleteFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u326060 pub unsafe fn DhcpDeleteFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u32 {
6061 #[cfg(windows)]
6062 {
6063 #[link(name = "windows")]
6064 extern "system" {
6065 fn DhcpDeleteFilterV4(serveripaddress: super::super::Foundation::PWSTR, deletefilterinfo: *const DHCP_ADDR_PATTERN) -> u32;
6066 }
6067 ::std::mem::transmute(DhcpDeleteFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(deletefilterinfo)))
6068 }
6069 #[cfg(not(windows))]
6070 unimplemented!("Unsupported target OS");
6071 }
6072 #[cfg(feature = "Win32_Foundation")]
6073 #[inline]
DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u326074 pub unsafe fn DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
6075 #[cfg(windows)]
6076 {
6077 #[link(name = "windows")]
6078 extern "system" {
6079 fn DhcpDeleteServer(flags: u32, idinfo: *mut ::std::ffi::c_void, newserver: *mut DHCPDS_SERVER, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
6080 }
6081 ::std::mem::transmute(DhcpDeleteServer(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(newserver), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
6082 }
6083 #[cfg(not(windows))]
6084 unimplemented!("Unsupported target OS");
6085 }
6086 #[cfg(feature = "Win32_Foundation")]
6087 #[inline]
DhcpDeleteSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u326088 pub unsafe fn DhcpDeleteSubnet<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u32 {
6089 #[cfg(windows)]
6090 {
6091 #[link(name = "windows")]
6092 extern "system" {
6093 fn DhcpDeleteSubnet(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, forceflag: DHCP_FORCE_FLAG) -> u32;
6094 }
6095 ::std::mem::transmute(DhcpDeleteSubnet(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(forceflag)))
6096 }
6097 #[cfg(not(windows))]
6098 unimplemented!("Unsupported target OS");
6099 }
6100 #[cfg(feature = "Win32_Foundation")]
6101 #[inline]
DhcpDeleteSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, forceflag: DHCP_FORCE_FLAG) -> u326102 pub unsafe fn DhcpDeleteSubnetV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, forceflag: DHCP_FORCE_FLAG) -> u32 {
6103 #[cfg(windows)]
6104 {
6105 #[link(name = "windows")]
6106 extern "system" {
6107 fn DhcpDeleteSubnetV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, forceflag: DHCP_FORCE_FLAG) -> u32;
6108 }
6109 ::std::mem::transmute(DhcpDeleteSubnetV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(forceflag)))
6110 }
6111 #[cfg(not(windows))]
6112 unimplemented!("Unsupported target OS");
6113 }
6114 #[cfg(feature = "Win32_Foundation")]
6115 #[inline]
DhcpDeleteSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopename: Param1) -> u326116 pub unsafe fn DhcpDeleteSuperScopeV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopename: Param1) -> u32 {
6117 #[cfg(windows)]
6118 {
6119 #[link(name = "windows")]
6120 extern "system" {
6121 fn DhcpDeleteSuperScopeV4(serveripaddress: super::super::Foundation::PWSTR, superscopename: super::super::Foundation::PWSTR) -> u32;
6122 }
6123 ::std::mem::transmute(DhcpDeleteSuperScopeV4(serveripaddress.into_param().abi(), superscopename.into_param().abi()))
6124 }
6125 #[cfg(not(windows))]
6126 unimplemented!("Unsupported target OS");
6127 }
6128 #[inline]
DhcpDsCleanup()6129 pub unsafe fn DhcpDsCleanup() {
6130 #[cfg(windows)]
6131 {
6132 #[link(name = "windows")]
6133 extern "system" {
6134 fn DhcpDsCleanup();
6135 }
6136 ::std::mem::transmute(DhcpDsCleanup())
6137 }
6138 #[cfg(not(windows))]
6139 unimplemented!("Unsupported target OS");
6140 }
6141 #[inline]
DhcpDsInit() -> u326142 pub unsafe fn DhcpDsInit() -> u32 {
6143 #[cfg(windows)]
6144 {
6145 #[link(name = "windows")]
6146 extern "system" {
6147 fn DhcpDsInit() -> u32;
6148 }
6149 ::std::mem::transmute(DhcpDsInit())
6150 }
6151 #[cfg(not(windows))]
6152 unimplemented!("Unsupported target OS");
6153 }
6154 #[cfg(feature = "Win32_Foundation")]
6155 #[inline]
DhcpEnumClasses<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u326156 pub unsafe fn DhcpEnumClasses<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u32 {
6157 #[cfg(windows)]
6158 {
6159 #[link(name = "windows")]
6160 extern "system" {
6161 fn DhcpEnumClasses(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY, nread: *mut u32, ntotal: *mut u32) -> u32;
6162 }
6163 ::std::mem::transmute(DhcpEnumClasses(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(classinfoarray), ::std::mem::transmute(nread), ::std::mem::transmute(ntotal)))
6164 }
6165 #[cfg(not(windows))]
6166 unimplemented!("Unsupported target OS");
6167 }
6168 #[cfg(feature = "Win32_Foundation")]
6169 #[inline]
DhcpEnumClassesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u326170 pub unsafe fn DhcpEnumClassesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u32 {
6171 #[cfg(windows)]
6172 {
6173 #[link(name = "windows")]
6174 extern "system" {
6175 fn DhcpEnumClassesV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, resumehandle: *mut u32, preferredmaximum: u32, classinfoarray: *mut *mut DHCP_CLASS_INFO_ARRAY_V6, nread: *mut u32, ntotal: *mut u32) -> u32;
6176 }
6177 ::std::mem::transmute(DhcpEnumClassesV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(classinfoarray), ::std::mem::transmute(nread), ::std::mem::transmute(ntotal)))
6178 }
6179 #[cfg(not(windows))]
6180 unimplemented!("Unsupported target OS");
6181 }
6182 #[cfg(feature = "Win32_Foundation")]
6183 #[inline]
DhcpEnumFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u326184 pub unsafe fn DhcpEnumFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6185 #[cfg(windows)]
6186 {
6187 #[link(name = "windows")]
6188 extern "system" {
6189 fn DhcpEnumFilterV4(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut DHCP_ADDR_PATTERN, preferredmaximum: u32, listtype: DHCP_FILTER_LIST_TYPE, enumfilterinfo: *mut *mut DHCP_FILTER_ENUM_INFO, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6190 }
6191 ::std::mem::transmute(DhcpEnumFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(listtype), ::std::mem::transmute(enumfilterinfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6192 }
6193 #[cfg(not(windows))]
6194 unimplemented!("Unsupported target OS");
6195 }
6196 #[cfg(feature = "Win32_Foundation")]
6197 #[inline]
DhcpEnumOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326198 pub unsafe fn DhcpEnumOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6199 #[cfg(windows)]
6200 {
6201 #[link(name = "windows")]
6202 extern "system" {
6203 fn DhcpEnumOptionValues(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6204 }
6205 ::std::mem::transmute(DhcpEnumOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(optionvalues), ::std::mem::transmute(optionsread), ::std::mem::transmute(optionstotal)))
6206 }
6207 #[cfg(not(windows))]
6208 unimplemented!("Unsupported target OS");
6209 }
6210 #[cfg(feature = "Win32_Foundation")]
6211 #[inline]
DhcpEnumOptionValuesV5<'a, Param0: ::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>>( serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32, ) -> u326212 pub unsafe fn DhcpEnumOptionValuesV5<'a, Param0: ::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>>(
6213 serveripaddress: Param0,
6214 flags: u32,
6215 classname: Param2,
6216 vendorname: Param3,
6217 scopeinfo: *mut DHCP_OPTION_SCOPE_INFO,
6218 resumehandle: *mut u32,
6219 preferredmaximum: u32,
6220 optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY,
6221 optionsread: *mut u32,
6222 optionstotal: *mut u32,
6223 ) -> u32 {
6224 #[cfg(windows)]
6225 {
6226 #[link(name = "windows")]
6227 extern "system" {
6228 fn DhcpEnumOptionValuesV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6229 }
6230 ::std::mem::transmute(DhcpEnumOptionValuesV5(
6231 serveripaddress.into_param().abi(),
6232 ::std::mem::transmute(flags),
6233 classname.into_param().abi(),
6234 vendorname.into_param().abi(),
6235 ::std::mem::transmute(scopeinfo),
6236 ::std::mem::transmute(resumehandle),
6237 ::std::mem::transmute(preferredmaximum),
6238 ::std::mem::transmute(optionvalues),
6239 ::std::mem::transmute(optionsread),
6240 ::std::mem::transmute(optionstotal),
6241 ))
6242 }
6243 #[cfg(not(windows))]
6244 unimplemented!("Unsupported target OS");
6245 }
6246 #[cfg(feature = "Win32_Foundation")]
6247 #[inline]
DhcpEnumOptionValuesV6<'a, Param0: ::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>>( serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32, ) -> u326248 pub unsafe fn DhcpEnumOptionValuesV6<'a, Param0: ::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>>(
6249 serveripaddress: Param0,
6250 flags: u32,
6251 classname: Param2,
6252 vendorname: Param3,
6253 scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6,
6254 resumehandle: *mut u32,
6255 preferredmaximum: u32,
6256 optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY,
6257 optionsread: *mut u32,
6258 optionstotal: *mut u32,
6259 ) -> u32 {
6260 #[cfg(windows)]
6261 {
6262 #[link(name = "windows")]
6263 extern "system" {
6264 fn DhcpEnumOptionValuesV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, resumehandle: *mut u32, preferredmaximum: u32, optionvalues: *mut *mut DHCP_OPTION_VALUE_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6265 }
6266 ::std::mem::transmute(DhcpEnumOptionValuesV6(
6267 serveripaddress.into_param().abi(),
6268 ::std::mem::transmute(flags),
6269 classname.into_param().abi(),
6270 vendorname.into_param().abi(),
6271 ::std::mem::transmute(scopeinfo),
6272 ::std::mem::transmute(resumehandle),
6273 ::std::mem::transmute(preferredmaximum),
6274 ::std::mem::transmute(optionvalues),
6275 ::std::mem::transmute(optionsread),
6276 ::std::mem::transmute(optionstotal),
6277 ))
6278 }
6279 #[cfg(not(windows))]
6280 unimplemented!("Unsupported target OS");
6281 }
6282 #[cfg(feature = "Win32_Foundation")]
6283 #[inline]
DhcpEnumOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326284 pub unsafe fn DhcpEnumOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6285 #[cfg(windows)]
6286 {
6287 #[link(name = "windows")]
6288 extern "system" {
6289 fn DhcpEnumOptions(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6290 }
6291 ::std::mem::transmute(DhcpEnumOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(options), ::std::mem::transmute(optionsread), ::std::mem::transmute(optionstotal)))
6292 }
6293 #[cfg(not(windows))]
6294 unimplemented!("Unsupported target OS");
6295 }
6296 #[cfg(feature = "Win32_Foundation")]
6297 #[inline]
DhcpEnumOptionsV5<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326298 pub unsafe fn DhcpEnumOptionsV5<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6299 #[cfg(windows)]
6300 {
6301 #[link(name = "windows")]
6302 extern "system" {
6303 fn DhcpEnumOptionsV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6304 }
6305 ::std::mem::transmute(DhcpEnumOptionsV5(
6306 serveripaddress.into_param().abi(),
6307 ::std::mem::transmute(flags),
6308 classname.into_param().abi(),
6309 vendorname.into_param().abi(),
6310 ::std::mem::transmute(resumehandle),
6311 ::std::mem::transmute(preferredmaximum),
6312 ::std::mem::transmute(options),
6313 ::std::mem::transmute(optionsread),
6314 ::std::mem::transmute(optionstotal),
6315 ))
6316 }
6317 #[cfg(not(windows))]
6318 unimplemented!("Unsupported target OS");
6319 }
6320 #[cfg(feature = "Win32_Foundation")]
6321 #[inline]
DhcpEnumOptionsV6<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u326322 pub unsafe fn DhcpEnumOptionsV6<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32 {
6323 #[cfg(windows)]
6324 {
6325 #[link(name = "windows")]
6326 extern "system" {
6327 fn DhcpEnumOptionsV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, options: *mut *mut DHCP_OPTION_ARRAY, optionsread: *mut u32, optionstotal: *mut u32) -> u32;
6328 }
6329 ::std::mem::transmute(DhcpEnumOptionsV6(
6330 serveripaddress.into_param().abi(),
6331 ::std::mem::transmute(flags),
6332 classname.into_param().abi(),
6333 vendorname.into_param().abi(),
6334 ::std::mem::transmute(resumehandle),
6335 ::std::mem::transmute(preferredmaximum),
6336 ::std::mem::transmute(options),
6337 ::std::mem::transmute(optionsread),
6338 ::std::mem::transmute(optionstotal),
6339 ))
6340 }
6341 #[cfg(not(windows))]
6342 unimplemented!("Unsupported target OS");
6343 }
6344 #[cfg(feature = "Win32_Foundation")]
6345 #[inline]
DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u326346 pub unsafe fn DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32 {
6347 #[cfg(windows)]
6348 {
6349 #[link(name = "windows")]
6350 extern "system" {
6351 fn DhcpEnumServers(flags: u32, idinfo: *mut ::std::ffi::c_void, servers: *mut *mut DHCPDS_SERVERS, callbackfn: *mut ::std::ffi::c_void, callbackdata: *mut ::std::ffi::c_void) -> u32;
6352 }
6353 ::std::mem::transmute(DhcpEnumServers(::std::mem::transmute(flags), ::std::mem::transmute(idinfo), ::std::mem::transmute(servers), ::std::mem::transmute(callbackfn), ::std::mem::transmute(callbackdata)))
6354 }
6355 #[cfg(not(windows))]
6356 unimplemented!("Unsupported target OS");
6357 }
6358 #[cfg(feature = "Win32_Foundation")]
6359 #[inline]
DhcpEnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u326360 pub unsafe fn DhcpEnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6361 #[cfg(windows)]
6362 {
6363 #[link(name = "windows")]
6364 extern "system" {
6365 fn DhcpEnumSubnetClients(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6366 }
6367 ::std::mem::transmute(DhcpEnumSubnetClients(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6368 }
6369 #[cfg(not(windows))]
6370 unimplemented!("Unsupported target OS");
6371 }
6372 #[cfg(feature = "Win32_Foundation")]
6373 #[inline]
DhcpEnumSubnetClientsFilterStatusInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u326374 pub unsafe fn DhcpEnumSubnetClientsFilterStatusInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6375 #[cfg(windows)]
6376 {
6377 #[link(name = "windows")]
6378 extern "system" {
6379 fn DhcpEnumSubnetClientsFilterStatusInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_FILTER_STATUS_INFO_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6380 }
6381 ::std::mem::transmute(DhcpEnumSubnetClientsFilterStatusInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6382 }
6383 #[cfg(not(windows))]
6384 unimplemented!("Unsupported target OS");
6385 }
6386 #[cfg(feature = "Win32_Foundation")]
6387 #[inline]
DhcpEnumSubnetClientsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u326388 pub unsafe fn DhcpEnumSubnetClientsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6389 #[cfg(windows)]
6390 {
6391 #[link(name = "windows")]
6392 extern "system" {
6393 fn DhcpEnumSubnetClientsV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V4, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6394 }
6395 ::std::mem::transmute(DhcpEnumSubnetClientsV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6396 }
6397 #[cfg(not(windows))]
6398 unimplemented!("Unsupported target OS");
6399 }
6400 #[cfg(feature = "Win32_Foundation")]
6401 #[inline]
DhcpEnumSubnetClientsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u326402 pub unsafe fn DhcpEnumSubnetClientsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6403 #[cfg(windows)]
6404 {
6405 #[link(name = "windows")]
6406 extern "system" {
6407 fn DhcpEnumSubnetClientsV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V5, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6408 }
6409 ::std::mem::transmute(DhcpEnumSubnetClientsV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6410 }
6411 #[cfg(not(windows))]
6412 unimplemented!("Unsupported target OS");
6413 }
6414 #[cfg(feature = "Win32_Foundation")]
6415 #[inline]
DhcpEnumSubnetClientsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u326416 pub unsafe fn DhcpEnumSubnetClientsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6417 #[cfg(windows)]
6418 {
6419 #[link(name = "windows")]
6420 extern "system" {
6421 fn DhcpEnumSubnetClientsV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, resumehandle: *mut DHCP_IPV6_ADDRESS, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_V6, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6422 }
6423 ::std::mem::transmute(DhcpEnumSubnetClientsV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6424 }
6425 #[cfg(not(windows))]
6426 unimplemented!("Unsupported target OS");
6427 }
6428 #[cfg(feature = "Win32_Foundation")]
6429 #[inline]
DhcpEnumSubnetClientsVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u326430 pub unsafe fn DhcpEnumSubnetClientsVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
6431 #[cfg(windows)]
6432 {
6433 #[link(name = "windows")]
6434 extern "system" {
6435 fn DhcpEnumSubnetClientsVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_ARRAY_VQ, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
6436 }
6437 ::std::mem::transmute(DhcpEnumSubnetClientsVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
6438 }
6439 #[cfg(not(windows))]
6440 unimplemented!("Unsupported target OS");
6441 }
6442 #[cfg(feature = "Win32_Foundation")]
6443 #[inline]
DhcpEnumSubnetElements<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326444 pub unsafe fn DhcpEnumSubnetElements<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6445 #[cfg(windows)]
6446 {
6447 #[link(name = "windows")]
6448 extern "system" {
6449 fn DhcpEnumSubnetElements(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6450 }
6451 ::std::mem::transmute(DhcpEnumSubnetElements(
6452 serveripaddress.into_param().abi(),
6453 ::std::mem::transmute(subnetaddress),
6454 ::std::mem::transmute(enumelementtype),
6455 ::std::mem::transmute(resumehandle),
6456 ::std::mem::transmute(preferredmaximum),
6457 ::std::mem::transmute(enumelementinfo),
6458 ::std::mem::transmute(elementsread),
6459 ::std::mem::transmute(elementstotal),
6460 ))
6461 }
6462 #[cfg(not(windows))]
6463 unimplemented!("Unsupported target OS");
6464 }
6465 #[cfg(feature = "Win32_Foundation")]
6466 #[inline]
DhcpEnumSubnetElementsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u326467 pub unsafe fn DhcpEnumSubnetElementsV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6468 #[cfg(windows)]
6469 {
6470 #[link(name = "windows")]
6471 extern "system" {
6472 fn DhcpEnumSubnetElementsV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V4, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6473 }
6474 ::std::mem::transmute(DhcpEnumSubnetElementsV4(
6475 serveripaddress.into_param().abi(),
6476 ::std::mem::transmute(subnetaddress),
6477 ::std::mem::transmute(enumelementtype),
6478 ::std::mem::transmute(resumehandle),
6479 ::std::mem::transmute(preferredmaximum),
6480 ::std::mem::transmute(enumelementinfo),
6481 ::std::mem::transmute(elementsread),
6482 ::std::mem::transmute(elementstotal),
6483 ))
6484 }
6485 #[cfg(not(windows))]
6486 unimplemented!("Unsupported target OS");
6487 }
6488 #[cfg(feature = "Win32_Foundation")]
6489 #[inline]
DhcpEnumSubnetElementsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u326490 pub unsafe fn DhcpEnumSubnetElementsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6491 #[cfg(windows)]
6492 {
6493 #[link(name = "windows")]
6494 extern "system" {
6495 fn DhcpEnumSubnetElementsV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V5, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6496 }
6497 ::std::mem::transmute(DhcpEnumSubnetElementsV5(
6498 serveripaddress.into_param().abi(),
6499 ::std::mem::transmute(subnetaddress),
6500 ::std::mem::transmute(enumelementtype),
6501 ::std::mem::transmute(resumehandle),
6502 ::std::mem::transmute(preferredmaximum),
6503 ::std::mem::transmute(enumelementinfo),
6504 ::std::mem::transmute(elementsread),
6505 ::std::mem::transmute(elementstotal),
6506 ))
6507 }
6508 #[cfg(not(windows))]
6509 unimplemented!("Unsupported target OS");
6510 }
6511 #[cfg(feature = "Win32_Foundation")]
6512 #[inline]
DhcpEnumSubnetElementsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u326513 pub unsafe fn DhcpEnumSubnetElementsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6514 #[cfg(windows)]
6515 {
6516 #[link(name = "windows")]
6517 extern "system" {
6518 fn DhcpEnumSubnetElementsV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, enumelementtype: DHCP_SUBNET_ELEMENT_TYPE_V6, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_SUBNET_ELEMENT_INFO_ARRAY_V6, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6519 }
6520 ::std::mem::transmute(DhcpEnumSubnetElementsV6(
6521 serveripaddress.into_param().abi(),
6522 subnetaddress.into_param().abi(),
6523 ::std::mem::transmute(enumelementtype),
6524 ::std::mem::transmute(resumehandle),
6525 ::std::mem::transmute(preferredmaximum),
6526 ::std::mem::transmute(enumelementinfo),
6527 ::std::mem::transmute(elementsread),
6528 ::std::mem::transmute(elementstotal),
6529 ))
6530 }
6531 #[cfg(not(windows))]
6532 unimplemented!("Unsupported target OS");
6533 }
6534 #[cfg(feature = "Win32_Foundation")]
6535 #[inline]
DhcpEnumSubnets<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326536 pub unsafe fn DhcpEnumSubnets<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6537 #[cfg(windows)]
6538 {
6539 #[link(name = "windows")]
6540 extern "system" {
6541 fn DhcpEnumSubnets(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCP_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6542 }
6543 ::std::mem::transmute(DhcpEnumSubnets(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enuminfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6544 }
6545 #[cfg(not(windows))]
6546 unimplemented!("Unsupported target OS");
6547 }
6548 #[cfg(feature = "Win32_Foundation")]
6549 #[inline]
DhcpEnumSubnetsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u326550 pub unsafe fn DhcpEnumSubnetsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
6551 #[cfg(windows)]
6552 {
6553 #[link(name = "windows")]
6554 extern "system" {
6555 fn DhcpEnumSubnetsV6(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, enuminfo: *mut *mut DHCPV6_IP_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
6556 }
6557 ::std::mem::transmute(DhcpEnumSubnetsV6(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enuminfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
6558 }
6559 #[cfg(not(windows))]
6560 unimplemented!("Unsupported target OS");
6561 }
6562 #[cfg(feature = "Win32_Foundation")]
6563 #[inline]
DhcpGetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u326564 pub unsafe fn DhcpGetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32 {
6565 #[cfg(windows)]
6566 {
6567 #[link(name = "windows")]
6568 extern "system" {
6569 fn DhcpGetAllOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32;
6570 }
6571 ::std::mem::transmute(DhcpGetAllOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
6572 }
6573 #[cfg(not(windows))]
6574 unimplemented!("Unsupported target OS");
6575 }
6576 #[cfg(feature = "Win32_Foundation")]
6577 #[inline]
DhcpGetAllOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u326578 pub unsafe fn DhcpGetAllOptionValuesV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32 {
6579 #[cfg(windows)]
6580 {
6581 #[link(name = "windows")]
6582 extern "system" {
6583 fn DhcpGetAllOptionValuesV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, values: *mut *mut DHCP_ALL_OPTION_VALUES) -> u32;
6584 }
6585 ::std::mem::transmute(DhcpGetAllOptionValuesV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
6586 }
6587 #[cfg(not(windows))]
6588 unimplemented!("Unsupported target OS");
6589 }
6590 #[cfg(feature = "Win32_Foundation")]
6591 #[inline]
DhcpGetAllOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u326592 pub unsafe fn DhcpGetAllOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32 {
6593 #[cfg(windows)]
6594 {
6595 #[link(name = "windows")]
6596 extern "system" {
6597 fn DhcpGetAllOptions(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32;
6598 }
6599 ::std::mem::transmute(DhcpGetAllOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionstruct)))
6600 }
6601 #[cfg(not(windows))]
6602 unimplemented!("Unsupported target OS");
6603 }
6604 #[cfg(feature = "Win32_Foundation")]
6605 #[inline]
DhcpGetAllOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u326606 pub unsafe fn DhcpGetAllOptionsV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32 {
6607 #[cfg(windows)]
6608 {
6609 #[link(name = "windows")]
6610 extern "system" {
6611 fn DhcpGetAllOptionsV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionstruct: *mut *mut DHCP_ALL_OPTIONS) -> u32;
6612 }
6613 ::std::mem::transmute(DhcpGetAllOptionsV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionstruct)))
6614 }
6615 #[cfg(not(windows))]
6616 unimplemented!("Unsupported target OS");
6617 }
6618 #[cfg(feature = "Win32_Foundation")]
6619 #[inline]
DhcpGetClassInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u326620 pub unsafe fn DhcpGetClassInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u32 {
6621 #[cfg(windows)]
6622 {
6623 #[link(name = "windows")]
6624 extern "system" {
6625 fn DhcpGetClassInfo(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, partialclassinfo: *mut DHCP_CLASS_INFO, filledclassinfo: *mut *mut DHCP_CLASS_INFO) -> u32;
6626 }
6627 ::std::mem::transmute(DhcpGetClassInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(partialclassinfo), ::std::mem::transmute(filledclassinfo)))
6628 }
6629 #[cfg(not(windows))]
6630 unimplemented!("Unsupported target OS");
6631 }
6632 #[cfg(feature = "Win32_Foundation")]
6633 #[inline]
DhcpGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u326634 pub unsafe fn DhcpGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u32 {
6635 #[cfg(windows)]
6636 {
6637 #[link(name = "windows")]
6638 extern "system" {
6639 fn DhcpGetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO) -> u32;
6640 }
6641 ::std::mem::transmute(DhcpGetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6642 }
6643 #[cfg(not(windows))]
6644 unimplemented!("Unsupported target OS");
6645 }
6646 #[cfg(feature = "Win32_Foundation")]
6647 #[inline]
DhcpGetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u326648 pub unsafe fn DhcpGetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u32 {
6649 #[cfg(windows)]
6650 {
6651 #[link(name = "windows")]
6652 extern "system" {
6653 fn DhcpGetClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_V4) -> u32;
6654 }
6655 ::std::mem::transmute(DhcpGetClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6656 }
6657 #[cfg(not(windows))]
6658 unimplemented!("Unsupported target OS");
6659 }
6660 #[cfg(feature = "Win32_Foundation")]
6661 #[inline]
DhcpGetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u326662 pub unsafe fn DhcpGetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u32 {
6663 #[cfg(windows)]
6664 {
6665 #[link(name = "windows")]
6666 extern "system" {
6667 fn DhcpGetClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO_V6, clientinfo: *mut *mut DHCP_CLIENT_INFO_V6) -> u32;
6668 }
6669 ::std::mem::transmute(DhcpGetClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6670 }
6671 #[cfg(not(windows))]
6672 unimplemented!("Unsupported target OS");
6673 }
6674 #[cfg(feature = "Win32_Foundation")]
6675 #[inline]
DhcpGetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u326676 pub unsafe fn DhcpGetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u32 {
6677 #[cfg(windows)]
6678 {
6679 #[link(name = "windows")]
6680 extern "system" {
6681 fn DhcpGetClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_VQ) -> u32;
6682 }
6683 ::std::mem::transmute(DhcpGetClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
6684 }
6685 #[cfg(not(windows))]
6686 unimplemented!("Unsupported target OS");
6687 }
6688 #[cfg(feature = "Win32_Foundation")]
6689 #[inline]
DhcpGetClientOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u326690 pub unsafe fn DhcpGetClientOptions<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u32 {
6691 #[cfg(windows)]
6692 {
6693 #[link(name = "windows")]
6694 extern "system" {
6695 fn DhcpGetClientOptions(serveripaddress: super::super::Foundation::PWSTR, clientipaddress: u32, clientsubnetmask: u32, clientoptions: *mut *mut DHCP_OPTION_LIST) -> u32;
6696 }
6697 ::std::mem::transmute(DhcpGetClientOptions(serveripaddress.into_param().abi(), ::std::mem::transmute(clientipaddress), ::std::mem::transmute(clientsubnetmask), ::std::mem::transmute(clientoptions)))
6698 }
6699 #[cfg(not(windows))]
6700 unimplemented!("Unsupported target OS");
6701 }
6702 #[cfg(feature = "Win32_Foundation")]
6703 #[inline]
DhcpGetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u326704 pub unsafe fn DhcpGetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u32 {
6705 #[cfg(windows)]
6706 {
6707 #[link(name = "windows")]
6708 extern "system" {
6709 fn DhcpGetFilterV4(serveripaddress: super::super::Foundation::PWSTR, globalfilterinfo: *mut DHCP_FILTER_GLOBAL_INFO) -> u32;
6710 }
6711 ::std::mem::transmute(DhcpGetFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(globalfilterinfo)))
6712 }
6713 #[cfg(not(windows))]
6714 unimplemented!("Unsupported target OS");
6715 }
6716 #[cfg(feature = "Win32_Foundation")]
6717 #[inline]
DhcpGetMibInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO) -> u326718 pub unsafe fn DhcpGetMibInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO) -> u32 {
6719 #[cfg(windows)]
6720 {
6721 #[link(name = "windows")]
6722 extern "system" {
6723 fn DhcpGetMibInfo(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO) -> u32;
6724 }
6725 ::std::mem::transmute(DhcpGetMibInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6726 }
6727 #[cfg(not(windows))]
6728 unimplemented!("Unsupported target OS");
6729 }
6730 #[cfg(feature = "Win32_Foundation")]
6731 #[inline]
DhcpGetMibInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u326732 pub unsafe fn DhcpGetMibInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u32 {
6733 #[cfg(windows)]
6734 {
6735 #[link(name = "windows")]
6736 extern "system" {
6737 fn DhcpGetMibInfoV5(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO_V5) -> u32;
6738 }
6739 ::std::mem::transmute(DhcpGetMibInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6740 }
6741 #[cfg(not(windows))]
6742 unimplemented!("Unsupported target OS");
6743 }
6744 #[cfg(feature = "Win32_Foundation")]
6745 #[inline]
DhcpGetMibInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u326746 pub unsafe fn DhcpGetMibInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u32 {
6747 #[cfg(windows)]
6748 {
6749 #[link(name = "windows")]
6750 extern "system" {
6751 fn DhcpGetMibInfoV6(serveripaddress: super::super::Foundation::PWSTR, mibinfo: *mut *mut DHCP_MIB_INFO_V6) -> u32;
6752 }
6753 ::std::mem::transmute(DhcpGetMibInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(mibinfo)))
6754 }
6755 #[cfg(not(windows))]
6756 unimplemented!("Unsupported target OS");
6757 }
6758 #[cfg(feature = "Win32_Foundation")]
6759 #[inline]
DhcpGetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u326760 pub unsafe fn DhcpGetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6761 #[cfg(windows)]
6762 {
6763 #[link(name = "windows")]
6764 extern "system" {
6765 fn DhcpGetOptionInfo(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6766 }
6767 ::std::mem::transmute(DhcpGetOptionInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
6768 }
6769 #[cfg(not(windows))]
6770 unimplemented!("Unsupported target OS");
6771 }
6772 #[cfg(feature = "Win32_Foundation")]
6773 #[inline]
DhcpGetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u326774 pub unsafe fn DhcpGetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6775 #[cfg(windows)]
6776 {
6777 #[link(name = "windows")]
6778 extern "system" {
6779 fn DhcpGetOptionInfoV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6780 }
6781 ::std::mem::transmute(DhcpGetOptionInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
6782 }
6783 #[cfg(not(windows))]
6784 unimplemented!("Unsupported target OS");
6785 }
6786 #[cfg(feature = "Win32_Foundation")]
6787 #[inline]
DhcpGetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u326788 pub unsafe fn DhcpGetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut *mut DHCP_OPTION) -> u32 {
6789 #[cfg(windows)]
6790 {
6791 #[link(name = "windows")]
6792 extern "system" {
6793 fn DhcpGetOptionInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut *mut DHCP_OPTION) -> u32;
6794 }
6795 ::std::mem::transmute(DhcpGetOptionInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
6796 }
6797 #[cfg(not(windows))]
6798 unimplemented!("Unsupported target OS");
6799 }
6800 #[cfg(feature = "Win32_Foundation")]
6801 #[inline]
DhcpGetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326802 pub unsafe fn DhcpGetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6803 #[cfg(windows)]
6804 {
6805 #[link(name = "windows")]
6806 extern "system" {
6807 fn DhcpGetOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6808 }
6809 ::std::mem::transmute(DhcpGetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6810 }
6811 #[cfg(not(windows))]
6812 unimplemented!("Unsupported target OS");
6813 }
6814 #[cfg(feature = "Win32_Foundation")]
6815 #[inline]
DhcpGetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326816 pub unsafe fn DhcpGetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6817 #[cfg(windows)]
6818 {
6819 #[link(name = "windows")]
6820 extern "system" {
6821 fn DhcpGetOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6822 }
6823 ::std::mem::transmute(DhcpGetOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6824 }
6825 #[cfg(not(windows))]
6826 unimplemented!("Unsupported target OS");
6827 }
6828 #[cfg(feature = "Win32_Foundation")]
6829 #[inline]
DhcpGetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u326830 pub unsafe fn DhcpGetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
6831 #[cfg(windows)]
6832 {
6833 #[link(name = "windows")]
6834 extern "system" {
6835 fn DhcpGetOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
6836 }
6837 ::std::mem::transmute(DhcpGetOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
6838 }
6839 #[cfg(not(windows))]
6840 unimplemented!("Unsupported target OS");
6841 }
6842 #[cfg(feature = "Win32_Foundation")]
6843 #[inline]
DhcpGetOriginalSubnetMask<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(sadaptername: Param0, dwsubnetmask: *mut u32) -> u326844 pub unsafe fn DhcpGetOriginalSubnetMask<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(sadaptername: Param0, dwsubnetmask: *mut u32) -> u32 {
6845 #[cfg(windows)]
6846 {
6847 #[link(name = "windows")]
6848 extern "system" {
6849 fn DhcpGetOriginalSubnetMask(sadaptername: super::super::Foundation::PWSTR, dwsubnetmask: *mut u32) -> u32;
6850 }
6851 ::std::mem::transmute(DhcpGetOriginalSubnetMask(sadaptername.into_param().abi(), ::std::mem::transmute(dwsubnetmask)))
6852 }
6853 #[cfg(not(windows))]
6854 unimplemented!("Unsupported target OS");
6855 }
6856 #[cfg(feature = "Win32_Foundation")]
6857 #[inline]
DhcpGetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u326858 pub unsafe fn DhcpGetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u32 {
6859 #[cfg(windows)]
6860 {
6861 #[link(name = "windows")]
6862 extern "system" {
6863 fn DhcpGetServerBindingInfo(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementsinfo: *mut *mut DHCP_BIND_ELEMENT_ARRAY) -> u32;
6864 }
6865 ::std::mem::transmute(DhcpGetServerBindingInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementsinfo)))
6866 }
6867 #[cfg(not(windows))]
6868 unimplemented!("Unsupported target OS");
6869 }
6870 #[cfg(feature = "Win32_Foundation")]
6871 #[inline]
DhcpGetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u326872 pub unsafe fn DhcpGetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32 {
6873 #[cfg(windows)]
6874 {
6875 #[link(name = "windows")]
6876 extern "system" {
6877 fn DhcpGetServerBindingInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementsinfo: *mut *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32;
6878 }
6879 ::std::mem::transmute(DhcpGetServerBindingInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementsinfo)))
6880 }
6881 #[cfg(not(windows))]
6882 unimplemented!("Unsupported target OS");
6883 }
6884 #[cfg(feature = "Win32_Foundation")]
6885 #[inline]
DhcpGetServerSpecificStrings<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u326886 pub unsafe fn DhcpGetServerSpecificStrings<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u32 {
6887 #[cfg(windows)]
6888 {
6889 #[link(name = "windows")]
6890 extern "system" {
6891 fn DhcpGetServerSpecificStrings(serveripaddress: super::super::Foundation::PWSTR, serverspecificstrings: *mut *mut DHCP_SERVER_SPECIFIC_STRINGS) -> u32;
6892 }
6893 ::std::mem::transmute(DhcpGetServerSpecificStrings(serveripaddress.into_param().abi(), ::std::mem::transmute(serverspecificstrings)))
6894 }
6895 #[cfg(not(windows))]
6896 unimplemented!("Unsupported target OS");
6897 }
6898 #[cfg(feature = "Win32_Foundation")]
6899 #[inline]
DhcpGetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u326900 pub unsafe fn DhcpGetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u32 {
6901 #[cfg(windows)]
6902 {
6903 #[link(name = "windows")]
6904 extern "system" {
6905 fn DhcpGetSubnetDelayOffer(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, timedelayinmilliseconds: *mut u16) -> u32;
6906 }
6907 ::std::mem::transmute(DhcpGetSubnetDelayOffer(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(timedelayinmilliseconds)))
6908 }
6909 #[cfg(not(windows))]
6910 unimplemented!("Unsupported target OS");
6911 }
6912 #[cfg(feature = "Win32_Foundation")]
6913 #[inline]
DhcpGetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u326914 pub unsafe fn DhcpGetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u32 {
6915 #[cfg(windows)]
6916 {
6917 #[link(name = "windows")]
6918 extern "system" {
6919 fn DhcpGetSubnetInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO) -> u32;
6920 }
6921 ::std::mem::transmute(DhcpGetSubnetInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
6922 }
6923 #[cfg(not(windows))]
6924 unimplemented!("Unsupported target OS");
6925 }
6926 #[cfg(feature = "Win32_Foundation")]
6927 #[inline]
DhcpGetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u326928 pub unsafe fn DhcpGetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u32 {
6929 #[cfg(windows)]
6930 {
6931 #[link(name = "windows")]
6932 extern "system" {
6933 fn DhcpGetSubnetInfoV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut *mut DHCP_SUBNET_INFO_V6) -> u32;
6934 }
6935 ::std::mem::transmute(DhcpGetSubnetInfoV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
6936 }
6937 #[cfg(not(windows))]
6938 unimplemented!("Unsupported target OS");
6939 }
6940 #[cfg(feature = "Win32_Foundation")]
6941 #[inline]
DhcpGetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u326942 pub unsafe fn DhcpGetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u32 {
6943 #[cfg(windows)]
6944 {
6945 #[link(name = "windows")]
6946 extern "system" {
6947 fn DhcpGetSubnetInfoVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *mut *mut DHCP_SUBNET_INFO_VQ) -> u32;
6948 }
6949 ::std::mem::transmute(DhcpGetSubnetInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
6950 }
6951 #[cfg(not(windows))]
6952 unimplemented!("Unsupported target OS");
6953 }
6954 #[cfg(feature = "Win32_Foundation")]
6955 #[inline]
DhcpGetSuperScopeInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u326956 pub unsafe fn DhcpGetSuperScopeInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u32 {
6957 #[cfg(windows)]
6958 {
6959 #[link(name = "windows")]
6960 extern "system" {
6961 fn DhcpGetSuperScopeInfoV4(serveripaddress: super::super::Foundation::PWSTR, superscopetable: *mut *mut DHCP_SUPER_SCOPE_TABLE) -> u32;
6962 }
6963 ::std::mem::transmute(DhcpGetSuperScopeInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(superscopetable)))
6964 }
6965 #[cfg(not(windows))]
6966 unimplemented!("Unsupported target OS");
6967 }
6968 #[inline]
DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u326969 pub unsafe fn DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u32 {
6970 #[cfg(windows)]
6971 {
6972 #[link(name = "windows")]
6973 extern "system" {
6974 fn DhcpGetThreadOptions(pflags: *mut u32, reserved: *mut ::std::ffi::c_void) -> u32;
6975 }
6976 ::std::mem::transmute(DhcpGetThreadOptions(::std::mem::transmute(pflags), ::std::mem::transmute(reserved)))
6977 }
6978 #[cfg(not(windows))]
6979 unimplemented!("Unsupported target OS");
6980 }
6981 #[cfg(feature = "Win32_Foundation")]
6982 #[inline]
DhcpGetVersion<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, majorversion: *mut u32, minorversion: *mut u32) -> u326983 pub unsafe fn DhcpGetVersion<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, majorversion: *mut u32, minorversion: *mut u32) -> u32 {
6984 #[cfg(windows)]
6985 {
6986 #[link(name = "windows")]
6987 extern "system" {
6988 fn DhcpGetVersion(serveripaddress: super::super::Foundation::PWSTR, majorversion: *mut u32, minorversion: *mut u32) -> u32;
6989 }
6990 ::std::mem::transmute(DhcpGetVersion(serveripaddress.into_param().abi(), ::std::mem::transmute(majorversion), ::std::mem::transmute(minorversion)))
6991 }
6992 #[cfg(not(windows))]
6993 unimplemented!("Unsupported target OS");
6994 }
6995 #[cfg(feature = "Win32_Foundation")]
6996 #[inline]
DhcpHlprAddV4PolicyCondition<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: Param5, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u326997 pub unsafe fn DhcpHlprAddV4PolicyCondition<'a, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: Param5, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u32 {
6998 #[cfg(windows)]
6999 {
7000 #[link(name = "windows")]
7001 extern "system" {
7002 fn DhcpHlprAddV4PolicyCondition(policy: *mut DHCP_POLICY, parentexpr: u32, r#type: DHCP_POL_ATTR_TYPE, optionid: u32, suboptionid: u32, vendorname: super::super::Foundation::PWSTR, operator: DHCP_POL_COMPARATOR, value: *const u8, valuelength: u32, conditionindex: *mut u32) -> u32;
7003 }
7004 ::std::mem::transmute(DhcpHlprAddV4PolicyCondition(
7005 ::std::mem::transmute(policy),
7006 ::std::mem::transmute(parentexpr),
7007 ::std::mem::transmute(r#type),
7008 ::std::mem::transmute(optionid),
7009 ::std::mem::transmute(suboptionid),
7010 vendorname.into_param().abi(),
7011 ::std::mem::transmute(operator),
7012 ::std::mem::transmute(value),
7013 ::std::mem::transmute(valuelength),
7014 ::std::mem::transmute(conditionindex),
7015 ))
7016 }
7017 #[cfg(not(windows))]
7018 unimplemented!("Unsupported target OS");
7019 }
7020 #[cfg(feature = "Win32_Foundation")]
7021 #[inline]
DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u327022 pub unsafe fn DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u32 {
7023 #[cfg(windows)]
7024 {
7025 #[link(name = "windows")]
7026 extern "system" {
7027 fn DhcpHlprAddV4PolicyExpr(policy: *mut DHCP_POLICY, parentexpr: u32, operator: DHCP_POL_LOGIC_OPER, exprindex: *mut u32) -> u32;
7028 }
7029 ::std::mem::transmute(DhcpHlprAddV4PolicyExpr(::std::mem::transmute(policy), ::std::mem::transmute(parentexpr), ::std::mem::transmute(operator), ::std::mem::transmute(exprindex)))
7030 }
7031 #[cfg(not(windows))]
7032 unimplemented!("Unsupported target OS");
7033 }
7034 #[cfg(feature = "Win32_Foundation")]
7035 #[inline]
DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u327036 pub unsafe fn DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u32 {
7037 #[cfg(windows)]
7038 {
7039 #[link(name = "windows")]
7040 extern "system" {
7041 fn DhcpHlprAddV4PolicyRange(policy: *mut DHCP_POLICY, range: *const DHCP_IP_RANGE) -> u32;
7042 }
7043 ::std::mem::transmute(DhcpHlprAddV4PolicyRange(::std::mem::transmute(policy), ::std::mem::transmute(range)))
7044 }
7045 #[cfg(not(windows))]
7046 unimplemented!("Unsupported target OS");
7047 }
7048 #[cfg(feature = "Win32_Foundation")]
7049 #[inline]
DhcpHlprCreateV4Policy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( policyname: Param0, fglobalpolicy: Param1, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: Param5, enabled: Param6, policy: *mut *mut DHCP_POLICY, ) -> u327050 pub unsafe fn DhcpHlprCreateV4Policy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
7051 policyname: Param0,
7052 fglobalpolicy: Param1,
7053 subnet: u32,
7054 processingorder: u32,
7055 rootoperator: DHCP_POL_LOGIC_OPER,
7056 description: Param5,
7057 enabled: Param6,
7058 policy: *mut *mut DHCP_POLICY,
7059 ) -> u32 {
7060 #[cfg(windows)]
7061 {
7062 #[link(name = "windows")]
7063 extern "system" {
7064 fn DhcpHlprCreateV4Policy(policyname: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: super::super::Foundation::PWSTR, enabled: super::super::Foundation::BOOL, policy: *mut *mut DHCP_POLICY) -> u32;
7065 }
7066 ::std::mem::transmute(DhcpHlprCreateV4Policy(policyname.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnet), ::std::mem::transmute(processingorder), ::std::mem::transmute(rootoperator), description.into_param().abi(), enabled.into_param().abi(), ::std::mem::transmute(policy)))
7067 }
7068 #[cfg(not(windows))]
7069 unimplemented!("Unsupported target OS");
7070 }
7071 #[cfg(feature = "Win32_Foundation")]
7072 #[inline]
DhcpHlprCreateV4PolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>( policyname: Param0, fglobalpolicy: Param1, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: Param5, enabled: Param6, policy: *mut *mut DHCP_POLICY_EX, ) -> u327073 pub unsafe fn DhcpHlprCreateV4PolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(
7074 policyname: Param0,
7075 fglobalpolicy: Param1,
7076 subnet: u32,
7077 processingorder: u32,
7078 rootoperator: DHCP_POL_LOGIC_OPER,
7079 description: Param5,
7080 enabled: Param6,
7081 policy: *mut *mut DHCP_POLICY_EX,
7082 ) -> u32 {
7083 #[cfg(windows)]
7084 {
7085 #[link(name = "windows")]
7086 extern "system" {
7087 fn DhcpHlprCreateV4PolicyEx(policyname: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnet: u32, processingorder: u32, rootoperator: DHCP_POL_LOGIC_OPER, description: super::super::Foundation::PWSTR, enabled: super::super::Foundation::BOOL, policy: *mut *mut DHCP_POLICY_EX) -> u32;
7088 }
7089 ::std::mem::transmute(DhcpHlprCreateV4PolicyEx(policyname.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnet), ::std::mem::transmute(processingorder), ::std::mem::transmute(rootoperator), description.into_param().abi(), enabled.into_param().abi(), ::std::mem::transmute(policy)))
7090 }
7091 #[cfg(not(windows))]
7092 unimplemented!("Unsupported target OS");
7093 }
7094 #[cfg(feature = "Win32_Foundation")]
7095 #[inline]
DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY7096 pub unsafe fn DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY {
7097 #[cfg(windows)]
7098 {
7099 #[link(name = "windows")]
7100 extern "system" {
7101 fn DhcpHlprFindV4DhcpProperty(propertyarray: *const DHCP_PROPERTY_ARRAY, id: DHCP_PROPERTY_ID, r#type: DHCP_PROPERTY_TYPE) -> *mut DHCP_PROPERTY;
7102 }
7103 ::std::mem::transmute(DhcpHlprFindV4DhcpProperty(::std::mem::transmute(propertyarray), ::std::mem::transmute(id), ::std::mem::transmute(r#type)))
7104 }
7105 #[cfg(not(windows))]
7106 unimplemented!("Unsupported target OS");
7107 }
7108 #[cfg(feature = "Win32_Foundation")]
7109 #[inline]
DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY)7110 pub unsafe fn DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY) {
7111 #[cfg(windows)]
7112 {
7113 #[link(name = "windows")]
7114 extern "system" {
7115 fn DhcpHlprFreeV4DhcpProperty(property: *mut DHCP_PROPERTY);
7116 }
7117 ::std::mem::transmute(DhcpHlprFreeV4DhcpProperty(::std::mem::transmute(property)))
7118 }
7119 #[cfg(not(windows))]
7120 unimplemented!("Unsupported target OS");
7121 }
7122 #[cfg(feature = "Win32_Foundation")]
7123 #[inline]
DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY)7124 pub unsafe fn DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY) {
7125 #[cfg(windows)]
7126 {
7127 #[link(name = "windows")]
7128 extern "system" {
7129 fn DhcpHlprFreeV4DhcpPropertyArray(propertyarray: *mut DHCP_PROPERTY_ARRAY);
7130 }
7131 ::std::mem::transmute(DhcpHlprFreeV4DhcpPropertyArray(::std::mem::transmute(propertyarray)))
7132 }
7133 #[cfg(not(windows))]
7134 unimplemented!("Unsupported target OS");
7135 }
7136 #[cfg(feature = "Win32_Foundation")]
7137 #[inline]
DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY)7138 pub unsafe fn DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY) {
7139 #[cfg(windows)]
7140 {
7141 #[link(name = "windows")]
7142 extern "system" {
7143 fn DhcpHlprFreeV4Policy(policy: *mut DHCP_POLICY);
7144 }
7145 ::std::mem::transmute(DhcpHlprFreeV4Policy(::std::mem::transmute(policy)))
7146 }
7147 #[cfg(not(windows))]
7148 unimplemented!("Unsupported target OS");
7149 }
7150 #[cfg(feature = "Win32_Foundation")]
7151 #[inline]
DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY)7152 pub unsafe fn DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY) {
7153 #[cfg(windows)]
7154 {
7155 #[link(name = "windows")]
7156 extern "system" {
7157 fn DhcpHlprFreeV4PolicyArray(policyarray: *mut DHCP_POLICY_ARRAY);
7158 }
7159 ::std::mem::transmute(DhcpHlprFreeV4PolicyArray(::std::mem::transmute(policyarray)))
7160 }
7161 #[cfg(not(windows))]
7162 unimplemented!("Unsupported target OS");
7163 }
7164 #[cfg(feature = "Win32_Foundation")]
7165 #[inline]
DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX)7166 pub unsafe fn DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX) {
7167 #[cfg(windows)]
7168 {
7169 #[link(name = "windows")]
7170 extern "system" {
7171 fn DhcpHlprFreeV4PolicyEx(policyex: *mut DHCP_POLICY_EX);
7172 }
7173 ::std::mem::transmute(DhcpHlprFreeV4PolicyEx(::std::mem::transmute(policyex)))
7174 }
7175 #[cfg(not(windows))]
7176 unimplemented!("Unsupported target OS");
7177 }
7178 #[cfg(feature = "Win32_Foundation")]
7179 #[inline]
DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY)7180 pub unsafe fn DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY) {
7181 #[cfg(windows)]
7182 {
7183 #[link(name = "windows")]
7184 extern "system" {
7185 fn DhcpHlprFreeV4PolicyExArray(policyexarray: *mut DHCP_POLICY_EX_ARRAY);
7186 }
7187 ::std::mem::transmute(DhcpHlprFreeV4PolicyExArray(::std::mem::transmute(policyexarray)))
7188 }
7189 #[cfg(not(windows))]
7190 unimplemented!("Unsupported target OS");
7191 }
7192 #[cfg(feature = "Win32_Foundation")]
7193 #[inline]
DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL7194 pub unsafe fn DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL {
7195 #[cfg(windows)]
7196 {
7197 #[link(name = "windows")]
7198 extern "system" {
7199 fn DhcpHlprIsV4PolicySingleUC(policy: *const DHCP_POLICY) -> super::super::Foundation::BOOL;
7200 }
7201 ::std::mem::transmute(DhcpHlprIsV4PolicySingleUC(::std::mem::transmute(policy)))
7202 }
7203 #[cfg(not(windows))]
7204 unimplemented!("Unsupported target OS");
7205 }
7206 #[cfg(feature = "Win32_Foundation")]
7207 #[inline]
DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u327208 pub unsafe fn DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u32 {
7209 #[cfg(windows)]
7210 {
7211 #[link(name = "windows")]
7212 extern "system" {
7213 fn DhcpHlprIsV4PolicyValid(ppolicy: *const DHCP_POLICY) -> u32;
7214 }
7215 ::std::mem::transmute(DhcpHlprIsV4PolicyValid(::std::mem::transmute(ppolicy)))
7216 }
7217 #[cfg(not(windows))]
7218 unimplemented!("Unsupported target OS");
7219 }
7220 #[cfg(feature = "Win32_Foundation")]
7221 #[inline]
DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL7222 pub unsafe fn DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL {
7223 #[cfg(windows)]
7224 {
7225 #[link(name = "windows")]
7226 extern "system" {
7227 fn DhcpHlprIsV4PolicyWellFormed(ppolicy: *const DHCP_POLICY) -> super::super::Foundation::BOOL;
7228 }
7229 ::std::mem::transmute(DhcpHlprIsV4PolicyWellFormed(::std::mem::transmute(ppolicy)))
7230 }
7231 #[cfg(not(windows))]
7232 unimplemented!("Unsupported target OS");
7233 }
7234 #[cfg(feature = "Win32_Foundation")]
7235 #[inline]
DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u327236 pub unsafe fn DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u32 {
7237 #[cfg(windows)]
7238 {
7239 #[link(name = "windows")]
7240 extern "system" {
7241 fn DhcpHlprModifyV4PolicyExpr(policy: *mut DHCP_POLICY, operator: DHCP_POL_LOGIC_OPER) -> u32;
7242 }
7243 ::std::mem::transmute(DhcpHlprModifyV4PolicyExpr(::std::mem::transmute(policy), ::std::mem::transmute(operator)))
7244 }
7245 #[cfg(not(windows))]
7246 unimplemented!("Unsupported target OS");
7247 }
7248 #[cfg(feature = "Win32_Foundation")]
7249 #[inline]
DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u327250 pub unsafe fn DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u32 {
7251 #[cfg(windows)]
7252 {
7253 #[link(name = "windows")]
7254 extern "system" {
7255 fn DhcpHlprResetV4PolicyExpr(policy: *mut DHCP_POLICY) -> u32;
7256 }
7257 ::std::mem::transmute(DhcpHlprResetV4PolicyExpr(::std::mem::transmute(policy)))
7258 }
7259 #[cfg(not(windows))]
7260 unimplemented!("Unsupported target OS");
7261 }
7262 #[cfg(feature = "Win32_Foundation")]
7263 #[inline]
DhcpModifyClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u327264 pub unsafe fn DhcpModifyClass<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32 {
7265 #[cfg(windows)]
7266 {
7267 #[link(name = "windows")]
7268 extern "system" {
7269 fn DhcpModifyClass(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO) -> u32;
7270 }
7271 ::std::mem::transmute(DhcpModifyClass(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
7272 }
7273 #[cfg(not(windows))]
7274 unimplemented!("Unsupported target OS");
7275 }
7276 #[cfg(feature = "Win32_Foundation")]
7277 #[inline]
DhcpModifyClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u327278 pub unsafe fn DhcpModifyClassV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32 {
7279 #[cfg(windows)]
7280 {
7281 #[link(name = "windows")]
7282 extern "system" {
7283 fn DhcpModifyClassV6(serveripaddress: super::super::Foundation::PWSTR, reservedmustbezero: u32, classinfo: *mut DHCP_CLASS_INFO_V6) -> u32;
7284 }
7285 ::std::mem::transmute(DhcpModifyClassV6(serveripaddress.into_param().abi(), ::std::mem::transmute(reservedmustbezero), ::std::mem::transmute(classinfo)))
7286 }
7287 #[cfg(not(windows))]
7288 unimplemented!("Unsupported target OS");
7289 }
7290 #[cfg(feature = "Win32_Foundation")]
7291 #[inline]
DhcpRegisterParamChange<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, params: Param4, handle: *mut ::std::ffi::c_void) -> u327292 pub unsafe fn DhcpRegisterParamChange<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, params: Param4, handle: *mut ::std::ffi::c_void) -> u32 {
7293 #[cfg(windows)]
7294 {
7295 #[link(name = "windows")]
7296 extern "system" {
7297 fn DhcpRegisterParamChange(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPCAPI_CLASSID, params: DHCPCAPI_PARAMS_ARRAY, handle: *mut ::std::ffi::c_void) -> u32;
7298 }
7299 ::std::mem::transmute(DhcpRegisterParamChange(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), params.into_param().abi(), ::std::mem::transmute(handle)))
7300 }
7301 #[cfg(not(windows))]
7302 unimplemented!("Unsupported target OS");
7303 }
7304 #[inline]
DhcpRemoveDNSRegistrations() -> u327305 pub unsafe fn DhcpRemoveDNSRegistrations() -> u32 {
7306 #[cfg(windows)]
7307 {
7308 #[link(name = "windows")]
7309 extern "system" {
7310 fn DhcpRemoveDNSRegistrations() -> u32;
7311 }
7312 ::std::mem::transmute(DhcpRemoveDNSRegistrations())
7313 }
7314 #[cfg(not(windows))]
7315 unimplemented!("Unsupported target OS");
7316 }
7317 #[cfg(feature = "Win32_Foundation")]
7318 #[inline]
DhcpRemoveOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32) -> u327319 pub unsafe fn DhcpRemoveOption<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32) -> u32 {
7320 #[cfg(windows)]
7321 {
7322 #[link(name = "windows")]
7323 extern "system" {
7324 fn DhcpRemoveOption(serveripaddress: super::super::Foundation::PWSTR, optionid: u32) -> u32;
7325 }
7326 ::std::mem::transmute(DhcpRemoveOption(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid)))
7327 }
7328 #[cfg(not(windows))]
7329 unimplemented!("Unsupported target OS");
7330 }
7331 #[cfg(feature = "Win32_Foundation")]
7332 #[inline]
DhcpRemoveOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u327333 pub unsafe fn DhcpRemoveOptionV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u32 {
7334 #[cfg(windows)]
7335 {
7336 #[link(name = "windows")]
7337 extern "system" {
7338 fn DhcpRemoveOptionV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR) -> u32;
7339 }
7340 ::std::mem::transmute(DhcpRemoveOptionV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi()))
7341 }
7342 #[cfg(not(windows))]
7343 unimplemented!("Unsupported target OS");
7344 }
7345 #[cfg(feature = "Win32_Foundation")]
7346 #[inline]
DhcpRemoveOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u327347 pub unsafe fn DhcpRemoveOptionV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4) -> u32 {
7348 #[cfg(windows)]
7349 {
7350 #[link(name = "windows")]
7351 extern "system" {
7352 fn DhcpRemoveOptionV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR) -> u32;
7353 }
7354 ::std::mem::transmute(DhcpRemoveOptionV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi()))
7355 }
7356 #[cfg(not(windows))]
7357 unimplemented!("Unsupported target OS");
7358 }
7359 #[cfg(feature = "Win32_Foundation")]
7360 #[inline]
DhcpRemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u327361 pub unsafe fn DhcpRemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u32 {
7362 #[cfg(windows)]
7363 {
7364 #[link(name = "windows")]
7365 extern "system" {
7366 fn DhcpRemoveOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO) -> u32;
7367 }
7368 ::std::mem::transmute(DhcpRemoveOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo)))
7369 }
7370 #[cfg(not(windows))]
7371 unimplemented!("Unsupported target OS");
7372 }
7373 #[cfg(feature = "Win32_Foundation")]
7374 #[inline]
DhcpRemoveOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u327375 pub unsafe fn DhcpRemoveOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32 {
7376 #[cfg(windows)]
7377 {
7378 #[link(name = "windows")]
7379 extern "system" {
7380 fn DhcpRemoveOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32;
7381 }
7382 ::std::mem::transmute(DhcpRemoveOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
7383 }
7384 #[cfg(not(windows))]
7385 unimplemented!("Unsupported target OS");
7386 }
7387 #[cfg(feature = "Win32_Foundation")]
7388 #[inline]
DhcpRemoveOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u327389 pub unsafe fn DhcpRemoveOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u32 {
7390 #[cfg(windows)]
7391 {
7392 #[link(name = "windows")]
7393 extern "system" {
7394 fn DhcpRemoveOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6) -> u32;
7395 }
7396 ::std::mem::transmute(DhcpRemoveOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
7397 }
7398 #[cfg(not(windows))]
7399 unimplemented!("Unsupported target OS");
7400 }
7401 #[cfg(feature = "Win32_Foundation")]
7402 #[inline]
DhcpRemoveSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u327403 pub unsafe fn DhcpRemoveSubnetElement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u32 {
7404 #[cfg(windows)]
7405 {
7406 #[link(name = "windows")]
7407 extern "system" {
7408 fn DhcpRemoveSubnetElement(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA, forceflag: DHCP_FORCE_FLAG) -> u32;
7409 }
7410 ::std::mem::transmute(DhcpRemoveSubnetElement(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7411 }
7412 #[cfg(not(windows))]
7413 unimplemented!("Unsupported target OS");
7414 }
7415 #[cfg(feature = "Win32_Foundation")]
7416 #[inline]
DhcpRemoveSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u327417 pub unsafe fn DhcpRemoveSubnetElementV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u32 {
7418 #[cfg(windows)]
7419 {
7420 #[link(name = "windows")]
7421 extern "system" {
7422 fn DhcpRemoveSubnetElementV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V4, forceflag: DHCP_FORCE_FLAG) -> u32;
7423 }
7424 ::std::mem::transmute(DhcpRemoveSubnetElementV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7425 }
7426 #[cfg(not(windows))]
7427 unimplemented!("Unsupported target OS");
7428 }
7429 #[cfg(feature = "Win32_Foundation")]
7430 #[inline]
DhcpRemoveSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u327431 pub unsafe fn DhcpRemoveSubnetElementV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u32 {
7432 #[cfg(windows)]
7433 {
7434 #[link(name = "windows")]
7435 extern "system" {
7436 fn DhcpRemoveSubnetElementV5(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, removeelementinfo: *const DHCP_SUBNET_ELEMENT_DATA_V5, forceflag: DHCP_FORCE_FLAG) -> u32;
7437 }
7438 ::std::mem::transmute(DhcpRemoveSubnetElementV5(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7439 }
7440 #[cfg(not(windows))]
7441 unimplemented!("Unsupported target OS");
7442 }
7443 #[cfg(feature = "Win32_Foundation")]
7444 #[inline]
DhcpRemoveSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u327445 pub unsafe fn DhcpRemoveSubnetElementV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u32 {
7446 #[cfg(windows)]
7447 {
7448 #[link(name = "windows")]
7449 extern "system" {
7450 fn DhcpRemoveSubnetElementV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, removeelementinfo: *mut DHCP_SUBNET_ELEMENT_DATA_V6, forceflag: DHCP_FORCE_FLAG) -> u32;
7451 }
7452 ::std::mem::transmute(DhcpRemoveSubnetElementV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(removeelementinfo), ::std::mem::transmute(forceflag)))
7453 }
7454 #[cfg(not(windows))]
7455 unimplemented!("Unsupported target OS");
7456 }
7457 #[cfg(feature = "Win32_Foundation")]
7458 #[inline]
DhcpRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param5: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>( flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPCAPI_CLASSID, sendparams: Param4, recdparams: Param5, buffer: *mut u8, psize: *mut u32, requestidstr: Param8, ) -> u327459 pub unsafe fn DhcpRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param5: ::windows::runtime::IntoParam<'a, DHCPCAPI_PARAMS_ARRAY>, Param8: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(
7460 flags: u32,
7461 reserved: *mut ::std::ffi::c_void,
7462 adaptername: Param2,
7463 classid: *mut DHCPCAPI_CLASSID,
7464 sendparams: Param4,
7465 recdparams: Param5,
7466 buffer: *mut u8,
7467 psize: *mut u32,
7468 requestidstr: Param8,
7469 ) -> u32 {
7470 #[cfg(windows)]
7471 {
7472 #[link(name = "windows")]
7473 extern "system" {
7474 fn DhcpRequestParams(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPCAPI_CLASSID, sendparams: DHCPCAPI_PARAMS_ARRAY, recdparams: DHCPCAPI_PARAMS_ARRAY, buffer: *mut u8, psize: *mut u32, requestidstr: super::super::Foundation::PWSTR) -> u32;
7475 }
7476 ::std::mem::transmute(DhcpRequestParams(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), sendparams.into_param().abi(), recdparams.into_param().abi(), ::std::mem::transmute(buffer), ::std::mem::transmute(psize), requestidstr.into_param().abi()))
7477 }
7478 #[cfg(not(windows))]
7479 unimplemented!("Unsupported target OS");
7480 }
7481 #[inline]
DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void)7482 pub unsafe fn DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void) {
7483 #[cfg(windows)]
7484 {
7485 #[link(name = "windows")]
7486 extern "system" {
7487 fn DhcpRpcFreeMemory(bufferpointer: *mut ::std::ffi::c_void);
7488 }
7489 ::std::mem::transmute(DhcpRpcFreeMemory(::std::mem::transmute(bufferpointer)))
7490 }
7491 #[cfg(not(windows))]
7492 unimplemented!("Unsupported target OS");
7493 }
7494 #[cfg(feature = "Win32_Foundation")]
7495 #[inline]
DhcpScanDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u327496 pub unsafe fn DhcpScanDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u32 {
7497 #[cfg(windows)]
7498 {
7499 #[link(name = "windows")]
7500 extern "system" {
7501 fn DhcpScanDatabase(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, fixflag: u32, scanlist: *mut *mut DHCP_SCAN_LIST) -> u32;
7502 }
7503 ::std::mem::transmute(DhcpScanDatabase(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(fixflag), ::std::mem::transmute(scanlist)))
7504 }
7505 #[cfg(not(windows))]
7506 unimplemented!("Unsupported target OS");
7507 }
7508 #[cfg(feature = "Win32_Foundation")]
7509 #[inline]
DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ)7510 pub unsafe fn DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) {
7511 #[cfg(windows)]
7512 {
7513 #[link(name = "windows")]
7514 extern "system" {
7515 fn DhcpServerAuditlogParamsFree(configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ);
7516 }
7517 ::std::mem::transmute(DhcpServerAuditlogParamsFree(::std::mem::transmute(configinfo)))
7518 }
7519 #[cfg(not(windows))]
7520 unimplemented!("Unsupported target OS");
7521 }
7522 #[cfg(feature = "Win32_Foundation")]
7523 #[inline]
DhcpServerBackupDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u327524 pub unsafe fn DhcpServerBackupDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u32 {
7525 #[cfg(windows)]
7526 {
7527 #[link(name = "windows")]
7528 extern "system" {
7529 fn DhcpServerBackupDatabase(serveripaddress: super::super::Foundation::PWSTR, path: super::super::Foundation::PWSTR) -> u32;
7530 }
7531 ::std::mem::transmute(DhcpServerBackupDatabase(serveripaddress.into_param().abi(), path.into_param().abi()))
7532 }
7533 #[cfg(not(windows))]
7534 unimplemented!("Unsupported target OS");
7535 }
7536 #[cfg(feature = "Win32_Foundation")]
7537 #[inline]
DhcpServerGetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u327538 pub unsafe fn DhcpServerGetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u32 {
7539 #[cfg(windows)]
7540 {
7541 #[link(name = "windows")]
7542 extern "system" {
7543 fn DhcpServerGetConfig(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO) -> u32;
7544 }
7545 ::std::mem::transmute(DhcpServerGetConfig(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7546 }
7547 #[cfg(not(windows))]
7548 unimplemented!("Unsupported target OS");
7549 }
7550 #[cfg(feature = "Win32_Foundation")]
7551 #[inline]
DhcpServerGetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u327552 pub unsafe fn DhcpServerGetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32 {
7553 #[cfg(windows)]
7554 {
7555 #[link(name = "windows")]
7556 extern "system" {
7557 fn DhcpServerGetConfigV4(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32;
7558 }
7559 ::std::mem::transmute(DhcpServerGetConfigV4(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7560 }
7561 #[cfg(not(windows))]
7562 unimplemented!("Unsupported target OS");
7563 }
7564 #[cfg(feature = "Win32_Foundation")]
7565 #[inline]
DhcpServerGetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u327566 pub unsafe fn DhcpServerGetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32 {
7567 #[cfg(windows)]
7568 {
7569 #[link(name = "windows")]
7570 extern "system" {
7571 fn DhcpServerGetConfigV6(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32;
7572 }
7573 ::std::mem::transmute(DhcpServerGetConfigV6(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(configinfo)))
7574 }
7575 #[cfg(not(windows))]
7576 unimplemented!("Unsupported target OS");
7577 }
7578 #[cfg(feature = "Win32_Foundation")]
7579 #[inline]
DhcpServerGetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u327580 pub unsafe fn DhcpServerGetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32 {
7581 #[cfg(windows)]
7582 {
7583 #[link(name = "windows")]
7584 extern "system" {
7585 fn DhcpServerGetConfigVQ(serveripaddress: super::super::Foundation::PWSTR, configinfo: *mut *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32;
7586 }
7587 ::std::mem::transmute(DhcpServerGetConfigVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(configinfo)))
7588 }
7589 #[cfg(not(windows))]
7590 unimplemented!("Unsupported target OS");
7591 }
7592 #[cfg(feature = "Win32_Foundation")]
7593 #[inline]
DhcpServerQueryAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u327594 pub unsafe fn DhcpServerQueryAttribute<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u32 {
7595 #[cfg(windows)]
7596 {
7597 #[link(name = "windows")]
7598 extern "system" {
7599 fn DhcpServerQueryAttribute(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32, dhcpattribid: u32, pdhcpattrib: *mut *mut DHCP_ATTRIB) -> u32;
7600 }
7601 ::std::mem::transmute(DhcpServerQueryAttribute(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(dhcpattribid), ::std::mem::transmute(pdhcpattrib)))
7602 }
7603 #[cfg(not(windows))]
7604 unimplemented!("Unsupported target OS");
7605 }
7606 #[cfg(feature = "Win32_Foundation")]
7607 #[inline]
DhcpServerQueryAttributes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u327608 pub unsafe fn DhcpServerQueryAttributes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u32 {
7609 #[cfg(windows)]
7610 {
7611 #[link(name = "windows")]
7612 extern "system" {
7613 fn DhcpServerQueryAttributes(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32, dwattribcount: u32, pdhcpattribs: *mut u32, pdhcpattribarr: *mut *mut DHCP_ATTRIB_ARRAY) -> u32;
7614 }
7615 ::std::mem::transmute(DhcpServerQueryAttributes(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(dwattribcount), ::std::mem::transmute(pdhcpattribs), ::std::mem::transmute(pdhcpattribarr)))
7616 }
7617 #[cfg(not(windows))]
7618 unimplemented!("Unsupported target OS");
7619 }
7620 #[cfg(feature = "Win32_Foundation")]
7621 #[inline]
DhcpServerQueryDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u327622 pub unsafe fn DhcpServerQueryDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u32 {
7623 #[cfg(windows)]
7624 {
7625 #[link(name = "windows")]
7626 extern "system" {
7627 fn DhcpServerQueryDnsRegCredentials(serveripaddress: super::super::Foundation::PWSTR, unamesize: u32, uname: super::super::Foundation::PWSTR, domainsize: u32, domain: super::super::Foundation::PWSTR) -> u32;
7628 }
7629 ::std::mem::transmute(DhcpServerQueryDnsRegCredentials(serveripaddress.into_param().abi(), ::std::mem::transmute(unamesize), ::std::mem::transmute(uname), ::std::mem::transmute(domainsize), ::std::mem::transmute(domain)))
7630 }
7631 #[cfg(not(windows))]
7632 unimplemented!("Unsupported target OS");
7633 }
7634 #[cfg(feature = "Win32_Foundation")]
7635 #[inline]
DhcpServerRedoAuthorization<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32) -> u327636 pub unsafe fn DhcpServerRedoAuthorization<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddr: Param0, dwreserved: u32) -> u32 {
7637 #[cfg(windows)]
7638 {
7639 #[link(name = "windows")]
7640 extern "system" {
7641 fn DhcpServerRedoAuthorization(serveripaddr: super::super::Foundation::PWSTR, dwreserved: u32) -> u32;
7642 }
7643 ::std::mem::transmute(DhcpServerRedoAuthorization(serveripaddr.into_param().abi(), ::std::mem::transmute(dwreserved)))
7644 }
7645 #[cfg(not(windows))]
7646 unimplemented!("Unsupported target OS");
7647 }
7648 #[cfg(feature = "Win32_Foundation")]
7649 #[inline]
DhcpServerRestoreDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u327650 pub unsafe fn DhcpServerRestoreDatabase<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, path: Param1) -> u32 {
7651 #[cfg(windows)]
7652 {
7653 #[link(name = "windows")]
7654 extern "system" {
7655 fn DhcpServerRestoreDatabase(serveripaddress: super::super::Foundation::PWSTR, path: super::super::Foundation::PWSTR) -> u32;
7656 }
7657 ::std::mem::transmute(DhcpServerRestoreDatabase(serveripaddress.into_param().abi(), path.into_param().abi()))
7658 }
7659 #[cfg(not(windows))]
7660 unimplemented!("Unsupported target OS");
7661 }
7662 #[cfg(feature = "Win32_Foundation")]
7663 #[inline]
DhcpServerSetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u327664 pub unsafe fn DhcpServerSetConfig<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u32 {
7665 #[cfg(windows)]
7666 {
7667 #[link(name = "windows")]
7668 extern "system" {
7669 fn DhcpServerSetConfig(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO) -> u32;
7670 }
7671 ::std::mem::transmute(DhcpServerSetConfig(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7672 }
7673 #[cfg(not(windows))]
7674 unimplemented!("Unsupported target OS");
7675 }
7676 #[cfg(feature = "Win32_Foundation")]
7677 #[inline]
DhcpServerSetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u327678 pub unsafe fn DhcpServerSetConfigV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32 {
7679 #[cfg(windows)]
7680 {
7681 #[link(name = "windows")]
7682 extern "system" {
7683 fn DhcpServerSetConfigV4(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V4) -> u32;
7684 }
7685 ::std::mem::transmute(DhcpServerSetConfigV4(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7686 }
7687 #[cfg(not(windows))]
7688 unimplemented!("Unsupported target OS");
7689 }
7690 #[cfg(feature = "Win32_Foundation")]
7691 #[inline]
DhcpServerSetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u327692 pub unsafe fn DhcpServerSetConfigV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32 {
7693 #[cfg(windows)]
7694 {
7695 #[link(name = "windows")]
7696 extern "system" {
7697 fn DhcpServerSetConfigV6(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_V6) -> u32;
7698 }
7699 ::std::mem::transmute(DhcpServerSetConfigV6(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7700 }
7701 #[cfg(not(windows))]
7702 unimplemented!("Unsupported target OS");
7703 }
7704 #[cfg(feature = "Win32_Foundation")]
7705 #[inline]
DhcpServerSetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u327706 pub unsafe fn DhcpServerSetConfigVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32 {
7707 #[cfg(windows)]
7708 {
7709 #[link(name = "windows")]
7710 extern "system" {
7711 fn DhcpServerSetConfigVQ(serveripaddress: super::super::Foundation::PWSTR, fieldstoset: u32, configinfo: *mut DHCP_SERVER_CONFIG_INFO_VQ) -> u32;
7712 }
7713 ::std::mem::transmute(DhcpServerSetConfigVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldstoset), ::std::mem::transmute(configinfo)))
7714 }
7715 #[cfg(not(windows))]
7716 unimplemented!("Unsupported target OS");
7717 }
7718 #[cfg(feature = "Win32_Foundation")]
7719 #[inline]
DhcpServerSetDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, 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>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u327720 pub unsafe fn DhcpServerSetDnsRegCredentials<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, 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>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u32 {
7721 #[cfg(windows)]
7722 {
7723 #[link(name = "windows")]
7724 extern "system" {
7725 fn DhcpServerSetDnsRegCredentials(serveripaddress: super::super::Foundation::PWSTR, uname: super::super::Foundation::PWSTR, domain: super::super::Foundation::PWSTR, passwd: super::super::Foundation::PWSTR) -> u32;
7726 }
7727 ::std::mem::transmute(DhcpServerSetDnsRegCredentials(serveripaddress.into_param().abi(), uname.into_param().abi(), domain.into_param().abi(), passwd.into_param().abi()))
7728 }
7729 #[cfg(not(windows))]
7730 unimplemented!("Unsupported target OS");
7731 }
7732 #[cfg(feature = "Win32_Foundation")]
7733 #[inline]
DhcpServerSetDnsRegCredentialsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, 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>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u327734 pub unsafe fn DhcpServerSetDnsRegCredentialsV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, 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>>(serveripaddress: Param0, uname: Param1, domain: Param2, passwd: Param3) -> u32 {
7735 #[cfg(windows)]
7736 {
7737 #[link(name = "windows")]
7738 extern "system" {
7739 fn DhcpServerSetDnsRegCredentialsV5(serveripaddress: super::super::Foundation::PWSTR, uname: super::super::Foundation::PWSTR, domain: super::super::Foundation::PWSTR, passwd: super::super::Foundation::PWSTR) -> u32;
7740 }
7741 ::std::mem::transmute(DhcpServerSetDnsRegCredentialsV5(serveripaddress.into_param().abi(), uname.into_param().abi(), domain.into_param().abi(), passwd.into_param().abi()))
7742 }
7743 #[cfg(not(windows))]
7744 unimplemented!("Unsupported target OS");
7745 }
7746 #[cfg(feature = "Win32_Foundation")]
7747 #[inline]
DhcpSetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u327748 pub unsafe fn DhcpSetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO) -> u32 {
7749 #[cfg(windows)]
7750 {
7751 #[link(name = "windows")]
7752 extern "system" {
7753 fn DhcpSetClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO) -> u32;
7754 }
7755 ::std::mem::transmute(DhcpSetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7756 }
7757 #[cfg(not(windows))]
7758 unimplemented!("Unsupported target OS");
7759 }
7760 #[cfg(feature = "Win32_Foundation")]
7761 #[inline]
DhcpSetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u327762 pub unsafe fn DhcpSetClientInfoV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32 {
7763 #[cfg(windows)]
7764 {
7765 #[link(name = "windows")]
7766 extern "system" {
7767 fn DhcpSetClientInfoV4(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V4) -> u32;
7768 }
7769 ::std::mem::transmute(DhcpSetClientInfoV4(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7770 }
7771 #[cfg(not(windows))]
7772 unimplemented!("Unsupported target OS");
7773 }
7774 #[cfg(feature = "Win32_Foundation")]
7775 #[inline]
DhcpSetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u327776 pub unsafe fn DhcpSetClientInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32 {
7777 #[cfg(windows)]
7778 {
7779 #[link(name = "windows")]
7780 extern "system" {
7781 fn DhcpSetClientInfoV6(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32;
7782 }
7783 ::std::mem::transmute(DhcpSetClientInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7784 }
7785 #[cfg(not(windows))]
7786 unimplemented!("Unsupported target OS");
7787 }
7788 #[cfg(feature = "Win32_Foundation")]
7789 #[inline]
DhcpSetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u327790 pub unsafe fn DhcpSetClientInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32 {
7791 #[cfg(windows)]
7792 {
7793 #[link(name = "windows")]
7794 extern "system" {
7795 fn DhcpSetClientInfoVQ(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_VQ) -> u32;
7796 }
7797 ::std::mem::transmute(DhcpSetClientInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
7798 }
7799 #[cfg(not(windows))]
7800 unimplemented!("Unsupported target OS");
7801 }
7802 #[cfg(feature = "Win32_Foundation")]
7803 #[inline]
DhcpSetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u327804 pub unsafe fn DhcpSetFilterV4<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u32 {
7805 #[cfg(windows)]
7806 {
7807 #[link(name = "windows")]
7808 extern "system" {
7809 fn DhcpSetFilterV4(serveripaddress: super::super::Foundation::PWSTR, globalfilterinfo: *const DHCP_FILTER_GLOBAL_INFO) -> u32;
7810 }
7811 ::std::mem::transmute(DhcpSetFilterV4(serveripaddress.into_param().abi(), ::std::mem::transmute(globalfilterinfo)))
7812 }
7813 #[cfg(not(windows))]
7814 unimplemented!("Unsupported target OS");
7815 }
7816 #[cfg(feature = "Win32_Foundation")]
7817 #[inline]
DhcpSetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u327818 pub unsafe fn DhcpSetOptionInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32 {
7819 #[cfg(windows)]
7820 {
7821 #[link(name = "windows")]
7822 extern "system" {
7823 fn DhcpSetOptionInfo(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, optioninfo: *const DHCP_OPTION) -> u32;
7824 }
7825 ::std::mem::transmute(DhcpSetOptionInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(optioninfo)))
7826 }
7827 #[cfg(not(windows))]
7828 unimplemented!("Unsupported target OS");
7829 }
7830 #[cfg(feature = "Win32_Foundation")]
7831 #[inline]
DhcpSetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u327832 pub unsafe fn DhcpSetOptionInfoV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
7833 #[cfg(windows)]
7834 {
7835 #[link(name = "windows")]
7836 extern "system" {
7837 fn DhcpSetOptionInfoV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
7838 }
7839 ::std::mem::transmute(DhcpSetOptionInfoV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
7840 }
7841 #[cfg(not(windows))]
7842 unimplemented!("Unsupported target OS");
7843 }
7844 #[cfg(feature = "Win32_Foundation")]
7845 #[inline]
DhcpSetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u327846 pub unsafe fn DhcpSetOptionInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, optioninfo: *mut DHCP_OPTION) -> u32 {
7847 #[cfg(windows)]
7848 {
7849 #[link(name = "windows")]
7850 extern "system" {
7851 fn DhcpSetOptionInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, optioninfo: *mut DHCP_OPTION) -> u32;
7852 }
7853 ::std::mem::transmute(DhcpSetOptionInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(optioninfo)))
7854 }
7855 #[cfg(not(windows))]
7856 unimplemented!("Unsupported target OS");
7857 }
7858 #[cfg(feature = "Win32_Foundation")]
7859 #[inline]
DhcpSetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u327860 pub unsafe fn DhcpSetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u32 {
7861 #[cfg(windows)]
7862 {
7863 #[link(name = "windows")]
7864 extern "system" {
7865 fn DhcpSetOptionValue(serveripaddress: super::super::Foundation::PWSTR, optionid: u32, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalue: *const DHCP_OPTION_DATA) -> u32;
7866 }
7867 ::std::mem::transmute(DhcpSetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(optionid), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7868 }
7869 #[cfg(not(windows))]
7870 unimplemented!("Unsupported target OS");
7871 }
7872 #[cfg(feature = "Win32_Foundation")]
7873 #[inline]
DhcpSetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u327874 pub unsafe fn DhcpSetOptionValueV5<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
7875 #[cfg(windows)]
7876 {
7877 #[link(name = "windows")]
7878 extern "system" {
7879 fn DhcpSetOptionValueV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
7880 }
7881 ::std::mem::transmute(DhcpSetOptionValueV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7882 }
7883 #[cfg(not(windows))]
7884 unimplemented!("Unsupported target OS");
7885 }
7886 #[cfg(feature = "Win32_Foundation")]
7887 #[inline]
DhcpSetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u327888 pub unsafe fn DhcpSetOptionValueV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, classname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
7889 #[cfg(windows)]
7890 {
7891 #[link(name = "windows")]
7892 extern "system" {
7893 fn DhcpSetOptionValueV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO6, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
7894 }
7895 ::std::mem::transmute(DhcpSetOptionValueV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
7896 }
7897 #[cfg(not(windows))]
7898 unimplemented!("Unsupported target OS");
7899 }
7900 #[cfg(feature = "Win32_Foundation")]
7901 #[inline]
DhcpSetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u327902 pub unsafe fn DhcpSetOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u32 {
7903 #[cfg(windows)]
7904 {
7905 #[link(name = "windows")]
7906 extern "system" {
7907 fn DhcpSetOptionValues(serveripaddress: super::super::Foundation::PWSTR, scopeinfo: *const DHCP_OPTION_SCOPE_INFO, optionvalues: *const DHCP_OPTION_VALUE_ARRAY) -> u32;
7908 }
7909 ::std::mem::transmute(DhcpSetOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
7910 }
7911 #[cfg(not(windows))]
7912 unimplemented!("Unsupported target OS");
7913 }
7914 #[cfg(feature = "Win32_Foundation")]
7915 #[inline]
DhcpSetOptionValuesV5<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u327916 pub unsafe fn DhcpSetOptionValuesV5<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, classname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32 {
7917 #[cfg(windows)]
7918 {
7919 #[link(name = "windows")]
7920 extern "system" {
7921 fn DhcpSetOptionValuesV5(serveripaddress: super::super::Foundation::PWSTR, flags: u32, classname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32;
7922 }
7923 ::std::mem::transmute(DhcpSetOptionValuesV5(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), classname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
7924 }
7925 #[cfg(not(windows))]
7926 unimplemented!("Unsupported target OS");
7927 }
7928 #[cfg(feature = "Win32_Foundation")]
7929 #[inline]
DhcpSetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u327930 pub unsafe fn DhcpSetServerBindingInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u32 {
7931 #[cfg(windows)]
7932 {
7933 #[link(name = "windows")]
7934 extern "system" {
7935 fn DhcpSetServerBindingInfo(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementinfo: *mut DHCP_BIND_ELEMENT_ARRAY) -> u32;
7936 }
7937 ::std::mem::transmute(DhcpSetServerBindingInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementinfo)))
7938 }
7939 #[cfg(not(windows))]
7940 unimplemented!("Unsupported target OS");
7941 }
7942 #[cfg(feature = "Win32_Foundation")]
7943 #[inline]
DhcpSetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u327944 pub unsafe fn DhcpSetServerBindingInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32 {
7945 #[cfg(windows)]
7946 {
7947 #[link(name = "windows")]
7948 extern "system" {
7949 fn DhcpSetServerBindingInfoV6(serveripaddress: super::super::Foundation::PWSTR, flags: u32, bindelementinfo: *mut DHCPV6_BIND_ELEMENT_ARRAY) -> u32;
7950 }
7951 ::std::mem::transmute(DhcpSetServerBindingInfoV6(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(bindelementinfo)))
7952 }
7953 #[cfg(not(windows))]
7954 unimplemented!("Unsupported target OS");
7955 }
7956 #[cfg(feature = "Win32_Foundation")]
7957 #[inline]
DhcpSetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: u16) -> u327958 pub unsafe fn DhcpSetSubnetDelayOffer<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, timedelayinmilliseconds: u16) -> u32 {
7959 #[cfg(windows)]
7960 {
7961 #[link(name = "windows")]
7962 extern "system" {
7963 fn DhcpSetSubnetDelayOffer(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, timedelayinmilliseconds: u16) -> u32;
7964 }
7965 ::std::mem::transmute(DhcpSetSubnetDelayOffer(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(timedelayinmilliseconds)))
7966 }
7967 #[cfg(not(windows))]
7968 unimplemented!("Unsupported target OS");
7969 }
7970 #[cfg(feature = "Win32_Foundation")]
7971 #[inline]
DhcpSetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u327972 pub unsafe fn DhcpSetSubnetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32 {
7973 #[cfg(windows)]
7974 {
7975 #[link(name = "windows")]
7976 extern "system" {
7977 fn DhcpSetSubnetInfo(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO) -> u32;
7978 }
7979 ::std::mem::transmute(DhcpSetSubnetInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
7980 }
7981 #[cfg(not(windows))]
7982 unimplemented!("Unsupported target OS");
7983 }
7984 #[cfg(feature = "Win32_Foundation")]
7985 #[inline]
DhcpSetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u327986 pub unsafe fn DhcpSetSubnetInfoV6<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, subnetaddress: Param1, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32 {
7987 #[cfg(windows)]
7988 {
7989 #[link(name = "windows")]
7990 extern "system" {
7991 fn DhcpSetSubnetInfoV6(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: DHCP_IPV6_ADDRESS, subnetinfo: *mut DHCP_SUBNET_INFO_V6) -> u32;
7992 }
7993 ::std::mem::transmute(DhcpSetSubnetInfoV6(serveripaddress.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(subnetinfo)))
7994 }
7995 #[cfg(not(windows))]
7996 unimplemented!("Unsupported target OS");
7997 }
7998 #[cfg(feature = "Win32_Foundation")]
7999 #[inline]
DhcpSetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u328000 pub unsafe fn DhcpSetSubnetInfoVQ<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32 {
8001 #[cfg(windows)]
8002 {
8003 #[link(name = "windows")]
8004 extern "system" {
8005 fn DhcpSetSubnetInfoVQ(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, subnetinfo: *const DHCP_SUBNET_INFO_VQ) -> u32;
8006 }
8007 ::std::mem::transmute(DhcpSetSubnetInfoVQ(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(subnetinfo)))
8008 }
8009 #[cfg(not(windows))]
8010 unimplemented!("Unsupported target OS");
8011 }
8012 #[cfg(feature = "Win32_Foundation")]
8013 #[inline]
DhcpSetSuperScopeV4<'a, Param0: ::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::BOOL>>(serveripaddress: Param0, subnetaddress: u32, superscopename: Param2, changeexisting: Param3) -> u328014 pub unsafe fn DhcpSetSuperScopeV4<'a, Param0: ::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::BOOL>>(serveripaddress: Param0, subnetaddress: u32, superscopename: Param2, changeexisting: Param3) -> u32 {
8015 #[cfg(windows)]
8016 {
8017 #[link(name = "windows")]
8018 extern "system" {
8019 fn DhcpSetSuperScopeV4(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, superscopename: super::super::Foundation::PWSTR, changeexisting: super::super::Foundation::BOOL) -> u32;
8020 }
8021 ::std::mem::transmute(DhcpSetSuperScopeV4(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), superscopename.into_param().abi(), changeexisting.into_param().abi()))
8022 }
8023 #[cfg(not(windows))]
8024 unimplemented!("Unsupported target OS");
8025 }
8026 #[inline]
DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u328027 pub unsafe fn DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u32 {
8028 #[cfg(windows)]
8029 {
8030 #[link(name = "windows")]
8031 extern "system" {
8032 fn DhcpSetThreadOptions(flags: u32, reserved: *mut ::std::ffi::c_void) -> u32;
8033 }
8034 ::std::mem::transmute(DhcpSetThreadOptions(::std::mem::transmute(flags), ::std::mem::transmute(reserved)))
8035 }
8036 #[cfg(not(windows))]
8037 unimplemented!("Unsupported target OS");
8038 }
8039 #[cfg(feature = "Win32_Foundation")]
8040 #[inline]
DhcpUndoRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, requestidstr: Param3) -> u328041 pub unsafe fn DhcpUndoRequestParams<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: Param2, requestidstr: Param3) -> u32 {
8042 #[cfg(windows)]
8043 {
8044 #[link(name = "windows")]
8045 extern "system" {
8046 fn DhcpUndoRequestParams(flags: u32, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, requestidstr: super::super::Foundation::PWSTR) -> u32;
8047 }
8048 ::std::mem::transmute(DhcpUndoRequestParams(::std::mem::transmute(flags), ::std::mem::transmute(reserved), adaptername.into_param().abi(), requestidstr.into_param().abi()))
8049 }
8050 #[cfg(not(windows))]
8051 unimplemented!("Unsupported target OS");
8052 }
8053 #[cfg(feature = "Win32_Foundation")]
8054 #[inline]
DhcpV4AddPolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u328055 pub unsafe fn DhcpV4AddPolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u32 {
8056 #[cfg(windows)]
8057 {
8058 #[link(name = "windows")]
8059 extern "system" {
8060 fn DhcpV4AddPolicyRange(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, range: *const DHCP_IP_RANGE) -> u32;
8061 }
8062 ::std::mem::transmute(DhcpV4AddPolicyRange(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(range)))
8063 }
8064 #[cfg(not(windows))]
8065 unimplemented!("Unsupported target OS");
8066 }
8067 #[cfg(feature = "Win32_Foundation")]
8068 #[inline]
DhcpV4CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u328069 pub unsafe fn DhcpV4CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u32 {
8070 #[cfg(windows)]
8071 {
8072 #[link(name = "windows")]
8073 extern "system" {
8074 fn DhcpV4CreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_PB) -> u32;
8075 }
8076 ::std::mem::transmute(DhcpV4CreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8077 }
8078 #[cfg(not(windows))]
8079 unimplemented!("Unsupported target OS");
8080 }
8081 #[cfg(feature = "Win32_Foundation")]
8082 #[inline]
DhcpV4CreateClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u328083 pub unsafe fn DhcpV4CreateClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u32 {
8084 #[cfg(windows)]
8085 {
8086 #[link(name = "windows")]
8087 extern "system" {
8088 fn DhcpV4CreateClientInfoEx(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_EX) -> u32;
8089 }
8090 ::std::mem::transmute(DhcpV4CreateClientInfoEx(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8091 }
8092 #[cfg(not(windows))]
8093 unimplemented!("Unsupported target OS");
8094 }
8095 #[cfg(feature = "Win32_Foundation")]
8096 #[inline]
DhcpV4CreatePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ppolicy: *const DHCP_POLICY) -> u328097 pub unsafe fn DhcpV4CreatePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ppolicy: *const DHCP_POLICY) -> u32 {
8098 #[cfg(windows)]
8099 {
8100 #[link(name = "windows")]
8101 extern "system" {
8102 fn DhcpV4CreatePolicy(serveripaddress: super::super::Foundation::PWSTR, ppolicy: *const DHCP_POLICY) -> u32;
8103 }
8104 ::std::mem::transmute(DhcpV4CreatePolicy(serveripaddress.into_param().abi(), ::std::mem::transmute(ppolicy)))
8105 }
8106 #[cfg(not(windows))]
8107 unimplemented!("Unsupported target OS");
8108 }
8109 #[cfg(feature = "Win32_Foundation")]
8110 #[inline]
DhcpV4CreatePolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, policyex: *const DHCP_POLICY_EX) -> u328111 pub unsafe fn DhcpV4CreatePolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, policyex: *const DHCP_POLICY_EX) -> u32 {
8112 #[cfg(windows)]
8113 {
8114 #[link(name = "windows")]
8115 extern "system" {
8116 fn DhcpV4CreatePolicyEx(serveripaddress: super::super::Foundation::PWSTR, policyex: *const DHCP_POLICY_EX) -> u32;
8117 }
8118 ::std::mem::transmute(DhcpV4CreatePolicyEx(serveripaddress.into_param().abi(), ::std::mem::transmute(policyex)))
8119 }
8120 #[cfg(not(windows))]
8121 unimplemented!("Unsupported target OS");
8122 }
8123 #[cfg(feature = "Win32_Foundation")]
8124 #[inline]
DhcpV4DeletePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3) -> u328125 pub unsafe fn DhcpV4DeletePolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3) -> u32 {
8126 #[cfg(windows)]
8127 {
8128 #[link(name = "windows")]
8129 extern "system" {
8130 fn DhcpV4DeletePolicy(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR) -> u32;
8131 }
8132 ::std::mem::transmute(DhcpV4DeletePolicy(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi()))
8133 }
8134 #[cfg(not(windows))]
8135 unimplemented!("Unsupported target OS");
8136 }
8137 #[cfg(feature = "Win32_Foundation")]
8138 #[inline]
DhcpV4EnumPolicies<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328139 pub unsafe fn DhcpV4EnumPolicies<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8140 #[cfg(windows)]
8141 {
8142 #[link(name = "windows")]
8143 extern "system" {
8144 fn DhcpV4EnumPolicies(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8145 }
8146 ::std::mem::transmute(DhcpV4EnumPolicies(
8147 serveripaddress.into_param().abi(),
8148 ::std::mem::transmute(resumehandle),
8149 ::std::mem::transmute(preferredmaximum),
8150 fglobalpolicy.into_param().abi(),
8151 ::std::mem::transmute(subnetaddress),
8152 ::std::mem::transmute(enuminfo),
8153 ::std::mem::transmute(elementsread),
8154 ::std::mem::transmute(elementstotal),
8155 ))
8156 }
8157 #[cfg(not(windows))]
8158 unimplemented!("Unsupported target OS");
8159 }
8160 #[cfg(feature = "Win32_Foundation")]
8161 #[inline]
DhcpV4EnumPoliciesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328162 pub unsafe fn DhcpV4EnumPoliciesEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: Param3, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8163 #[cfg(windows)]
8164 {
8165 #[link(name = "windows")]
8166 extern "system" {
8167 fn DhcpV4EnumPoliciesEx(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enuminfo: *mut *mut DHCP_POLICY_EX_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8168 }
8169 ::std::mem::transmute(DhcpV4EnumPoliciesEx(
8170 serveripaddress.into_param().abi(),
8171 ::std::mem::transmute(resumehandle),
8172 ::std::mem::transmute(preferredmaximum),
8173 globalpolicy.into_param().abi(),
8174 ::std::mem::transmute(subnetaddress),
8175 ::std::mem::transmute(enuminfo),
8176 ::std::mem::transmute(elementsread),
8177 ::std::mem::transmute(elementstotal),
8178 ))
8179 }
8180 #[cfg(not(windows))]
8181 unimplemented!("Unsupported target OS");
8182 }
8183 #[cfg(feature = "Win32_Foundation")]
8184 #[inline]
DhcpV4EnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u328185 pub unsafe fn DhcpV4EnumSubnetClients<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
8186 #[cfg(windows)]
8187 {
8188 #[link(name = "windows")]
8189 extern "system" {
8190 fn DhcpV4EnumSubnetClients(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
8191 }
8192 ::std::mem::transmute(DhcpV4EnumSubnetClients(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
8193 }
8194 #[cfg(not(windows))]
8195 unimplemented!("Unsupported target OS");
8196 }
8197 #[cfg(feature = "Win32_Foundation")]
8198 #[inline]
DhcpV4EnumSubnetClientsEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u328199 pub unsafe fn DhcpV4EnumSubnetClientsEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32 {
8200 #[cfg(windows)]
8201 {
8202 #[link(name = "windows")]
8203 extern "system" {
8204 fn DhcpV4EnumSubnetClientsEx(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX_ARRAY, clientsread: *mut u32, clientstotal: *mut u32) -> u32;
8205 }
8206 ::std::mem::transmute(DhcpV4EnumSubnetClientsEx(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(clientinfo), ::std::mem::transmute(clientsread), ::std::mem::transmute(clientstotal)))
8207 }
8208 #[cfg(not(windows))]
8209 unimplemented!("Unsupported target OS");
8210 }
8211 #[cfg(feature = "Win32_Foundation")]
8212 #[inline]
DhcpV4EnumSubnetReservations<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u328213 pub unsafe fn DhcpV4EnumSubnetReservations<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32 {
8214 #[cfg(windows)]
8215 {
8216 #[link(name = "windows")]
8217 extern "system" {
8218 fn DhcpV4EnumSubnetReservations(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, resumehandle: *mut u32, preferredmaximum: u32, enumelementinfo: *mut *mut DHCP_RESERVATION_INFO_ARRAY, elementsread: *mut u32, elementstotal: *mut u32) -> u32;
8219 }
8220 ::std::mem::transmute(DhcpV4EnumSubnetReservations(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(enumelementinfo), ::std::mem::transmute(elementsread), ::std::mem::transmute(elementstotal)))
8221 }
8222 #[cfg(not(windows))]
8223 unimplemented!("Unsupported target OS");
8224 }
8225 #[cfg(feature = "Win32_Foundation")]
8226 #[inline]
DhcpV4FailoverAddScopeToRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328227 pub unsafe fn DhcpV4FailoverAddScopeToRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8228 #[cfg(windows)]
8229 {
8230 #[link(name = "windows")]
8231 extern "system" {
8232 fn DhcpV4FailoverAddScopeToRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8233 }
8234 ::std::mem::transmute(DhcpV4FailoverAddScopeToRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8235 }
8236 #[cfg(not(windows))]
8237 unimplemented!("Unsupported target OS");
8238 }
8239 #[cfg(feature = "Win32_Foundation")]
8240 #[inline]
DhcpV4FailoverCreateRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328241 pub unsafe fn DhcpV4FailoverCreateRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8242 #[cfg(windows)]
8243 {
8244 #[link(name = "windows")]
8245 extern "system" {
8246 fn DhcpV4FailoverCreateRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8247 }
8248 ::std::mem::transmute(DhcpV4FailoverCreateRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8249 }
8250 #[cfg(not(windows))]
8251 unimplemented!("Unsupported target OS");
8252 }
8253 #[cfg(feature = "Win32_Foundation")]
8254 #[inline]
DhcpV4FailoverDeleteRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1) -> u328255 pub unsafe fn DhcpV4FailoverDeleteRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1) -> u32 {
8256 #[cfg(windows)]
8257 {
8258 #[link(name = "windows")]
8259 extern "system" {
8260 fn DhcpV4FailoverDeleteRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationshipname: super::super::Foundation::PWSTR) -> u32;
8261 }
8262 ::std::mem::transmute(DhcpV4FailoverDeleteRelationship(serveripaddress.into_param().abi(), prelationshipname.into_param().abi()))
8263 }
8264 #[cfg(not(windows))]
8265 unimplemented!("Unsupported target OS");
8266 }
8267 #[cfg(feature = "Win32_Foundation")]
8268 #[inline]
DhcpV4FailoverDeleteScopeFromRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328269 pub unsafe fn DhcpV4FailoverDeleteScopeFromRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8270 #[cfg(windows)]
8271 {
8272 #[link(name = "windows")]
8273 extern "system" {
8274 fn DhcpV4FailoverDeleteScopeFromRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8275 }
8276 ::std::mem::transmute(DhcpV4FailoverDeleteScopeFromRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(prelationship)))
8277 }
8278 #[cfg(not(windows))]
8279 unimplemented!("Unsupported target OS");
8280 }
8281 #[cfg(feature = "Win32_Foundation")]
8282 #[inline]
DhcpV4FailoverEnumRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u328283 pub unsafe fn DhcpV4FailoverEnumRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u32 {
8284 #[cfg(windows)]
8285 {
8286 #[link(name = "windows")]
8287 extern "system" {
8288 fn DhcpV4FailoverEnumRelationship(serveripaddress: super::super::Foundation::PWSTR, resumehandle: *mut u32, preferredmaximum: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP_ARRAY, relationshipread: *mut u32, relationshiptotal: *mut u32) -> u32;
8289 }
8290 ::std::mem::transmute(DhcpV4FailoverEnumRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(resumehandle), ::std::mem::transmute(preferredmaximum), ::std::mem::transmute(prelationship), ::std::mem::transmute(relationshipread), ::std::mem::transmute(relationshiptotal)))
8291 }
8292 #[cfg(not(windows))]
8293 unimplemented!("Unsupported target OS");
8294 }
8295 #[cfg(feature = "Win32_Foundation")]
8296 #[inline]
DhcpV4FailoverGetAddressStatus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, pstatus: *mut u32) -> u328297 pub unsafe fn DhcpV4FailoverGetAddressStatus<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, pstatus: *mut u32) -> u32 {
8298 #[cfg(windows)]
8299 {
8300 #[link(name = "windows")]
8301 extern "system" {
8302 fn DhcpV4FailoverGetAddressStatus(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, pstatus: *mut u32) -> u32;
8303 }
8304 ::std::mem::transmute(DhcpV4FailoverGetAddressStatus(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(pstatus)))
8305 }
8306 #[cfg(not(windows))]
8307 unimplemented!("Unsupported target OS");
8308 }
8309 #[cfg(feature = "Win32_Foundation")]
8310 #[inline]
DhcpV4FailoverGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u328311 pub unsafe fn DhcpV4FailoverGetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u32 {
8312 #[cfg(windows)]
8313 {
8314 #[link(name = "windows")]
8315 extern "system" {
8316 fn DhcpV4FailoverGetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCPV4_FAILOVER_CLIENT_INFO) -> u32;
8317 }
8318 ::std::mem::transmute(DhcpV4FailoverGetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8319 }
8320 #[cfg(not(windows))]
8321 unimplemented!("Unsupported target OS");
8322 }
8323 #[cfg(feature = "Win32_Foundation")]
8324 #[inline]
DhcpV4FailoverGetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u328325 pub unsafe fn DhcpV4FailoverGetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, prelationshipname: Param1, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8326 #[cfg(windows)]
8327 {
8328 #[link(name = "windows")]
8329 extern "system" {
8330 fn DhcpV4FailoverGetRelationship(serveripaddress: super::super::Foundation::PWSTR, prelationshipname: super::super::Foundation::PWSTR, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32;
8331 }
8332 ::std::mem::transmute(DhcpV4FailoverGetRelationship(serveripaddress.into_param().abi(), prelationshipname.into_param().abi(), ::std::mem::transmute(prelationship)))
8333 }
8334 #[cfg(not(windows))]
8335 unimplemented!("Unsupported target OS");
8336 }
8337 #[cfg(feature = "Win32_Foundation")]
8338 #[inline]
DhcpV4FailoverGetScopeRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u328339 pub unsafe fn DhcpV4FailoverGetScopeRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8340 #[cfg(windows)]
8341 {
8342 #[link(name = "windows")]
8343 extern "system" {
8344 fn DhcpV4FailoverGetScopeRelationship(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, prelationship: *mut *mut DHCP_FAILOVER_RELATIONSHIP) -> u32;
8345 }
8346 ::std::mem::transmute(DhcpV4FailoverGetScopeRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(prelationship)))
8347 }
8348 #[cfg(not(windows))]
8349 unimplemented!("Unsupported target OS");
8350 }
8351 #[cfg(feature = "Win32_Foundation")]
8352 #[inline]
DhcpV4FailoverGetScopeStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u328353 pub unsafe fn DhcpV4FailoverGetScopeStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u32 {
8354 #[cfg(windows)]
8355 {
8356 #[link(name = "windows")]
8357 extern "system" {
8358 fn DhcpV4FailoverGetScopeStatistics(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, pstats: *mut *mut DHCP_FAILOVER_STATISTICS) -> u32;
8359 }
8360 ::std::mem::transmute(DhcpV4FailoverGetScopeStatistics(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(pstats)))
8361 }
8362 #[cfg(not(windows))]
8363 unimplemented!("Unsupported target OS");
8364 }
8365 #[cfg(feature = "Win32_Foundation")]
8366 #[inline]
DhcpV4FailoverGetSystemTime<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u328367 pub unsafe fn DhcpV4FailoverGetSystemTime<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u32 {
8368 #[cfg(windows)]
8369 {
8370 #[link(name = "windows")]
8371 extern "system" {
8372 fn DhcpV4FailoverGetSystemTime(serveripaddress: super::super::Foundation::PWSTR, ptime: *mut u32, pmaxalloweddeltatime: *mut u32) -> u32;
8373 }
8374 ::std::mem::transmute(DhcpV4FailoverGetSystemTime(serveripaddress.into_param().abi(), ::std::mem::transmute(ptime), ::std::mem::transmute(pmaxalloweddeltatime)))
8375 }
8376 #[cfg(not(windows))]
8377 unimplemented!("Unsupported target OS");
8378 }
8379 #[cfg(feature = "Win32_Foundation")]
8380 #[inline]
DhcpV4FailoverSetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u328381 pub unsafe fn DhcpV4FailoverSetRelationship<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32 {
8382 #[cfg(windows)]
8383 {
8384 #[link(name = "windows")]
8385 extern "system" {
8386 fn DhcpV4FailoverSetRelationship(serveripaddress: super::super::Foundation::PWSTR, flags: u32, prelationship: *const DHCP_FAILOVER_RELATIONSHIP) -> u32;
8387 }
8388 ::std::mem::transmute(DhcpV4FailoverSetRelationship(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(prelationship)))
8389 }
8390 #[cfg(not(windows))]
8391 unimplemented!("Unsupported target OS");
8392 }
8393 #[cfg(feature = "Win32_Foundation")]
8394 #[inline]
DhcpV4FailoverTriggerAddrAllocation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, pfailrelname: Param1) -> u328395 pub unsafe fn DhcpV4FailoverTriggerAddrAllocation<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, pfailrelname: Param1) -> u32 {
8396 #[cfg(windows)]
8397 {
8398 #[link(name = "windows")]
8399 extern "system" {
8400 fn DhcpV4FailoverTriggerAddrAllocation(serveripaddress: super::super::Foundation::PWSTR, pfailrelname: super::super::Foundation::PWSTR) -> u32;
8401 }
8402 ::std::mem::transmute(DhcpV4FailoverTriggerAddrAllocation(serveripaddress.into_param().abi(), pfailrelname.into_param().abi()))
8403 }
8404 #[cfg(not(windows))]
8405 unimplemented!("Unsupported target OS");
8406 }
8407 #[cfg(feature = "Win32_Foundation")]
8408 #[inline]
DhcpV4GetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u328409 pub unsafe fn DhcpV4GetAllOptionValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u32 {
8410 #[cfg(windows)]
8411 {
8412 #[link(name = "windows")]
8413 extern "system" {
8414 fn DhcpV4GetAllOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, values: *mut *mut DHCP_ALL_OPTION_VALUES_PB) -> u32;
8415 }
8416 ::std::mem::transmute(DhcpV4GetAllOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(values)))
8417 }
8418 #[cfg(not(windows))]
8419 unimplemented!("Unsupported target OS");
8420 }
8421 #[cfg(feature = "Win32_Foundation")]
8422 #[inline]
DhcpV4GetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u328423 pub unsafe fn DhcpV4GetClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u32 {
8424 #[cfg(windows)]
8425 {
8426 #[link(name = "windows")]
8427 extern "system" {
8428 fn DhcpV4GetClientInfo(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_PB) -> u32;
8429 }
8430 ::std::mem::transmute(DhcpV4GetClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8431 }
8432 #[cfg(not(windows))]
8433 unimplemented!("Unsupported target OS");
8434 }
8435 #[cfg(feature = "Win32_Foundation")]
8436 #[inline]
DhcpV4GetClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u328437 pub unsafe fn DhcpV4GetClientInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u32 {
8438 #[cfg(windows)]
8439 {
8440 #[link(name = "windows")]
8441 extern "system" {
8442 fn DhcpV4GetClientInfoEx(serveripaddress: super::super::Foundation::PWSTR, searchinfo: *const DHCP_SEARCH_INFO, clientinfo: *mut *mut DHCP_CLIENT_INFO_EX) -> u32;
8443 }
8444 ::std::mem::transmute(DhcpV4GetClientInfoEx(serveripaddress.into_param().abi(), ::std::mem::transmute(searchinfo), ::std::mem::transmute(clientinfo)))
8445 }
8446 #[cfg(not(windows))]
8447 unimplemented!("Unsupported target OS");
8448 }
8449 #[cfg(feature = "Win32_Foundation")]
8450 #[inline]
DhcpV4GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u328451 pub unsafe fn DhcpV4GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u32 {
8452 #[cfg(windows)]
8453 {
8454 #[link(name = "windows")]
8455 extern "system" {
8456 fn DhcpV4GetFreeIPAddress(serveripaddress: super::super::Foundation::PWSTR, scopeid: u32, startip: u32, endip: u32, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCP_IP_ARRAY) -> u32;
8457 }
8458 ::std::mem::transmute(DhcpV4GetFreeIPAddress(serveripaddress.into_param().abi(), ::std::mem::transmute(scopeid), ::std::mem::transmute(startip), ::std::mem::transmute(endip), ::std::mem::transmute(numfreeaddrreq), ::std::mem::transmute(ipaddrlist)))
8459 }
8460 #[cfg(not(windows))]
8461 unimplemented!("Unsupported target OS");
8462 }
8463 #[cfg(feature = "Win32_Foundation")]
8464 #[inline]
DhcpV4GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u328465 pub unsafe fn DhcpV4GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32 {
8466 #[cfg(windows)]
8467 {
8468 #[link(name = "windows")]
8469 extern "system" {
8470 fn DhcpV4GetOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut *mut DHCP_OPTION_VALUE) -> u32;
8471 }
8472 ::std::mem::transmute(DhcpV4GetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
8473 }
8474 #[cfg(not(windows))]
8475 unimplemented!("Unsupported target OS");
8476 }
8477 #[cfg(feature = "Win32_Foundation")]
8478 #[inline]
DhcpV4GetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY) -> u328479 pub unsafe fn DhcpV4GetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY) -> u32 {
8480 #[cfg(windows)]
8481 {
8482 #[link(name = "windows")]
8483 extern "system" {
8484 fn DhcpV4GetPolicy(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *mut *mut DHCP_POLICY) -> u32;
8485 }
8486 ::std::mem::transmute(DhcpV4GetPolicy(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8487 }
8488 #[cfg(not(windows))]
8489 unimplemented!("Unsupported target OS");
8490 }
8491 #[cfg(feature = "Win32_Foundation")]
8492 #[inline]
DhcpV4GetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY_EX) -> u328493 pub unsafe fn DhcpV4GetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, globalpolicy: Param1, subnetaddress: u32, policyname: Param3, policy: *mut *mut DHCP_POLICY_EX) -> u32 {
8494 #[cfg(windows)]
8495 {
8496 #[link(name = "windows")]
8497 extern "system" {
8498 fn DhcpV4GetPolicyEx(serveripaddress: super::super::Foundation::PWSTR, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *mut *mut DHCP_POLICY_EX) -> u32;
8499 }
8500 ::std::mem::transmute(DhcpV4GetPolicyEx(serveripaddress.into_param().abi(), globalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8501 }
8502 #[cfg(not(windows))]
8503 unimplemented!("Unsupported target OS");
8504 }
8505 #[cfg(feature = "Win32_Foundation")]
8506 #[inline]
DhcpV4QueryPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u328507 pub unsafe fn DhcpV4QueryPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u32 {
8508 #[cfg(windows)]
8509 {
8510 #[link(name = "windows")]
8511 extern "system" {
8512 fn DhcpV4QueryPolicyEnforcement(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enabled: *mut super::super::Foundation::BOOL) -> u32;
8513 }
8514 ::std::mem::transmute(DhcpV4QueryPolicyEnforcement(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), ::std::mem::transmute(enabled)))
8515 }
8516 #[cfg(not(windows))]
8517 unimplemented!("Unsupported target OS");
8518 }
8519 #[cfg(feature = "Win32_Foundation")]
8520 #[inline]
DhcpV4RemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u328521 pub unsafe fn DhcpV4RemoveOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32 {
8522 #[cfg(windows)]
8523 {
8524 #[link(name = "windows")]
8525 extern "system" {
8526 fn DhcpV4RemoveOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO) -> u32;
8527 }
8528 ::std::mem::transmute(DhcpV4RemoveOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo)))
8529 }
8530 #[cfg(not(windows))]
8531 unimplemented!("Unsupported target OS");
8532 }
8533 #[cfg(feature = "Win32_Foundation")]
8534 #[inline]
DhcpV4RemovePolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u328535 pub unsafe fn DhcpV4RemovePolicyRange<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, subnetaddress: u32, policyname: Param2, range: *const DHCP_IP_RANGE) -> u32 {
8536 #[cfg(windows)]
8537 {
8538 #[link(name = "windows")]
8539 extern "system" {
8540 fn DhcpV4RemovePolicyRange(serveripaddress: super::super::Foundation::PWSTR, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, range: *const DHCP_IP_RANGE) -> u32;
8541 }
8542 ::std::mem::transmute(DhcpV4RemovePolicyRange(serveripaddress.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(range)))
8543 }
8544 #[cfg(not(windows))]
8545 unimplemented!("Unsupported target OS");
8546 }
8547 #[cfg(feature = "Win32_Foundation")]
8548 #[inline]
DhcpV4SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u328549 pub unsafe fn DhcpV4SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, flags: u32, optionid: u32, policyname: Param3, vendorname: Param4, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32 {
8550 #[cfg(windows)]
8551 {
8552 #[link(name = "windows")]
8553 extern "system" {
8554 fn DhcpV4SetOptionValue(serveripaddress: super::super::Foundation::PWSTR, flags: u32, optionid: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalue: *mut DHCP_OPTION_DATA) -> u32;
8555 }
8556 ::std::mem::transmute(DhcpV4SetOptionValue(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(optionid), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalue)))
8557 }
8558 #[cfg(not(windows))]
8559 unimplemented!("Unsupported target OS");
8560 }
8561 #[cfg(feature = "Win32_Foundation")]
8562 #[inline]
DhcpV4SetOptionValues<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, policyname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u328563 pub unsafe fn DhcpV4SetOptionValues<'a, Param0: ::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>>(serveripaddress: Param0, flags: u32, policyname: Param2, vendorname: Param3, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32 {
8564 #[cfg(windows)]
8565 {
8566 #[link(name = "windows")]
8567 extern "system" {
8568 fn DhcpV4SetOptionValues(serveripaddress: super::super::Foundation::PWSTR, flags: u32, policyname: super::super::Foundation::PWSTR, vendorname: super::super::Foundation::PWSTR, scopeinfo: *mut DHCP_OPTION_SCOPE_INFO, optionvalues: *mut DHCP_OPTION_VALUE_ARRAY) -> u32;
8569 }
8570 ::std::mem::transmute(DhcpV4SetOptionValues(serveripaddress.into_param().abi(), ::std::mem::transmute(flags), policyname.into_param().abi(), vendorname.into_param().abi(), ::std::mem::transmute(scopeinfo), ::std::mem::transmute(optionvalues)))
8571 }
8572 #[cfg(not(windows))]
8573 unimplemented!("Unsupported target OS");
8574 }
8575 #[cfg(feature = "Win32_Foundation")]
8576 #[inline]
DhcpV4SetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, fglobalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY) -> u328577 pub unsafe fn DhcpV4SetPolicy<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, fglobalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY) -> u32 {
8578 #[cfg(windows)]
8579 {
8580 #[link(name = "windows")]
8581 extern "system" {
8582 fn DhcpV4SetPolicy(serveripaddress: super::super::Foundation::PWSTR, fieldsmodified: u32, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *const DHCP_POLICY) -> u32;
8583 }
8584 ::std::mem::transmute(DhcpV4SetPolicy(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldsmodified), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8585 }
8586 #[cfg(not(windows))]
8587 unimplemented!("Unsupported target OS");
8588 }
8589 #[cfg(feature = "Win32_Foundation")]
8590 #[inline]
DhcpV4SetPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enable: Param3) -> u328591 pub unsafe fn DhcpV4SetPolicyEnforcement<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(serveripaddress: Param0, fglobalpolicy: Param1, subnetaddress: u32, enable: Param3) -> u32 {
8592 #[cfg(windows)]
8593 {
8594 #[link(name = "windows")]
8595 extern "system" {
8596 fn DhcpV4SetPolicyEnforcement(serveripaddress: super::super::Foundation::PWSTR, fglobalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, enable: super::super::Foundation::BOOL) -> u32;
8597 }
8598 ::std::mem::transmute(DhcpV4SetPolicyEnforcement(serveripaddress.into_param().abi(), fglobalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), enable.into_param().abi()))
8599 }
8600 #[cfg(not(windows))]
8601 unimplemented!("Unsupported target OS");
8602 }
8603 #[cfg(feature = "Win32_Foundation")]
8604 #[inline]
DhcpV4SetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, globalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY_EX) -> u328605 pub unsafe fn DhcpV4SetPolicyEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, fieldsmodified: u32, globalpolicy: Param2, subnetaddress: u32, policyname: Param4, policy: *const DHCP_POLICY_EX) -> u32 {
8606 #[cfg(windows)]
8607 {
8608 #[link(name = "windows")]
8609 extern "system" {
8610 fn DhcpV4SetPolicyEx(serveripaddress: super::super::Foundation::PWSTR, fieldsmodified: u32, globalpolicy: super::super::Foundation::BOOL, subnetaddress: u32, policyname: super::super::Foundation::PWSTR, policy: *const DHCP_POLICY_EX) -> u32;
8611 }
8612 ::std::mem::transmute(DhcpV4SetPolicyEx(serveripaddress.into_param().abi(), ::std::mem::transmute(fieldsmodified), globalpolicy.into_param().abi(), ::std::mem::transmute(subnetaddress), policyname.into_param().abi(), ::std::mem::transmute(policy)))
8613 }
8614 #[cfg(not(windows))]
8615 unimplemented!("Unsupported target OS");
8616 }
8617 #[cfg(feature = "Win32_Foundation")]
8618 #[inline]
DhcpV6CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u328619 pub unsafe fn DhcpV6CreateClientInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32 {
8620 #[cfg(windows)]
8621 {
8622 #[link(name = "windows")]
8623 extern "system" {
8624 fn DhcpV6CreateClientInfo(serveripaddress: super::super::Foundation::PWSTR, clientinfo: *const DHCP_CLIENT_INFO_V6) -> u32;
8625 }
8626 ::std::mem::transmute(DhcpV6CreateClientInfo(serveripaddress.into_param().abi(), ::std::mem::transmute(clientinfo)))
8627 }
8628 #[cfg(not(windows))]
8629 unimplemented!("Unsupported target OS");
8630 }
8631 #[cfg(feature = "Win32_Foundation")]
8632 #[inline]
DhcpV6GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param3: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, scopeid: Param1, startip: Param2, endip: Param3, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u328633 pub unsafe fn DhcpV6GetFreeIPAddress<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>, Param3: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, scopeid: Param1, startip: Param2, endip: Param3, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u32 {
8634 #[cfg(windows)]
8635 {
8636 #[link(name = "windows")]
8637 extern "system" {
8638 fn DhcpV6GetFreeIPAddress(serveripaddress: super::super::Foundation::PWSTR, scopeid: DHCP_IPV6_ADDRESS, startip: DHCP_IPV6_ADDRESS, endip: DHCP_IPV6_ADDRESS, numfreeaddrreq: u32, ipaddrlist: *mut *mut DHCPV6_IP_ARRAY) -> u32;
8639 }
8640 ::std::mem::transmute(DhcpV6GetFreeIPAddress(serveripaddress.into_param().abi(), scopeid.into_param().abi(), startip.into_param().abi(), endip.into_param().abi(), ::std::mem::transmute(numfreeaddrreq), ::std::mem::transmute(ipaddrlist)))
8641 }
8642 #[cfg(not(windows))]
8643 unimplemented!("Unsupported target OS");
8644 }
8645 #[cfg(feature = "Win32_Foundation")]
8646 #[inline]
DhcpV6GetStatelessStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u328647 pub unsafe fn DhcpV6GetStatelessStatistics<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(serveripaddress: Param0, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u32 {
8648 #[cfg(windows)]
8649 {
8650 #[link(name = "windows")]
8651 extern "system" {
8652 fn DhcpV6GetStatelessStatistics(serveripaddress: super::super::Foundation::PWSTR, statelessstats: *mut *mut DHCPV6_STATELESS_STATS) -> u32;
8653 }
8654 ::std::mem::transmute(DhcpV6GetStatelessStatistics(serveripaddress.into_param().abi(), ::std::mem::transmute(statelessstats)))
8655 }
8656 #[cfg(not(windows))]
8657 unimplemented!("Unsupported target OS");
8658 }
8659 #[cfg(feature = "Win32_Foundation")]
8660 #[inline]
DhcpV6GetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u328661 pub unsafe fn DhcpV6GetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u32 {
8662 #[cfg(windows)]
8663 {
8664 #[link(name = "windows")]
8665 extern "system" {
8666 fn DhcpV6GetStatelessStoreParams(serveripaddress: super::super::Foundation::PWSTR, fserverlevel: super::super::Foundation::BOOL, subnetaddress: DHCP_IPV6_ADDRESS, params: *mut *mut DHCPV6_STATELESS_PARAMS) -> u32;
8667 }
8668 ::std::mem::transmute(DhcpV6GetStatelessStoreParams(serveripaddress.into_param().abi(), fserverlevel.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(params)))
8669 }
8670 #[cfg(not(windows))]
8671 unimplemented!("Unsupported target OS");
8672 }
8673 #[cfg(feature = "Win32_Foundation")]
8674 #[inline]
DhcpV6SetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u328675 pub unsafe fn DhcpV6SetStatelessStoreParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, DHCP_IPV6_ADDRESS>>(serveripaddress: Param0, fserverlevel: Param1, subnetaddress: Param2, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u32 {
8676 #[cfg(windows)]
8677 {
8678 #[link(name = "windows")]
8679 extern "system" {
8680 fn DhcpV6SetStatelessStoreParams(serveripaddress: super::super::Foundation::PWSTR, fserverlevel: super::super::Foundation::BOOL, subnetaddress: DHCP_IPV6_ADDRESS, fieldmodified: u32, params: *const DHCPV6_STATELESS_PARAMS) -> u32;
8681 }
8682 ::std::mem::transmute(DhcpV6SetStatelessStoreParams(serveripaddress.into_param().abi(), fserverlevel.into_param().abi(), subnetaddress.into_param().abi(), ::std::mem::transmute(fieldmodified), ::std::mem::transmute(params)))
8683 }
8684 #[cfg(not(windows))]
8685 unimplemented!("Unsupported target OS");
8686 }
8687 #[inline]
Dhcpv6CApiCleanup()8688 pub unsafe fn Dhcpv6CApiCleanup() {
8689 #[cfg(windows)]
8690 {
8691 #[link(name = "windows")]
8692 extern "system" {
8693 fn Dhcpv6CApiCleanup();
8694 }
8695 ::std::mem::transmute(Dhcpv6CApiCleanup())
8696 }
8697 #[cfg(not(windows))]
8698 unimplemented!("Unsupported target OS");
8699 }
8700 #[inline]
Dhcpv6CApiInitialize(version: *mut u32)8701 pub unsafe fn Dhcpv6CApiInitialize(version: *mut u32) {
8702 #[cfg(windows)]
8703 {
8704 #[link(name = "windows")]
8705 extern "system" {
8706 fn Dhcpv6CApiInitialize(version: *mut u32);
8707 }
8708 ::std::mem::transmute(Dhcpv6CApiInitialize(::std::mem::transmute(version)))
8709 }
8710 #[cfg(not(windows))]
8711 unimplemented!("Unsupported target OS");
8712 }
8713 #[cfg(feature = "Win32_Foundation")]
8714 #[inline]
Dhcpv6ReleasePrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u328715 pub unsafe fn Dhcpv6ReleasePrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u32 {
8716 #[cfg(windows)]
8717 {
8718 #[link(name = "windows")]
8719 extern "system" {
8720 fn Dhcpv6ReleasePrefix(adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPV6CAPI_CLASSID, leaseinfo: *mut DHCPV6PrefixLeaseInformation) -> u32;
8721 }
8722 ::std::mem::transmute(Dhcpv6ReleasePrefix(adaptername.into_param().abi(), ::std::mem::transmute(classid), ::std::mem::transmute(leaseinfo)))
8723 }
8724 #[cfg(not(windows))]
8725 unimplemented!("Unsupported target OS");
8726 }
8727 #[cfg(feature = "Win32_Foundation")]
8728 #[inline]
Dhcpv6RenewPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u328729 pub unsafe fn Dhcpv6RenewPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u32 {
8730 #[cfg(windows)]
8731 {
8732 #[link(name = "windows")]
8733 extern "system" {
8734 fn Dhcpv6RenewPrefix(adaptername: super::super::Foundation::PWSTR, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32, bvalidateprefix: u32) -> u32;
8735 }
8736 ::std::mem::transmute(Dhcpv6RenewPrefix(adaptername.into_param().abi(), ::std::mem::transmute(pclassid), ::std::mem::transmute(prefixleaseinfo), ::std::mem::transmute(pdwtimetowait), ::std::mem::transmute(bvalidateprefix)))
8737 }
8738 #[cfg(not(windows))]
8739 unimplemented!("Unsupported target OS");
8740 }
8741 #[cfg(feature = "Win32_Foundation")]
8742 #[inline]
Dhcpv6RequestParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPV6CAPI_PARAMS_ARRAY>>(forcenewinform: Param0, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPV6CAPI_CLASSID, recdparams: Param4, buffer: *mut u8, psize: *mut u32) -> u328743 pub unsafe fn Dhcpv6RequestParams<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, DHCPV6CAPI_PARAMS_ARRAY>>(forcenewinform: Param0, reserved: *mut ::std::ffi::c_void, adaptername: Param2, classid: *mut DHCPV6CAPI_CLASSID, recdparams: Param4, buffer: *mut u8, psize: *mut u32) -> u32 {
8744 #[cfg(windows)]
8745 {
8746 #[link(name = "windows")]
8747 extern "system" {
8748 fn Dhcpv6RequestParams(forcenewinform: super::super::Foundation::BOOL, reserved: *mut ::std::ffi::c_void, adaptername: super::super::Foundation::PWSTR, classid: *mut DHCPV6CAPI_CLASSID, recdparams: DHCPV6CAPI_PARAMS_ARRAY, buffer: *mut u8, psize: *mut u32) -> u32;
8749 }
8750 ::std::mem::transmute(Dhcpv6RequestParams(forcenewinform.into_param().abi(), ::std::mem::transmute(reserved), adaptername.into_param().abi(), ::std::mem::transmute(classid), recdparams.into_param().abi(), ::std::mem::transmute(buffer), ::std::mem::transmute(psize)))
8751 }
8752 #[cfg(not(windows))]
8753 unimplemented!("Unsupported target OS");
8754 }
8755 #[cfg(feature = "Win32_Foundation")]
8756 #[inline]
Dhcpv6RequestPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u328757 pub unsafe fn Dhcpv6RequestPrefix<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PWSTR>>(adaptername: Param0, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u32 {
8758 #[cfg(windows)]
8759 {
8760 #[link(name = "windows")]
8761 extern "system" {
8762 fn Dhcpv6RequestPrefix(adaptername: super::super::Foundation::PWSTR, pclassid: *mut DHCPV6CAPI_CLASSID, prefixleaseinfo: *mut DHCPV6PrefixLeaseInformation, pdwtimetowait: *mut u32) -> u32;
8763 }
8764 ::std::mem::transmute(Dhcpv6RequestPrefix(adaptername.into_param().abi(), ::std::mem::transmute(pclassid), ::std::mem::transmute(prefixleaseinfo), ::std::mem::transmute(pdwtimetowait)))
8765 }
8766 #[cfg(not(windows))]
8767 unimplemented!("Unsupported target OS");
8768 }
8769 pub const ERROR_DDS_CLASS_DOES_NOT_EXIST: u32 = 20078u32;
8770 pub const ERROR_DDS_CLASS_EXISTS: u32 = 20077u32;
8771 pub const ERROR_DDS_DHCP_SERVER_NOT_FOUND: u32 = 20074u32;
8772 pub const ERROR_DDS_NO_DHCP_ROOT: u32 = 20071u32;
8773 pub const ERROR_DDS_NO_DS_AVAILABLE: u32 = 20070u32;
8774 pub const ERROR_DDS_OPTION_ALREADY_EXISTS: u32 = 20075u32;
8775 pub const ERROR_DDS_OPTION_DOES_NOT_EXIST: u32 = 20076u32;
8776 pub const ERROR_DDS_POSSIBLE_RANGE_CONFLICT: u32 = 20087u32;
8777 pub const ERROR_DDS_RANGE_DOES_NOT_EXIST: u32 = 20088u32;
8778 pub const ERROR_DDS_RESERVATION_CONFLICT: u32 = 20086u32;
8779 pub const ERROR_DDS_RESERVATION_NOT_PRESENT: u32 = 20085u32;
8780 pub const ERROR_DDS_SERVER_ADDRESS_MISMATCH: u32 = 20081u32;
8781 pub const ERROR_DDS_SERVER_ALREADY_EXISTS: u32 = 20079u32;
8782 pub const ERROR_DDS_SERVER_DOES_NOT_EXIST: u32 = 20080u32;
8783 pub const ERROR_DDS_SUBNET_EXISTS: u32 = 20082u32;
8784 pub const ERROR_DDS_SUBNET_HAS_DIFF_SSCOPE: u32 = 20083u32;
8785 pub const ERROR_DDS_SUBNET_NOT_PRESENT: u32 = 20084u32;
8786 pub const ERROR_DDS_TOO_MANY_ERRORS: u32 = 20073u32;
8787 pub const ERROR_DDS_UNEXPECTED_ERROR: u32 = 20072u32;
8788 pub const ERROR_DHCP_ADDRESS_NOT_AVAILABLE: u32 = 20011u32;
8789 pub const ERROR_DHCP_CANNOT_MODIFY_BINDINGS: u32 = 20051u32;
8790 pub const ERROR_DHCP_CANT_CHANGE_ATTRIBUTE: u32 = 20048u32;
8791 pub const ERROR_DHCP_CLASS_ALREADY_EXISTS: u32 = 20045u32;
8792 pub const ERROR_DHCP_CLASS_NOT_FOUND: u32 = 20044u32;
8793 pub const ERROR_DHCP_CLIENT_EXISTS: u32 = 20014u32;
8794 pub const ERROR_DHCP_DATABASE_INIT_FAILED: u32 = 20001u32;
8795 pub const ERROR_DHCP_DEFAULT_SCOPE_EXITS: u32 = 20047u32;
8796 pub const ERROR_DHCP_DELETE_BUILTIN_CLASS: u32 = 20089u32;
8797 pub const ERROR_DHCP_ELEMENT_CANT_REMOVE: u32 = 20007u32;
8798 pub const ERROR_DHCP_EXEMPTION_EXISTS: u32 = 20055u32;
8799 pub const ERROR_DHCP_EXEMPTION_NOT_PRESENT: u32 = 20056u32;
8800 pub const ERROR_DHCP_FO_ADDSCOPE_LEASES_NOT_SYNCED: u32 = 20127u32;
8801 pub const ERROR_DHCP_FO_BOOT_NOT_SUPPORTED: u32 = 20131u32;
8802 pub const ERROR_DHCP_FO_FEATURE_NOT_SUPPORTED: u32 = 20134u32;
8803 pub const ERROR_DHCP_FO_IPRANGE_TYPE_CONV_ILLEGAL: u32 = 20129u32;
8804 pub const ERROR_DHCP_FO_MAX_ADD_SCOPES: u32 = 20130u32;
8805 pub const ERROR_DHCP_FO_MAX_RELATIONSHIPS: u32 = 20128u32;
8806 pub const ERROR_DHCP_FO_NOT_SUPPORTED: u32 = 20118u32;
8807 pub const ERROR_DHCP_FO_RANGE_PART_OF_REL: u32 = 20132u32;
8808 pub const ERROR_DHCP_FO_RELATIONSHIP_DOES_NOT_EXIST: u32 = 20115u32;
8809 pub const ERROR_DHCP_FO_RELATIONSHIP_EXISTS: u32 = 20114u32;
8810 pub const ERROR_DHCP_FO_RELATIONSHIP_NAME_TOO_LONG: u32 = 20125u32;
8811 pub const ERROR_DHCP_FO_RELATION_IS_SECONDARY: u32 = 20117u32;
8812 pub const ERROR_DHCP_FO_SCOPE_ALREADY_IN_RELATIONSHIP: u32 = 20113u32;
8813 pub const ERROR_DHCP_FO_SCOPE_NOT_IN_RELATIONSHIP: u32 = 20116u32;
8814 pub const ERROR_DHCP_FO_SCOPE_SYNC_IN_PROGRESS: u32 = 20133u32;
8815 pub const ERROR_DHCP_FO_STATE_NOT_NORMAL: u32 = 20120u32;
8816 pub const ERROR_DHCP_FO_TIME_OUT_OF_SYNC: u32 = 20119u32;
8817 pub const ERROR_DHCP_HARDWARE_ADDRESS_TYPE_ALREADY_EXEMPT: u32 = 20101u32;
8818 pub const ERROR_DHCP_INVALID_DELAY: u32 = 20092u32;
8819 pub const ERROR_DHCP_INVALID_DHCP_CLIENT: u32 = 20016u32;
8820 pub const ERROR_DHCP_INVALID_DHCP_MESSAGE: u32 = 20015u32;
8821 pub const ERROR_DHCP_INVALID_PARAMETER_OPTION32: u32 = 20057u32;
8822 pub const ERROR_DHCP_INVALID_POLICY_EXPRESSION: u32 = 20109u32;
8823 pub const ERROR_DHCP_INVALID_PROCESSING_ORDER: u32 = 20110u32;
8824 pub const ERROR_DHCP_INVALID_RANGE: u32 = 20023u32;
8825 pub const ERROR_DHCP_INVALID_SUBNET_PREFIX: u32 = 20091u32;
8826 pub const ERROR_DHCP_IPRANGE_CONV_ILLEGAL: u32 = 20049u32;
8827 pub const ERROR_DHCP_IPRANGE_EXITS: u32 = 20021u32;
8828 pub const ERROR_DHCP_IP_ADDRESS_IN_USE: u32 = 20032u32;
8829 pub const ERROR_DHCP_JET97_CONV_REQUIRED: u32 = 20036u32;
8830 pub const ERROR_DHCP_JET_CONV_REQUIRED: u32 = 20027u32;
8831 pub const ERROR_DHCP_JET_ERROR: u32 = 20013u32;
8832 pub const ERROR_DHCP_LINKLAYER_ADDRESS_DOES_NOT_EXIST: u32 = 20095u32;
8833 pub const ERROR_DHCP_LINKLAYER_ADDRESS_EXISTS: u32 = 20093u32;
8834 pub const ERROR_DHCP_LINKLAYER_ADDRESS_RESERVATION_EXISTS: u32 = 20094u32;
8835 pub const ERROR_DHCP_LOG_FILE_PATH_TOO_LONG: u32 = 20033u32;
8836 pub const ERROR_DHCP_MSCOPE_EXISTS: u32 = 20053u32;
8837 pub const ERROR_DHCP_NAP_NOT_SUPPORTED: u32 = 20138u32;
8838 pub const ERROR_DHCP_NETWORK_CHANGED: u32 = 20050u32;
8839 pub const ERROR_DHCP_NETWORK_INIT_FAILED: u32 = 20003u32;
8840 pub const ERROR_DHCP_NOT_RESERVED_CLIENT: u32 = 20018u32;
8841 pub const ERROR_DHCP_NO_ADMIN_PERMISSION: u32 = 20121u32;
8842 pub const ERROR_DHCP_OPTION_EXITS: u32 = 20009u32;
8843 pub const ERROR_DHCP_OPTION_NOT_PRESENT: u32 = 20010u32;
8844 pub const ERROR_DHCP_OPTION_TYPE_MISMATCH: u32 = 20103u32;
8845 pub const ERROR_DHCP_POLICY_BAD_PARENT_EXPR: u32 = 20104u32;
8846 pub const ERROR_DHCP_POLICY_EDIT_FQDN_UNSUPPORTED: u32 = 20137u32;
8847 pub const ERROR_DHCP_POLICY_EXISTS: u32 = 20105u32;
8848 pub const ERROR_DHCP_POLICY_FQDN_OPTION_UNSUPPORTED: u32 = 20136u32;
8849 pub const ERROR_DHCP_POLICY_FQDN_RANGE_UNSUPPORTED: u32 = 20135u32;
8850 pub const ERROR_DHCP_POLICY_NOT_FOUND: u32 = 20111u32;
8851 pub const ERROR_DHCP_POLICY_RANGE_BAD: u32 = 20107u32;
8852 pub const ERROR_DHCP_POLICY_RANGE_EXISTS: u32 = 20106u32;
8853 pub const ERROR_DHCP_PRIMARY_NOT_FOUND: u32 = 20006u32;
8854 pub const ERROR_DHCP_RANGE_EXTENDED: u32 = 20024u32;
8855 pub const ERROR_DHCP_RANGE_FULL: u32 = 20012u32;
8856 pub const ERROR_DHCP_RANGE_INVALID_IN_SERVER_POLICY: u32 = 20108u32;
8857 pub const ERROR_DHCP_RANGE_TOO_SMALL: u32 = 20020u32;
8858 pub const ERROR_DHCP_REACHED_END_OF_SELECTION: u32 = 20126u32;
8859 pub const ERROR_DHCP_REGISTRY_INIT_FAILED: u32 = 20000u32;
8860 pub const ERROR_DHCP_RESERVEDIP_EXITS: u32 = 20022u32;
8861 pub const ERROR_DHCP_RESERVED_CLIENT: u32 = 20019u32;
8862 pub const ERROR_DHCP_ROGUE_DS_CONFLICT: u32 = 20041u32;
8863 pub const ERROR_DHCP_ROGUE_DS_UNREACHABLE: u32 = 20040u32;
8864 pub const ERROR_DHCP_ROGUE_INIT_FAILED: u32 = 20037u32;
8865 pub const ERROR_DHCP_ROGUE_NOT_AUTHORIZED: u32 = 20039u32;
8866 pub const ERROR_DHCP_ROGUE_NOT_OUR_ENTERPRISE: u32 = 20042u32;
8867 pub const ERROR_DHCP_ROGUE_SAMSHUTDOWN: u32 = 20038u32;
8868 pub const ERROR_DHCP_ROGUE_STANDALONE_IN_DS: u32 = 20043u32;
8869 pub const ERROR_DHCP_RPC_INIT_FAILED: u32 = 20002u32;
8870 pub const ERROR_DHCP_SCOPE_NAME_TOO_LONG: u32 = 20046u32;
8871 pub const ERROR_DHCP_SERVER_NAME_NOT_RESOLVED: u32 = 20124u32;
8872 pub const ERROR_DHCP_SERVER_NOT_REACHABLE: u32 = 20122u32;
8873 pub const ERROR_DHCP_SERVER_NOT_RUNNING: u32 = 20123u32;
8874 pub const ERROR_DHCP_SERVICE_PAUSED: u32 = 20017u32;
8875 pub const ERROR_DHCP_SUBNET_EXISTS: u32 = 20052u32;
8876 pub const ERROR_DHCP_SUBNET_EXITS: u32 = 20004u32;
8877 pub const ERROR_DHCP_SUBNET_NOT_PRESENT: u32 = 20005u32;
8878 pub const ERROR_DHCP_SUPER_SCOPE_NAME_TOO_LONG: u32 = 20030u32;
8879 pub const ERROR_DHCP_UNDEFINED_HARDWARE_ADDRESS_TYPE: u32 = 20102u32;
8880 pub const ERROR_DHCP_UNSUPPORTED_CLIENT: u32 = 20034u32;
8881 pub const ERROR_EXTEND_TOO_SMALL: u32 = 20025u32;
8882 pub const ERROR_LAST_DHCP_SERVER_ERROR: u32 = 20139u32;
8883 pub const ERROR_MSCOPE_RANGE_TOO_SMALL: u32 = 20054u32;
8884 pub const ERROR_SCOPE_RANGE_POLICY_RANGE_CONFLICT: u32 = 20112u32;
8885 pub const ERROR_SERVER_INVALID_BOOT_FILE_TABLE: u32 = 20028u32;
8886 pub const ERROR_SERVER_UNKNOWN_BOOT_FILE_NAME: u32 = 20029u32;
8887 pub const FILTER_STATUS_FULL_MATCH_IN_ALLOW_LIST: u32 = 2u32;
8888 pub const FILTER_STATUS_FULL_MATCH_IN_DENY_LIST: u32 = 4u32;
8889 pub const FILTER_STATUS_NONE: u32 = 1u32;
8890 pub const FILTER_STATUS_WILDCARD_MATCH_IN_ALLOW_LIST: u32 = 8u32;
8891 pub const FILTER_STATUS_WILDCARD_MATCH_IN_DENY_LIST: u32 = 16u32;
8892 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8893 #[repr(transparent)]
8894 pub struct FSM_STATE(pub i32);
8895 pub const NO_STATE: FSM_STATE = FSM_STATE(0i32);
8896 pub const INIT: FSM_STATE = FSM_STATE(1i32);
8897 pub const STARTUP: FSM_STATE = FSM_STATE(2i32);
8898 pub const NORMAL: FSM_STATE = FSM_STATE(3i32);
8899 pub const COMMUNICATION_INT: FSM_STATE = FSM_STATE(4i32);
8900 pub const PARTNER_DOWN: FSM_STATE = FSM_STATE(5i32);
8901 pub const POTENTIAL_CONFLICT: FSM_STATE = FSM_STATE(6i32);
8902 pub const CONFLICT_DONE: FSM_STATE = FSM_STATE(7i32);
8903 pub const RESOLUTION_INT: FSM_STATE = FSM_STATE(8i32);
8904 pub const RECOVER: FSM_STATE = FSM_STATE(9i32);
8905 pub const RECOVER_WAIT: FSM_STATE = FSM_STATE(10i32);
8906 pub const RECOVER_DONE: FSM_STATE = FSM_STATE(11i32);
8907 pub const PAUSED: FSM_STATE = FSM_STATE(12i32);
8908 pub const SHUTDOWN: FSM_STATE = FSM_STATE(13i32);
8909 impl ::std::convert::From<i32> for FSM_STATE {
from(value: i32) -> Self8910 fn from(value: i32) -> Self {
8911 Self(value)
8912 }
8913 }
8914 unsafe impl ::windows::runtime::Abi for FSM_STATE {
8915 type Abi = Self;
8916 type DefaultType = Self;
8917 }
8918 pub const HWTYPE_ETHERNET_10MB: u32 = 1u32;
8919 pub type LPDHCP_CONTROL = unsafe extern "system" fn(dwcontrolcode: u32, lpreserved: *mut ::std::ffi::c_void) -> u32;
8920 pub type LPDHCP_DELETE_CLIENT = unsafe extern "system" fn(ipaddress: u32, hwaddress: *mut u8, hwaddresslength: u32, reserved: u32, clienttype: u32) -> u32;
8921 pub type LPDHCP_DROP_SEND = unsafe extern "system" fn(packet: *mut *mut u8, packetsize: *mut u32, controlcode: u32, ipaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8922 #[cfg(feature = "Win32_Foundation")]
8923 pub type LPDHCP_ENTRY_POINT_FUNC = unsafe extern "system" fn(chaindlls: super::super::Foundation::PWSTR, calloutversion: u32, callouttbl: *mut ::std::mem::ManuallyDrop<DHCP_CALLOUT_TABLE>) -> u32;
8924 pub type LPDHCP_GIVE_ADDRESS = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, controlcode: u32, ipaddress: u32, altaddress: u32, addrtype: u32, leasetime: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8925 #[cfg(feature = "Win32_Foundation")]
8926 pub type LPDHCP_HANDLE_OPTIONS = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void, serveroptions: *mut DHCP_SERVER_OPTIONS) -> u32;
8927 pub type LPDHCP_NEWPKT = unsafe extern "system" fn(packet: *mut *mut u8, packetsize: *mut u32, ipaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut *mut ::std::ffi::c_void, processit: *mut i32) -> u32;
8928 pub type LPDHCP_PROB = unsafe extern "system" fn(packet: *mut u8, packetsize: u32, controlcode: u32, ipaddress: u32, altaddress: u32, reserved: *mut ::std::ffi::c_void, pktcontext: *mut ::std::ffi::c_void) -> u32;
8929 pub const MAC_ADDRESS_LENGTH: u32 = 6u32;
8930 pub const MAX_PATTERN_LENGTH: u32 = 255u32;
8931 pub const MCLT: u32 = 1u32;
8932 pub const MODE: u32 = 16u32;
8933 pub const OPTION_ALL_SUBNETS_MTU: u32 = 27u32;
8934 pub const OPTION_ARP_CACHE_TIMEOUT: u32 = 35u32;
8935 pub const OPTION_BE_A_MASK_SUPPLIER: u32 = 30u32;
8936 pub const OPTION_BE_A_ROUTER: u32 = 19u32;
8937 pub const OPTION_BOOTFILE_NAME: u32 = 67u32;
8938 pub const OPTION_BOOT_FILE_SIZE: u32 = 13u32;
8939 pub const OPTION_BROADCAST_ADDRESS: u32 = 28u32;
8940 pub const OPTION_CLIENT_CLASS_INFO: u32 = 60u32;
8941 pub const OPTION_CLIENT_ID: u32 = 61u32;
8942 pub const OPTION_COOKIE_SERVERS: u32 = 8u32;
8943 pub const OPTION_DEFAULT_TTL: u32 = 23u32;
8944 pub const OPTION_DOMAIN_NAME: u32 = 15u32;
8945 pub const OPTION_DOMAIN_NAME_SERVERS: u32 = 6u32;
8946 pub const OPTION_END: u32 = 255u32;
8947 pub const OPTION_ETHERNET_ENCAPSULATION: u32 = 36u32;
8948 pub const OPTION_EXTENSIONS_PATH: u32 = 18u32;
8949 pub const OPTION_HOST_NAME: u32 = 12u32;
8950 pub const OPTION_IEN116_NAME_SERVERS: u32 = 5u32;
8951 pub const OPTION_IMPRESS_SERVERS: u32 = 10u32;
8952 pub const OPTION_KEEP_ALIVE_DATA_SIZE: u32 = 39u32;
8953 pub const OPTION_KEEP_ALIVE_INTERVAL: u32 = 38u32;
8954 pub const OPTION_LEASE_TIME: u32 = 51u32;
8955 pub const OPTION_LOG_SERVERS: u32 = 7u32;
8956 pub const OPTION_LPR_SERVERS: u32 = 9u32;
8957 pub const OPTION_MAX_REASSEMBLY_SIZE: u32 = 22u32;
8958 pub const OPTION_MERIT_DUMP_FILE: u32 = 14u32;
8959 pub const OPTION_MESSAGE: u32 = 56u32;
8960 pub const OPTION_MESSAGE_LENGTH: u32 = 57u32;
8961 pub const OPTION_MESSAGE_TYPE: u32 = 53u32;
8962 pub const OPTION_MSFT_IE_PROXY: u32 = 252u32;
8963 pub const OPTION_MTU: u32 = 26u32;
8964 pub const OPTION_NETBIOS_DATAGRAM_SERVER: u32 = 45u32;
8965 pub const OPTION_NETBIOS_NAME_SERVER: u32 = 44u32;
8966 pub const OPTION_NETBIOS_NODE_TYPE: u32 = 46u32;
8967 pub const OPTION_NETBIOS_SCOPE_OPTION: u32 = 47u32;
8968 pub const OPTION_NETWORK_INFO_SERVERS: u32 = 41u32;
8969 pub const OPTION_NETWORK_INFO_SERVICE_DOM: u32 = 40u32;
8970 pub const OPTION_NETWORK_TIME_SERVERS: u32 = 42u32;
8971 pub const OPTION_NON_LOCAL_SOURCE_ROUTING: u32 = 20u32;
8972 pub const OPTION_OK_TO_OVERLAY: u32 = 52u32;
8973 pub const OPTION_PAD: u32 = 0u32;
8974 pub const OPTION_PARAMETER_REQUEST_LIST: u32 = 55u32;
8975 pub const OPTION_PERFORM_MASK_DISCOVERY: u32 = 29u32;
8976 pub const OPTION_PERFORM_ROUTER_DISCOVERY: u32 = 31u32;
8977 pub const OPTION_PMTU_AGING_TIMEOUT: u32 = 24u32;
8978 pub const OPTION_PMTU_PLATEAU_TABLE: u32 = 25u32;
8979 pub const OPTION_POLICY_FILTER_FOR_NLSR: u32 = 21u32;
8980 pub const OPTION_REBIND_TIME: u32 = 59u32;
8981 pub const OPTION_RENEWAL_TIME: u32 = 58u32;
8982 pub const OPTION_REQUESTED_ADDRESS: u32 = 50u32;
8983 pub const OPTION_RLP_SERVERS: u32 = 11u32;
8984 pub const OPTION_ROOT_DISK: u32 = 17u32;
8985 pub const OPTION_ROUTER_ADDRESS: u32 = 3u32;
8986 pub const OPTION_ROUTER_SOLICITATION_ADDR: u32 = 32u32;
8987 pub const OPTION_SERVER_IDENTIFIER: u32 = 54u32;
8988 pub const OPTION_STATIC_ROUTES: u32 = 33u32;
8989 pub const OPTION_SUBNET_MASK: u32 = 1u32;
8990 pub const OPTION_SWAP_SERVER: u32 = 16u32;
8991 pub const OPTION_TFTP_SERVER_NAME: u32 = 66u32;
8992 pub const OPTION_TIME_OFFSET: u32 = 2u32;
8993 pub const OPTION_TIME_SERVERS: u32 = 4u32;
8994 pub const OPTION_TRAILERS: u32 = 34u32;
8995 pub const OPTION_TTL: u32 = 37u32;
8996 pub const OPTION_VENDOR_SPEC_INFO: u32 = 43u32;
8997 pub const OPTION_XWINDOW_DISPLAY_MANAGER: u32 = 49u32;
8998 pub const OPTION_XWINDOW_FONT_SERVER: u32 = 48u32;
8999 pub const PERCENTAGE: u32 = 8u32;
9000 pub const PREVSTATE: u32 = 32u32;
9001 pub const QUARANTINE_CONFIG_OPTION: u32 = 43222u32;
9002 pub const QUARANTINE_SCOPE_QUARPROFILE_OPTION: u32 = 43221u32;
9003 pub const QUARANTIN_OPTION_BASE: u32 = 43220u32;
9004 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9005 #[repr(transparent)]
9006 pub struct QuarantineStatus(pub i32);
9007 pub const NOQUARANTINE: QuarantineStatus = QuarantineStatus(0i32);
9008 pub const RESTRICTEDACCESS: QuarantineStatus = QuarantineStatus(1i32);
9009 pub const DROPPACKET: QuarantineStatus = QuarantineStatus(2i32);
9010 pub const PROBATION: QuarantineStatus = QuarantineStatus(3i32);
9011 pub const EXEMPT: QuarantineStatus = QuarantineStatus(4i32);
9012 pub const DEFAULTQUARSETTING: QuarantineStatus = QuarantineStatus(5i32);
9013 pub const NOQUARINFO: QuarantineStatus = QuarantineStatus(6i32);
9014 impl ::std::convert::From<i32> for QuarantineStatus {
from(value: i32) -> Self9015 fn from(value: i32) -> Self {
9016 Self(value)
9017 }
9018 }
9019 unsafe impl ::windows::runtime::Abi for QuarantineStatus {
9020 type Abi = Self;
9021 type DefaultType = Self;
9022 }
9023 pub const SAFEPERIOD: u32 = 2u32;
9024 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9025 #[repr(C)]
9026 pub struct SCOPE_MIB_INFO {
9027 pub Subnet: u32,
9028 pub NumAddressesInuse: u32,
9029 pub NumAddressesFree: u32,
9030 pub NumPendingOffers: u32,
9031 }
9032 impl SCOPE_MIB_INFO {}
9033 impl ::std::default::Default for SCOPE_MIB_INFO {
default() -> Self9034 fn default() -> Self {
9035 unsafe { ::std::mem::zeroed() }
9036 }
9037 }
9038 impl ::std::fmt::Debug for SCOPE_MIB_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9039 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9040 fmt.debug_struct("SCOPE_MIB_INFO").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingOffers", &self.NumPendingOffers).finish()
9041 }
9042 }
9043 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO {
eq(&self, other: &Self) -> bool9044 fn eq(&self, other: &Self) -> bool {
9045 self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers
9046 }
9047 }
9048 impl ::std::cmp::Eq for SCOPE_MIB_INFO {}
9049 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO {
9050 type Abi = Self;
9051 type DefaultType = Self;
9052 }
9053 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9054 #[repr(C)]
9055 pub struct SCOPE_MIB_INFO_V5 {
9056 pub Subnet: u32,
9057 pub NumAddressesInuse: u32,
9058 pub NumAddressesFree: u32,
9059 pub NumPendingOffers: u32,
9060 }
9061 impl SCOPE_MIB_INFO_V5 {}
9062 impl ::std::default::Default for SCOPE_MIB_INFO_V5 {
default() -> Self9063 fn default() -> Self {
9064 unsafe { ::std::mem::zeroed() }
9065 }
9066 }
9067 impl ::std::fmt::Debug for SCOPE_MIB_INFO_V5 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9068 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9069 fmt.debug_struct("SCOPE_MIB_INFO_V5").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingOffers", &self.NumPendingOffers).finish()
9070 }
9071 }
9072 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_V5 {
eq(&self, other: &Self) -> bool9073 fn eq(&self, other: &Self) -> bool {
9074 self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers
9075 }
9076 }
9077 impl ::std::cmp::Eq for SCOPE_MIB_INFO_V5 {}
9078 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_V5 {
9079 type Abi = Self;
9080 type DefaultType = Self;
9081 }
9082 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9083 #[repr(C)]
9084 pub struct SCOPE_MIB_INFO_V6 {
9085 pub Subnet: DHCP_IPV6_ADDRESS,
9086 pub NumAddressesInuse: u64,
9087 pub NumAddressesFree: u64,
9088 pub NumPendingAdvertises: u64,
9089 }
9090 impl SCOPE_MIB_INFO_V6 {}
9091 impl ::std::default::Default for SCOPE_MIB_INFO_V6 {
default() -> Self9092 fn default() -> Self {
9093 unsafe { ::std::mem::zeroed() }
9094 }
9095 }
9096 impl ::std::fmt::Debug for SCOPE_MIB_INFO_V6 {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9097 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9098 fmt.debug_struct("SCOPE_MIB_INFO_V6").field("Subnet", &self.Subnet).field("NumAddressesInuse", &self.NumAddressesInuse).field("NumAddressesFree", &self.NumAddressesFree).field("NumPendingAdvertises", &self.NumPendingAdvertises).finish()
9099 }
9100 }
9101 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_V6 {
eq(&self, other: &Self) -> bool9102 fn eq(&self, other: &Self) -> bool {
9103 self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingAdvertises == other.NumPendingAdvertises
9104 }
9105 }
9106 impl ::std::cmp::Eq for SCOPE_MIB_INFO_V6 {}
9107 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_V6 {
9108 type Abi = Self;
9109 type DefaultType = Self;
9110 }
9111 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9112 #[repr(C)]
9113 pub struct SCOPE_MIB_INFO_VQ {
9114 pub Subnet: u32,
9115 pub NumAddressesInuse: u32,
9116 pub NumAddressesFree: u32,
9117 pub NumPendingOffers: u32,
9118 pub QtnNumLeases: u32,
9119 pub QtnPctQtnLeases: u32,
9120 pub QtnProbationLeases: u32,
9121 pub QtnNonQtnLeases: u32,
9122 pub QtnExemptLeases: u32,
9123 pub QtnCapableClients: u32,
9124 }
9125 impl SCOPE_MIB_INFO_VQ {}
9126 impl ::std::default::Default for SCOPE_MIB_INFO_VQ {
default() -> Self9127 fn default() -> Self {
9128 unsafe { ::std::mem::zeroed() }
9129 }
9130 }
9131 impl ::std::fmt::Debug for SCOPE_MIB_INFO_VQ {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9132 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9133 fmt.debug_struct("SCOPE_MIB_INFO_VQ")
9134 .field("Subnet", &self.Subnet)
9135 .field("NumAddressesInuse", &self.NumAddressesInuse)
9136 .field("NumAddressesFree", &self.NumAddressesFree)
9137 .field("NumPendingOffers", &self.NumPendingOffers)
9138 .field("QtnNumLeases", &self.QtnNumLeases)
9139 .field("QtnPctQtnLeases", &self.QtnPctQtnLeases)
9140 .field("QtnProbationLeases", &self.QtnProbationLeases)
9141 .field("QtnNonQtnLeases", &self.QtnNonQtnLeases)
9142 .field("QtnExemptLeases", &self.QtnExemptLeases)
9143 .field("QtnCapableClients", &self.QtnCapableClients)
9144 .finish()
9145 }
9146 }
9147 impl ::std::cmp::PartialEq for SCOPE_MIB_INFO_VQ {
eq(&self, other: &Self) -> bool9148 fn eq(&self, other: &Self) -> bool {
9149 self.Subnet == other.Subnet && self.NumAddressesInuse == other.NumAddressesInuse && self.NumAddressesFree == other.NumAddressesFree && self.NumPendingOffers == other.NumPendingOffers && self.QtnNumLeases == other.QtnNumLeases && self.QtnPctQtnLeases == other.QtnPctQtnLeases && self.QtnProbationLeases == other.QtnProbationLeases && self.QtnNonQtnLeases == other.QtnNonQtnLeases && self.QtnExemptLeases == other.QtnExemptLeases && self.QtnCapableClients == other.QtnCapableClients
9150 }
9151 }
9152 impl ::std::cmp::Eq for SCOPE_MIB_INFO_VQ {}
9153 unsafe impl ::windows::runtime::Abi for SCOPE_MIB_INFO_VQ {
9154 type Abi = Self;
9155 type DefaultType = Self;
9156 }
9157 pub const SHAREDSECRET: u32 = 64u32;
9158 pub const Set_APIProtocolSupport: u32 = 1u32;
9159 pub const Set_AuditLogState: u32 = 2048u32;
9160 pub const Set_BackupInterval: u32 = 16u32;
9161 pub const Set_BackupPath: u32 = 8u32;
9162 pub const Set_BootFileTable: u32 = 1024u32;
9163 pub const Set_DatabaseCleanupInterval: u32 = 128u32;
9164 pub const Set_DatabaseLoggingFlag: u32 = 32u32;
9165 pub const Set_DatabaseName: u32 = 2u32;
9166 pub const Set_DatabasePath: u32 = 4u32;
9167 pub const Set_DebugFlag: u32 = 256u32;
9168 pub const Set_PingRetries: u32 = 512u32;
9169 pub const Set_PreferredLifetime: u32 = 4u32;
9170 pub const Set_PreferredLifetimeIATA: u32 = 64u32;
9171 pub const Set_QuarantineDefFail: u32 = 8192u32;
9172 pub const Set_QuarantineON: u32 = 4096u32;
9173 pub const Set_RapidCommitFlag: u32 = 2u32;
9174 pub const Set_RestoreFlag: u32 = 64u32;
9175 pub const Set_T1: u32 = 16u32;
9176 pub const Set_T2: u32 = 32u32;
9177 pub const Set_UnicastFlag: u32 = 1u32;
9178 pub const Set_ValidLifetime: u32 = 8u32;
9179 pub const Set_ValidLifetimeIATA: u32 = 128u32;
9180 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9181 #[repr(transparent)]
9182 pub struct StatusCode(pub i32);
9183 pub const STATUS_NO_ERROR: StatusCode = StatusCode(0i32);
9184 pub const STATUS_UNSPECIFIED_FAILURE: StatusCode = StatusCode(1i32);
9185 pub const STATUS_NO_BINDING: StatusCode = StatusCode(3i32);
9186 pub const STATUS_NOPREFIX_AVAIL: StatusCode = StatusCode(6i32);
9187 impl ::std::convert::From<i32> for StatusCode {
from(value: i32) -> Self9188 fn from(value: i32) -> Self {
9189 Self(value)
9190 }
9191 }
9192 unsafe impl ::windows::runtime::Abi for StatusCode {
9193 type Abi = Self;
9194 type DefaultType = Self;
9195 }
9196 pub const V5_ADDRESS_BIT_BOTH_REC: u32 = 32u32;
9197 pub const V5_ADDRESS_BIT_DELETED: u32 = 128u32;
9198 pub const V5_ADDRESS_BIT_UNREGISTERED: u32 = 64u32;
9199 pub const V5_ADDRESS_EX_BIT_DISABLE_PTR_RR: u32 = 1u32;
9200 pub const V5_ADDRESS_STATE_ACTIVE: u32 = 1u32;
9201 pub const V5_ADDRESS_STATE_DECLINED: u32 = 2u32;
9202 pub const V5_ADDRESS_STATE_DOOM: u32 = 3u32;
9203 pub const V5_ADDRESS_STATE_OFFERED: u32 = 0u32;
9204 pub const WARNING_EXTENDED_LESS: i32 = 20026i32;
9205