Add missing sysctl net types for mac

Author: GuillaumeGomez

src/unix/bsd/apple/mod.rs

@@ -1580,6 +1580,50 @@ s_no_extra_traits! {
         pub ifr_name: [::c_char; ::IFNAMSIZ],
         pub ifr_ifru: __c_anonymous_ifr_ifru6,
     }
+
+    pub struct ifmibdata {
+        /// Name of interface
+        pub ifmd_name: [::c_char; ::IFNAMSIZ],
+        /// Number of promiscuous listeners
+        pub ifmd_pcount: ::c_uint,
+        /// Interface flags
+        pub ifmd_flags: ::c_uint,
+        /// Instantaneous length of send queue
+        pub ifmd_snd_len: ::c_uint,
+        /// Maximum length of send queue
+        pub ifmd_snd_maxlen: ::c_uint,
+        /// Number of drops in send queue
+        pub ifmd_snd_drops: ::c_uint,
+        /// For future expansion
+        pub ifmd_filler: [::c_uint; 4],
+        /// Generic information and statistics
+        pub ifmd_data: if_data64,
+    }
+
+    pub struct ifs_iso_8802_3 {
+        pub dot3StatsAlignmentErrors: u32,
+        pub dot3StatsFCSErrors: u32,
+        pub dot3StatsSingleCollisionFrames: u32,
+        pub dot3StatsMultipleCollisionFrames: u32,
+        pub dot3StatsSQETestErrors: u32,
+        pub dot3StatsDeferredTransmissions: u32,
+        pub dot3StatsLateCollisions: u32,
+        pub dot3StatsExcessiveCollisions: u32,
+        pub dot3StatsInternalMacTransmitErrors: u32,
+        pub dot3StatsCarrierSenseErrors: u32,
+        pub dot3StatsFrameTooLongs: u32,
+        pub dot3StatsInternalMacReceiveErrors: u32,
+        pub dot3StatsEtherChipSet: u32,
+        pub dot3StatsMissedFrames: u32,
+        pub dot3StatsCollFrequencies: [u32; 16],
+        pub dot3Compliance: u32,
+    }
+
+    pub struct if_family_id {
+        pub iffmid_len: u32,
+        pub iffmid_id: u32,
+        pub iffmid_str: [::c_char; 1],
+    }
 }
 
 impl siginfo_t {
@@ -3102,7 +3146,7 @@ cfg_if! {
             }
         }
 
-        impl ::fmt::Debug for ifconf{
+        impl ::fmt::Debug for ifconf {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 f.debug_struct("ifconf").finish_non_exhaustive()
             }
@@ -3181,6 +3225,206 @@ cfg_if! {
                     .finish()
             }
         }
