#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn extract_bit(byte: u8, index: usize) -> bool {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
Self::extract_bit(byte, index)
}
#[inline]
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
};
Self::extract_bit(byte, index)
}
#[inline]
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
byte | mask
} else {
byte & !mask
}
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
};
unsafe { *byte = Self::change_bit(*byte, index, val) };
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
let mut val = 0;
for i in 0..(bit_width as usize) {
if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
#[inline]
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
}
}
}
pub type wchar_t = ::std::os::raw::c_ushort;
pub type ULONG = ::std::os::raw::c_ulong;
pub type PULONG = *mut ULONG;
pub type USHORT = ::std::os::raw::c_ushort;
pub type DWORD = ::std::os::raw::c_ulong;
pub type BYTE = ::std::os::raw::c_uchar;
pub type INT = ::std::os::raw::c_int;
pub type UINT8 = ::std::os::raw::c_uchar;
pub type UINT32 = ::std::os::raw::c_uint;
pub type ULONG64 = ::std::os::raw::c_ulonglong;
pub type PVOID = *mut ::std::os::raw::c_void;
pub type CHAR = ::std::os::raw::c_char;
pub type WCHAR = wchar_t;
pub type PWCHAR = *mut WCHAR;
pub type PCHAR = *mut CHAR;
pub type ULONGLONG = ::std::os::raw::c_ulonglong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GUID {
pub Data1: ::std::os::raw::c_ulong,
pub Data2: ::std::os::raw::c_ushort,
pub Data3: ::std::os::raw::c_ushort,
pub Data4: [::std::os::raw::c_uchar; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _GUID"][::std::mem::size_of::<_GUID>() - 16usize];
["Alignment of _GUID"][::std::mem::align_of::<_GUID>() - 4usize];
["Offset of field: _GUID::Data1"][::std::mem::offset_of!(_GUID, Data1) - 0usize];
["Offset of field: _GUID::Data2"][::std::mem::offset_of!(_GUID, Data2) - 4usize];
["Offset of field: _GUID::Data3"][::std::mem::offset_of!(_GUID, Data3) - 6usize];
["Offset of field: _GUID::Data4"][::std::mem::offset_of!(_GUID, Data4) - 8usize];
};
pub type GUID = _GUID;
pub type ADDRESS_FAMILY = USHORT;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr {
pub sa_family: ADDRESS_FAMILY,
pub sa_data: [CHAR; 14usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of sockaddr"][::std::mem::size_of::<sockaddr>() - 16usize];
["Alignment of sockaddr"][::std::mem::align_of::<sockaddr>() - 2usize];
["Offset of field: sockaddr::sa_family"][::std::mem::offset_of!(sockaddr, sa_family) - 0usize];
["Offset of field: sockaddr::sa_data"][::std::mem::offset_of!(sockaddr, sa_data) - 2usize];
};
pub type LPSOCKADDR = *mut sockaddr;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _SOCKET_ADDRESS {
pub lpSockaddr: LPSOCKADDR,
pub iSockaddrLength: INT,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _SOCKET_ADDRESS"][::std::mem::size_of::<_SOCKET_ADDRESS>() - 16usize];
["Alignment of _SOCKET_ADDRESS"][::std::mem::align_of::<_SOCKET_ADDRESS>() - 8usize];
["Offset of field: _SOCKET_ADDRESS::lpSockaddr"]
[::std::mem::offset_of!(_SOCKET_ADDRESS, lpSockaddr) - 0usize];
["Offset of field: _SOCKET_ADDRESS::iSockaddrLength"]
[::std::mem::offset_of!(_SOCKET_ADDRESS, iSockaddrLength) - 8usize];
};
pub type SOCKET_ADDRESS = _SOCKET_ADDRESS;
pub type IFTYPE = ULONG;
pub type NET_IF_COMPARTMENT_ID = UINT32;
pub type NET_IF_NETWORK_GUID = GUID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _NET_LUID_LH {
pub Value: ULONG64,
pub Info: _NET_LUID_LH__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct _NET_LUID_LH__bindgen_ty_1 {
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _NET_LUID_LH__bindgen_ty_1"]
[::std::mem::size_of::<_NET_LUID_LH__bindgen_ty_1>() - 8usize];
["Alignment of _NET_LUID_LH__bindgen_ty_1"]
[::std::mem::align_of::<_NET_LUID_LH__bindgen_ty_1>() - 8usize];
};
impl _NET_LUID_LH__bindgen_ty_1 {
#[inline]
pub fn Reserved(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u64) }
}
#[inline]
pub fn set_Reserved(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn Reserved_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_Reserved_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn NetLuidIndex(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 24u8) as u64) }
}
#[inline]
pub fn set_NetLuidIndex(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(24usize, 24u8, val as u64)
}
}
#[inline]
pub unsafe fn NetLuidIndex_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
24usize,
24u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_NetLuidIndex_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
24usize,
24u8,
val as u64,
)
}
}
#[inline]
pub fn IfType(&self) -> ULONG64 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
}
#[inline]
pub fn set_IfType(&mut self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(48usize, 16u8, val as u64)
}
}
#[inline]
pub unsafe fn IfType_raw(this: *const Self) -> ULONG64 {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
48usize,
16u8,
) as u64)
}
}
#[inline]
pub unsafe fn set_IfType_raw(this: *mut Self, val: ULONG64) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
48usize,
16u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
Reserved: ULONG64,
NetLuidIndex: ULONG64,
IfType: ULONG64,
) -> __BindgenBitfieldUnit<[u8; 8usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 24u8, {
let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
Reserved as u64
});
__bindgen_bitfield_unit.set(24usize, 24u8, {
let NetLuidIndex: u64 = unsafe { ::std::mem::transmute(NetLuidIndex) };
NetLuidIndex as u64
});
__bindgen_bitfield_unit.set(48usize, 16u8, {
let IfType: u64 = unsafe { ::std::mem::transmute(IfType) };
IfType as u64
});
__bindgen_bitfield_unit
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _NET_LUID_LH"][::std::mem::size_of::<_NET_LUID_LH>() - 8usize];
["Alignment of _NET_LUID_LH"][::std::mem::align_of::<_NET_LUID_LH>() - 8usize];
["Offset of field: _NET_LUID_LH::Value"][::std::mem::offset_of!(_NET_LUID_LH, Value) - 0usize];
["Offset of field: _NET_LUID_LH::Info"][::std::mem::offset_of!(_NET_LUID_LH, Info) - 0usize];
};
pub type NET_LUID_LH = _NET_LUID_LH;
pub type NET_LUID = NET_LUID_LH;
pub type IF_LUID = NET_LUID;
pub type NET_IFINDEX = ULONG;
pub type IF_INDEX = NET_IFINDEX;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_DEDICATED: _NET_IF_CONNECTION_TYPE = 1;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_PASSIVE: _NET_IF_CONNECTION_TYPE = 2;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_DEMAND: _NET_IF_CONNECTION_TYPE = 3;
pub const _NET_IF_CONNECTION_TYPE_NET_IF_CONNECTION_MAXIMUM: _NET_IF_CONNECTION_TYPE = 4;
pub type _NET_IF_CONNECTION_TYPE = ::std::os::raw::c_int;
pub use self::_NET_IF_CONNECTION_TYPE as NET_IF_CONNECTION_TYPE;
pub const TUNNEL_TYPE_TUNNEL_TYPE_NONE: TUNNEL_TYPE = 0;
pub const TUNNEL_TYPE_TUNNEL_TYPE_OTHER: TUNNEL_TYPE = 1;
pub const TUNNEL_TYPE_TUNNEL_TYPE_DIRECT: TUNNEL_TYPE = 2;
pub const TUNNEL_TYPE_TUNNEL_TYPE_6TO4: TUNNEL_TYPE = 11;
pub const TUNNEL_TYPE_TUNNEL_TYPE_ISATAP: TUNNEL_TYPE = 13;
pub const TUNNEL_TYPE_TUNNEL_TYPE_TEREDO: TUNNEL_TYPE = 14;
pub const TUNNEL_TYPE_TUNNEL_TYPE_IPHTTPS: TUNNEL_TYPE = 15;
pub type TUNNEL_TYPE = ::std::os::raw::c_int;
pub const IF_OPER_STATUS_IfOperStatusUp: IF_OPER_STATUS = 1;
pub const IF_OPER_STATUS_IfOperStatusDown: IF_OPER_STATUS = 2;
pub const IF_OPER_STATUS_IfOperStatusTesting: IF_OPER_STATUS = 3;
pub const IF_OPER_STATUS_IfOperStatusUnknown: IF_OPER_STATUS = 4;
pub const IF_OPER_STATUS_IfOperStatusDormant: IF_OPER_STATUS = 5;
pub const IF_OPER_STATUS_IfOperStatusNotPresent: IF_OPER_STATUS = 6;
pub const IF_OPER_STATUS_IfOperStatusLowerLayerDown: IF_OPER_STATUS = 7;
pub type IF_OPER_STATUS = ::std::os::raw::c_int;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginOther: NL_PREFIX_ORIGIN = 0;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginManual: NL_PREFIX_ORIGIN = 1;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginWellKnown: NL_PREFIX_ORIGIN = 2;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginDhcp: NL_PREFIX_ORIGIN = 3;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginRouterAdvertisement: NL_PREFIX_ORIGIN = 4;
pub const NL_PREFIX_ORIGIN_IpPrefixOriginUnchanged: NL_PREFIX_ORIGIN = 16;
pub type NL_PREFIX_ORIGIN = ::std::os::raw::c_int;
pub const NL_SUFFIX_ORIGIN_NlsoOther: NL_SUFFIX_ORIGIN = 0;
pub const NL_SUFFIX_ORIGIN_NlsoManual: NL_SUFFIX_ORIGIN = 1;
pub const NL_SUFFIX_ORIGIN_NlsoWellKnown: NL_SUFFIX_ORIGIN = 2;
pub const NL_SUFFIX_ORIGIN_NlsoDhcp: NL_SUFFIX_ORIGIN = 3;
pub const NL_SUFFIX_ORIGIN_NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = 4;
pub const NL_SUFFIX_ORIGIN_NlsoRandom: NL_SUFFIX_ORIGIN = 5;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginOther: NL_SUFFIX_ORIGIN = 0;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginManual: NL_SUFFIX_ORIGIN = 1;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginWellKnown: NL_SUFFIX_ORIGIN = 2;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginDhcp: NL_SUFFIX_ORIGIN = 3;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginLinkLayerAddress: NL_SUFFIX_ORIGIN = 4;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginRandom: NL_SUFFIX_ORIGIN = 5;
pub const NL_SUFFIX_ORIGIN_IpSuffixOriginUnchanged: NL_SUFFIX_ORIGIN = 16;
pub type NL_SUFFIX_ORIGIN = ::std::os::raw::c_int;
pub const NL_DAD_STATE_NldsInvalid: NL_DAD_STATE = 0;
pub const NL_DAD_STATE_NldsTentative: NL_DAD_STATE = 1;
pub const NL_DAD_STATE_NldsDuplicate: NL_DAD_STATE = 2;
pub const NL_DAD_STATE_NldsDeprecated: NL_DAD_STATE = 3;
pub const NL_DAD_STATE_NldsPreferred: NL_DAD_STATE = 4;
pub const NL_DAD_STATE_IpDadStateInvalid: NL_DAD_STATE = 0;
pub const NL_DAD_STATE_IpDadStateTentative: NL_DAD_STATE = 1;
pub const NL_DAD_STATE_IpDadStateDuplicate: NL_DAD_STATE = 2;
pub const NL_DAD_STATE_IpDadStateDeprecated: NL_DAD_STATE = 3;
pub const NL_DAD_STATE_IpDadStatePreferred: NL_DAD_STATE = 4;
pub type NL_DAD_STATE = ::std::os::raw::c_int;
pub use self::NL_DAD_STATE as IP_DAD_STATE;
pub use self::NL_PREFIX_ORIGIN as IP_PREFIX_ORIGIN;
pub use self::NL_SUFFIX_ORIGIN as IP_SUFFIX_ORIGIN;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_UNICAST_ADDRESS_LH {
pub __bindgen_anon_1: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_UNICAST_ADDRESS_LH,
pub Address: SOCKET_ADDRESS,
pub PrefixOrigin: IP_PREFIX_ORIGIN,
pub SuffixOrigin: IP_SUFFIX_ORIGIN,
pub DadState: IP_DAD_STATE,
pub ValidLifetime: ULONG,
pub PreferredLifetime: ULONG,
pub LeaseLifetime: ULONG,
pub OnLinkPrefixLength: UINT8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Flags: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"][::std::mem::align_of::<
_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
>() - 4usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Flags"][::std::mem::offset_of!(
_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Flags
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1::Alignment"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH__bindgen_ty_1, Alignment) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_UNICAST_ADDRESS_LH"]
[::std::mem::size_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH>() - 64usize];
["Alignment of _IP_ADAPTER_UNICAST_ADDRESS_LH"]
[::std::mem::align_of::<_IP_ADAPTER_UNICAST_ADDRESS_LH>() - 8usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, Next) - 8usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, Address) - 16usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::PrefixOrigin"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, PrefixOrigin) - 32usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::SuffixOrigin"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, SuffixOrigin) - 36usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::DadState"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, DadState) - 40usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::ValidLifetime"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, ValidLifetime) - 44usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::PreferredLifetime"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, PreferredLifetime) - 48usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::LeaseLifetime"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, LeaseLifetime) - 52usize];
["Offset of field: _IP_ADAPTER_UNICAST_ADDRESS_LH::OnLinkPrefixLength"]
[::std::mem::offset_of!(_IP_ADAPTER_UNICAST_ADDRESS_LH, OnLinkPrefixLength) - 56usize];
};
pub type PIP_ADAPTER_UNICAST_ADDRESS_LH = *mut _IP_ADAPTER_UNICAST_ADDRESS_LH;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_ANYCAST_ADDRESS_XP {
pub __bindgen_anon_1: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_ANYCAST_ADDRESS_XP,
pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Flags: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"][::std::mem::align_of::<
_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
>() - 4usize];
["Offset of field: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Flags"][::std::mem::offset_of!(
_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Flags
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1::Alignment"]
[::std::mem::offset_of!(_IP_ADAPTER_ANYCAST_ADDRESS_XP__bindgen_ty_1, Alignment) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ANYCAST_ADDRESS_XP"]
[::std::mem::size_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP>() - 32usize];
["Alignment of _IP_ADAPTER_ANYCAST_ADDRESS_XP"]
[::std::mem::align_of::<_IP_ADAPTER_ANYCAST_ADDRESS_XP>() - 8usize];
["Offset of field: _IP_ADAPTER_ANYCAST_ADDRESS_XP::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_ANYCAST_ADDRESS_XP, Next) - 8usize];
["Offset of field: _IP_ADAPTER_ANYCAST_ADDRESS_XP::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_ANYCAST_ADDRESS_XP, Address) - 16usize];
};
pub type PIP_ADAPTER_ANYCAST_ADDRESS_XP = *mut _IP_ADAPTER_ANYCAST_ADDRESS_XP;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_MULTICAST_ADDRESS_XP {
pub __bindgen_anon_1: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_MULTICAST_ADDRESS_XP,
pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Flags: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>()
- 4usize];
["Offset of field: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Flags"][::std::mem::offset_of!(
_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Flags
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1::Alignment"][::std::mem::offset_of!(
_IP_ADAPTER_MULTICAST_ADDRESS_XP__bindgen_ty_1,
Alignment
) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_MULTICAST_ADDRESS_XP"]
[::std::mem::size_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP>() - 32usize];
["Alignment of _IP_ADAPTER_MULTICAST_ADDRESS_XP"]
[::std::mem::align_of::<_IP_ADAPTER_MULTICAST_ADDRESS_XP>() - 8usize];
["Offset of field: _IP_ADAPTER_MULTICAST_ADDRESS_XP::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_MULTICAST_ADDRESS_XP, Next) - 8usize];
["Offset of field: _IP_ADAPTER_MULTICAST_ADDRESS_XP::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_MULTICAST_ADDRESS_XP, Address) - 16usize];
};
pub type PIP_ADAPTER_MULTICAST_ADDRESS_XP = *mut _IP_ADAPTER_MULTICAST_ADDRESS_XP;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP {
pub __bindgen_anon_1: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_DNS_SERVER_ADDRESS_XP,
pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Reserved: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1>()
- 4usize];
["Offset of field: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1::Reserved"][::std::mem::offset_of!(
_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1__bindgen_ty_1,
Reserved
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1::Alignment"][::std::mem::offset_of!(
_IP_ADAPTER_DNS_SERVER_ADDRESS_XP__bindgen_ty_1,
Alignment
) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP"]
[::std::mem::size_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP>() - 32usize];
["Alignment of _IP_ADAPTER_DNS_SERVER_ADDRESS_XP"]
[::std::mem::align_of::<_IP_ADAPTER_DNS_SERVER_ADDRESS_XP>() - 8usize];
["Offset of field: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP, Next) - 8usize];
["Offset of field: _IP_ADAPTER_DNS_SERVER_ADDRESS_XP::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_DNS_SERVER_ADDRESS_XP, Address) - 16usize];
};
pub type PIP_ADAPTER_DNS_SERVER_ADDRESS_XP = *mut _IP_ADAPTER_DNS_SERVER_ADDRESS_XP;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH {
pub __bindgen_anon_1: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_WINS_SERVER_ADDRESS_LH,
pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Reserved: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1>()
- 4usize];
["Offset of field: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Reserved"][::std::mem::offset_of!(
_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Reserved
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1::Alignment"][::std::mem::offset_of!(
_IP_ADAPTER_WINS_SERVER_ADDRESS_LH__bindgen_ty_1,
Alignment
) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH"]
[::std::mem::size_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH>() - 32usize];
["Alignment of _IP_ADAPTER_WINS_SERVER_ADDRESS_LH"]
[::std::mem::align_of::<_IP_ADAPTER_WINS_SERVER_ADDRESS_LH>() - 8usize];
["Offset of field: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH, Next) - 8usize];
["Offset of field: _IP_ADAPTER_WINS_SERVER_ADDRESS_LH::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_WINS_SERVER_ADDRESS_LH, Address) - 16usize];
};
pub type PIP_ADAPTER_WINS_SERVER_ADDRESS_LH = *mut _IP_ADAPTER_WINS_SERVER_ADDRESS_LH;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_GATEWAY_ADDRESS_LH {
pub __bindgen_anon_1: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_GATEWAY_ADDRESS_LH,
pub Address: SOCKET_ADDRESS,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Reserved: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
>() - 8usize];
["Alignment of _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1"][::std::mem::align_of::<
_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
>() - 4usize];
["Offset of field: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Length
)
- 0usize];
["Offset of field: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1::Reserved"][::std::mem::offset_of!(
_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1__bindgen_ty_1,
Reserved
)
- 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1::Alignment"]
[::std::mem::offset_of!(_IP_ADAPTER_GATEWAY_ADDRESS_LH__bindgen_ty_1, Alignment) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_GATEWAY_ADDRESS_LH"]
[::std::mem::size_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH>() - 32usize];
["Alignment of _IP_ADAPTER_GATEWAY_ADDRESS_LH"]
[::std::mem::align_of::<_IP_ADAPTER_GATEWAY_ADDRESS_LH>() - 8usize];
["Offset of field: _IP_ADAPTER_GATEWAY_ADDRESS_LH::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_GATEWAY_ADDRESS_LH, Next) - 8usize];
["Offset of field: _IP_ADAPTER_GATEWAY_ADDRESS_LH::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_GATEWAY_ADDRESS_LH, Address) - 16usize];
};
pub type PIP_ADAPTER_GATEWAY_ADDRESS_LH = *mut _IP_ADAPTER_GATEWAY_ADDRESS_LH;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_PREFIX_XP {
pub __bindgen_anon_1: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_PREFIX_XP,
pub Address: SOCKET_ADDRESS,
pub PrefixLength: ULONG,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_PREFIX_XP__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub Flags: DWORD,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1>() - 4usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1,
Length
) - 0usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1::Flags"]
[::std::mem::offset_of!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1__bindgen_ty_1, Flags) - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_PREFIX_XP__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_PREFIX_XP__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP__bindgen_ty_1::Alignment"]
[::std::mem::offset_of!(_IP_ADAPTER_PREFIX_XP__bindgen_ty_1, Alignment) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_PREFIX_XP"][::std::mem::size_of::<_IP_ADAPTER_PREFIX_XP>() - 40usize];
["Alignment of _IP_ADAPTER_PREFIX_XP"]
[::std::mem::align_of::<_IP_ADAPTER_PREFIX_XP>() - 8usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_PREFIX_XP, Next) - 8usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP::Address"]
[::std::mem::offset_of!(_IP_ADAPTER_PREFIX_XP, Address) - 16usize];
["Offset of field: _IP_ADAPTER_PREFIX_XP::PrefixLength"]
[::std::mem::offset_of!(_IP_ADAPTER_PREFIX_XP, PrefixLength) - 32usize];
};
pub type PIP_ADAPTER_PREFIX_XP = *mut _IP_ADAPTER_PREFIX_XP;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_DNS_SUFFIX {
pub Next: *mut _IP_ADAPTER_DNS_SUFFIX,
pub String: [WCHAR; 256usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_DNS_SUFFIX"][::std::mem::size_of::<_IP_ADAPTER_DNS_SUFFIX>() - 520usize];
["Alignment of _IP_ADAPTER_DNS_SUFFIX"]
[::std::mem::align_of::<_IP_ADAPTER_DNS_SUFFIX>() - 8usize];
["Offset of field: _IP_ADAPTER_DNS_SUFFIX::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_DNS_SUFFIX, Next) - 0usize];
["Offset of field: _IP_ADAPTER_DNS_SUFFIX::String"]
[::std::mem::offset_of!(_IP_ADAPTER_DNS_SUFFIX, String) - 8usize];
};
pub type PIP_ADAPTER_DNS_SUFFIX = *mut _IP_ADAPTER_DNS_SUFFIX;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _IP_ADAPTER_ADDRESSES_LH {
pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1,
pub Next: *mut _IP_ADAPTER_ADDRESSES_LH,
pub AdapterName: PCHAR,
pub FirstUnicastAddress: PIP_ADAPTER_UNICAST_ADDRESS_LH,
pub FirstAnycastAddress: PIP_ADAPTER_ANYCAST_ADDRESS_XP,
pub FirstMulticastAddress: PIP_ADAPTER_MULTICAST_ADDRESS_XP,
pub FirstDnsServerAddress: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP,
pub DnsSuffix: PWCHAR,
pub Description: PWCHAR,
pub FriendlyName: PWCHAR,
pub PhysicalAddress: [BYTE; 8usize],
pub PhysicalAddressLength: ULONG,
pub __bindgen_anon_2: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2,
pub Mtu: ULONG,
pub IfType: IFTYPE,
pub OperStatus: IF_OPER_STATUS,
pub Ipv6IfIndex: IF_INDEX,
pub ZoneIndices: [ULONG; 16usize],
pub FirstPrefix: PIP_ADAPTER_PREFIX_XP,
pub TransmitLinkSpeed: ULONG64,
pub ReceiveLinkSpeed: ULONG64,
pub FirstWinsServerAddress: PIP_ADAPTER_WINS_SERVER_ADDRESS_LH,
pub FirstGatewayAddress: PIP_ADAPTER_GATEWAY_ADDRESS_LH,
pub Ipv4Metric: ULONG,
pub Ipv6Metric: ULONG,
pub Luid: IF_LUID,
pub Dhcpv4Server: SOCKET_ADDRESS,
pub CompartmentId: NET_IF_COMPARTMENT_ID,
pub NetworkGuid: NET_IF_NETWORK_GUID,
pub ConnectionType: NET_IF_CONNECTION_TYPE,
pub TunnelType: TUNNEL_TYPE,
pub Dhcpv6Server: SOCKET_ADDRESS,
pub Dhcpv6ClientDuid: [BYTE; 130usize],
pub Dhcpv6ClientDuidLength: ULONG,
pub Dhcpv6Iaid: ULONG,
pub FirstDnsSuffix: PIP_ADAPTER_DNS_SUFFIX,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1 {
pub Alignment: ULONGLONG,
pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1 {
pub Length: ULONG,
pub IfIndex: IF_INDEX,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1>() - 4usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1::Length"][::std::mem::offset_of!(
_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1,
Length
) - 0usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1::IfIndex"][::std::mem::offset_of!(
_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1__bindgen_ty_1,
IfIndex
) - 4usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1>() - 8usize];
["Alignment of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1>() - 8usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1::Alignment"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_1, Alignment) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub union _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2 {
pub Flags: ULONG,
pub __bindgen_anon_1: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Copy, Clone)]
pub struct _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
pub __bindgen_padding_0: u16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1"]
[::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1>() - 4usize];
["Alignment of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1"]
[::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1>() - 4usize];
};
impl _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn DdnsEnabled(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_DdnsEnabled(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn DdnsEnabled_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_DdnsEnabled_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn RegisterAdapterSuffix(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_RegisterAdapterSuffix(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn RegisterAdapterSuffix_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_RegisterAdapterSuffix_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn Dhcpv4Enabled(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_Dhcpv4Enabled(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn Dhcpv4Enabled_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
2usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_Dhcpv4Enabled_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
2usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn ReceiveOnly(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
}
#[inline]
pub fn set_ReceiveOnly(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn ReceiveOnly_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
3usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_ReceiveOnly_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
3usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn NoMulticast(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_NoMulticast(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn NoMulticast_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
4usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_NoMulticast_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
4usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn Ipv6OtherStatefulConfig(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_Ipv6OtherStatefulConfig(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn Ipv6OtherStatefulConfig_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
5usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_Ipv6OtherStatefulConfig_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
5usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn NetbiosOverTcpipEnabled(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_NetbiosOverTcpipEnabled(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn NetbiosOverTcpipEnabled_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
6usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_NetbiosOverTcpipEnabled_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
6usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn Ipv4Enabled(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_Ipv4Enabled(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn Ipv4Enabled_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
7usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_Ipv4Enabled_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
7usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn Ipv6Enabled(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
}
#[inline]
pub fn set_Ipv6Enabled(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn Ipv6Enabled_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
8usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_Ipv6Enabled_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
8usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn Ipv6ManagedAddressConfigurationSupported(&self) -> ULONG {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
}
#[inline]
pub fn set_Ipv6ManagedAddressConfigurationSupported(&mut self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn Ipv6ManagedAddressConfigurationSupported_raw(this: *const Self) -> ULONG {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
9usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_Ipv6ManagedAddressConfigurationSupported_raw(this: *mut Self, val: ULONG) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
9usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
DdnsEnabled: ULONG,
RegisterAdapterSuffix: ULONG,
Dhcpv4Enabled: ULONG,
ReceiveOnly: ULONG,
NoMulticast: ULONG,
Ipv6OtherStatefulConfig: ULONG,
NetbiosOverTcpipEnabled: ULONG,
Ipv4Enabled: ULONG,
Ipv6Enabled: ULONG,
Ipv6ManagedAddressConfigurationSupported: ULONG,
) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let DdnsEnabled: u32 = unsafe { ::std::mem::transmute(DdnsEnabled) };
DdnsEnabled as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let RegisterAdapterSuffix: u32 =
unsafe { ::std::mem::transmute(RegisterAdapterSuffix) };
RegisterAdapterSuffix as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let Dhcpv4Enabled: u32 = unsafe { ::std::mem::transmute(Dhcpv4Enabled) };
Dhcpv4Enabled as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let ReceiveOnly: u32 = unsafe { ::std::mem::transmute(ReceiveOnly) };
ReceiveOnly as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let NoMulticast: u32 = unsafe { ::std::mem::transmute(NoMulticast) };
NoMulticast as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let Ipv6OtherStatefulConfig: u32 =
unsafe { ::std::mem::transmute(Ipv6OtherStatefulConfig) };
Ipv6OtherStatefulConfig as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let NetbiosOverTcpipEnabled: u32 =
unsafe { ::std::mem::transmute(NetbiosOverTcpipEnabled) };
NetbiosOverTcpipEnabled as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let Ipv4Enabled: u32 = unsafe { ::std::mem::transmute(Ipv4Enabled) };
Ipv4Enabled as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let Ipv6Enabled: u32 = unsafe { ::std::mem::transmute(Ipv6Enabled) };
Ipv6Enabled as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let Ipv6ManagedAddressConfigurationSupported: u32 =
unsafe { ::std::mem::transmute(Ipv6ManagedAddressConfigurationSupported) };
Ipv6ManagedAddressConfigurationSupported as u64
});
__bindgen_bitfield_unit
}
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2"]
[::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2>() - 4usize];
["Alignment of _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2"]
[::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2>() - 4usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2::Flags"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH__bindgen_ty_2, Flags) - 0usize];
};
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of _IP_ADAPTER_ADDRESSES_LH"]
[::std::mem::size_of::<_IP_ADAPTER_ADDRESSES_LH>() - 448usize];
["Alignment of _IP_ADAPTER_ADDRESSES_LH"]
[::std::mem::align_of::<_IP_ADAPTER_ADDRESSES_LH>() - 8usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Next"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Next) - 8usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::AdapterName"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, AdapterName) - 16usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstUnicastAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstUnicastAddress) - 24usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstAnycastAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstAnycastAddress) - 32usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstMulticastAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstMulticastAddress) - 40usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstDnsServerAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstDnsServerAddress) - 48usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::DnsSuffix"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, DnsSuffix) - 56usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Description"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Description) - 64usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FriendlyName"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FriendlyName) - 72usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::PhysicalAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, PhysicalAddress) - 80usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::PhysicalAddressLength"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, PhysicalAddressLength) - 88usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Mtu"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Mtu) - 96usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::IfType"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, IfType) - 100usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::OperStatus"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, OperStatus) - 104usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Ipv6IfIndex"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Ipv6IfIndex) - 108usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::ZoneIndices"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, ZoneIndices) - 112usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstPrefix"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstPrefix) - 176usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::TransmitLinkSpeed"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, TransmitLinkSpeed) - 184usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::ReceiveLinkSpeed"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, ReceiveLinkSpeed) - 192usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstWinsServerAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstWinsServerAddress) - 200usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstGatewayAddress"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstGatewayAddress) - 208usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Ipv4Metric"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Ipv4Metric) - 216usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Ipv6Metric"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Ipv6Metric) - 220usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Luid"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Luid) - 224usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Dhcpv4Server"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Dhcpv4Server) - 232usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::CompartmentId"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, CompartmentId) - 248usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::NetworkGuid"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, NetworkGuid) - 252usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::ConnectionType"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, ConnectionType) - 268usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::TunnelType"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, TunnelType) - 272usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Dhcpv6Server"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Dhcpv6Server) - 280usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Dhcpv6ClientDuid"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Dhcpv6ClientDuid) - 296usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Dhcpv6ClientDuidLength"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Dhcpv6ClientDuidLength) - 428usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::Dhcpv6Iaid"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, Dhcpv6Iaid) - 432usize];
["Offset of field: _IP_ADAPTER_ADDRESSES_LH::FirstDnsSuffix"]
[::std::mem::offset_of!(_IP_ADAPTER_ADDRESSES_LH, FirstDnsSuffix) - 440usize];
};
pub type IP_ADAPTER_ADDRESSES_LH = _IP_ADAPTER_ADDRESSES_LH;
pub type PIP_ADAPTER_ADDRESSES = *mut IP_ADAPTER_ADDRESSES_LH;
unsafe extern "C" {
pub fn GetAdaptersAddresses(
Family: ULONG,
Flags: ULONG,
Reserved: PVOID,
AdapterAddresses: PIP_ADAPTER_ADDRESSES,
SizePointer: PULONG,
) -> ULONG;
}