do not panic on errors, rather propagate errors

Author: OliLay

Cargo.lock

@@ -49,14 +49,14 @@ async fn resolve_advanced(mac_addr: MacAddr, ip_addr: Ipv4Addr) {
     */
 
     let arp_request =
-        ArpMessage::new_arp_request(iface.get_mac().into(), iface.get_ip().unwrap(), ip_addr);
+        ArpMessage::new_arp_request(iface.get_mac().unwrap().into(), iface.get_ip().unwrap(), ip_addr);
     let result = client.send_message(None, arp_request).await.unwrap();
     println!(
         "Advanced: IP for MAC {} is {}",
         mac_addr, result.target_protocol_address
     );
 
-    let rarp_request = ArpMessage::new_rarp_request(iface.get_mac().into(), mac_addr);
+    let rarp_request = ArpMessage::new_rarp_request(iface.get_mac().unwrap().into(), mac_addr);
     let result = client.send_message(None, rarp_request).await.unwrap();
     println!(
         "Advanced: MAC for IP {} is {}",

examples/async-example/async-example.rs

@@ -30,17 +30,21 @@ fn resolve_advanced(mac_addr: MacAddr, ip_addr: Ipv4Addr) {
     The following code may not lead to the same result as the previous code,
     as checking if the ARP response is related to us (or if it even is a response) is omitted.
     One would have to implement these checks manually, similar to how it is done in the
-    client's mac_to_ip and ip_to_mac methods. 
-    */ 
+    client's mac_to_ip and ip_to_mac methods.
+    */
 
-    let arp_request = ArpMessage::new_arp_request(iface.get_mac().into(), iface.get_ip().unwrap(), ip_addr);
+    let arp_request = ArpMessage::new_arp_request(
+        iface.get_mac().unwrap().into(),
+        iface.get_ip().unwrap(),
+        ip_addr,
+    );
     let result = client.send_message(None, arp_request).unwrap();
     println!(
         "Advanced: IP for MAC {} is {}",
         mac_addr, result.target_protocol_address
     );
 
-    let rarp_request = ArpMessage::new_rarp_request(iface.get_mac().into(), mac_addr);
+    let rarp_request = ArpMessage::new_rarp_request(iface.get_mac().unwrap().into(), mac_addr);
     let result = client.send_message(None, rarp_request).unwrap();
     println!(
         "Advanced: MAC for IP {} is {}",

examples/sync-example/sync-example.rs

@@ -136,7 +136,7 @@ impl ArpMessage {
         let mut eth_packet = MutableEthernetPacket::new(&mut eth_buf).unwrap();
 
         eth_packet.set_destination(MacAddr::new(0xff, 0xff, 0xff, 0xff, 0xff, 0xff).into());
-        eth_packet.set_source(interface.get_mac().into());
+        eth_packet.set_source(interface.get_mac()?.into());
         eth_packet.set_ethertype(self.ethertype);
 
         let mut arp_buf = vec![0; 28];

src/arp.rs

@@ -25,7 +25,7 @@ pub struct ArpClient {
 impl ArpClient {
     /// Create an ARP client on a guessed, "best-suited" interface.
     pub fn new() -> Result<Self, Error> {
-        ArpClient::new_with_iface(&Interface::new())
+        ArpClient::new_with_iface(&Interface::new()?)
     }
 
     /// Create an ARP client on the interface with the name `iface_name`.
@@ -107,8 +107,8 @@ impl ArpClient {
         timeout: Option<Duration>,
     ) -> Result<MacAddr, Error> {
         let message = ArpMessage::new_arp_request(
-            self.interface.get_mac().into(),
-            self.interface.get_ip().unwrap(),
+            self.interface.get_mac()?,
+            self.interface.get_ip()?,
             ip_addr,
         );
 
@@ -133,7 +133,7 @@ impl ArpClient {
         timeout: Option<Duration>,
     ) -> Result<Ipv4Addr, Error> {
         let message =
-            ArpMessage::new_rarp_request(self.interface.get_mac().into(), mac_addr.into());
+            ArpMessage::new_rarp_request(self.interface.get_mac()?.into(), mac_addr.into());
 
         self.send_message_with_check(timeout, message, |arp_message| {
             let source_mac: MacAddr = arp_message.source_hardware_address.into();

src/client.rs

@@ -11,14 +11,20 @@ use std::{
 /// Wraps pnet's `NetworkInterface` struct for better convenience.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Interface {
-    network_interface: Option<NetworkInterface>,
+    network_interface: NetworkInterface,
 }
 
 impl Interface {
     /// Selects the first "best-suited" interface found.
-    pub fn new() -> Self {
-        Interface {
-            network_interface: Interface::get_interface_by_guess(),
+    pub fn new() -> Result<Self, Error> {
+        match Interface::get_interface_by_guess() {
+            Some(iface) => Ok(Interface {
+                network_interface: iface,
+            }),
+            None => Err(Error::new(
+                ErrorKind::NotConnected,
+                "Could not get any network interface.",
+            )),
         }
     }
 
@@ -27,36 +33,49 @@ impl Interface {
         let iface = Interface::get_interface_by_name(&interface_name);
 
         match iface {
-            Some(_) => Some(Interface {
+            Some(iface) => Some(Interface {
                 network_interface: iface,
             }),
             None => None,
         }
     }
 
     /// Returns the IPv4 address of the interface.
-    pub fn get_ip(&self) -> Option<Ipv4Addr> {
-        self.network_interface
-            .as_ref()
-            .unwrap()
+    pub fn get_ip(&self) -> Result<Ipv4Addr, Error> {
+        let ip = self
+            .network_interface
             .ips
             .iter()
             .find(|ip| ip.is_ipv4())
             .map(|ip| match ip.ip() {
                 IpAddr::V4(ip) => Some(ip),
                 _ => None,
             })
-            .unwrap()
+            .unwrap_or(None);
+
+        match ip {
+            Some(ip) => Ok(ip),
+            None => Err(Error::new(
+                ErrorKind::AddrNotAvailable,
+                "Currently selected interface does not have any IP address assigned.",
+            )),
+        }
     }
 
     /// Returns the MAC address assigned to the interface.
-    pub fn get_mac(&self) -> MacAddr {
-        self.network_interface.as_ref().unwrap().mac.unwrap().into()
+    pub fn get_mac(&self) -> Result<MacAddr, Error> {
+        match self.network_interface.mac {
+            Some(mac) => Ok(mac.into()),
+            None => Err(Error::new(
+                ErrorKind::AddrNotAvailable,
+                "Currently selected interface does not have any MAC address assigned.",
+            )),
+        }
     }
 
     /// Returns the raw `pnet` interface instance related to the interface.
     pub fn get_raw_interface(&self) -> &NetworkInterface {
-        &self.network_interface.as_ref().unwrap()
+        &self.network_interface
     }
 
     /// Creates and returns a new Ethernet (tx, rx) channel pair on the interface.