+
+        impl PartialEq for ifmibdata {
+            fn eq(&self, other: &ifmibdata) -> bool {
+                self.ifmd_name == other.ifmd_name
+                    && self.ifmd_pcount == other.ifmd_pcount
+                    && self.ifmd_flags == other.ifmd_flags
+                    && self.ifmd_snd_len == other.ifmd_snd_len
+                    && self.ifmd_snd_maxlen == other.ifmd_snd_maxlen
+                    && self.ifmd_snd_drops == other.ifmd_snd_drops
+                    && self.ifmd_filler == other.ifmd_filler
+                    && self.ifmd_data == other.ifmd_data
+            }
+        }
+
+        impl Eq for ifmibdata {}
+
+        impl ::fmt::Debug for ifmibdata {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                let ifmd_name = self.ifmd_name;
+                let ifmd_pcount = self.ifmd_pcount;
+                let ifmd_flags = self.ifmd_flags;
+                let ifmd_snd_len = self.ifmd_snd_len;
+                let ifmd_snd_maxlen = self.ifmd_snd_maxlen;
+                let ifmd_snd_drops = self.ifmd_snd_drops;
+                let ifmd_filler = self.ifmd_filler;
+                let ifmd_data = self.ifmd_data;
+
+                f.debug_struct("ifmibdata")
+                    .field("ifmd_name", &ifmd_name)
+                    .field("ifmd_pcount", &ifmd_pcount)
+                    .field("ifmd_flags", &ifmd_flags)
+                    .field("ifmd_snd_len", &ifmd_snd_len)
+                    .field("ifmd_snd_maxlen", &ifmd_snd_maxlen)
+                    .field("ifmd_snd_drops", &ifmd_snd_drops)
+                    .field("ifmd_filler", &ifmd_filler)
+                    .field("ifmd_data", &ifmd_data)
+                    .finish()
+            }
+        }
+
+        impl ::hash::Hash for ifmibdata {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                let ifmd_name = self.ifmd_name;
+                let ifmd_pcount = self.ifmd_pcount;
+                let ifmd_flags = self.ifmd_flags;
+                let ifmd_snd_len = self.ifmd_snd_len;
+                let ifmd_snd_maxlen = self.ifmd_snd_maxlen;
+                let ifmd_snd_drops = self.ifmd_snd_drops;
+                let ifmd_filler = self.ifmd_filler;
+                let ifmd_data = self.ifmd_data;
+
+                ifmd_name.hash(state);
+                ifmd_pcount.hash(state);
+                ifmd_flags.hash(state);
+                ifmd_snd_len.hash(state);
+                ifmd_snd_maxlen.hash(state);
+                ifmd_snd_drops.hash(state);
+                ifmd_filler.hash(state);
+                ifmd_data.hash(state);
+            }
+        }
+
+        impl PartialEq for ifs_iso_8802_3 {
+            fn eq(&self, other: &ifs_iso_8802_3) -> bool {
+                self.dot3StatsAlignmentErrors == other.dot3StatsAlignmentErrors
+                && self.dot3StatsFCSErrors == other.dot3StatsFCSErrors
+                && self.dot3StatsSingleCollisionFrames == other.dot3StatsSingleCollisionFrames
+                && self.dot3StatsMultipleCollisionFrames == other.dot3StatsMultipleCollisionFrames
+                && self.dot3StatsSQETestErrors == other.dot3StatsSQETestErrors
+                && self.dot3StatsDeferredTransmissions == other.dot3StatsDeferredTransmissions
+                && self.dot3StatsLateCollisions == other.dot3StatsLateCollisions
+                && self.dot3StatsExcessiveCollisions == other.dot3StatsExcessiveCollisions
+                && self.dot3StatsInternalMacTransmitErrors ==
+                    other.dot3StatsInternalMacTransmitErrors
+                && self.dot3StatsCarrierSenseErrors == other.dot3StatsCarrierSenseErrors
+                && self.dot3StatsFrameTooLongs == other.dot3StatsFrameTooLongs
+                && self.dot3StatsInternalMacReceiveErrors == other.dot3StatsInternalMacReceiveErrors
+                && self.dot3StatsEtherChipSet == other.dot3StatsEtherChipSet
+                && self.dot3StatsMissedFrames == other.dot3StatsMissedFrames
+                && self.dot3StatsCollFrequencies == other.dot3StatsCollFrequencies
+                && self.dot3Compliance == other.dot3Compliance
+            }
+        }
+
+        impl Eq for ifs_iso_8802_3 {}
+
+        impl ::fmt::Debug for ifs_iso_8802_3 {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                let dot3StatsAlignmentErrors = self.dot3StatsAlignmentErrors;
+                let dot3StatsFCSErrors = self.dot3StatsFCSErrors;
+                let dot3StatsSingleCollisionFrames = self.dot3StatsSingleCollisionFrames;
+                let dot3StatsMultipleCollisionFrames = self.dot3StatsMultipleCollisionFrames;
+                let dot3StatsSQETestErrors = self.dot3StatsSQETestErrors;
+                let dot3StatsDeferredTransmissions = self.dot3StatsDeferredTransmissions;
+                let dot3StatsLateCollisions = self.dot3StatsLateCollisions;
+                let dot3StatsExcessiveCollisions = self.dot3StatsExcessiveCollisions;
+                let dot3StatsInternalMacTransmitErrors = self.dot3StatsInternalMacTransmitErrors;
+                let dot3StatsCarrierSenseErrors = self.dot3StatsCarrierSenseErrors;
+                let dot3StatsFrameTooLongs = self.dot3StatsFrameTooLongs;
+                let dot3StatsInternalMacReceiveErrors = self.dot3StatsInternalMacReceiveErrors;
+                let dot3StatsEtherChipSet = self.dot3StatsEtherChipSet;
+                let dot3StatsMissedFrames = self.dot3StatsMissedFrames;
+                let dot3StatsCollFrequencies = self.dot3StatsCollFrequencies;
+                let dot3Compliance = self.dot3Compliance;
+
+                f.debug_struct("ifs_iso_8802_3")
+                    .field("dot3StatsAlignmentErrors", &dot3StatsAlignmentErrors)
+                    .field("dot3StatsFCSErrors", &dot3StatsFCSErrors)
+                    .field("dot3StatsSingleCollisionFrames", &dot3StatsSingleCollisionFrames)
+                    .field("dot3StatsMultipleCollisionFrames", &dot3StatsMultipleCollisionFrames)
+                    .field("dot3StatsSQETestErrors", &dot3StatsSQETestErrors)
+                    .field("dot3StatsDeferredTransmissions", &dot3StatsDeferredTransmissions)
+                    .field("dot3StatsLateCollisions", &dot3StatsLateCollisions)
+                    .field("dot3StatsExcessiveCollisions", &dot3StatsExcessiveCollisions)
+                    .field(
+                        "dot3StatsInternalMacTransmitErrors", &dot3StatsInternalMacTransmitErrors)
+                    .field("dot3StatsCarrierSenseErrors", &dot3StatsCarrierSenseErrors)
+                    .field("dot3StatsFrameTooLongs", &dot3StatsFrameTooLongs)
+                    .field("dot3StatsInternalMacReceiveErrors", &dot3StatsInternalMacReceiveErrors)
+                    .field("dot3StatsEtherChipSet", &dot3StatsEtherChipSet)
+                    .field("dot3StatsMissedFrames", &dot3StatsMissedFrames)
+                    .field("dot3StatsCollFrequencies", &dot3StatsCollFrequencies)
+                    .field("dot3Compliance", &dot3Compliance)
+                    .finish()
+            }
+        }
+
+        impl ::hash::Hash for ifs_iso_8802_3 {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                let dot3StatsAlignmentErrors = self.dot3StatsAlignmentErrors;
+                let dot3StatsFCSErrors = self.dot3StatsFCSErrors;
+                let dot3StatsSingleCollisionFrames = self.dot3StatsSingleCollisionFrames;
+                let dot3StatsMultipleCollisionFrames = self.dot3StatsMultipleCollisionFrames;
+                let dot3StatsSQETestErrors = self.dot3StatsSQETestErrors;
+                let dot3StatsDeferredTransmissions = self.dot3StatsDeferredTransmissions;
+                let dot3StatsLateCollisions = self.dot3StatsLateCollisions;
+                let dot3StatsExcessiveCollisions = self.dot3StatsExcessiveCollisions;
+                let dot3StatsInternalMacTransmitErrors = self.dot3StatsInternalMacTransmitErrors;
+                let dot3StatsCarrierSenseErrors = self.dot3StatsCarrierSenseErrors;
+                let dot3StatsFrameTooLongs = self.dot3StatsFrameTooLongs;
+                let dot3StatsInternalMacReceiveErrors = self.dot3StatsInternalMacReceiveErrors;
+                let dot3StatsEtherChipSet = self.dot3StatsEtherChipSet;
+                let dot3StatsMissedFrames = self.dot3StatsMissedFrames;
+                let dot3StatsCollFrequencies = self.dot3StatsCollFrequencies;
+                let dot3Compliance = self.dot3Compliance;
+
+                dot3StatsAlignmentErrors.hash(state);
+                dot3StatsFCSErrors.hash(state);
+                dot3StatsSingleCollisionFrames.hash(state);
+                dot3StatsMultipleCollisionFrames.hash(state);
+                dot3StatsSQETestErrors.hash(state);
+                dot3StatsDeferredTransmissions.hash(state);
+                dot3StatsLateCollisions.hash(state);
+                dot3StatsExcessiveCollisions.hash(state);
+                dot3StatsInternalMacTransmitErrors.hash(state);
+                dot3StatsCarrierSenseErrors.hash(state);
+                dot3StatsFrameTooLongs.hash(state);
+                dot3StatsInternalMacReceiveErrors.hash(state);
+                dot3StatsEtherChipSet.hash(state);
+                dot3StatsMissedFrames.hash(state);
+                dot3StatsCollFrequencies.hash(state);
+                dot3Compliance.hash(state);
+            }
+        }
+
+        impl PartialEq for ifs_iso_8802_3 {
+            fn eq(&self, other: &ifs_iso_8802_3) -> bool {
+                self.iffmid_len = other.iffmid_len
+                && self.iffmid_id = other.iffmid_id
+                && self.iffmid_str = other.iffmid_str
+            }
+        }
+
+        impl Eq for ifs_iso_8802_3 {}
+
+        impl ::fmt::Debug for ifs_iso_8802_3 {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                let iffmid_len = self.iffmid_len;
+                let iffmid_id = self.iffmid_id;
+                let iffmid_str = self.iffmid_str;
+
+                f.debug_struct("ifs_iso_8802_3")
+                    .field("iffmid_len", &iffmid_len)
+                    .field("iffmid_id", &iffmid_id)
+                    .field("iffmid_str", &iffmid_str)
+                    .finish()
+            }
+        }
+
+        impl ::hash::Hash for ifs_iso_8802_3 {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                let iffmid_len = self.iffmid_len;
+                let iffmid_id = self.iffmid_id;
+                let iffmid_str = self.iffmid_str;
+
+                iffmid_len.hash(state);
+                iffmid_id.hash(state);
+                iffmid_str.hash(state);
+            }
+        }
     }
 }
 
