Switch to pnet for network interface telemetry

Fixes #38

Author: rushmorem

Cargo.toml

@@ -32,8 +32,7 @@ zdaemon = "0.0.2"
 zfilexfer = "0.0.2"
 hostname = "0.1"
 czmq = { version = "0.1", optional = true }
-interfaces = "0.0.1"
-ipnetwork = "0.12"
+pnet = "0.16"
 
 [lib]
 name = "inapi"

src/error.rs

@@ -19,7 +19,6 @@ use std::ffi::CString;
 use zdaemon;
 #[cfg(feature = "remote-run")]
 use zfilexfer;
-use interfaces;
 
 pub type Result<T> = result::Result<T, Error>;
 
@@ -97,8 +96,6 @@ pub enum Error {
     #[cfg(feature = "remote-run")]
     /// ZFileXfer error
     ZFileXfer(zfilexfer::Error),
-    /// Network interface error
-    Interfaces(interfaces::InterfacesError),
 }
 
 unsafe impl Send for Error {}
@@ -138,7 +135,6 @@ impl fmt::Display for Error {
             Error::ZDaemon(ref e) => write!(f, "ZDaemon error: {}", e),
             #[cfg(feature = "remote-run")]
             Error::ZFileXfer(ref e) => write!(f, "ZFileXfer error: {}", e),
-            Error::Interfaces(ref e) => write!(f, "Interfaces error: {}", e),
         }
     }
 }
@@ -178,7 +174,6 @@ impl error::Error for Error {
             Error::ZDaemon(ref e) => e.description(),
             #[cfg(feature = "remote-run")]
             Error::ZFileXfer(ref e) => e.description(),
-            Error::Interfaces(ref e) => e.description(),
         }
     }
 }
@@ -283,12 +278,6 @@ impl convert::From<zfilexfer::Error> for Error {
     }
 }
 
