Don't assume memory layout of std::net::SocketAddr (0.3.x)

Cargo.toml

@@ -21,7 +21,7 @@ features = ["handleapi", "ws2def", "ws2ipdef", "ws2tcpip", "minwindef"]
 
 [target."cfg(any(unix, target_os = \"redox\"))".dependencies]
 cfg-if = "0.1.6"
-libc = "0.2.66"
+libc = { version = "0.2.66", features = ["align"] }
 
 [target."cfg(target_os = \"redox\")".dependencies]
 redox_syscall = "0.1.38"

src/sockaddr.rs

@@ -1,14 +1,18 @@
 use std::fmt;
 use std::mem::{self, MaybeUninit};
-use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::ptr;
 
 #[cfg(any(unix, target_os = "redox"))]
 use libc::{
-    sa_family_t, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage, socklen_t, AF_INET,
-    AF_INET6,
+    in6_addr, in_addr, sa_family_t, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage,
+    socklen_t, AF_INET, AF_INET6,
 };
 #[cfg(windows)]
+use winapi::shared::in6addr::IN6_ADDR as in6_addr;
+#[cfg(windows)]
+use winapi::shared::inaddr::IN_ADDR as in_addr;
+#[cfg(windows)]
 use winapi::shared::ws2def::{
     ADDRESS_FAMILY as sa_family_t, AF_INET, AF_INET6, SOCKADDR as sockaddr,
     SOCKADDR_IN as sockaddr_in, SOCKADDR_STORAGE as sockaddr_storage,
@@ -120,33 +124,42 @@ impl SockAddr {
         }
     }
 
-    unsafe fn as_<T>(&self, family: sa_family_t) -> Option<T> {
-        if self.storage.ss_family != family {
-            return None;
-        }
-
-        Some(mem::transmute_copy(&self.storage))
-    }
-
     /// Returns this address as a `SocketAddrV4` if it is in the `AF_INET`
     /// family.
     pub fn as_inet(&self) -> Option<SocketAddrV4> {
-        unsafe { self.as_(AF_INET as sa_family_t) }
+        match self.as_std() {
+            Some(SocketAddr::V4(addr)) => Some(addr),
+            _ => None,
+        }
     }
 
     /// Returns this address as a `SocketAddrV6` if it is in the `AF_INET6`
     /// family.
     pub fn as_inet6(&self) -> Option<SocketAddrV6> {
-        unsafe { self.as_(AF_INET6 as sa_family_t) }
+        match self.as_std() {
+            Some(SocketAddr::V6(addr)) => Some(addr),
+            _ => None,
+        }
     }
 
     /// Returns this address as a `SocketAddr` if it is in the `AF_INET`
     /// or `AF_INET6` family, otherwise returns `None`.
     pub fn as_std(&self) -> Option<SocketAddr> {
-        if let Some(addr) = self.as_inet() {
-            Some(SocketAddr::V4(addr))
-        } else if let Some(addr) = self.as_inet6() {
-            Some(SocketAddr::V6(addr))
+        if self.storage.ss_family == AF_INET as sa_family_t {
+            let addr = unsafe { &*(&self.storage as *const _ as *const sockaddr_in) };
+            let ip = Ipv4Addr::from(addr.sin_addr.s_addr.to_ne_bytes());
+            let port = u16::from_be(addr.sin_port);
+            Some(SocketAddr::V4(SocketAddrV4::new(ip, port)))
+        } else if self.storage.ss_family == AF_INET6 as sa_family_t {
+            let addr = unsafe { &*(&self.storage as *const _ as *const sockaddr_in6) };
+            let ip = Ipv6Addr::from(addr.sin6_addr.s6_addr);
+            let port = u16::from_be(addr.sin6_port);
+            Some(SocketAddr::V6(SocketAddrV6::new(
+                ip,
+                port,
+                addr.sin6_flowinfo,
+                addr.sin6_scope_id,
+            )))
         } else {
             None
         }
@@ -168,34 +181,42 @@ impl SockAddr {
     }
 }
 
-// SocketAddrV4 and SocketAddrV6 are just wrappers around sockaddr_in and sockaddr_in6
-
-// check to make sure that the sizes at least match up
-fn _size_checks(v4: SocketAddrV4, v6: SocketAddrV6) {
-    unsafe {
-        mem::transmute::<SocketAddrV4, sockaddr_in>(v4);
-        mem::transmute::<SocketAddrV6, sockaddr_in6>(v6);
-    }
-}
-
 impl From<SocketAddrV4> for SockAddr {
     fn from(addr: SocketAddrV4) -> SockAddr {
-        unsafe {
-            SockAddr::from_raw_parts(
-                &addr as *const _ as *const _,
-                mem::size_of::<SocketAddrV4>() as socklen_t,
-            )
+        let mut storage = MaybeUninit::<sockaddr_storage>::uninit();
+        let sockaddr_in = unsafe { &mut *(storage.as_mut_ptr() as *mut sockaddr_in) };
+        *sockaddr_in = sockaddr_in {
+            sin_family: AF_INET as sa_family_t,
+            sin_port: addr.port().to_be(),
+            sin_addr: in_addr {
+                s_addr: u32::from_ne_bytes(addr.ip().octets()),
+            },
+            ..unsafe { mem::zeroed() }
+        };
+        SockAddr {
+            storage: unsafe { storage.assume_init() },
+            len: mem::size_of::<sockaddr_in>() as socklen_t,
         }
     }
 }
 
 impl From<SocketAddrV6> for SockAddr {
     fn from(addr: SocketAddrV6) -> SockAddr {
-        unsafe {
-            SockAddr::from_raw_parts(
-                &addr as *const _ as *const _,
-                mem::size_of::<SocketAddrV6>() as socklen_t,
-            )
+        let mut storage = MaybeUninit::<sockaddr_storage>::uninit();
+        let sockaddr_in6 = unsafe { &mut *(storage.as_mut_ptr() as *mut sockaddr_in6) };
+        *sockaddr_in6 = sockaddr_in6 {
+            sin6_family: AF_INET6 as sa_family_t,
+            sin6_port: addr.port().to_be(),
+            sin6_addr: in6_addr {
+                s6_addr: addr.ip().octets(),
+            },
+            sin6_flowinfo: addr.flowinfo(),
+            sin6_scope_id: addr.scope_id(),
+            ..unsafe { mem::zeroed() }
+        };
+        SockAddr {
+            storage: unsafe { storage.assume_init() },
+            len: mem::size_of::<sockaddr_in6>() as socklen_t,
         }
     }
 }