@@ -5496,6 +5740,32 @@ pub const HOST_VM_INFO64_COUNT: mach_msg_type_number_t =
     (::mem::size_of::<vm_statistics64_data_t>() / ::mem::size_of::<integer_t>())
         as mach_msg_type_number_t;
 
+// bsd/net/if_mib.h
+/// Non-interface-specific
+pub const IFMIB_SYSTEM: ::c_int = 1;
+/// Per-interface data table
+pub const IFMIB_IFDATA: ::c_int = 2;
+/// All interfaces data at once
+pub const IFMIB_IFALLDATA: ::c_int = 3;
+
+/// Generic stats for all kinds of ifaces
+pub const IFDATA_GENERAL: ::c_int = 1;
+/// Specific to the type of interface
+pub const IFDATA_LINKSPECIFIC: ::c_int = 2;
+/// Addresses assigned to interface
+pub const IFDATA_ADDRS: ::c_int = 3;
+/// Multicast addresses assigned to interface
+pub const IFDATA_MULTIADDRS: ::c_int = 4;
+
+/// Number of interfaces configured
+pub const IFMIB_IFCOUNT: ::c_int = 1;
+
+/// Functions not specific to a type of iface
+pub const NETLINK_GENERIC: ::c_int = 0;
+
+pub const DOT3COMPLIANCE_STATS: ::c_int = 1;
+pub const DOT3COMPLIANCE_COLLS: ::c_int = 2;
+
 f! {
     pub fn CMSG_NXTHDR(mhdr: *const ::msghdr,
                        cmsg: *const ::cmsghdr) -> *mut ::cmsghdr {