Use ptr::addr_of

As recommended by Clippy.

Author: Thomasdezeeuw

src/sockaddr.rs

@@ -169,7 +169,7 @@ impl SockAddr {
 
     /// Returns a raw pointer to the address.
     pub const fn as_ptr(&self) -> *const sockaddr {
-        &self.storage as *const _ as *const _
+        ptr::addr_of!(self.storage).cast()
     }
 
     /// Returns true if this address is in the `AF_INET` (IPv4) family, false otherwise.
@@ -193,16 +193,16 @@ impl SockAddr {
     /// or `AF_INET6` (IPv6) family, otherwise returns `None`.
     pub fn as_socket(&self) -> Option<SocketAddr> {
         if self.storage.ss_family == AF_INET as sa_family_t {
-            // Safety: if the ss_family field is AF_INET then storage must be a sockaddr_in.
-            let addr = unsafe { &*(&self.storage as *const _ as *const sockaddr_in) };
-
+            // SAFETY: if the `ss_family` field is `AF_INET` then storage must
+            // be a `sockaddr_in`.
+            let addr = unsafe { &*(ptr::addr_of!(self.storage).cast::<sockaddr_in>()) };
             let ip = crate::sys::from_in_addr(addr.sin_addr);
             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 {
-            // Safety: if the ss_family field is AF_INET6 then storage must be a sockaddr_in6.
-            let addr = unsafe { &*(&self.storage as *const _ as *const sockaddr_in6) };
-
+            // SAFETY: if the `ss_family` field is `AF_INET6` then storage must
+            // be a `sockaddr_in6`.
+            let addr = unsafe { &*(ptr::addr_of!(self.storage).cast::<sockaddr_in6>()) };
             let ip = crate::sys::from_in6_addr(addr.sin6_addr);
             let port = u16::from_be(addr.sin6_port);
             Some(SocketAddr::V6(SocketAddrV6::new(

src/sys/unix.rs

@@ -46,7 +46,7 @@ use std::{io, slice};
 
 #[cfg(not(target_vendor = "apple"))]
 use libc::ssize_t;
-use libc::{c_void, in6_addr, in_addr};
+use libc::{in6_addr, in_addr};
 
 #[cfg(not(target_os = "redox"))]
 use crate::RecvFlags;
@@ -458,8 +458,7 @@ pub(crate) fn unix_sockaddr(path: &Path) -> io::Result<SockAddr> {
     // SAFETY: a `sockaddr_storage` of all zeros is valid.
     let mut storage = unsafe { mem::zeroed::<sockaddr_storage>() };
     let len = {
-        let storage: &mut libc::sockaddr_un =
-            unsafe { &mut *(&mut storage as *mut sockaddr_storage).cast() };
+        let storage = unsafe { &mut *ptr::addr_of_mut!(storage).cast::<libc::sockaddr_un>() };
 
         let bytes = path.as_os_str().as_bytes();
         let too_long = match bytes.first() {
@@ -483,13 +482,13 @@ pub(crate) fn unix_sockaddr(path: &Path) -> io::Result<SockAddr> {
         unsafe {
             ptr::copy_nonoverlapping(
                 bytes.as_ptr(),
-                storage.sun_path.as_mut_ptr() as *mut u8,
+                storage.sun_path.as_mut_ptr().cast(),
                 bytes.len(),
             )
         };
 
         let base = storage as *const _ as usize;
-        let path = &storage.sun_path as *const _ as usize;
+        let path = ptr::addr_of!(storage.sun_path) as usize;
         let sun_path_offset = path - base;
         sun_path_offset
             + bytes.len()
@@ -955,7 +954,7 @@ pub(crate) unsafe fn setsockopt<T>(
     val: c_int,
     payload: T,
 ) -> io::Result<()> {
-    let payload = &payload as *const T as *const c_void;
+    let payload = ptr::addr_of!(payload).cast();
     syscall!(setsockopt(
         fd,
         opt,