-impl From<interfaces::InterfacesError> for Error {
-    fn from(err: interfaces::InterfacesError) -> Error {
-        Error::Interfaces(err)
-    }
-}
-
 #[cfg(feature = "remote-run")]
 #[derive(Debug)]
 pub struct MissingFrame {

src/host/telemetry.rs

@@ -12,6 +12,7 @@ use host::Host;
 use serde_json::Map;
 use serde_json::Value;
 use target::Target;
+#[cfg(feature = "local-run")]
 
 #[cfg(feature = "local-run")]
 #[derive(Debug, RustcEncodable)]
@@ -80,25 +81,15 @@ impl Telemetry {
         let mut net = Vec::new();
         for netif in self.net {
             let mut map: Map<String, Value> = Map::new();
-            map.insert("interface".into(), json!(netif.interface));
-            map.insert("mac".into(), json!(netif.mac));
-            if let Some(inet) = netif.inet {
-                let mut map1: Map<String, Value> = Map::new();
-                map1.insert("address".into(), json!(inet.address));
-                map1.insert("netmask".into(), json!(inet.netmask));
-                map.insert("inet".into(), json!(map1));
-            }
-            if let Some(inet6) = netif.inet6 {
-                let mut map1: Map<String, Value> = Map::new();
-                map1.insert("address".into(), json!(inet6.address));
-                map1.insert("prefixlen".into(), json!(inet6.prefixlen));
-                map1.insert("scopeid".into(), json!(inet6.scopeid));
-                map.insert("inet6".into(), json!(map1));
+            map.insert("name".into(), json!(netif.name));
+            map.insert("index".into(), json!(netif.index));
+            if let Some(mac) = netif.mac {
+                map.insert("mac".into(), json!(mac));
             }
-            if let Some(status) = netif.status {
-                let status = if status == NetifStatus::Active { "Active".to_string() } else { "Inactive".to_string() };
-                map.insert("status".into(), json!(status));
+            if let Some(ips) = netif.ips {
+                map.insert("ips".into(), json!(ips));
             }
+            map.insert("flags".into(), json!(netif.flags));
             net.push(map);
         }
 
@@ -159,33 +150,11 @@ pub struct FsMount {
 #[cfg(feature = "local-run")]
 #[derive(Debug, RustcEncodable)]
 pub struct Netif {
-    pub interface: String,
+    pub name: String,
+    pub index: u32,
     pub mac: Option<String>,
-    pub inet: Option<NetifIPv4>,
-    pub inet6: Option<NetifIPv6>,
-    pub status: Option<NetifStatus>,
-}
-
-#[cfg(feature = "local-run")]
-#[derive(Debug, RustcEncodable, PartialEq)]
-pub enum NetifStatus {
-    Active,
-    Inactive,
-}
-
-#[cfg(feature = "local-run")]
-#[derive(Debug, RustcEncodable)]
-pub struct NetifIPv4 {
-    pub address: String,
-    pub netmask: String,
-}
-
-#[cfg(feature = "local-run")]
-#[derive(Debug, RustcEncodable)]
-pub struct NetifIPv6 {
-    pub address: String,
-    pub prefixlen: u8,
-    pub scopeid: Option<String>,
+    pub ips: Option<Vec<String>>,
+    pub flags: u32,
 }
 
 #[cfg(feature = "local-run")]

src/lib.rs

@@ -42,8 +42,7 @@ extern crate tempfile;
 extern crate zdaemon;
 extern crate zfilexfer;
 extern crate hostname;
-extern crate interfaces;
-extern crate ipnetwork;
+extern crate pnet;
 
 #[macro_use]
 mod ffi_helpers;

src/target/centos.rs

@@ -181,7 +181,7 @@ impl TelemetryTarget for CentosTarget {
             try!(default::fs()),
             &hostname,
             try!(linux::memory()),
-            try!(linux::net()),
+            default::net(),
             Os::new(
                 env::consts::ARCH,
                 "redhat",

src/target/debian.rs

@@ -182,7 +182,7 @@ impl TelemetryTarget for DebianTarget {
             try!(default::fs()),
             &hostname,
             try!(linux::memory()),
-            try!(linux::net()),
+            default::net(),
             Os::new(env::consts::ARCH, "debian", "debian", &version_str, version_maj, version_min, 0), // No known patch version
         );
 

src/target/default_base.rs

@@ -9,12 +9,13 @@
 use command::CommandResult;
 use error::{Error, Result};
 use host::Host;
-use host::telemetry::{FsMount, Netif, NetifIPv4, NetifIPv6, NetifStatus};
+use host::telemetry::{FsMount, Netif};
 use package::providers::{ProviderFactory, Providers};
 use regex::Regex;
 use std::{fs, process, str};
 use std::path::Path;
 use hostname::get_hostname;
+use pnet::datalink::interfaces;
 
 pub fn default_provider(host: &mut Host, providers: Vec<Providers>) -> Result<Providers> {
     for p in providers {
@@ -204,79 +205,16 @@ pub fn parse_fs(fields: Vec<FsFieldOrder>) -> Result<Vec<FsMount>> {
     Ok(fs)
 }
 
-pub fn parse_nettools_net(if_pattern: &str, kv_pattern: &str, ipv4_pattern: &str, ipv6_pattern: &str) -> Result<Vec<Netif>> {
-    let ifconfig_out = try!(process::Command::new("ifconfig").output());
-    let ifconfig = try!(str::from_utf8(&ifconfig_out.stdout));
-
-    // Rust Regex doesn't support negative lookahead, so we are
-    // forced to pass this line by line.
-    // Match interfaces:
-    // (?m:^([a-z]+[0-9]+):((?:(?!^[a-z]+[0-9]+:).)+))
-    // Match options:
-    // (?m:^\s*([a-z0-9]+)(?:\s|:\s|=)(.+))
-    let if_regex = Regex::new(if_pattern).unwrap();
-
-    let mut net = vec!();
-
-    for cap in if_regex.captures_iter(ifconfig) {
-        net.push(try!(parse_nettools_netif(cap.name("if").unwrap().as_str(), cap.name("content").unwrap().as_str(), kv_pattern, ipv4_pattern, ipv6_pattern)));
-    }
-
-    Ok(net)
-}
-
-fn parse_nettools_netif(iface: &str, content: &str, kv_pattern: &str, ipv4_pattern: &str, ipv6_pattern: &str) -> Result<Netif> {
-    let mut netif = Netif {
-        interface: iface.to_string(),
-        mac: None,
-        inet: None,
-        inet6: None,
-        status: None,
-    };
-
-    let kv_regex = Regex::new(kv_pattern).unwrap();
-    let ipv4_regex = Regex::new(ipv4_pattern).unwrap();
-    let ipv6_regex = Regex::new(ipv6_pattern).unwrap();
-
-    let lines: Vec<&str> = content.lines().collect();
-    for line in lines {
-        if let Some(kv_capture) = kv_regex.captures(line) {
-            let value = kv_capture.name("value").unwrap().as_str().trim();
-
-            match kv_capture.name("key").unwrap().as_str() {
-                "ether" | "HWaddr" => netif.mac = Some(value.to_string()),
-                "inet" => {
-                    if let Some(ipv4_capture) = ipv4_regex.captures(value) {
-                        netif.inet = Some(NetifIPv4 {
-                            address: ipv4_capture.name("ip").unwrap().as_str().to_string(),
-                            netmask: ipv4_capture.name("mask").unwrap().as_str().to_string(),
-                        });
-                    }
-                },
-                "inet6" => {
-                    if let Some(ipv6_capture) = ipv6_regex.captures(value) {
-                        netif.inet6 = Some(NetifIPv6 {
-                            address: ipv6_capture.name("ip").unwrap().as_str().to_string(),
-                            prefixlen: try!(ipv6_capture.name("prefix").unwrap().as_str().parse::<u8>()),
-                            scopeid: if ipv6_capture.name("scope").is_some() {
-                                Some(ipv6_capture.name("scope").unwrap().as_str().to_string())
-                            } else {
-                                None
-                            },
-                        });
-                    }
-                },
-                "status" => netif.status = match value {
-                    "active" => Some(NetifStatus::Active),
-                    "inactive" => Some(NetifStatus::Inactive),
-                    _ => unreachable!(),
-                },
-                _ => (),
-            }
-        }
-    }
-
-    Ok(netif)
+pub fn net() -> Vec<Netif> {
+    interfaces().into_iter()
+        .map(|iface| Netif {
+            name: iface.name,
+            index: iface.index,
+            mac: iface.mac.map(|addr| addr.to_string()),
+            ips: iface.ips.map(|ips| ips.into_iter().map(|ip| ip.to_string()).collect()),
+            flags: iface.flags,
+        })
+    .collect()
 }
 
 #[cfg(test)]

src/target/fedora.rs

@@ -181,7 +181,7 @@ impl TelemetryTarget for FedoraTarget {
             try!(default::fs()),
             &hostname,
             try!(linux::memory()),
-            try!(linux::net()),
+            default::net(),
             Os::new(
                 env::consts::ARCH,
                 "redhat",

src/target/freebsd.rs

@@ -221,7 +221,7 @@ impl TelemetryTarget for Target {
             try!(default::fs()),
             &hostname,
             try!(try!(unix::get_sysctl_item("hw\\.physmem")).parse::<u64>()),
-            try!(unix::net()),
+            default::net(),
             Os::new(env::consts::ARCH, "unix", "freebsd", &version_str, version_maj, version_min, 0),
         );
 

src/target/linux_base.rs

@@ -9,17 +9,12 @@
 use command::CommandResult;
 use error::{Error, Result};
 use file::FileOwner;
-use host::telemetry::{Netif, NetifIPv4, NetifIPv6, NetifStatus};
 use regex::Regex;
 use std::{process, str};
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::Path;
-use std::net::SocketAddr;
 use target::default_base as default;
-use ipnetwork::ipv6_mask_to_prefix;
-use interfaces::Kind::{Ipv4, Ipv6};
-use interfaces::{Address, Interface, flags};
 
 pub fn file_get_owner<P: AsRef<Path>>(path: P) -> Result<FileOwner> {
     Ok(FileOwner {
@@ -110,78 +105,6 @@ fn get_cpu_item(item: &str) -> Result<String> {
     }
 }
 
-fn ipv4(a: &Address) -> Option<NetifIPv4> {
-    match a.addr {
-        Some(addr) => {
-            let address = addr.ip().to_string();
-            let netmask = a.mask
-                .and_then(|mask| Some(mask.ip().to_string()))
-                .unwrap_or(String::new());
-
-            Some(NetifIPv4 {
-                address: address,
-                netmask: netmask,
-            })
-        },
-        None => None,
-    }
-}
-
-fn ipv6(a: &Address) -> Option<NetifIPv6> {
-    if let Some(SocketAddr::V6(address)) = a.addr {
-        if let Some(SocketAddr::V6(mask)) = a.mask {
-            if let Ok(prefixlen) = ipv6_mask_to_prefix(*mask.ip()) {
-                return Some(NetifIPv6 {
-                    address: address.ip().to_string(),
-                    prefixlen: prefixlen,
-                    scopeid: Some(address.scope_id().to_string()),
-                });
-            }
-        }
-    }
-    None
-}
-
-pub fn net() -> Result<Vec<Netif>> {
-    let mut ifaces = Vec::new();
-
-    for iface in Interface::get_all()? {
-        let mac = match iface.hardware_addr() {
-            Ok(addr) => Some(addr.as_string()),
-            Err(_) => None,
-        };
-
-        let inet = iface.addresses.iter()
-            .filter(|addr| addr.kind == Ipv4)
-            .next()
-            .and_then(|addr| ipv4(addr));
-
-        let inet6 = iface.addresses.iter()
-            .filter(|addr| addr.kind == Ipv6)
-            .next()
-            .and_then(|addr| ipv6(addr));
-
-        let up = iface.is_up();
-        let running = iface.flags.contains(flags::IFF_RUNNING);
-
-        let status = if up && running {
-            Some(NetifStatus::Active)
-        } else {
-            Some(NetifStatus::Inactive)
-        };
-
-        ifaces.push(Netif {
-            interface: iface.name.to_string(),
-            mac: mac,
-            inet: inet,
-            inet6: inet6,
-            status: status,
-        });
-    }
-
-    Ok(ifaces)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -219,6 +142,6 @@ mod tests {
     #[test]
     fn test_net() {
         // XXX Not a proper test. Requires mocking.
-        assert!(net().is_ok());
+        assert!(!net().is_empty());
     }
 }