Update src/sys/socket/addr.rs

Author: luozijun

src/sys/socket/addr.rs

@@ -206,7 +206,7 @@ impl AddressFamily {
     /// Create a new `AddressFamily` from an integer value retrieved from `libc`, usually from
     /// the `sa_family` field of a `sockaddr`.
     ///
-    /// Currently only supports these address families: Unix, Inet (v4 & v6), Netlink
+    /// Currently only supports these address families: Unix, Inet (v4 & v6), Netlink, Link 
     /// and System. Returns None for unsupported or unknown address families.
     pub fn from_i32(family: i32) -> Option<AddressFamily> {
         match family {
@@ -798,52 +798,22 @@ impl SockAddr {
                 #[cfg(any(target_os = "ios", target_os = "macos"))]
                 Some(AddressFamily::System) => Some(SockAddr::SysControl(
                     SysControlAddr(*(addr as *const sys_control::sockaddr_ctl)))),
-                // FIXME: android is same ?
-                // #[cfg(any(target_os = "android", target_os = "linux"))]
-                #[cfg(target_os = "linux")]
-                Some(AddressFamily::Packet) => {
-                    let sll: *const libc::sockaddr_ll = mem::transmute(addr);
-                    let mac = EtherAddr((*sll).sll_addr[0],
-                                      (*sll).sll_addr[1],
-                                      (*sll).sll_addr[2],
-                                      (*sll).sll_addr[3],
-                                      (*sll).sll_addr[4],
-                                      (*sll).sll_addr[5]);
-                    Some(SockAddr::Ether(mac))
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                Some(AddressFamily::Packet) => match EtherAddr::from_libc_sockaddr_ll(
+                    addr as *const libc::sockaddr_ll) {
+                        Some(mac_addr) => Some(SockAddr::Ether(mac_addr)),
+                        None => None
                 },
                 #[cfg(any(target_os = "dragonfly",
-                  target_os = "freebsd",
-                  target_os = "ios",
-                  target_os = "macos",
-                  target_os = "netbsd",
-                  target_os = "openbsd"))]
-                Some(AddressFamily::Link) => {
-                    let sdl: *const libc::sockaddr_dl = mem::transmute(addr);
-                    let nlen = (*sdl).sdl_nlen as usize;
-                    let max_nlen: usize = if cfg!(target_os = "macos") {
-                        12
-                    } else if cfg!(target_os = "freebsd") {
-                        46
-                    } else if cfg!(target_os = "dragonfly") {
-                        12
-                    } else if cfg!(target_os = "netbsd") {
-                        12
-                    } else if cfg!(target_os = "openbsd") {
-                        24
-                    } else {
-                        return None;
-                    };
-                    if nlen + 5 >= max_nlen {
-                        return None;
-                    }
-                    let mac = EtherAddr((*sdl).sdl_data[nlen] as u8,
-                                      (*sdl).sdl_data[nlen + 1] as u8,
-                                      (*sdl).sdl_data[nlen + 2] as u8,
-                                      (*sdl).sdl_data[nlen + 3] as u8,
-                                      (*sdl).sdl_data[nlen + 4] as u8,
-                                      (*sdl).sdl_data[nlen + 5] as u8);
-
-                    Some(SockAddr::Ether(mac))
+                          target_os = "freebsd",
+                          target_os = "ios",
+                          target_os = "macos",
+                          target_os = "netbsd",
+                          target_os = "openbsd"))]
+                Some(AddressFamily::Link) => match EtherAddr::from_libc_sockaddr_dl(
+                        addr as *const libc::sockaddr_dl) {
+                            Some(mac_addr) => Some(SockAddr::Ether(mac_addr)),
+                            None => None
                 },
                 // Other address families are currently not supported and simply yield a None
                 // entry instead of a proper conversion to a `SockAddr`.
@@ -1091,23 +1061,83 @@ pub mod sys_control {
 }
 
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
-pub struct EtherAddr(pub u8, pub u8, pub u8, pub u8, pub u8, pub u8);
+pub struct EtherAddr {
+    pub a: u8,
+    pub b: u8,
+    pub c: u8,
+    pub d: u8,
+    pub e: u8,
+    pub f: u8,
+}
 
 impl EtherAddr {
     pub fn new(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8) -> EtherAddr {
-        EtherAddr(a, b, c, d, e, f)
+        EtherAddr {
+            a: a,
+            b: b,
+            c: c,
+            d: d,
+            e: e,
+            f: f,
+        }
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    pub unsafe fn from_libc_sockaddr_ll(sll: *const libc::sockaddr_ll) -> Option<EtherAddr> {
+        let mac = EtherAddr::new(
+                    (*sll).sll_addr[0],
+                    (*sll).sll_addr[1],
+                    (*sll).sll_addr[2],
+                    (*sll).sll_addr[3],
+                    (*sll).sll_addr[4],
+                    (*sll).sll_addr[5]);
+        Some(mac)
+    }
+
+    #[cfg(any(target_os = "dragonfly",
+              target_os = "freebsd",
+              target_os = "ios",
+              target_os = "macos",
+              target_os = "netbsd",
+              target_os = "openbsd"))]
+    pub unsafe fn from_libc_sockaddr_dl(sdl: *const libc::sockaddr_dl) -> Option<EtherAddr> {
+        let nlen = (*sdl).sdl_nlen as usize;
+        let max_nlen: usize = if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
+            12
+        } else if cfg!(target_os = "freebsd") {
+            46
+        } else if cfg!(target_os = "dragonfly") {
+            12
+        } else if cfg!(target_os = "netbsd") {
+            12
+        } else if cfg!(target_os = "openbsd") {
+            24
+        } else {
+            unreachable!();
+        };
+        if nlen + 5 >= max_nlen {
+            return None;
+        }
+        let mac = EtherAddr::new(
+                    (*sdl).sdl_data[nlen    ] as u8,
+                    (*sdl).sdl_data[nlen + 1] as u8,
+                    (*sdl).sdl_data[nlen + 2] as u8,
+                    (*sdl).sdl_data[nlen + 3] as u8,
+                    (*sdl).sdl_data[nlen + 4] as u8,
+                    (*sdl).sdl_data[nlen + 5] as u8);
+        Some(mac)
     }
 }
 
 impl fmt::Display for EtherAddr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
-            self.0,
-            self.1,
-            self.2,
-            self.3,
-            self.4,
-            self.5)
+            self.a,
+            self.b,
+            self.c,
+            self.d,
+            self.e,
+            self.f)
     }
 }