From 8b193f197cab87a3031f93f0a430d6fe433cca41 Mon Sep 17 00:00:00 2001 From: BlackHoleFox Date: Sun, 2 Jun 2019 14:28:56 -0500 Subject: [PATCH 01/26] Iphlpapi addition --- Cargo.toml | 13 ++ build.rs | 15 +- src/lib.rs | 1 + src/shared/ifdef.rs | 195 +++++++++++++++++++- src/shared/ifmib.rs | 53 ++++++ src/shared/in6addr.rs | 7 +- src/shared/inaddr.rs | 2 +- src/shared/ipifcons.rs | 244 ++++++++++++++++++++++++ src/shared/ipmib.rs | 384 ++++++++++++++++++++++++++++++++++++++ src/shared/iprtrmib.rs | 125 +++++++++++++ src/shared/mod.rs | 9 + src/shared/mprapidef.rs | 14 ++ src/shared/nldef.rs | 204 +++++++++++++++++++++ src/shared/tcpestats.rs | 211 +++++++++++++++++++++ src/shared/tcpmib.rs | 243 ++++++++++++++++++++++++ src/shared/udpmib.rs | 131 +++++++++++++ src/shared/ws2ipdef.rs | 3 +- src/ucrt/corecrt.rs | 11 ++ src/ucrt/mod.rs | 7 + src/um/ipexport.rs | 178 ++++++++++++++++++ src/um/iphlpapi.rs | 397 ++++++++++++++++++++++++++++++++++++++++ src/um/iptypes.rs | 383 ++++++++++++++++++++++++++++++++++++++ src/um/mod.rs | 3 + 23 files changed, 2820 insertions(+), 13 deletions(-) create mode 100644 src/shared/ifmib.rs create mode 100644 src/shared/ipifcons.rs create mode 100644 src/shared/ipmib.rs create mode 100644 src/shared/iprtrmib.rs create mode 100644 src/shared/mprapidef.rs create mode 100644 src/shared/nldef.rs create mode 100644 src/shared/tcpestats.rs create mode 100644 src/shared/tcpmib.rs create mode 100644 src/shared/udpmib.rs create mode 100644 src/ucrt/corecrt.rs create mode 100644 src/ucrt/mod.rs create mode 100644 src/um/ipexport.rs create mode 100644 src/um/iphlpapi.rs create mode 100644 src/um/iptypes.rs diff --git a/Cargo.toml b/Cargo.toml index 1cf29c7da..593f08076 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -71,18 +71,24 @@ hidpi = [] hidsdi = [] hidusage = [] ifdef = [] +ifmib = [] in6addr = [] inaddr = [] intsafe = [] +ipifcons = [] +ipmib = [] +iprtrmib = [] ks = [] ksmedia = [] ktmtypes = [] lmcons = [] minwindef = [] mmreg = [] +mprapidef = [] mstcpip = [] mswsockdef = [] netioapi = [] +nldef = [] ntddscsi = [] ntddser = [] ntdef = [] @@ -95,8 +101,11 @@ sddl = [] spellcheck = [] sspi = [] stralign = [] +tcpestats = [] +tcpmib = [] transportsettingcommon = [] tvout = [] +udpmib = [] usb = [] usbiodef = [] usbspec = [] @@ -111,6 +120,7 @@ ws2ipdef = [] wtypes = [] wtypesbase = [] #ucrt +corecrt = [] #um accctrl = [] aclapi = [] @@ -226,6 +236,9 @@ http = [] imm = [] interlockedapi = [] ioapiset = [] +ipexport = [] +iphlpapi = [] +iptypes = [] jobapi = [] jobapi2 = [] knownfolders = [] diff --git a/build.rs b/build.rs index d36512bcf..dd0483a87 100644 --- a/build.rs +++ b/build.rs @@ -46,19 +46,25 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("hidpi", &["hidusage", "minwindef", "ntdef", "ntstatus", "winnt"], &["hid"]), ("hidsdi", &["guiddef", "hidpi", "minwindef", "winnt"], &["hid"]), ("hidusage", &["minwindef"], &[]), - ("ifdef", &["basetsd", "minwindef"], &[]), + ("ifdef", &["basetsd", "guiddef", "ntdef"], &[]), + ("ifmib", &["ifdef", "ipifcons", "minwindef", "ntdef"], &[]), ("in6addr", &["minwindef"], &[]), ("inaddr", &["minwindef"], &[]), ("intsafe", &[], &[]), + ("ipifcons", &["minwindef"], &[]), + ("ipmib", &["ifdef", "ifmib", "minwindef", "nldef", "ntdef"], &[]), + ("iprtrmib", &["ipmib", "minwindef", "ntdef"], &[]), ("ks", &[], &[]), ("ksmedia", &["minwindef"], &[]), ("ktmtypes", &["guiddef", "minwindef", "winnt"], &[]), ("lmcons", &["minwindef", "winnt"], &[]), ("minwindef", &["basetsd", "ntdef"], &[]), ("mmreg", &["guiddef", "minwindef"], &[]), + ("mprapidef", &[], &[]), ("mstcpip", &["basetsd", "guiddef", "in6addr", "inaddr", "minwindef", "winnt", "ws2def"], &["ntdll"]), ("mswsockdef", &["minwindef", "winnt", "ws2def"], &[]), ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "ntdef"], &["iphlpapi"]), + ("nldef", &["basetsd", "minwindef", "winnt"], &[]), ("ntddscsi", &["basetsd", "minwindef", "ntdef", "winioctl", "winnt"], &[]), ("ntddser", &["devpropdef"], &[]), ("ntdef", &["basetsd", "guiddef"], &[]), @@ -70,8 +76,11 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("sddl", &["basetsd", "minwindef", "winnt"], &["advapi32"]), ("sspi", &["basetsd", "guiddef", "minwindef", "subauth", "wincred", "winnt"], &["credui", "secur32"]), ("stralign", &["vcruntime", "winnt"], &["kernel32"]), + ("tcpestats", &["basetsd", "ntdef"], &[]), + ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), ("transportsettingcommon", &["guiddef"], &[]), ("tvout", &["guiddef", "minwindef"], &[]), + ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), ("usb", &["minwindef", "usbspec", "winnt"], &[]), ("usbiodef", &["guiddef", "minwindef", "winioctl", "winnt"], &[]), ("usbspec", &["basetsd", "guiddef", "minwindef", "winnt"], &[]), @@ -86,6 +95,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("wtypes", &["guiddef", "minwindef", "ntdef", "rpcndr", "wingdi", "wtypesbase"], &[]), ("wtypesbase", &["minwindef", "rpcndr", "winnt"], &[]), // ucrt + ("corecrt", &[], &[]), // um ("accctrl", &["guiddef", "minwindef", "winbase", "winnt"], &[]), ("aclapi", &["accctrl", "guiddef", "minwindef", "winnt"], &["advapi32"]), @@ -202,6 +212,9 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("imm", &["minwindef", "windef"], &["imm32"]), ("interlockedapi", &["minwindef", "winnt"], &["kernel32"]), ("ioapiset", &["basetsd", "minwinbase", "minwindef", "winnt"], &["kernel32"]), + ("ipexport", &["basetsd", "in6addr", "ntdef"], &[]), + ("iphlpapi", &["basetsd", "ifmib", "ipexport", "ipmib", "iprtrmib", "iptypes", "minwinbase", "minwindef", "ntdef", "tcpmib", "udpmib", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("iptypes", &["basetsd", "corecrt", "guiddef", "ifdef", "ipifcons", "minwindef", "nldef", "ntdef", "ws2def"], &[]), ("jobapi", &["minwindef", "winnt"], &["kernel32"]), ("jobapi2", &["basetsd", "minwinbase", "minwindef", "ntdef", "winnt"], &["kernel32"]), ("knownfolders", &[], &[]), diff --git a/src/lib.rs b/src/lib.rs index c26f5b361..d8253abae 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -25,6 +25,7 @@ pub extern crate core as _core; mod macros; pub mod km; pub mod shared; +pub mod ucrt; pub mod um; pub mod vc; pub mod winrt; diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index e64527a3f..12209e250 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -3,20 +3,201 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -use shared::basetsd::{UINT16, ULONG64}; -use shared::minwindef::ULONG; -STRUCT!{struct NET_LUID_LH { - Value: ULONG64, +// #include +// #include +use shared::basetsd::{UINT16, UINT32, ULONG32, ULONG64}; +use shared::guiddef::GUID; +use shared::ntdef::{BOOLEAN, ULONG, USHORT}; +pub type NET_IF_COMPARTMENT_ID = UINT32; +pub type PNET_IF_COMPARTMENT_ID = *mut NET_IF_COMPARTMENT_ID; +pub const NET_IF_COMPARTMENT_ID_UNSPECIFIED: NET_IF_COMPARTMENT_ID = 0; +pub const NET_IF_COMPARTMENT_ID_PRIMARY: NET_IF_COMPARTMENT_ID = 1; +pub type NET_IF_NETWORK_GUID = GUID; +pub type PNET_IF_NETWORK_GUID = *mut NET_IF_NETWORK_GUID; +ENUM!{enum NET_IF_OPER_STATUS { + NET_IF_OPER_STATUS_UP = 1, + NET_IF_OPER_STATUS_DOWN = 2, + NET_IF_OPER_STATUS_TESTING = 3, + NET_IF_OPER_STATUS_UNKNOWN = 4, + NET_IF_OPER_STATUS_DORMANT = 5, + NET_IF_OPER_STATUS_NOT_PRESENT = 6, + NET_IF_OPER_STATUS_LOWER_LAYER_DOWN = 7, }} -BITFIELD!{NET_LUID_LH Value: ULONG64 [ +pub type PNET_IF_OPER_STATUS = *mut NET_IF_OPER_STATUS; +pub type NET_IF_OBJECT_ID = ULONG32; +pub type PNET_IF_OBJECT_ID = *mut NET_IF_OBJECT_ID; +ENUM!{enum NET_IF_ADMIN_STATUS { + NET_IF_ADMIN_STATUS_UP = 1, + NET_IF_ADMIN_STATUS_DOWN = 2, + NET_IF_ADMIN_STATUS_TESTING = 3, +}} +pub type PNET_IF_ADMIN_STATUS = *mut NET_IF_ADMIN_STATUS; +pub type NET_IF_COMPARTMENT_SCOPE = UINT32; +pub type PNET_IF_COMPARTMENT_SCOPE = *mut NET_IF_COMPARTMENT_SCOPE; +pub const NET_IF_COMPARTMENT_SCOPE_UNSPECIFIED: NET_IF_COMPARTMENT_SCOPE = 0; +// pub const NET_IF_COMPARTMENT_SCOPE_ALL: NET_IF_COMPARTMENT_SCOPE = -1; +ENUM!{enum NET_IF_RCV_ADDRESS_TYPE { + NET_IF_RCV_ADDRESS_TYPE_OTHER = 1, + NET_IF_RCV_ADDRESS_TYPE_VOLATILE = 2, + NET_IF_RCV_ADDRESS_TYPE_NON_VOLATILE = 3, +}} +pub type PNET_IF_RCV_ADDRESS_TYPE = *mut NET_IF_RCV_ADDRESS_TYPE; +STRUCT!{struct NET_IF_RCV_ADDRESS_LH { + ifRcvAddressType: NET_IF_RCV_ADDRESS_TYPE, + ifRcvAddressLength: USHORT, + ifRcvAddressOffset: USHORT, +}} +pub type PNET_IF_RCV_ADDRESS_LH = *mut NET_IF_RCV_ADDRESS_LH; +STRUCT!{struct NET_IF_ALIAS_LH { + ifAliasLength: USHORT, + ifAliasOffset: USHORT, +}} +pub type PNET_IF_ALIAS_LH = *mut NET_IF_ALIAS_LH; +STRUCT!{struct NET_LUID_LH_Info { + bitfield: ULONG64, +}} +BITFIELD!{NET_LUID_LH_Info bitfield: ULONG64 [ Reserved set_Reserved[0..24], NetLuidIndex set_NetLuidIndex[24..48], IfType set_IfType[48..64], ]} +UNION!{union NET_LUID_LH { + [u64; 1], + Value Value_mut: ULONG64, + Info Info_mut: NET_LUID_LH_Info, +}} pub type PNET_LUID_LH = *mut NET_LUID_LH; +pub type NET_IF_RCV_ADDRESS = NET_IF_RCV_ADDRESS_LH; +pub type PNET_IF_RCV_ADDRESS = *mut NET_IF_RCV_ADDRESS; +pub type NET_IF_ALIAS = NET_IF_ALIAS_LH; +pub type PNET_IF_ALIAS = *mut NET_IF_ALIAS; pub type NET_LUID = NET_LUID_LH; pub type PNET_LUID = *mut NET_LUID; +pub type IF_LUID = NET_LUID; +pub type PIF_LUID = *mut NET_LUID; pub type NET_IFINDEX = ULONG; -pub type PNET_IFINDEX = *mut ULONG; +pub type PNET_IFINDEX = *mut NET_IFINDEX; pub type NET_IFTYPE = UINT16; -pub type PNET_IFTYPE = *mut UINT16; +pub type PNET_IFTYPE = *mut NET_IFTYPE; +pub type IF_INDEX = NET_IFINDEX; +pub type PIF_INDEX = *mut NET_IFINDEX; +ENUM!{enum NET_IF_CONNECTION_TYPE { + NET_IF_CONNECTION_DEDICATED = 1, + NET_IF_CONNECTION_PASSIVE = 2, + NET_IF_CONNECTION_DEMAND = 3, + NET_IF_CONNECTION_MAXIMUM = 4, +}} +pub type PNET_IF_CONNECTION_TYPE = *mut NET_IF_CONNECTION_TYPE; +ENUM!{enum TUNNEL_TYPE { + TUNNEL_TYPE_NONE = 0, + TUNNEL_TYPE_OTHER = 1, + TUNNEL_TYPE_DIRECT = 2, + TUNNEL_TYPE_6TO4 = 11, + TUNNEL_TYPE_ISATAP = 13, + TUNNEL_TYPE_TEREDO = 14, + TUNNEL_TYPE_IPHTTPS = 15, +}} +pub type PTUNNEL_TYPE = *mut TUNNEL_TYPE; +ENUM!{enum NET_IF_ACCESS_TYPE { + NET_IF_ACCESS_LOOPBACK = 1, + NET_IF_ACCESS_BROADCAST = 2, + NET_IF_ACCESS_POINT_TO_POINT = 3, + NET_IF_ACCESS_POINT_TO_MULTI_POINT = 4, + NET_IF_ACCESS_MAXIMUM = 5, +}} +pub type PNET_IF_ACCESS_TYPE = *mut NET_IF_ACCESS_TYPE; +ENUM!{enum NET_IF_DIRECTION_TYPE { + NET_IF_DIRECTION_SENDRECEIVE, + NET_IF_DIRECTION_SENDONLY, + NET_IF_DIRECTION_RECEIVEONLY, + NET_IF_DIRECTION_MAXIMUM, +}} +pub type PNET_IF_DIRECTION_TYPE = *mut NET_IF_DIRECTION_TYPE; +ENUM!{enum NET_IF_MEDIA_CONNECT_STATE { + MediaConnectStateUnknown, + MediaConnectStateConnected, + MediaConnectStateDisconnected, +}} +pub type PNET_IF_MEDIA_CONNECT_STATE = *mut NET_IF_MEDIA_CONNECT_STATE; +ENUM!{enum NET_IF_MEDIA_DUPLEX_STATE { + MediaDuplexStateUnknown, + MediaDuplexStateHalf, + MediaDuplexStateFull, +}} +pub type PNET_IF_MEDIA_DUPLEX_STATE = *mut NET_IF_MEDIA_DUPLEX_STATE; +STRUCT!{struct NET_PHYSICAL_LOCATION_LH { + BusNumber: ULONG, + SlotNumber: ULONG, + FunctionNumber: ULONG, +}} +pub type PNET_PHYSICAL_LOCATION_LH = *mut NET_PHYSICAL_LOCATION_LH; +pub const IF_MAX_STRING_SIZE: usize = 256; +pub const IF_MAX_PHYS_ADDRESS_LENGTH: usize = 32; +// STRUCT!{struct IF_COUNTED_STRING_LH { +// // _Field_range_(0, (IF_MAX_STRING_SIZE + 1) * sizeof(WCHAR)) +// Length: USHORT, +// String: [WCHAR; IF_MAX_STRING_SIZE + 1], +// }} +// pub type PIF_COUNTED_STRING_LH = *mut IF_COUNTED_STRING_LH; +// STRUCT!{struct IF_PHYSICAL_ADDRESS_LH { +// // _Field_range_(0, IF_MAX_PHYS_ADDRESS_LENGTH) +// Length: USHORT, +// Address: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], +// }} +// pub type PIF_PHYSICAL_ADDRESS_LH = *mut IF_PHYSICAL_ADDRESS_LH; +pub type NET_PHYSICAL_LOCATION = NET_PHYSICAL_LOCATION_LH; +pub type PNET_PHYSICAL_LOCATION = *mut NET_PHYSICAL_LOCATION; +// pub type IF_COUNTED_STRING = IF_COUNTED_STRING_LH; +// pub type PIF_COUNTED_STRING = *mut IF_COUNTED_STRING; +// pub type IF_PHYSICAL_ADDRESS = IF_PHYSICAL_ADDRESS_LH; +// pub type PIF_PHYSICAL_ADDRESS = *mut IF_PHYSICAL_ADDRESS; +ENUM!{enum IF_ADMINISTRATIVE_STATE { + IF_ADMINISTRATIVE_DISABLED, + IF_ADMINISTRATIVE_ENABLED, + IF_ADMINISTRATIVE_DEMANDDIAL, +}} +pub type PIF_ADMINISTRATIVE_STATE = *mut IF_ADMINISTRATIVE_STATE; +ENUM!{enum IF_OPER_STATUS { + IfOperStatusUp = 1, + IfOperStatusDown, + IfOperStatusTesting, + IfOperStatusUnknown, + IfOperStatusDormant, + IfOperStatusNotPresent, + IfOperStatusLowerLayerDown, +}} +STRUCT!{struct NDIS_INTERFACE_INFORMATION { + ifOperStatus: NET_IF_OPER_STATUS, + ifOperStatusFlags: ULONG, + MediaConnectState: NET_IF_MEDIA_CONNECT_STATE, + MediaDuplexState: NET_IF_MEDIA_DUPLEX_STATE, + ifMtu: ULONG, + ifPromiscuousMode: BOOLEAN, + ifDeviceWakeUpEnable: BOOLEAN, + XmitLinkSpeed: ULONG64, + RcvLinkSpeed: ULONG64, + ifLastChange: ULONG64, + ifCounterDiscontinuityTime: ULONG64, + ifInUnknownProtos: ULONG64, + ifInDiscards: ULONG64, + ifInErrors: ULONG64, + ifHCInOctets: ULONG64, + ifHCInUcastPkts: ULONG64, + ifHCInMulticastPkts: ULONG64, + ifHCInBroadcastPkts: ULONG64, + ifHCOutOctets: ULONG64, + ifHCOutUcastPkts: ULONG64, + ifHCOutMulticastPkts: ULONG64, + ifHCOutBroadcastPkts: ULONG64, + ifOutErrors: ULONG64, + ifOutDiscards: ULONG64, + ifHCInUcastOctets: ULONG64, + ifHCInMulticastOctets: ULONG64, + ifHCInBroadcastOctets: ULONG64, + ifHCOutUcastOctets: ULONG64, + ifHCOutMulticastOctets: ULONG64, + ifHCOutBroadcastOctets: ULONG64, + CompartmentId: NET_IF_COMPARTMENT_ID, + SupportedStatistics: ULONG, +}} +pub type PNDIS_INTERFACE_INFORMATION = *mut NDIS_INTERFACE_INFORMATION; diff --git a/src/shared/ifmib.rs b/src/shared/ifmib.rs new file mode 100644 index 000000000..6656fc57c --- /dev/null +++ b/src/shared/ifmib.rs @@ -0,0 +1,53 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! Contains the public definitions and structures for the non-TCP/IP specific parts of MIB-II. +// #include +// #include +use shared::ifdef::IF_INDEX; +use shared::ipifcons::{IFTYPE, INTERNAL_IF_OPER_STATUS}; +use shared::minwindef::DWORD; +use shared::ntdef::{UCHAR, WCHAR}; +const ANY_SIZE: usize = 1; +STRUCT!{struct MIB_IFNUMBER { + dwValue: DWORD, +}} +pub type PMIB_IFNUMBER = *mut MIB_IFNUMBER; +pub const MAXLEN_PHYSADDR: usize = 8; +pub const MAXLEN_IFDESCR: usize = 256; +pub const MAX_INTERFACE_NAME_LEN: usize = 256; +STRUCT!{struct MIB_IFROW { + wszName: [WCHAR; MAX_INTERFACE_NAME_LEN], + dwIndex: IF_INDEX, + dwType: IFTYPE, + dwMtu: DWORD, + dwSpeed: DWORD, + dwPhysAddrLen: DWORD, + bPhysAddr: [UCHAR; MAXLEN_PHYSADDR], + dwAdminStatus: DWORD, + dwOperStatus: INTERNAL_IF_OPER_STATUS, + dwLastChange: DWORD, + dwInOctets: DWORD, + dwInUcastPkts: DWORD, + dwInNUcastPkts: DWORD, + dwInDiscards: DWORD, + dwInErrors: DWORD, + dwInUnknownProtos: DWORD, + dwOutOctets: DWORD, + dwOutUcastPkts: DWORD, + dwOutNUcastPkts: DWORD, + dwOutDiscards: DWORD, + dwOutErrors: DWORD, + dwOutQLen: DWORD, + dwDescrLen: DWORD, + bDescr: [UCHAR; MAXLEN_IFDESCR], +}} +pub type PMIB_IFROW = *mut MIB_IFROW; +STRUCT!{struct MIB_IFTABLE { + dwNumEntries: DWORD, + table: [MIB_IFROW; ANY_SIZE], +}} +pub type PMIB_IFTABLE = *mut MIB_IFTABLE; +// FIXME: How to define SIZEOF_IFTABLE(X) diff --git a/src/shared/in6addr.rs b/src/shared/in6addr.rs index 6ed9382e6..3c51e4e01 100644 --- a/src/shared/in6addr.rs +++ b/src/shared/in6addr.rs @@ -3,11 +3,12 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -use shared::minwindef::{UCHAR, USHORT}; +//! IPv6 Internet address, 'on-wire' format structure. +use shared::minwindef::{BYTE, WORD}; UNION!{union in6_addr_u { [u16; 8], - Byte Byte_mut: [UCHAR; 16], - Word Word_mut: [USHORT; 8], + Byte Byte_mut: [BYTE; 16], + Word Word_mut: [WORD; 8], }} STRUCT!{struct in6_addr { u: in6_addr_u, diff --git a/src/shared/inaddr.rs b/src/shared/inaddr.rs index c56e1ea8b..830dd0505 100644 --- a/src/shared/inaddr.rs +++ b/src/shared/inaddr.rs @@ -3,7 +3,7 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -//! IPv4 Internet address +//! IPv4 Internet address, 'on-wire' format structure. use shared::minwindef::{UCHAR, ULONG, USHORT}; STRUCT!{struct in_addr_S_un_b { s_b1: UCHAR, diff --git a/src/shared/ipifcons.rs b/src/shared/ipifcons.rs new file mode 100644 index 000000000..c500e2cec --- /dev/null +++ b/src/shared/ipifcons.rs @@ -0,0 +1,244 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! Constants needed for the Interface Object +// #include +use shared::minwindef::ULONG; +pub type IFTYPE = ULONG; +pub const MIN_IF_TYPE: IFTYPE = 1; +pub const IF_TYPE_OTHER: IFTYPE = 1; +pub const IF_TYPE_REGULAR_1822: IFTYPE = 2; +pub const IF_TYPE_HDH_1822: IFTYPE = 3; +pub const IF_TYPE_DDN_X25: IFTYPE = 4; +pub const IF_TYPE_RFC877_X25: IFTYPE = 5; +pub const IF_TYPE_ETHERNET_CSMACD: IFTYPE = 6; +pub const IF_TYPE_IS088023_CSMACD: IFTYPE = 7; +pub const IF_TYPE_ISO88024_TOKENBUS: IFTYPE = 8; +pub const IF_TYPE_ISO88025_TOKENRING: IFTYPE = 9; +pub const IF_TYPE_ISO88026_MAN: IFTYPE = 10; +pub const IF_TYPE_STARLAN: IFTYPE = 11; +pub const IF_TYPE_PROTEON_10MBIT: IFTYPE = 12; +pub const IF_TYPE_PROTEON_80MBIT: IFTYPE = 13; +pub const IF_TYPE_HYPERCHANNEL: IFTYPE = 14; +pub const IF_TYPE_FDDI: IFTYPE = 15; +pub const IF_TYPE_LAP_B: IFTYPE = 16; +pub const IF_TYPE_SDLC: IFTYPE = 17; +pub const IF_TYPE_DS1: IFTYPE = 18; +pub const IF_TYPE_E1: IFTYPE = 19; +pub const IF_TYPE_BASIC_ISDN: IFTYPE = 20; +pub const IF_TYPE_PRIMARY_ISDN: IFTYPE = 21; +pub const IF_TYPE_PROP_POINT2POINT_SERIAL: IFTYPE = 22; +pub const IF_TYPE_PPP: IFTYPE = 23; +pub const IF_TYPE_SOFTWARE_LOOPBACK: IFTYPE = 24; +pub const IF_TYPE_EON: IFTYPE = 25; +pub const IF_TYPE_ETHERNET_3MBIT: IFTYPE = 26; +pub const IF_TYPE_NSIP: IFTYPE = 27; +pub const IF_TYPE_SLIP: IFTYPE = 28; +pub const IF_TYPE_ULTRA: IFTYPE = 29; +pub const IF_TYPE_DS3: IFTYPE = 30; +pub const IF_TYPE_SIP: IFTYPE = 31; +pub const IF_TYPE_FRAMERELAY: IFTYPE = 32; +pub const IF_TYPE_RS232: IFTYPE = 33; +pub const IF_TYPE_PARA: IFTYPE = 34; +pub const IF_TYPE_ARCNET: IFTYPE = 35; +pub const IF_TYPE_ARCNET_PLUS: IFTYPE = 36; +pub const IF_TYPE_ATM: IFTYPE = 37; +pub const IF_TYPE_MIO_X25: IFTYPE = 38; +pub const IF_TYPE_SONET: IFTYPE = 39; +pub const IF_TYPE_X25_PLE: IFTYPE = 40; +pub const IF_TYPE_ISO88022_LLC: IFTYPE = 41; +pub const IF_TYPE_LOCALTALK: IFTYPE = 42; +pub const IF_TYPE_SMDS_DXI: IFTYPE = 43; +pub const IF_TYPE_FRAMERELAY_SERVICE: IFTYPE = 44; +pub const IF_TYPE_V35: IFTYPE = 45; +pub const IF_TYPE_HSSI: IFTYPE = 46; +pub const IF_TYPE_HIPPI: IFTYPE = 47; +pub const IF_TYPE_MODEM: IFTYPE = 48; +pub const IF_TYPE_AAL5: IFTYPE = 49; +pub const IF_TYPE_SONET_PATH: IFTYPE = 50; +pub const IF_TYPE_SONET_VT: IFTYPE = 51; +pub const IF_TYPE_SMDS_ICIP: IFTYPE = 52; +pub const IF_TYPE_PROP_VIRTUAL: IFTYPE = 53; +pub const IF_TYPE_PROP_MULTIPLEXOR: IFTYPE = 54; +pub const IF_TYPE_IEEE80212: IFTYPE = 55; +pub const IF_TYPE_FIBRECHANNEL: IFTYPE = 56; +pub const IF_TYPE_HIPPIINTERFACE: IFTYPE = 57; +pub const IF_TYPE_FRAMERELAY_INTERCONNECT: IFTYPE = 58; +pub const IF_TYPE_AFLANE_8023: IFTYPE = 59; +pub const IF_TYPE_AFLANE_8025: IFTYPE = 60; +pub const IF_TYPE_CCTEMUL: IFTYPE = 61; +pub const IF_TYPE_FASTETHER: IFTYPE = 62; +pub const IF_TYPE_ISDN: IFTYPE = 63; +pub const IF_TYPE_V11: IFTYPE = 64; +pub const IF_TYPE_V36: IFTYPE = 65; +pub const IF_TYPE_G703_64K: IFTYPE = 66; +pub const IF_TYPE_G703_2MB: IFTYPE = 67; +pub const IF_TYPE_QLLC: IFTYPE = 68; +pub const IF_TYPE_FASTETHER_FX: IFTYPE = 69; +pub const IF_TYPE_CHANNEL: IFTYPE = 70; +pub const IF_TYPE_IEEE80211: IFTYPE = 71; +pub const IF_TYPE_IBM370PARCHAN: IFTYPE = 72; +pub const IF_TYPE_ESCON: IFTYPE = 73; +pub const IF_TYPE_DLSW: IFTYPE = 74; +pub const IF_TYPE_ISDN_S: IFTYPE = 75; +pub const IF_TYPE_ISDN_U: IFTYPE = 76; +pub const IF_TYPE_LAP_D: IFTYPE = 77; +pub const IF_TYPE_IPSWITCH: IFTYPE = 78; +pub const IF_TYPE_RSRB: IFTYPE = 79; +pub const IF_TYPE_ATM_LOGICAL: IFTYPE = 80; +pub const IF_TYPE_DS0: IFTYPE = 81; +pub const IF_TYPE_DS0_BUNDLE: IFTYPE = 82; +pub const IF_TYPE_BSC: IFTYPE = 83; +pub const IF_TYPE_ASYNC: IFTYPE = 84; +pub const IF_TYPE_CNR: IFTYPE = 85; +pub const IF_TYPE_ISO88025R_DTR: IFTYPE = 86; +pub const IF_TYPE_EPLRS: IFTYPE = 87; +pub const IF_TYPE_ARAP: IFTYPE = 88; +pub const IF_TYPE_PROP_CNLS: IFTYPE = 89; +pub const IF_TYPE_HOSTPAD: IFTYPE = 90; +pub const IF_TYPE_TERMPAD: IFTYPE = 91; +pub const IF_TYPE_FRAMERELAY_MPI: IFTYPE = 92; +pub const IF_TYPE_X213: IFTYPE = 93; +pub const IF_TYPE_ADSL: IFTYPE = 94; +pub const IF_TYPE_RADSL: IFTYPE = 95; +pub const IF_TYPE_SDSL: IFTYPE = 96; +pub const IF_TYPE_VDSL: IFTYPE = 97; +pub const IF_TYPE_ISO88025_CRFPRINT: IFTYPE = 98; +pub const IF_TYPE_MYRINET: IFTYPE = 99; +pub const IF_TYPE_VOICE_EM: IFTYPE = 100; +pub const IF_TYPE_VOICE_FXO: IFTYPE = 101; +pub const IF_TYPE_VOICE_FXS: IFTYPE = 102; +pub const IF_TYPE_VOICE_ENCAP: IFTYPE = 103; +pub const IF_TYPE_VOICE_OVERIP: IFTYPE = 104; +pub const IF_TYPE_ATM_DXI: IFTYPE = 105; +pub const IF_TYPE_ATM_FUNI: IFTYPE = 106; +pub const IF_TYPE_ATM_IMA: IFTYPE = 107; +pub const IF_TYPE_PPPMULTILINKBUNDLE: IFTYPE = 108; +pub const IF_TYPE_IPOVER_CDLC: IFTYPE = 109; +pub const IF_TYPE_IPOVER_CLAW: IFTYPE = 110; +pub const IF_TYPE_STACKTOSTACK: IFTYPE = 111; +pub const IF_TYPE_VIRTUALIPADDRESS: IFTYPE = 112; +pub const IF_TYPE_MPC: IFTYPE = 113; +pub const IF_TYPE_IPOVER_ATM: IFTYPE = 114; +pub const IF_TYPE_ISO88025_FIBER: IFTYPE = 115; +pub const IF_TYPE_TDLC: IFTYPE = 116; +pub const IF_TYPE_GIGABITETHERNET: IFTYPE = 117; +pub const IF_TYPE_HDLC: IFTYPE = 118; +pub const IF_TYPE_LAP_F: IFTYPE = 119; +pub const IF_TYPE_V37: IFTYPE = 120; +pub const IF_TYPE_X25_MLP: IFTYPE = 121; +pub const IF_TYPE_X25_HUNTGROUP: IFTYPE = 122; +pub const IF_TYPE_TRANSPHDLC: IFTYPE = 123; +pub const IF_TYPE_INTERLEAVE: IFTYPE = 124; +pub const IF_TYPE_FAST: IFTYPE = 125; +pub const IF_TYPE_IP: IFTYPE = 126; +pub const IF_TYPE_DOCSCABLE_MACLAYER: IFTYPE = 127; +pub const IF_TYPE_DOCSCABLE_DOWNSTREAM: IFTYPE = 128; +pub const IF_TYPE_DOCSCABLE_UPSTREAM: IFTYPE = 129; +pub const IF_TYPE_A12MPPSWITCH: IFTYPE = 130; +pub const IF_TYPE_TUNNEL: IFTYPE = 131; +pub const IF_TYPE_COFFEE: IFTYPE = 132; +pub const IF_TYPE_CES: IFTYPE = 133; +pub const IF_TYPE_ATM_SUBINTERFACE: IFTYPE = 134; +pub const IF_TYPE_L2_VLAN: IFTYPE = 135; +pub const IF_TYPE_L3_IPVLAN: IFTYPE = 136; +pub const IF_TYPE_L3_IPXVLAN: IFTYPE = 137; +pub const IF_TYPE_DIGITALPOWERLINE: IFTYPE = 138; +pub const IF_TYPE_MEDIAMAILOVERIP: IFTYPE = 139; +pub const IF_TYPE_DTM: IFTYPE = 140; +pub const IF_TYPE_DCN: IFTYPE = 141; +pub const IF_TYPE_IPFORWARD: IFTYPE = 142; +pub const IF_TYPE_MSDSL: IFTYPE = 143; +pub const IF_TYPE_IEEE1394: IFTYPE = 144; +pub const IF_TYPE_IF_GSN: IFTYPE = 145; +pub const IF_TYPE_DVBRCC_MACLAYER: IFTYPE = 146; +pub const IF_TYPE_DVBRCC_DOWNSTREAM: IFTYPE = 147; +pub const IF_TYPE_DVBRCC_UPSTREAM: IFTYPE = 148; +pub const IF_TYPE_ATM_VIRTUAL: IFTYPE = 149; +pub const IF_TYPE_MPLS_TUNNEL: IFTYPE = 150; +pub const IF_TYPE_SRP: IFTYPE = 151; +pub const IF_TYPE_VOICEOVERATM: IFTYPE = 152; +pub const IF_TYPE_VOICEOVERFRAMERELAY: IFTYPE = 153; +pub const IF_TYPE_IDSL: IFTYPE = 154; +pub const IF_TYPE_COMPOSITELINK: IFTYPE = 155; +pub const IF_TYPE_SS7_SIGLINK: IFTYPE = 156; +pub const IF_TYPE_PROP_WIRELESS_P2P: IFTYPE = 157; +pub const IF_TYPE_FR_FORWARD: IFTYPE = 158; +pub const IF_TYPE_RFC1483: IFTYPE = 159; +pub const IF_TYPE_USB: IFTYPE = 160; +pub const IF_TYPE_IEEE8023AD_LAG: IFTYPE = 161; +pub const IF_TYPE_BGP_POLICY_ACCOUNTING: IFTYPE = 162; +pub const IF_TYPE_FRF16_MFR_BUNDLE: IFTYPE = 163; +pub const IF_TYPE_H323_GATEKEEPER: IFTYPE = 164; +pub const IF_TYPE_H323_PROXY: IFTYPE = 165; +pub const IF_TYPE_MPLS: IFTYPE = 166; +pub const IF_TYPE_MF_SIGLINK: IFTYPE = 167; +pub const IF_TYPE_HDSL2: IFTYPE = 168; +pub const IF_TYPE_SHDSL: IFTYPE = 169; +pub const IF_TYPE_DS1_FDL: IFTYPE = 170; +pub const IF_TYPE_POS: IFTYPE = 171; +pub const IF_TYPE_DVB_ASI_IN: IFTYPE = 172; +pub const IF_TYPE_DVB_ASI_OUT: IFTYPE = 173; +pub const IF_TYPE_PLC: IFTYPE = 174; +pub const IF_TYPE_NFAS: IFTYPE = 175; +pub const IF_TYPE_TR008: IFTYPE = 176; +pub const IF_TYPE_GR303_RDT: IFTYPE = 177; +pub const IF_TYPE_GR303_IDT: IFTYPE = 178; +pub const IF_TYPE_ISUP: IFTYPE = 179; +pub const IF_TYPE_PROP_DOCS_WIRELESS_MACLAYER: IFTYPE = 180; +pub const IF_TYPE_PROP_DOCS_WIRELESS_DOWNSTREAM: IFTYPE = 181; +pub const IF_TYPE_PROP_DOCS_WIRELESS_UPSTREAM: IFTYPE = 182; +pub const IF_TYPE_HIPERLAN2: IFTYPE = 183; +pub const IF_TYPE_PROP_BWA_P2MP: IFTYPE = 184; +pub const IF_TYPE_SONET_OVERHEAD_CHANNEL: IFTYPE = 185; +pub const IF_TYPE_DIGITAL_WRAPPER_OVERHEAD_CHANNEL: IFTYPE = 186; +pub const IF_TYPE_AAL2: IFTYPE = 187; +pub const IF_TYPE_RADIO_MAC: IFTYPE = 188; +pub const IF_TYPE_ATM_RADIO: IFTYPE = 189; +pub const IF_TYPE_IMT: IFTYPE = 190; +pub const IF_TYPE_MVL: IFTYPE = 191; +pub const IF_TYPE_REACH_DSL: IFTYPE = 192; +pub const IF_TYPE_FR_DLCI_ENDPT: IFTYPE = 193; +pub const IF_TYPE_ATM_VCI_ENDPT: IFTYPE = 194; +pub const IF_TYPE_OPTICAL_CHANNEL: IFTYPE = 195; +pub const IF_TYPE_OPTICAL_TRANSPORT: IFTYPE = 196; +pub const IF_TYPE_IEEE80216_WMAN: IFTYPE = 237; +pub const IF_TYPE_WWANPP: IFTYPE = 243; +pub const IF_TYPE_WWANPP2: IFTYPE = 244; +pub const IF_TYPE_IEEE802154: IFTYPE = 259; +pub const IF_TYPE_XBOX_WIRELESS: IFTYPE = 281; +pub const MAX_IF_TYPE: IFTYPE = 281; +ENUM!{enum IF_ACCESS_TYPE { + IF_ACCESS_LOOPBACK = 1, + IF_ACCESS_BROADCAST = 2, + IF_ACCESS_POINT_TO_POINT = 3, + IF_ACCESS_POINTTOPOINT = 3, + IF_ACCESS_POINT_TO_MULTI_POINT = 4, + IF_ACCESS_POINTTOMULTIPOINT = 4, +}} +ENUM!{enum INTERNAL_IF_OPER_STATUS { + IF_OPER_STATUS_NON_OPERATIONAL = 0, + IF_OPER_STATUS_UNREACHABLE = 1, + IF_OPER_STATUS_DISCONNECTED = 2, + IF_OPER_STATUS_CONNECTING = 3, + IF_OPER_STATUS_CONNECTED = 4, + IF_OPER_STATUS_OPERATIONAL = 5, +}} +pub const MIB_IF_TYPE_OTHER: IFTYPE = 1; +pub const MIB_IF_TYPE_ETHERNET: IFTYPE = 6; +pub const MIB_IF_TYPE_TOKENRING: IFTYPE = 9; +pub const MIB_IF_TYPE_FDDI: IFTYPE = 15; +pub const MIB_IF_TYPE_PPP: IFTYPE = 23; +pub const MIB_IF_TYPE_LOOPBACK: IFTYPE = 24; +pub const MIB_IF_TYPE_SLIP: IFTYPE = 28; +pub const MIB_IF_ADMIN_STATUS_UP: IFTYPE = 1; +pub const MIB_IF_ADMIN_STATUS_DOWN: IFTYPE = 2; +pub const MIB_IF_ADMIN_STATUS_TESTING: IFTYPE = 3; +pub const MIB_IF_OPER_STATUS_NON_OPERATIONAL: INTERNAL_IF_OPER_STATUS = 0; +pub const MIB_IF_OPER_STATUS_UNREACHABLE: INTERNAL_IF_OPER_STATUS = 1; +pub const MIB_IF_OPER_STATUS_DISCONNECTED: INTERNAL_IF_OPER_STATUS = 2; +pub const MIB_IF_OPER_STATUS_CONNECTING: INTERNAL_IF_OPER_STATUS = 3; +pub const MIB_IF_OPER_STATUS_CONNECTED: INTERNAL_IF_OPER_STATUS = 4; +pub const MIB_IF_OPER_STATUS_OPERATIONAL: INTERNAL_IF_OPER_STATUS = 5; diff --git a/src/shared/ipmib.rs b/src/shared/ipmib.rs new file mode 100644 index 000000000..caa0179f4 --- /dev/null +++ b/src/shared/ipmib.rs @@ -0,0 +1,384 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +// #include +use shared::ifdef::IF_INDEX; +use shared::ifmib::MAXLEN_PHYSADDR; +use shared::minwindef::DWORD; +use shared::nldef::NL_ROUTE_PROTOCOL; +use shared::ntdef::{PVOID, UCHAR, ULONG, USHORT}; +const ANY_SIZE: usize = 1; +STRUCT!{struct MIB_IPADDRROW_XP { + dwAddr: DWORD, + dwIndex: IF_INDEX, + dwMask: DWORD, + dwBCastAddr: DWORD, + dwReasmSize: DWORD, + unused1: USHORT, + wType: USHORT, +}} +pub type PMIB_IPADDRROW_XP = *mut MIB_IPADDRROW_XP; +STRUCT!{struct MIB_IPADDRROW_W2K { + dwAddr: DWORD, + dwIndex: DWORD, + dwMask: DWORD, + dwBCastAddr: DWORD, + dwReasmSize: DWORD, + unused1: USHORT, + unused2: USHORT, +}} +pub type PMIB_IPADDRROW_W2K = *mut MIB_IPADDRROW_W2K; +// Windows XP +// pub type MIB_IPADDRROW = MIB_IPADDRROW_XP; +pub type MIB_IPADDRROW = MIB_IPADDRROW_W2K; +pub type PMIB_IPADDRROW = *mut MIB_IPADDRROW; +STRUCT!{struct MIB_IPADDRTABLE { + dwNumEntries: DWORD, + table: [MIB_IPADDRROW; ANY_SIZE], +}} +pub type PMIB_IPADDRTABLE = *mut MIB_IPADDRTABLE; +STRUCT!{struct MIB_IPFORWARDNUMBER { + dwValue: DWORD, +}} +pub type PMIB_IPFORWARDNUMBER = *mut MIB_IPFORWARDNUMBER; +pub type MIB_IPFORWARD_PROTO = NL_ROUTE_PROTOCOL; +ENUM!{enum MIB_IPFORWARD_TYPE { + MIB_IPROUTE_TYPE_OTHER = 1, + MIB_IPROUTE_TYPE_INVALID = 2, + MIB_IPROUTE_TYPE_DIRECT = 3, + MIB_IPROUTE_TYPE_INDIRECT = 4, +}} +STRUCT!{struct MIB_IPFORWARDROW { + dwForwardDest: DWORD, + dwForwardMask: DWORD, + dwForwardPolicy: DWORD, + dwForwardNextHop: DWORD, + dwForwardIfIndex: IF_INDEX, + ForwardType: MIB_IPFORWARD_TYPE, + ForwardProto: MIB_IPFORWARD_PROTO, + dwForwardAge: DWORD, + dwForwardNextHopAS: DWORD, + dwForwardMetric1: DWORD, + dwForwardMetric2: DWORD, + dwForwardMetric3: DWORD, + dwForwardMetric4: DWORD, + dwForwardMetric5: DWORD, +}} +pub type PMIB_IPFORWARDROW = *mut MIB_IPFORWARDROW; +STRUCT!{struct MIB_IPFORWARDTABLE { + dwNumEntries: DWORD, + table: [MIB_IPFORWARDROW; ANY_SIZE], +}} +pub type PMIB_IPFORWARDTABLE = *mut MIB_IPFORWARDTABLE; +ENUM!{enum MIB_IPNET_TYPE { + MIB_IPNET_TYPE_OTHER = 1, + MIB_IPNET_TYPE_INVALID = 2, + MIB_IPNET_TYPE_DYNAMIC = 3, + MIB_IPNET_TYPE_STATIC = 4, +}} +STRUCT!{struct MIB_IPNETROW_LH { + dwIndex: IF_INDEX, + dwPhysAddrLen: DWORD, + bPhysAddr: [UCHAR; MAXLEN_PHYSADDR], + dwAddr: DWORD, + Type: MIB_IPNET_TYPE, +}} +pub type PMIB_IPNETROW_LH = *mut MIB_IPNETROW_LH; +STRUCT!{struct MIB_IPNETROW_W2K { + dwIndex: IF_INDEX, + dwPhysAddrLen: DWORD, + bPhysAddr: [UCHAR; MAXLEN_PHYSADDR], + dwAddr: DWORD, + dwType: DWORD, +}} +pub type PMIB_IPNETROW_W2K = *mut MIB_IPNETROW_W2K; +// Windows XP +// pub type MIB_IPNETROW = MIB_IPNETROW_LH; +pub type MIB_IPNETROW = MIB_IPNETROW_W2K; +pub type PMIB_IPNETROW = *mut MIB_IPNETROW; +STRUCT!{struct MIB_IPNETTABLE { + dwNumEntries: DWORD, + table: [MIB_IPNETROW; ANY_SIZE], +}} +pub type PMIB_IPNETTABLE = *mut MIB_IPNETTABLE; +ENUM!{enum MIB_IPSTATS_FORWARDING { + MIB_IP_FORWARDING = 1, + MIB_IP_NOT_FORWARDING = 2, +}} +pub type PMIB_IPSTATS_FORWARDING = *mut MIB_IPSTATS_FORWARDING; +STRUCT!{struct MIB_IPSTATS_LH { + Forwarding: MIB_IPSTATS_FORWARDING, + dwDefaultTTL: DWORD, + dwInReceives: DWORD, + dwInHdrErrors: DWORD, + dwInAddrErrors: DWORD, + dwForwDatagrams: DWORD, + dwInUnknownProtos: DWORD, + dwInDiscards: DWORD, + dwInDelivers: DWORD, + dwOutRequests: DWORD, + dwRoutingDiscards: DWORD, + dwOutDiscards: DWORD, + dwOutNoRoutes: DWORD, + dwReasmTimeout: DWORD, + dwReasmReqds: DWORD, + dwReasmOks: DWORD, + dwReasmFails: DWORD, + dwFragOks: DWORD, + dwFragFails: DWORD, + dwFragCreates: DWORD, + dwNumIf: DWORD, + dwNumAddr: DWORD, + dwNumRoutes: DWORD, +}} +pub type PMIB_IPSTATS_LH = *mut MIB_IPSTATS_LH; +STRUCT!{struct MIB_IPSTATS_W2K { + dwForwarding: DWORD, + dwDefaultTTL: DWORD, + dwInReceives: DWORD, + dwInHdrErrors: DWORD, + dwInAddrErrors: DWORD, + dwForwDatagrams: DWORD, + dwInUnknownProtos: DWORD, + dwInDiscards: DWORD, + dwInDelivers: DWORD, + dwOutRequests: DWORD, + dwRoutingDiscards: DWORD, + dwOutDiscards: DWORD, + dwOutNoRoutes: DWORD, + dwReasmTimeout: DWORD, + dwReasmReqds: DWORD, + dwReasmOks: DWORD, + dwReasmFails: DWORD, + dwFragOks: DWORD, + dwFragFails: DWORD, + dwFragCreates: DWORD, + dwNumIf: DWORD, + dwNumAddr: DWORD, + dwNumRoutes: DWORD, +}} +pub type PMIB_IPSTATS_W2K = *mut MIB_IPSTATS_W2K; +// Windows XP +// pub type MIB_IPSTATS = MIB_IPSTATS_LH; +pub type MIB_IPSTATS = MIB_IPSTATS_W2K; +pub type PMIB_IPSTATS = *mut MIB_IPSTATS; +STRUCT!{struct MIBICMPSTATS { + dwMsgs: DWORD, + dwErrors: DWORD, + dwDestUnreachs: DWORD, + dwTimeExcds: DWORD, + dwParmProbs: DWORD, + dwSrcQuenchs: DWORD, + dwRedirects: DWORD, + dwEchos: DWORD, + dwEchoReps: DWORD, + dwTimestamps: DWORD, + dwTimestampReps: DWORD, + dwAddrMasks: DWORD, + dwAddrMaskReps: DWORD, +}} +pub type PMIBICMPSTATS = *mut MIBICMPSTATS; +STRUCT!{struct MIBICMPINFO { + icmpInStats: MIBICMPSTATS, + icmpOutStats: MIBICMPSTATS, +}} +STRUCT!{struct MIB_ICMP { + stats: MIBICMPINFO, +}} +pub type PMIB_ICMP = *mut MIB_ICMP; +STRUCT!{struct MIBICMPSTATS_EX_XPSP1 { + dwMsgs: DWORD, + dwErrors: DWORD, + rgdwTypeCount: [DWORD; 256], +}} +pub type PMIBICMPSTATS_EX_XPSP1 = *mut MIBICMPSTATS_EX_XPSP1; +pub type MIBICMPSTATS_EX = MIBICMPSTATS_EX_XPSP1; +pub type PMIBICMPSTATS_EX = *mut MIBICMPSTATS_EX_XPSP1; +STRUCT!{struct MIB_ICMP_EX_XPSP1 { + icmpInStats: MIBICMPSTATS_EX, + icmpOutStats: MIBICMPSTATS_EX, +}} +pub type PMIB_ICMP_EX_XPSP1 = *mut MIB_ICMP_EX_XPSP1; +pub type MIB_ICMP_EX = MIB_ICMP_EX_XPSP1; +pub type PMIB_ICMP_EX = *mut MIB_ICMP_EX_XPSP1; +ENUM!{enum ICMP6_TYPE { + ICMP6_DST_UNREACH = 1, + ICMP6_PACKET_TOO_BIG = 2, + ICMP6_TIME_EXCEEDED = 3, + ICMP6_PARAM_PROB = 4, + ICMP6_ECHO_REQUEST = 128, + ICMP6_ECHO_REPLY = 129, + ICMP6_MEMBERSHIP_QUERY = 130, + ICMP6_MEMBERSHIP_REPORT = 131, + ICMP6_MEMBERSHIP_REDUCTION = 132, + ND_ROUTER_SOLICIT = 133, + ND_ROUTER_ADVERT = 134, + ND_NEIGHBOR_SOLICIT = 135, + ND_NEIGHBOR_ADVERT = 136, + ND_REDIRECT = 137, + ICMP6_V2_MEMBERSHIP_REPORT = 143, +}} +pub type PICMP6_TYPE = *mut ICMP6_TYPE; +ENUM!{enum ICMP4_TYPE { + ICMP4_ECHO_REPLY = 0, + ICMP4_DST_UNREACH = 3, + ICMP4_SOURCE_QUENCH = 4, + ICMP4_REDIRECT = 5, + ICMP4_ECHO_REQUEST = 8, + ICMP4_ROUTER_ADVERT = 9, + ICMP4_ROUTER_SOLICIT = 10, + ICMP4_TIME_EXCEEDED = 11, + ICMP4_PARAM_PROB = 12, + ICMP4_TIMESTAMP_REQUEST = 13, + ICMP4_TIMESTAMP_REPLY = 14, + ICMP4_MASK_REQUEST = 17, + ICMP4_MASK_REPLY = 18, +}} +pub type PICMP4_TYPE = *mut ICMP4_TYPE; +STRUCT!{struct MIB_IPMCAST_OIF_XP { + dwOutIfIndex: DWORD, + dwNextHopAddr: DWORD, + dwReserved: DWORD, + dwReserved1: DWORD, +}} +pub type PMIB_IPMCAST_OIF_XP = *mut MIB_IPMCAST_OIF_XP; +STRUCT!{struct MIB_IPMCAST_OIF_W2K { + dwOutIfIndex: DWORD, + dwNextHopAddr: DWORD, + pvReserved: PVOID, + dwReserved: DWORD, +}} +pub type PMIB_IPMCAST_OIF_W2K = *mut MIB_IPMCAST_OIF_W2K; +// Windows XP +// pub type MIB_IPMCAST_OIF = MIB_IPMCAST_OIF_XP; +pub type MIB_IPMCAST_OIF = MIB_IPMCAST_OIF_W2K; +pub type PMIB_IPMCAST_OIF = *mut MIB_IPMCAST_OIF; +STRUCT!{struct MIB_IPMCAST_MFE { + dwGroup: DWORD, + dwSource: DWORD, + dwSrcMask: DWORD, + dwUpStrmNgbr: DWORD, + dwInIfIndex: DWORD, + dwInIfProtocol: DWORD, + dwRouteProtocol: DWORD, + dwRouteNetwork: DWORD, + dwRouteMask: DWORD, + ulUpTime: ULONG, + ulExpiryTime: ULONG, + ulTimeOut: ULONG, + ulNumOutIf: ULONG, + fFlags: DWORD, + dwReserved: DWORD, + rgmioOutInfo: [MIB_IPMCAST_OIF; ANY_SIZE], +}} +pub type PMIB_IPMCAST_MFE = *mut MIB_IPMCAST_MFE; +STRUCT!{struct MIB_MFE_TABLE { + dwNumEntries: DWORD, + table: [MIB_IPMCAST_MFE; ANY_SIZE], +}} +pub type PMIB_MFE_TABLE = *mut MIB_MFE_TABLE; +STRUCT!{struct MIB_IPMCAST_OIF_STATS_LH { + dwOutIfIndex: DWORD, + dwNextHopAddr: DWORD, + dwDialContext: DWORD, + ulTtlTooLow: ULONG, + ulFragNeeded: ULONG, + ulOutPackets: ULONG, + ulOutDiscards: ULONG, +}} +pub type PMIB_IPMCAST_OIF_STATS_LH = *mut MIB_IPMCAST_OIF_STATS_LH; +STRUCT!{struct MIB_IPMCAST_OIF_STATS_W2K { + dwOutIfIndex: DWORD, + dwNextHopAddr: DWORD, + pvDialContext: PVOID, + ulTtlTooLow: ULONG, + ulFragNeeded: ULONG, + ulOutPackets: ULONG, + ulOutDiscards: ULONG, +}} +pub type PMIB_IPMCAST_OIF_STATS_W2K = *mut MIB_IPMCAST_OIF_STATS_W2K; +// Windows Vista +// pub type MIB_IPMCAST_OIF_STATS = MIB_IPMCAST_OIF_STATS_LH; +pub type MIB_IPMCAST_OIF_STATS = MIB_IPMCAST_OIF_STATS_W2K; +pub type PMIB_IPMCAST_OIF_STATS = *mut MIB_IPMCAST_OIF_STATS; +STRUCT!{struct MIB_IPMCAST_MFE_STATS { + dwGroup: DWORD, + dwSource: DWORD, + dwSrcMask: DWORD, + dwUpStrmNgbr: DWORD, + dwInIfIndex: DWORD, + dwInIfProtocol: DWORD, + dwRouteProtocol: DWORD, + dwRouteNetwork: DWORD, + dwRouteMask: DWORD, + ulUpTime: ULONG, + ulExpiryTime: ULONG, + ulNumOutIf: ULONG, + ulInPkts: ULONG, + ulInOctets: ULONG, + ulPktsDifferentIf: ULONG, + ulQueueOverflow: ULONG, + rgmiosOutStats: [MIB_IPMCAST_OIF_STATS; ANY_SIZE], +}} +pub type PMIB_IPMCAST_MFE_STATS = *mut MIB_IPMCAST_MFE_STATS; +STRUCT!{struct MIB_MFE_STATS_TABLE { + dwNumEntries: DWORD, + table: [MIB_IPMCAST_MFE_STATS; ANY_SIZE], +}} +pub type PMIB_MFE_STATS_TABLE = *mut MIB_MFE_STATS_TABLE; +STRUCT!{struct MIB_IPMCAST_MFE_STATS_EX_XP { + dwGroup: DWORD, + dwSource: DWORD, + dwSrcMask: DWORD, + dwUpStrmNgbr: DWORD, + dwInIfIndex: DWORD, + dwInIfProtocol: DWORD, + dwRouteProtocol: DWORD, + dwRouteNetwork: DWORD, + dwRouteMask: DWORD, + ulUpTime: ULONG, + ulExpiryTime: ULONG, + ulNumOutIf: ULONG, + ulInPkts: ULONG, + ulInOctets: ULONG, + ulPktsDifferentIf: ULONG, + ulQueueOverflow: ULONG, + ulUninitMfe: ULONG, + ulNegativeMfe: ULONG, + ulInDiscards: ULONG, + ulInHdrErrors: ULONG, + ulTotalOutPackets: ULONG, + rgmiosOutStats: [MIB_IPMCAST_OIF_STATS; ANY_SIZE], +}} +pub type PMIB_IPMCAST_MFE_STATS_EX_XP = *mut MIB_IPMCAST_MFE_STATS_EX_XP; +pub type MIB_IPMCAST_MFE_STATS_EX = MIB_IPMCAST_MFE_STATS_EX_XP; +pub type PMIB_IPMCAST_MFE_STATS_EX = *mut MIB_IPMCAST_MFE_STATS_EX; +STRUCT!{struct MIB_MFE_STATS_TABLE_EX_XP { + dwNumEntries: DWORD, + table: [PMIB_IPMCAST_MFE_STATS_EX_XP; ANY_SIZE], +}} +pub type PMIB_MFE_STATS_TABLE_EX_XP = *mut MIB_MFE_STATS_TABLE_EX_XP; +pub type MIB_MFE_STATS_TABLE_EX = MIB_MFE_STATS_TABLE_EX_XP; +pub type PMIB_MFE_STATS_TABLE_EX = *mut MIB_MFE_STATS_TABLE_EX; +STRUCT!{struct MIB_IPMCAST_GLOBAL { + dwEnable: DWORD, +}} +pub type PMIB_IPMCAST_GLOBAL = *mut MIB_IPMCAST_GLOBAL; +STRUCT!{struct MIB_IPMCAST_IF_ENTRY { + dwIfIndex: DWORD, + dwTtl: DWORD, + dwProtocol: DWORD, + dwRateLimit: DWORD, + ulInMcastOctets: ULONG, + ulOutMcastOctets: ULONG, +}} +pub type PMIB_IPMCAST_IF_ENTRY = *mut MIB_IPMCAST_IF_ENTRY; +STRUCT!{struct MIB_IPMCAST_IF_TABLE { + dwNumEntries: DWORD, + table: [MIB_IPMCAST_IF_ENTRY; ANY_SIZE], +}} +pub type PMIB_IPMCAST_IF_TABLE = *mut MIB_IPMCAST_IF_TABLE; diff --git a/src/shared/iprtrmib.rs b/src/shared/iprtrmib.rs new file mode 100644 index 000000000..ca667b9a5 --- /dev/null +++ b/src/shared/iprtrmib.rs @@ -0,0 +1,125 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +// #include +// #include +// #include +// #include +use shared::ipmib::MIB_IPFORWARDROW; +use shared::minwindef::{BOOL, BYTE, DWORD}; +use shared::ntdef::{PWCHAR, ULONGLONG, WCHAR}; +pub const MAX_SCOPE_NAME_LEN: usize = 255; +pub const MAX_MIB_OFFSET: usize = 8; +const ANY_SIZE: usize = 1; +STRUCT!{struct MIB_OPAQUE_QUERY { + dwVarId: DWORD, + rgdwVarIndex: [DWORD; ANY_SIZE], +}} +pub type PMIB_OPAQUE_QUERY = *mut MIB_OPAQUE_QUERY; +ENUM!{enum TCP_TABLE_CLASS { + TCP_TABLE_BASIC_LISTENER, + TCP_TABLE_BASIC_CONNECTIONS, + TCP_TABLE_BASIC_ALL, + TCP_TABLE_OWNER_PID_LISTENER, + TCP_TABLE_OWNER_PID_CONNECTIONS, + TCP_TABLE_OWNER_PID_ALL, + TCP_TABLE_OWNER_MODULE_LISTENER, + TCP_TABLE_OWNER_MODULE_CONNECTIONS, + TCP_TABLE_OWNER_MODULE_ALL, +}} +pub type PTCP_TABLE_CLASS = *mut TCP_TABLE_CLASS; +ENUM!{enum UDP_TABLE_CLASS { + UDP_TABLE_BASIC, + UDP_TABLE_OWNER_PID, + UDP_TABLE_OWNER_MODULE, +}} +pub type PUDP_TABLE_CLASS = *mut UDP_TABLE_CLASS; +ENUM!{enum TCPIP_OWNER_MODULE_INFO_CLASS { + TCPIP_OWNER_MODULE_INFO_BASIC, +}} +pub type PTCPIP_OWNER_MODULE_INFO_CLASS = *mut TCPIP_OWNER_MODULE_INFO_CLASS; +STRUCT!{struct TCPIP_OWNER_MODULE_BASIC_INFO { + pModuleName: PWCHAR, + pModulePath: PWCHAR, +}} +pub type PTCPIP_OWNER_MODULE_BASIC_INFO = *mut TCPIP_OWNER_MODULE_BASIC_INFO; +STRUCT!{struct MIB_IPMCAST_BOUNDARY { + dwIfIndex: DWORD, + dwGroupAddress: DWORD, + dwGroupMask: DWORD, + dwStatus: DWORD, +}} +pub type PMIB_IPMCAST_BOUNDARY = *mut MIB_IPMCAST_BOUNDARY; +STRUCT!{struct MIB_IPMCAST_BOUNDARY_TABLE { + dwNumEntries: DWORD, + table: [MIB_IPMCAST_BOUNDARY; ANY_SIZE], +}} +pub type PMIB_IPMCAST_BOUNDARY_TABLE = *mut MIB_IPMCAST_BOUNDARY_TABLE; +STRUCT!{struct MIB_BOUNDARYROW { + dwGroupAddress: DWORD, + dwGroupMask: DWORD, +}} +pub type PMIB_BOUNDARYROW = *mut MIB_BOUNDARYROW; +STRUCT!{struct MIB_MCAST_LIMIT_ROW { + dwTtl: DWORD, + dwRateLimit: DWORD, +}} +pub type PMIB_MCAST_LIMIT_ROW = *mut MIB_MCAST_LIMIT_ROW; +pub type SN_CHAR = WCHAR; +pub type SCOPE_NAME_BUFFER = [SN_CHAR; MAX_SCOPE_NAME_LEN + 1]; +pub type SCOPE_NAME = *mut SCOPE_NAME_BUFFER; +STRUCT!{struct MIB_IPMCAST_SCOPE { + dwGroupAddress: DWORD, + dwGroupMask: DWORD, + snNameBuffer: SCOPE_NAME_BUFFER, + dwStatus: DWORD, +}} +pub type PMIB_IPMCAST_SCOPE = *mut MIB_IPMCAST_SCOPE; +STRUCT!{struct MIB_IPDESTROW { + ForwardRow: MIB_IPFORWARDROW, + dwForwardPreference: DWORD, + dwForwardViewSet: DWORD, +}} +pub type PMIB_IPDESTROW = *mut MIB_IPDESTROW; +STRUCT!{struct MIB_IPDESTTABLE { + dwNumEntries: DWORD, + table: [MIB_IPDESTROW; ANY_SIZE], +}} +pub type PMIB_IPDESTTABLE = *mut MIB_IPDESTTABLE; +STRUCT!{struct MIB_BEST_IF { + dwDestAddr: DWORD, + dwIfIndex: DWORD, +}} +pub type PMIB_BEST_IF = *mut MIB_BEST_IF; +STRUCT!{struct MIB_PROXYARP { + dwAddress: DWORD, + dwMask: DWORD, + dwIfIndex: DWORD, +}} +pub type PMIB_PROXYARP = *mut MIB_PROXYARP; +STRUCT!{struct MIB_IFSTATUS { + dwIfIndex: DWORD, + dwAdminStatus: DWORD, + dwOperationalStatus: DWORD, + bMHbeatActive: BOOL, + bMHbeatAlive: BOOL, +}} +pub type PMIB_IFSTATUS = *mut MIB_IFSTATUS; +STRUCT!{struct MIB_ROUTESTATE { + bRoutesSetToStack: BOOL, +}} +pub type PMIB_ROUTESTATE = *mut MIB_ROUTESTATE; +UNION!{union MIB_OPAQUE_INFO_Value { + [u64; 1], + ullAlign ullAlign_mut: ULONGLONG, + rgbyData rgbyData_mut: [BYTE; 1], +}} +STRUCT!{struct MIB_OPAQUE_INFO { + dwId: DWORD, + Value: MIB_OPAQUE_INFO_Value, +}} +pub type PMIB_OPAQUE_INFO = *mut MIB_OPAQUE_INFO; diff --git a/src/shared/mod.rs b/src/shared/mod.rs index 6867fa05a..22ab9d7f0 100644 --- a/src/shared/mod.rs +++ b/src/shared/mod.rs @@ -38,18 +38,24 @@ pub mod guiddef; #[cfg(feature = "hidsdi")] pub mod hidsdi; #[cfg(feature = "hidusage")] pub mod hidusage; #[cfg(feature = "ifdef")] pub mod ifdef; +#[cfg(feature = "ifmib")] pub mod ifmib; #[cfg(feature = "in6addr")] pub mod in6addr; #[cfg(feature = "inaddr")] pub mod inaddr; #[cfg(feature = "intsafe")] pub mod intsafe; +#[cfg(feature = "ipifcons")] pub mod ipifcons; +#[cfg(feature = "ipmib")] pub mod ipmib; +#[cfg(feature = "iprtrmib")] pub mod iprtrmib; #[cfg(feature = "ks")] pub mod ks; #[cfg(feature = "ksmedia")] pub mod ksmedia; #[cfg(feature = "ktmtypes")] pub mod ktmtypes; #[cfg(feature = "lmcons")] pub mod lmcons; #[cfg(feature = "minwindef")] pub mod minwindef; #[cfg(feature = "mmreg")] pub mod mmreg; +#[cfg(feature = "mprapidef")] pub mod mprapidef; #[cfg(feature = "mstcpip")] pub mod mstcpip; #[cfg(feature = "mswsockdef")] pub mod mswsockdef; #[cfg(feature = "netioapi")] pub mod netioapi; +#[cfg(feature = "nldef")] pub mod nldef; #[cfg(feature = "ntddscsi")] pub mod ntddscsi; #[cfg(feature = "ntddser")] pub mod ntddser; #[cfg(feature = "ntdef")] pub mod ntdef; @@ -61,8 +67,11 @@ pub mod guiddef; #[cfg(feature = "sddl")] pub mod sddl; #[cfg(feature = "sspi")] pub mod sspi; #[cfg(feature = "stralign")] pub mod stralign; +#[cfg(feature = "tcpestats")] pub mod tcpestats; +#[cfg(feature = "tcpmib")] pub mod tcpmib; #[cfg(feature = "transportsettingcommon")] pub mod transportsettingcommon; #[cfg(feature = "tvout")] pub mod tvout; +#[cfg(feature = "udpmib")] pub mod udpmib; #[cfg(feature = "usb")] pub mod usb; #[cfg(feature = "usbiodef")] pub mod usbiodef; #[cfg(feature = "usbspec")] pub mod usbspec; diff --git a/src/shared/mprapidef.rs b/src/shared/mprapidef.rs new file mode 100644 index 000000000..db5c1696d --- /dev/null +++ b/src/shared/mprapidef.rs @@ -0,0 +1,14 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! MPR (Multiple Provider Router) definitions +// #include +pub const MAX_INTERFACE_NAME_LEN: usize = 256; +pub const MAX_TRANSPORT_NAME_LEN: usize = 40; +pub const MAX_MEDIA_NAME: usize = 16; +pub const MAX_PORT_NAME: usize = 16; +pub const MAX_DEVICE_NAME: usize = 128; +pub const MAX_PHONE_NUMBER_LEN: usize = 128; +pub const MAX_DEVICETYPE_NAME: usize = 16; diff --git a/src/shared/nldef.rs b/src/shared/nldef.rs new file mode 100644 index 000000000..bbde419a4 --- /dev/null +++ b/src/shared/nldef.rs @@ -0,0 +1,204 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +use shared::basetsd::ULONG64; +use shared::minwindef::ULONG; +use um::winnt::BOOLEAN; +ENUM!{enum NL_PREFIX_ORIGIN { + IpPrefixOriginOther, + IpPrefixOriginManual, + IpPrefixOriginWellKnown, + IpPrefixOriginDhcp, + IpPrefixOriginRouterAdvertisement, + IpPrefixOriginUnchanged = 1 << 4, +}} +pub const NlpoOther: NL_PREFIX_ORIGIN = IpPrefixOriginOther; +pub const NlpoManual: NL_PREFIX_ORIGIN = IpPrefixOriginManual; +pub const NlpoWellKnown: NL_PREFIX_ORIGIN = IpPrefixOriginWellKnown; +pub const NlpoDhcp: NL_PREFIX_ORIGIN = IpPrefixOriginDhcp; +pub const NlpoRouterAdvertisement: NL_PREFIX_ORIGIN = IpPrefixOriginRouterAdvertisement; +ENUM!{enum NL_SUFFIX_ORIGIN { + NlsoOther = 0, + NlsoManual, + NlsoWellKnown, + NlsoDhcp, + NlsoLinkLayerAddress, + NlsoRandom, + IpSuffixOriginOther = 0, + IpSuffixOriginManual, + IpSuffixOriginWellKnown, + IpSuffixOriginDhcp, + IpSuffixOriginLinkLayerAddress, + IpSuffixOriginRandom, + IpSuffixOriginUnchanged = 1 << 4, +}} +ENUM!{enum NL_DAD_STATE { + NldsInvalid, + NldsTentative, + NldsDuplicate, + NldsDeprecated, + NldsPreferred, + IpDadStateInvalid = 0, + IpDadStateTentative, + IpDadStateDuplicate, + IpDadStateDeprecated, + IpDadStatePreferred, +}} +pub const NL_MAX_METRIC_COMPONENT: ULONG = (1u32 << 31) - 1; +ENUM!{enum NL_ROUTE_PROTOCOL { + RouteProtocolOther = 1, + RouteProtocolLocal = 2, + RouteProtocolNetMgmt = 3, + RouteProtocolIcmp = 4, + RouteProtocolEgp = 5, + RouteProtocolGgp = 6, + RouteProtocolHello = 7, + RouteProtocolRip = 8, + RouteProtocolIsIs = 9, + RouteProtocolEsIs = 10, + RouteProtocolCisco = 11, + RouteProtocolBbn = 12, + RouteProtocolOspf = 13, + RouteProtocolBgp = 14, + RouteProtocolIdpr = 15, + RouteProtocolEigrp = 16, + RouteProtocolDvmrp = 17, + RouteProtocolRpl = 18, + RouteProtocolDhcp = 19, + MIB_IPPROTO_OTHER = 1, + PROTO_IP_OTHER = 1, + MIB_IPPROTO_LOCAL = 2, + PROTO_IP_LOCAL = 2, + MIB_IPPROTO_NETMGMT = 3, + PROTO_IP_NETMGMT = 3, + MIB_IPPROTO_ICMP = 4, + PROTO_IP_ICMP = 4, + MIB_IPPROTO_EGP = 5, + PROTO_IP_EGP = 5, + MIB_IPPROTO_GGP = 6, + PROTO_IP_GGP = 6, + MIB_IPPROTO_HELLO = 7, + PROTO_IP_HELLO = 7, + MIB_IPPROTO_RIP = 8, + PROTO_IP_RIP = 8, + MIB_IPPROTO_IS_IS = 9, + PROTO_IP_IS_IS = 9, + MIB_IPPROTO_ES_IS = 10, + PROTO_IP_ES_IS = 10, + MIB_IPPROTO_CISCO = 11, + PROTO_IP_CISCO = 11, + MIB_IPPROTO_BBN = 12, + PROTO_IP_BBN = 12, + MIB_IPPROTO_OSPF = 13, + PROTO_IP_OSPF = 13, + MIB_IPPROTO_BGP = 14, + PROTO_IP_BGP = 14, + MIB_IPPROTO_IDPR = 15, + PROTO_IP_IDPR = 15, + MIB_IPPROTO_EIGRP =16, + PROTO_IP_EIGRP = 16, + MIB_IPPROTO_DVMRP = 17, + PROTO_IP_DVMRP = 17, + MIB_IPPROTO_RPL = 18, + PROTO_IP_RPL = 18, + MIB_IPPROTO_DHCP = 19, + PROTO_IP_DHCP = 19, + MIB_IPPROTO_NT_AUTOSTATIC = 10002, + PROTO_IP_NT_AUTOSTATIC = 10002, + MIB_IPPROTO_NT_STATIC = 10006, + PROTO_IP_NT_STATIC = 10006, + MIB_IPPROTO_NT_STATIC_NON_DOD = 10007, + PROTO_IP_NT_STATIC_NON_DOD = 10007, +}} +pub type PNL_ROUTE_PROTOCOL = *mut NL_ROUTE_PROTOCOL; +ENUM!{enum NL_ADDRESS_TYPE { + NlatUnspecified, + NlatUnicast, + NlatAnycast, + NlatMulticast, + NlatBroadcast, + NlatInvalid, +}} +pub type PNL_ADDRESS_TYPE = *mut NL_ADDRESS_TYPE; +ENUM!{enum NL_ROUTE_ORIGIN { + NlroManual, + NlroWellKnown, + NlroDHCP, + NlroRouterAdvertisement, + Nlro6to4, +}} +pub type PNL_ROUTE_ORIGIN = *mut NL_ROUTE_ORIGIN; +ENUM!{enum NL_NEIGHBOR_STATE { + NlnsUnreachable, + NlnsIncomplete, + NlnsProbe, + NlnsDelay, + NlnsStale, + NlnsReachable, + NlnsPermanent, + NlnsMaximum, +}} +pub type PNL_NEIGHBOR_STATE = *mut NL_NEIGHBOR_STATE; +ENUM!{enum NL_LINK_LOCAL_ADDRESS_BEHAVIOR { + LinkLocalAlwaysOff = 0, + LinkLocalDelayed, + LinkLocalAlwaysOn, + LinkLocalUnchanged = 0xFFFFFFFF, +}} +STRUCT!{struct NL_INTERFACE_OFFLOAD_ROD { + Bitfield: BOOLEAN, +}} +BITFIELD!{NL_INTERFACE_OFFLOAD_ROD Bitfield: BOOLEAN [ + NlChecksumSupported set_NlChecksumSupported[0..1], + NlOptionsSupported set_NlOptionsSupported[1..2], + TlDatagramChecksumSupported set_TlDatagramChecksumSupported[2..3], + TlStreamChecksumSupported set_TlStreamChecksumSupported[3..4], + TlStreamOptionsSupported set_TlStreamOptionsSupported[4..5], + FastPathCompatible set_FastPathCompatible[5..6], + TlLargeSendOffloadSupported set_TlLargeSendOffloadSupported[6..7], + TlGiantSendOffloadSupported set_TlGiantSendOffloadSupported[7..8], +]} +pub type PNL_INTERFACE_OFFLOAD_ROD = *mut NL_INTERFACE_OFFLOAD_ROD; +ENUM!{enum NL_ROUTER_DISCOVERY_BEHAVIOR { + RouterDiscoveryDisabled = 0, + RouterDiscoveryEnabled, + RouterDiscoveryDhcp, + RouterDiscoveryUnchanged = 0xFFFFFFFF, +}} +ENUM!{enum NL_PATH_BANDWIDTH_FLAG { + NlbwDisabled = 0, + NlbwEnabled, + NlbwUnchanged = 0xFFFFFFFF, +}} +pub type PNL_PATH_BANDWIDTH_FLAG = *mut NL_PATH_BANDWIDTH_FLAG; +STRUCT!{struct NL_PATH_BANDWIDTH_ROD { + Bandwidth: ULONG64, + Instability: ULONG64, + BandwidthPeaked: BOOLEAN, +}} +pub type PNL_PATH_BANDWIDTH_ROD = *mut NL_PATH_BANDWIDTH_ROD; +ENUM!{enum NL_NETWORK_CATEGORY { + NetworkCategoryPublic, + NetworkCategoryPrivate, + NetworkCategoryDomainAuthenticated, + NetworkCategoryUnchanged = 0xFFFFFFFF, + NetworkCategoryUnknown = 0xFFFFFFFF, +}} +pub type PNL_NETWORK_CATEGORY = *mut NL_NETWORK_CATEGORY; +ENUM!{enum NL_INTERFACE_NETWORK_CATEGORY_STATE { + NlincCategoryUnknown = 0, + NlincPublic = 1, + NlincPrivate = 2, + NlincDomainAuthenticated = 3, + NlincCategoryStateMax, +}} +pub type PNL_INTERFACE_NETWORK_CATEGORY_STATE = *mut NL_INTERFACE_NETWORK_CATEGORY_STATE; +pub const NET_IF_CURRENT_SESSION : ULONG = 0xFFFFFFFF; +STRUCT!{struct NL_BANDWIDTH_INFORMATION { + Bandwidth: ULONG64, + Instability: ULONG64, + BandwidthPeaked: BOOLEAN, +}} +pub type PNL_BANDWIDTH_INFORMATION = *mut NL_BANDWIDTH_INFORMATION; diff --git a/src/shared/tcpestats.rs b/src/shared/tcpestats.rs new file mode 100644 index 000000000..6c3917a53 --- /dev/null +++ b/src/shared/tcpestats.rs @@ -0,0 +1,211 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +use shared::basetsd::{SIZE_T, ULONG64}; +use shared::ntdef::{BOOLEAN, UCHAR, ULONG}; +ENUM!{enum TCP_ESTATS_TYPE { + TcpConnectionEstatsSynOpts, + TcpConnectionEstatsData, + TcpConnectionEstatsSndCong, + TcpConnectionEstatsPath, + TcpConnectionEstatsSendBuff, + TcpConnectionEstatsRec, + TcpConnectionEstatsObsRec, + TcpConnectionEstatsBandwidth, + TcpConnectionEstatsFineRtt, + TcpConnectionEstatsMaximum, +}} +pub type PTCP_ESTATS_TYPE = *mut TCP_ESTATS_TYPE; +ENUM!{enum TCP_BOOLEAN_OPTIONAL { + TcpBoolOptDisabled = 0, + TcpBoolOptEnabled, + TcpBoolOptUnchanged = -1i32 as u32, +}} +pub type PTCP_BOOLEAN_OPTIONAL = *mut TCP_BOOLEAN_OPTIONAL; +STRUCT!{struct TCP_ESTATS_SYN_OPTS_ROS_v0 { + ActiveOpen: BOOLEAN, + MssRcvd: ULONG, + MssSent: ULONG, +}} +pub type PTCP_ESTATS_SYN_OPTS_ROS_v0 = *mut TCP_ESTATS_SYN_OPTS_ROS_v0; +ENUM!{enum TCP_SOFT_ERROR { + TcpErrorNone = 0, + TcpErrorBelowDataWindow, + TcpErrorAboveDataWindow, + TcpErrorBelowAckWindow, + TcpErrorAboveAckWindow, + TcpErrorBelowTsWindow, + TcpErrorAboveTsWindow, + TcpErrorDataChecksumError, + TcpErrorDataLengthError, + TcpErrorMaxSoftError, +}} +pub type PTCP_SOFT_ERROR = *mut TCP_SOFT_ERROR; +STRUCT!{struct TCP_ESTATS_DATA_ROD_v0 { + DataBytesOut: ULONG64, + DataSegsOut: ULONG64, + DataBytesIn: ULONG64, + DataSegsIn: ULONG64, + SegsOut: ULONG64, + SegsIn: ULONG64, + SoftErrors: ULONG, + SoftErrorReason: ULONG, + SndUna: ULONG, + SndNxt: ULONG, + SndMax: ULONG, + ThruBytesAcked: ULONG64, + RcvNxt: ULONG, + ThruBytesReceived: ULONG64, +}} +pub type PTCP_ESTATS_DATA_ROD_v0 = *mut TCP_ESTATS_DATA_ROD_v0; +STRUCT!{struct TCP_ESTATS_DATA_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_DATA_RW_v0 = TCP_ESTATS_DATA_RW_v0; +STRUCT!{struct TCP_ESTATS_SND_CONG_ROD_v0 { + SndLimTransRwin: ULONG, + SndLimTimeRwin: ULONG, + SndLimBytesRwin: SIZE_T, + SndLimTransCwnd: ULONG, + SndLimTimeCwnd: ULONG, + SndLimBytesCwnd: SIZE_T, + SndLimTransSnd: ULONG, + SndLimTimeSnd: ULONG, + SndLimBytesSnd: SIZE_T, + SlowStart: ULONG, + CongAvoid: ULONG, + OtherReductions: ULONG, + CurCwnd: ULONG, + MaxSsCwnd: ULONG, + MaxCaCwnd: ULONG, + CurSsthresh: ULONG, + MaxSsthresh: ULONG, + MinSsthresh: ULONG, +}} +pub type PTCP_ESTATS_SND_CONG_ROD_v0 = *mut TCP_ESTATS_SND_CONG_ROD_v0; +STRUCT!{struct TCP_ESTATS_SND_CONG_ROS_v0 { + LimCwnd: ULONG, +}} +pub type PTCP_ESTATS_SND_CONG_ROS_v0 = *mut TCP_ESTATS_SND_CONG_ROS_v0; +STRUCT!{struct TCP_ESTATS_SND_CONG_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_SND_CONG_RW_v0 = *mut TCP_ESTATS_SND_CONG_RW_v0; +STRUCT!{struct TCP_ESTATS_PATH_ROD_v0 { + FastRetran: ULONG, + Timeouts: ULONG, + SubsequentTimeouts: ULONG, + CurTimeoutCount: ULONG, + AbruptTimeouts: ULONG, + PktsRetrans: ULONG, + BytesRetrans: ULONG, + DupAcksIn: ULONG, + SacksRcvd: ULONG, + SackBlocksRcvd: ULONG, + CongSignals: ULONG, + PreCongSumCwnd: ULONG, + PreCongSumRtt: ULONG, + PostCongSumRtt: ULONG, + PostCongCountRtt: ULONG, + EcnSignals: ULONG, + EceRcvd: ULONG, + SendStall: ULONG, + QuenchRcvd: ULONG, + RetranThresh: ULONG, + SndDupAckEpisodes: ULONG, + SumBytesReordered: ULONG, + NonRecovDa: ULONG, + NonRecovDaEpisodes: ULONG, + AckAfterFr: ULONG, + DsackDups: ULONG, + SampleRtt: ULONG, + SmoothedRtt: ULONG, + RttVar: ULONG, + MaxRtt: ULONG, + MinRtt: ULONG, + SumRtt: ULONG, + CountRtt: ULONG, + CurRto: ULONG, + MaxRto: ULONG, + MinRto: ULONG, + CurMss: ULONG, + MaxMss: ULONG, + MinMss: ULONG, + SpuriousRtoDetections: ULONG, +}} +pub type PTCP_ESTATS_PATH_ROD_v0 = *mut TCP_ESTATS_PATH_ROD_v0; +STRUCT!{struct TCP_ESTATS_PATH_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_PATH_RW_v0 = *mut TCP_ESTATS_PATH_RW_v0; +STRUCT!{struct TCP_ESTATS_SEND_BUFF_ROD_v0 { + CurRetxQueue: SIZE_T, + MaxRetxQueue: SIZE_T, + CurAppWQueue: SIZE_T, + MaxAppWQueue: SIZE_T, +}} +pub type PTCP_ESTATS_SEND_BUFF_ROD_v0 = *mut TCP_ESTATS_SEND_BUFF_ROD_v0; +STRUCT!{struct TCP_ESTATS_SEND_BUFF_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_SEND_BUFF_RW_v0 = *mut TCP_ESTATS_SEND_BUFF_RW_v0; +STRUCT!{struct TCP_ESTATS_REC_ROD_v0 { + CurRwinSent: ULONG, + MaxRwinSent: ULONG, + MinRwinSent: ULONG, + LimRwin: ULONG, + DupAckEpisodes: ULONG, + DupAcksOut: ULONG, + CeRcvd: ULONG, + EcnSent: ULONG, + EcnNoncesRcvd: ULONG, + CurReasmQueue: ULONG, + MaxReasmQueue: ULONG, + CurAppRQueue: SIZE_T, + MaxAppRQueue: SIZE_T, + WinScaleSent: UCHAR, +}} +pub type PTCP_ESTATS_REC_ROD_v0 = *mut TCP_ESTATS_REC_ROD_v0; +STRUCT!{struct TCP_ESTATS_REC_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_REC_RW_v0 = *mut TCP_ESTATS_REC_RW_v0; +STRUCT!{struct TCP_ESTATS_OBS_REC_ROD_v0 { + CurRwinRcvd: ULONG, + MaxRwinRcvd: ULONG, + MinRwinRcvd: ULONG, + WinScaleRcvd: UCHAR, +}} +pub type PTCP_ESTATS_OBS_REC_ROD_v0 = *mut TCP_ESTATS_OBS_REC_ROD_v0; +STRUCT!{struct TCP_ESTATS_OBS_REC_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_OBS_REC_RW_v0 = *mut TCP_ESTATS_OBS_REC_RW_v0; +STRUCT!{struct TCP_ESTATS_BANDWIDTH_RW_v0 { + EnableCollectionOutbound: TCP_BOOLEAN_OPTIONAL, + EnableCollectionInbound: TCP_BOOLEAN_OPTIONAL, +}} +pub type PTCP_ESTATS_BANDWIDTH_RW_v0 = *mut TCP_ESTATS_BANDWIDTH_RW_v0; +STRUCT!{struct TCP_ESTATS_BANDWIDTH_ROD_v0 { + OutboundBandwidth: ULONG64, + InboundBandwidth: ULONG64, + OutboundInstability: ULONG64, + InboundInstability: ULONG64, + OutboundBandwidthPeaked: BOOLEAN, + InboundBandwidthPeaked: BOOLEAN, +}} +pub type PTCP_ESTATS_BANDWIDTH_ROD_v0 = *mut TCP_ESTATS_BANDWIDTH_ROD_v0; +STRUCT!{struct TCP_ESTATS_FINE_RTT_RW_v0 { + EnableCollection: BOOLEAN, +}} +pub type PTCP_ESTATS_FINE_RTT_RW_v0 = *mut TCP_ESTATS_FINE_RTT_RW_v0; +STRUCT!{struct TCP_ESTATS_FINE_RTT_ROD_v0 { + RttVar: ULONG, + MaxRtt: ULONG, + MinRtt: ULONG, + SumRtt: ULONG, +}} +pub type PTCP_ESTATS_FINE_RTT_ROD_v0 = *mut TCP_ESTATS_FINE_RTT_ROD_v0; diff --git a/src/shared/tcpmib.rs b/src/shared/tcpmib.rs new file mode 100644 index 000000000..f6ad65c79 --- /dev/null +++ b/src/shared/tcpmib.rs @@ -0,0 +1,243 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +use shared::basetsd::DWORD64; +use shared::in6addr::IN6_ADDR; +use shared::minwindef::DWORD; +use shared::ntdef::{LARGE_INTEGER, UCHAR, ULONGLONG}; +pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; +const ANY_SIZE: usize = 1; +ENUM!{enum MIB_TCP_STATE { + MIB_TCP_STATE_CLOSED = 1, + MIB_TCP_STATE_LISTEN = 2, + MIB_TCP_STATE_SYN_SENT = 3, + MIB_TCP_STATE_SYN_RCVD = 4, + MIB_TCP_STATE_ESTAB = 5, + MIB_TCP_STATE_FIN_WAIT1 = 6, + MIB_TCP_STATE_FIN_WAIT2 = 7, + MIB_TCP_STATE_CLOSE_WAIT = 8, + MIB_TCP_STATE_CLOSING = 9, + MIB_TCP_STATE_LAST_ACK = 10, + MIB_TCP_STATE_TIME_WAIT = 11, + MIB_TCP_STATE_DELETE_TCB = 12, + MIB_TCP_STATE_RESERVED = 100, +}} +ENUM!{enum TCP_CONNECTION_OFFLOAD_STATE { + TcpConnectionOffloadStateInHost, + TcpConnectionOffloadStateOffloading, + TcpConnectionOffloadStateOffloaded, + TcpConnectionOffloadStateUploading, + TcpConnectionOffloadStateMax, +}} +pub type PTCP_CONNECTION_OFFLOAD_STATE = *mut TCP_CONNECTION_OFFLOAD_STATE; +STRUCT!{struct MIB_TCPROW_LH { + State: MIB_TCP_STATE, + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwRemoteAddr: DWORD, + dwRemotePort: DWORD, +}} +pub type PMIB_TCPROW_LH = *mut MIB_TCPROW_LH; +STRUCT!{struct MIB_TCPROW_W2K { + dwState: DWORD, + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwRemoteAddr: DWORD, + dwRemotePort: DWORD, +}} +pub type PMIB_TCPROW_W2K = *mut MIB_TCPROW_W2K; +// Windows Vista +// pub type MIB_TCPROW = MIB_TCPROW_LH; +pub type MIB_TCPROW = MIB_TCPROW_W2K; +pub type PMIB_TCPROW = *mut MIB_TCPROW; +STRUCT!{struct MIB_TCPTABLE { + dwNumEntries: DWORD, + table: [MIB_TCPROW; ANY_SIZE], +}} +pub type PMIB_TCPTABLE = *mut MIB_TCPTABLE; +STRUCT!{struct MIB_TCPROW2 { + dwState: DWORD, + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwRemoteAddr: DWORD, + dwRemotePort: DWORD, + dwOwningPid: DWORD, + dwOffloadState: TCP_CONNECTION_OFFLOAD_STATE, +}} +pub type PMIB_TCPROW2 = *mut MIB_TCPROW2; +STRUCT!{struct MIB_TCPTABLE2 { + dwNumEntries: DWORD, + table: [MIB_TCPROW2; ANY_SIZE], +}} +pub type PMIB_TCPTABLE2 = *mut MIB_TCPTABLE2; +STRUCT!{struct MIB_TCPROW_OWNER_PID { + dwState: DWORD, + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwRemoteAddr: DWORD, + dwRemotePort: DWORD, + dwOwningPid: DWORD, +}} +pub type PMIB_TCPROW_OWNER_PID = *mut MIB_TCPROW_OWNER_PID; +STRUCT!{struct MIB_TCPTABLE_OWNER_PID { + dwNumEntries: DWORD, + table: [MIB_TCPROW_OWNER_PID; ANY_SIZE], +}} +pub type PMIB_TCPTABLE_OWNER_PID = *mut MIB_TCPTABLE_OWNER_PID; +STRUCT!{struct MIB_TCPROW_OWNER_MODULE { + dwState: DWORD, + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwRemoteAddr: DWORD, + dwRemotePort: DWORD, + dwOwningPid: DWORD, + liCreateTimestamp: LARGE_INTEGER, + OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE], +}} +pub type PMIB_TCPROW_OWNER_MODULE = *mut MIB_TCPROW_OWNER_MODULE; +STRUCT!{struct MIB_TCPTABLE_OWNER_MODULE { + dwNumEntries: DWORD, + table: [MIB_TCPROW_OWNER_MODULE; ANY_SIZE], +}} +pub type PMIB_TCPTABLE_OWNER_MODULE = *mut MIB_TCPTABLE_OWNER_MODULE; +STRUCT!{struct MIB_TCP6ROW { + State: MIB_TCP_STATE, + LocalAddr: IN6_ADDR, + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + RemoteAddr: IN6_ADDR, + dwRemoteScopeId: DWORD, + dwRemotePort: DWORD, +}} +pub type PMIB_TCP6ROW = *mut MIB_TCP6ROW; +STRUCT!{struct MIB_TCP6TABLE { + dwNumEntries: DWORD, + table: [MIB_TCP6ROW; ANY_SIZE], +}} +pub type PMIB_TCP6TABLE = *mut MIB_TCP6TABLE; +STRUCT!{struct MIB_TCP6ROW2 { + LocalAddr: IN6_ADDR, + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + RemoteAddr: IN6_ADDR, + dwRemoteScopeId: DWORD, + dwRemotePort: DWORD, + State: MIB_TCP_STATE, + dwOwningPid: DWORD, + dwOffloadState: TCP_CONNECTION_OFFLOAD_STATE, +}} +pub type PMIB_TCP6ROW2 = *mut MIB_TCP6ROW2; +STRUCT!{struct MIB_TCP6TABLE2 { + dwNumEntries: DWORD, + table: [MIB_TCP6ROW2; ANY_SIZE], +}} +pub type PMIB_TCP6TABLE2 = *mut MIB_TCP6TABLE2; +STRUCT!{struct MIB_TCP6ROW_OWNER_PID { + ucLocalAddr: [UCHAR; 16], + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + ucRemoteAddr: [UCHAR; 16], + dwRemoteScopeId: DWORD, + dwRemotePort: DWORD, + dwState: DWORD, + dwOwningPid: DWORD, +}} +pub type PMIB_TCP6ROW_OWNER_PID = *mut MIB_TCP6ROW_OWNER_PID; +// STRUCT!{struct MIB_TCP6TABLE_OWNER_PID { +// dwNumEntries: DWORD, +// // _Field_size_(dwNumEntries) +// table: [MIB_TCP6ROW_OWNER_PID; ANY_SIZE], +// }} +// pub type PMIB_TCP6TABLE_OWNER_PID = *mut MIB_TCP6TABLE_OWNER_PID; +STRUCT!{struct MIB_TCP6ROW_OWNER_MODULE { + ucLocalAddr: [UCHAR; 16], + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + ucRemoteAddr: [UCHAR; 16], + dwRemoteScopeId: DWORD, + dwRemotePort: DWORD, + dwState: DWORD, + dwOwningPid: DWORD, + liCreateTimestamp: LARGE_INTEGER, + OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE], +}} +pub type PMIB_TCP6ROW_OWNER_MODULE = *mut MIB_TCP6ROW_OWNER_MODULE; +// STRUCT!{struct MIB_TCP6TABLE_OWNER_MODULE { +// dwNumEntries: DWORD, +// // _Field_size_(dwNumEntries) +// table: [MIB_TCP6ROW_OWNER_MODULE; ANY_SIZE], +// }} +// pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE; +ENUM!{enum TCP_RTO_ALGORITHM { + TcpRtoAlgorithmOther = 1, + TcpRtoAlgorithmConstant, + TcpRtoAlgorithmRsre, + TcpRtoAlgorithmVanj, + MIB_TCP_RTO_OTHER = 1, + MIB_TCP_RTO_CONSTANT = 2, + MIB_TCP_RTO_RSRE = 3, + MIB_TCP_RTO_VANJ = 4, +}} +pub type PTCP_RTO_ALGORITHM = *mut TCP_RTO_ALGORITHM; +STRUCT!{struct MIB_TCPSTATS_LH { + RtoAlgorithm: TCP_RTO_ALGORITHM, + dwRtoMin: DWORD, + dwRtoMax: DWORD, + dwMaxConn: DWORD, + dwActiveOpens: DWORD, + dwPassiveOpens: DWORD, + dwAttemptFails: DWORD, + dwEstabResets: DWORD, + dwCurrEstab: DWORD, + dwInSegs: DWORD, + dwOutSegs: DWORD, + dwRetransSegs: DWORD, + dwInErrs: DWORD, + dwOutRsts: DWORD, + dwNumConns: DWORD, +}} +pub type PMIB_TCPSTATS_LH = *mut MIB_TCPSTATS_LH; +STRUCT!{struct MIB_TCPSTATS_W2K { + dwRtoAlgorithm: DWORD, + dwRtoMin: DWORD, + dwRtoMax: DWORD, + dwMaxConn: DWORD, + dwActiveOpens: DWORD, + dwPassiveOpens: DWORD, + dwAttemptFails: DWORD, + dwEstabResets: DWORD, + dwCurrEstab: DWORD, + dwInSegs: DWORD, + dwOutSegs: DWORD, + dwRetransSegs: DWORD, + dwInErrs: DWORD, + dwOutRsts: DWORD, + dwNumConns: DWORD, +}} +pub type PMIB_TCPSTATS_W2K = *mut MIB_TCPSTATS_W2K; +// Windows Vista +// pub type MIB_TCPSTATS = MIB_TCPSTATS_LH; +pub type MIB_TCPSTATS = MIB_TCPSTATS_W2K; +pub type PMIB_TCPSTATS = *mut MIB_TCPSTATS; +// if NTDDI_VERSION >= NTDDI_WIN10_RS3 +STRUCT!{struct MIB_TCPSTATS2 { + RtoAlgorithm: TCP_RTO_ALGORITHM, + dwRtoMin: DWORD, + dwRtoMax: DWORD, + dwMaxConn: DWORD, + dwActiveOpens: DWORD, + dwPassiveOpens: DWORD, + dwAttemptFails: DWORD, + dwEstabResets: DWORD, + dwCurrEstab: DWORD, + dw64InSegs: DWORD64, + dw64OutSegs: DWORD64, + dwRetransSegs: DWORD, + dwInErrs: DWORD, + dwOutRsts: DWORD, + dwNumConns: DWORD, +}} +pub type PMIB_TCPSTATS2 = *mut MIB_TCPSTATS2; diff --git a/src/shared/udpmib.rs b/src/shared/udpmib.rs new file mode 100644 index 000000000..584ed92dd --- /dev/null +++ b/src/shared/udpmib.rs @@ -0,0 +1,131 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! Contains the public definitions and structures for the UDP-specific parts of MIB-II +// #include +use shared::basetsd::DWORD64; +use shared::in6addr::IN6_ADDR; +use shared::minwindef::DWORD; +use shared::ntdef::{INT, LARGE_INTEGER, UCHAR, ULONGLONG}; +const ANY_SIZE: usize = 1; +pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; +STRUCT!{struct MIB_UDPROW { + dwLocalAddr: DWORD, + dwLocalPort: DWORD, +}} +pub type PMIB_UDPROW = *mut MIB_UDPROW; +STRUCT!{struct MIB_UDPTABLE { + dwNumEntries: DWORD, + table: [MIB_UDPROW; ANY_SIZE], +}} +pub type PMIB_UDPTABLE = *mut MIB_UDPTABLE; +// FIXME: Need to figure out how to define SIZEOF_UDPTABLE(X) +STRUCT!{struct MIB_UDPROW_OWNER_PID { + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwOwningPid: DWORD, +}} +pub type PMIB_UDPROW_OWNER_PID = *mut MIB_UDPROW_OWNER_PID; +STRUCT!{struct MIB_UDPTABLE_OWNER_PID { + dwNumEntries: DWORD, + table: [MIB_UDPROW_OWNER_PID; ANY_SIZE], +}} +pub type PMIB_UDPTABLE_OWNER_PID = *mut MIB_UDPTABLE_OWNER_PID; +// FIXME: Need to figure out how to define SIZEOF_UDPTABLE_OWNER_PID(X) +STRUCT!{struct MIB_UDPROW_OWNER_MODULE_u_s { + bitfield: INT, +}} +BITFIELD!{MIB_UDPROW_OWNER_MODULE_u_s bitfield: INT [ + SpecificPortBind set_SpecificPortBind[0..1], +]} +UNION!{union MIB_UDPROW_OWNER_MODULE_u { + [i32; 1], + s s_mut: MIB_UDPROW_OWNER_MODULE_u_s, + dwFlags dwFlags_mut: INT, +}} +STRUCT!{struct MIB_UDPROW_OWNER_MODULE { + dwLocalAddr: DWORD, + dwLocalPort: DWORD, + dwOwningPid: DWORD, + liCreateTimestamp: LARGE_INTEGER, + u: MIB_UDPROW_OWNER_MODULE_u, + OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE], +}} +pub type PMIB_UDPROW_OWNER_MODULE = *mut MIB_UDPROW_OWNER_MODULE; +STRUCT!{struct MIB_UDPTABLE_OWNER_MODULE { + dwNumEntries: DWORD, + table: [MIB_UDPROW_OWNER_MODULE; ANY_SIZE], +}} +pub type PMIB_UDPTABLE_OWNER_MODULE = *mut MIB_UDPTABLE_OWNER_MODULE; +// FIXME: Need to figure out how to define SIZEOF_UDPTABLE_OWNER_MODULE(X) +STRUCT!{struct MIB_UDP6ROW { + dwLocalAddr: IN6_ADDR, + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, +}} +pub type PMIB_UDP6ROW = *mut MIB_UDP6ROW; +STRUCT!{struct MIB_UDP6TABLE { + dwNumEntries: DWORD, + table: [MIB_UDP6ROW; ANY_SIZE], +}} +pub type PMIB_UDP6TABLE = *mut MIB_UDP6TABLE; +// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE(X) +STRUCT!{struct MIB_UDP6ROW_OWNER_PID { + ucLocalAddr: [UCHAR; 16], + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + dwOwningPid: DWORD, +}} +pub type PMIB_UDP6ROW_OWNER_PID = *mut MIB_UDP6ROW_OWNER_PID; +STRUCT!{struct MIB_UDP6TABLE_OWNER_PID { + dwNumEntries: DWORD, + // _Field_size_(dwNumEntries) // FIXME: Unsure what this is/means + table: [MIB_UDP6ROW_OWNER_PID; ANY_SIZE], +}} +pub type PMIB_UDP6TABLE_OWNER_PID = *mut MIB_UDP6TABLE_OWNER_PID; +// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE_OWNER_PID(X) +STRUCT!{struct MIB_UDP6ROW_OWNER_MODULE_u_s { + bitfield: INT, +}} +BITFIELD!{MIB_UDP6ROW_OWNER_MODULE_u_s bitfield: INT [ + SpecificPortBind set_SpecificPortBind[0..1], +]} +UNION!{union MIB_UDP6ROW_OWNER_MODULE_u { + [i32; 1], + s s_mut: INT, + dwFlags dwFlags_mut: INT, +}} +STRUCT!{struct MIB_UDP6ROW_OWNER_MODULE { + ucLocalAddr: [UCHAR; 16], + dwLocalScopeId: DWORD, + dwLocalPort: DWORD, + dwOwningPid: DWORD, + liCreateTimestamp: LARGE_INTEGER, + u: MIB_UDP6ROW_OWNER_MODULE_u, + OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE], +}} +pub type PMIB_UDP6ROW_OWNER_MODULE = *mut MIB_UDP6ROW_OWNER_MODULE; +STRUCT!{struct MIB_UDP6TABLE_OWNER_MODULE { + dwNumEntries: DWORD, + table: [MIB_UDP6ROW_OWNER_MODULE; ANY_SIZE], +}} +pub type PMIB_UDP6TABLE_OWNER_MODULE = *mut MIB_UDP6TABLE_OWNER_MODULE; +// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE_OWNER_MODULE(X) +STRUCT!{struct MIB_UDPSTATS { + dwInDatagrams: DWORD, + dwNoPorts: DWORD, + dwInErrors: DWORD, + dwOutDatagrams: DWORD, + dwNumAddrs: DWORD, +}} +pub type PMIB_UDPSTATS = *mut MIB_UDPSTATS; +STRUCT!{struct MIB_UDPSTATS2 { + dw64InDatagrams: DWORD64, + dwNoPorts: DWORD, + dwInErrors: DWORD, + dw64OutDatagrams: DWORD64, + dwNumAddrs: DWORD, +}} +pub type PMIB_UDPSTATS2 = *mut MIB_UDPSTATS2; diff --git a/src/shared/ws2ipdef.rs b/src/shared/ws2ipdef.rs index b48518ecc..fe6a3f2c5 100644 --- a/src/shared/ws2ipdef.rs +++ b/src/shared/ws2ipdef.rs @@ -36,13 +36,14 @@ UNION!{union SOCKADDR_IN6_LH_u { sin6_scope_id sin6_scope_id_mut: ULONG, sin6_scope_struct sin6_scope_struct_mut: SCOPE_ID, }} -STRUCT!{struct SOCKADDR_IN6_LH { +STRUCT!{struct SOCKADDR_IN6 { sin6_family: ADDRESS_FAMILY, sin6_port: USHORT, sin6_flowinfo: ULONG, sin6_addr: IN6_ADDR, u: SOCKADDR_IN6_LH_u, }} +pub type SOCKADDR_IN6_LH = SOCKADDR_IN6; pub type PSOCKADDR_IN6_LH = *mut SOCKADDR_IN6_LH; STRUCT!{struct IP_MREQ { imr_multiaddr: IN_ADDR, diff --git a/src/ucrt/corecrt.rs b/src/ucrt/corecrt.rs new file mode 100644 index 000000000..4fdf89736 --- /dev/null +++ b/src/ucrt/corecrt.rs @@ -0,0 +1,11 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +use ctypes::{__int64, c_long}; +pub type __time32_t = c_long; +pub type __time64_t = __int64; +pub type time_t = __time64_t; diff --git a/src/ucrt/mod.rs b/src/ucrt/mod.rs new file mode 100644 index 000000000..d24d55372 --- /dev/null +++ b/src/ucrt/mod.rs @@ -0,0 +1,7 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// Headers for the universal C Runtime +#[cfg(feature = "corecrt")] pub mod corecrt; diff --git a/src/um/ipexport.rs b/src/um/ipexport.rs new file mode 100644 index 000000000..292e13513 --- /dev/null +++ b/src/um/ipexport.rs @@ -0,0 +1,178 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +// #include +use shared::basetsd::ULONG64; +use shared::in6addr::in6_addr; +use shared::ntdef::{INT, UCHAR, ULONG, USHORT, WCHAR}; +pub const MAX_ADAPTER_NAME: usize = 128; +pub const MAX_OPT_SIZE: usize = 40; +pub type IPAddr = ULONG; +pub type IPMask = ULONG; +pub type IP_STATUS = ULONG; +pub type IPv6Addr = in6_addr; +// STRUCT!{struct IP_OPTION_INFORMATION { +// Ttl: UCHAR, +// Tos: UCHAR, +// Flags: UCHAR, +// OptionsSize: UCHAR, +// // _Field_size_bytes_(OptionsSize) +// OptionsData: PUCHAR, +// }} +// pub type PIP_OPTION_INFORMATION = *mut IP_OPTION_INFORMATION; +// #if defined(_WIN64) +// STRUCT!{struct IP_OPTION_INFORMATION32 { +// Ttl: UCHAR, +// Tos: UCHAR, +// Flags: UCHAR, +// OptionsSize: UCHAR, +// // UCHAR * POINTER_32 OptionsData, +// }} +// pub type PIP_OPTION_INFORMATION32 = *mut IP_OPTION_INFORMATION32; +// #endif // _WIN64 +// STRUCT!{struct ICMP_ECHO_REPLY { +// Address: IPAddr, +// Status: ULONG, +// RoundTripTime: ULONG, +// DataSize: USHORT, +// Reserved: USHORT, +// // _Field_size_bytes_(DataSize) +// Data: PVOID, +// Options: ip_option_information, +// }} +// pub type PICMP_ECHO_REPLY = *mut ICMP_ECHO_REPLY; +// #if defined(_WIN64) +// STRUCT!{struct ICMP_ECHO_REPLY32 { +// Address: IPAddr, +// Status: ULONG, +// RoundTripTime: ULONG, +// DataSize: USHORT, +// Reserved: USHORT, +// // VOID * POINTER_32 Data; +// Options: ip_option_information32, +// }} +// pub type PICMP_ECHO_REPLY32 = *mut ICMP_ECHO_REPLY32; +// #endif // _WIN64 +// #if (NTDDI_VERSION >= NTDDI_WINXP) +// #include +STRUCT!{struct IPV6_ADDRESS_EX { + sin6_port: USHORT, + sin6_flowinfo: ULONG, + sin6_addr: [USHORT; 8], + sin6_scope_id: ULONG, +}} +pub type PIPV6_ADDRESS_EX = *mut IPV6_ADDRESS_EX; +// #include +STRUCT!{struct ICMPV6_ECHO_REPLY_LH { + Address: IPV6_ADDRESS_EX, + Status: ULONG, + RoundTripTime: INT, +}} +pub type PICMPV6_ECHO_REPLY_LH = *mut ICMPV6_ECHO_REPLY_LH; +pub type ICMPV6_ECHO_REPLY = ICMPV6_ECHO_REPLY_LH; +pub type PICMPV6_ECHO_REPLY = *mut ICMPV6_ECHO_REPLY; +// #endif +STRUCT!{struct ARP_SEND_REPLY { + DestAddress: IPAddr, + SrcAddress: IPAddr, +}} +pub type PARP_SEND_REPLY = *mut ARP_SEND_REPLY; +STRUCT!{struct TCP_RESERVE_PORT_RANGE { + UpperRange: USHORT, + LowerRange: USHORT, +}} +pub type PTCP_RESERVE_PORT_RANGE = *mut TCP_RESERVE_PORT_RANGE; +STRUCT!{struct IP_ADAPTER_INDEX_MAP { + Index: ULONG, + Name: [WCHAR; MAX_ADAPTER_NAME], +}} +pub type PIP_ADAPTER_INDEX_MAP = *mut IP_ADAPTER_INDEX_MAP; +STRUCT!{struct IP_INTERFACE_INFO { + NumAdapters: ULONG, + Adapter: [IP_ADAPTER_INDEX_MAP; 1], +}} +pub type PIP_INTERFACE_INFO = *mut IP_INTERFACE_INFO; +STRUCT!{struct IP_UNIDIRECTIONAL_ADAPTER_ADDRESS { + NumAdapters: ULONG, + Address: [IPAddr; 1], +}} +pub type PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS = *mut IP_UNIDIRECTIONAL_ADAPTER_ADDRESS; +STRUCT!{struct IP_ADAPTER_ORDER_MAP { + NumAdapters: ULONG, + AdapterOrder: [ULONG; 1], +}} +pub type PIP_ADAPTER_ORDER_MAP = *mut IP_ADAPTER_ORDER_MAP; +STRUCT!{struct IP_MCAST_COUNTER_INFO { + InMcastOctets: ULONG64, + OutMcastOctets: ULONG64, + InMcastPkts: ULONG64, + OutMcastPkts: ULONG64, +}} +pub type PIP_MCAST_COUNTER_INFO = *mut IP_MCAST_COUNTER_INFO; +// IP_STATUS codes returned from IP APIs +pub const IP_STATUS_BASE: IP_STATUS = 11000; +pub const IP_SUCCESS: IP_STATUS = 0; +pub const IP_BUF_TOO_SMALL: IP_STATUS = IP_STATUS_BASE + 1; +pub const IP_DEST_NET_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 2; +pub const IP_DEST_HOST_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 3; +pub const IP_DEST_PROT_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 4; +pub const IP_DEST_PORT_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 5; +pub const IP_NO_RESOURCES: IP_STATUS = IP_STATUS_BASE + 6; +pub const IP_BAD_OPTION: IP_STATUS = IP_STATUS_BASE + 7; +pub const IP_HW_ERROR: IP_STATUS = IP_STATUS_BASE + 8; +pub const IP_PACKET_TOO_BIG: IP_STATUS = IP_STATUS_BASE + 9; +pub const IP_REQ_TIMED_OUT: IP_STATUS = IP_STATUS_BASE + 10; +pub const IP_BAD_REQ: IP_STATUS = IP_STATUS_BASE + 11; +pub const IP_BAD_ROUTE: IP_STATUS = IP_STATUS_BASE + 12; +pub const IP_TTL_EXPIRED_TRANSIT: IP_STATUS = IP_STATUS_BASE + 13; +pub const IP_TTL_EXPIRED_REASSEM: IP_STATUS = IP_STATUS_BASE + 14; +pub const IP_PARAM_PROBLEM: IP_STATUS = IP_STATUS_BASE + 15; +pub const IP_SOURCE_QUENCH: IP_STATUS = IP_STATUS_BASE + 16; +pub const IP_OPTION_TOO_BIG: IP_STATUS = IP_STATUS_BASE + 17; +pub const IP_BAD_DESTINATION: IP_STATUS = IP_STATUS_BASE + 18; +pub const IP_DEST_NO_ROUTE: IP_STATUS = IP_STATUS_BASE + 2; +pub const IP_DEST_ADDR_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 3; +pub const IP_DEST_PROHIBITED: IP_STATUS = IP_STATUS_BASE + 4; +pub const IP_HOP_LIMIT_EXCEEDED: IP_STATUS = IP_STATUS_BASE + 13; +pub const IP_REASSEMBLY_TIME_EXCEEDED: IP_STATUS = IP_STATUS_BASE + 14; +pub const IP_PARAMETER_PROBLEM: IP_STATUS = IP_STATUS_BASE + 15; +pub const IP_DEST_UNREACHABLE: IP_STATUS = IP_STATUS_BASE + 40; +pub const IP_TIME_EXCEEDED: IP_STATUS = IP_STATUS_BASE + 41; +pub const IP_BAD_HEADER: IP_STATUS = IP_STATUS_BASE + 42; +pub const IP_UNRECOGNIZED_NEXT_HEADER: IP_STATUS = IP_STATUS_BASE + 43; +pub const IP_ICMP_ERROR: IP_STATUS = IP_STATUS_BASE + 44; +pub const IP_DEST_SCOPE_MISMATCH: IP_STATUS = IP_STATUS_BASE + 45; +pub const IP_ADDR_DELETED: IP_STATUS = IP_STATUS_BASE + 19; +pub const IP_SPEC_MTU_CHANGE: IP_STATUS = IP_STATUS_BASE + 20; +pub const IP_MTU_CHANGE: IP_STATUS = IP_STATUS_BASE + 21; +pub const IP_UNLOAD: IP_STATUS = IP_STATUS_BASE + 22; +pub const IP_ADDR_ADDED: IP_STATUS = IP_STATUS_BASE + 23; +pub const IP_MEDIA_CONNECT: IP_STATUS = IP_STATUS_BASE + 24; +pub const IP_MEDIA_DISCONNECT: IP_STATUS = IP_STATUS_BASE + 25; +pub const IP_BIND_ADAPTER: IP_STATUS = IP_STATUS_BASE + 26; +pub const IP_UNBIND_ADAPTER: IP_STATUS = IP_STATUS_BASE + 27; +pub const IP_DEVICE_DOES_NOT_EXIST: IP_STATUS = IP_STATUS_BASE + 28; +pub const IP_DUPLICATE_ADDRESS: IP_STATUS = IP_STATUS_BASE + 29; +pub const IP_INTERFACE_METRIC_CHANGE: IP_STATUS = IP_STATUS_BASE + 30; +pub const IP_RECONFIG_SECFLTR: IP_STATUS = IP_STATUS_BASE + 31; +pub const IP_NEGOTIATING_IPSEC: IP_STATUS = IP_STATUS_BASE + 32; +pub const IP_INTERFACE_WOL_CAPABILITY_CHANGE: IP_STATUS = IP_STATUS_BASE + 33; +pub const IP_DUPLICATE_IPADD: IP_STATUS = IP_STATUS_BASE + 34; +pub const IP_GENERAL_FAILURE: IP_STATUS = IP_STATUS_BASE + 50; +pub const MAX_IP_STATUS: IP_STATUS = IP_GENERAL_FAILURE; +pub const IP_PENDING: IP_STATUS = IP_STATUS_BASE + 255; +pub const IP_FLAG_REVERSE: UCHAR = 0x1; +pub const IP_FLAG_DF: UCHAR = 0x2; +pub const IP_OPT_EOL: u8 = 0; +pub const IP_OPT_NOP: u8 = 1; +pub const IP_OPT_SECURITY: u8 = 0x82; +pub const IP_OPT_LSRR: u8 = 0x83; +pub const IP_OPT_SSRR: u8 = 0x89; +pub const IP_OPT_RR: u8 = 0x7; +pub const IP_OPT_TS: u8 = 0x44; +pub const IP_OPT_SID: u8 = 0x88; +pub const IP_OPT_ROUTER_ALERT: u8 = 0x94; diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs new file mode 100644 index 000000000..f289140f5 --- /dev/null +++ b/src/um/iphlpapi.rs @@ -0,0 +1,397 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +// #include +// #include +use shared::basetsd::PULONG64; +use shared::ifmib::{PMIB_IFROW, PMIB_IFTABLE}; +use shared::ipmib::{ + PMIB_ICMP, PMIB_ICMP_EX, PMIB_IPADDRTABLE, PMIB_IPFORWARDROW, PMIB_IPFORWARDTABLE, + PMIB_IPNETROW, PMIB_IPNETTABLE, PMIB_IPSTATS +}; +use shared::iprtrmib::{TCPIP_OWNER_MODULE_INFO_CLASS, TCP_TABLE_CLASS, UDP_TABLE_CLASS}; +use shared::minwindef::{BOOL, BYTE, DWORD, LPDWORD, PDWORD, PULONG, UINT}; +use shared::ntdef::{HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, USHORT, WCHAR}; +use shared::tcpmib::{ + PMIB_TCP6ROW_OWNER_MODULE, PMIB_TCP6TABLE, PMIB_TCP6TABLE2, PMIB_TCPROW, + PMIB_TCPROW_OWNER_MODULE, PMIB_TCPSTATS, PMIB_TCPSTATS2, PMIB_TCPTABLE, PMIB_TCPTABLE2 +}; +use shared::udpmib::{ + PMIB_UDP6ROW_OWNER_MODULE, PMIB_UDP6TABLE, PMIB_UDPROW_OWNER_MODULE, PMIB_UDPSTATS, + PMIB_UDPSTATS2, PMIB_UDPTABLE +}; +use shared::ws2def::{PSOCKADDR, SOCKADDR, SOCKADDR_IN}; +use shared::ws2ipdef::SOCKADDR_IN6; +use um::ipexport::{ + IPAddr, IPMask, IP_STATUS, PIP_ADAPTER_INDEX_MAP, PIP_INTERFACE_INFO, + PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS +}; +use um::iptypes::{PFIXED_INFO, PIP_ADAPTER_ADDRESSES, PIP_ADAPTER_INFO, PIP_PER_ADAPTER_INFO}; +use um::minwinbase::{LPOVERLAPPED,OVERLAPPED}; +ENUM!{enum NET_ADDRESS_FORMAT { + NET_ADDRESS_FORMAT_UNSPECIFIED = 0, + NET_ADDRESS_DNS_NAME, + NET_ADDRESS_IPV4, + NET_ADDRESS_IPV6, +}} +pub const DNS_MAX_NAME_BUFFER_LENGTH: usize = 256; +STRUCT!{struct NET_NAMED_ADDRESS { + Address: [WCHAR; DNS_MAX_NAME_BUFFER_LENGTH], + Port: [WCHAR; 6], +}} +UNION!{union NET_ADDRESS { + [u8; 256], + NamedAddress NamedAddress_mut: NET_NAMED_ADDRESS, // [u16; 6] + [u16; ] + Ipv4Address Ipv4Address_mut: SOCKADDR_IN, // [u8; 4] + Ipv6Address Ipv6Address_mut: SOCKADDR_IN6, // [u8; 16] + IpAddress IpAddress_mut: SOCKADDR, // [u8; 16] +}} +STRUCT!{struct NET_ADDRESS_INFO { + Format: NET_ADDRESS_FORMAT, + Address: NET_ADDRESS, +}} +pub type PNET_ADDRESS_INFO = *mut NET_ADDRESS_INFO; +extern "system" { + pub fn GetNumberOfInterfaces( + pdwNumIf: PDWORD + ) -> DWORD; + pub fn GetIfEntry( + pIfRow: PMIB_IFROW, + ) -> DWORD; + pub fn GetIfTable( + pIfTable: PMIB_IFTABLE, + pdwSize: PULONG, + bOrder: BOOL, + ) -> DWORD; + pub fn GetIpAddrTable( + pIpAddrTable: PMIB_IPADDRTABLE, + pdwSize: PULONG, + bOrder: BOOL, + ) -> DWORD; + pub fn GetIpNetTable( + IpNetTable: PMIB_IPNETTABLE, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + pub fn GetIpForwardTable( + pIpForwardTable: PMIB_IPFORWARDTABLE, + pdwSize: PULONG, + bOrder: BOOL, + ) -> DWORD; + pub fn GetTcpTable( + TcpTable: PMIB_TCPTABLE, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365928(v=vs.85).aspx + pub fn GetExtendedTcpTable( + pTcpTable: PVOID, + pdwSize: PDWORD, + bOrder: BOOL, + ulAf: ULONG, + TableClass: TCP_TABLE_CLASS, + Reserved: ULONG, + ) -> DWORD; + pub fn GetOwnerModuleFromTcpEntry( + pTcpEntry: PMIB_TCPROW_OWNER_MODULE, + Class: TCPIP_OWNER_MODULE_INFO_CLASS, + pBuffer: PVOID, + pdwSize: PDWORD, + ) -> DWORD; + pub fn GetUdpTable( + UdpTable: PMIB_UDPTABLE, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + pub fn GetExtendedUdpTable( + pUdpTable: PVOID, + pdwSize: PDWORD, + bOrder: BOOL, + ulAf: ULONG, + TableClass: UDP_TABLE_CLASS, + Reserved: ULONG, + ) -> DWORD; + pub fn GetOwnerModuleFromUdpEntry( + pUdpEntry: PMIB_UDPROW_OWNER_MODULE, + Class: TCPIP_OWNER_MODULE_INFO_CLASS, + pBuffer: PVOID, + pdwSize: PDWORD, + ) -> DWORD; + pub fn GetTcpTable2( + TcpTable: PMIB_TCPTABLE2, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + // pub fn AllocateAndGetTcpExTableFromStack() -> DWORD; + // pub fn AllocateAndGetUdpExTableFromStack() -> DWORD; + pub fn GetTcp6Table( + TcpTable: PMIB_TCP6TABLE, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + pub fn GetTcp6Table2( + TcpTable: PMIB_TCP6TABLE2, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + // pub fn GetPerTcpConnectionEStats() -> ULONG; + // pub fn GetPerTcp6ConnectionEStats() -> ULONG; + // pub fn SetPerTcp6ConnectionEStats() -> ULONG; + pub fn GetOwnerModuleFromTcp6Entry( + pTcpEntry: PMIB_TCP6ROW_OWNER_MODULE, + Class: TCPIP_OWNER_MODULE_INFO_CLASS, + pBuffer: PVOID, + pdwSize: PDWORD, + ) -> DWORD; + pub fn GetUdp6Table( + Udp6Table: PMIB_UDP6TABLE, + SizePointer: PULONG, + Order: BOOL, + ) -> ULONG; + pub fn GetOwnerModuleFromUdp6Entry( + pUdpEntry: PMIB_UDP6ROW_OWNER_MODULE, + Class: TCPIP_OWNER_MODULE_INFO_CLASS, + pBuffer: PVOID, + pdwSize: PDWORD, + ) -> DWORD; + // pub fn GetOwnerModuleFromPidAndInfo() -> DWORD; + pub fn GetIpStatistics( + Statistics: PMIB_IPSTATS, + ) -> ULONG; + pub fn GetIcmpStatistics( + Statistics: PMIB_ICMP, + ) -> ULONG; + pub fn GetTcpStatistics( + Statistics: PMIB_TCPSTATS, + ) -> ULONG; + pub fn GetUdpStatistics( + Stats: PMIB_UDPSTATS, + ) -> ULONG; + pub fn SetIpStatisticsEx( + Statistics: PMIB_IPSTATS, + Family: ULONG, + ) -> ULONG; + pub fn GetIpStatisticsEx( + Statistics: PMIB_IPSTATS, + Family: ULONG, + ) -> ULONG; + pub fn GetIcmpStatisticsEx( + Statistics: PMIB_ICMP_EX, + Family: ULONG, + ) -> ULONG; + pub fn GetTcpStatisticsEx( + Statistics: PMIB_TCPSTATS, + Family: ULONG, + ) -> ULONG; + pub fn GetUdpStatisticsEx( + Statistics: PMIB_UDPSTATS, + Family: ULONG, + ) -> ULONG; + pub fn GetTcpStatisticsEx2( + Statistics: PMIB_TCPSTATS2, + Family: ULONG, + ) -> ULONG; + pub fn GetUdpStatisticsEx2( + Statistics: PMIB_UDPSTATS2, + Family: ULONG, + ) -> ULONG; + pub fn SetIfEntry( + pIfRow: PMIB_IFROW, + ) -> DWORD; + pub fn CreateIpForwardEntry( + pRoute: PMIB_IPFORWARDROW, + ) -> DWORD; + pub fn SetIpForwardEntry( + pRoute: PMIB_IPFORWARDROW, + ) -> DWORD; + pub fn DeleteIpForwardEntry( + pRoute: PMIB_IPFORWARDROW, + ) -> DWORD; + pub fn SetIpStatistics( + pIpStats: PMIB_IPSTATS, + ) -> DWORD; + pub fn SetIpTTL( + nTTL: UINT, + ) -> DWORD; + pub fn CreateIpNetEntry( + pArpEntry: PMIB_IPNETROW, + ) -> DWORD; + pub fn SetIpNetEntry( + pArpEntry: PMIB_IPNETROW, + ) -> DWORD; + pub fn DeleteIpNetEntry( + pArpEntry: PMIB_IPNETROW, + ) -> DWORD; + pub fn FlushIpNetTable( + dwIfIndex: DWORD, + ) -> DWORD; + pub fn CreateProxyArpEntry( + dwAddress: DWORD, + dwMask: DWORD, + dwIfIndex: DWORD, + ) -> DWORD; + pub fn DeleteProxyArpEntry( + dwAddress: DWORD, + dwMask: DWORD, + dwIfIndex: DWORD, + ) -> DWORD; + pub fn SetTcpEntry( + pTcpRow: PMIB_TCPROW, + ) -> DWORD; + pub fn GetInterfaceInfo( + pIfTable: PIP_INTERFACE_INFO, + dwOutBufLen: PULONG, + ) -> DWORD; + pub fn GetUniDirectionalAdapterInfo( + pIPIfInfo: PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, + dwOutBufLen: PULONG, + ) -> DWORD; + // pub fn NhpAllocateAndGetInterfaceInfoFromStack() -> DWORD; + pub fn GetBestInterface( + dwDestAddr: IPAddr, + pdwBestIfIndex: PDWORD, + ) -> DWORD; + pub fn GetBestInterfaceEx( + pDestAddr: PSOCKADDR, + pdwBestIfIndex: PDWORD, + ) -> DWORD; + pub fn GetBestRoute( + dwDestAddr: DWORD, + dwSourceAddr: DWORD, + pBestRoute: PMIB_IPFORWARDROW, + ) -> DWORD; + pub fn NotifyAddrChange( + Handle: PHANDLE, + overlapped: LPOVERLAPPED, + ) -> DWORD; + pub fn NotifyRouteChange( + Handle: PHANDLE, + overlapped: LPOVERLAPPED, + ) -> DWORD; + pub fn CancelIPChangeNotify( + notifyOverlapped: LPOVERLAPPED + ) -> BOOL; + pub fn GetAdapterIndex( + AdapterName: LPWSTR, + IfIndex: PULONG, + ) -> DWORD; + pub fn AddIPAddress( + Address: IPAddr, + IpMask: IPMask, + IfIndex: DWORD, + NTEContext: PULONG, + NTEInstance: PULONG, + ) -> DWORD; + pub fn DeleteIPAddress( + NTEContext: ULONG, + ) -> DWORD; + pub fn GetNetworkParams( + pFixedInfo: PFIXED_INFO, + pOutBufLen: PULONG, + ) -> DWORD; + pub fn GetAdaptersInfo( + AdapterInfo: PIP_ADAPTER_INFO, + SizePointer: PULONG, + ) -> ULONG; + // pub fn GetAdapterOrderMap(VOID) -> PIP_ADAPTER_ORDER_MAP; + pub fn GetAdaptersAddresses( + Family: ULONG, + Flags: ULONG, + Reserved: PVOID, + AdapterAddresses: PIP_ADAPTER_ADDRESSES, + SizePointer: PULONG, + ) -> ULONG; + pub fn GetPerAdapterInfo( + IfIndex: ULONG, + pPerAdapterInfo: PIP_PER_ADAPTER_INFO, + pOutBufLen: PULONG, + ) -> DWORD; + pub fn IpReleaseAddress( + AdapterInfo: PIP_ADAPTER_INDEX_MAP, + ) -> DWORD; + pub fn IpRenewAddress( + AdapterInfo: PIP_ADAPTER_INDEX_MAP, + ) -> DWORD; + pub fn SendARP( + DestIP: IPAddr, + SrcIP: IPAddr, + pMacAddr: PVOID, + PhyAddrLen: PULONG, + ) -> DWORD; + pub fn GetRTTAndHopCount( + DestIpAddress: IPAddr, + HopCount: PULONG, + MaxHops: ULONG, + RTT: PULONG, + ) -> BOOL; + pub fn GetFriendlyIfIndex( + IfIndex: DWORD, + ) -> DWORD; + pub fn EnableRouter( + pHandle: *mut HANDLE, + pOverlapped: *mut OVERLAPPED, + ) -> DWORD; + pub fn UnenableRouter( + pOverlapped: *mut OVERLAPPED, + lpdwEnableCount: LPDWORD, + ) -> DWORD; + pub fn DisableMediaSense( + pHandle: *mut HANDLE, + pOverLapped: *mut OVERLAPPED, + ) -> DWORD; + pub fn RestoreMediaSense( + pOverlapped: *mut OVERLAPPED, + lpdwEnableCount: LPDWORD, + ) -> DWORD; + pub fn GetIpErrorString( + ErrorCode: IP_STATUS, + Buffer: PWSTR, + Size: PDWORD, + ) -> DWORD; + pub fn ResolveNeighbor( + NetworkAddress: *mut SOCKADDR, + PhysicalAddress: PVOID, + PhysicalAddressLength: PULONG, + ) -> ULONG; + pub fn CreatePersistentTcpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + Token: PULONG64, + ) -> ULONG; + pub fn CreatePersistentUdpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + Token: PULONG64, + ) -> ULONG; + pub fn DeletePersistentTcpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + ) -> ULONG; + pub fn DeletePersistentUdpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + ) -> ULONG; + pub fn LookupPersistentTcpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + Token: PULONG64, + ) -> ULONG; + pub fn LookupPersistentUdpPortReservation( + StartPort: USHORT, + NumberOfPorts: USHORT, + Token: PULONG64, + ) -> ULONG; + // #if defined (_WS2DEF_) && defined (_WS2IPDEF_) && defined(_WINDNS_INCLUDED_) + #[cfg(all(feature = "ws2def", feature = "ws2ipdef"))] + pub fn ParseNetworkString( + NetworkString: *const *mut WCHAR, + Types: DWORD, + AddressInfo: PNET_ADDRESS_INFO, + PortNumber: *mut USHORT, + PrefixLength: *mut BYTE, + ) -> DWORD; +} diff --git a/src/um/iptypes.rs b/src/um/iptypes.rs new file mode 100644 index 000000000..93a342b84 --- /dev/null +++ b/src/um/iptypes.rs @@ -0,0 +1,383 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +// #include +// #include +// #include +use shared::basetsd::{UINT8, ULONG64}; +use shared::guiddef::GUID; +use shared::ifdef::{ + IF_INDEX, IF_LUID, IF_OPER_STATUS, NET_IF_COMPARTMENT_ID, NET_IF_CONNECTION_TYPE, + NET_IF_NETWORK_GUID, TUNNEL_TYPE +}; +use shared::ipifcons::IFTYPE; +use shared::minwindef::{BOOL, BYTE, DWORD, UCHAR, UINT}; +use shared::nldef::{NL_DAD_STATE, NL_PREFIX_ORIGIN, NL_SUFFIX_ORIGIN}; +use shared::ntdef::{CHAR, PCHAR, PWCHAR, ULONG, ULONGLONG, WCHAR}; +use shared::ws2def::SOCKET_ADDRESS; +use ucrt::corecrt::time_t; +pub const MAX_ADAPTER_DESCRIPTION_LENGTH: usize = 128; +pub const MAX_ADAPTER_NAME_LENGTH: usize = 256; +pub const MAX_ADAPTER_ADDRESS_LENGTH: usize = 8; +pub const DEFAULT_MINIMUM_ENTITIES: usize = 32; +pub const MAX_HOSTNAME_LEN: usize = 128; +pub const MAX_DOMAIN_NAME_LEN: usize = 128; +pub const MAX_SCOPE_ID_LEN: usize = 256; +pub const MAX_DHCPV6_DUID_LENGTH: usize = 130; +pub const MAX_DNS_SUFFIX_STRING_LENGTH: usize = 256; +pub const BROADCAST_NODETYPE: usize = 1; +pub const PEER_TO_PEER_NODETYPE: usize = 2; +pub const MIXED_NODETYPE: usize = 4; +pub const HYBRID_NODETYPE: usize = 8; +STRUCT!{struct IP_ADDRESS_STRING { + String: [CHAR; 4*4], +}} +pub type PIP_ADDRESS_STRING = *mut IP_ADDRESS_STRING; +pub type IP_MASK_STRING = IP_ADDRESS_STRING; +pub type PIP_MASK_STRING = *mut IP_MASK_STRING; +STRUCT!{struct IP_ADDR_STRING { + Next: *mut IP_ADDR_STRING, + IpAddress: IP_ADDRESS_STRING, + IpMask: IP_MASK_STRING, + Context: DWORD, +}} +pub type PIP_ADDR_STRING = *mut IP_ADDR_STRING; +STRUCT!{struct IP_ADAPTER_INFO { + Next: *mut IP_ADAPTER_INFO, + ComboIndex: DWORD, + AdapterName: [CHAR; MAX_ADAPTER_NAME_LENGTH + 4], + Description: [CHAR; MAX_ADAPTER_DESCRIPTION_LENGTH + 4], + AddressLength: UINT, + Address: [BYTE; MAX_ADAPTER_ADDRESS_LENGTH], + Index: DWORD, + Type: UINT, + DhcpEnabled: UINT, + CurrentIpAddress: PIP_ADDR_STRING, + IpAddressList: IP_ADDR_STRING, + GatewayList: IP_ADDR_STRING, + DhcpServer: IP_ADDR_STRING, + HaveWins: BOOL, + PrimaryWinsServer: IP_ADDR_STRING, + SecondaryWinsServer: IP_ADDR_STRING, + LeaseObtained: time_t, + LeaseExpires: time_t, +}} +pub type PIP_ADAPTER_INFO = *mut IP_ADAPTER_INFO; +pub type IP_PREFIX_ORIGIN = NL_PREFIX_ORIGIN; +pub type IP_SUFFIX_ORIGIN = NL_SUFFIX_ORIGIN; +pub type IP_DAD_STATE = NL_DAD_STATE; +STRUCT!{struct IP_ADAPTER_UNICAST_ADDRESS_LH_u_s { + Length: ULONG, + Flags: DWORD, +}} +UNION!{union IP_ADAPTER_UNICAST_ADDRESS_LH_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_UNICAST_ADDRESS_LH_u_s, +}} +STRUCT!{struct IP_ADAPTER_UNICAST_ADDRESS_LH { + u: IP_ADAPTER_UNICAST_ADDRESS_LH_u, + Next: *mut IP_ADAPTER_UNICAST_ADDRESS_LH, + Address: SOCKET_ADDRESS, + PrefixOrigin: IP_PREFIX_ORIGIN, + SuffixOrigin: IP_SUFFIX_ORIGIN, + DadState: IP_DAD_STATE, + ValidLifetime: ULONG, + PreferredLifetime: ULONG, + LeaseLifetime: ULONG, + OnLinkPrefixLength: UINT8, +}} +pub type PIP_ADAPTER_UNICAST_ADDRESS_LH = *mut IP_ADAPTER_UNICAST_ADDRESS_LH; +STRUCT!{struct IP_ADAPTER_UNICAST_ADDRESS_XP_u_s { + Length: ULONG, + Flags: DWORD, +}} +UNION!{union IP_ADAPTER_UNICAST_ADDRESS_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_UNICAST_ADDRESS_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_UNICAST_ADDRESS_XP { + u: IP_ADAPTER_UNICAST_ADDRESS_XP_u, + Next: *mut IP_ADAPTER_UNICAST_ADDRESS_XP, + Address: SOCKET_ADDRESS, + PrefixOrigin: IP_PREFIX_ORIGIN, + SuffixOrigin: IP_SUFFIX_ORIGIN, + DadState: IP_DAD_STATE, + ValidLifetime: ULONG, + PreferredLifetime: ULONG, + LeaseLifetime: ULONG, +}} +pub type PIP_ADAPTER_UNICAST_ADDRESS_XP = *mut IP_ADAPTER_UNICAST_ADDRESS_XP; +pub type IP_ADAPTER_UNICAST_ADDRESS = IP_ADAPTER_UNICAST_ADDRESS_LH; +// pub type IP_ADAPTER_UNICAST_ADDRESS = IP_ADAPTER_UNICAST_ADDRESS_XP; +pub type PIP_ADAPTER_UNICAST_ADDRESS = *mut IP_ADAPTER_UNICAST_ADDRESS; +pub const IP_ADAPTER_ADDRESS_DNS_ELIGIBLE: usize = 0x01; +pub const IP_ADAPTER_ADDRESS_TRANSIENT: usize = 0x02; +STRUCT!{struct IP_ADAPTER_ANYCAST_ADDRESS_XP_u_s { + Length: ULONG, + Flags: DWORD, +}} +UNION!{union IP_ADAPTER_ANYCAST_ADDRESS_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_ANYCAST_ADDRESS_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_ANYCAST_ADDRESS_XP { + u: IP_ADAPTER_ANYCAST_ADDRESS_XP_u, + Next: *mut IP_ADAPTER_ANYCAST_ADDRESS_XP, + Address: SOCKET_ADDRESS, +}} +pub type PIP_ADAPTER_ANYCAST_ADDRESS_XP = *mut IP_ADAPTER_ANYCAST_ADDRESS_XP; +pub type IP_ADAPTER_ANYCAST_ADDRESS = IP_ADAPTER_ANYCAST_ADDRESS_XP; +pub type PIP_ADAPTER_ANYCAST_ADDRESS = *mut IP_ADAPTER_ANYCAST_ADDRESS; +STRUCT!{struct IP_ADAPTER_MULTICAST_ADDRESS_XP_u_s { + Length: ULONG, + Flags: DWORD, +}} +UNION!{union IP_ADAPTER_MULTICAST_ADDRESS_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_MULTICAST_ADDRESS_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_MULTICAST_ADDRESS_XP { + u: IP_ADAPTER_MULTICAST_ADDRESS_XP_u, + Next: *mut IP_ADAPTER_MULTICAST_ADDRESS_XP, + Address: SOCKET_ADDRESS, +}} +pub type PIP_ADAPTER_MULTICAST_ADDRESS_XP = *mut IP_ADAPTER_MULTICAST_ADDRESS_XP; +pub type IP_ADAPTER_MULTICAST_ADDRESS = IP_ADAPTER_MULTICAST_ADDRESS_XP; +pub type PIP_ADAPTER_MULTICAST_ADDRESS = *mut IP_ADAPTER_MULTICAST_ADDRESS_XP; +STRUCT!{struct IP_ADAPTER_DNS_SERVER_ADDRESS_XP_u_s { + Length: ULONG, + Reserved: DWORD, +}} +UNION!{union IP_ADAPTER_DNS_SERVER_ADDRESS_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_DNS_SERVER_ADDRESS_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_DNS_SERVER_ADDRESS_XP { + u: IP_ADAPTER_DNS_SERVER_ADDRESS_XP_u, + Next: *mut IP_ADAPTER_DNS_SERVER_ADDRESS_XP, + Address: SOCKET_ADDRESS, +}} +pub type PIP_ADAPTER_DNS_SERVER_ADDRESS_XP = *mut IP_ADAPTER_DNS_SERVER_ADDRESS_XP; +pub type IP_ADAPTER_DNS_SERVER_ADDRESS = IP_ADAPTER_DNS_SERVER_ADDRESS_XP; +pub type PIP_ADAPTER_DNS_SERVER_ADDRESS = *mut IP_ADAPTER_DNS_SERVER_ADDRESS_XP; +STRUCT!{struct IP_ADAPTER_WINS_SERVER_ADDRESS_LH_u_s { + Length: ULONG, + Reserved: DWORD, +}} +UNION!{union IP_ADAPTER_WINS_SERVER_ADDRESS_LH_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_WINS_SERVER_ADDRESS_LH_u_s, +}} +STRUCT!{struct IP_ADAPTER_WINS_SERVER_ADDRESS_LH { + u: IP_ADAPTER_WINS_SERVER_ADDRESS_LH_u, + Next: *mut IP_ADAPTER_WINS_SERVER_ADDRESS_LH, + Address: SOCKET_ADDRESS, +}} +pub type PIP_ADAPTER_WINS_SERVER_ADDRESS_LH = *mut IP_ADAPTER_WINS_SERVER_ADDRESS_LH; +pub type IP_ADAPTER_WINS_SERVER_ADDRESS = IP_ADAPTER_WINS_SERVER_ADDRESS_LH; +pub type PIP_ADAPTER_WINS_SERVER_ADDRESS = *mut IP_ADAPTER_WINS_SERVER_ADDRESS_LH; +STRUCT!{struct IP_ADAPTER_GATEWAY_ADDRESS_LH_u_s { + Length: ULONG, + Reserved: DWORD, +}} +UNION!{union IP_ADAPTER_GATEWAY_ADDRESS_LH_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_GATEWAY_ADDRESS_LH_u_s, +}} +STRUCT!{struct IP_ADAPTER_GATEWAY_ADDRESS_LH { + u: IP_ADAPTER_GATEWAY_ADDRESS_LH_u, + Next: *mut IP_ADAPTER_GATEWAY_ADDRESS_LH, + Address: SOCKET_ADDRESS, +}} +pub type PIP_ADAPTER_GATEWAY_ADDRESS_LH = *mut IP_ADAPTER_GATEWAY_ADDRESS_LH; +pub type IP_ADAPTER_GATEWAY_ADDRESS = IP_ADAPTER_GATEWAY_ADDRESS_LH; +pub type PIP_ADAPTER_GATEWAY_ADDRESS = *mut IP_ADAPTER_GATEWAY_ADDRESS_LH; +STRUCT!{struct IP_ADAPTER_PREFIX_XP_u_s { + Length: ULONG, + Flags: DWORD, +}} +UNION!{union IP_ADAPTER_PREFIX_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_PREFIX_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_PREFIX_XP { + u: IP_ADAPTER_PREFIX_XP_u, + Next: *mut IP_ADAPTER_PREFIX_XP, + Address: SOCKET_ADDRESS, + PrefixLength: ULONG, +}} +pub type PIP_ADAPTER_PREFIX_XP = *mut IP_ADAPTER_PREFIX_XP; +pub type IP_ADAPTER_PREFIX = IP_ADAPTER_PREFIX_XP; +pub type PIP_ADAPTER_PREFIX = *mut IP_ADAPTER_PREFIX_XP; +STRUCT!{struct IP_ADAPTER_DNS_SUFFIX { + Next: *mut IP_ADAPTER_DNS_SUFFIX, + String: [WCHAR; MAX_DNS_SUFFIX_STRING_LENGTH], +}} +pub type PIP_ADAPTER_DNS_SUFFIX = *mut IP_ADAPTER_DNS_SUFFIX; +pub const IP_ADAPTER_DDNS_ENABLED: DWORD = 0x00000001; +pub const IP_ADAPTER_REGISTER_ADAPTER_SUFFIX: DWORD = 0x00000002; +pub const IP_ADAPTER_DHCP_ENABLED: DWORD = 0x00000004; +pub const IP_ADAPTER_RECEIVE_ONLY: DWORD = 0x00000008; +pub const IP_ADAPTER_NO_MULTICAST: DWORD = 0x00000010; +pub const IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG: DWORD = 0x00000020; +pub const IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED: DWORD = 0x00000040; +pub const IP_ADAPTER_IPV4_ENABLED: DWORD = 0x00000080; +pub const IP_ADAPTER_IPV6_ENABLED: DWORD = 0x00000100; +pub const IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG: DWORD = 0x00000200; +STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_u1_s { + Length: ULONG, + IfIndex: IF_INDEX, +}} +UNION!{union IP_ADAPTER_ADDRESSES_LH_u1 { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_ADDRESSES_LH_u1_s, +}} +STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_u2_s { + bitfield: ULONG, +}} +BITFIELD!{IP_ADAPTER_ADDRESSES_LH_u2_s bitfield: ULONG [ + DdnsEnabled set_DdnsEnabled[0..1], + RegisterAdapterSuffix set_RegisterAdapterSuffix[1..2], + Dhcpv4Enabled set_Dhcpv4Enabled[2..3], + ReceiveOnly set_ReceiveOnly[3..4], + NoMulticast set_NoMulticast[4..5], + Ipv6OtherStatefulConfig set_Ipv6OtherStatefulConfig[5..6], + NetbiosOverTcpipEnabled set_NetbiosOverTcpipEnabled[6..7], + Ipv4Enabled set_Ipv4Enabled[7..8], + Ipv6Enabled set_Ipv6Enabled[8..9], + Ipv6ManagedAddressConfigurationSupported set_Ipv6ManagedAddressConfigurationSupported[9..10], +]} +UNION!{union IP_ADAPTER_ADDRESSES_LH_u2 { + [u64; 1], + Flags Flags_mut: ULONG, + s s_mut: IP_ADAPTER_ADDRESSES_LH_u2_s, +}} +STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { + u1: IP_ADAPTER_ADDRESSES_LH_u1, + Next: *mut IP_ADAPTER_ADDRESSES_LH, + AdapterName: PCHAR, + FirstUnicastAddress: PIP_ADAPTER_UNICAST_ADDRESS_LH, + FirstAnycastAddress: PIP_ADAPTER_ANYCAST_ADDRESS_XP, + FirstMulticastAddress: PIP_ADAPTER_MULTICAST_ADDRESS_XP, + FirstDnsServerAddress: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP, + DnsSuffix: PWCHAR, + Description: PWCHAR, + FriendlyName: PWCHAR, + PhysicalAddress: [BYTE; MAX_ADAPTER_ADDRESS_LENGTH], + PhysicalAddressLength: ULONG, + u2: IP_ADAPTER_ADDRESSES_LH_u2, + Mtu: ULONG, + IfType: IFTYPE, + OperStatus: IF_OPER_STATUS, + Ipv6IfIndex: IF_INDEX, + ZoneIndices: [ULONG; 16], + FirstPrefix: PIP_ADAPTER_PREFIX_XP, + TransmitLinkSpeed: ULONG64, + ReceiveLinkSpeed: ULONG64, + FirstWinsServerAddress: PIP_ADAPTER_WINS_SERVER_ADDRESS_LH, + FirstGatewayAddress: PIP_ADAPTER_GATEWAY_ADDRESS_LH, + Ipv4Metric: ULONG, + Ipv6Metric: ULONG, + Luid: IF_LUID, + Dhcpv4Server: SOCKET_ADDRESS, + CompartmentId: NET_IF_COMPARTMENT_ID, + NetworkGuid: NET_IF_NETWORK_GUID, + ConnectionType: NET_IF_CONNECTION_TYPE, + TunnelType: TUNNEL_TYPE, + Dhcpv6Server: SOCKET_ADDRESS, + Dhcpv6ClientDuid: [BYTE; MAX_DHCPV6_DUID_LENGTH], + Dhcpv6ClientDuidLength: ULONG, + Dhcpv6Iaid: ULONG, + FirstDnsSuffix: PIP_ADAPTER_DNS_SUFFIX, +}} +pub type PIP_ADAPTER_ADDRESSES_LH = *mut IP_ADAPTER_ADDRESSES_LH; +STRUCT!{struct IP_ADAPTER_ADDRESSES_XP_u_s { + Length: ULONG, + IfIndex: DWORD, +}} +UNION!{union IP_ADAPTER_ADDRESSES_XP_u { + [u64; 1], + Alignment Alignment_mut: ULONGLONG, + s s_mut: IP_ADAPTER_ADDRESSES_XP_u_s, +}} +STRUCT!{struct IP_ADAPTER_ADDRESSES_XP { + u: IP_ADAPTER_ADDRESSES_XP_u, + Next: *mut IP_ADAPTER_ADDRESSES_XP, + AdapterName: PCHAR, + FirstUnicastAddress: PIP_ADAPTER_UNICAST_ADDRESS_XP, + FirstAnycastAddress: PIP_ADAPTER_ANYCAST_ADDRESS_XP, + FirstMulticastAddress: PIP_ADAPTER_MULTICAST_ADDRESS_XP, + FirstDnsServerAddress: PIP_ADAPTER_DNS_SERVER_ADDRESS_XP, + DnsSuffix: PWCHAR, + Description: PWCHAR, + FriendlyName: PWCHAR, + PhysicalAddress: [BYTE; MAX_ADAPTER_ADDRESS_LENGTH], + PhysicalAddressLength: DWORD, + Flags: DWORD, + Mtu: DWORD, + IfType: DWORD, + OperStatus: IF_OPER_STATUS, + Ipv6IfIndex: DWORD, + ZoneIndices: [DWORD; 16], + FirstPrefix: PIP_ADAPTER_PREFIX_XP, +}} +pub type PIP_ADAPTER_ADDRESSES_XP = *mut IP_ADAPTER_ADDRESSES_XP; +pub type IP_ADAPTER_ADDRESSES = IP_ADAPTER_ADDRESSES_LH; +// pub type IP_ADAPTER_ADDRESSES = IP_ADAPTER_ADDRESSES_XP; +pub type PIP_ADAPTER_ADDRESSES = *mut IP_ADAPTER_ADDRESSES; +pub const GAA_FLAG_SKIP_UNICAST: ULONG = 0x0001; +pub const GAA_FLAG_SKIP_ANYCAST: ULONG = 0x0002; +pub const GAA_FLAG_SKIP_MULTICAST: ULONG = 0x0004; +pub const GAA_FLAG_SKIP_DNS_SERVER: ULONG = 0x0008; +pub const GAA_FLAG_INCLUDE_PREFIX: ULONG = 0x0010; +pub const GAA_FLAG_SKIP_FRIENDLY_NAME: ULONG = 0x0020; +pub const GAA_FLAG_INCLUDE_WINS_INFO: ULONG = 0x0040; +pub const GAA_FLAG_INCLUDE_GATEWAYS: ULONG = 0x0080; +pub const GAA_FLAG_INCLUDE_ALL_INTERFACES: ULONG = 0x0100; +pub const GAA_FLAG_INCLUDE_ALL_COMPARTMENTS: ULONG = 0x0200; +pub const GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER: ULONG = 0x0400; +STRUCT!{struct IP_PER_ADAPTER_INFO_W2KSP1 { + AutoconfigEnabled: UINT, + AutoconfigActive: UINT, + CurrentDnsServer: PIP_ADDR_STRING, + DnsServerList: IP_ADDR_STRING, +}} +pub type PIP_PER_ADAPTER_INFO_W2KSP1 = *mut IP_PER_ADAPTER_INFO_W2KSP1; +pub type IP_PER_ADAPTER_INFO = IP_PER_ADAPTER_INFO_W2KSP1; +pub type PIP_PER_ADAPTER_INFO = *mut IP_PER_ADAPTER_INFO; +STRUCT!{struct FIXED_INFO_W2KSP1 { + HostName: [CHAR; MAX_HOSTNAME_LEN + 4], + DomainName: [CHAR; MAX_DOMAIN_NAME_LEN + 4], + CurrentDnsServer: PIP_ADDR_STRING, + DnsServerList: IP_ADDR_STRING, + NodeType: UINT, + ScopeId: [CHAR; MAX_SCOPE_ID_LEN + 4], + EnableRouting: UINT, + EnableProxy: UINT, + EnableDns: UINT, +}} +pub type PFIXED_INFO_W2KSP1 = *mut FIXED_INFO_W2KSP1; +pub type FIXED_INFO = FIXED_INFO_W2KSP1; +pub type PFIXED_INFO = *mut FIXED_INFO; +STRUCT!{struct IP_INTERFACE_NAME_INFO_W2KSP1 { + Index: ULONG, + MediaType: ULONG, + ConnectionType: UCHAR, + AccessType: UCHAR, + DeviceGuid: GUID, + InterfaceGuid: GUID, +}} +pub type PIP_INTERFACE_NAME_INFO_W2KSP1 = *mut IP_INTERFACE_NAME_INFO_W2KSP1; +pub type IP_INTERFACE_NAME_INFO = IP_INTERFACE_NAME_INFO_W2KSP1; +pub type PIP_INTERFACE_NAME_INFO = *mut IP_INTERFACE_NAME_INFO; diff --git a/src/um/mod.rs b/src/um/mod.rs index fb690061d..8ce4c9c2d 100644 --- a/src/um/mod.rs +++ b/src/um/mod.rs @@ -120,6 +120,9 @@ pub mod gl; #[cfg(feature = "imm")] pub mod imm; #[cfg(feature = "interlockedapi")] pub mod interlockedapi; #[cfg(feature = "ioapiset")] pub mod ioapiset; +#[cfg(feature = "ipexport")] pub mod ipexport; +#[cfg(feature = "iphlpapi")] pub mod iphlpapi; +#[cfg(feature = "iptypes")] pub mod iptypes; #[cfg(feature = "jobapi")] pub mod jobapi; #[cfg(feature = "jobapi2")] pub mod jobapi2; #[cfg(feature = "knownfolders")] pub mod knownfolders; From 0fd9b462294d42951d80eb31e7238f30fbfdb9c1 Mon Sep 17 00:00:00 2001 From: hankbao Date: Mon, 26 Aug 2019 17:33:55 +0800 Subject: [PATCH 02/26] comply to pr comments in #772 --- src/shared/in6addr.rs | 6 +++--- src/shared/ws2ipdef.rs | 4 ++-- src/um/iphlpapi.rs | 1 - 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/shared/in6addr.rs b/src/shared/in6addr.rs index 3c51e4e01..ea7eb75be 100644 --- a/src/shared/in6addr.rs +++ b/src/shared/in6addr.rs @@ -4,11 +4,11 @@ // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. //! IPv6 Internet address, 'on-wire' format structure. -use shared::minwindef::{BYTE, WORD}; +use shared::minwindef::{UCHAR, USHORT}; UNION!{union in6_addr_u { [u16; 8], - Byte Byte_mut: [BYTE; 16], - Word Word_mut: [WORD; 8], + Byte Byte_mut: [UCHAR; 16], + Word Word_mut: [USHORT; 8], }} STRUCT!{struct in6_addr { u: in6_addr_u, diff --git a/src/shared/ws2ipdef.rs b/src/shared/ws2ipdef.rs index fe6a3f2c5..6799b19f4 100644 --- a/src/shared/ws2ipdef.rs +++ b/src/shared/ws2ipdef.rs @@ -36,14 +36,14 @@ UNION!{union SOCKADDR_IN6_LH_u { sin6_scope_id sin6_scope_id_mut: ULONG, sin6_scope_struct sin6_scope_struct_mut: SCOPE_ID, }} -STRUCT!{struct SOCKADDR_IN6 { +STRUCT!{struct SOCKADDR_IN6_LH { sin6_family: ADDRESS_FAMILY, sin6_port: USHORT, sin6_flowinfo: ULONG, sin6_addr: IN6_ADDR, u: SOCKADDR_IN6_LH_u, }} -pub type SOCKADDR_IN6_LH = SOCKADDR_IN6; +pub type SOCKADDR_IN6 = SOCKADDR_IN6_LH; pub type PSOCKADDR_IN6_LH = *mut SOCKADDR_IN6_LH; STRUCT!{struct IP_MREQ { imr_multiaddr: IN_ADDR, diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index f289140f5..7bec6d173 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -386,7 +386,6 @@ extern "system" { Token: PULONG64, ) -> ULONG; // #if defined (_WS2DEF_) && defined (_WS2IPDEF_) && defined(_WINDNS_INCLUDED_) - #[cfg(all(feature = "ws2def", feature = "ws2ipdef"))] pub fn ParseNetworkString( NetworkString: *const *mut WCHAR, Types: DWORD, From 31f5abc41ec238bcbcd61a72f1c146f5776245d7 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 02:07:32 +0800 Subject: [PATCH 03/26] replace SIZEOF_* macros with functions --- build.rs | 2 +- src/shared/ifmib.rs | 12 ++++++++++- src/shared/udpmib.rs | 45 ++++++++++++++++++++++++++++++++++-------- src/shared/ws2ipdef.rs | 8 +++++++- 4 files changed, 56 insertions(+), 11 deletions(-) diff --git a/build.rs b/build.rs index dd0483a87..e69c6c037 100644 --- a/build.rs +++ b/build.rs @@ -47,7 +47,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("hidsdi", &["guiddef", "hidpi", "minwindef", "winnt"], &["hid"]), ("hidusage", &["minwindef"], &[]), ("ifdef", &["basetsd", "guiddef", "ntdef"], &[]), - ("ifmib", &["ifdef", "ipifcons", "minwindef", "ntdef"], &[]), + ("ifmib", &["basetsd", "ifdef", "ipifcons", "minwindef", "ntdef"], &[]), ("in6addr", &["minwindef"], &[]), ("inaddr", &["minwindef"], &[]), ("intsafe", &[], &[]), diff --git a/src/shared/ifmib.rs b/src/shared/ifmib.rs index 6656fc57c..770f785d0 100644 --- a/src/shared/ifmib.rs +++ b/src/shared/ifmib.rs @@ -6,10 +6,14 @@ //! Contains the public definitions and structures for the non-TCP/IP specific parts of MIB-II. // #include // #include +use core::mem; +use core::ptr; +use shared::basetsd::DWORD_PTR; use shared::ifdef::IF_INDEX; use shared::ipifcons::{IFTYPE, INTERNAL_IF_OPER_STATUS}; use shared::minwindef::DWORD; use shared::ntdef::{UCHAR, WCHAR}; +const ALIGN_SIZE: DWORD_PTR = 0x00000008; // from RTInfo.h const ANY_SIZE: usize = 1; STRUCT!{struct MIB_IFNUMBER { dwValue: DWORD, @@ -50,4 +54,10 @@ STRUCT!{struct MIB_IFTABLE { table: [MIB_IFROW; ANY_SIZE], }} pub type PMIB_IFTABLE = *mut MIB_IFTABLE; -// FIXME: How to define SIZEOF_IFTABLE(X) +#[inline] +pub fn SIZEOF_IFTABLE(num: usize) -> usize { + let offset = unsafe { + &(*(ptr::null() as *const MIB_IFTABLE)).table[0] as *const _ as usize + }; + offset + num * mem::size_of::() + ALIGN_SIZE +} diff --git a/src/shared/udpmib.rs b/src/shared/udpmib.rs index 584ed92dd..c5fe32a7c 100644 --- a/src/shared/udpmib.rs +++ b/src/shared/udpmib.rs @@ -5,12 +5,20 @@ // except according to those terms. //! Contains the public definitions and structures for the UDP-specific parts of MIB-II // #include -use shared::basetsd::DWORD64; +use core::mem; +use core::ptr; +use shared::basetsd::{DWORD64, DWORD_PTR}; use shared::in6addr::IN6_ADDR; use shared::minwindef::DWORD; use shared::ntdef::{INT, LARGE_INTEGER, UCHAR, ULONGLONG}; +const ALIGN_SIZE: DWORD_PTR = 0x00000008; // from RTInfo.h const ANY_SIZE: usize = 1; pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; +macro_rules! offset_of_table { + ($type:ty) => (unsafe { + &(*(ptr::null() as *const $type)).table[0] as *const _ as usize + }) +} STRUCT!{struct MIB_UDPROW { dwLocalAddr: DWORD, dwLocalPort: DWORD, @@ -21,7 +29,10 @@ STRUCT!{struct MIB_UDPTABLE { table: [MIB_UDPROW; ANY_SIZE], }} pub type PMIB_UDPTABLE = *mut MIB_UDPTABLE; -// FIXME: Need to figure out how to define SIZEOF_UDPTABLE(X) +#[inline] +pub fn SIZEOF_UDPTABLE(num: usize) -> usize { + offset_of_table!(MIB_UDPTABLE) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_UDPROW_OWNER_PID { dwLocalAddr: DWORD, dwLocalPort: DWORD, @@ -33,7 +44,11 @@ STRUCT!{struct MIB_UDPTABLE_OWNER_PID { table: [MIB_UDPROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_UDPTABLE_OWNER_PID = *mut MIB_UDPTABLE_OWNER_PID; -// FIXME: Need to figure out how to define SIZEOF_UDPTABLE_OWNER_PID(X) +#[inline] +pub fn SIZEOF_UDPTABLE_OWNER_PID(num: usize) -> usize { + offset_of_table!(MIB_UDPTABLE_OWNER_PID) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_UDPROW_OWNER_MODULE_u_s { bitfield: INT, }} @@ -59,7 +74,11 @@ STRUCT!{struct MIB_UDPTABLE_OWNER_MODULE { table: [MIB_UDPROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_UDPTABLE_OWNER_MODULE = *mut MIB_UDPTABLE_OWNER_MODULE; -// FIXME: Need to figure out how to define SIZEOF_UDPTABLE_OWNER_MODULE(X) +#[inline] +pub fn SIZEOF_UDPTABLE_OWNER_MODULE(num: usize) -> usize { + offset_of_table!(MIB_UDPTABLE_OWNER_MODULE) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_UDP6ROW { dwLocalAddr: IN6_ADDR, dwLocalScopeId: DWORD, @@ -71,7 +90,10 @@ STRUCT!{struct MIB_UDP6TABLE { table: [MIB_UDP6ROW; ANY_SIZE], }} pub type PMIB_UDP6TABLE = *mut MIB_UDP6TABLE; -// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE(X) +#[inline] +pub fn SIZEOF_UDP6TABLE(num: usize) -> usize { + offset_of_table!(MIB_UDP6TABLE) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_UDP6ROW_OWNER_PID { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -81,11 +103,14 @@ STRUCT!{struct MIB_UDP6ROW_OWNER_PID { pub type PMIB_UDP6ROW_OWNER_PID = *mut MIB_UDP6ROW_OWNER_PID; STRUCT!{struct MIB_UDP6TABLE_OWNER_PID { dwNumEntries: DWORD, - // _Field_size_(dwNumEntries) // FIXME: Unsure what this is/means table: [MIB_UDP6ROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_UDP6TABLE_OWNER_PID = *mut MIB_UDP6TABLE_OWNER_PID; -// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE_OWNER_PID(X) +#[inline] +pub fn SIZEOF_UDP6TABLE_OWNER_PID(num: usize) -> usize { + offset_of_table!(MIB_UDP6TABLE_OWNER_PID) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_UDP6ROW_OWNER_MODULE_u_s { bitfield: INT, }} @@ -112,7 +137,11 @@ STRUCT!{struct MIB_UDP6TABLE_OWNER_MODULE { table: [MIB_UDP6ROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_UDP6TABLE_OWNER_MODULE = *mut MIB_UDP6TABLE_OWNER_MODULE; -// FIXME: Need to figure out how to define SIZEOF_UDP6TABLE_OWNER_MODULE(X) +#[inline] +pub fn SIZEOF_UDP6TABLE_OWNER_MODULE(num: usize) -> usize { + offset_of_table!(MIB_UDP6TABLE_OWNER_MODULE) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_UDPSTATS { dwInDatagrams: DWORD, dwNoPorts: DWORD, diff --git a/src/shared/ws2ipdef.rs b/src/shared/ws2ipdef.rs index 6799b19f4..e948030cd 100644 --- a/src/shared/ws2ipdef.rs +++ b/src/shared/ws2ipdef.rs @@ -43,8 +43,14 @@ STRUCT!{struct SOCKADDR_IN6_LH { sin6_addr: IN6_ADDR, u: SOCKADDR_IN6_LH_u, }} -pub type SOCKADDR_IN6 = SOCKADDR_IN6_LH; pub type PSOCKADDR_IN6_LH = *mut SOCKADDR_IN6_LH; +pub type SOCKADDR_IN6 = SOCKADDR_IN6_LH; +pub type PSOCKADDR_IN6 = *mut SOCKADDR_IN6; +STRUCT!{struct SOCKADDR_IN6_PAIR { + SourceAddress: PSOCKADDR_IN6, + DestinationAddress: PSOCKADDR_IN6, +}} +pub type PSOCKADDR_IN6_PAIR = *mut SOCKADDR_IN6_PAIR; STRUCT!{struct IP_MREQ { imr_multiaddr: IN_ADDR, imr_interface: IN_ADDR, From 6fac11ea6857df1bc1f546dcbbc209aec517abd8 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 00:25:11 +0800 Subject: [PATCH 04/26] feat: netioapi support --- Cargo.toml | 1 + build.rs | 7 +- src/shared/ifdef.rs | 37 ++- src/shared/mod.rs | 1 + src/shared/netioapi.rs | 650 ++++++++++++++++++++++++++++++++++++++++- src/shared/nldef.rs | 165 ++++++----- src/shared/ntddndis.rs | 59 ++++ src/shared/ws2ipdef.rs | 7 + 8 files changed, 831 insertions(+), 96 deletions(-) create mode 100644 src/shared/ntddndis.rs diff --git a/Cargo.toml b/Cargo.toml index 593f08076..a8ec9bc8a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -89,6 +89,7 @@ mstcpip = [] mswsockdef = [] netioapi = [] nldef = [] +ntddndis = [] ntddscsi = [] ntddser = [] ntdef = [] diff --git a/build.rs b/build.rs index e69c6c037..8c956f999 100644 --- a/build.rs +++ b/build.rs @@ -46,7 +46,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("hidpi", &["hidusage", "minwindef", "ntdef", "ntstatus", "winnt"], &["hid"]), ("hidsdi", &["guiddef", "hidpi", "minwindef", "winnt"], &["hid"]), ("hidusage", &["minwindef"], &[]), - ("ifdef", &["basetsd", "guiddef", "ntdef"], &[]), + ("ifdef", &["basetsd", "guiddef", "minwindef", "ntdef"], &[]), ("ifmib", &["basetsd", "ifdef", "ipifcons", "minwindef", "ntdef"], &[]), ("in6addr", &["minwindef"], &[]), ("inaddr", &["minwindef"], &[]), @@ -63,8 +63,9 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("mprapidef", &[], &[]), ("mstcpip", &["basetsd", "guiddef", "in6addr", "inaddr", "minwindef", "winnt", "ws2def"], &["ntdll"]), ("mswsockdef", &["minwindef", "winnt", "ws2def"], &[]), - ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "ntdef"], &["iphlpapi"]), - ("nldef", &["basetsd", "minwindef", "winnt"], &[]), + ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "ntddndis", "ntdef", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("nldef", &["basetsd", "minwindef", "ntdef", "winnt"], &[]), + ("ntddndis", &["ifdef"], &[]), ("ntddscsi", &["basetsd", "minwindef", "ntdef", "winioctl", "winnt"], &[]), ("ntddser", &["devpropdef"], &[]), ("ntdef", &["basetsd", "guiddef"], &[]), diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index 12209e250..0ebd3d46e 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -3,8 +3,6 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -// #include -// #include use shared::basetsd::{UINT16, UINT32, ULONG32, ULONG64}; use shared::guiddef::GUID; use shared::ntdef::{BOOLEAN, ULONG, USHORT}; @@ -35,7 +33,8 @@ pub type PNET_IF_ADMIN_STATUS = *mut NET_IF_ADMIN_STATUS; pub type NET_IF_COMPARTMENT_SCOPE = UINT32; pub type PNET_IF_COMPARTMENT_SCOPE = *mut NET_IF_COMPARTMENT_SCOPE; pub const NET_IF_COMPARTMENT_SCOPE_UNSPECIFIED: NET_IF_COMPARTMENT_SCOPE = 0; -// pub const NET_IF_COMPARTMENT_SCOPE_ALL: NET_IF_COMPARTMENT_SCOPE = -1; +pub const NET_IF_COMPARTMENT_SCOPE_ALL: NET_IF_COMPARTMENT_SCOPE = -1i32 as + NET_IF_COMPARTMENT_SCOPE; ENUM!{enum NET_IF_RCV_ADDRESS_TYPE { NET_IF_RCV_ADDRESS_TYPE_OTHER = 1, NET_IF_RCV_ADDRESS_TYPE_VOLATILE = 2, @@ -107,22 +106,22 @@ ENUM!{enum NET_IF_ACCESS_TYPE { }} pub type PNET_IF_ACCESS_TYPE = *mut NET_IF_ACCESS_TYPE; ENUM!{enum NET_IF_DIRECTION_TYPE { - NET_IF_DIRECTION_SENDRECEIVE, - NET_IF_DIRECTION_SENDONLY, - NET_IF_DIRECTION_RECEIVEONLY, - NET_IF_DIRECTION_MAXIMUM, + NET_IF_DIRECTION_SENDRECEIVE = 0, + NET_IF_DIRECTION_SENDONLY = 1, + NET_IF_DIRECTION_RECEIVEONLY = 2, + NET_IF_DIRECTION_MAXIMUM = 3, }} pub type PNET_IF_DIRECTION_TYPE = *mut NET_IF_DIRECTION_TYPE; ENUM!{enum NET_IF_MEDIA_CONNECT_STATE { - MediaConnectStateUnknown, - MediaConnectStateConnected, - MediaConnectStateDisconnected, + MediaConnectStateUnknown = 0, + MediaConnectStateConnected = 1, + MediaConnectStateDisconnected = 2, }} pub type PNET_IF_MEDIA_CONNECT_STATE = *mut NET_IF_MEDIA_CONNECT_STATE; ENUM!{enum NET_IF_MEDIA_DUPLEX_STATE { - MediaDuplexStateUnknown, - MediaDuplexStateHalf, - MediaDuplexStateFull, + MediaDuplexStateUnknown = 0, + MediaDuplexStateHalf = 1, + MediaDuplexStateFull = 2, }} pub type PNET_IF_MEDIA_DUPLEX_STATE = *mut NET_IF_MEDIA_DUPLEX_STATE; STRUCT!{struct NET_PHYSICAL_LOCATION_LH { @@ -159,12 +158,12 @@ ENUM!{enum IF_ADMINISTRATIVE_STATE { pub type PIF_ADMINISTRATIVE_STATE = *mut IF_ADMINISTRATIVE_STATE; ENUM!{enum IF_OPER_STATUS { IfOperStatusUp = 1, - IfOperStatusDown, - IfOperStatusTesting, - IfOperStatusUnknown, - IfOperStatusDormant, - IfOperStatusNotPresent, - IfOperStatusLowerLayerDown, + IfOperStatusDown = 2, + IfOperStatusTesting = 3, + IfOperStatusUnknown = 4, + IfOperStatusDormant = 5, + IfOperStatusNotPresent = 6, + IfOperStatusLowerLayerDown = 7, }} STRUCT!{struct NDIS_INTERFACE_INFORMATION { ifOperStatus: NET_IF_OPER_STATUS, diff --git a/src/shared/mod.rs b/src/shared/mod.rs index 22ab9d7f0..b75105613 100644 --- a/src/shared/mod.rs +++ b/src/shared/mod.rs @@ -56,6 +56,7 @@ pub mod guiddef; #[cfg(feature = "mswsockdef")] pub mod mswsockdef; #[cfg(feature = "netioapi")] pub mod netioapi; #[cfg(feature = "nldef")] pub mod nldef; +#[cfg(feature = "ntddndis")] pub mod ntddndis; #[cfg(feature = "ntddscsi")] pub mod ntddscsi; #[cfg(feature = "ntddser")] pub mod ntddser; #[cfg(feature = "ntdef")] pub mod ntdef; diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index e8788e50b..4612daf4c 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -3,14 +3,550 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -use shared::basetsd::SIZE_T; +use shared::basetsd::{SIZE_T, PUINT8, UINT8, ULONG64}; use shared::guiddef::GUID; -use shared::ifdef::{NET_IFINDEX, NET_LUID, PNET_IFINDEX, PNET_LUID}; -use shared::minwindef::DWORD; -use shared::ntdef::{CHAR, PSTR, PWSTR, WCHAR}; +use shared::ifdef::{ + IF_MAX_PHYS_ADDRESS_LENGTH, IF_MAX_STRING_SIZE, IF_OPER_STATUS, NET_IFINDEX, + NET_IF_ACCESS_TYPE, NET_IF_ADMIN_STATUS, NET_IF_COMPARTMENT_ID, NET_IF_COMPARTMENT_SCOPE, + NET_IF_DIRECTION_TYPE, NET_IF_MEDIA_CONNECT_STATE, NET_IF_NETWORK_GUID, NET_LUID, PNET_IFINDEX, + PNET_IF_COMPARTMENT_ID, PNET_IF_COMPARTMENT_SCOPE, PNET_LUID, TUNNEL_TYPE, +}; +use shared::minwindef::{BYTE, DWORD, PULONG, UCHAR, ULONG}; +use shared::nldef::{ + NL_BANDWIDTH_INFORMATION, NL_DAD_STATE, NL_INTERFACE_OFFLOAD_ROD, + NL_LINK_LOCAL_ADDRESS_BEHAVIOR, NL_NEIGHBOR_STATE, NL_PREFIX_ORIGIN, + NL_ROUTER_DISCOVERY_BEHAVIOR, NL_ROUTE_ORIGIN, NL_ROUTE_PROTOCOL, NL_SUFFIX_ORIGIN, +}; +use shared::ntddndis::{NDIS_IF_MAX_STRING_SIZE, NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; +use shared::ntdef::{ + BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, VOID, WCHAR, +}; +use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID}; +use shared::ws2ipdef::SOCKADDR_INET; +pub use um::winnt::ANYSIZE_ARRAY as ANY_SIZE; pub type NETIO_STATUS = DWORD; pub type NETIOAPI_API = NETIO_STATUS; +ENUM!{enum MIB_NOTIFICATION_TYPE { + MibParameterNotification = 0, + MibAddInstance = 1, + MibDeleteInstance = 2, + MibInitialNotification = 3, +}} +pub type PMIB_NOTIFICATION_TYPE = *mut MIB_NOTIFICATION_TYPE; +STRUCT!{struct MIB_IF_ROW2_InterfaceAndOperStatusFlags { + bitfield: BYTE, +}} +BITFIELD!{MIB_IF_ROW2_InterfaceAndOperStatusFlags bitfield: BYTE [ + HardwareInterface set_HardwareInterface[0..1], + FilterInterface set_FilterInterface: [1..2], + ConnectorPresent set_ConnectorPresent: [2..3], + NotAuthenticated set_NotAuthenticated: [3..4], + NotMediaConnected set_NotMediaConnected: [4..5], + Paused set_Paused: [5..6], + LowPower set_LowPower: [6..7], + EndPointInterface set_LowPower: [7..8], +]} +STRUCT!{struct MIB_IF_ROW2 { + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + InterfaceGuid: GUID, + Alias: [WCHAR; IF_MAX_STRING_SIZE + 1], + Description: [WCHAR; IF_MAX_STRING_SIZE + 1], + PhysicalAddressLength: ULONG, + PhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], + PermanentPhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], + Mtu: ULONG, + Type: ULONG, // Interface Type. + TunnelType: TUNNEL_TYPE, // Tunnel Type, if Type = IF_TUNNEL. + MediaType: NDIS_MEDIUM, + PhysicalMediumType: NDIS_PHYSICAL_MEDIUM, + AccessType NET_IF_ACCESS_TYPE, + DirectionType NET_IF_DIRECTION_TYPE, + InterfaceAndOperStatusFlags: MIB_IF_ROW2_InterfaceAndOperStatusFlags, + OperStatus: IF_OPER_STATUS, + AdminStatus: NET_IF_ADMIN_STATUS, + MediaConnectState: NET_IF_MEDIA_CONNECT_STATE, + NetworkGuid: NET_IF_NETWORK_GUID, + ConnectionType: NET_IF_CONNECTION_TYPE, + TransmitLinkSpeed: ULONG64, + ReceiveLinkSpeed: ULONG64, + InOctets: ULONG64, + InUcastPkts: ULONG64, + InNUcastPkts: ULONG64, + InDiscards: ULONG64, + InErrors: ULONG64, + InUnknownProtos: ULONG64, + InUcastOctets: ULONG64, + InMulticastOctets: ULONG64, + InBroadcastOctets: ULONG64, + OutOctets: ULONG64, + OutUcastPkts: ULONG64, + OutNUcastPkts: ULONG64, + OutDiscards: ULONG64, + OutErrors: ULONG64, + OutUcastOctets: ULONG64, + OutMulticastOctets: ULONG64, + OutBroadcastOctets: ULONG64, + OutQLen: ULONG64, +}} +pub type PMIB_IF_ROW2 = *mut MIB_IF_ROW2; +STRUCT!{struct MIB_IF_TABLE2 { + NumEntries: ULONG, + Table: [MIB_IF_ROW2; ANY_SIZE], +}} +pub type PMIB_IF_TABLE2 = *mut MIB_IF_TABLE2; +extern "system" pub fn GetIfEntry2( + Row: PMIB_IF_ROW2, +) -> NETIOAPI_API; +ENUM!{enum MIB_IF_ENTRY_LEVEL { + MibIfEntryNormal = 0, + MibIfEntryNormalWithoutStatistics = 2, +}} +pub type PMIB_IF_ENTRY_LEVEL = *mut MIB_IF_ENTRY_LEVEL; extern "system" { + pub fn GetIfEntry2Ex( + Level: MIB_IF_ENTRY_LEVEL, + Row: PMIB_IF_ROW2, + ) -> NETIOAPI_API; + pub fn GetIfTable2( + Table: *mut PMIB_IF_TABLE2, + ) -> NETIOAPI_API; +} +ENUM!{enum MIB_IF_TABLE_LEVEL { + MibIfTableNormal = 0, + MibIfTableRaw = 1, + MibIfTableNormalWithoutStatistics = 2, +}} +pub type PMIB_IF_TABLE_LEVEL = *mut MIB_IF_TABLE_LEVEL; +extern "system" { + pub fn GetIfTable2Ex( + Level: MIB_IF_TABLE_LEVEL, + Table: *mut PMIB_IF_TABLE2, + ) -> NETIOAPI_API; +} +STRUCT!{struct MIB_IPINTERFACE_ROW { + Family: ADDRESS_FAMILY, + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + MaxReassemblySize: ULONG, + InterfaceIdentifier: ULONG64, + MinRouterAdvertisementInterval: ULONG, + MaxRouterAdvertisementInterval: ULONG, + AdvertisingEnabled: BOOLEAN, + ForwardingEnabled: BOOLEAN, + WeakHostSend: BOOLEAN, + WeakHostReceive: BOOLEAN, + UseAutomaticMetric: BOOLEAN, + UseNeighborUnreachabilityDetection: BOOLEAN, + ManagedAddressConfigurationSupported: BOOLEAN, + OtherStatefulConfigurationSupported: BOOLEAN, + AdvertiseDefaultRoute: BOOLEAN, + RouterDiscoveryBehavior: NL_ROUTER_DISCOVERY_BEHAVIOR, + DadTransmits: ULONG, // DupAddrDetectTransmits in RFC 2462. + BaseReachableTime: ULONG, + RetransmitTime: ULONG, + PathMtuDiscoveryTimeout: ULONG, // Path MTU discovery timeout (in ms). + LinkLocalAddressBehavior: NL_LINK_LOCAL_ADDRESS_BEHAVIOR, + LinkLocalAddressTimeout: ULONG, // In ms. + ZoneIndices: [ULONG; ScopeLevelCount], // Zone part of a SCOPE_ID. + SitePrefixLength: ULONG, + Metric: ULONG, + NlMtu: ULONG, + Connected: BOOLEAN, + SupportsWakeUpPatterns: BOOLEAN, + SupportsNeighborDiscovery: BOOLEAN, + SupportsRouterDiscovery: BOOLEAN, + ReachableTime: ULONG, + TransmitOffload: NL_INTERFACE_OFFLOAD_ROD, + ReceiveOffload: NL_INTERFACE_OFFLOAD_ROD, + DisableDefaultRoutes: BOOLEAN, +}} +pub type PMIB_IPINTERFACE_ROW = *mut MIB_IPINTERFACE_ROW; +STRUCT!{struct MIB_IPINTERFACE_TABLE { + NumEntries: ULONG, + Table: [MIB_IPINTERFACE_ROW; ANY_SIZE], +}} +pub type PMIB_IPINTERFACE_TABLE = *mut MIB_IPINTERFACE_TABLE; +STRUCT!{struct MIB_IFSTACK_ROW { + HigherLayerInterfaceIndex: NET_IFINDEX, + LowerLayerInterfaceIndex: NET_IFINDEX, +}} +pub type PMIB_IFSTACK_ROW = *mut MIB_IFSTACK_ROW; +STRUCT!{struct MIB_INVERTEDIFSTACK_ROW { + LowerLayerInterfaceIndex: NET_IFINDEX, + HigherLayerInterfaceIndex: NET_IFINDEX, +}} +pub type PMIB_INVERTEDIFSTACK_ROW = *mut MIB_INVERTEDIFSTACK_ROW; +STRUCT!{struct MIB_IFSTACK_TABLE { + NumEntries: ULONG, + Table: [MIB_IFSTACK_ROW; ANY_SIZE], +}} +pub type PMIB_IFSTACK_TABLE = *mut MIB_IFSTACK_TABLE; +STRUCT!{struct MIB_INVERTEDIFSTACK_TABLE { + NumEntries: ULONG, + Table: [MIB_INVERTEDIFSTACK_ROW; ANY_SIZE], +}} +pub type PMIB_INVERTEDIFSTACK_TABLE = *mut MIB_INVERTEDIFSTACK_TABLE; +FN!{stdcall PIPINTERFACE_CHANGE_CALLBACK( + CallerContext: PVOID, + Row: PMIB_IPINTERFACE_ROW, + NotificationType: MIB_NOTIFICATION_TYPE, +) -> VOID} +STRUCT!{struct MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES { + InboundBandwidthInformation: NL_BANDWIDTH_INFORMATION, + OutboundBandwidthInformation: NL_BANDWIDTH_INFORMATION, +}} +pub type PMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES = *mut + MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES; +extern "system" { + pub fn GetIfStackTable( + Table: *mut PMIB_IFSTACK_TABLE, + ) -> NETIOAPI_API; + pub fn GetInvertedIfStackTable( + Table: *mut PMIB_INVERTEDIFSTACK_TABLE, + ) -> NETIOAPI_API; + pub fn GetIpInterfaceEntry( + Row: PMIB_IPINTERFACE_ROW, + ) -> NETIOAPI_API; + pub fn GetIpInterfaceTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_IPINTERFACE_TABLE, + ) -> NETIOAPI_API; + pub fn InitializeIpInterfaceEntry( + Row: PMIB_IPINTERFACE_ROW, + ); + pub fn NotifyIpInterfaceChange( + Family: ADDRESS_FAMILY, + Callback: PIPINTERFACE_CHANGE_CALLBACK, + CallerContext: PVOID, + InitialNotification: BOOLEAN, + NotificationHandle: *mut HANDLE + ) -> NETIOAPI_API; + pub fn SetIpInterfaceEntry( + Row: PMIB_IPINTERFACE_ROW, + ) -> NETIOAPI_API; + pub fn GetIpNetworkConnectionBandwidthEstimates( + InterfaceIndex: NET_IFINDEX, + AddressFamily: ADDRESS_FAMILY, + BandwidthEstimates: PMIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES, + ) -> NETIOAPI_API; +} +STRUCT!{struct MIB_UNICASTIPADDRESS_ROW { + Address: SOCKADDR_INET, + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + PrefixOrigin: NL_PREFIX_ORIGIN, + SuffixOrigin: NL_SUFFIX_ORIGIN, + ValidLifetime: ULONG, + PreferredLifetime: ULONG, + OnLinkPrefixLength: UINT8, + SkipAsSource: BOOLEAN, + DadState: NL_DAD_STATE, + ScopeId: SCOPE_ID, + CreationTimeStamp: LARGE_INTEGER, +}} +pub type PMIB_UNICASTIPADDRESS_ROW = *mut MIB_UNICASTIPADDRESS_ROW; +STRUCT!{struct MIB_UNICASTIPADDRESS_TABLE { + NumEntries: ULONG, + Table: [MIB_UNICASTIPADDRESS_ROW; ANY_SIZE], +}} +pub type PMIB_UNICASTIPADDRESS_TABLE = *mut MIB_UNICASTIPADDRESS_TABLE; +FN!{stdcall PUNICAST_IPADDRESS_CHANGE_CALLBACK( + CallerContext: PVOID, + Row: PMIB_UNICASTIPADDRESS_ROW, + NotificationType: MIB_NOTIFICATION_TYPE, +) -> VOID} +extern "system" { + pub fn CreateUnicastIpAddressEntry( + Row: *const MIB_UNICASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn DeleteUnicastIpAddressEntry( + Row: *const MIB_UNICASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn GetUnicastIpAddressEntry( + Row: PMIB_UNICASTIPADDRESS_ROW + ) -> NETIOAPI_API; + pub fn GetUnicastIpAddressTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_UNICASTIPADDRESS_TABLE, + ) -> NETIOAPI_API; + pub fn InitializeUnicastIpAddressEntry( + Row: PMIB_UNICASTIPADDRESS_ROW, + ); + pub fn NotifyUnicastIpAddressChange( + Family: ADDRESS_FAMILY, + Callback: PUNICAST_IPADDRESS_CHANGE_CALLBACK, + CallerContext: PVOID, + InitialNotification: BOOLEAN, + NotificationHandle: *mut HANDLE, + ) -> NETIOAPI_API; +} +FN!{stdcall PSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACK( + CallerContext: PVOID, + AddressTable: PMIB_UNICASTIPADDRESS_TABLE, +) -> VOID} +extern "system" { + pub fn NotifyStableUnicastIpAddressTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_UNICASTIPADDRESS_TABLE, + CallerCallback: PSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACK, + CallerContext: PVOID, + NotificationHandle: *mut HANDLE, + ) -> NETIOAPI_API; + pub fn SetUnicastIpAddressEntry( + Row: *const MIB_UNICASTIPADDRESS_ROW, + ) -> NETIOAPI_API; +} +STRUCT!{struct MIB_ANYCASTIPADDRESS_ROW { + Address: SOCKADDR_INET, + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + ScopeId: SCOPE_ID, +}} +pub type PMIB_ANYCASTIPADDRESS_ROW = *mut MIB_ANYCASTIPADDRESS_ROW; +STRUCT!{struct MIB_ANYCASTIPADDRESS_TABLE { + NumEntries: ULONG, + Table: [MIB_ANYCASTIPADDRESS_ROW; ANY_SIZE], +}} +pub type PMIB_ANYCASTIPADDRESS_TABLE = *mut MIB_ANYCASTIPADDRESS_TABLE; +extern "system" { + pub fn CreateAnycastIpAddressEntry( + Row: *const MIB_ANYCASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn DeleteAnycastIpAddressEntry( + Row: *const MIB_ANYCASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn GetAnycastIpAddressEntry( + Row: PMIB_ANYCASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn GetAnycastIpAddressTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_ANYCASTIPADDRESS_TABLE, + ) -> NETIOAPI_API; +} +STRUCT!{struct MIB_MULTICASTIPADDRESS_ROW { + Address: SOCKADDR_INET, + InterfaceIndex: NET_IFINDEX, + InterfaceLuid: NET_LUID, + ScopeId: SCOPE_ID, +}} +pub type PMIB_MULTICASTIPADDRESS_ROW = *mut MIB_MULTICASTIPADDRESS_ROW; +STRUCT!{struct MIB_MULTICASTIPADDRESS_TABLE { + NumEntries: ULONG, + Table: [MIB_MULTICASTIPADDRESS_ROW; ANY_SIZE], +}} +pub type PMIB_MULTICASTIPADDRESS_TABLE = *mut MIB_MULTICASTIPADDRESS_TABLE; +extern "system" { + pub fn GetMulticastIpAddressEntry( + Row: PMIB_MULTICASTIPADDRESS_ROW, + ) -> NETIOAPI_API; + pub fn GetMulticastIpAddressTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_MULTICASTIPADDRESS_TABLE, + ) -> NETIOAPI_API; +} +STRUCT!{struct IP_ADDRESS_PREFIX { + Prefix: SOCKADDR_INET, + PrefixLength: UINT8, +}} +pub type PIP_ADDRESS_PREFIX = *mut IP_ADDRESS_PREFIX; +STRUCT!{struct MIB_IPFORWARD_ROW2 { + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + DestinationPrefix: IP_ADDRESS_PREFIX, + NextHop: SOCKADDR_INET, + SitePrefixLength: UCHAR, + ValidLifetime: ULONG, + PreferredLifetime: ULONG, + Metric: ULONG, + Protocol: NL_ROUTE_PROTOCOL, + Loopback: BOOLEAN, + AutoconfigureAddress: BOOLEAN, + Publish: BOOLEAN, + Immortal: BOOLEAN, + Age: ULONG, + Origin: NL_ROUTE_ORIGIN, +}} +pub type PMIB_IPFORWARD_ROW2 = *mut MIB_IPFORWARD_ROW2; +STRUCT!{struct MIB_IPFORWARD_TABLE2 { + NumEntries: ULONG, + Table: [MIB_IPFORWARD_ROW2; ANY_SIZE] +}} +pub type PMIB_IPFORWARD_TABLE2 = *mut MIB_IPFORWARD_TABLE2; +FN!{stdcall PIPFORWARD_CHANGE_CALLBACK( + CallerContext: PVOID, + Row: PMIB_IPFORWARD_ROW2, + NotificationType: MIB_NOTIFICATION_TYPE, +) -> VOID} +extern "system" { + pub fn CreateIpForwardEntry2( + Row: *const MIB_IPFORWARD_ROW2, + ) -> NETIOAPI_API; + pub fn DeleteIpForwardEntry2( + Row: *const MIB_IPFORWARD_ROW2, + ) -> NETIOAPI_API; + pub fn GetBestRoute2( + InterfaceLuid: *mut NET_LUID, + InterfaceIndex: NET_IFINDEX, + SourceAddress: *const SOCKADDR_INET, + DestinationAddress: *const SOCKADDR_INET, + AddressSortOptions: ULONG, + BestRoute: PMIB_IPFORWARD_ROW2, + BestSourceAddress: *mut SOCKADDR_INET, + ) - > NETIOAPI_API; + pub fn GetIpForwardEntry2( + Row: PMIB_IPFORWARD_ROW2, + ) -> NETIOAPI_API; + pub fn GetIpForwardTable2( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_IPFORWARD_TABLE2, + ) -> NETIOAPI_API; + pub fn InitializeIpForwardEntry( + Row: PMIB_IPFORWARD_ROW2, + ); + pub fn NotifyRouteChange2( + AddressFamily: ADDRESS_FAMILY, + Callback: PIPFORWARD_CHANGE_CALLBACK, + CallerContext: PVOID, + InitialNotification: BOOLEAN, + NotificationHandle: *mut HANDLE, + ) -> NETIOAPI_API; + pub fn SetIpForwardEntry2( + Route: *const MIB_IPFORWARD_ROW2, + ) -> NETIOAPI_API; +} +UNION!{union MIB_IPPATH_ROW_u { + [u32; 1], + LastReachable: ULONG, // Milliseconds. + LastUnreachable: ULONG, // Milliseconds. +}} +STRUCT!{struct MIB_IPPATH_ROW { + Source: SOCKADDR_INET, + Destination: SOCKADDR_INET, + InterfaceLuid: NET_LUID, + InterfaceIndex: NET_IFINDEX, + CurrentNextHop: SOCKADDR_INET, + PathMtu: ULONG, + RttMean: ULONG, + RttDeviation: ULONG, + u: MIB_IPPATH_ROW_u, + IsReachable: BOOLEAN, + LinkTransmitSpeed: ULONG64, + LinkReceiveSpeed: ULONG64, +}} +pub type PMIB_IPPATH_ROW = *mut MIB_IPPATH_ROW; +STRUCT!{struct MIB_IPPATH_TABLE { + NumEntries: ULONG, + Table: [MIB_IPPATH_ROW; ANY_SIZE], +}} +pub type PMIB_IPPATH_TABLE = *mut MIB_IPPATH_TABLE; +extern "system" { + pub fn FlushIpPathTable( + Family: ADDRESS_FAMILY, + ) -> NETIOAPI_API; + pub fn GetIpPathEntry( + Row: PMIB_IPPATH_ROW, + ) -> NETIOAPI_API; + pub fn GetIpPathTable( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_IPPATH_TABLE, + ) -> NETIOAPI_API; +} +STRUCT!{struct MIB_IPNET_ROW2_s { + Flags: UCHAR, +}} +BITFIELD!{MIB_IPNET_ROW2_s Flags: UCHAR [ + IsRouter set_IsRouter[0..1], + IsUnreachable set_IsUnreachable[1..2], + Reserved set_Reserved[2..8], +]} +UNION!{union MIB_IPNET_ROW2_ReachabilityTime { + [u32; 1], + LastReachable LastReachable_mut: ULONG, + LastUnreachable LastUnreachable_mut: ULONG, +}} +STRUCT!{struct MIB_IPNET_ROW2 { + Address: SOCKADDR_INET, + InterfaceIndex NET_IFINDEX, + InterfaceLuid NET_LUID, + PhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], + PhysicalAddressLength ULONG, + State: NL_NEIGHBOR_STATE, + s: MIB_IPNET_ROW2_s, + ReachabilityTime: MIB_IPNET_ROW2_ReachabilityTime, +}} +pub type PMIB_IPNET_ROW2 = *mut MIB_IPNET_ROW2; +STRUCT!{struct MIB_IPNET_TABLE2 { + NumEntries: ULONG, + Table: [MIB_IPNET_ROW2; ANY_SIZE], +}} +pub type PMIB_IPNET_TABLE2 = *mut MIB_IPNET_TABLE2; +extern "system" { + pub fn CreateIpNetEntry2( + Row: *const MIB_IPNET_ROW2, + ) -> NETIOAPI_API; + pub fn DeleteIpNetEntry2( + Row: *const MIB_IPNET_ROW2, + ) -> NETIOAPI_API; + pub fn FlushIpNetTable2( + Family: ADDRESS_FAMILY, + InterfaceIndex: NET_IFINDEX, + ) -> NETIOAPI_API; + pub fn GetIpNetEntry2( + Row: PMIB_IPNET_ROW2, + ) -> NETIOAPI_API; + pub fn GetIpNetTable2( + Family: ADDRESS_FAMILY, + Table: *mut PMIB_IPNET_TABLE2, + ) -> NETIOAPI_API; + pub fn ResolveIpNetEntry2( + Row: PMIB_IPNET_ROW2, + SourceAddress: *const SOCKADDR_INET, + ) -> NETIOAPI_API; + pub fn SetIpNetEntry2( + Row: PMIB_IPNET_ROW2, + ) -> NETIOAPI_API; +} +const MIB_INVALID_TEREDO_PORT_NUMBER: USHORT = 0; +FN!{stdcall PTEREDO_PORT_CHANGE_CALLBACK( + CallerContext: PVOID, + Port: USHORT, + NotificationType: MIB_NOTIFICATION_TYPE, +) -> VOID} +extern "system" { + pub fn NotifyTeredoPortChange( + Callback: PTEREDO_PORT_CHANGE_CALLBACK, + CallerContext: PVOID, + InitialNotification: BOOLEAN, + NotificationHandle: *mut HANDLE, + ) -> NETIOAPI_API; + pub fn GetTeredoPort( + Port: *mut USHORT, + ) -> NETIOAPI_API; + pub fn CancelMibChangeNotify2( + NotificationHandle: HANDLE, + ) -> NETIOAPI_API; + pub fn FreeMibTable( + Memory: PVOID, + ); + // FIXME: + // pub fn CreateSortedAddressPairs( + // const PSOCKADDR_IN6 SourceAddressList, + // ULONG SourceAddressCount, + // const PSOCKADDR_IN6 DestinationAddressList, + // ULONG DestinationAddressCount, + // ULONG AddressSortOptions, + // PSOCKADDR_IN6_PAIR *SortedAddressPairList, + // ULONG *SortedAddressPairCoun + // ) -> NETIOAPI_API; + pub fn ConvertCompartmentGuidToId( + CompartmentGuid: *const GUID, + CompartmentId: PNET_IF_COMPARTMENT_ID, + ) -> NETIOAPI_API; + pub fn ConvertCompartmentIdToGuid( + CompartmentId: NET_IF_COMPARTMENT_ID, + CompartmentGuid: *mut GUID, + ) -> NETIOAPI_API; pub fn ConvertInterfaceNameToLuidA( InterfaceName: *const CHAR, InterfaceLuid: *mut NET_LUID, @@ -54,4 +590,110 @@ extern "system" { InterfaceGuid: *const GUID, InterfaceLuid: PNET_LUID, ) -> NETIOAPI_API; + pub fn if_nametoindex( + InterfaceName: PCSTR, + ) -> NET_IFINDEX; + pub fn if_indextoname( + InterfaceIndex: NET_IFINDEX, + InterfaceName: PCHAR, + ) -> PCHAR; + pub fn GetCurrentThreadCompartmentId() -> NET_IF_COMPARTMENT_ID; + pub fn SetCurrentThreadCompartmentId( + CompartmentId: NET_IF_COMPARTMENT_ID + ) -> NETIOAPI_API; + pub fn GetCurrentThreadCompartmentScope( + CompartmentScope: PNET_IF_COMPARTMENT_SCOPE, + CompartmentId: PNET_IF_COMPARTMENT_ID, + ); + pub fn SetCurrentThreadCompartmentScope( + CompartmentScope: NET_IF_COMPARTMENT_SCOPE, + ) -> NETIOAPI_API; + pub fn GetJobCompartmentId( + JobHandle: HANDLE, + ) -> NET_IF_COMPARTMENT_ID; + pub fn SetJobCompartmentId( + JobHandle: HANDLE, + CompartmentId: NET_IF_COMPARTMENT_ID, + ) -> NETIOAPI_API; + pub fn GetSessionCompartmentId( + SessionId: ULONG, + ) -> NET_IF_COMPARTMENT_ID; + pub fn SetSessionCompartmentId( + SessionId: ULONG, + CompartmentId: NET_IF_COMPARTMENT_ID, + ) -> NETIOAPI_API; + pub fn GetDefaultCompartmentId() -> NET_IF_COMPARTMENT_ID; + pub fn GetNetworkInformation( + NetworkGuid: *const NET_IF_NETWORK_GUID, + CompartmentId: PNET_IF_COMPARTMENT_ID, + SiteId: PULONG, + NetworkName: PWCHAR, + Length: ULONG, + ) -> NETIOAPI_API; + pub fn SetNetworkInformation( + NetworkGuid: *const NET_IF_NETWORK_GUID, + CompartmentId: NET_IF_COMPARTMENT_ID, + NetworkName: *const WCHAR, + ) -> NETIOAPI_API; + pub fn ConvertLengthToIpv4Mask( + MaskLength: ULONG, + Mask: PULONG, + ) -> NETIOAPI_API; + pub fn ConvertIpv4MaskToLength( + Mask: ULONG, + MaskLength: PUINT8, + ) -> NETIOAPI_API; +} +pub const DNS_SETTINGS_VERSION1: ULONG = 0x0001; +pub const DNS_INTERFACE_SETTINGS_VERSION1: ULONG = 0x0001; +pub const DNS_SETTING_IPV6: ULONG64 = 0x0001; +pub const DNS_SETTING_NAMESERVER: ULONG64 = 0x0002; +pub const DNS_SETTING_SEARCHLIST: ULONG64 = 0x0004; +pub const DNS_SETTING_REGISTRATION_ENABLED: ULONG64 = 0x0008; +pub const DNS_SETTING_REGISTER_ADAPTER_NAME: ULONG64 = 0x0010 +pub const DNS_SETTING_DOMAIN: ULONG64 = 0x0020; +pub const DNS_SETTING_HOSTNAME: ULONG64 = 0x0040; +pub const DNS_SETTINGS_ENABLE_LLMNR: ULONG64 = 0x0080; +pub const DNS_SETTINGS_QUERY_ADAPTER_NAME: ULONG64 = 0x0100; +pub const DNS_SETTING_PROFILE_NAMESERVER: ULONG64 = 0x0200; +STRUCT!{struct DNS_SETTINGS { + Version: ULONG, + Flags: ULONG64, + Hostname: PWSTR, + Domain: PWSTR, + SearchList: PWSTR, +}} +STRUCT!{struct DNS_INTERFACE_SETTINGS { + Version: ULONG, + Flags: ULONG64, + Domain: PWSTR, + NameServer: PWSTR, + SearchList: PWSTR, + RegistrationEnabled: ULONG, + RegisterAdapterName: ULONG, + EnableLLMNR: ULONG, + QueryAdapterName: ULONG, + ProfileNameServer: PWSTR, +}} +extern "system" { + pub fn GetDnsSettings( + Settings: *mut DNS_SETTINGS, + ) -> NETIOAPI_API; + pub fn FreeDnsSettings( + Settings: *mut DNS_SETTINGS, + ); + pub fn SetDnsSettings( + Settings: *const DNS_SETTINGS, + ) -> NETIOAPI_API; + pub fn GetInterfaceDnsSettings( + Interface: GUID, + Settings: *mut DNS_INTERFACE_SETTINGS, + ) -> NETIOAPI_API; + pub fn FreeInterfaceDnsSettings( + Settings: *mut DNS_INTERFACE_SETTINGS, + ); + pub fn SetInterfaceDnsSettings( + Interface: GUID, + Settings: *const DNS_INTERFACE_SETTINGS, + ) -> NETIOAPI_API; } diff --git a/src/shared/nldef.rs b/src/shared/nldef.rs index bbde419a4..ae897ebc5 100644 --- a/src/shared/nldef.rs +++ b/src/shared/nldef.rs @@ -4,14 +4,14 @@ // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. use shared::basetsd::ULONG64; -use shared::minwindef::ULONG; -use um::winnt::BOOLEAN; +use shared::minwindef::{BYTE, ULONG}; +use shared::ntdef::BOOLEAN ENUM!{enum NL_PREFIX_ORIGIN { - IpPrefixOriginOther, - IpPrefixOriginManual, - IpPrefixOriginWellKnown, - IpPrefixOriginDhcp, - IpPrefixOriginRouterAdvertisement, + IpPrefixOriginOther = 0, + IpPrefixOriginManual = 1, + IpPrefixOriginWellKnown = 2, + IpPrefixOriginDhcp = 3, + IpPrefixOriginRouterAdvertisement = 4, IpPrefixOriginUnchanged = 1 << 4, }} pub const NlpoOther: NL_PREFIX_ORIGIN = IpPrefixOriginOther; @@ -20,32 +20,57 @@ pub const NlpoWellKnown: NL_PREFIX_ORIGIN = IpPrefixOriginWellKnown; pub const NlpoDhcp: NL_PREFIX_ORIGIN = IpPrefixOriginDhcp; pub const NlpoRouterAdvertisement: NL_PREFIX_ORIGIN = IpPrefixOriginRouterAdvertisement; ENUM!{enum NL_SUFFIX_ORIGIN { - NlsoOther = 0, - NlsoManual, - NlsoWellKnown, - NlsoDhcp, - NlsoLinkLayerAddress, - NlsoRandom, IpSuffixOriginOther = 0, - IpSuffixOriginManual, - IpSuffixOriginWellKnown, - IpSuffixOriginDhcp, - IpSuffixOriginLinkLayerAddress, - IpSuffixOriginRandom, + IpSuffixOriginManual = 1, + IpSuffixOriginWellKnown = 2, + IpSuffixOriginDhcp = 3, + IpSuffixOriginLinkLayerAddress = 4, + IpSuffixOriginRandom = 5, IpSuffixOriginUnchanged = 1 << 4, }} +pub const NlsoOther: NL_SUFFIX_ORIGIN = IpSuffixOriginOther; +pub const NlsoManual: NL_SUFFIX_ORIGIN = IpSuffixOriginManual; +pub const NlsoWellKnown: NL_SUFFIX_ORIGIN = IpSuffixOriginWellKnown; +pub const NlsoDhcp: NL_SUFFIX_ORIGIN = IpSuffixOriginDhcp, +pub const NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = IpSuffixOriginLinkLayerAddress; +pub const NlsoRandom: NL_SUFFIX_ORIGIN = IpSuffixOriginRandom; ENUM!{enum NL_DAD_STATE { - NldsInvalid, - NldsTentative, - NldsDuplicate, - NldsDeprecated, - NldsPreferred, IpDadStateInvalid = 0, - IpDadStateTentative, - IpDadStateDuplicate, - IpDadStateDeprecated, - IpDadStatePreferred, + IpDadStateTentative = 1, + IpDadStateDuplicate = 2, + IpDadStateDeprecated = 3, + IpDadStatePreferred = 4, }} +pub const NldsInvalid: NL_DAD_STATE = IpDadStateInvalid; +pub const NldsTentative: NL_DAD_STATE = IpDadStateTentative; +pub const NldsDuplicate: NL_DAD_STATE = IpDadStateDuplicate; +pub const NldsDeprecated: NL_DAD_STATE = IpDadStateDeprecated; +pub const NldsPreferred: NL_DAD_STATE = IpDadStatePreferred; +ENUM!{enum NL_LINK_LOCAL_ADDRESS_BEHAVIOR { + LinkLocalAlwaysOff = 0, + LinkLocalDelayed = 1, + LinkLocalAlwaysOn = 2, + LinkLocalUnchanged = -1 +}} +ENUM!{enum NL_ROUTER_DISCOVERY_BEHAVIOR { + RouterDiscoveryDisabled = 0, + RouterDiscoveryEnabled = 1, + RouterDiscoveryDhcp = 2, + RouterDiscoveryUnchanged = -1, +}} +STRUCT!{struct NL_INTERFACE_OFFLOAD_ROD { + bitfield: BYTE, +}} +BITFIELD!{NL_INTERFACE_OFFLOAD_ROD bitfield: BYTE [ + NlChecksumSupported set_NlChecksumSupported[0..1], + NlOptionsSupported set_NlOptionsSupported [1..2], + TlDatagramChecksumSupported set_TlDatagramChecksumSupported: [2..3], + TlStreamChecksumSupported set_TlStreamChecksumSupported: [3..4], + TlStreamOptionsSupported set_TlStreamOptionsSupported: [4..5], + FastPathCompatible set_FastPathCompatible: [5..6], + TlLargeSendOffloadSupported set_TlLargeSendOffloadSupported: [6..7], + TlGiantSendOffloadSupported set_TlGiantSendOffloadSupported: [7..8] +]} pub const NL_MAX_METRIC_COMPONENT: ULONG = (1u32 << 31) - 1; ENUM!{enum NL_ROUTE_PROTOCOL { RouteProtocolOther = 1, @@ -73,8 +98,8 @@ ENUM!{enum NL_ROUTE_PROTOCOL { PROTO_IP_LOCAL = 2, MIB_IPPROTO_NETMGMT = 3, PROTO_IP_NETMGMT = 3, - MIB_IPPROTO_ICMP = 4, - PROTO_IP_ICMP = 4, + MIB_IPPROTO_ICMP = 4, + PROTO_IP_ICMP = 4, MIB_IPPROTO_EGP = 5, PROTO_IP_EGP = 5, MIB_IPPROTO_GGP = 6, @@ -93,16 +118,16 @@ ENUM!{enum NL_ROUTE_PROTOCOL { PROTO_IP_BBN = 12, MIB_IPPROTO_OSPF = 13, PROTO_IP_OSPF = 13, - MIB_IPPROTO_BGP = 14, - PROTO_IP_BGP = 14, + MIB_IPPROTO_BGP = 14, + PROTO_IP_BGP = 14, MIB_IPPROTO_IDPR = 15, PROTO_IP_IDPR = 15, - MIB_IPPROTO_EIGRP =16, + MIB_IPPROTO_EIGRP = 16, PROTO_IP_EIGRP = 16, MIB_IPPROTO_DVMRP = 17, PROTO_IP_DVMRP = 17, - MIB_IPPROTO_RPL = 18, - PROTO_IP_RPL = 18, + MIB_IPPROTO_RPL = 18, + PROTO_IP_RPL = 18, MIB_IPPROTO_DHCP = 19, PROTO_IP_DHCP = 19, MIB_IPPROTO_NT_AUTOSTATIC = 10002, @@ -114,38 +139,38 @@ ENUM!{enum NL_ROUTE_PROTOCOL { }} pub type PNL_ROUTE_PROTOCOL = *mut NL_ROUTE_PROTOCOL; ENUM!{enum NL_ADDRESS_TYPE { - NlatUnspecified, - NlatUnicast, - NlatAnycast, - NlatMulticast, - NlatBroadcast, - NlatInvalid, + NlatUnspecified = 0, + NlatUnicast = 1, + NlatAnycast = 2, + NlatMulticast = 3, + NlatBroadcast = 4, + NlatInvalid = 5, }} pub type PNL_ADDRESS_TYPE = *mut NL_ADDRESS_TYPE; ENUM!{enum NL_ROUTE_ORIGIN { - NlroManual, - NlroWellKnown, - NlroDHCP, - NlroRouterAdvertisement, - Nlro6to4, + NlroManual = 0, + NlroWellKnown = 1, + NlroDHCP = 2, + NlroRouterAdvertisement = 3, + Nlro6to4 = 4, }} pub type PNL_ROUTE_ORIGIN = *mut NL_ROUTE_ORIGIN; ENUM!{enum NL_NEIGHBOR_STATE { - NlnsUnreachable, - NlnsIncomplete, - NlnsProbe, - NlnsDelay, - NlnsStale, - NlnsReachable, - NlnsPermanent, - NlnsMaximum, + NlnsUnreachable = 0, + NlnsIncomplete = 1, + NlnsProbe = 2, + NlnsDelay = 3, + NlnsStale = 4, + NlnsReachable = 5, + NlnsPermanent = 6, + NlnsMaximum = 7, }} pub type PNL_NEIGHBOR_STATE = *mut NL_NEIGHBOR_STATE; ENUM!{enum NL_LINK_LOCAL_ADDRESS_BEHAVIOR { LinkLocalAlwaysOff = 0, - LinkLocalDelayed, - LinkLocalAlwaysOn, - LinkLocalUnchanged = 0xFFFFFFFF, + LinkLocalDelayed = 1, + LinkLocalAlwaysOn = 2, + LinkLocalUnchanged = -1, }} STRUCT!{struct NL_INTERFACE_OFFLOAD_ROD { Bitfield: BOOLEAN, @@ -163,16 +188,16 @@ BITFIELD!{NL_INTERFACE_OFFLOAD_ROD Bitfield: BOOLEAN [ pub type PNL_INTERFACE_OFFLOAD_ROD = *mut NL_INTERFACE_OFFLOAD_ROD; ENUM!{enum NL_ROUTER_DISCOVERY_BEHAVIOR { RouterDiscoveryDisabled = 0, - RouterDiscoveryEnabled, - RouterDiscoveryDhcp, - RouterDiscoveryUnchanged = 0xFFFFFFFF, + RouterDiscoveryEnabled = 1, + RouterDiscoveryDhcp = 2, + RouterDiscoveryUnchanged = -1, }} -ENUM!{enum NL_PATH_BANDWIDTH_FLAG { +ENUM!{enum NL_BANDWIDTH_FLAG { NlbwDisabled = 0, - NlbwEnabled, - NlbwUnchanged = 0xFFFFFFFF, + NlbwEnabled = 1, + NlbwUnchanged = -1, }} -pub type PNL_PATH_BANDWIDTH_FLAG = *mut NL_PATH_BANDWIDTH_FLAG; +pub type PNL_BANDWIDTH_FLAG = *mut NL_BANDWIDTH_FLAG; STRUCT!{struct NL_PATH_BANDWIDTH_ROD { Bandwidth: ULONG64, Instability: ULONG64, @@ -180,11 +205,11 @@ STRUCT!{struct NL_PATH_BANDWIDTH_ROD { }} pub type PNL_PATH_BANDWIDTH_ROD = *mut NL_PATH_BANDWIDTH_ROD; ENUM!{enum NL_NETWORK_CATEGORY { - NetworkCategoryPublic, - NetworkCategoryPrivate, - NetworkCategoryDomainAuthenticated, - NetworkCategoryUnchanged = 0xFFFFFFFF, - NetworkCategoryUnknown = 0xFFFFFFFF, + NetworkCategoryPublic = 0, + NetworkCategoryPrivate = 1, + NetworkCategoryDomainAuthenticated = 2, + NetworkCategoryUnchanged = -1, + NetworkCategoryUnknown = -1, }} pub type PNL_NETWORK_CATEGORY = *mut NL_NETWORK_CATEGORY; ENUM!{enum NL_INTERFACE_NETWORK_CATEGORY_STATE { @@ -192,10 +217,10 @@ ENUM!{enum NL_INTERFACE_NETWORK_CATEGORY_STATE { NlincPublic = 1, NlincPrivate = 2, NlincDomainAuthenticated = 3, - NlincCategoryStateMax, + NlincCategoryStateMax = 4, }} pub type PNL_INTERFACE_NETWORK_CATEGORY_STATE = *mut NL_INTERFACE_NETWORK_CATEGORY_STATE; -pub const NET_IF_CURRENT_SESSION : ULONG = 0xFFFFFFFF; +pub const NET_IF_CURRENT_SESSION : ULONG = -1i32 as u32; STRUCT!{struct NL_BANDWIDTH_INFORMATION { Bandwidth: ULONG64, Instability: ULONG64, diff --git a/src/shared/ntddndis.rs b/src/shared/ntddndis.rs new file mode 100644 index 000000000..babdc6e8a --- /dev/null +++ b/src/shared/ntddndis.rs @@ -0,0 +1,59 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +use shared::ifdef::IF_MAX_STRING_SIZE; +pub const NDIS_IF_MAX_STRING_SIZE: usize = IF_MAX_STRING_SIZE; +ENUM!{enum NDIS_MEDIUM { + NdisMedium802_3 = 0, + NdisMedium802_5 = 1, + NdisMediumFddi = 2, + NdisMediumWan = 3, + NdisMediumLocalTalk = 4, + NdisMediumDix = 5, // defined for convenience, not a real medium + NdisMediumArcnetRaw = 6, + NdisMediumArcnet878_2 = 7, + NdisMediumAtm = 8, + NdisMediumWirelessWan = 9, + NdisMediumIrda = 10, + NdisMediumBpc = 11, + NdisMediumCoWan = 12, + NdisMedium1394 = 13, + NdisMediumInfiniBand = 14, +// #if ((NTDDI_VERSION >= NTDDI_VISTA) || NDIS_SUPPORT_NDIS6) + NdisMediumTunnel = 15, + NdisMediumNative802_11 = 16, + NdisMediumLoopback = 17, +// #endif // (NTDDI_VERSION >= NTDDI_VISTA) +// #if (NTDDI_VERSION >= NTDDI_WIN7) + NdisMediumWiMAX = 18, + NdisMediumIP = 19, +// #endif + NdisMediumMax = 20, // Not a real medium, defined as an upper-bound +}} +pub type PNDIS_MEDIUM = *mut NDIS_MEDIUM; +ENUM!{enum NDIS_PHYSICAL_MEDIUM { + NdisPhysicalMediumUnspecified = 0, + NdisPhysicalMediumWirelessLan = 1, + NdisPhysicalMediumCableModem = 2, + NdisPhysicalMediumPhoneLine = 3, + NdisPhysicalMediumPowerLine = 4, + NdisPhysicalMediumDSL = 5, // includes ADSL and UADSL (G.Lite) + NdisPhysicalMediumFibreChannel = 6, + NdisPhysicalMedium1394 = 7, + NdisPhysicalMediumWirelessWan = 8, + NdisPhysicalMediumNative802_11 = 9, + NdisPhysicalMediumBluetooth = 10, + NdisPhysicalMediumInfiniband = 11, + NdisPhysicalMediumWiMax = 12, + NdisPhysicalMediumUWB = 13, + NdisPhysicalMedium802_3 = 14, + NdisPhysicalMedium802_5 = 15, + NdisPhysicalMediumIrda = 16, + NdisPhysicalMediumWiredWAN = 17, + NdisPhysicalMediumWiredCoWan = 18, + NdisPhysicalMediumOther = 19, + NdisPhysicalMediumMax = 20, // Not a real physical type, defined as an upper-bound +}} +pub type PNDIS_PHYSICAL_MEDIUM = *mut NDIS_PHYSICAL_MEDIUM; diff --git a/src/shared/ws2ipdef.rs b/src/shared/ws2ipdef.rs index e948030cd..e888452c5 100644 --- a/src/shared/ws2ipdef.rs +++ b/src/shared/ws2ipdef.rs @@ -51,6 +51,13 @@ STRUCT!{struct SOCKADDR_IN6_PAIR { DestinationAddress: PSOCKADDR_IN6, }} pub type PSOCKADDR_IN6_PAIR = *mut SOCKADDR_IN6_PAIR; +UNION!{union SOCKADDR_INET { + [u32; 7], + Ipv4 Ipv4_mut: SOCKADDR_IN, + Ipv6 Ipv6_mut: SOCKADDR_IN6, + si_family si_family_mut: ADDRESS_FAMILY, +}} +pub type PSOCKADDR_INET = *mut SOCKADDR_INET; STRUCT!{struct IP_MREQ { imr_multiaddr: IN_ADDR, imr_interface: IN_ADDR, From a9f1b668c46e2c02c8e09baca60ac5d056f52764 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 14:49:22 +0800 Subject: [PATCH 05/26] fix typo & improve code --- Cargo.toml | 1 + build.rs | 11 +++--- src/shared/ifmib.rs | 3 +- src/shared/netioapi.rs | 82 +++++++++++++++++++++--------------------- src/shared/nldef.rs | 45 ++++++----------------- src/shared/udpmib.rs | 4 +-- src/shared/ws2ipdef.rs | 2 +- src/um/mod.rs | 1 + src/um/rtinfo.rs | 7 ++++ 9 files changed, 71 insertions(+), 85 deletions(-) create mode 100644 src/um/rtinfo.rs diff --git a/Cargo.toml b/Cargo.toml index a8ec9bc8a..de10da64c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -316,6 +316,7 @@ reason = [] restartmanager = [] restrictederrorinfo = [] rmxfguid = [] +rtinfo = [] sapi = [] sapi51 = [] sapi53 = [] diff --git a/build.rs b/build.rs index 8c956f999..4620f92d7 100644 --- a/build.rs +++ b/build.rs @@ -46,8 +46,8 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("hidpi", &["hidusage", "minwindef", "ntdef", "ntstatus", "winnt"], &["hid"]), ("hidsdi", &["guiddef", "hidpi", "minwindef", "winnt"], &["hid"]), ("hidusage", &["minwindef"], &[]), - ("ifdef", &["basetsd", "guiddef", "minwindef", "ntdef"], &[]), - ("ifmib", &["basetsd", "ifdef", "ipifcons", "minwindef", "ntdef"], &[]), + ("ifdef", &["basetsd", "guiddef", "ntdef"], &[]), + ("ifmib", &["ifdef", "ipifcons", "minwindef", "ntdef", "rtinfo"], &[]), ("in6addr", &["minwindef"], &[]), ("inaddr", &["minwindef"], &[]), ("intsafe", &[], &[]), @@ -63,8 +63,8 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("mprapidef", &[], &[]), ("mstcpip", &["basetsd", "guiddef", "in6addr", "inaddr", "minwindef", "winnt", "ws2def"], &["ntdll"]), ("mswsockdef", &["minwindef", "winnt", "ws2def"], &[]), - ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "ntddndis", "ntdef", "ws2def", "ws2ipdef"], &["iphlpapi"]), - ("nldef", &["basetsd", "minwindef", "ntdef", "winnt"], &[]), + ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "nldef", "ntddndis", "ntdef", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("nldef", &["basetsd", "minwindef", "ntdef"], &[]), ("ntddndis", &["ifdef"], &[]), ("ntddscsi", &["basetsd", "minwindef", "ntdef", "winioctl", "winnt"], &[]), ("ntddser", &["devpropdef"], &[]), @@ -81,7 +81,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), ("transportsettingcommon", &["guiddef"], &[]), ("tvout", &["guiddef", "minwindef"], &[]), - ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), + ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef", "rtinfo"], &[]), ("usb", &["minwindef", "usbspec", "winnt"], &[]), ("usbiodef", &["guiddef", "minwindef", "winioctl", "winnt"], &[]), ("usbspec", &["basetsd", "guiddef", "minwindef", "winnt"], &[]), @@ -292,6 +292,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("restartmanager", &["minwindef", "winnt"], &["rstrtmgr"]), ("restrictederrorinfo", &["unknwnbase", "winnt", "wtypes"], &[]), ("rmxfguid", &[], &[]), + ("rtinfo", &["basetsd"], &[]), ("sapi", &["guiddef", "minwindef", "sapi53", "unknwnbase", "winnt"], &[]), ("sapi51", &["guiddef", "minwindef", "mmreg", "oaidl", "objidlbase", "rpcndr", "servprov", "unknwnbase", "windef", "winnt", "wtypes", "wtypesbase"], &[]), ("sapi53", &["guiddef", "minwindef", "oaidl", "sapi51", "unknwnbase", "urlmon", "winnt", "wtypes"], &[]), diff --git a/src/shared/ifmib.rs b/src/shared/ifmib.rs index 770f785d0..2be82e183 100644 --- a/src/shared/ifmib.rs +++ b/src/shared/ifmib.rs @@ -8,12 +8,11 @@ // #include use core::mem; use core::ptr; -use shared::basetsd::DWORD_PTR; use shared::ifdef::IF_INDEX; use shared::ipifcons::{IFTYPE, INTERNAL_IF_OPER_STATUS}; use shared::minwindef::DWORD; use shared::ntdef::{UCHAR, WCHAR}; -const ALIGN_SIZE: DWORD_PTR = 0x00000008; // from RTInfo.h +use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; STRUCT!{struct MIB_IFNUMBER { dwValue: DWORD, diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index 4612daf4c..efe925fae 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -3,27 +3,28 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -use shared::basetsd::{SIZE_T, PUINT8, UINT8, ULONG64}; +use shared::basetsd::{PUINT8, SIZE_T, UINT8, ULONG64}; use shared::guiddef::GUID; use shared::ifdef::{ IF_MAX_PHYS_ADDRESS_LENGTH, IF_MAX_STRING_SIZE, IF_OPER_STATUS, NET_IFINDEX, NET_IF_ACCESS_TYPE, NET_IF_ADMIN_STATUS, NET_IF_COMPARTMENT_ID, NET_IF_COMPARTMENT_SCOPE, - NET_IF_DIRECTION_TYPE, NET_IF_MEDIA_CONNECT_STATE, NET_IF_NETWORK_GUID, NET_LUID, PNET_IFINDEX, - PNET_IF_COMPARTMENT_ID, PNET_IF_COMPARTMENT_SCOPE, PNET_LUID, TUNNEL_TYPE, + NET_IF_CONNECTION_TYPE, NET_IF_DIRECTION_TYPE, NET_IF_MEDIA_CONNECT_STATE, NET_IF_NETWORK_GUID, + NET_LUID, PNET_IFINDEX, PNET_IF_COMPARTMENT_ID, PNET_IF_COMPARTMENT_SCOPE, PNET_LUID, + TUNNEL_TYPE, }; -use shared::minwindef::{BYTE, DWORD, PULONG, UCHAR, ULONG}; +use shared::minwindef::{BYTE, DWORD, PULONG, UCHAR, ULONG, USHORT}; use shared::nldef::{ NL_BANDWIDTH_INFORMATION, NL_DAD_STATE, NL_INTERFACE_OFFLOAD_ROD, NL_LINK_LOCAL_ADDRESS_BEHAVIOR, NL_NEIGHBOR_STATE, NL_PREFIX_ORIGIN, NL_ROUTER_DISCOVERY_BEHAVIOR, NL_ROUTE_ORIGIN, NL_ROUTE_PROTOCOL, NL_SUFFIX_ORIGIN, }; -use shared::ntddndis::{NDIS_IF_MAX_STRING_SIZE, NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; +use shared::ntddndis::{NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; use shared::ntdef::{ BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, VOID, WCHAR, }; -use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID}; -use shared::ws2ipdef::SOCKADDR_INET; -pub use um::winnt::ANYSIZE_ARRAY as ANY_SIZE; +use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID, ScopeLevelCount}; +use shared::ws2ipdef::{PSOCKADDR_IN6_PAIR, SOCKADDR_IN6, SOCKADDR_INET}; +const ANY_SIZE: usize = 1; pub type NETIO_STATUS = DWORD; pub type NETIOAPI_API = NETIO_STATUS; ENUM!{enum MIB_NOTIFICATION_TYPE { @@ -38,13 +39,13 @@ STRUCT!{struct MIB_IF_ROW2_InterfaceAndOperStatusFlags { }} BITFIELD!{MIB_IF_ROW2_InterfaceAndOperStatusFlags bitfield: BYTE [ HardwareInterface set_HardwareInterface[0..1], - FilterInterface set_FilterInterface: [1..2], - ConnectorPresent set_ConnectorPresent: [2..3], - NotAuthenticated set_NotAuthenticated: [3..4], - NotMediaConnected set_NotMediaConnected: [4..5], - Paused set_Paused: [5..6], - LowPower set_LowPower: [6..7], - EndPointInterface set_LowPower: [7..8], + FilterInterface set_FilterInterface[1..2], + ConnectorPresent set_ConnectorPresent[2..3], + NotAuthenticated set_NotAuthenticated[3..4], + NotMediaConnected set_NotMediaConnected[4..5], + Paused set_Paused[5..6], + LowPower set_LowPower[6..7], + EndPointInterface set_EndPointInterface[7..8], ]} STRUCT!{struct MIB_IF_ROW2 { InterfaceLuid: NET_LUID, @@ -60,8 +61,8 @@ STRUCT!{struct MIB_IF_ROW2 { TunnelType: TUNNEL_TYPE, // Tunnel Type, if Type = IF_TUNNEL. MediaType: NDIS_MEDIUM, PhysicalMediumType: NDIS_PHYSICAL_MEDIUM, - AccessType NET_IF_ACCESS_TYPE, - DirectionType NET_IF_DIRECTION_TYPE, + AccessType: NET_IF_ACCESS_TYPE, + DirectionType: NET_IF_DIRECTION_TYPE, InterfaceAndOperStatusFlags: MIB_IF_ROW2_InterfaceAndOperStatusFlags, OperStatus: IF_OPER_STATUS, AdminStatus: NET_IF_ADMIN_STATUS, @@ -95,9 +96,11 @@ STRUCT!{struct MIB_IF_TABLE2 { Table: [MIB_IF_ROW2; ANY_SIZE], }} pub type PMIB_IF_TABLE2 = *mut MIB_IF_TABLE2; -extern "system" pub fn GetIfEntry2( - Row: PMIB_IF_ROW2, -) -> NETIOAPI_API; +extern "system" { + pub fn GetIfEntry2( + Row: PMIB_IF_ROW2, + ) -> NETIOAPI_API; +} ENUM!{enum MIB_IF_ENTRY_LEVEL { MibIfEntryNormal = 0, MibIfEntryNormalWithoutStatistics = 2, @@ -148,7 +151,7 @@ STRUCT!{struct MIB_IPINTERFACE_ROW { PathMtuDiscoveryTimeout: ULONG, // Path MTU discovery timeout (in ms). LinkLocalAddressBehavior: NL_LINK_LOCAL_ADDRESS_BEHAVIOR, LinkLocalAddressTimeout: ULONG, // In ms. - ZoneIndices: [ULONG; ScopeLevelCount], // Zone part of a SCOPE_ID. + ZoneIndices: [ULONG; ScopeLevelCount as usize], // Zone part of a SCOPE_ID. SitePrefixLength: ULONG, Metric: ULONG, NlMtu: ULONG, @@ -370,7 +373,7 @@ STRUCT!{struct MIB_IPFORWARD_ROW2 { pub type PMIB_IPFORWARD_ROW2 = *mut MIB_IPFORWARD_ROW2; STRUCT!{struct MIB_IPFORWARD_TABLE2 { NumEntries: ULONG, - Table: [MIB_IPFORWARD_ROW2; ANY_SIZE] + Table: [MIB_IPFORWARD_ROW2; ANY_SIZE], }} pub type PMIB_IPFORWARD_TABLE2 = *mut MIB_IPFORWARD_TABLE2; FN!{stdcall PIPFORWARD_CHANGE_CALLBACK( @@ -393,7 +396,7 @@ extern "system" { AddressSortOptions: ULONG, BestRoute: PMIB_IPFORWARD_ROW2, BestSourceAddress: *mut SOCKADDR_INET, - ) - > NETIOAPI_API; + ) -> NETIOAPI_API; pub fn GetIpForwardEntry2( Row: PMIB_IPFORWARD_ROW2, ) -> NETIOAPI_API; @@ -417,8 +420,8 @@ extern "system" { } UNION!{union MIB_IPPATH_ROW_u { [u32; 1], - LastReachable: ULONG, // Milliseconds. - LastUnreachable: ULONG, // Milliseconds. + LastReachable LastReachable_mut: ULONG, // Milliseconds. + LastUnreachable LastUnreachable_mut: ULONG, // Milliseconds. }} STRUCT!{struct MIB_IPPATH_ROW { Source: SOCKADDR_INET, @@ -467,10 +470,10 @@ UNION!{union MIB_IPNET_ROW2_ReachabilityTime { }} STRUCT!{struct MIB_IPNET_ROW2 { Address: SOCKADDR_INET, - InterfaceIndex NET_IFINDEX, - InterfaceLuid NET_LUID, + InterfaceIndex: NET_IFINDEX, + InterfaceLuid: NET_LUID, PhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], - PhysicalAddressLength ULONG, + PhysicalAddressLength: ULONG, State: NL_NEIGHBOR_STATE, s: MIB_IPNET_ROW2_s, ReachabilityTime: MIB_IPNET_ROW2_ReachabilityTime, @@ -507,7 +510,7 @@ extern "system" { Row: PMIB_IPNET_ROW2, ) -> NETIOAPI_API; } -const MIB_INVALID_TEREDO_PORT_NUMBER: USHORT = 0; +pub const MIB_INVALID_TEREDO_PORT_NUMBER: USHORT = 0; FN!{stdcall PTEREDO_PORT_CHANGE_CALLBACK( CallerContext: PVOID, Port: USHORT, @@ -529,16 +532,15 @@ extern "system" { pub fn FreeMibTable( Memory: PVOID, ); - // FIXME: - // pub fn CreateSortedAddressPairs( - // const PSOCKADDR_IN6 SourceAddressList, - // ULONG SourceAddressCount, - // const PSOCKADDR_IN6 DestinationAddressList, - // ULONG DestinationAddressCount, - // ULONG AddressSortOptions, - // PSOCKADDR_IN6_PAIR *SortedAddressPairList, - // ULONG *SortedAddressPairCoun - // ) -> NETIOAPI_API; + pub fn CreateSortedAddressPairs( + SourceAddressList: *const SOCKADDR_IN6, + SourceAddressCount: ULONG, + DestinationAddressList: *const SOCKADDR_IN6, + DestinationAddressCount: ULONG, + AddressSortOptions: ULONG, + SortedAddressPairList: *mut PSOCKADDR_IN6_PAIR, + SortedAddressPairCount: *mut ULONG, + ) -> NETIOAPI_API; pub fn ConvertCompartmentGuidToId( CompartmentGuid: *const GUID, CompartmentId: PNET_IF_COMPARTMENT_ID, @@ -650,7 +652,7 @@ pub const DNS_SETTING_IPV6: ULONG64 = 0x0001; pub const DNS_SETTING_NAMESERVER: ULONG64 = 0x0002; pub const DNS_SETTING_SEARCHLIST: ULONG64 = 0x0004; pub const DNS_SETTING_REGISTRATION_ENABLED: ULONG64 = 0x0008; -pub const DNS_SETTING_REGISTER_ADAPTER_NAME: ULONG64 = 0x0010 +pub const DNS_SETTING_REGISTER_ADAPTER_NAME: ULONG64 = 0x0010; pub const DNS_SETTING_DOMAIN: ULONG64 = 0x0020; pub const DNS_SETTING_HOSTNAME: ULONG64 = 0x0040; pub const DNS_SETTINGS_ENABLE_LLMNR: ULONG64 = 0x0080; diff --git a/src/shared/nldef.rs b/src/shared/nldef.rs index ae897ebc5..2d2af0b52 100644 --- a/src/shared/nldef.rs +++ b/src/shared/nldef.rs @@ -4,8 +4,8 @@ // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. use shared::basetsd::ULONG64; -use shared::minwindef::{BYTE, ULONG}; -use shared::ntdef::BOOLEAN +use shared::minwindef::ULONG; +use shared::ntdef::BOOLEAN; ENUM!{enum NL_PREFIX_ORIGIN { IpPrefixOriginOther = 0, IpPrefixOriginManual = 1, @@ -31,7 +31,7 @@ ENUM!{enum NL_SUFFIX_ORIGIN { pub const NlsoOther: NL_SUFFIX_ORIGIN = IpSuffixOriginOther; pub const NlsoManual: NL_SUFFIX_ORIGIN = IpSuffixOriginManual; pub const NlsoWellKnown: NL_SUFFIX_ORIGIN = IpSuffixOriginWellKnown; -pub const NlsoDhcp: NL_SUFFIX_ORIGIN = IpSuffixOriginDhcp, +pub const NlsoDhcp: NL_SUFFIX_ORIGIN = IpSuffixOriginDhcp; pub const NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = IpSuffixOriginLinkLayerAddress; pub const NlsoRandom: NL_SUFFIX_ORIGIN = IpSuffixOriginRandom; ENUM!{enum NL_DAD_STATE { @@ -46,31 +46,6 @@ pub const NldsTentative: NL_DAD_STATE = IpDadStateTentative; pub const NldsDuplicate: NL_DAD_STATE = IpDadStateDuplicate; pub const NldsDeprecated: NL_DAD_STATE = IpDadStateDeprecated; pub const NldsPreferred: NL_DAD_STATE = IpDadStatePreferred; -ENUM!{enum NL_LINK_LOCAL_ADDRESS_BEHAVIOR { - LinkLocalAlwaysOff = 0, - LinkLocalDelayed = 1, - LinkLocalAlwaysOn = 2, - LinkLocalUnchanged = -1 -}} -ENUM!{enum NL_ROUTER_DISCOVERY_BEHAVIOR { - RouterDiscoveryDisabled = 0, - RouterDiscoveryEnabled = 1, - RouterDiscoveryDhcp = 2, - RouterDiscoveryUnchanged = -1, -}} -STRUCT!{struct NL_INTERFACE_OFFLOAD_ROD { - bitfield: BYTE, -}} -BITFIELD!{NL_INTERFACE_OFFLOAD_ROD bitfield: BYTE [ - NlChecksumSupported set_NlChecksumSupported[0..1], - NlOptionsSupported set_NlOptionsSupported [1..2], - TlDatagramChecksumSupported set_TlDatagramChecksumSupported: [2..3], - TlStreamChecksumSupported set_TlStreamChecksumSupported: [3..4], - TlStreamOptionsSupported set_TlStreamOptionsSupported: [4..5], - FastPathCompatible set_FastPathCompatible: [5..6], - TlLargeSendOffloadSupported set_TlLargeSendOffloadSupported: [6..7], - TlGiantSendOffloadSupported set_TlGiantSendOffloadSupported: [7..8] -]} pub const NL_MAX_METRIC_COMPONENT: ULONG = (1u32 << 31) - 1; ENUM!{enum NL_ROUTE_PROTOCOL { RouteProtocolOther = 1, @@ -170,12 +145,12 @@ ENUM!{enum NL_LINK_LOCAL_ADDRESS_BEHAVIOR { LinkLocalAlwaysOff = 0, LinkLocalDelayed = 1, LinkLocalAlwaysOn = 2, - LinkLocalUnchanged = -1, + LinkLocalUnchanged = -1i32 as u32, }} STRUCT!{struct NL_INTERFACE_OFFLOAD_ROD { - Bitfield: BOOLEAN, + bitfield: BOOLEAN, }} -BITFIELD!{NL_INTERFACE_OFFLOAD_ROD Bitfield: BOOLEAN [ +BITFIELD!{NL_INTERFACE_OFFLOAD_ROD bitfield: BOOLEAN [ NlChecksumSupported set_NlChecksumSupported[0..1], NlOptionsSupported set_NlOptionsSupported[1..2], TlDatagramChecksumSupported set_TlDatagramChecksumSupported[2..3], @@ -190,12 +165,12 @@ ENUM!{enum NL_ROUTER_DISCOVERY_BEHAVIOR { RouterDiscoveryDisabled = 0, RouterDiscoveryEnabled = 1, RouterDiscoveryDhcp = 2, - RouterDiscoveryUnchanged = -1, + RouterDiscoveryUnchanged = -1i32 as u32, }} ENUM!{enum NL_BANDWIDTH_FLAG { NlbwDisabled = 0, NlbwEnabled = 1, - NlbwUnchanged = -1, + NlbwUnchanged = -1i32 as u32, }} pub type PNL_BANDWIDTH_FLAG = *mut NL_BANDWIDTH_FLAG; STRUCT!{struct NL_PATH_BANDWIDTH_ROD { @@ -208,8 +183,8 @@ ENUM!{enum NL_NETWORK_CATEGORY { NetworkCategoryPublic = 0, NetworkCategoryPrivate = 1, NetworkCategoryDomainAuthenticated = 2, - NetworkCategoryUnchanged = -1, - NetworkCategoryUnknown = -1, + NetworkCategoryUnchanged = -1i32 as u32, + NetworkCategoryUnknown = -1i32 as u32, }} pub type PNL_NETWORK_CATEGORY = *mut NL_NETWORK_CATEGORY; ENUM!{enum NL_INTERFACE_NETWORK_CATEGORY_STATE { diff --git a/src/shared/udpmib.rs b/src/shared/udpmib.rs index c5fe32a7c..e730bbf9e 100644 --- a/src/shared/udpmib.rs +++ b/src/shared/udpmib.rs @@ -7,11 +7,11 @@ // #include use core::mem; use core::ptr; -use shared::basetsd::{DWORD64, DWORD_PTR}; +use shared::basetsd::DWORD64; use shared::in6addr::IN6_ADDR; use shared::minwindef::DWORD; use shared::ntdef::{INT, LARGE_INTEGER, UCHAR, ULONGLONG}; -const ALIGN_SIZE: DWORD_PTR = 0x00000008; // from RTInfo.h +use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; macro_rules! offset_of_table { diff --git a/src/shared/ws2ipdef.rs b/src/shared/ws2ipdef.rs index e888452c5..eaccade32 100644 --- a/src/shared/ws2ipdef.rs +++ b/src/shared/ws2ipdef.rs @@ -8,7 +8,7 @@ use ctypes::c_int; use shared::in6addr::IN6_ADDR; use shared::inaddr::IN_ADDR; use shared::minwindef::{ULONG, USHORT}; -use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID}; +use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID, SOCKADDR_IN}; pub const IFF_UP: ULONG = 0x00000001; pub const IFF_BROADCAST: ULONG = 0x00000002; pub const IFF_LOOPBACK: ULONG = 0x00000004; diff --git a/src/um/mod.rs b/src/um/mod.rs index 8ce4c9c2d..4276f982c 100644 --- a/src/um/mod.rs +++ b/src/um/mod.rs @@ -199,6 +199,7 @@ pub mod gl; #[cfg(feature = "restartmanager")] pub mod restartmanager; #[cfg(feature = "restrictederrorinfo")] pub mod restrictederrorinfo; #[cfg(feature = "rmxfguid")] pub mod rmxfguid; +#[cfg(feature = "rtinfo")] pub mod rtinfo; #[cfg(feature = "sapi")] pub mod sapi; #[cfg(feature = "sapi51")] pub mod sapi51; #[cfg(feature = "sapi53")] pub mod sapi53; diff --git a/src/um/rtinfo.rs b/src/um/rtinfo.rs new file mode 100644 index 000000000..7dd6aeb4b --- /dev/null +++ b/src/um/rtinfo.rs @@ -0,0 +1,7 @@ +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +use shared::basetsd::DWORD_PTR; +pub const ALIGN_SIZE: DWORD_PTR = 0x00000008; From 77cc4974a6d5a25bd363a580ba143a1e883f1574 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 14:51:32 +0800 Subject: [PATCH 06/26] avoid using keyword in macro --- src/shared/udpmib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/shared/udpmib.rs b/src/shared/udpmib.rs index e730bbf9e..28fa39d3c 100644 --- a/src/shared/udpmib.rs +++ b/src/shared/udpmib.rs @@ -15,8 +15,8 @@ use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; macro_rules! offset_of_table { - ($type:ty) => (unsafe { - &(*(ptr::null() as *const $type)).table[0] as *const _ as usize + ($container:ty) => (unsafe { + &(*(ptr::null() as *const $container)).table[0] as *const _ as usize }) } STRUCT!{struct MIB_UDPROW { From 0ac32b831732e9e1c568a452b5398a36e3d157e9 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 15:01:09 +0800 Subject: [PATCH 07/26] specify enum values --- src/shared/ifdef.rs | 6 +++--- src/shared/iprtrmib.rs | 26 +++++++++++++------------- src/shared/tcpestats.rs | 40 ++++++++++++++++++++-------------------- src/shared/tcpmib.rs | 16 ++++++++-------- src/um/iphlpapi.rs | 6 +++--- 5 files changed, 47 insertions(+), 47 deletions(-) diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index 0ebd3d46e..955c64116 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -151,9 +151,9 @@ pub type PNET_PHYSICAL_LOCATION = *mut NET_PHYSICAL_LOCATION; // pub type IF_PHYSICAL_ADDRESS = IF_PHYSICAL_ADDRESS_LH; // pub type PIF_PHYSICAL_ADDRESS = *mut IF_PHYSICAL_ADDRESS; ENUM!{enum IF_ADMINISTRATIVE_STATE { - IF_ADMINISTRATIVE_DISABLED, - IF_ADMINISTRATIVE_ENABLED, - IF_ADMINISTRATIVE_DEMANDDIAL, + IF_ADMINISTRATIVE_DISABLED = 0, + IF_ADMINISTRATIVE_ENABLED = 1, + IF_ADMINISTRATIVE_DEMANDDIAL = 2, }} pub type PIF_ADMINISTRATIVE_STATE = *mut IF_ADMINISTRATIVE_STATE; ENUM!{enum IF_OPER_STATUS { diff --git a/src/shared/iprtrmib.rs b/src/shared/iprtrmib.rs index ca667b9a5..8a3e891c3 100644 --- a/src/shared/iprtrmib.rs +++ b/src/shared/iprtrmib.rs @@ -21,25 +21,25 @@ STRUCT!{struct MIB_OPAQUE_QUERY { }} pub type PMIB_OPAQUE_QUERY = *mut MIB_OPAQUE_QUERY; ENUM!{enum TCP_TABLE_CLASS { - TCP_TABLE_BASIC_LISTENER, - TCP_TABLE_BASIC_CONNECTIONS, - TCP_TABLE_BASIC_ALL, - TCP_TABLE_OWNER_PID_LISTENER, - TCP_TABLE_OWNER_PID_CONNECTIONS, - TCP_TABLE_OWNER_PID_ALL, - TCP_TABLE_OWNER_MODULE_LISTENER, - TCP_TABLE_OWNER_MODULE_CONNECTIONS, - TCP_TABLE_OWNER_MODULE_ALL, + TCP_TABLE_BASIC_LISTENER = 0, + TCP_TABLE_BASIC_CONNECTIONS = 1, + TCP_TABLE_BASIC_ALL = 2, + TCP_TABLE_OWNER_PID_LISTENER = 3, + TCP_TABLE_OWNER_PID_CONNECTIONS = 4, + TCP_TABLE_OWNER_PID_ALL = 5, + TCP_TABLE_OWNER_MODULE_LISTENER = 6, + TCP_TABLE_OWNER_MODULE_CONNECTIONS = 7, + TCP_TABLE_OWNER_MODULE_ALL = 8, }} pub type PTCP_TABLE_CLASS = *mut TCP_TABLE_CLASS; ENUM!{enum UDP_TABLE_CLASS { - UDP_TABLE_BASIC, - UDP_TABLE_OWNER_PID, - UDP_TABLE_OWNER_MODULE, + UDP_TABLE_BASIC = 0, + UDP_TABLE_OWNER_PID = 1, + UDP_TABLE_OWNER_MODULE = 2, }} pub type PUDP_TABLE_CLASS = *mut UDP_TABLE_CLASS; ENUM!{enum TCPIP_OWNER_MODULE_INFO_CLASS { - TCPIP_OWNER_MODULE_INFO_BASIC, + TCPIP_OWNER_MODULE_INFO_BASIC = 0, }} pub type PTCPIP_OWNER_MODULE_INFO_CLASS = *mut TCPIP_OWNER_MODULE_INFO_CLASS; STRUCT!{struct TCPIP_OWNER_MODULE_BASIC_INFO { diff --git a/src/shared/tcpestats.rs b/src/shared/tcpestats.rs index 6c3917a53..7ddbd9645 100644 --- a/src/shared/tcpestats.rs +++ b/src/shared/tcpestats.rs @@ -7,21 +7,21 @@ use shared::basetsd::{SIZE_T, ULONG64}; use shared::ntdef::{BOOLEAN, UCHAR, ULONG}; ENUM!{enum TCP_ESTATS_TYPE { - TcpConnectionEstatsSynOpts, - TcpConnectionEstatsData, - TcpConnectionEstatsSndCong, - TcpConnectionEstatsPath, - TcpConnectionEstatsSendBuff, - TcpConnectionEstatsRec, - TcpConnectionEstatsObsRec, - TcpConnectionEstatsBandwidth, - TcpConnectionEstatsFineRtt, - TcpConnectionEstatsMaximum, + TcpConnectionEstatsSynOpts = 0, + TcpConnectionEstatsData = 1, + TcpConnectionEstatsSndCong = 2, + TcpConnectionEstatsPath = 3, + TcpConnectionEstatsSendBuff = 4, + TcpConnectionEstatsRec = 5, + TcpConnectionEstatsObsRec = 6, + TcpConnectionEstatsBandwidth = 7, + TcpConnectionEstatsFineRtt = 8, + TcpConnectionEstatsMaximum = 9, }} pub type PTCP_ESTATS_TYPE = *mut TCP_ESTATS_TYPE; ENUM!{enum TCP_BOOLEAN_OPTIONAL { TcpBoolOptDisabled = 0, - TcpBoolOptEnabled, + TcpBoolOptEnabled = 1, TcpBoolOptUnchanged = -1i32 as u32, }} pub type PTCP_BOOLEAN_OPTIONAL = *mut TCP_BOOLEAN_OPTIONAL; @@ -33,15 +33,15 @@ STRUCT!{struct TCP_ESTATS_SYN_OPTS_ROS_v0 { pub type PTCP_ESTATS_SYN_OPTS_ROS_v0 = *mut TCP_ESTATS_SYN_OPTS_ROS_v0; ENUM!{enum TCP_SOFT_ERROR { TcpErrorNone = 0, - TcpErrorBelowDataWindow, - TcpErrorAboveDataWindow, - TcpErrorBelowAckWindow, - TcpErrorAboveAckWindow, - TcpErrorBelowTsWindow, - TcpErrorAboveTsWindow, - TcpErrorDataChecksumError, - TcpErrorDataLengthError, - TcpErrorMaxSoftError, + TcpErrorBelowDataWindow = 1, + TcpErrorAboveDataWindow = 2, + TcpErrorBelowAckWindow = 3, + TcpErrorAboveAckWindow = 4, + TcpErrorBelowTsWindow = 5, + TcpErrorAboveTsWindow = 6, + TcpErrorDataChecksumError = 7, + TcpErrorDataLengthError = 8, + TcpErrorMaxSoftError = 9, }} pub type PTCP_SOFT_ERROR = *mut TCP_SOFT_ERROR; STRUCT!{struct TCP_ESTATS_DATA_ROD_v0 { diff --git a/src/shared/tcpmib.rs b/src/shared/tcpmib.rs index f6ad65c79..bca35d7b1 100644 --- a/src/shared/tcpmib.rs +++ b/src/shared/tcpmib.rs @@ -26,11 +26,11 @@ ENUM!{enum MIB_TCP_STATE { MIB_TCP_STATE_RESERVED = 100, }} ENUM!{enum TCP_CONNECTION_OFFLOAD_STATE { - TcpConnectionOffloadStateInHost, - TcpConnectionOffloadStateOffloading, - TcpConnectionOffloadStateOffloaded, - TcpConnectionOffloadStateUploading, - TcpConnectionOffloadStateMax, + TcpConnectionOffloadStateInHost = 0, + TcpConnectionOffloadStateOffloading = 1, + TcpConnectionOffloadStateOffloaded = 2, + TcpConnectionOffloadStateUploading = 3, + TcpConnectionOffloadStateMax = 4, }} pub type PTCP_CONNECTION_OFFLOAD_STATE = *mut TCP_CONNECTION_OFFLOAD_STATE; STRUCT!{struct MIB_TCPROW_LH { @@ -173,9 +173,9 @@ pub type PMIB_TCP6ROW_OWNER_MODULE = *mut MIB_TCP6ROW_OWNER_MODULE; // pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE; ENUM!{enum TCP_RTO_ALGORITHM { TcpRtoAlgorithmOther = 1, - TcpRtoAlgorithmConstant, - TcpRtoAlgorithmRsre, - TcpRtoAlgorithmVanj, + TcpRtoAlgorithmConstant = 2, + TcpRtoAlgorithmRsre = 3, + TcpRtoAlgorithmVanj = 4, MIB_TCP_RTO_OTHER = 1, MIB_TCP_RTO_CONSTANT = 2, MIB_TCP_RTO_RSRE = 3, diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index 7bec6d173..be546d490 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -34,9 +34,9 @@ use um::iptypes::{PFIXED_INFO, PIP_ADAPTER_ADDRESSES, PIP_ADAPTER_INFO, PIP_PER_ use um::minwinbase::{LPOVERLAPPED,OVERLAPPED}; ENUM!{enum NET_ADDRESS_FORMAT { NET_ADDRESS_FORMAT_UNSPECIFIED = 0, - NET_ADDRESS_DNS_NAME, - NET_ADDRESS_IPV4, - NET_ADDRESS_IPV6, + NET_ADDRESS_DNS_NAME = 1, + NET_ADDRESS_IPV4 = 2, + NET_ADDRESS_IPV6 = 3, }} pub const DNS_MAX_NAME_BUFFER_LENGTH: usize = 256; STRUCT!{struct NET_NAMED_ADDRESS { From c09eb9e3909f85d4852c11cbfb372446f9a22293 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 15:36:42 +0800 Subject: [PATCH 08/26] add missing functions in iphlpapi.h --- build.rs | 2 +- src/um/iphlpapi.rs | 80 +++++++++++++++++++++++++++++++++++++++------- 2 files changed, 69 insertions(+), 13 deletions(-) diff --git a/build.rs b/build.rs index 4620f92d7..782133cbe 100644 --- a/build.rs +++ b/build.rs @@ -214,7 +214,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("interlockedapi", &["minwindef", "winnt"], &["kernel32"]), ("ioapiset", &["basetsd", "minwinbase", "minwindef", "winnt"], &["kernel32"]), ("ipexport", &["basetsd", "in6addr", "ntdef"], &[]), - ("iphlpapi", &["basetsd", "ifmib", "ipexport", "ipmib", "iprtrmib", "iptypes", "minwinbase", "minwindef", "ntdef", "tcpmib", "udpmib", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("iphlpapi", &["basetsd", "ifmib", "ipexport", "ipmib", "iprtrmib", "iptypes", "minwinbase", "minwindef", "ntdef", "tcpestats", "tcpmib", "udpmib", "ws2def", "ws2ipdef"], &["iphlpapi"]), ("iptypes", &["basetsd", "corecrt", "guiddef", "ifdef", "ipifcons", "minwindef", "nldef", "ntdef", "ws2def"], &[]), ("jobapi", &["minwindef", "winnt"], &["kernel32"]), ("jobapi2", &["basetsd", "minwinbase", "minwindef", "ntdef", "winnt"], &["kernel32"]), diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index be546d490..ae664b5e7 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -14,10 +14,11 @@ use shared::ipmib::{ PMIB_IPNETROW, PMIB_IPNETTABLE, PMIB_IPSTATS }; use shared::iprtrmib::{TCPIP_OWNER_MODULE_INFO_CLASS, TCP_TABLE_CLASS, UDP_TABLE_CLASS}; -use shared::minwindef::{BOOL, BYTE, DWORD, LPDWORD, PDWORD, PULONG, UINT}; -use shared::ntdef::{HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, USHORT, WCHAR}; +use shared::minwindef::{BOOL, BYTE, DWORD, LPDWORD, PDWORD, PUCHAR, PULONG, UINT}; +use shared::ntdef::{HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, ULONGLONG, USHORT, WCHAR}; +use shared::tcpestats::TCP_ESTATS_TYPE; use shared::tcpmib::{ - PMIB_TCP6ROW_OWNER_MODULE, PMIB_TCP6TABLE, PMIB_TCP6TABLE2, PMIB_TCPROW, + PMIB_TCP6ROW, PMIB_TCP6ROW_OWNER_MODULE, PMIB_TCP6TABLE, PMIB_TCP6TABLE2, PMIB_TCPROW, PMIB_TCPROW_OWNER_MODULE, PMIB_TCPSTATS, PMIB_TCPSTATS2, PMIB_TCPTABLE, PMIB_TCPTABLE2 }; use shared::udpmib::{ @@ -27,10 +28,13 @@ use shared::udpmib::{ use shared::ws2def::{PSOCKADDR, SOCKADDR, SOCKADDR_IN}; use shared::ws2ipdef::SOCKADDR_IN6; use um::ipexport::{ - IPAddr, IPMask, IP_STATUS, PIP_ADAPTER_INDEX_MAP, PIP_INTERFACE_INFO, - PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS + IPAddr, IPMask, IP_STATUS, PIP_ADAPTER_INDEX_MAP, PIP_ADAPTER_ORDER_MAP, PIP_INTERFACE_INFO, + PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, +}; +use um::iptypes::{ + PFIXED_INFO, PIP_ADAPTER_ADDRESSES, PIP_ADAPTER_INFO, PIP_INTERFACE_NAME_INFO, + PIP_PER_ADAPTER_INFO, }; -use um::iptypes::{PFIXED_INFO, PIP_ADAPTER_ADDRESSES, PIP_ADAPTER_INFO, PIP_PER_ADAPTER_INFO}; use um::minwinbase::{LPOVERLAPPED,OVERLAPPED}; ENUM!{enum NET_ADDRESS_FORMAT { NET_ADDRESS_FORMAT_UNSPECIFIED = 0, @@ -126,6 +130,7 @@ extern "system" { SizePointer: PULONG, Order: BOOL, ) -> ULONG; + // Deprecated APIs, Added for documentation. // pub fn AllocateAndGetTcpExTableFromStack() -> DWORD; // pub fn AllocateAndGetUdpExTableFromStack() -> DWORD; pub fn GetTcp6Table( @@ -138,9 +143,48 @@ extern "system" { SizePointer: PULONG, Order: BOOL, ) -> ULONG; - // pub fn GetPerTcpConnectionEStats() -> ULONG; - // pub fn GetPerTcp6ConnectionEStats() -> ULONG; - // pub fn SetPerTcp6ConnectionEStats() -> ULONG; + pub fn GetPerTcpConnectionEStats( + Row: PMIB_TCPROW, + EstatsType: TCP_ESTATS_TYPE, + Rw: PUCHAR, + RwVersion: ULONG, + RwSize: ULONG, + Ros: PUCHAR, + RosVersion: ULONG, + RosSize: ULONG, + Rod: PUCHAR, + RodVersion: ULONG, + RodSize: ULONG, + ) -> ULONG; + pub fn SetPerTcpConnectionEStats( + Row: PMIB_TCPROW, + EstatsType: TCP_ESTATS_TYPE, + Rw: PUCHAR, + RwVersion: ULONG, + RwSize: ULONG, + Offset: ULONG, + ) -> ULONG; + pub fn GetPerTcp6ConnectionEStats( + Row: PMIB_TCP6ROW, + EstatsType: TCP_ESTATS_TYPE, + Rw: PUCHAR, + RwVersion: ULONG, + RwSize: ULONG, + Ros: PUCHAR, + RosVersion: ULONG, + RosSize: ULONG, + Rod: PUCHAR, + RodVersion: ULONG, + RodSize: ULONG, + ) -> ULONG; + pub fn SetPerTcp6ConnectionEStats( + Row: PMIB_TCP6ROW, + EstatsType: TCP_ESTATS_TYPE, + Rw: PUCHAR, + RwVersion: ULONG, + RwSize: ULONG, + Offset: ULONG, + ) -> ULONG; pub fn GetOwnerModuleFromTcp6Entry( pTcpEntry: PMIB_TCP6ROW_OWNER_MODULE, Class: TCPIP_OWNER_MODULE_INFO_CLASS, @@ -158,7 +202,13 @@ extern "system" { pBuffer: PVOID, pdwSize: PDWORD, ) -> DWORD; - // pub fn GetOwnerModuleFromPidAndInfo() -> DWORD; + pub fn GetOwnerModuleFromPidAndInfo( + ulPid: ULONG, + pInfo: *mut ULONGLONG, + Class: TCPIP_OWNER_MODULE_INFO_CLASS, + pBuffer: PVOID, + pdwSize: PDWORD, + ) -> DWORD; pub fn GetIpStatistics( Statistics: PMIB_IPSTATS, ) -> ULONG; @@ -250,7 +300,13 @@ extern "system" { pIPIfInfo: PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS, dwOutBufLen: PULONG, ) -> DWORD; - // pub fn NhpAllocateAndGetInterfaceInfoFromStack() -> DWORD; + pub fn NhpAllocateAndGetInterfaceInfoFromStack( + ppTable: *mut PIP_INTERFACE_NAME_INFO, + pdwCount: PDWORD, + bOrder: BOOL, + hHeap: HANDLE, + dwFlags: DWORD, + ) -> DWORD; pub fn GetBestInterface( dwDestAddr: IPAddr, pdwBestIfIndex: PDWORD, @@ -297,7 +353,7 @@ extern "system" { AdapterInfo: PIP_ADAPTER_INFO, SizePointer: PULONG, ) -> ULONG; - // pub fn GetAdapterOrderMap(VOID) -> PIP_ADAPTER_ORDER_MAP; + pub fn GetAdapterOrderMap() -> PIP_ADAPTER_ORDER_MAP; pub fn GetAdaptersAddresses( Family: ULONG, Flags: ULONG, From cac4b31d6c7a601c6318b93ea9151f7546525552 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 16:13:35 +0800 Subject: [PATCH 09/26] add missing struct & SIZEOF_* functions in tcpmib --- build.rs | 2 +- src/shared/ifdef.rs | 32 ++++++++--------- src/shared/tcpmib.rs | 70 ++++++++++++++++++++++++++++-------- src/um/ipexport.rs | 86 +++++++++++++++++++++----------------------- 4 files changed, 112 insertions(+), 78 deletions(-) diff --git a/build.rs b/build.rs index 782133cbe..ce0984202 100644 --- a/build.rs +++ b/build.rs @@ -78,7 +78,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("sspi", &["basetsd", "guiddef", "minwindef", "subauth", "wincred", "winnt"], &["credui", "secur32"]), ("stralign", &["vcruntime", "winnt"], &["kernel32"]), ("tcpestats", &["basetsd", "ntdef"], &[]), - ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), + ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef", "rtinfo"], &[]), ("transportsettingcommon", &["guiddef"], &[]), ("tvout", &["guiddef", "minwindef"], &[]), ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef", "rtinfo"], &[]), diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index 955c64116..734f35490 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -5,7 +5,7 @@ // except according to those terms. use shared::basetsd::{UINT16, UINT32, ULONG32, ULONG64}; use shared::guiddef::GUID; -use shared::ntdef::{BOOLEAN, ULONG, USHORT}; +use shared::ntdef::{BOOLEAN, UCHAR, ULONG, USHORT, WCHAR}; pub type NET_IF_COMPARTMENT_ID = UINT32; pub type PNET_IF_COMPARTMENT_ID = *mut NET_IF_COMPARTMENT_ID; pub const NET_IF_COMPARTMENT_ID_UNSPECIFIED: NET_IF_COMPARTMENT_ID = 0; @@ -132,24 +132,22 @@ STRUCT!{struct NET_PHYSICAL_LOCATION_LH { pub type PNET_PHYSICAL_LOCATION_LH = *mut NET_PHYSICAL_LOCATION_LH; pub const IF_MAX_STRING_SIZE: usize = 256; pub const IF_MAX_PHYS_ADDRESS_LENGTH: usize = 32; -// STRUCT!{struct IF_COUNTED_STRING_LH { -// // _Field_range_(0, (IF_MAX_STRING_SIZE + 1) * sizeof(WCHAR)) -// Length: USHORT, -// String: [WCHAR; IF_MAX_STRING_SIZE + 1], -// }} -// pub type PIF_COUNTED_STRING_LH = *mut IF_COUNTED_STRING_LH; -// STRUCT!{struct IF_PHYSICAL_ADDRESS_LH { -// // _Field_range_(0, IF_MAX_PHYS_ADDRESS_LENGTH) -// Length: USHORT, -// Address: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], -// }} -// pub type PIF_PHYSICAL_ADDRESS_LH = *mut IF_PHYSICAL_ADDRESS_LH; +STRUCT!{struct IF_COUNTED_STRING_LH { + Length: USHORT, // in -Bytes- + String: [WCHAR; IF_MAX_STRING_SIZE + 1], +}} +pub type PIF_COUNTED_STRING_LH = *mut IF_COUNTED_STRING_LH; +STRUCT!{struct IF_PHYSICAL_ADDRESS_LH { + Length: USHORT, + Address: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], +}} +pub type PIF_PHYSICAL_ADDRESS_LH = *mut IF_PHYSICAL_ADDRESS_LH; pub type NET_PHYSICAL_LOCATION = NET_PHYSICAL_LOCATION_LH; pub type PNET_PHYSICAL_LOCATION = *mut NET_PHYSICAL_LOCATION; -// pub type IF_COUNTED_STRING = IF_COUNTED_STRING_LH; -// pub type PIF_COUNTED_STRING = *mut IF_COUNTED_STRING; -// pub type IF_PHYSICAL_ADDRESS = IF_PHYSICAL_ADDRESS_LH; -// pub type PIF_PHYSICAL_ADDRESS = *mut IF_PHYSICAL_ADDRESS; +pub type IF_COUNTED_STRING = IF_COUNTED_STRING_LH; +pub type PIF_COUNTED_STRING = *mut IF_COUNTED_STRING; +pub type IF_PHYSICAL_ADDRESS = IF_PHYSICAL_ADDRESS_LH; +pub type PIF_PHYSICAL_ADDRESS = *mut IF_PHYSICAL_ADDRESS; ENUM!{enum IF_ADMINISTRATIVE_STATE { IF_ADMINISTRATIVE_DISABLED = 0, IF_ADMINISTRATIVE_ENABLED = 1, diff --git a/src/shared/tcpmib.rs b/src/shared/tcpmib.rs index bca35d7b1..f635459e0 100644 --- a/src/shared/tcpmib.rs +++ b/src/shared/tcpmib.rs @@ -4,12 +4,20 @@ // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. // #include +use core::mem; +use core::ptr; use shared::basetsd::DWORD64; use shared::in6addr::IN6_ADDR; use shared::minwindef::DWORD; use shared::ntdef::{LARGE_INTEGER, UCHAR, ULONGLONG}; +use um::rtinfo::ALIGN_SIZE; pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; const ANY_SIZE: usize = 1; +macro_rules! offset_of_table { + ($container:ty) => (unsafe { + &(*(ptr::null() as *const $container)).table[0] as *const _ as usize + }) +} ENUM!{enum MIB_TCP_STATE { MIB_TCP_STATE_CLOSED = 1, MIB_TCP_STATE_LISTEN = 2, @@ -49,15 +57,17 @@ STRUCT!{struct MIB_TCPROW_W2K { dwRemotePort: DWORD, }} pub type PMIB_TCPROW_W2K = *mut MIB_TCPROW_W2K; -// Windows Vista -// pub type MIB_TCPROW = MIB_TCPROW_LH; -pub type MIB_TCPROW = MIB_TCPROW_W2K; +pub type MIB_TCPROW = MIB_TCPROW_LH; pub type PMIB_TCPROW = *mut MIB_TCPROW; STRUCT!{struct MIB_TCPTABLE { dwNumEntries: DWORD, table: [MIB_TCPROW; ANY_SIZE], }} pub type PMIB_TCPTABLE = *mut MIB_TCPTABLE; +#[inline] +pub fn SIZEOF_TCPTABLE(num: usize) -> usize { + offset_of_table!(MIB_TCPTABLE) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_TCPROW2 { dwState: DWORD, dwLocalAddr: DWORD, @@ -73,6 +83,10 @@ STRUCT!{struct MIB_TCPTABLE2 { table: [MIB_TCPROW2; ANY_SIZE], }} pub type PMIB_TCPTABLE2 = *mut MIB_TCPTABLE2; +#[inline] +pub fn SIZEOF_TCPTABLE2(num: usize) -> usize { + offset_of_table!(MIB_TCPTABLE2) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_TCPROW_OWNER_PID { dwState: DWORD, dwLocalAddr: DWORD, @@ -87,6 +101,11 @@ STRUCT!{struct MIB_TCPTABLE_OWNER_PID { table: [MIB_TCPROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_TCPTABLE_OWNER_PID = *mut MIB_TCPTABLE_OWNER_PID; +#[inline] +pub fn SIZEOF_TCPTABLE_OWNER_PID(num: usize) -> usize { + offset_of_table!(MIB_TCPTABLE_OWNER_PID) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_TCPROW_OWNER_MODULE { dwState: DWORD, dwLocalAddr: DWORD, @@ -103,6 +122,11 @@ STRUCT!{struct MIB_TCPTABLE_OWNER_MODULE { table: [MIB_TCPROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_TCPTABLE_OWNER_MODULE = *mut MIB_TCPTABLE_OWNER_MODULE; +#[inline] +pub fn SIZEOF_TCPTABLE_OWNER_MODULE(num: usize) -> usize { + offset_of_table!(MIB_TCPTABLE_OWNER_MODULE) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_TCP6ROW { State: MIB_TCP_STATE, LocalAddr: IN6_ADDR, @@ -118,6 +142,10 @@ STRUCT!{struct MIB_TCP6TABLE { table: [MIB_TCP6ROW; ANY_SIZE], }} pub type PMIB_TCP6TABLE = *mut MIB_TCP6TABLE; +#[inline] +pub fn SIZEOF_TCP6TABLE(num: usize) -> usize { + offset_of_table!(MIB_TCP6TABLE) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_TCP6ROW2 { LocalAddr: IN6_ADDR, dwLocalScopeId: DWORD, @@ -135,6 +163,10 @@ STRUCT!{struct MIB_TCP6TABLE2 { table: [MIB_TCP6ROW2; ANY_SIZE], }} pub type PMIB_TCP6TABLE2 = *mut MIB_TCP6TABLE2; +#[inline] +pub fn SIZEOF_TCP6TABLE2(num: usize) -> usize { + offset_of_table!(MIB_TCP6TABLE2) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_TCP6ROW_OWNER_PID { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -146,12 +178,16 @@ STRUCT!{struct MIB_TCP6ROW_OWNER_PID { dwOwningPid: DWORD, }} pub type PMIB_TCP6ROW_OWNER_PID = *mut MIB_TCP6ROW_OWNER_PID; -// STRUCT!{struct MIB_TCP6TABLE_OWNER_PID { -// dwNumEntries: DWORD, -// // _Field_size_(dwNumEntries) -// table: [MIB_TCP6ROW_OWNER_PID; ANY_SIZE], -// }} -// pub type PMIB_TCP6TABLE_OWNER_PID = *mut MIB_TCP6TABLE_OWNER_PID; +STRUCT!{struct MIB_TCP6TABLE_OWNER_PID { + dwNumEntries: DWORD, + table: [MIB_TCP6ROW_OWNER_PID; ANY_SIZE], +}} +pub type PMIB_TCP6TABLE_OWNER_PID = *mut MIB_TCP6TABLE_OWNER_PID; +#[inline] +pub fn SIZEOF_TCP6TABLE_OWNER_PID(num: usize) -> usize { + offset_of_table!(MIB_TCP6TABLE_OWNER_PID) + num * mem::size_of::() + + ALIGN_SIZE +} STRUCT!{struct MIB_TCP6ROW_OWNER_MODULE { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -165,12 +201,16 @@ STRUCT!{struct MIB_TCP6ROW_OWNER_MODULE { OwningModuleInfo: [ULONGLONG; TCPIP_OWNING_MODULE_SIZE], }} pub type PMIB_TCP6ROW_OWNER_MODULE = *mut MIB_TCP6ROW_OWNER_MODULE; -// STRUCT!{struct MIB_TCP6TABLE_OWNER_MODULE { -// dwNumEntries: DWORD, -// // _Field_size_(dwNumEntries) -// table: [MIB_TCP6ROW_OWNER_MODULE; ANY_SIZE], -// }} -// pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE; +STRUCT!{struct MIB_TCP6TABLE_OWNER_MODULE { + dwNumEntries: DWORD, + table: [MIB_TCP6ROW_OWNER_MODULE; ANY_SIZE], +}} +pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE; +#[inline] +pub fn SIZEOF_TCP6TABLE_OWNER_MODULE(num: usize) -> usize { + offset_of_table!(MIB_TCP6TABLE_OWNER_MODULE) + num * mem::size_of::() + + ALIGN_SIZE +} ENUM!{enum TCP_RTO_ALGORITHM { TcpRtoAlgorithmOther = 1, TcpRtoAlgorithmConstant = 2, diff --git a/src/um/ipexport.rs b/src/um/ipexport.rs index 292e13513..a41c9de01 100644 --- a/src/um/ipexport.rs +++ b/src/um/ipexport.rs @@ -8,57 +8,53 @@ // #include use shared::basetsd::ULONG64; use shared::in6addr::in6_addr; -use shared::ntdef::{INT, UCHAR, ULONG, USHORT, WCHAR}; +use shared::ntdef::{INT, PUCHAR, PVOID, UCHAR, ULONG, USHORT, WCHAR}; pub const MAX_ADAPTER_NAME: usize = 128; pub const MAX_OPT_SIZE: usize = 40; pub type IPAddr = ULONG; pub type IPMask = ULONG; pub type IP_STATUS = ULONG; pub type IPv6Addr = in6_addr; -// STRUCT!{struct IP_OPTION_INFORMATION { -// Ttl: UCHAR, -// Tos: UCHAR, -// Flags: UCHAR, -// OptionsSize: UCHAR, -// // _Field_size_bytes_(OptionsSize) -// OptionsData: PUCHAR, -// }} -// pub type PIP_OPTION_INFORMATION = *mut IP_OPTION_INFORMATION; -// #if defined(_WIN64) -// STRUCT!{struct IP_OPTION_INFORMATION32 { -// Ttl: UCHAR, -// Tos: UCHAR, -// Flags: UCHAR, -// OptionsSize: UCHAR, -// // UCHAR * POINTER_32 OptionsData, -// }} -// pub type PIP_OPTION_INFORMATION32 = *mut IP_OPTION_INFORMATION32; -// #endif // _WIN64 -// STRUCT!{struct ICMP_ECHO_REPLY { -// Address: IPAddr, -// Status: ULONG, -// RoundTripTime: ULONG, -// DataSize: USHORT, -// Reserved: USHORT, -// // _Field_size_bytes_(DataSize) -// Data: PVOID, -// Options: ip_option_information, -// }} -// pub type PICMP_ECHO_REPLY = *mut ICMP_ECHO_REPLY; -// #if defined(_WIN64) -// STRUCT!{struct ICMP_ECHO_REPLY32 { -// Address: IPAddr, -// Status: ULONG, -// RoundTripTime: ULONG, -// DataSize: USHORT, -// Reserved: USHORT, -// // VOID * POINTER_32 Data; -// Options: ip_option_information32, -// }} -// pub type PICMP_ECHO_REPLY32 = *mut ICMP_ECHO_REPLY32; -// #endif // _WIN64 -// #if (NTDDI_VERSION >= NTDDI_WINXP) -// #include +STRUCT!{struct IP_OPTION_INFORMATION { + Ttl: UCHAR, + Tos: UCHAR, + Flags: UCHAR, + OptionsSize: UCHAR, + OptionsData: PUCHAR, +}} +pub type PIP_OPTION_INFORMATION = *mut IP_OPTION_INFORMATION; +#[cfg(target_arch = "x86_64")] +STRUCT!{struct IP_OPTION_INFORMATION32 { + Ttl: UCHAR, + Tos: UCHAR, + Flags: UCHAR, + OptionsSize: UCHAR, + OptionsData: *mut UCHAR, +}} +#[cfg(target_arch = "x86_64")] +pub type PIP_OPTION_INFORMATION32 = *mut IP_OPTION_INFORMATION32; +STRUCT!{struct ICMP_ECHO_REPLY { + Address: IPAddr, + Status: ULONG, + RoundTripTime: ULONG, + DataSize: USHORT, + Reserved: USHORT, + Data: PVOID, + Options: IP_OPTION_INFORMATION, +}} +pub type PICMP_ECHO_REPLY = *mut ICMP_ECHO_REPLY; +#[cfg(target_arch = "x86_64")] +STRUCT!{struct ICMP_ECHO_REPLY32 { + Address: IPAddr, + Status: ULONG, + RoundTripTime: ULONG, + DataSize: USHORT, + Reserved: USHORT, + Data: PVOID, + Options: IP_OPTION_INFORMATION32, +}} +#[cfg(target_arch = "x86_64")] +pub type PICMP_ECHO_REPLY32 = *mut ICMP_ECHO_REPLY32; STRUCT!{struct IPV6_ADDRESS_EX { sin6_port: USHORT, sin6_flowinfo: ULONG, From 583f6ad52ec8fe1da4d408fa0b9fa3c8ff843a24 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 16:51:27 +0800 Subject: [PATCH 10/26] use latest defines & add SIZEOF_* functions --- build.rs | 2 +- src/shared/ipmib.rs | 48 ++++++++++++++++++++++++++++----------------- 2 files changed, 31 insertions(+), 19 deletions(-) diff --git a/build.rs b/build.rs index ce0984202..ab88e526d 100644 --- a/build.rs +++ b/build.rs @@ -52,7 +52,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("inaddr", &["minwindef"], &[]), ("intsafe", &[], &[]), ("ipifcons", &["minwindef"], &[]), - ("ipmib", &["ifdef", "ifmib", "minwindef", "nldef", "ntdef"], &[]), + ("ipmib", &["ifdef", "ifmib", "minwindef", "nldef", "ntdef", "rtinfo"], &[]), ("iprtrmib", &["ipmib", "minwindef", "ntdef"], &[]), ("ks", &[], &[]), ("ksmedia", &["minwindef"], &[]), diff --git a/src/shared/ipmib.rs b/src/shared/ipmib.rs index caa0179f4..e4292991e 100644 --- a/src/shared/ipmib.rs +++ b/src/shared/ipmib.rs @@ -3,15 +3,20 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -// #include -// #include -// #include +use core::mem; +use core::ptr; use shared::ifdef::IF_INDEX; use shared::ifmib::MAXLEN_PHYSADDR; use shared::minwindef::DWORD; use shared::nldef::NL_ROUTE_PROTOCOL; use shared::ntdef::{PVOID, UCHAR, ULONG, USHORT}; +use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; +macro_rules! offset_of_table { + ($container:ty) => (unsafe { + &(*(ptr::null() as *const $container)).table[0] as *const _ as usize + }) +} STRUCT!{struct MIB_IPADDRROW_XP { dwAddr: DWORD, dwIndex: IF_INDEX, @@ -32,15 +37,17 @@ STRUCT!{struct MIB_IPADDRROW_W2K { unused2: USHORT, }} pub type PMIB_IPADDRROW_W2K = *mut MIB_IPADDRROW_W2K; -// Windows XP -// pub type MIB_IPADDRROW = MIB_IPADDRROW_XP; -pub type MIB_IPADDRROW = MIB_IPADDRROW_W2K; +pub type MIB_IPADDRROW = MIB_IPADDRROW_XP; pub type PMIB_IPADDRROW = *mut MIB_IPADDRROW; STRUCT!{struct MIB_IPADDRTABLE { dwNumEntries: DWORD, table: [MIB_IPADDRROW; ANY_SIZE], }} pub type PMIB_IPADDRTABLE = *mut MIB_IPADDRTABLE; +#[inline] +pub fn SIZEOF_IPADDRTABLE(num: usize) -> usize { + offset_of_table!(MIB_IPADDRTABLE) + num * mem::size_of::() + ALIGN_SIZE +} STRUCT!{struct MIB_IPFORWARDNUMBER { dwValue: DWORD, }} @@ -74,6 +81,10 @@ STRUCT!{struct MIB_IPFORWARDTABLE { table: [MIB_IPFORWARDROW; ANY_SIZE], }} pub type PMIB_IPFORWARDTABLE = *mut MIB_IPFORWARDTABLE; +#[inline] +pub fn SIZEOF_IPFORWARDTABLE(num: usize) -> usize { + offset_of_table!(MIB_IPFORWARDTABLE) + num * mem::size_of::() + ALIGN_SIZE +} ENUM!{enum MIB_IPNET_TYPE { MIB_IPNET_TYPE_OTHER = 1, MIB_IPNET_TYPE_INVALID = 2, @@ -96,15 +107,17 @@ STRUCT!{struct MIB_IPNETROW_W2K { dwType: DWORD, }} pub type PMIB_IPNETROW_W2K = *mut MIB_IPNETROW_W2K; -// Windows XP -// pub type MIB_IPNETROW = MIB_IPNETROW_LH; -pub type MIB_IPNETROW = MIB_IPNETROW_W2K; +pub type MIB_IPNETROW = MIB_IPNETROW_LH; pub type PMIB_IPNETROW = *mut MIB_IPNETROW; STRUCT!{struct MIB_IPNETTABLE { dwNumEntries: DWORD, table: [MIB_IPNETROW; ANY_SIZE], }} pub type PMIB_IPNETTABLE = *mut MIB_IPNETTABLE; +#[inline] +pub fn SIZEOF_IPNETTABLE(num: usize) -> usize { + offset_of_table!(MIB_IPNETTABLE) + num * mem::size_of::() + ALIGN_SIZE +} ENUM!{enum MIB_IPSTATS_FORWARDING { MIB_IP_FORWARDING = 1, MIB_IP_NOT_FORWARDING = 2, @@ -162,9 +175,7 @@ STRUCT!{struct MIB_IPSTATS_W2K { dwNumRoutes: DWORD, }} pub type PMIB_IPSTATS_W2K = *mut MIB_IPSTATS_W2K; -// Windows XP -// pub type MIB_IPSTATS = MIB_IPSTATS_LH; -pub type MIB_IPSTATS = MIB_IPSTATS_W2K; +pub type MIB_IPSTATS = MIB_IPSTATS_LH; pub type PMIB_IPSTATS = *mut MIB_IPSTATS; STRUCT!{struct MIBICMPSTATS { dwMsgs: DWORD, @@ -253,9 +264,7 @@ STRUCT!{struct MIB_IPMCAST_OIF_W2K { dwReserved: DWORD, }} pub type PMIB_IPMCAST_OIF_W2K = *mut MIB_IPMCAST_OIF_W2K; -// Windows XP -// pub type MIB_IPMCAST_OIF = MIB_IPMCAST_OIF_XP; -pub type MIB_IPMCAST_OIF = MIB_IPMCAST_OIF_W2K; +pub type MIB_IPMCAST_OIF = MIB_IPMCAST_OIF_XP; pub type PMIB_IPMCAST_OIF = *mut MIB_IPMCAST_OIF; STRUCT!{struct MIB_IPMCAST_MFE { dwGroup: DWORD, @@ -301,9 +310,7 @@ STRUCT!{struct MIB_IPMCAST_OIF_STATS_W2K { ulOutDiscards: ULONG, }} pub type PMIB_IPMCAST_OIF_STATS_W2K = *mut MIB_IPMCAST_OIF_STATS_W2K; -// Windows Vista -// pub type MIB_IPMCAST_OIF_STATS = MIB_IPMCAST_OIF_STATS_LH; -pub type MIB_IPMCAST_OIF_STATS = MIB_IPMCAST_OIF_STATS_W2K; +pub type MIB_IPMCAST_OIF_STATS = MIB_IPMCAST_OIF_STATS_LH; pub type PMIB_IPMCAST_OIF_STATS = *mut MIB_IPMCAST_OIF_STATS; STRUCT!{struct MIB_IPMCAST_MFE_STATS { dwGroup: DWORD, @@ -382,3 +389,8 @@ STRUCT!{struct MIB_IPMCAST_IF_TABLE { table: [MIB_IPMCAST_IF_ENTRY; ANY_SIZE], }} pub type PMIB_IPMCAST_IF_TABLE = *mut MIB_IPMCAST_IF_TABLE; +#[inline] +pub fn SIZEOF_MCAST_IF_TABLE(num: usize) -> usize { + offset_of_table!(MIB_IPMCAST_IF_TABLE) + num * mem::size_of::() + + ALIGN_SIZE +} From 8186c4aa9dd41125c0e2068dde7af351abe0ac26 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 19:24:29 +0800 Subject: [PATCH 11/26] add missing parts and fix naming, sizing, packing issues --- build.rs | 2 +- src/shared/iprtrmib.rs | 4 +- src/um/ipexport.rs | 6 +- src/um/iphlpapi.rs | 122 ++++++++++++++++++++++++++++++++--------- src/um/iptypes.rs | 20 +++---- 5 files changed, 111 insertions(+), 43 deletions(-) diff --git a/build.rs b/build.rs index ab88e526d..7481a0b9e 100644 --- a/build.rs +++ b/build.rs @@ -214,7 +214,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("interlockedapi", &["minwindef", "winnt"], &["kernel32"]), ("ioapiset", &["basetsd", "minwinbase", "minwindef", "winnt"], &["kernel32"]), ("ipexport", &["basetsd", "in6addr", "ntdef"], &[]), - ("iphlpapi", &["basetsd", "ifmib", "ipexport", "ipmib", "iprtrmib", "iptypes", "minwinbase", "minwindef", "ntdef", "tcpestats", "tcpmib", "udpmib", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("iphlpapi", &["basetsd", "ifdef", "ifmib", "ipexport", "ipmib", "iprtrmib", "iptypes", "minwinbase", "minwindef", "ntdef", "tcpestats", "tcpmib", "udpmib", "ws2def", "ws2ipdef"], &["iphlpapi"]), ("iptypes", &["basetsd", "corecrt", "guiddef", "ifdef", "ipifcons", "minwindef", "nldef", "ntdef", "ws2def"], &[]), ("jobapi", &["minwindef", "winnt"], &["kernel32"]), ("jobapi2", &["basetsd", "minwinbase", "minwindef", "ntdef", "winnt"], &["kernel32"]), diff --git a/src/shared/iprtrmib.rs b/src/shared/iprtrmib.rs index 8a3e891c3..cc47767fe 100644 --- a/src/shared/iprtrmib.rs +++ b/src/shared/iprtrmib.rs @@ -113,13 +113,13 @@ STRUCT!{struct MIB_ROUTESTATE { bRoutesSetToStack: BOOL, }} pub type PMIB_ROUTESTATE = *mut MIB_ROUTESTATE; -UNION!{union MIB_OPAQUE_INFO_Value { +UNION!{union MIB_OPAQUE_INFO_u { [u64; 1], ullAlign ullAlign_mut: ULONGLONG, rgbyData rgbyData_mut: [BYTE; 1], }} STRUCT!{struct MIB_OPAQUE_INFO { dwId: DWORD, - Value: MIB_OPAQUE_INFO_Value, + u: MIB_OPAQUE_INFO_u, }} pub type PMIB_OPAQUE_INFO = *mut MIB_OPAQUE_INFO; diff --git a/src/um/ipexport.rs b/src/um/ipexport.rs index a41c9de01..32511622c 100644 --- a/src/um/ipexport.rs +++ b/src/um/ipexport.rs @@ -29,7 +29,7 @@ STRUCT!{struct IP_OPTION_INFORMATION32 { Tos: UCHAR, Flags: UCHAR, OptionsSize: UCHAR, - OptionsData: *mut UCHAR, + OptionsData: u32, // UCHAR * POINTER_32 }} #[cfg(target_arch = "x86_64")] pub type PIP_OPTION_INFORMATION32 = *mut IP_OPTION_INFORMATION32; @@ -50,12 +50,12 @@ STRUCT!{struct ICMP_ECHO_REPLY32 { RoundTripTime: ULONG, DataSize: USHORT, Reserved: USHORT, - Data: PVOID, + Data: u32, // VOID * POINTER_32 Options: IP_OPTION_INFORMATION32, }} #[cfg(target_arch = "x86_64")] pub type PICMP_ECHO_REPLY32 = *mut ICMP_ECHO_REPLY32; -STRUCT!{struct IPV6_ADDRESS_EX { +STRUCT!{#[repr(packed)] struct IPV6_ADDRESS_EX { sin6_port: USHORT, sin6_flowinfo: ULONG, sin6_addr: [USHORT; 8], diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index ae664b5e7..42e2d2149 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -7,7 +7,8 @@ // #include // #include // #include -use shared::basetsd::PULONG64; +use shared::basetsd::{PULONG64, ULONG64}; +use shared::ifdef::NET_LUID; use shared::ifmib::{PMIB_IFROW, PMIB_IFTABLE}; use shared::ipmib::{ PMIB_ICMP, PMIB_ICMP_EX, PMIB_IPADDRTABLE, PMIB_IPFORWARDROW, PMIB_IPFORWARDTABLE, @@ -15,7 +16,9 @@ use shared::ipmib::{ }; use shared::iprtrmib::{TCPIP_OWNER_MODULE_INFO_CLASS, TCP_TABLE_CLASS, UDP_TABLE_CLASS}; use shared::minwindef::{BOOL, BYTE, DWORD, LPDWORD, PDWORD, PUCHAR, PULONG, UINT}; -use shared::ntdef::{HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, ULONGLONG, USHORT, WCHAR}; +use shared::ntdef::{ + BOOLEAN, HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, ULONGLONG, USHORT, VOID, WCHAR, +}; use shared::tcpestats::TCP_ESTATS_TYPE; use shared::tcpmib::{ PMIB_TCP6ROW, PMIB_TCP6ROW_OWNER_MODULE, PMIB_TCP6TABLE, PMIB_TCP6TABLE2, PMIB_TCPROW, @@ -36,29 +39,6 @@ use um::iptypes::{ PIP_PER_ADAPTER_INFO, }; use um::minwinbase::{LPOVERLAPPED,OVERLAPPED}; -ENUM!{enum NET_ADDRESS_FORMAT { - NET_ADDRESS_FORMAT_UNSPECIFIED = 0, - NET_ADDRESS_DNS_NAME = 1, - NET_ADDRESS_IPV4 = 2, - NET_ADDRESS_IPV6 = 3, -}} -pub const DNS_MAX_NAME_BUFFER_LENGTH: usize = 256; -STRUCT!{struct NET_NAMED_ADDRESS { - Address: [WCHAR; DNS_MAX_NAME_BUFFER_LENGTH], - Port: [WCHAR; 6], -}} -UNION!{union NET_ADDRESS { - [u8; 256], - NamedAddress NamedAddress_mut: NET_NAMED_ADDRESS, // [u16; 6] + [u16; ] - Ipv4Address Ipv4Address_mut: SOCKADDR_IN, // [u8; 4] - Ipv6Address Ipv6Address_mut: SOCKADDR_IN6, // [u8; 16] - IpAddress IpAddress_mut: SOCKADDR, // [u8; 16] -}} -STRUCT!{struct NET_ADDRESS_INFO { - Format: NET_ADDRESS_FORMAT, - Address: NET_ADDRESS, -}} -pub type PNET_ADDRESS_INFO = *mut NET_ADDRESS_INFO; extern "system" { pub fn GetNumberOfInterfaces( pdwNumIf: PDWORD @@ -366,6 +346,73 @@ extern "system" { pPerAdapterInfo: PIP_PER_ADAPTER_INFO, pOutBufLen: PULONG, ) -> DWORD; +} +STRUCT!{struct INTERFACE_TIMESTAMP_CAPABILITY_FLAGS { + PtpV2OverUdpIPv4EventMsgReceiveHw: BOOLEAN, + PtpV2OverUdpIPv4AllMsgReceiveHw: BOOLEAN, + PtpV2OverUdpIPv4EventMsgTransmitHw: BOOLEAN, + PtpV2OverUdpIPv4AllMsgTransmitHw: BOOLEAN, + PtpV2OverUdpIPv6EventMsgReceiveHw: BOOLEAN, + PtpV2OverUdpIPv6AllMsgReceiveHw: BOOLEAN, + PtpV2OverUdpIPv6EventMsgTransmitHw: BOOLEAN, + PtpV2OverUdpIPv6AllMsgTransmitHw: BOOLEAN, + AllReceiveHw: BOOLEAN, + AllTransmitHw: BOOLEAN, + TaggedTransmitHw: BOOLEAN, + AllReceiveSw: BOOLEAN, + AllTransmitSw: BOOLEAN, + TaggedTransmitSw: BOOLEAN, +}} +pub type PINTERFACE_TIMESTAMP_CAPABILITY_FLAGS = *mut INTERFACE_TIMESTAMP_CAPABILITY_FLAGS; +STRUCT!{struct INTERFACE_TIMESTAMP_CAPABILITIES { + Version: ULONG, + HardwareClockFrequencyHz: ULONG64, + CrossTimestamp: BOOLEAN, + Reserved1: ULONG64, + Reserved2: ULONG64, + TimestampFlags: INTERFACE_TIMESTAMP_CAPABILITY_FLAGS, +}} +pub type PINTERFACE_TIMESTAMP_CAPABILITIES = *mut INTERFACE_TIMESTAMP_CAPABILITIES; +STRUCT!{struct INTERFACE_HARDWARE_CROSSTIMESTAMP { + Version: ULONG, + Flags: ULONG, + SystemTimestamp1: ULONG64, + HardwareClockTimestamp: ULONG64, + SystemTimestamp2: ULONG64, +}} +pub type PINTERFACE_HARDWARE_CROSSTIMESTAMP = *mut INTERFACE_HARDWARE_CROSSTIMESTAMP; +STRUCT!{struct HIFTIMESTAMPCHANGE__ { + unused: i32, +}} +pub type HIFTIMESTAMPCHANGE = *mut HIFTIMESTAMPCHANGE__; +extern "system" { + pub fn GetInterfaceCurrentTimestampCapabilities( + InterfaceLuid: *const NET_LUID, + TimestampCapabilite: PINTERFACE_TIMESTAMP_CAPABILITIES, + ) -> DWORD; + pub fn GetInterfaceHardwareTimestampCapabilities( + InterfaceLuid: *const NET_LUID, + TimestampCapabilite: PINTERFACE_TIMESTAMP_CAPABILITIES, + ) -> DWORD; + pub fn CaptureInterfaceHardwareCrossTimestamp( + InterfaceLuid: *const NET_LUID, + CrossTimestamp: PINTERFACE_HARDWARE_CROSSTIMESTAMP, + ) -> DWORD; +} +FN!{stdcall INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK( + CallerContext: PVOID, +) -> VOID} +pub type PINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK = *mut + INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK; +extern "system" { + pub fn NotifyIfTimestampConfigChange( + CallerContext: PVOID, + Callback: PINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK, + NotificationHandle: *mut HIFTIMESTAMPCHANGE, + ) -> DWORD; + pub fn CancelIfTimestampConfigChange( + NotificationHandle: HIFTIMESTAMPCHANGE, + ); pub fn IpReleaseAddress( AdapterInfo: PIP_ADAPTER_INDEX_MAP, ) -> DWORD; @@ -441,6 +488,31 @@ extern "system" { NumberOfPorts: USHORT, Token: PULONG64, ) -> ULONG; +} +ENUM!{enum NET_ADDRESS_FORMAT { + NET_ADDRESS_FORMAT_UNSPECIFIED = 0, + NET_ADDRESS_DNS_NAME = 1, + NET_ADDRESS_IPV4 = 2, + NET_ADDRESS_IPV6 = 3, +}} +pub const DNS_MAX_NAME_BUFFER_LENGTH: usize = 256; +STRUCT!{struct NET_ADDRESS_INFO_u_s { + Address: [WCHAR; DNS_MAX_NAME_BUFFER_LENGTH], + Port: [WCHAR; 6], +}} +UNION!{union NET_ADDRESS_INFO_u { + [u32; 131], + NamedAddress NamedAddress_mut: NET_ADDRESS_INFO_u_s, + Ipv4Address Ipv4Address_mut: SOCKADDR_IN, + Ipv6Address Ipv6Address_mut: SOCKADDR_IN6, + IpAddress IpAddress_mut: SOCKADDR, +}} +STRUCT!{struct NET_ADDRESS_INFO { + Format: NET_ADDRESS_FORMAT, + u: NET_ADDRESS_INFO_u, +}} +pub type PNET_ADDRESS_INFO = *mut NET_ADDRESS_INFO; +extern "system" { // #if defined (_WS2DEF_) && defined (_WS2IPDEF_) && defined(_WINDNS_INCLUDED_) pub fn ParseNetworkString( NetworkString: *const *mut WCHAR, diff --git a/src/um/iptypes.rs b/src/um/iptypes.rs index 93a342b84..31287a633 100644 --- a/src/um/iptypes.rs +++ b/src/um/iptypes.rs @@ -234,19 +234,19 @@ pub const IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED: DWORD = 0x00000040; pub const IP_ADAPTER_IPV4_ENABLED: DWORD = 0x00000080; pub const IP_ADAPTER_IPV6_ENABLED: DWORD = 0x00000100; pub const IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG: DWORD = 0x00000200; -STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_u1_s { +STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_u_s { Length: ULONG, IfIndex: IF_INDEX, }} -UNION!{union IP_ADAPTER_ADDRESSES_LH_u1 { +UNION!{union IP_ADAPTER_ADDRESSES_LH_u { [u64; 1], Alignment Alignment_mut: ULONGLONG, - s s_mut: IP_ADAPTER_ADDRESSES_LH_u1_s, + s s_mut: IP_ADAPTER_ADDRESSES_LH_u_s, }} -STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_u2_s { +STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_s { bitfield: ULONG, }} -BITFIELD!{IP_ADAPTER_ADDRESSES_LH_u2_s bitfield: ULONG [ +BITFIELD!{IP_ADAPTER_ADDRESSES_LH_s bitfield: ULONG [ DdnsEnabled set_DdnsEnabled[0..1], RegisterAdapterSuffix set_RegisterAdapterSuffix[1..2], Dhcpv4Enabled set_Dhcpv4Enabled[2..3], @@ -257,14 +257,10 @@ BITFIELD!{IP_ADAPTER_ADDRESSES_LH_u2_s bitfield: ULONG [ Ipv4Enabled set_Ipv4Enabled[7..8], Ipv6Enabled set_Ipv6Enabled[8..9], Ipv6ManagedAddressConfigurationSupported set_Ipv6ManagedAddressConfigurationSupported[9..10], + Reserved set_Reserved[10..32], ]} -UNION!{union IP_ADAPTER_ADDRESSES_LH_u2 { - [u64; 1], - Flags Flags_mut: ULONG, - s s_mut: IP_ADAPTER_ADDRESSES_LH_u2_s, -}} STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { - u1: IP_ADAPTER_ADDRESSES_LH_u1, + u: IP_ADAPTER_ADDRESSES_LH_u, Next: *mut IP_ADAPTER_ADDRESSES_LH, AdapterName: PCHAR, FirstUnicastAddress: PIP_ADAPTER_UNICAST_ADDRESS_LH, @@ -276,7 +272,7 @@ STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { FriendlyName: PWCHAR, PhysicalAddress: [BYTE; MAX_ADAPTER_ADDRESS_LENGTH], PhysicalAddressLength: ULONG, - u2: IP_ADAPTER_ADDRESSES_LH_u2, + s: IP_ADAPTER_ADDRESSES_LH_s, Mtu: ULONG, IfType: IFTYPE, OperStatus: IF_OPER_STATUS, From 385fbce0cdbd6d3faa18b6dc68273bca2c38471b Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 27 Aug 2019 19:24:48 +0800 Subject: [PATCH 12/26] add tests --- tests/structs_x86.rs | 382 ++++++++++++++++++++++++++++++++++++++- tests/structs_x86_64.rs | 386 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 764 insertions(+), 4 deletions(-) diff --git a/tests/structs_x86.rs b/tests/structs_x86.rs index 00b472869..4e7b0f1d0 100644 --- a/tests/structs_x86.rs +++ b/tests/structs_x86.rs @@ -614,6 +614,28 @@ fn shared_ifdef() { use winapi::shared::ifdef::*; assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 516); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 34); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 216); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "ifmib")] #[test] +fn shared_ifmib() { + use winapi::shared::ifmib::*; + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 860); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 864); + assert_eq!(align_of::(), 4); } #[cfg(feature = "in6addr")] #[test] fn shared_in6addr() { @@ -635,6 +657,100 @@ fn shared_inaddr() { assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); } +#[cfg(feature = "ipmib")] #[test] +fn shared_ipmib() { + use winapi::shared::ipmib::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 52); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1032); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 2064); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 76); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "iprtrmib")] #[test] +fn shared_iprtrmib() { + use winapi::shared::iprtrmib::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 524); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 68); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "ktmtypes")] #[test] fn shared_ktmtypes() { use winapi::shared::ktmtypes::*; @@ -721,6 +837,68 @@ fn shared_mstcpip() { assert_eq!(size_of::(), 1); assert_eq!(align_of::(), 1); } +#[cfg(feature = "netioapi")] #[test] +fn shared_netioapi() { + use winapi::shared::netioapi::*; + assert_eq!(size_of::(), 1352); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1360); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 136); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "nldef")] #[test] +fn shared_nldef() { + use winapi::shared::nldef::*; + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "ntddscsi")] #[test] fn shared_ntddscsi() { use winapi::shared::ntddscsi::*; @@ -1105,6 +1283,88 @@ fn shared_sspi() { assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 4); } +#[cfg(feature = "tcpestats")] #[test] +fn shared_tcpestats() { + use winapi::shared::tcpestats::*; + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "tcpmib")] #[test] +fn shared_tcpmib() { + use winapi::shared::tcpmib::*; + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 52); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 192); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 200); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "transportsettingcommon")] #[test] fn shared_transportsettingcommon() { use winapi::shared::transportsettingcommon::*; @@ -1117,6 +1377,38 @@ fn shared_tvout() { assert_eq!(size_of::(), 356); assert_eq!(align_of::(), 4); } +#[cfg(feature = "udpmib")] #[test] +fn shared_udpmib() { + use winapi::shared::udpmib::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "usb")] #[test] fn shared_usb() { use winapi::shared::usb::*; @@ -1414,12 +1706,20 @@ fn shared_ws2def() { #[cfg(feature = "ws2ipdef")] #[test] fn shared_ws2ipdef() { use winapi::shared::ws2ipdef::*; + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 28); - assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); } #[cfg(feature = "wtypes")] #[test] fn shared_wtypes() { @@ -3589,6 +3889,84 @@ fn um_http() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); } +#[cfg(feature = "ipexport")] #[test] +fn um_ipexport() { + use winapi::um::ipexport::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 26); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 260); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 264); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "iphlpapi")] #[test] +fn um_iphlpapi() { + use winapi::um::iphlpapi::*; + assert_eq!(size_of::(), 14); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 528); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "iptypes")] #[test] +fn um_iptypes() { + use winapi::um::iptypes::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 648); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 516); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 376); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 52); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 584); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 44); + assert_eq!(align_of::(), 4); +} #[cfg(feature = "jobapi2")] #[test] fn um_jobapi2() { use winapi::um::jobapi2::*; diff --git a/tests/structs_x86_64.rs b/tests/structs_x86_64.rs index 901fd8cdd..2340887d6 100644 --- a/tests/structs_x86_64.rs +++ b/tests/structs_x86_64.rs @@ -611,6 +611,28 @@ fn shared_ifdef() { use winapi::shared::ifdef::*; assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 516); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 34); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 216); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "ifmib")] #[test] +fn shared_ifmib() { + use winapi::shared::ifmib::*; + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 860); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 864); + assert_eq!(align_of::(), 4); } #[cfg(feature = "in6addr")] #[test] fn shared_in6addr() { @@ -632,6 +654,100 @@ fn shared_inaddr() { assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); } +#[cfg(feature = "ipmib")] #[test] +fn shared_ipmib() { + use winapi::shared::ipmib::*; + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 52); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1032); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 2064); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 76); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 92); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "iprtrmib")] #[test] +fn shared_iprtrmib() { + use winapi::shared::iprtrmib::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 524); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 68); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "ktmtypes")] #[test] fn shared_ktmtypes() { use winapi::shared::ktmtypes::*; @@ -718,6 +834,68 @@ fn shared_mstcpip() { assert_eq!(size_of::(), 1); assert_eq!(align_of::(), 1); } +#[cfg(feature = "netioapi")] #[test] +fn shared_netioapi() { + use winapi::shared::netioapi::*; + assert_eq!(size_of::(), 1352); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1360); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 136); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 144); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "nldef")] #[test] +fn shared_nldef() { + use winapi::shared::nldef::*; + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "ntddscsi")] #[test] fn shared_ntddscsi() { use winapi::shared::ntddscsi::*; @@ -1122,6 +1300,88 @@ fn shared_sspi() { assert_eq!(size_of::(), 48); assert_eq!(align_of::(), 8); } +#[cfg(feature = "tcpestats")] #[test] +fn shared_tcpestats() { + use winapi::shared::tcpestats::*; + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 88); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 1); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "tcpmib")] #[test] +fn shared_tcpmib() { + use winapi::shared::tcpmib::*; + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 52); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 192); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 200); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "transportsettingcommon")] #[test] fn shared_transportsettingcommon() { use winapi::shared::transportsettingcommon::*; @@ -1134,6 +1394,38 @@ fn shared_tvout() { assert_eq!(size_of::(), 356); assert_eq!(align_of::(), 4); } +#[cfg(feature = "udpmib")] #[test] +fn shared_udpmib() { + use winapi::shared::udpmib::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 160); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 168); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "usb")] #[test] fn shared_usb() { use winapi::shared::usb::*; @@ -1431,12 +1723,20 @@ fn shared_ws2def() { #[cfg(feature = "ws2ipdef")] #[test] fn shared_ws2ipdef() { use winapi::shared::ws2ipdef::*; + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 28); - assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); } #[cfg(feature = "wtypes")] #[test] fn shared_wtypes() { @@ -3604,6 +3904,88 @@ fn um_http() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); } +#[cfg(feature = "ipexport")] #[test] +fn um_ipexport() { + use winapi::um::ipexport::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 26); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 260); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 264); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); +} +#[cfg(feature = "iphlpapi")] #[test] +fn um_iphlpapi() { + use winapi::um::iphlpapi::*; + assert_eq!(size_of::(), 14); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 528); + assert_eq!(align_of::(), 4); +} +#[cfg(feature = "iptypes")] #[test] +fn um_iptypes() { + use winapi::um::iptypes::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 1); + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 704); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 520); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 448); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 184); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 600); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 44); + assert_eq!(align_of::(), 4); +} #[cfg(feature = "jobapi2")] #[test] fn um_jobapi2() { use winapi::um::jobapi2::*; From 3b5121f78aeb5c72945ec195a472b27780150c3a Mon Sep 17 00:00:00 2001 From: hankbao Date: Wed, 28 Aug 2019 15:45:20 +0800 Subject: [PATCH 13/26] remove comments & use DECLARE_HANDLE macro --- src/shared/ntddndis.rs | 4 ---- src/shared/tcpmib.rs | 5 +---- src/um/iphlpapi.rs | 5 +---- tests/structs_x86.rs | 2 -- tests/structs_x86_64.rs | 2 -- 5 files changed, 2 insertions(+), 16 deletions(-) diff --git a/src/shared/ntddndis.rs b/src/shared/ntddndis.rs index babdc6e8a..ee0f83f1c 100644 --- a/src/shared/ntddndis.rs +++ b/src/shared/ntddndis.rs @@ -21,15 +21,11 @@ ENUM!{enum NDIS_MEDIUM { NdisMediumCoWan = 12, NdisMedium1394 = 13, NdisMediumInfiniBand = 14, -// #if ((NTDDI_VERSION >= NTDDI_VISTA) || NDIS_SUPPORT_NDIS6) NdisMediumTunnel = 15, NdisMediumNative802_11 = 16, NdisMediumLoopback = 17, -// #endif // (NTDDI_VERSION >= NTDDI_VISTA) -// #if (NTDDI_VERSION >= NTDDI_WIN7) NdisMediumWiMAX = 18, NdisMediumIP = 19, -// #endif NdisMediumMax = 20, // Not a real medium, defined as an upper-bound }} pub type PNDIS_MEDIUM = *mut NDIS_MEDIUM; diff --git a/src/shared/tcpmib.rs b/src/shared/tcpmib.rs index f635459e0..63f7b87cf 100644 --- a/src/shared/tcpmib.rs +++ b/src/shared/tcpmib.rs @@ -258,11 +258,8 @@ STRUCT!{struct MIB_TCPSTATS_W2K { dwNumConns: DWORD, }} pub type PMIB_TCPSTATS_W2K = *mut MIB_TCPSTATS_W2K; -// Windows Vista -// pub type MIB_TCPSTATS = MIB_TCPSTATS_LH; -pub type MIB_TCPSTATS = MIB_TCPSTATS_W2K; +pub type MIB_TCPSTATS = MIB_TCPSTATS_LH; pub type PMIB_TCPSTATS = *mut MIB_TCPSTATS; -// if NTDDI_VERSION >= NTDDI_WIN10_RS3 STRUCT!{struct MIB_TCPSTATS2 { RtoAlgorithm: TCP_RTO_ALGORITHM, dwRtoMin: DWORD, diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index 42e2d2149..377b71130 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -381,10 +381,7 @@ STRUCT!{struct INTERFACE_HARDWARE_CROSSTIMESTAMP { SystemTimestamp2: ULONG64, }} pub type PINTERFACE_HARDWARE_CROSSTIMESTAMP = *mut INTERFACE_HARDWARE_CROSSTIMESTAMP; -STRUCT!{struct HIFTIMESTAMPCHANGE__ { - unused: i32, -}} -pub type HIFTIMESTAMPCHANGE = *mut HIFTIMESTAMPCHANGE__; +DECLARE_HANDLE!{HIFTIMESTAMPCHANGE, HIFTIMESTAMPCHANGE__} extern "system" { pub fn GetInterfaceCurrentTimestampCapabilities( InterfaceLuid: *const NET_LUID, diff --git a/tests/structs_x86.rs b/tests/structs_x86.rs index 4e7b0f1d0..44b310c33 100644 --- a/tests/structs_x86.rs +++ b/tests/structs_x86.rs @@ -3924,8 +3924,6 @@ fn um_iphlpapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 4); - assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 528); assert_eq!(align_of::(), 4); } diff --git a/tests/structs_x86_64.rs b/tests/structs_x86_64.rs index 2340887d6..132f0fc62 100644 --- a/tests/structs_x86_64.rs +++ b/tests/structs_x86_64.rs @@ -3943,8 +3943,6 @@ fn um_iphlpapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 4); - assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 528); assert_eq!(align_of::(), 4); } From f0e54ba404c2c28a69dafddae7fc0950d6c26e62 Mon Sep 17 00:00:00 2001 From: hankbao Date: Wed, 28 Aug 2019 17:52:30 +0800 Subject: [PATCH 14/26] replace all SIZEOF_* functions with FIXME comments --- build.rs | 8 +++---- src/shared/ifmib.rs | 11 +-------- src/shared/ipmib.rs | 35 ++++++++-------------------- src/shared/tcpmib.rs | 54 ++++++++------------------------------------ src/shared/udpmib.rs | 42 +++++----------------------------- 5 files changed, 30 insertions(+), 120 deletions(-) diff --git a/build.rs b/build.rs index 7481a0b9e..808fd951d 100644 --- a/build.rs +++ b/build.rs @@ -47,12 +47,12 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("hidsdi", &["guiddef", "hidpi", "minwindef", "winnt"], &["hid"]), ("hidusage", &["minwindef"], &[]), ("ifdef", &["basetsd", "guiddef", "ntdef"], &[]), - ("ifmib", &["ifdef", "ipifcons", "minwindef", "ntdef", "rtinfo"], &[]), + ("ifmib", &["ifdef", "ipifcons", "minwindef", "ntdef"], &[]), ("in6addr", &["minwindef"], &[]), ("inaddr", &["minwindef"], &[]), ("intsafe", &[], &[]), ("ipifcons", &["minwindef"], &[]), - ("ipmib", &["ifdef", "ifmib", "minwindef", "nldef", "ntdef", "rtinfo"], &[]), + ("ipmib", &["ifdef", "ifmib", "minwindef", "nldef", "ntdef"], &[]), ("iprtrmib", &["ipmib", "minwindef", "ntdef"], &[]), ("ks", &[], &[]), ("ksmedia", &["minwindef"], &[]), @@ -78,10 +78,10 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("sspi", &["basetsd", "guiddef", "minwindef", "subauth", "wincred", "winnt"], &["credui", "secur32"]), ("stralign", &["vcruntime", "winnt"], &["kernel32"]), ("tcpestats", &["basetsd", "ntdef"], &[]), - ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef", "rtinfo"], &[]), + ("tcpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), ("transportsettingcommon", &["guiddef"], &[]), ("tvout", &["guiddef", "minwindef"], &[]), - ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef", "rtinfo"], &[]), + ("udpmib", &["basetsd", "in6addr", "minwindef", "ntdef"], &[]), ("usb", &["minwindef", "usbspec", "winnt"], &[]), ("usbiodef", &["guiddef", "minwindef", "winioctl", "winnt"], &[]), ("usbspec", &["basetsd", "guiddef", "minwindef", "winnt"], &[]), diff --git a/src/shared/ifmib.rs b/src/shared/ifmib.rs index 2be82e183..855b147f6 100644 --- a/src/shared/ifmib.rs +++ b/src/shared/ifmib.rs @@ -6,13 +6,10 @@ //! Contains the public definitions and structures for the non-TCP/IP specific parts of MIB-II. // #include // #include -use core::mem; -use core::ptr; use shared::ifdef::IF_INDEX; use shared::ipifcons::{IFTYPE, INTERNAL_IF_OPER_STATUS}; use shared::minwindef::DWORD; use shared::ntdef::{UCHAR, WCHAR}; -use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; STRUCT!{struct MIB_IFNUMBER { dwValue: DWORD, @@ -53,10 +50,4 @@ STRUCT!{struct MIB_IFTABLE { table: [MIB_IFROW; ANY_SIZE], }} pub type PMIB_IFTABLE = *mut MIB_IFTABLE; -#[inline] -pub fn SIZEOF_IFTABLE(num: usize) -> usize { - let offset = unsafe { - &(*(ptr::null() as *const MIB_IFTABLE)).table[0] as *const _ as usize - }; - offset + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_IFTABLE(x) diff --git a/src/shared/ipmib.rs b/src/shared/ipmib.rs index e4292991e..cddd8f61a 100644 --- a/src/shared/ipmib.rs +++ b/src/shared/ipmib.rs @@ -3,20 +3,12 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. -use core::mem; -use core::ptr; use shared::ifdef::IF_INDEX; use shared::ifmib::MAXLEN_PHYSADDR; use shared::minwindef::DWORD; use shared::nldef::NL_ROUTE_PROTOCOL; use shared::ntdef::{PVOID, UCHAR, ULONG, USHORT}; -use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; -macro_rules! offset_of_table { - ($container:ty) => (unsafe { - &(*(ptr::null() as *const $container)).table[0] as *const _ as usize - }) -} STRUCT!{struct MIB_IPADDRROW_XP { dwAddr: DWORD, dwIndex: IF_INDEX, @@ -44,10 +36,7 @@ STRUCT!{struct MIB_IPADDRTABLE { table: [MIB_IPADDRROW; ANY_SIZE], }} pub type PMIB_IPADDRTABLE = *mut MIB_IPADDRTABLE; -#[inline] -pub fn SIZEOF_IPADDRTABLE(num: usize) -> usize { - offset_of_table!(MIB_IPADDRTABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_IPADDRTABLE(x) STRUCT!{struct MIB_IPFORWARDNUMBER { dwValue: DWORD, }} @@ -81,10 +70,7 @@ STRUCT!{struct MIB_IPFORWARDTABLE { table: [MIB_IPFORWARDROW; ANY_SIZE], }} pub type PMIB_IPFORWARDTABLE = *mut MIB_IPFORWARDTABLE; -#[inline] -pub fn SIZEOF_IPFORWARDTABLE(num: usize) -> usize { - offset_of_table!(MIB_IPFORWARDTABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_IPFORWARDTABLE(x) ENUM!{enum MIB_IPNET_TYPE { MIB_IPNET_TYPE_OTHER = 1, MIB_IPNET_TYPE_INVALID = 2, @@ -114,10 +100,7 @@ STRUCT!{struct MIB_IPNETTABLE { table: [MIB_IPNETROW; ANY_SIZE], }} pub type PMIB_IPNETTABLE = *mut MIB_IPNETTABLE; -#[inline] -pub fn SIZEOF_IPNETTABLE(num: usize) -> usize { - offset_of_table!(MIB_IPNETTABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_IPNETTABLE(x) ENUM!{enum MIB_IPSTATS_FORWARDING { MIB_IP_FORWARDING = 1, MIB_IP_NOT_FORWARDING = 2, @@ -290,6 +273,8 @@ STRUCT!{struct MIB_MFE_TABLE { table: [MIB_IPMCAST_MFE; ANY_SIZE], }} pub type PMIB_MFE_TABLE = *mut MIB_MFE_TABLE; +// FIXME: SIZEOF_BASIC_MIB_MFE +// FIXME: SIZEOF_MIB_MFE(x) STRUCT!{struct MIB_IPMCAST_OIF_STATS_LH { dwOutIfIndex: DWORD, dwNextHopAddr: DWORD, @@ -337,6 +322,8 @@ STRUCT!{struct MIB_MFE_STATS_TABLE { table: [MIB_IPMCAST_MFE_STATS; ANY_SIZE], }} pub type PMIB_MFE_STATS_TABLE = *mut MIB_MFE_STATS_TABLE; +// FIXME: SIZEOF_BASIC_MIB_MFE_STATS +// FIXME: SIZEOF_MIB_MFE_STATS(x) STRUCT!{struct MIB_IPMCAST_MFE_STATS_EX_XP { dwGroup: DWORD, dwSource: DWORD, @@ -371,6 +358,8 @@ STRUCT!{struct MIB_MFE_STATS_TABLE_EX_XP { pub type PMIB_MFE_STATS_TABLE_EX_XP = *mut MIB_MFE_STATS_TABLE_EX_XP; pub type MIB_MFE_STATS_TABLE_EX = MIB_MFE_STATS_TABLE_EX_XP; pub type PMIB_MFE_STATS_TABLE_EX = *mut MIB_MFE_STATS_TABLE_EX; +// FIXME: SIZEOF_BASIC_MIB_MFE_STATS_EX +// FIXME: SIZEOF_MIB_MFE_STATS_EX(x) STRUCT!{struct MIB_IPMCAST_GLOBAL { dwEnable: DWORD, }} @@ -389,8 +378,4 @@ STRUCT!{struct MIB_IPMCAST_IF_TABLE { table: [MIB_IPMCAST_IF_ENTRY; ANY_SIZE], }} pub type PMIB_IPMCAST_IF_TABLE = *mut MIB_IPMCAST_IF_TABLE; -#[inline] -pub fn SIZEOF_MCAST_IF_TABLE(num: usize) -> usize { - offset_of_table!(MIB_IPMCAST_IF_TABLE) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_MCAST_IF_TABLE(x) diff --git a/src/shared/tcpmib.rs b/src/shared/tcpmib.rs index 63f7b87cf..63ae7965a 100644 --- a/src/shared/tcpmib.rs +++ b/src/shared/tcpmib.rs @@ -4,20 +4,12 @@ // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. // #include -use core::mem; -use core::ptr; use shared::basetsd::DWORD64; use shared::in6addr::IN6_ADDR; use shared::minwindef::DWORD; use shared::ntdef::{LARGE_INTEGER, UCHAR, ULONGLONG}; -use um::rtinfo::ALIGN_SIZE; -pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; const ANY_SIZE: usize = 1; -macro_rules! offset_of_table { - ($container:ty) => (unsafe { - &(*(ptr::null() as *const $container)).table[0] as *const _ as usize - }) -} +pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; ENUM!{enum MIB_TCP_STATE { MIB_TCP_STATE_CLOSED = 1, MIB_TCP_STATE_LISTEN = 2, @@ -64,10 +56,7 @@ STRUCT!{struct MIB_TCPTABLE { table: [MIB_TCPROW; ANY_SIZE], }} pub type PMIB_TCPTABLE = *mut MIB_TCPTABLE; -#[inline] -pub fn SIZEOF_TCPTABLE(num: usize) -> usize { - offset_of_table!(MIB_TCPTABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_TCPTABLE(x) STRUCT!{struct MIB_TCPROW2 { dwState: DWORD, dwLocalAddr: DWORD, @@ -83,10 +72,7 @@ STRUCT!{struct MIB_TCPTABLE2 { table: [MIB_TCPROW2; ANY_SIZE], }} pub type PMIB_TCPTABLE2 = *mut MIB_TCPTABLE2; -#[inline] -pub fn SIZEOF_TCPTABLE2(num: usize) -> usize { - offset_of_table!(MIB_TCPTABLE2) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_TCPTABLE2(x) STRUCT!{struct MIB_TCPROW_OWNER_PID { dwState: DWORD, dwLocalAddr: DWORD, @@ -101,11 +87,7 @@ STRUCT!{struct MIB_TCPTABLE_OWNER_PID { table: [MIB_TCPROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_TCPTABLE_OWNER_PID = *mut MIB_TCPTABLE_OWNER_PID; -#[inline] -pub fn SIZEOF_TCPTABLE_OWNER_PID(num: usize) -> usize { - offset_of_table!(MIB_TCPTABLE_OWNER_PID) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_TCPTABLE_OWNER_PID(x) STRUCT!{struct MIB_TCPROW_OWNER_MODULE { dwState: DWORD, dwLocalAddr: DWORD, @@ -122,11 +104,7 @@ STRUCT!{struct MIB_TCPTABLE_OWNER_MODULE { table: [MIB_TCPROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_TCPTABLE_OWNER_MODULE = *mut MIB_TCPTABLE_OWNER_MODULE; -#[inline] -pub fn SIZEOF_TCPTABLE_OWNER_MODULE(num: usize) -> usize { - offset_of_table!(MIB_TCPTABLE_OWNER_MODULE) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_TCPTABLE_OWNER_MODULE(x) STRUCT!{struct MIB_TCP6ROW { State: MIB_TCP_STATE, LocalAddr: IN6_ADDR, @@ -142,10 +120,7 @@ STRUCT!{struct MIB_TCP6TABLE { table: [MIB_TCP6ROW; ANY_SIZE], }} pub type PMIB_TCP6TABLE = *mut MIB_TCP6TABLE; -#[inline] -pub fn SIZEOF_TCP6TABLE(num: usize) -> usize { - offset_of_table!(MIB_TCP6TABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_TCP6TABLE(x) STRUCT!{struct MIB_TCP6ROW2 { LocalAddr: IN6_ADDR, dwLocalScopeId: DWORD, @@ -163,10 +138,7 @@ STRUCT!{struct MIB_TCP6TABLE2 { table: [MIB_TCP6ROW2; ANY_SIZE], }} pub type PMIB_TCP6TABLE2 = *mut MIB_TCP6TABLE2; -#[inline] -pub fn SIZEOF_TCP6TABLE2(num: usize) -> usize { - offset_of_table!(MIB_TCP6TABLE2) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_TCP6TABLE2(x) STRUCT!{struct MIB_TCP6ROW_OWNER_PID { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -183,11 +155,7 @@ STRUCT!{struct MIB_TCP6TABLE_OWNER_PID { table: [MIB_TCP6ROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_TCP6TABLE_OWNER_PID = *mut MIB_TCP6TABLE_OWNER_PID; -#[inline] -pub fn SIZEOF_TCP6TABLE_OWNER_PID(num: usize) -> usize { - offset_of_table!(MIB_TCP6TABLE_OWNER_PID) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_TCP6TABLE_OWNER_PID(x) STRUCT!{struct MIB_TCP6ROW_OWNER_MODULE { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -206,11 +174,7 @@ STRUCT!{struct MIB_TCP6TABLE_OWNER_MODULE { table: [MIB_TCP6ROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_TCP6TABLE_OWNER_MODULE = *mut MIB_TCP6TABLE_OWNER_MODULE; -#[inline] -pub fn SIZEOF_TCP6TABLE_OWNER_MODULE(num: usize) -> usize { - offset_of_table!(MIB_TCP6TABLE_OWNER_MODULE) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_TCP6TABLE_OWNER_MODULE(x) ENUM!{enum TCP_RTO_ALGORITHM { TcpRtoAlgorithmOther = 1, TcpRtoAlgorithmConstant = 2, diff --git a/src/shared/udpmib.rs b/src/shared/udpmib.rs index 28fa39d3c..e5a73a20c 100644 --- a/src/shared/udpmib.rs +++ b/src/shared/udpmib.rs @@ -5,20 +5,12 @@ // except according to those terms. //! Contains the public definitions and structures for the UDP-specific parts of MIB-II // #include -use core::mem; -use core::ptr; use shared::basetsd::DWORD64; use shared::in6addr::IN6_ADDR; use shared::minwindef::DWORD; use shared::ntdef::{INT, LARGE_INTEGER, UCHAR, ULONGLONG}; -use um::rtinfo::ALIGN_SIZE; const ANY_SIZE: usize = 1; pub const TCPIP_OWNING_MODULE_SIZE: usize = 16; -macro_rules! offset_of_table { - ($container:ty) => (unsafe { - &(*(ptr::null() as *const $container)).table[0] as *const _ as usize - }) -} STRUCT!{struct MIB_UDPROW { dwLocalAddr: DWORD, dwLocalPort: DWORD, @@ -29,10 +21,7 @@ STRUCT!{struct MIB_UDPTABLE { table: [MIB_UDPROW; ANY_SIZE], }} pub type PMIB_UDPTABLE = *mut MIB_UDPTABLE; -#[inline] -pub fn SIZEOF_UDPTABLE(num: usize) -> usize { - offset_of_table!(MIB_UDPTABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_UDPTABLE(x) STRUCT!{struct MIB_UDPROW_OWNER_PID { dwLocalAddr: DWORD, dwLocalPort: DWORD, @@ -44,11 +33,7 @@ STRUCT!{struct MIB_UDPTABLE_OWNER_PID { table: [MIB_UDPROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_UDPTABLE_OWNER_PID = *mut MIB_UDPTABLE_OWNER_PID; -#[inline] -pub fn SIZEOF_UDPTABLE_OWNER_PID(num: usize) -> usize { - offset_of_table!(MIB_UDPTABLE_OWNER_PID) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_UDPTABLE_OWNER_PID(x) STRUCT!{struct MIB_UDPROW_OWNER_MODULE_u_s { bitfield: INT, }} @@ -74,11 +59,7 @@ STRUCT!{struct MIB_UDPTABLE_OWNER_MODULE { table: [MIB_UDPROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_UDPTABLE_OWNER_MODULE = *mut MIB_UDPTABLE_OWNER_MODULE; -#[inline] -pub fn SIZEOF_UDPTABLE_OWNER_MODULE(num: usize) -> usize { - offset_of_table!(MIB_UDPTABLE_OWNER_MODULE) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_UDPTABLE_OWNER_MODULE(x) STRUCT!{struct MIB_UDP6ROW { dwLocalAddr: IN6_ADDR, dwLocalScopeId: DWORD, @@ -90,10 +71,7 @@ STRUCT!{struct MIB_UDP6TABLE { table: [MIB_UDP6ROW; ANY_SIZE], }} pub type PMIB_UDP6TABLE = *mut MIB_UDP6TABLE; -#[inline] -pub fn SIZEOF_UDP6TABLE(num: usize) -> usize { - offset_of_table!(MIB_UDP6TABLE) + num * mem::size_of::() + ALIGN_SIZE -} +// FIXME: SIZEOF_UDP6TABLE(x) STRUCT!{struct MIB_UDP6ROW_OWNER_PID { ucLocalAddr: [UCHAR; 16], dwLocalScopeId: DWORD, @@ -106,11 +84,7 @@ STRUCT!{struct MIB_UDP6TABLE_OWNER_PID { table: [MIB_UDP6ROW_OWNER_PID; ANY_SIZE], }} pub type PMIB_UDP6TABLE_OWNER_PID = *mut MIB_UDP6TABLE_OWNER_PID; -#[inline] -pub fn SIZEOF_UDP6TABLE_OWNER_PID(num: usize) -> usize { - offset_of_table!(MIB_UDP6TABLE_OWNER_PID) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_UDP6TABLE_OWNER_PID(x) STRUCT!{struct MIB_UDP6ROW_OWNER_MODULE_u_s { bitfield: INT, }} @@ -137,11 +111,7 @@ STRUCT!{struct MIB_UDP6TABLE_OWNER_MODULE { table: [MIB_UDP6ROW_OWNER_MODULE; ANY_SIZE], }} pub type PMIB_UDP6TABLE_OWNER_MODULE = *mut MIB_UDP6TABLE_OWNER_MODULE; -#[inline] -pub fn SIZEOF_UDP6TABLE_OWNER_MODULE(num: usize) -> usize { - offset_of_table!(MIB_UDP6TABLE_OWNER_MODULE) + num * mem::size_of::() - + ALIGN_SIZE -} +// FIXME: SIZEOF_UDP6TABLE_OWNER_MODULE(x) STRUCT!{struct MIB_UDPSTATS { dwInDatagrams: DWORD, dwNoPorts: DWORD, From a5fb87cbc7d0b04b2e0ba25c10f7e5eae657d82b Mon Sep 17 00:00:00 2001 From: hankbao Date: Mon, 9 Sep 2019 21:45:04 +0800 Subject: [PATCH 15/26] fix callback return type in netioapi & iphlpapi --- src/shared/netioapi.rs | 12 ++++++------ src/um/iphlpapi.rs | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index efe925fae..7d51d7337 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -20,7 +20,7 @@ use shared::nldef::{ }; use shared::ntddndis::{NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; use shared::ntdef::{ - BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, VOID, WCHAR, + BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, WCHAR, }; use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID, ScopeLevelCount}; use shared::ws2ipdef::{PSOCKADDR_IN6_PAIR, SOCKADDR_IN6, SOCKADDR_INET}; @@ -194,7 +194,7 @@ FN!{stdcall PIPINTERFACE_CHANGE_CALLBACK( CallerContext: PVOID, Row: PMIB_IPINTERFACE_ROW, NotificationType: MIB_NOTIFICATION_TYPE, -) -> VOID} +) -> ()} STRUCT!{struct MIB_IP_NETWORK_CONNECTION_BANDWIDTH_ESTIMATES { InboundBandwidthInformation: NL_BANDWIDTH_INFORMATION, OutboundBandwidthInformation: NL_BANDWIDTH_INFORMATION, @@ -258,7 +258,7 @@ FN!{stdcall PUNICAST_IPADDRESS_CHANGE_CALLBACK( CallerContext: PVOID, Row: PMIB_UNICASTIPADDRESS_ROW, NotificationType: MIB_NOTIFICATION_TYPE, -) -> VOID} +) -> ()} extern "system" { pub fn CreateUnicastIpAddressEntry( Row: *const MIB_UNICASTIPADDRESS_ROW, @@ -287,7 +287,7 @@ extern "system" { FN!{stdcall PSTABLE_UNICAST_IPADDRESS_TABLE_CALLBACK( CallerContext: PVOID, AddressTable: PMIB_UNICASTIPADDRESS_TABLE, -) -> VOID} +) -> ()} extern "system" { pub fn NotifyStableUnicastIpAddressTable( Family: ADDRESS_FAMILY, @@ -380,7 +380,7 @@ FN!{stdcall PIPFORWARD_CHANGE_CALLBACK( CallerContext: PVOID, Row: PMIB_IPFORWARD_ROW2, NotificationType: MIB_NOTIFICATION_TYPE, -) -> VOID} +) -> ()} extern "system" { pub fn CreateIpForwardEntry2( Row: *const MIB_IPFORWARD_ROW2, @@ -515,7 +515,7 @@ FN!{stdcall PTEREDO_PORT_CHANGE_CALLBACK( CallerContext: PVOID, Port: USHORT, NotificationType: MIB_NOTIFICATION_TYPE, -) -> VOID} +) -> ()} extern "system" { pub fn NotifyTeredoPortChange( Callback: PTEREDO_PORT_CHANGE_CALLBACK, diff --git a/src/um/iphlpapi.rs b/src/um/iphlpapi.rs index 377b71130..926545b0d 100644 --- a/src/um/iphlpapi.rs +++ b/src/um/iphlpapi.rs @@ -17,7 +17,7 @@ use shared::ipmib::{ use shared::iprtrmib::{TCPIP_OWNER_MODULE_INFO_CLASS, TCP_TABLE_CLASS, UDP_TABLE_CLASS}; use shared::minwindef::{BOOL, BYTE, DWORD, LPDWORD, PDWORD, PUCHAR, PULONG, UINT}; use shared::ntdef::{ - BOOLEAN, HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, ULONGLONG, USHORT, VOID, WCHAR, + BOOLEAN, HANDLE, LPWSTR, PHANDLE, PVOID, PWSTR, ULONG, ULONGLONG, USHORT, WCHAR, }; use shared::tcpestats::TCP_ESTATS_TYPE; use shared::tcpmib::{ @@ -398,7 +398,7 @@ extern "system" { } FN!{stdcall INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK( CallerContext: PVOID, -) -> VOID} +) -> ()} pub type PINTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK = *mut INTERFACE_TIMESTAMP_CONFIG_CHANGE_CALLBACK; extern "system" { From ed707659a4d4a7d97bcff94540bb21c99248079f Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:04:52 +0800 Subject: [PATCH 16/26] Update src/shared/ifdef.rs Co-Authored-By: Peter Atashian --- src/shared/ifdef.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index 734f35490..d46226079 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -33,8 +33,7 @@ pub type PNET_IF_ADMIN_STATUS = *mut NET_IF_ADMIN_STATUS; pub type NET_IF_COMPARTMENT_SCOPE = UINT32; pub type PNET_IF_COMPARTMENT_SCOPE = *mut NET_IF_COMPARTMENT_SCOPE; pub const NET_IF_COMPARTMENT_SCOPE_UNSPECIFIED: NET_IF_COMPARTMENT_SCOPE = 0; -pub const NET_IF_COMPARTMENT_SCOPE_ALL: NET_IF_COMPARTMENT_SCOPE = -1i32 as - NET_IF_COMPARTMENT_SCOPE; +pub const NET_IF_COMPARTMENT_SCOPE_ALL: NET_IF_COMPARTMENT_SCOPE = -1i32 as u32; ENUM!{enum NET_IF_RCV_ADDRESS_TYPE { NET_IF_RCV_ADDRESS_TYPE_OTHER = 1, NET_IF_RCV_ADDRESS_TYPE_VOLATILE = 2, From 5b4a0c0ad634a6b243c043ddb9f43d92c4f084e8 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:05:10 +0800 Subject: [PATCH 17/26] Update src/shared/ifdef.rs Co-Authored-By: Peter Atashian --- src/shared/ifdef.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index d46226079..c0bdf08f4 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -132,7 +132,7 @@ pub type PNET_PHYSICAL_LOCATION_LH = *mut NET_PHYSICAL_LOCATION_LH; pub const IF_MAX_STRING_SIZE: usize = 256; pub const IF_MAX_PHYS_ADDRESS_LENGTH: usize = 32; STRUCT!{struct IF_COUNTED_STRING_LH { - Length: USHORT, // in -Bytes- + Length: USHORT, String: [WCHAR; IF_MAX_STRING_SIZE + 1], }} pub type PIF_COUNTED_STRING_LH = *mut IF_COUNTED_STRING_LH; From 33062cea9c1005c19dab47616f99a200ad8656d2 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:05:41 +0800 Subject: [PATCH 18/26] Update src/shared/ifdef.rs Co-Authored-By: Peter Atashian --- src/shared/ifdef.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/shared/ifdef.rs b/src/shared/ifdef.rs index c0bdf08f4..52f714940 100644 --- a/src/shared/ifdef.rs +++ b/src/shared/ifdef.rs @@ -155,12 +155,12 @@ ENUM!{enum IF_ADMINISTRATIVE_STATE { pub type PIF_ADMINISTRATIVE_STATE = *mut IF_ADMINISTRATIVE_STATE; ENUM!{enum IF_OPER_STATUS { IfOperStatusUp = 1, - IfOperStatusDown = 2, - IfOperStatusTesting = 3, - IfOperStatusUnknown = 4, - IfOperStatusDormant = 5, - IfOperStatusNotPresent = 6, - IfOperStatusLowerLayerDown = 7, + IfOperStatusDown, + IfOperStatusTesting, + IfOperStatusUnknown, + IfOperStatusDormant, + IfOperStatusNotPresent, + IfOperStatusLowerLayerDown, }} STRUCT!{struct NDIS_INTERFACE_INFORMATION { ifOperStatus: NET_IF_OPER_STATUS, From 7a31121e8c8a342295da77b82839d8de8b3a1f61 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:05:53 +0800 Subject: [PATCH 19/26] Update src/shared/netioapi.rs Co-Authored-By: Peter Atashian --- src/shared/netioapi.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index 7d51d7337..aa309fc34 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -57,8 +57,8 @@ STRUCT!{struct MIB_IF_ROW2 { PhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], PermanentPhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], Mtu: ULONG, - Type: ULONG, // Interface Type. - TunnelType: TUNNEL_TYPE, // Tunnel Type, if Type = IF_TUNNEL. + Type: ULONG, + TunnelType: TUNNEL_TYPE, MediaType: NDIS_MEDIUM, PhysicalMediumType: NDIS_PHYSICAL_MEDIUM, AccessType: NET_IF_ACCESS_TYPE, From bfc5bc1e6b17a96b9dcf95f22a9c0708779cb657 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:06:02 +0800 Subject: [PATCH 20/26] Update src/shared/netioapi.rs Co-Authored-By: Peter Atashian --- src/shared/netioapi.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index aa309fc34..38bfc9841 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -37,7 +37,7 @@ pub type PMIB_NOTIFICATION_TYPE = *mut MIB_NOTIFICATION_TYPE; STRUCT!{struct MIB_IF_ROW2_InterfaceAndOperStatusFlags { bitfield: BYTE, }} -BITFIELD!{MIB_IF_ROW2_InterfaceAndOperStatusFlags bitfield: BYTE [ +BITFIELD!{MIB_IF_ROW2_InterfaceAndOperStatusFlags bitfield: BOOLEAN [ HardwareInterface set_HardwareInterface[0..1], FilterInterface set_FilterInterface[1..2], ConnectorPresent set_ConnectorPresent[2..3], From 216da0a19a5a6fe3213b22a14e6ca7b7ff2de2f6 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:06:59 +0800 Subject: [PATCH 21/26] Update src/shared/nldef.rs Co-Authored-By: Peter Atashian --- src/shared/nldef.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/shared/nldef.rs b/src/shared/nldef.rs index 2d2af0b52..f4de179f6 100644 --- a/src/shared/nldef.rs +++ b/src/shared/nldef.rs @@ -195,7 +195,7 @@ ENUM!{enum NL_INTERFACE_NETWORK_CATEGORY_STATE { NlincCategoryStateMax = 4, }} pub type PNL_INTERFACE_NETWORK_CATEGORY_STATE = *mut NL_INTERFACE_NETWORK_CATEGORY_STATE; -pub const NET_IF_CURRENT_SESSION : ULONG = -1i32 as u32; +pub const NET_IF_CURRENT_SESSION: ULONG = -1i32 as u32; STRUCT!{struct NL_BANDWIDTH_INFORMATION { Bandwidth: ULONG64, Instability: ULONG64, From fdae58b355ba1b0e8317b4eb2ab6875d42b9bdf1 Mon Sep 17 00:00:00 2001 From: Hank Bao Date: Mon, 6 Apr 2020 17:07:59 +0800 Subject: [PATCH 22/26] Update src/shared/nldef.rs Co-Authored-By: Peter Atashian --- src/shared/nldef.rs | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/shared/nldef.rs b/src/shared/nldef.rs index f4de179f6..1dbd557c8 100644 --- a/src/shared/nldef.rs +++ b/src/shared/nldef.rs @@ -20,20 +20,20 @@ pub const NlpoWellKnown: NL_PREFIX_ORIGIN = IpPrefixOriginWellKnown; pub const NlpoDhcp: NL_PREFIX_ORIGIN = IpPrefixOriginDhcp; pub const NlpoRouterAdvertisement: NL_PREFIX_ORIGIN = IpPrefixOriginRouterAdvertisement; ENUM!{enum NL_SUFFIX_ORIGIN { + NlsoOther = 0, + NlsoManual, + NlsoWellKnown, + NlsoDhcp, + NlsoLinkLayerAddress, + NlsoRandom, IpSuffixOriginOther = 0, - IpSuffixOriginManual = 1, - IpSuffixOriginWellKnown = 2, - IpSuffixOriginDhcp = 3, - IpSuffixOriginLinkLayerAddress = 4, - IpSuffixOriginRandom = 5, + IpSuffixOriginManual, + IpSuffixOriginWellKnown, + IpSuffixOriginDhcp, + IpSuffixOriginLinkLayerAddress, + IpSuffixOriginRandom, IpSuffixOriginUnchanged = 1 << 4, }} -pub const NlsoOther: NL_SUFFIX_ORIGIN = IpSuffixOriginOther; -pub const NlsoManual: NL_SUFFIX_ORIGIN = IpSuffixOriginManual; -pub const NlsoWellKnown: NL_SUFFIX_ORIGIN = IpSuffixOriginWellKnown; -pub const NlsoDhcp: NL_SUFFIX_ORIGIN = IpSuffixOriginDhcp; -pub const NlsoLinkLayerAddress: NL_SUFFIX_ORIGIN = IpSuffixOriginLinkLayerAddress; -pub const NlsoRandom: NL_SUFFIX_ORIGIN = IpSuffixOriginRandom; ENUM!{enum NL_DAD_STATE { IpDadStateInvalid = 0, IpDadStateTentative = 1, From 66706f9458b03bb37073f2a3cb5fccabe5ec5dbe Mon Sep 17 00:00:00 2001 From: hankbao Date: Mon, 6 Apr 2020 18:35:17 +0800 Subject: [PATCH 23/26] fix field type error in MIB_IF_ROW2 --- src/shared/netioapi.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index 38bfc9841..11d83e1d1 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -12,6 +12,7 @@ use shared::ifdef::{ NET_LUID, PNET_IFINDEX, PNET_IF_COMPARTMENT_ID, PNET_IF_COMPARTMENT_SCOPE, PNET_LUID, TUNNEL_TYPE, }; +use shared::ipifcons::IFTYPE; use shared::minwindef::{BYTE, DWORD, PULONG, UCHAR, ULONG, USHORT}; use shared::nldef::{ NL_BANDWIDTH_INFORMATION, NL_DAD_STATE, NL_INTERFACE_OFFLOAD_ROD, @@ -22,7 +23,7 @@ use shared::ntddndis::{NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; use shared::ntdef::{ BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, WCHAR, }; -use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID, ScopeLevelCount}; +use shared::ws2def::{ScopeLevelCount, ADDRESS_FAMILY, SCOPE_ID}; use shared::ws2ipdef::{PSOCKADDR_IN6_PAIR, SOCKADDR_IN6, SOCKADDR_INET}; const ANY_SIZE: usize = 1; pub type NETIO_STATUS = DWORD; @@ -57,7 +58,7 @@ STRUCT!{struct MIB_IF_ROW2 { PhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], PermanentPhysicalAddress: [UCHAR; IF_MAX_PHYS_ADDRESS_LENGTH], Mtu: ULONG, - Type: ULONG, + Type: IFTYPE, TunnelType: TUNNEL_TYPE, MediaType: NDIS_MEDIUM, PhysicalMediumType: NDIS_PHYSICAL_MEDIUM, From 68e6bf22b071f5c0f3814d3e04430e64d9628501 Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 7 Apr 2020 01:58:27 +0800 Subject: [PATCH 24/26] fix imports sorting --- src/shared/netioapi.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/shared/netioapi.rs b/src/shared/netioapi.rs index 11d83e1d1..7c3f6224c 100644 --- a/src/shared/netioapi.rs +++ b/src/shared/netioapi.rs @@ -23,7 +23,7 @@ use shared::ntddndis::{NDIS_MEDIUM, NDIS_PHYSICAL_MEDIUM}; use shared::ntdef::{ BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, PCHAR, PCSTR, PSTR, PVOID, PWCHAR, PWSTR, WCHAR, }; -use shared::ws2def::{ScopeLevelCount, ADDRESS_FAMILY, SCOPE_ID}; +use shared::ws2def::{ADDRESS_FAMILY, SCOPE_ID, ScopeLevelCount}; use shared::ws2ipdef::{PSOCKADDR_IN6_PAIR, SOCKADDR_IN6, SOCKADDR_INET}; const ANY_SIZE: usize = 1; pub type NETIO_STATUS = DWORD; From db0602debd0006afa55e4eb4e3995907d737f37a Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 7 Apr 2020 02:03:50 +0800 Subject: [PATCH 25/26] fix imports --- build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.rs b/build.rs index 808fd951d..eaae6cb46 100644 --- a/build.rs +++ b/build.rs @@ -63,7 +63,7 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("mprapidef", &[], &[]), ("mstcpip", &["basetsd", "guiddef", "in6addr", "inaddr", "minwindef", "winnt", "ws2def"], &["ntdll"]), ("mswsockdef", &["minwindef", "winnt", "ws2def"], &[]), - ("netioapi", &["basetsd", "guiddef", "ifdef", "minwindef", "nldef", "ntddndis", "ntdef", "ws2def", "ws2ipdef"], &["iphlpapi"]), + ("netioapi", &["basetsd", "guiddef", "ifdef", "ipifcons", "minwindef", "nldef", "ntddndis", "ntdef", "ws2def", "ws2ipdef"], &["iphlpapi"]), ("nldef", &["basetsd", "minwindef", "ntdef"], &[]), ("ntddndis", &["ifdef"], &[]), ("ntddscsi", &["basetsd", "minwindef", "ntdef", "winioctl", "winnt"], &[]), From 2f2d3feda1d95319f2519b07550647a7db1c934e Mon Sep 17 00:00:00 2001 From: hankbao Date: Tue, 7 Apr 2020 02:05:10 +0800 Subject: [PATCH 26/26] have the bitfield applied directly to a Flags field in IP_ADAPTER_ADDRESSES_LH --- src/um/iptypes.rs | 31 ++++++++++++++----------------- 1 file changed, 14 insertions(+), 17 deletions(-) diff --git a/src/um/iptypes.rs b/src/um/iptypes.rs index 31287a633..2fde8ba10 100644 --- a/src/um/iptypes.rs +++ b/src/um/iptypes.rs @@ -243,22 +243,6 @@ UNION!{union IP_ADAPTER_ADDRESSES_LH_u { Alignment Alignment_mut: ULONGLONG, s s_mut: IP_ADAPTER_ADDRESSES_LH_u_s, }} -STRUCT!{struct IP_ADAPTER_ADDRESSES_LH_s { - bitfield: ULONG, -}} -BITFIELD!{IP_ADAPTER_ADDRESSES_LH_s bitfield: ULONG [ - DdnsEnabled set_DdnsEnabled[0..1], - RegisterAdapterSuffix set_RegisterAdapterSuffix[1..2], - Dhcpv4Enabled set_Dhcpv4Enabled[2..3], - ReceiveOnly set_ReceiveOnly[3..4], - NoMulticast set_NoMulticast[4..5], - Ipv6OtherStatefulConfig set_Ipv6OtherStatefulConfig[5..6], - NetbiosOverTcpipEnabled set_NetbiosOverTcpipEnabled[6..7], - Ipv4Enabled set_Ipv4Enabled[7..8], - Ipv6Enabled set_Ipv6Enabled[8..9], - Ipv6ManagedAddressConfigurationSupported set_Ipv6ManagedAddressConfigurationSupported[9..10], - Reserved set_Reserved[10..32], -]} STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { u: IP_ADAPTER_ADDRESSES_LH_u, Next: *mut IP_ADAPTER_ADDRESSES_LH, @@ -272,7 +256,7 @@ STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { FriendlyName: PWCHAR, PhysicalAddress: [BYTE; MAX_ADAPTER_ADDRESS_LENGTH], PhysicalAddressLength: ULONG, - s: IP_ADAPTER_ADDRESSES_LH_s, + Flags: ULONG, Mtu: ULONG, IfType: IFTYPE, OperStatus: IF_OPER_STATUS, @@ -297,6 +281,19 @@ STRUCT!{struct IP_ADAPTER_ADDRESSES_LH { Dhcpv6Iaid: ULONG, FirstDnsSuffix: PIP_ADAPTER_DNS_SUFFIX, }} +BITFIELD!{IP_ADAPTER_ADDRESSES_LH Flags: ULONG [ + DdnsEnabled set_DdnsEnabled[0..1], + RegisterAdapterSuffix set_RegisterAdapterSuffix[1..2], + Dhcpv4Enabled set_Dhcpv4Enabled[2..3], + ReceiveOnly set_ReceiveOnly[3..4], + NoMulticast set_NoMulticast[4..5], + Ipv6OtherStatefulConfig set_Ipv6OtherStatefulConfig[5..6], + NetbiosOverTcpipEnabled set_NetbiosOverTcpipEnabled[6..7], + Ipv4Enabled set_Ipv4Enabled[7..8], + Ipv6Enabled set_Ipv6Enabled[8..9], + Ipv6ManagedAddressConfigurationSupported set_Ipv6ManagedAddressConfigurationSupported[9..10], + Reserved set_Reserved[10..32], +]} pub type PIP_ADAPTER_ADDRESSES_LH = *mut IP_ADAPTER_ADDRESSES_LH; STRUCT!{struct IP_ADAPTER_ADDRESSES_XP_u_s { Length: ULONG,