Make AsSockAddr() to replace reinterpret_cast<sockaddr*>

It's a common pattern in test code to reinterpret_cast<sockaddr*> from
sockaddr_* structs. Make AsSockAddr() for them so code looks better.

Note: Why not a wrapper type for `sockaddr_storage` and etc?
It's also a common need to have a local in-out variable of socklen_t.
Creating a wrapper type may however lead to this wrong code:
  Wrapper addr;
  socklen_t addrlen = sizeof(addr);
where sizeof(Wrapper) may not equal to sizeof(sockaddr_storage).
PiperOrigin-RevId: 368126229

19 files changed, 971 insertions, 1363 deletions

diff --git a/test/syscalls/linux/accept_bind.cc b/test/syscalls/linux/accept_bind.cc
index 119a1466b..d8fdb5f10 100644
--- a/test/syscalls/linux/accept_bind.cc
+++ b/test/syscalls/linux/accept_bind.cc
@@ -321,8 +321,7 @@ TEST_P(AllSocketPairTest, AcceptValidAddrLen) {
   struct sockaddr_un addr = {};
   socklen_t addr_len = sizeof(addr);
   ASSERT_THAT(
-      accepted = accept(sockets->first_fd(),
-                        reinterpret_cast<struct sockaddr*>(&addr), &addr_len),
+      accepted = accept(sockets->first_fd(), AsSockAddr(&addr), &addr_len),
       SyscallSucceeds());
   ASSERT_THAT(close(accepted), SyscallSucceeds());
 }
@@ -343,8 +342,7 @@ TEST_P(AllSocketPairTest, AcceptNegativeAddrLen) {
   // With a negative addr_len, accept returns EINVAL,
   struct sockaddr_un addr = {};
   socklen_t addr_len = -1;
-  ASSERT_THAT(accept(sockets->first_fd(),
-                     reinterpret_cast<struct sockaddr*>(&addr), &addr_len),
+  ASSERT_THAT(accept(sockets->first_fd(), AsSockAddr(&addr), &addr_len),
               SyscallFailsWithErrno(EINVAL));
 }
 
@@ -535,10 +533,9 @@ TEST_P(AllSocketPairTest, UnboundSenderAddr) {
 
   struct sockaddr_storage addr;
   socklen_t addr_len = sizeof(addr);
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
-                           reinterpret_cast<sockaddr*>(&addr), &addr_len),
-      SyscallSucceedsWithValue(sizeof(i)));
+  ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
+                                   AsSockAddr(&addr), &addr_len),
+              SyscallSucceedsWithValue(sizeof(i)));
   EXPECT_EQ(addr_len, 0);
 }
 
@@ -570,10 +567,9 @@ TEST_P(AllSocketPairTest, BoundSenderAddr) {
 
   struct sockaddr_storage addr;
   socklen_t addr_len = sizeof(addr);
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
-                           reinterpret_cast<sockaddr*>(&addr), &addr_len),
-      SyscallSucceedsWithValue(sizeof(i)));
+  ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
+                                   AsSockAddr(&addr), &addr_len),
+              SyscallSucceedsWithValue(sizeof(i)));
   EXPECT_EQ(addr_len, sockets->second_addr_len());
   EXPECT_EQ(
       memcmp(&addr, sockets->second_addr(),
@@ -609,10 +605,9 @@ TEST_P(AllSocketPairTest, BindAfterConnectSenderAddr) {
 
   struct sockaddr_storage addr;
   socklen_t addr_len = sizeof(addr);
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
-                           reinterpret_cast<sockaddr*>(&addr), &addr_len),
-      SyscallSucceedsWithValue(sizeof(i)));
+  ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
+                                   AsSockAddr(&addr), &addr_len),
+              SyscallSucceedsWithValue(sizeof(i)));
   EXPECT_EQ(addr_len, sockets->second_addr_len());
   EXPECT_EQ(
       memcmp(&addr, sockets->second_addr(),
@@ -648,10 +643,9 @@ TEST_P(AllSocketPairTest, BindAfterAcceptSenderAddr) {
 
   struct sockaddr_storage addr;
   socklen_t addr_len = sizeof(addr);
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
-                           reinterpret_cast<sockaddr*>(&addr), &addr_len),
-      SyscallSucceedsWithValue(sizeof(i)));
+  ASSERT_THAT(RetryEINTR(recvfrom)(accepted_fd.get(), &i, sizeof(i), 0,
+                                   AsSockAddr(&addr), &addr_len),
+              SyscallSucceedsWithValue(sizeof(i)));
   EXPECT_EQ(addr_len, sockets->second_addr_len());
   EXPECT_EQ(
       memcmp(&addr, sockets->second_addr(),
diff --git a/test/syscalls/linux/proc_net.cc b/test/syscalls/linux/proc_net.cc
index 20f1dc305..cf5c25017 100644
--- a/test/syscalls/linux/proc_net.cc
+++ b/test/syscalls/linux/proc_net.cc
@@ -263,9 +263,8 @@ TEST(ProcNetSnmp, TcpEstab_NoRandomSave) {
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = sizeof(sin);
-  ASSERT_THAT(
-      getsockname(s_listen.get(), reinterpret_cast<sockaddr*>(&sin), &addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(getsockname(s_listen.get(), AsSockAddr(&sin), &addrlen),
+              SyscallSucceeds());
 
   FileDescriptor s_connect =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(AF_INET, SOCK_STREAM, 0));
@@ -384,9 +383,8 @@ TEST(ProcNetSnmp, UdpIn_NoRandomSave) {
               SyscallSucceeds());
   // Get the port bound by the server socket.
   socklen_t addrlen = sizeof(sin);
-  ASSERT_THAT(
-      getsockname(server.get(), reinterpret_cast<sockaddr*>(&sin), &addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(getsockname(server.get(), AsSockAddr(&sin), &addrlen),
+              SyscallSucceeds());
 
   FileDescriptor client =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(AF_INET, SOCK_DGRAM, 0));
diff --git a/test/syscalls/linux/socket_bind_to_device_distribution.cc b/test/syscalls/linux/socket_bind_to_device_distribution.cc
index f8a0a80f2..73b0d2546 100644
--- a/test/syscalls/linux/socket_bind_to_device_distribution.cc
+++ b/test/syscalls/linux/socket_bind_to_device_distribution.cc
@@ -141,9 +141,8 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
                            endpoint.bind_to_device.c_str(),
                            endpoint.bind_to_device.size() + 1),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
+                SyscallSucceeds());
     ASSERT_THAT(listen(fd, 40), SyscallSucceeds());
 
     // On the first bind we need to determine which port was bound.
@@ -154,8 +153,7 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
     // Get the port bound by the listening socket.
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listener_fds[0].get(),
-                    reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+        getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -207,10 +205,9 @@ TEST_P(BindToDeviceDistributionTest, Tcp) {
   for (int32_t i = 0; i < kConnectAttempts; i++) {
     const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(
-        RetryEINTR(connect)(fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                            connector.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(RetryEINTR(connect)(fd.get(), AsSockAddr(&conn_addr),
+                                    connector.addr_len),
+                SyscallSucceeds());
 
     EXPECT_THAT(RetryEINTR(send)(fd.get(), &i, sizeof(i), 0),
                 SyscallSucceedsWithValue(sizeof(i)));
@@ -267,9 +264,8 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
                            endpoint.bind_to_device.c_str(),
                            endpoint.bind_to_device.size() + 1),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
+                SyscallSucceeds());
 
     // On the first bind we need to determine which port was bound.
     if (listener_fds.size() > 1) {
@@ -279,8 +275,7 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
     // Get the port bound by the listening socket.
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listener_fds[0].get(),
-                    reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+        getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -302,9 +297,9 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
             socklen_t addrlen = sizeof(addr);
             int data;
 
-            auto ret = RetryEINTR(recvfrom)(
-                listener_fds[i].get(), &data, sizeof(data), 0,
-                reinterpret_cast<struct sockaddr*>(&addr), &addrlen);
+            auto ret =
+                RetryEINTR(recvfrom)(listener_fds[i].get(), &data, sizeof(data),
+                                     0, AsSockAddr(&addr), &addrlen);
 
             if (packets_received < kConnectAttempts) {
               ASSERT_THAT(ret, SyscallSucceedsWithValue(sizeof(data)));
@@ -322,10 +317,10 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
             // A response is required to synchronize with the main thread,
             // otherwise the main thread can send more than can fit into receive
             // queues.
-            EXPECT_THAT(RetryEINTR(sendto)(
-                            listener_fds[i].get(), &data, sizeof(data), 0,
-                            reinterpret_cast<sockaddr*>(&addr), addrlen),
-                        SyscallSucceedsWithValue(sizeof(data)));
+            EXPECT_THAT(
+                RetryEINTR(sendto)(listener_fds[i].get(), &data, sizeof(data),
+                                   0, AsSockAddr(&addr), addrlen),
+                SyscallSucceedsWithValue(sizeof(data)));
           } while (packets_received < kConnectAttempts);
 
           // Shutdown all sockets to wake up other threads.
@@ -339,8 +334,7 @@ TEST_P(BindToDeviceDistributionTest, Udp) {
     FileDescriptor const fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(connector.family(), SOCK_DGRAM, 0));
     EXPECT_THAT(RetryEINTR(sendto)(fd.get(), &i, sizeof(i), 0,
-                                   reinterpret_cast<sockaddr*>(&conn_addr),
-                                   connector.addr_len),
+                                   AsSockAddr(&conn_addr), connector.addr_len),
                 SyscallSucceedsWithValue(sizeof(i)));
     int data;
     EXPECT_THAT(RetryEINTR(recv)(fd.get(), &data, sizeof(data), 0),
diff --git a/test/syscalls/linux/socket_inet_loopback.cc b/test/syscalls/linux/socket_inet_loopback.cc
index d391363fb..6b7776186 100644
--- a/test/syscalls/linux/socket_inet_loopback.cc
+++ b/test/syscalls/linux/socket_inet_loopback.cc
@@ -190,8 +190,7 @@ TEST_P(DualStackSocketTest, AddressOperations) {
     if (sockname) {
       sockaddr_storage sock_addr;
       socklen_t addrlen = sizeof(sock_addr);
-      ASSERT_THAT(getsockname(fd.get(), reinterpret_cast<sockaddr*>(&sock_addr),
-                              &addrlen),
+      ASSERT_THAT(getsockname(fd.get(), AsSockAddr(&sock_addr), &addrlen),
                   SyscallSucceeds());
       ASSERT_EQ(addrlen, sizeof(struct sockaddr_in6));
 
@@ -200,24 +199,23 @@ TEST_P(DualStackSocketTest, AddressOperations) {
       if (operation == Operation::SendTo) {
         EXPECT_EQ(sock_addr_in6->sin6_family, AF_INET6);
         EXPECT_TRUE(IN6_IS_ADDR_UNSPECIFIED(sock_addr_in6->sin6_addr.s6_addr32))
-            << OperationToString(operation) << " getsocknam="
-            << GetAddrStr(reinterpret_cast<sockaddr*>(&sock_addr));
+            << OperationToString(operation)
+            << " getsocknam=" << GetAddrStr(AsSockAddr(&sock_addr));
 
         EXPECT_NE(sock_addr_in6->sin6_port, 0);
       } else if (IN6_IS_ADDR_V4MAPPED(
                      reinterpret_cast<const sockaddr_in6*>(addr_in)
                          ->sin6_addr.s6_addr32)) {
         EXPECT_TRUE(IN6_IS_ADDR_V4MAPPED(sock_addr_in6->sin6_addr.s6_addr32))
-            << OperationToString(operation) << " getsocknam="
-            << GetAddrStr(reinterpret_cast<sockaddr*>(&sock_addr));
+            << OperationToString(operation)
+            << " getsocknam=" << GetAddrStr(AsSockAddr(&sock_addr));
       }
     }
 
     if (peername) {
       sockaddr_storage peer_addr;
       socklen_t addrlen = sizeof(peer_addr);
-      ASSERT_THAT(getpeername(fd.get(), reinterpret_cast<sockaddr*>(&peer_addr),
-                              &addrlen),
+      ASSERT_THAT(getpeername(fd.get(), AsSockAddr(&peer_addr), &addrlen),
                   SyscallSucceeds());
       ASSERT_EQ(addrlen, sizeof(struct sockaddr_in6));
 
@@ -227,8 +225,8 @@ TEST_P(DualStackSocketTest, AddressOperations) {
         EXPECT_TRUE(IN6_IS_ADDR_V4MAPPED(
             reinterpret_cast<const sockaddr_in6*>(&peer_addr)
                 ->sin6_addr.s6_addr32))
-            << OperationToString(operation) << " getpeername="
-            << GetAddrStr(reinterpret_cast<sockaddr*>(&peer_addr));
+            << OperationToString(operation)
+            << " getpeername=" << GetAddrStr(AsSockAddr(&peer_addr));
       }
     }
   }
@@ -265,16 +263,15 @@ void tcpSimpleConnectTest(TestAddress const& listener,
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
   if (!unbound) {
-    ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                     listener.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+        SyscallSucceeds());
   }
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -284,8 +281,7 @@ void tcpSimpleConnectTest(TestAddress const& listener,
       Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -331,9 +327,9 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdownListen) {
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
 
   ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
   ASSERT_THAT(shutdown(listen_fd.get(), SHUT_RD), SyscallSucceeds());
@@ -341,8 +337,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdownListen) {
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   const uint16_t port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -357,8 +352,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdownListen) {
   for (int i = 0; i < kBacklog; i++) {
     auto client = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(RetryEINTR(connect)(client.get(),
-                                    reinterpret_cast<sockaddr*>(&conn_addr),
+    ASSERT_THAT(RetryEINTR(connect)(client.get(), AsSockAddr(&conn_addr),
                                     connector.addr_len),
                 SyscallSucceeds());
   }
@@ -380,15 +374,14 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdown) {
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -402,8 +395,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdown) {
   for (int i = 0; i < kFDs; i++) {
     auto client = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(RetryEINTR(connect)(client.get(),
-                                    reinterpret_cast<sockaddr*>(&conn_addr),
+    ASSERT_THAT(RetryEINTR(connect)(client.get(), AsSockAddr(&conn_addr),
                                     connector.addr_len),
                 SyscallSucceeds());
     ASSERT_THAT(accept(listen_fd.get(), nullptr, nullptr), SyscallSucceeds());
@@ -420,8 +412,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdown) {
   FileDescriptor new_listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   ASSERT_THAT(
-      bind(new_listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-           listener.addr_len),
+      bind(new_listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
       SyscallFailsWithErrno(EADDRINUSE));
 
   // Check that subsequent connection attempts receive a RST.
@@ -431,8 +422,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenShutdown) {
   for (int i = 0; i < kFDs; i++) {
     auto client = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(RetryEINTR(connect)(client.get(),
-                                    reinterpret_cast<sockaddr*>(&conn_addr),
+    ASSERT_THAT(RetryEINTR(connect)(client.get(), AsSockAddr(&conn_addr),
                                     connector.addr_len),
                 SyscallFailsWithErrno(ECONNREFUSED));
   }
@@ -452,15 +442,14 @@ TEST_P(SocketInetLoopbackTest, TCPListenClose) {
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -471,8 +460,7 @@ TEST_P(SocketInetLoopbackTest, TCPListenClose) {
   for (int i = 0; i < kFDs; i++) {
     auto client = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
-    int ret = connect(client.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                      connector.addr_len);
+    int ret = connect(client.get(), AsSockAddr(&conn_addr), connector.addr_len);
     if (ret != 0) {
       EXPECT_THAT(ret, SyscallFailsWithErrno(EINPROGRESS));
     }
@@ -493,9 +481,9 @@ void TestListenWhileConnect(const TestParam& param,
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   // This test is only interested in deterministically getting a socket in
   // connecting state. For that, we use a listen backlog of zero which would
   // mean there is exactly one connection that gets established and is enqueued
@@ -507,8 +495,7 @@ void TestListenWhileConnect(const TestParam& param,
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -517,10 +504,9 @@ void TestListenWhileConnect(const TestParam& param,
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
   FileDescriptor established_client = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-  ASSERT_THAT(
-      connect(established_client.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-              connector.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(established_client.get(), AsSockAddr(&conn_addr),
+                      connector.addr_len),
+              SyscallSucceeds());
 
   // Ensure that the accept queue has the completed connection.
   constexpr int kTimeout = 10000;
@@ -534,9 +520,8 @@ void TestListenWhileConnect(const TestParam& param,
   FileDescriptor connecting_client = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(connector.family(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
   // Keep the last client in connecting state.
-  int ret =
-      connect(connecting_client.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-              connector.addr_len);
+  int ret = connect(connecting_client.get(), AsSockAddr(&conn_addr),
+                    connector.addr_len);
   if (ret != 0) {
     EXPECT_THAT(ret, SyscallFailsWithErrno(EINPROGRESS));
   }
@@ -587,13 +572,12 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptBacklogSizes_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -614,11 +598,9 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptBacklogSizes_NoRandomSave) {
           Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
       sockaddr_storage conn_addr = connector.addr;
       ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-      ASSERT_THAT(
-          RetryEINTR(connect)(conn_fd.get(),
-                              reinterpret_cast<struct sockaddr*>(&conn_addr),
-                              connector.addr_len),
-          SyscallSucceeds());
+      ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
+                                      connector.addr_len),
+                  SyscallSucceeds());
       const FileDescriptor accepted =
           ASSERT_NO_ERRNO_AND_VALUE(Accept(listen_fd.get(), nullptr, nullptr));
     }
@@ -639,16 +621,15 @@ TEST_P(SocketInetLoopbackTest, TCPBacklog_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   constexpr int kBacklogSize = 2;
   ASSERT_THAT(listen(listen_fd.get(), kBacklogSize), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -662,8 +643,7 @@ TEST_P(SocketInetLoopbackTest, TCPBacklog_NoRandomSave) {
         Socket(connector.family(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
     sockaddr_storage conn_addr = connector.addr;
     ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-    ret = connect(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                  connector.addr_len);
+    ret = connect(conn_fd.get(), AsSockAddr(&conn_addr), connector.addr_len);
     if (ret != 0) {
       EXPECT_THAT(ret, SyscallFailsWithErrno(EINPROGRESS));
       pollfd pfd = {
@@ -727,16 +707,15 @@ TEST_P(SocketInetLoopbackTest, TCPBacklogAcceptAll_NoRandomSave) {
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   constexpr int kBacklog = 1;
   ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -750,16 +729,14 @@ TEST_P(SocketInetLoopbackTest, TCPBacklogAcceptAll_NoRandomSave) {
   for (auto& fd : established_clients) {
     fd = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(connect(fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                        connector.addr_len),
+    ASSERT_THAT(connect(fd.get(), AsSockAddr(&conn_addr), connector.addr_len),
                 SyscallSucceeds());
   }
   std::array<FileDescriptor, kBacklog> waiting_clients;
   for (auto& fd : waiting_clients) {
     fd = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
-    int ret = connect(fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                      connector.addr_len);
+    int ret = connect(fd.get(), AsSockAddr(&conn_addr), connector.addr_len);
     if (ret != 0) {
       EXPECT_THAT(ret, SyscallFailsWithErrno(EINPROGRESS));
     }
@@ -827,15 +804,14 @@ TEST_P(SocketInetLoopbackTest, TCPFinWait2Test_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   uint16_t const port =
@@ -853,8 +829,7 @@ TEST_P(SocketInetLoopbackTest, TCPFinWait2Test_NoRandomSave) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -866,8 +841,7 @@ TEST_P(SocketInetLoopbackTest, TCPFinWait2Test_NoRandomSave) {
   sockaddr_storage conn_bound_addr;
   socklen_t conn_addrlen = connector.addr_len;
   ASSERT_THAT(
-      getsockname(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
-                  &conn_addrlen),
+      getsockname(conn_fd.get(), AsSockAddr(&conn_bound_addr), &conn_addrlen),
       SyscallSucceeds());
 
   // close the connecting FD to trigger FIN_WAIT2  on the connected fd.
@@ -882,8 +856,7 @@ TEST_P(SocketInetLoopbackTest, TCPFinWait2Test_NoRandomSave) {
   // be restarted causing the final bind/connect to fail.
   DisableSave ds;
 
-  ASSERT_THAT(bind(conn_fd2.get(),
-                   reinterpret_cast<sockaddr*>(&conn_bound_addr), conn_addrlen),
+  ASSERT_THAT(bind(conn_fd2.get(), AsSockAddr(&conn_bound_addr), conn_addrlen),
               SyscallFailsWithErrno(EADDRINUSE));
 
   // Sleep for a little over the linger timeout to reduce flakiness in
@@ -892,10 +865,9 @@ TEST_P(SocketInetLoopbackTest, TCPFinWait2Test_NoRandomSave) {
 
   ds.reset();
 
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd2.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
-                                  conn_addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      RetryEINTR(connect)(conn_fd2.get(), AsSockAddr(&conn_addr), conn_addrlen),
+      SyscallSucceeds());
 }
 
 // TCPLinger2TimeoutAfterClose creates a pair of connected sockets
@@ -914,15 +886,14 @@ TEST_P(SocketInetLoopbackTest, TCPLinger2TimeoutAfterClose_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   uint16_t const port =
@@ -934,8 +905,7 @@ TEST_P(SocketInetLoopbackTest, TCPLinger2TimeoutAfterClose_NoRandomSave) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -947,8 +917,7 @@ TEST_P(SocketInetLoopbackTest, TCPLinger2TimeoutAfterClose_NoRandomSave) {
   sockaddr_storage conn_bound_addr;
   socklen_t conn_addrlen = connector.addr_len;
   ASSERT_THAT(
-      getsockname(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
-                  &conn_addrlen),
+      getsockname(conn_fd.get(), AsSockAddr(&conn_bound_addr), &conn_addrlen),
       SyscallSucceeds());
 
   // Disable cooperative saves after this point as TCP timers are not restored
@@ -974,13 +943,11 @@ TEST_P(SocketInetLoopbackTest, TCPLinger2TimeoutAfterClose_NoRandomSave) {
   const FileDescriptor conn_fd2 = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
 
-  ASSERT_THAT(bind(conn_fd2.get(),
-                   reinterpret_cast<sockaddr*>(&conn_bound_addr), conn_addrlen),
-              SyscallSucceeds());
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd2.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
-                                  conn_addrlen),
+  ASSERT_THAT(bind(conn_fd2.get(), AsSockAddr(&conn_bound_addr), conn_addrlen),
               SyscallSucceeds());
+  ASSERT_THAT(
+      RetryEINTR(connect)(conn_fd2.get(), AsSockAddr(&conn_addr), conn_addrlen),
+      SyscallSucceeds());
 }
 
 // TCPResetAfterClose creates a pair of connected sockets then closes
@@ -996,15 +963,14 @@ TEST_P(SocketInetLoopbackTest, TCPResetAfterClose) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   uint16_t const port =
@@ -1016,8 +982,7 @@ TEST_P(SocketInetLoopbackTest, TCPResetAfterClose) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -1065,15 +1030,14 @@ void setupTimeWaitClose(const TestAddress* listener,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
   }
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(listen_addr),
-                   listener->addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(listen_addr), listener->addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener->addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(listen_addr), &addrlen),
               SyscallSucceeds());
 
   uint16_t const port =
@@ -1095,8 +1059,7 @@ void setupTimeWaitClose(const TestAddress* listener,
 
   sockaddr_storage conn_addr = connector->addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector->family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector->addr_len),
               SyscallSucceeds());
 
@@ -1107,8 +1070,7 @@ void setupTimeWaitClose(const TestAddress* listener,
   // Get the address/port bound by the connecting socket.
   socklen_t conn_addrlen = connector->addr_len;
   ASSERT_THAT(
-      getsockname(conn_fd.get(), reinterpret_cast<sockaddr*>(conn_bound_addr),
-                  &conn_addrlen),
+      getsockname(conn_fd.get(), AsSockAddr(conn_bound_addr), &conn_addrlen),
       SyscallSucceeds());
 
   FileDescriptor active_closefd, passive_closefd;
@@ -1165,15 +1127,15 @@ TEST_P(SocketInetLoopbackTest, TCPPassiveCloseNoTimeWaitTest_NoRandomSave) {
   // bound by the conn_fd as it never entered TIME_WAIT.
   const FileDescriptor conn_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(param.connector.family(), SOCK_STREAM, IPPROTO_TCP));
-  ASSERT_THAT(bind(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
+  ASSERT_THAT(bind(conn_fd.get(), AsSockAddr(&conn_bound_addr),
                    param.connector.addr_len),
               SyscallSucceeds());
 
   FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(param.listener.family(), SOCK_STREAM, IPPROTO_TCP));
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   param.listener.addr_len),
-              SyscallFailsWithErrno(EADDRINUSE));
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), param.listener.addr_len),
+      SyscallFailsWithErrno(EADDRINUSE));
 }
 
 TEST_P(SocketInetLoopbackTest,
@@ -1189,9 +1151,9 @@ TEST_P(SocketInetLoopbackTest,
   ASSERT_THAT(setsockopt(listen_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   param.listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), param.listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Now bind and connect  new socket and verify that we can immediately rebind
@@ -1201,7 +1163,7 @@ TEST_P(SocketInetLoopbackTest,
   ASSERT_THAT(setsockopt(conn_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
+  ASSERT_THAT(bind(conn_fd.get(), AsSockAddr(&conn_bound_addr),
                    param.connector.addr_len),
               SyscallSucceeds());
 
@@ -1209,8 +1171,7 @@ TEST_P(SocketInetLoopbackTest,
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(param.listener.family(), listen_addr));
   sockaddr_storage conn_addr = param.connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(param.connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   param.connector.addr_len),
               SyscallSucceeds());
 }
@@ -1224,7 +1185,7 @@ TEST_P(SocketInetLoopbackTest, TCPActiveCloseTimeWaitTest_NoRandomSave) {
   FileDescriptor conn_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(param.connector.family(), SOCK_STREAM, IPPROTO_TCP));
 
-  ASSERT_THAT(bind(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
+  ASSERT_THAT(bind(conn_fd.get(), AsSockAddr(&conn_bound_addr),
                    param.connector.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
@@ -1240,7 +1201,7 @@ TEST_P(SocketInetLoopbackTest, TCPActiveCloseTimeWaitReuseTest_NoRandomSave) {
   ASSERT_THAT(setsockopt(conn_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(conn_fd.get(), reinterpret_cast<sockaddr*>(&conn_bound_addr),
+  ASSERT_THAT(bind(conn_fd.get(), AsSockAddr(&conn_bound_addr),
                    param.connector.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
@@ -1254,15 +1215,14 @@ TEST_P(SocketInetLoopbackTest, AcceptedInheritsTCPUserTimeout) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   const uint16_t port =
@@ -1280,8 +1240,7 @@ TEST_P(SocketInetLoopbackTest, AcceptedInheritsTCPUserTimeout) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -1308,17 +1267,16 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptAfterReset) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   {
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                    &addrlen),
+        getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
   }
 
@@ -1334,8 +1292,7 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptAfterReset) {
 
   // TODO(b/157236388): Reenable Cooperative S/R once bug is fixed.
   DisableSave ds;
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -1362,8 +1319,8 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptAfterReset) {
   sockaddr_storage accept_addr;
   socklen_t addrlen = sizeof(accept_addr);
 
-  auto accept_fd = ASSERT_NO_ERRNO_AND_VALUE(Accept(
-      listen_fd.get(), reinterpret_cast<sockaddr*>(&accept_addr), &addrlen));
+  auto accept_fd = ASSERT_NO_ERRNO_AND_VALUE(
+      Accept(listen_fd.get(), AsSockAddr(&accept_addr), &addrlen));
   ASSERT_EQ(addrlen, listener.addr_len);
 
   // Wait for accept_fd to process the RST.
@@ -1401,8 +1358,7 @@ TEST_P(SocketInetLoopbackTest, TCPAcceptAfterReset) {
     sockaddr_storage peer_addr;
     socklen_t addrlen = sizeof(peer_addr);
     // The socket is not connected anymore and should return ENOTCONN.
-    ASSERT_THAT(getpeername(accept_fd.get(),
-                            reinterpret_cast<sockaddr*>(&peer_addr), &addrlen),
+    ASSERT_THAT(getpeername(accept_fd.get(), AsSockAddr(&peer_addr), &addrlen),
                 SyscallFailsWithErrno(ENOTCONN));
   }
 }
@@ -1422,15 +1378,14 @@ TEST_P(SocketInetLoopbackTest, TCPDeferAccept_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   const uint16_t port =
@@ -1448,8 +1403,7 @@ TEST_P(SocketInetLoopbackTest, TCPDeferAccept_NoRandomSave) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -1504,15 +1458,14 @@ TEST_P(SocketInetLoopbackTest, TCPDeferAcceptTimeout_NoRandomSave) {
   const FileDescriptor listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
 
   const uint16_t port =
@@ -1530,8 +1483,7 @@ TEST_P(SocketInetLoopbackTest, TCPDeferAcceptTimeout_NoRandomSave) {
 
   sockaddr_storage conn_addr = connector.addr;
   ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
-  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&conn_addr),
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
                                   connector.addr_len),
               SyscallSucceeds());
 
@@ -1619,9 +1571,8 @@ TEST_P(SocketInetReusePortTest, TcpPortReuseMultiThread_NoRandomSave) {
     ASSERT_THAT(setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                            sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
+                SyscallSucceeds());
     ASSERT_THAT(listen(fd, 40), SyscallSucceeds());
 
     // On the first bind we need to determine which port was bound.
@@ -1632,8 +1583,7 @@ TEST_P(SocketInetReusePortTest, TcpPortReuseMultiThread_NoRandomSave) {
     // Get the port bound by the listening socket.
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listener_fds[0].get(),
-                    reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+        getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -1691,10 +1641,9 @@ TEST_P(SocketInetReusePortTest, TcpPortReuseMultiThread_NoRandomSave) {
     for (int32_t i = 0; i < kConnectAttempts; i++) {
       const FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(
           Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-      ASSERT_THAT(
-          RetryEINTR(connect)(fd.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                              connector.addr_len),
-          SyscallSucceeds());
+      ASSERT_THAT(RetryEINTR(connect)(fd.get(), AsSockAddr(&conn_addr),
+                                      connector.addr_len),
+                  SyscallSucceeds());
 
       EXPECT_THAT(RetryEINTR(send)(fd.get(), &i, sizeof(i), 0),
                   SyscallSucceedsWithValue(sizeof(i)));
@@ -1731,9 +1680,8 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThread_NoRandomSave) {
     ASSERT_THAT(setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                            sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
+                SyscallSucceeds());
 
     // On the first bind we need to determine which port was bound.
     if (i != 0) {
@@ -1743,8 +1691,7 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThread_NoRandomSave) {
     // Get the port bound by the listening socket.
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listener_fds[0].get(),
-                    reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+        getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -1767,9 +1714,9 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThread_NoRandomSave) {
             socklen_t addrlen = sizeof(addr);
             int data;
 
-            auto ret = RetryEINTR(recvfrom)(
-                listener_fds[i].get(), &data, sizeof(data), 0,
-                reinterpret_cast<struct sockaddr*>(&addr), &addrlen);
+            auto ret =
+                RetryEINTR(recvfrom)(listener_fds[i].get(), &data, sizeof(data),
+                                     0, AsSockAddr(&addr), &addrlen);
 
             if (packets_received < kConnectAttempts) {
               ASSERT_THAT(ret, SyscallSucceedsWithValue(sizeof(data)));
@@ -1787,10 +1734,10 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThread_NoRandomSave) {
             // A response is required to synchronize with the main thread,
             // otherwise the main thread can send more than can fit into receive
             // queues.
-            EXPECT_THAT(RetryEINTR(sendto)(
-                            listener_fds[i].get(), &data, sizeof(data), 0,
-                            reinterpret_cast<sockaddr*>(&addr), addrlen),
-                        SyscallSucceedsWithValue(sizeof(data)));
+            EXPECT_THAT(
+                RetryEINTR(sendto)(listener_fds[i].get(), &data, sizeof(data),
+                                   0, AsSockAddr(&addr), addrlen),
+                SyscallSucceedsWithValue(sizeof(data)));
           } while (packets_received < kConnectAttempts);
 
           // Shutdown all sockets to wake up other threads.
@@ -1803,10 +1750,10 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThread_NoRandomSave) {
     for (int i = 0; i < kConnectAttempts; i++) {
       const FileDescriptor fd =
           ASSERT_NO_ERRNO_AND_VALUE(Socket(connector.family(), SOCK_DGRAM, 0));
-      EXPECT_THAT(RetryEINTR(sendto)(fd.get(), &i, sizeof(i), 0,
-                                     reinterpret_cast<sockaddr*>(&conn_addr),
-                                     connector.addr_len),
-                  SyscallSucceedsWithValue(sizeof(i)));
+      EXPECT_THAT(
+          RetryEINTR(sendto)(fd.get(), &i, sizeof(i), 0, AsSockAddr(&conn_addr),
+                             connector.addr_len),
+          SyscallSucceedsWithValue(sizeof(i)));
       int data;
       EXPECT_THAT(RetryEINTR(recv)(fd.get(), &data, sizeof(data), 0),
                   SyscallSucceedsWithValue(sizeof(data)));
@@ -1847,9 +1794,8 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThreadShort_NoRandomSave) {
     ASSERT_THAT(setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                            sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(fd, reinterpret_cast<sockaddr*>(&listen_addr), listener.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(fd, AsSockAddr(&listen_addr), listener.addr_len),
+                SyscallSucceeds());
 
     // On the first bind we need to determine which port was bound.
     if (i != 0) {
@@ -1859,8 +1805,7 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThreadShort_NoRandomSave) {
     // Get the port bound by the listening socket.
     socklen_t addrlen = listener.addr_len;
     ASSERT_THAT(
-        getsockname(listener_fds[0].get(),
-                    reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+        getsockname(listener_fds[0].get(), AsSockAddr(&listen_addr), &addrlen),
         SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -1877,8 +1822,7 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThreadShort_NoRandomSave) {
     client_fds[i] =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(connector.family(), SOCK_DGRAM, 0));
     EXPECT_THAT(RetryEINTR(sendto)(client_fds[i].get(), &i, sizeof(i), 0,
-                                   reinterpret_cast<sockaddr*>(&conn_addr),
-                                   connector.addr_len),
+                                   AsSockAddr(&conn_addr), connector.addr_len),
                 SyscallSucceedsWithValue(sizeof(i)));
   }
   ds.reset();
@@ -1887,8 +1831,7 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThreadShort_NoRandomSave) {
   // not been change after save/restore.
   for (int i = 0; i < kConnectAttempts; i++) {
     EXPECT_THAT(RetryEINTR(sendto)(client_fds[i].get(), &i, sizeof(i), 0,
-                                   reinterpret_cast<sockaddr*>(&conn_addr),
-                                   connector.addr_len),
+                                   AsSockAddr(&conn_addr), connector.addr_len),
                 SyscallSucceedsWithValue(sizeof(i)));
   }
 
@@ -1916,9 +1859,8 @@ TEST_P(SocketInetReusePortTest, UdpPortReuseMultiThreadShort_NoRandomSave) {
       struct sockaddr_storage addr = {};
       socklen_t addrlen = sizeof(addr);
       int data;
-      EXPECT_THAT(RetryEINTR(recvfrom)(
-                      fd, &data, sizeof(data), 0,
-                      reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
+      EXPECT_THAT(RetryEINTR(recvfrom)(fd, &data, sizeof(data), 0,
+                                       AsSockAddr(&addr), &addrlen),
                   SyscallSucceedsWithValue(sizeof(data)));
       uint16_t const port =
           ASSERT_NO_ERRNO_AND_VALUE(AddrPort(connector.family(), addr));
@@ -1972,14 +1914,13 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedLoopbackOnlyReservesV4) {
     sockaddr_storage addr_dual = test_addr_dual.addr;
     const FileDescriptor fd_dual = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_dual.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                     test_addr_dual.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+        SyscallSucceeds());
 
     // Get the port that we bound.
     socklen_t addrlen = test_addr_dual.addr_len;
-    ASSERT_THAT(getsockname(fd_dual.get(),
-                            reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+    ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
                 SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -1990,8 +1931,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedLoopbackOnlyReservesV4) {
     ASSERT_NO_ERRNO(SetAddrPort(test_addr_v6.family(), &addr_v6, port));
     const FileDescriptor fd_v6 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-    int ret = bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                   test_addr_v6.addr_len);
+    int ret = bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len);
     if (ret == -1 && errno == EADDRINUSE) {
       // Port may have been in use.
       ASSERT_LT(i, 100);  // Give up after 100 tries.
@@ -2006,8 +1946,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedLoopbackOnlyReservesV4) {
     ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4.family(), &addr_v4, port));
     const FileDescriptor fd_v4 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v4.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v4.get(), reinterpret_cast<sockaddr*>(&addr_v4),
-                     test_addr_v4.addr_len),
+    ASSERT_THAT(bind(fd_v4.get(), AsSockAddr(&addr_v4), test_addr_v4.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
     // No need to try again.
@@ -2024,14 +1963,13 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedAnyOnlyReservesV4) {
     sockaddr_storage addr_dual = test_addr_dual.addr;
     const FileDescriptor fd_dual = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_dual.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                     test_addr_dual.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+        SyscallSucceeds());
 
     // Get the port that we bound.
     socklen_t addrlen = test_addr_dual.addr_len;
-    ASSERT_THAT(getsockname(fd_dual.get(),
-                            reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+    ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
                 SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2042,8 +1980,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedAnyOnlyReservesV4) {
     ASSERT_NO_ERRNO(SetAddrPort(test_addr_v6.family(), &addr_v6, port));
     const FileDescriptor fd_v6 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-    int ret = bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                   test_addr_v6.addr_len);
+    int ret = bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len);
     if (ret == -1 && errno == EADDRINUSE) {
       // Port may have been in use.
       ASSERT_LT(i, 100);  // Give up after 100 tries.
@@ -2058,8 +1995,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedAnyOnlyReservesV4) {
     ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4.family(), &addr_v4, port));
     const FileDescriptor fd_v4 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v4.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v4.get(), reinterpret_cast<sockaddr*>(&addr_v4),
-                     test_addr_v4.addr_len),
+    ASSERT_THAT(bind(fd_v4.get(), AsSockAddr(&addr_v4), test_addr_v4.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
     // No need to try again.
@@ -2075,14 +2011,13 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, DualStackV6AnyReservesEverything) {
   sockaddr_storage addr_dual = test_addr_dual.addr;
   const FileDescriptor fd_dual =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_dual.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                   test_addr_dual.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+      SyscallSucceeds());
 
   // Get the port that we bound.
   socklen_t addrlen = test_addr_dual.addr_len;
-  ASSERT_THAT(getsockname(fd_dual.get(),
-                          reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+  ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2093,8 +2028,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, DualStackV6AnyReservesEverything) {
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v6.family(), &addr_v6, port));
   const FileDescriptor fd_v6 =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                   test_addr_v6.addr_len),
+  ASSERT_THAT(bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 loopback on the same port with a v6 socket
@@ -2105,10 +2039,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, DualStackV6AnyReservesEverything) {
       SetAddrPort(test_addr_v4_mapped.family(), &addr_v4_mapped, port));
   const FileDescriptor fd_v4_mapped = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(test_addr_v4_mapped.family(), param.type, 0));
-  ASSERT_THAT(
-      bind(fd_v4_mapped.get(), reinterpret_cast<sockaddr*>(&addr_v4_mapped),
-           test_addr_v4_mapped.addr_len),
-      SyscallFailsWithErrno(EADDRINUSE));
+  ASSERT_THAT(bind(fd_v4_mapped.get(), AsSockAddr(&addr_v4_mapped),
+                   test_addr_v4_mapped.addr_len),
+              SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 loopback on the same port with a v4 socket
   // fails.
@@ -2117,8 +2050,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, DualStackV6AnyReservesEverything) {
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4.family(), &addr_v4, port));
   const FileDescriptor fd_v4 =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v4.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v4.get(), reinterpret_cast<sockaddr*>(&addr_v4),
-                   test_addr_v4.addr_len),
+  ASSERT_THAT(bind(fd_v4.get(), AsSockAddr(&addr_v4), test_addr_v4.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 any on the same port with a v4 socket
@@ -2128,7 +2060,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, DualStackV6AnyReservesEverything) {
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4_any.family(), &addr_v4_any, port));
   const FileDescriptor fd_v4_any = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(test_addr_v4_any.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v4_any.get(), reinterpret_cast<sockaddr*>(&addr_v4_any),
+  ASSERT_THAT(bind(fd_v4_any.get(), AsSockAddr(&addr_v4_any),
                    test_addr_v4_any.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
@@ -2145,14 +2077,13 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(fd_dual.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                   test_addr_dual.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+      SyscallSucceeds());
 
   // Get the port that we bound.
   socklen_t addrlen = test_addr_dual.addr_len;
-  ASSERT_THAT(getsockname(fd_dual.get(),
-                          reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+  ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2166,7 +2097,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(fd_v4_any.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(fd_v4_any.get(), reinterpret_cast<sockaddr*>(&addr_v4_any),
+  ASSERT_THAT(bind(fd_v4_any.get(), AsSockAddr(&addr_v4_any),
                    test_addr_v4_any.addr_len),
               SyscallSucceeds());
 }
@@ -2186,16 +2117,15 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(fd_dual.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                   test_addr_dual.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+      SyscallSucceeds());
 
   ASSERT_THAT(listen(fd_dual.get(), 5), SyscallSucceeds());
 
   // Get the port that we bound.
   socklen_t addrlen = test_addr_dual.addr_len;
-  ASSERT_THAT(getsockname(fd_dual.get(),
-                          reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+  ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2210,7 +2140,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
 
-  ASSERT_THAT(bind(fd_v4_any.get(), reinterpret_cast<sockaddr*>(&addr_v4_any),
+  ASSERT_THAT(bind(fd_v4_any.get(), AsSockAddr(&addr_v4_any),
                    test_addr_v4_any.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
@@ -2227,16 +2157,15 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   sockaddr_storage addr_dual = test_addr_dual.addr;
   const FileDescriptor fd_dual =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_dual.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                   test_addr_dual.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+      SyscallSucceeds());
 
   ASSERT_THAT(listen(fd_dual.get(), 5), SyscallSucceeds());
 
   // Get the port that we bound.
   socklen_t addrlen = test_addr_dual.addr_len;
-  ASSERT_THAT(getsockname(fd_dual.get(),
-                          reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+  ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2247,8 +2176,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v6.family(), &addr_v6, port));
   const FileDescriptor fd_v6 =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                   test_addr_v6.addr_len),
+  ASSERT_THAT(bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 loopback on the same port with a v6 socket
@@ -2259,10 +2187,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
       SetAddrPort(test_addr_v4_mapped.family(), &addr_v4_mapped, port));
   const FileDescriptor fd_v4_mapped = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(test_addr_v4_mapped.family(), param.type, 0));
-  ASSERT_THAT(
-      bind(fd_v4_mapped.get(), reinterpret_cast<sockaddr*>(&addr_v4_mapped),
-           test_addr_v4_mapped.addr_len),
-      SyscallFailsWithErrno(EADDRINUSE));
+  ASSERT_THAT(bind(fd_v4_mapped.get(), AsSockAddr(&addr_v4_mapped),
+                   test_addr_v4_mapped.addr_len),
+              SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 loopback on the same port with a v4 socket
   // fails.
@@ -2271,8 +2198,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4.family(), &addr_v4, port));
   const FileDescriptor fd_v4 =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v4.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v4.get(), reinterpret_cast<sockaddr*>(&addr_v4),
-                   test_addr_v4.addr_len),
+  ASSERT_THAT(bind(fd_v4.get(), AsSockAddr(&addr_v4), test_addr_v4.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 
   // Verify that binding the v4 any on the same port with a v4 socket
@@ -2282,7 +2208,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_NO_ERRNO(SetAddrPort(test_addr_v4_any.family(), &addr_v4_any, port));
   const FileDescriptor fd_v4_any = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(test_addr_v4_any.family(), param.type, 0));
-  ASSERT_THAT(bind(fd_v4_any.get(), reinterpret_cast<sockaddr*>(&addr_v4_any),
+  ASSERT_THAT(bind(fd_v4_any.get(), AsSockAddr(&addr_v4_any),
                    test_addr_v4_any.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
@@ -2299,14 +2225,13 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6OnlyV6AnyReservesV6) {
     EXPECT_THAT(setsockopt(fd_dual.get(), IPPROTO_IPV6, IPV6_V6ONLY,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(bind(fd_dual.get(), reinterpret_cast<sockaddr*>(&addr_dual),
-                     test_addr_dual.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(fd_dual.get(), AsSockAddr(&addr_dual), test_addr_dual.addr_len),
+        SyscallSucceeds());
 
     // Get the port that we bound.
     socklen_t addrlen = test_addr_dual.addr_len;
-    ASSERT_THAT(getsockname(fd_dual.get(),
-                            reinterpret_cast<sockaddr*>(&addr_dual), &addrlen),
+    ASSERT_THAT(getsockname(fd_dual.get(), AsSockAddr(&addr_dual), &addrlen),
                 SyscallSucceeds());
     uint16_t const port =
         ASSERT_NO_ERRNO_AND_VALUE(AddrPort(test_addr_dual.family(), addr_dual));
@@ -2317,8 +2242,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6OnlyV6AnyReservesV6) {
     ASSERT_NO_ERRNO(SetAddrPort(test_addr_v6.family(), &addr_v6, port));
     const FileDescriptor fd_v6 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                     test_addr_v6.addr_len),
+    ASSERT_THAT(bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that we can still bind the v4 loopback on the same port.
@@ -2328,9 +2252,8 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6OnlyV6AnyReservesV6) {
         SetAddrPort(test_addr_v4_mapped.family(), &addr_v4_mapped, port));
     const FileDescriptor fd_v4_mapped = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_v4_mapped.family(), param.type, 0));
-    int ret =
-        bind(fd_v4_mapped.get(), reinterpret_cast<sockaddr*>(&addr_v4_mapped),
-             test_addr_v4_mapped.addr_len);
+    int ret = bind(fd_v4_mapped.get(), AsSockAddr(&addr_v4_mapped),
+                   test_addr_v4_mapped.addr_len);
     if (ret == -1 && errno == EADDRINUSE) {
       // Port may have been in use.
       ASSERT_LT(i, 100);  // Give up after 100 tries.
@@ -2352,9 +2275,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReserved) {
     sockaddr_storage bound_addr = test_addr.addr;
     const FileDescriptor bound_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                     test_addr.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
+        SyscallSucceeds());
 
     // Listen iff TCP.
     if (param.type == SOCK_STREAM) {
@@ -2364,23 +2287,20 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReserved) {
     // Get the port that we bound.
     socklen_t bound_addr_len = test_addr.addr_len;
     ASSERT_THAT(
-        getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                    &bound_addr_len),
+        getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
         SyscallSucceeds());
 
     // Connect to bind an ephemeral port.
     const FileDescriptor connected_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                    reinterpret_cast<sockaddr*>(&bound_addr),
+    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                     bound_addr_len),
                 SyscallSucceeds());
 
     // Get the ephemeral port.
     sockaddr_storage connected_addr = {};
     socklen_t connected_addr_len = sizeof(connected_addr);
-    ASSERT_THAT(getsockname(connected_fd.get(),
-                            reinterpret_cast<sockaddr*>(&connected_addr),
+    ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                             &connected_addr_len),
                 SyscallSucceeds());
     uint16_t const ephemeral_port =
@@ -2392,10 +2312,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReserved) {
     // Verify that the ephemeral port is reserved.
     const FileDescriptor checking_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    EXPECT_THAT(
-        bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-             connected_addr_len),
-        SyscallFailsWithErrno(EADDRINUSE));
+    EXPECT_THAT(bind(checking_fd.get(), AsSockAddr(&connected_addr),
+                     connected_addr_len),
+                SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that binding the v6 loopback with the same port fails.
     TestAddress const& test_addr_v6 = V6Loopback();
@@ -2404,8 +2323,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReserved) {
         SetAddrPort(test_addr_v6.family(), &addr_v6, ephemeral_port));
     const FileDescriptor fd_v6 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v6.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                     test_addr_v6.addr_len),
+    ASSERT_THAT(bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that we can still bind the v4 loopback on the same port.
@@ -2415,9 +2333,8 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReserved) {
                                 ephemeral_port));
     const FileDescriptor fd_v4_mapped = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_v4_mapped.family(), param.type, 0));
-    int ret =
-        bind(fd_v4_mapped.get(), reinterpret_cast<sockaddr*>(&addr_v4_mapped),
-             test_addr_v4_mapped.addr_len);
+    int ret = bind(fd_v4_mapped.get(), AsSockAddr(&addr_v4_mapped),
+                   test_addr_v4_mapped.addr_len);
     if (ret == -1 && errno == EADDRINUSE) {
       // Port may have been in use.
       ASSERT_LT(i, 100);  // Give up after 100 tries.
@@ -2438,8 +2355,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReservedReuseAddr) {
   sockaddr_storage bound_addr = test_addr.addr;
   const FileDescriptor bound_fd =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-  ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len),
+  ASSERT_THAT(bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
               SyscallSucceeds());
   ASSERT_THAT(setsockopt(bound_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
@@ -2453,8 +2369,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReservedReuseAddr) {
   // Get the port that we bound.
   socklen_t bound_addr_len = test_addr.addr_len;
   ASSERT_THAT(
-      getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                  &bound_addr_len),
+      getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
       SyscallSucceeds());
 
   // Connect to bind an ephemeral port.
@@ -2463,16 +2378,14 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReservedReuseAddr) {
   ASSERT_THAT(setsockopt(connected_fd.get(), SOL_SOCKET, SO_REUSEADDR,
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&bound_addr),
+  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                   bound_addr_len),
               SyscallSucceeds());
 
   // Get the ephemeral port.
   sockaddr_storage connected_addr = {};
   socklen_t connected_addr_len = sizeof(connected_addr);
-  ASSERT_THAT(getsockname(connected_fd.get(),
-                          reinterpret_cast<sockaddr*>(&connected_addr),
+  ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                           &connected_addr_len),
               SyscallSucceeds());
   uint16_t const ephemeral_port =
@@ -2488,8 +2401,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V6EphemeralPortReservedReuseAddr) {
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
   EXPECT_THAT(
-      bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-           connected_addr_len),
+      bind(checking_fd.get(), AsSockAddr(&connected_addr), connected_addr_len),
       SyscallSucceeds());
 }
 
@@ -2502,9 +2414,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
     sockaddr_storage bound_addr = test_addr.addr;
     const FileDescriptor bound_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                     test_addr.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
+        SyscallSucceeds());
 
     // Listen iff TCP.
     if (param.type == SOCK_STREAM) {
@@ -2514,23 +2426,20 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
     // Get the port that we bound.
     socklen_t bound_addr_len = test_addr.addr_len;
     ASSERT_THAT(
-        getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                    &bound_addr_len),
+        getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
         SyscallSucceeds());
 
     // Connect to bind an ephemeral port.
     const FileDescriptor connected_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                    reinterpret_cast<sockaddr*>(&bound_addr),
+    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                     bound_addr_len),
                 SyscallSucceeds());
 
     // Get the ephemeral port.
     sockaddr_storage connected_addr = {};
     socklen_t connected_addr_len = sizeof(connected_addr);
-    ASSERT_THAT(getsockname(connected_fd.get(),
-                            reinterpret_cast<sockaddr*>(&connected_addr),
+    ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                             &connected_addr_len),
                 SyscallSucceeds());
     uint16_t const ephemeral_port =
@@ -2542,10 +2451,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
     // Verify that the ephemeral port is reserved.
     const FileDescriptor checking_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    EXPECT_THAT(
-        bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-             connected_addr_len),
-        SyscallFailsWithErrno(EADDRINUSE));
+    EXPECT_THAT(bind(checking_fd.get(), AsSockAddr(&connected_addr),
+                     connected_addr_len),
+                SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that binding the v4 loopback on the same port with a v4 socket
     // fails.
@@ -2555,8 +2463,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
         SetAddrPort(test_addr_v4.family(), &addr_v4, ephemeral_port));
     const FileDescriptor fd_v4 =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr_v4.family(), param.type, 0));
-    EXPECT_THAT(bind(fd_v4.get(), reinterpret_cast<sockaddr*>(&addr_v4),
-                     test_addr_v4.addr_len),
+    EXPECT_THAT(bind(fd_v4.get(), AsSockAddr(&addr_v4), test_addr_v4.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that binding the v6 any on the same port with a dual-stack socket
@@ -2567,7 +2474,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
         SetAddrPort(test_addr_v6_any.family(), &addr_v6_any, ephemeral_port));
     const FileDescriptor fd_v6_any = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_v6_any.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v6_any.get(), reinterpret_cast<sockaddr*>(&addr_v6_any),
+    ASSERT_THAT(bind(fd_v6_any.get(), AsSockAddr(&addr_v6_any),
                      test_addr_v6_any.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
@@ -2586,8 +2493,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
           SetAddrPort(test_addr_v6.family(), &addr_v6, ephemeral_port));
       const FileDescriptor fd_v6 = ASSERT_NO_ERRNO_AND_VALUE(
           Socket(test_addr_v6.family(), param.type, 0));
-      ret = bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                 test_addr_v6.addr_len);
+      ret = bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len);
     } else {
       // Verify that we can still bind the v6 any on the same port with a
       // v6-only socket.
@@ -2596,9 +2502,8 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4MappedEphemeralPortReserved) {
       EXPECT_THAT(setsockopt(fd_v6_only_any.get(), IPPROTO_IPV6, IPV6_V6ONLY,
                              &kSockOptOn, sizeof(kSockOptOn)),
                   SyscallSucceeds());
-      ret =
-          bind(fd_v6_only_any.get(), reinterpret_cast<sockaddr*>(&addr_v6_any),
-               test_addr_v6_any.addr_len);
+      ret = bind(fd_v6_only_any.get(), AsSockAddr(&addr_v6_any),
+                 test_addr_v6_any.addr_len);
     }
 
     if (ret == -1 && errno == EADDRINUSE) {
@@ -2622,8 +2527,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   sockaddr_storage bound_addr = test_addr.addr;
   const FileDescriptor bound_fd =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-  ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len),
+  ASSERT_THAT(bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
               SyscallSucceeds());
 
   ASSERT_THAT(setsockopt(bound_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
@@ -2638,8 +2542,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   // Get the port that we bound.
   socklen_t bound_addr_len = test_addr.addr_len;
   ASSERT_THAT(
-      getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                  &bound_addr_len),
+      getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
       SyscallSucceeds());
 
   // Connect to bind an ephemeral port.
@@ -2648,16 +2551,14 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(connected_fd.get(), SOL_SOCKET, SO_REUSEADDR,
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&bound_addr),
+  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                   bound_addr_len),
               SyscallSucceeds());
 
   // Get the ephemeral port.
   sockaddr_storage connected_addr = {};
   socklen_t connected_addr_len = sizeof(connected_addr);
-  ASSERT_THAT(getsockname(connected_fd.get(),
-                          reinterpret_cast<sockaddr*>(&connected_addr),
+  ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                           &connected_addr_len),
               SyscallSucceeds());
   uint16_t const ephemeral_port =
@@ -2673,8 +2574,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
   EXPECT_THAT(
-      bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-           connected_addr_len),
+      bind(checking_fd.get(), AsSockAddr(&connected_addr), connected_addr_len),
       SyscallSucceeds());
 }
 
@@ -2687,9 +2587,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
     sockaddr_storage bound_addr = test_addr.addr;
     const FileDescriptor bound_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                     test_addr.addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
+        SyscallSucceeds());
 
     // Listen iff TCP.
     if (param.type == SOCK_STREAM) {
@@ -2699,23 +2599,20 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
     // Get the port that we bound.
     socklen_t bound_addr_len = test_addr.addr_len;
     ASSERT_THAT(
-        getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                    &bound_addr_len),
+        getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
         SyscallSucceeds());
 
     // Connect to bind an ephemeral port.
     const FileDescriptor connected_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                    reinterpret_cast<sockaddr*>(&bound_addr),
+    ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                     bound_addr_len),
                 SyscallSucceeds());
 
     // Get the ephemeral port.
     sockaddr_storage connected_addr = {};
     socklen_t connected_addr_len = sizeof(connected_addr);
-    ASSERT_THAT(getsockname(connected_fd.get(),
-                            reinterpret_cast<sockaddr*>(&connected_addr),
+    ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                             &connected_addr_len),
                 SyscallSucceeds());
     uint16_t const ephemeral_port =
@@ -2727,10 +2624,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
     // Verify that the ephemeral port is reserved.
     const FileDescriptor checking_fd =
         ASSERT_NO_ERRNO_AND_VALUE(Socket(test_addr.family(), param.type, 0));
-    EXPECT_THAT(
-        bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-             connected_addr_len),
-        SyscallFailsWithErrno(EADDRINUSE));
+    EXPECT_THAT(bind(checking_fd.get(), AsSockAddr(&connected_addr),
+                     connected_addr_len),
+                SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that binding the v4 loopback on the same port with a v6 socket
     // fails.
@@ -2740,10 +2636,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
                                 ephemeral_port));
     const FileDescriptor fd_v4_mapped = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_v4_mapped.family(), param.type, 0));
-    EXPECT_THAT(
-        bind(fd_v4_mapped.get(), reinterpret_cast<sockaddr*>(&addr_v4_mapped),
-             test_addr_v4_mapped.addr_len),
-        SyscallFailsWithErrno(EADDRINUSE));
+    EXPECT_THAT(bind(fd_v4_mapped.get(), AsSockAddr(&addr_v4_mapped),
+                     test_addr_v4_mapped.addr_len),
+                SyscallFailsWithErrno(EADDRINUSE));
 
     // Verify that binding the v6 any on the same port with a dual-stack socket
     // fails.
@@ -2753,7 +2648,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
         SetAddrPort(test_addr_v6_any.family(), &addr_v6_any, ephemeral_port));
     const FileDescriptor fd_v6_any = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(test_addr_v6_any.family(), param.type, 0));
-    ASSERT_THAT(bind(fd_v6_any.get(), reinterpret_cast<sockaddr*>(&addr_v6_any),
+    ASSERT_THAT(bind(fd_v6_any.get(), AsSockAddr(&addr_v6_any),
                      test_addr_v6_any.addr_len),
                 SyscallFailsWithErrno(EADDRINUSE));
 
@@ -2772,8 +2667,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
           SetAddrPort(test_addr_v6.family(), &addr_v6, ephemeral_port));
       const FileDescriptor fd_v6 = ASSERT_NO_ERRNO_AND_VALUE(
           Socket(test_addr_v6.family(), param.type, 0));
-      ret = bind(fd_v6.get(), reinterpret_cast<sockaddr*>(&addr_v6),
-                 test_addr_v6.addr_len);
+      ret = bind(fd_v6.get(), AsSockAddr(&addr_v6), test_addr_v6.addr_len);
     } else {
       // Verify that we can still bind the v6 any on the same port with a
       // v6-only socket.
@@ -2782,9 +2676,8 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReserved) {
       EXPECT_THAT(setsockopt(fd_v6_only_any.get(), IPPROTO_IPV6, IPV6_V6ONLY,
                              &kSockOptOn, sizeof(kSockOptOn)),
                   SyscallSucceeds());
-      ret =
-          bind(fd_v6_only_any.get(), reinterpret_cast<sockaddr*>(&addr_v6_any),
-               test_addr_v6_any.addr_len);
+      ret = bind(fd_v6_only_any.get(), AsSockAddr(&addr_v6_any),
+                 test_addr_v6_any.addr_len);
     }
 
     if (ret == -1 && errno == EADDRINUSE) {
@@ -2812,8 +2705,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReservedReuseAddr) {
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
 
-  ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len),
+  ASSERT_THAT(bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
               SyscallSucceeds());
 
   // Listen iff TCP.
@@ -2824,8 +2716,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReservedReuseAddr) {
   // Get the port that we bound.
   socklen_t bound_addr_len = test_addr.addr_len;
   ASSERT_THAT(
-      getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                  &bound_addr_len),
+      getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
       SyscallSucceeds());
 
   // Connect to bind an ephemeral port.
@@ -2836,16 +2727,14 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReservedReuseAddr) {
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
 
-  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(),
-                                  reinterpret_cast<sockaddr*>(&bound_addr),
+  ASSERT_THAT(RetryEINTR(connect)(connected_fd.get(), AsSockAddr(&bound_addr),
                                   bound_addr_len),
               SyscallSucceeds());
 
   // Get the ephemeral port.
   sockaddr_storage connected_addr = {};
   socklen_t connected_addr_len = sizeof(connected_addr);
-  ASSERT_THAT(getsockname(connected_fd.get(),
-                          reinterpret_cast<sockaddr*>(&connected_addr),
+  ASSERT_THAT(getsockname(connected_fd.get(), AsSockAddr(&connected_addr),
                           &connected_addr_len),
               SyscallSucceeds());
   uint16_t const ephemeral_port =
@@ -2861,8 +2750,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, V4EphemeralPortReservedReuseAddr) {
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
   EXPECT_THAT(
-      bind(checking_fd.get(), reinterpret_cast<sockaddr*>(&connected_addr),
-           connected_addr_len),
+      bind(checking_fd.get(), AsSockAddr(&connected_addr), connected_addr_len),
       SyscallSucceeds());
 }
 
@@ -2881,14 +2769,12 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(bound_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len),
+  ASSERT_THAT(bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
               SyscallSucceeds());
   // Get the port that we bound.
   socklen_t bound_addr_len = test_addr.addr_len;
   ASSERT_THAT(
-      getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                  &bound_addr_len),
+      getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
       SyscallSucceeds());
 
   // Now create a socket and bind it to the same port, this should
@@ -2899,9 +2785,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
   ASSERT_THAT(setsockopt(second_fd.get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(second_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(second_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len),
+      SyscallSucceeds());
 }
 
 TEST_P(SocketMultiProtocolInetLoopbackTest, PortReuseTwoSockets) {
@@ -2920,10 +2806,9 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, PortReuseTwoSockets) {
         setsockopt(fd1, SOL_SOCKET, SO_REUSEPORT, &portreuse1, sizeof(int)),
         SyscallSucceeds());
 
-    ASSERT_THAT(bind(fd1, reinterpret_cast<sockaddr*>(&addr), addrlen),
-                SyscallSucceeds());
+    ASSERT_THAT(bind(fd1, AsSockAddr(&addr), addrlen), SyscallSucceeds());
 
-    ASSERT_THAT(getsockname(fd1, reinterpret_cast<sockaddr*>(&addr), &addrlen),
+    ASSERT_THAT(getsockname(fd1, AsSockAddr(&addr), &addrlen),
                 SyscallSucceeds());
     if (param.type == SOCK_STREAM) {
       ASSERT_THAT(listen(fd1, 1), SyscallSucceeds());
@@ -2942,7 +2827,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, PortReuseTwoSockets) {
           SyscallSucceeds());
 
       std::cout << portreuse1 << " " << portreuse2 << std::endl;
-      int ret = bind(fd2, reinterpret_cast<sockaddr*>(&addr), addrlen);
+      int ret = bind(fd2, AsSockAddr(&addr), addrlen);
 
       // Verify that two sockets can be bound to the same port only if
       // SO_REUSEPORT is set for both of them.
@@ -2970,10 +2855,8 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, NoReusePortFollowingReusePort) {
   ASSERT_THAT(
       setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &portreuse, sizeof(portreuse)),
       SyscallSucceeds());
-  ASSERT_THAT(bind(fd, reinterpret_cast<sockaddr*>(&addr), addrlen),
-              SyscallSucceeds());
-  ASSERT_THAT(getsockname(fd, reinterpret_cast<sockaddr*>(&addr), &addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(bind(fd, AsSockAddr(&addr), addrlen), SyscallSucceeds());
+  ASSERT_THAT(getsockname(fd, AsSockAddr(&addr), &addrlen), SyscallSucceeds());
   ASSERT_EQ(addrlen, test_addr.addr_len);
 
   s.reset();
@@ -2985,8 +2868,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest, NoReusePortFollowingReusePort) {
   ASSERT_THAT(
       setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &portreuse, sizeof(portreuse)),
       SyscallSucceeds());
-  ASSERT_THAT(bind(fd, reinterpret_cast<sockaddr*>(&addr), addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(bind(fd, AsSockAddr(&addr), addrlen), SyscallSucceeds());
 }
 
 INSTANTIATE_TEST_SUITE_P(
diff --git a/test/syscalls/linux/socket_inet_loopback_nogotsan.cc b/test/syscalls/linux/socket_inet_loopback_nogotsan.cc
index 1a0b53394..47103e99b 100644
--- a/test/syscalls/linux/socket_inet_loopback_nogotsan.cc
+++ b/test/syscalls/linux/socket_inet_loopback_nogotsan.cc
@@ -98,15 +98,14 @@ TEST_P(SocketInetLoopbackTest, DISABLED_TestTCPPortExhaustion_NoRandomSave) {
   auto listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
   sockaddr_storage listen_addr = listener.addr;
-  ASSERT_THAT(bind(listen_fd.get(), reinterpret_cast<sockaddr*>(&listen_addr),
-                   listener.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
   ASSERT_THAT(listen(listen_fd.get(), kBacklog), SyscallSucceeds());
 
   // Get the port bound by the listening socket.
   socklen_t addrlen = listener.addr_len;
-  ASSERT_THAT(getsockname(listen_fd.get(),
-                          reinterpret_cast<sockaddr*>(&listen_addr), &addrlen),
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
               SyscallSucceeds());
   uint16_t const port =
       ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
@@ -124,8 +123,7 @@ TEST_P(SocketInetLoopbackTest, DISABLED_TestTCPPortExhaustion_NoRandomSave) {
   for (int i = 0; i < kClients; i++) {
     FileDescriptor client = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
-    int ret = connect(client.get(), reinterpret_cast<sockaddr*>(&conn_addr),
-                      connector.addr_len);
+    int ret = connect(client.get(), AsSockAddr(&conn_addr), connector.addr_len);
     if (ret == 0) {
       clients.push_back(std::move(client));
       FileDescriptor server =
@@ -205,8 +203,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
 
-    int ret = bind(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                   test_addr.addr_len);
+    int ret = bind(bound_fd.get(), AsSockAddr(&bound_addr), test_addr.addr_len);
     if (ret != 0) {
       ASSERT_EQ(errno, EADDRINUSE);
       break;
@@ -214,8 +211,7 @@ TEST_P(SocketMultiProtocolInetLoopbackTest,
     // Get the port that we bound.
     socklen_t bound_addr_len = test_addr.addr_len;
     ASSERT_THAT(
-        getsockname(bound_fd.get(), reinterpret_cast<sockaddr*>(&bound_addr),
-                    &bound_addr_len),
+        getsockname(bound_fd.get(), AsSockAddr(&bound_addr), &bound_addr_len),
         SyscallSucceeds());
     uint16_t port = reinterpret_cast<sockaddr_in*>(&bound_addr)->sin_port;
 
diff --git a/test/syscalls/linux/socket_ip_unbound_netlink.cc b/test/syscalls/linux/socket_ip_unbound_netlink.cc
index 7fb1c0faf..1858dca17 100644
--- a/test/syscalls/linux/socket_ip_unbound_netlink.cc
+++ b/test/syscalls/linux/socket_ip_unbound_netlink.cc
@@ -57,8 +57,7 @@ TEST_P(IPv6UnboundSocketTest, ConnectToBadLocalAddress_NoRandomSave) {
   TestAddress addr = V6Loopback();
   reinterpret_cast<sockaddr_in6*>(&addr.addr)->sin6_port = 65535;
   auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
-  EXPECT_THAT(connect(sock->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                      addr.addr_len),
+  EXPECT_THAT(connect(sock->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EADDRNOTAVAIL));
 }
 
@@ -90,8 +89,7 @@ TEST_P(IPv4UnboundSocketTest, ConnectToBadLocalAddress_NoRandomSave) {
   TestAddress addr = V4Loopback();
   reinterpret_cast<sockaddr_in*>(&addr.addr)->sin_port = 65535;
   auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
-  EXPECT_THAT(connect(sock->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                      addr.addr_len),
+  EXPECT_THAT(connect(sock->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(ENETUNREACH));
 }
 
diff --git a/test/syscalls/linux/socket_ipv4_udp_unbound.cc b/test/syscalls/linux/socket_ipv4_udp_unbound.cc
index 8eec31a46..04fa042c4 100644
--- a/test/syscalls/linux/socket_ipv4_udp_unbound.cc
+++ b/test/syscalls/linux/socket_ipv4_udp_unbound.cc
@@ -44,20 +44,17 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNoGroup) {
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
   EXPECT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Bind the second FD to the v4 any address. If multicast worked like unicast,
   // this would ensure that we get the packet.
   auto receiver_addr = V4Any();
-  EXPECT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  EXPECT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -68,10 +65,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNoGroup) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  EXPECT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  EXPECT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -89,13 +86,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackAddrNoDefaultSendIf) {
   // Bind the second FD to the v4 any address to ensure that we can receive any
   // unicast packet.
   auto receiver_addr = V4Any();
-  EXPECT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  EXPECT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -114,10 +109,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackAddrNoDefaultSendIf) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  EXPECT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallFailsWithErrno(ENETUNREACH));
+  EXPECT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallFailsWithErrno(ENETUNREACH));
 }
 
 // Check that not setting a default send interface prevents multicast packets
@@ -129,13 +124,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNicNoDefaultSendIf) {
   // Bind the second FD to the v4 any address to ensure that we can receive any
   // unicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -154,10 +147,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNicNoDefaultSendIf) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  EXPECT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallFailsWithErrno(ENETUNREACH));
+  EXPECT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallFailsWithErrno(ENETUNREACH));
 }
 
 // Check that multicast works when the default send interface is configured by
@@ -170,20 +163,17 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackAddr) {
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
   ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -202,10 +192,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackAddr) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -226,20 +216,17 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNic) {
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
   ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -258,10 +245,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackNic) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -289,13 +276,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddr) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -314,10 +299,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddr) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -345,13 +330,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNic) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -370,10 +353,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNic) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -401,13 +384,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrConnect) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -425,8 +406,7 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrConnect) {
   reinterpret_cast<sockaddr_in*>(&connect_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   ASSERT_THAT(
-      RetryEINTR(connect)(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&connect_addr.addr),
+      RetryEINTR(connect)(socket1->get(), AsSockAddr(&connect_addr.addr),
                           connect_addr.addr_len),
       SyscallSucceeds());
 
@@ -461,13 +441,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicConnect) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -485,8 +463,7 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicConnect) {
   reinterpret_cast<sockaddr_in*>(&connect_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   ASSERT_THAT(
-      RetryEINTR(connect)(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&connect_addr.addr),
+      RetryEINTR(connect)(socket1->get(), AsSockAddr(&connect_addr.addr),
                           connect_addr.addr_len),
       SyscallSucceeds());
 
@@ -521,13 +498,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelf) {
   // Bind the first FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -546,10 +521,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelf) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -577,13 +552,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelf) {
   // Bind the first FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -602,10 +575,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelf) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -633,13 +606,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelfConnect) {
   // Bind the first FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -657,8 +628,7 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelfConnect) {
   reinterpret_cast<sockaddr_in*>(&connect_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   EXPECT_THAT(
-      RetryEINTR(connect)(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&connect_addr.addr),
+      RetryEINTR(connect)(socket1->get(), AsSockAddr(&connect_addr.addr),
                           connect_addr.addr_len),
       SyscallSucceeds());
 
@@ -691,13 +661,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelfConnect) {
   // Bind the first FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -715,8 +683,7 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelfConnect) {
   reinterpret_cast<sockaddr_in*>(&connect_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   ASSERT_THAT(
-      RetryEINTR(connect)(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&connect_addr.addr),
+      RetryEINTR(connect)(socket1->get(), AsSockAddr(&connect_addr.addr),
                           connect_addr.addr_len),
       SyscallSucceeds());
 
@@ -753,13 +720,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelfNoLoop) {
   // Bind the first FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -778,10 +743,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfAddrSelfNoLoop) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -813,13 +778,11 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelfNoLoop) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -838,10 +801,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastLoopbackIfNicSelfNoLoop) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -877,20 +840,17 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastDropAddr) {
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
   EXPECT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  EXPECT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  EXPECT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -912,10 +872,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastDropAddr) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  EXPECT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  EXPECT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -935,20 +895,17 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastDropNic) {
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
   EXPECT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  EXPECT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  EXPECT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -970,10 +927,10 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastDropNic) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  EXPECT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  EXPECT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1292,16 +1249,15 @@ TEST_P(IPv4UDPUnboundSocketTest, TestMcastReceptionOnTwoSockets) {
     ASSERT_THAT(setsockopt(sockets->second_fd(), IPPROTO_IP, IP_ADD_MEMBERSHIP,
                            &group, sizeof(group)),
                 SyscallSucceeds());
-    ASSERT_THAT(bind(sockets->second_fd(),
-                     reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+    ASSERT_THAT(bind(sockets->second_fd(), AsSockAddr(&receiver_addr.addr),
                      receiver_addr.addr_len),
                 SyscallSucceeds());
     // Get the port assigned.
     socklen_t receiver_addr_len = receiver_addr.addr_len;
-    ASSERT_THAT(getsockname(sockets->second_fd(),
-                            reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-                            &receiver_addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        getsockname(sockets->second_fd(), AsSockAddr(&receiver_addr.addr),
+                    &receiver_addr_len),
+        SyscallSucceeds());
     EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
     // On the first iteration, save the port we are bound to. On the second
     // iteration, verify the port is the same as the one from the first
@@ -1324,8 +1280,7 @@ TEST_P(IPv4UDPUnboundSocketTest, TestMcastReceptionOnTwoSockets) {
     RandomizeBuffer(send_buf, sizeof(send_buf));
     ASSERT_THAT(
         RetryEINTR(sendto)(sockets->first_fd(), send_buf, sizeof(send_buf), 0,
-                           reinterpret_cast<sockaddr*>(&send_addr.addr),
-                           send_addr.addr_len),
+                           AsSockAddr(&send_addr.addr), send_addr.addr_len),
         SyscallSucceedsWithValue(sizeof(send_buf)));
 
     // Check that we received the multicast packet on both sockets.
@@ -1367,16 +1322,15 @@ TEST_P(IPv4UDPUnboundSocketTest, TestMcastReceptionWhenDroppingMemberships) {
     ASSERT_THAT(setsockopt(sockets->second_fd(), IPPROTO_IP, IP_ADD_MEMBERSHIP,
                            &group, sizeof(group)),
                 SyscallSucceeds());
-    ASSERT_THAT(bind(sockets->second_fd(),
-                     reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+    ASSERT_THAT(bind(sockets->second_fd(), AsSockAddr(&receiver_addr.addr),
                      receiver_addr.addr_len),
                 SyscallSucceeds());
     // Get the port assigned.
     socklen_t receiver_addr_len = receiver_addr.addr_len;
-    ASSERT_THAT(getsockname(sockets->second_fd(),
-                            reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-                            &receiver_addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        getsockname(sockets->second_fd(), AsSockAddr(&receiver_addr.addr),
+                    &receiver_addr_len),
+        SyscallSucceeds());
     EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
     // On the first iteration, save the port we are bound to. On the second
     // iteration, verify the port is the same as the one from the first
@@ -1403,8 +1357,7 @@ TEST_P(IPv4UDPUnboundSocketTest, TestMcastReceptionWhenDroppingMemberships) {
     RandomizeBuffer(send_buf, sizeof(send_buf));
     ASSERT_THAT(
         RetryEINTR(sendto)(sockets->first_fd(), send_buf, sizeof(send_buf), 0,
-                           reinterpret_cast<sockaddr*>(&send_addr.addr),
-                           send_addr.addr_len),
+                           AsSockAddr(&send_addr.addr), send_addr.addr_len),
         SyscallSucceedsWithValue(sizeof(send_buf)));
 
     // Check that we received the multicast packet on both sockets.
@@ -1427,8 +1380,7 @@ TEST_P(IPv4UDPUnboundSocketTest, TestMcastReceptionWhenDroppingMemberships) {
     char send_buf[200];
     ASSERT_THAT(
         RetryEINTR(sendto)(sockets->first_fd(), send_buf, sizeof(send_buf), 0,
-                           reinterpret_cast<sockaddr*>(&send_addr.addr),
-                           send_addr.addr_len),
+                           AsSockAddr(&send_addr.addr), send_addr.addr_len),
         SyscallSucceedsWithValue(sizeof(send_buf)));
 
     char recv_buf[sizeof(send_buf)] = {};
@@ -1448,14 +1400,12 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenJoinThenReceive) {
 
   // Bind second socket (receiver) to the multicast address.
   auto receiver_addr = V4Multicast();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   // Update receiver_addr with the correct port number.
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -1479,10 +1429,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenJoinThenReceive) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1500,14 +1450,12 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenNoJoinThenNoReceive) {
 
   // Bind second socket (receiver) to the multicast address.
   auto receiver_addr = V4Multicast();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   // Update receiver_addr with the correct port number.
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -1523,10 +1471,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenNoJoinThenNoReceive) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we don't receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1543,13 +1491,11 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenSend) {
 
   // Bind second socket (receiver) to the ANY address.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -1557,12 +1503,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenSend) {
   // Bind the first socket (sender) to the multicast address.
   auto sender_addr = V4Multicast();
   ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
   socklen_t sender_addr_len = sender_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&sender_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&sender_addr.addr),
                           &sender_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(sender_addr_len, sender_addr.addr_len);
@@ -1573,10 +1517,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToMcastThenSend) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1594,13 +1538,11 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToBcastThenReceive) {
 
   // Bind second socket (receiver) to the broadcast address.
   auto receiver_addr = V4Broadcast();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -1611,19 +1553,18 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToBcastThenReceive) {
               SyscallSucceedsWithValue(0));
   // Note: Binding to the loopback interface makes the broadcast go out of it.
   auto sender_bind_addr = V4Loopback();
-  ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_bind_addr.addr),
-           sender_bind_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&sender_bind_addr.addr),
+                   sender_bind_addr.addr_len),
+              SyscallSucceeds());
   auto sendto_addr = V4Broadcast();
   reinterpret_cast<sockaddr_in*>(&sendto_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1641,13 +1582,11 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToBcastThenSend) {
 
   // Bind second socket (receiver) to the ANY address.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(socket2->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(socket2->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(socket2->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -1655,12 +1594,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToBcastThenSend) {
   // Bind the first socket (sender) to the broadcast address.
   auto sender_addr = V4Broadcast();
   ASSERT_THAT(
-      bind(socket1->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(socket1->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
   socklen_t sender_addr_len = sender_addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&sender_addr.addr),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&sender_addr.addr),
                           &sender_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(sender_addr_len, sender_addr.addr_len);
@@ -1671,10 +1608,10 @@ TEST_P(IPv4UDPUnboundSocketTest, TestBindToBcastThenSend) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket1->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -1698,12 +1635,10 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrDistribution_NoRandomSave) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(sockets[0]->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(sockets[0]->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(sockets[0]->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(sockets[0]->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1719,8 +1654,7 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrDistribution_NoRandomSave) {
     ASSERT_THAT(setsockopt(last->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                            sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(bind(last->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                     addr.addr_len),
+    ASSERT_THAT(bind(last->get(), AsSockAddr(&addr.addr), addr.addr_len),
                 SyscallSucceeds());
 
     // Send a new message to the SO_REUSEADDR group. We use a new socket each
@@ -1730,8 +1664,7 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrDistribution_NoRandomSave) {
     char send_buf[kMessageSize];
     RandomizeBuffer(send_buf, sizeof(send_buf));
     EXPECT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                   reinterpret_cast<sockaddr*>(&addr.addr),
-                                   addr.addr_len),
+                                   AsSockAddr(&addr.addr), addr.addr_len),
                 SyscallSucceedsWithValue(sizeof(send_buf)));
 
     // Verify that the most recent socket got the message. We don't expect any
@@ -1763,12 +1696,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrThenReusePort) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1776,8 +1707,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrThenReusePort) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
 
@@ -1792,12 +1722,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReusePortThenReuseAddr) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1805,8 +1733,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReusePortThenReuseAddr) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
 
@@ -1825,12 +1752,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConvertibleToReusePort) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1838,16 +1763,14 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConvertibleToReusePort) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Bind socket3 to the same address as socket1, only with REUSEADDR.
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
 
@@ -1866,12 +1789,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConvertibleToReuseAddr) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1879,16 +1800,14 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConvertibleToReuseAddr) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Bind socket3 to the same address as socket1, only with REUSEPORT.
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EADDRINUSE));
 }
 
@@ -1907,12 +1826,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable1) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1920,8 +1837,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable1) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Close socket2 to revert to just socket1 with REUSEADDR and REUSEPORT.
@@ -1931,8 +1847,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable1) {
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 }
 
@@ -1951,12 +1866,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable2) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -1964,8 +1877,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable2) {
   ASSERT_THAT(setsockopt(socket2->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Close socket2 to revert to just socket1 with REUSEADDR and REUSEPORT.
@@ -1975,8 +1887,7 @@ TEST_P(IPv4UDPUnboundSocketTest, BindReuseAddrReusePortConversionReversable2) {
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 }
 
@@ -1995,12 +1906,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindDoubleReuseAddrReusePortThenReusePort) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -2013,16 +1922,14 @@ TEST_P(IPv4UDPUnboundSocketTest, BindDoubleReuseAddrReusePortThenReusePort) {
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
 
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Bind socket3 to the same address as socket1, only with REUSEPORT.
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEPORT, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 }
 
@@ -2041,12 +1948,10 @@ TEST_P(IPv4UDPUnboundSocketTest, BindDoubleReuseAddrReusePortThenReuseAddr) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(socket1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(socket1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(socket1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -2059,16 +1964,14 @@ TEST_P(IPv4UDPUnboundSocketTest, BindDoubleReuseAddrReusePortThenReuseAddr) {
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
 
-  ASSERT_THAT(bind(socket2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   // Bind socket3 to the same address as socket1, only with REUSEADDR.
   ASSERT_THAT(setsockopt(socket3->get(), SOL_SOCKET, SO_REUSEADDR, &kSockOptOn,
                          sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(socket3->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(socket3->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 }
 
@@ -2086,12 +1989,10 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrReusePortDistribution) {
 
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(receiver1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(receiver1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(receiver1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(receiver1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -2103,8 +2004,7 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrReusePortDistribution) {
   ASSERT_THAT(setsockopt(receiver2->get(), SOL_SOCKET, SO_REUSEPORT,
                          &kSockOptOn, sizeof(kSockOptOn)),
               SyscallSucceeds());
-  ASSERT_THAT(bind(receiver2->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(receiver2->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
 
   constexpr int kMessageSize = 10;
@@ -2119,8 +2019,7 @@ TEST_P(IPv4UDPUnboundSocketTest, ReuseAddrReusePortDistribution) {
     auto sender = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
     char send_buf[kMessageSize] = {};
     EXPECT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                   reinterpret_cast<sockaddr*>(&addr.addr),
-                                   addr.addr_len),
+                                   AsSockAddr(&addr.addr), addr.addr_len),
                 SyscallSucceedsWithValue(sizeof(send_buf)));
   }
 
@@ -2149,13 +2048,11 @@ TEST_P(IPv4UDPUnboundSocketTest, SetAndReceiveIPPKTINFO) {
   int level = SOL_IP;
   int type = IP_PKTINFO;
 
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&sender_addr.addr),
+                   sender_addr.addr_len),
+              SyscallSucceeds());
   socklen_t sender_addr_len = sender_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&sender_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&sender_addr.addr),
                           &sender_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(sender_addr_len, sender_addr.addr_len);
@@ -2163,10 +2060,9 @@ TEST_P(IPv4UDPUnboundSocketTest, SetAndReceiveIPPKTINFO) {
   auto receiver_addr = V4Loopback();
   reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&sender_addr.addr)->sin_port;
-  ASSERT_THAT(
-      connect(sender->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-              receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sender->get(), AsSockAddr(&receiver_addr.addr),
+                      receiver_addr.addr_len),
+              SyscallSucceeds());
 
   // Allow socket to receive control message.
   ASSERT_THAT(
@@ -2230,29 +2126,25 @@ TEST_P(IPv4UDPUnboundSocketTest, SetAndReceiveIPReceiveOrigDstAddr) {
   int level = SOL_IP;
   int type = IP_RECVORIGDSTADDR;
 
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
 
   // Retrieve the port bound by the receiver.
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
 
-  ASSERT_THAT(
-      connect(sender->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-              receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sender->get(), AsSockAddr(&receiver_addr.addr),
+                      receiver_addr.addr_len),
+              SyscallSucceeds());
 
   // Get address and port bound by the sender.
   sockaddr_storage sender_addr_storage;
   socklen_t sender_addr_len = sizeof(sender_addr_storage);
-  ASSERT_THAT(getsockname(sender->get(),
-                          reinterpret_cast<sockaddr*>(&sender_addr_storage),
+  ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&sender_addr_storage),
                           &sender_addr_len),
               SyscallSucceeds());
   ASSERT_EQ(sender_addr_len, sizeof(struct sockaddr_in));
@@ -2524,22 +2416,19 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastIPPacketInfo) {
   // Bind the first FD to the loopback. This is an alternative to
   // IP_MULTICAST_IF for setting the default send interface.
   auto sender_addr = V4Loopback();
-  ASSERT_THAT(
-      bind(sender_socket->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(sender_socket->get(), AsSockAddr(&sender_addr.addr),
+                   sender_addr.addr_len),
+              SyscallSucceeds());
 
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(bind(receiver_socket->get(),
-                   reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(bind(receiver_socket->get(), AsSockAddr(&receiver_addr.addr),
                    receiver_addr.addr_len),
               SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
   ASSERT_THAT(getsockname(receiver_socket->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-                          &receiver_addr_len),
+                          AsSockAddr(&receiver_addr.addr), &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
 
@@ -2565,8 +2454,7 @@ TEST_P(IPv4UDPUnboundSocketTest, IpMulticastIPPacketInfo) {
   RandomizeBuffer(send_buf, sizeof(send_buf));
   ASSERT_THAT(
       RetryEINTR(sendto)(sender_socket->get(), send_buf, sizeof(send_buf), 0,
-                         reinterpret_cast<sockaddr*>(&send_addr.addr),
-                         send_addr.addr_len),
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
       SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
diff --git a/test/syscalls/linux/socket_ipv4_udp_unbound_external_networking.cc b/test/syscalls/linux/socket_ipv4_udp_unbound_external_networking.cc
index 940289d15..c6e775b2a 100644
--- a/test/syscalls/linux/socket_ipv4_udp_unbound_external_networking.cc
+++ b/test/syscalls/linux/socket_ipv4_udp_unbound_external_networking.cc
@@ -50,38 +50,35 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
 
   // Bind the first socket to the ANY address and let the system assign a port.
   auto rcv1_addr = V4Any();
-  ASSERT_THAT(bind(rcvr1->get(), reinterpret_cast<sockaddr*>(&rcv1_addr.addr),
-                   rcv1_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(rcvr1->get(), AsSockAddr(&rcv1_addr.addr), rcv1_addr.addr_len),
+      SyscallSucceedsWithValue(0));
   // Retrieve port number from first socket so that it can be bound to the
   // second socket.
   socklen_t rcv_addr_sz = rcv1_addr.addr_len;
   ASSERT_THAT(
-      getsockname(rcvr1->get(), reinterpret_cast<sockaddr*>(&rcv1_addr.addr),
-                  &rcv_addr_sz),
+      getsockname(rcvr1->get(), AsSockAddr(&rcv1_addr.addr), &rcv_addr_sz),
       SyscallSucceedsWithValue(0));
   EXPECT_EQ(rcv_addr_sz, rcv1_addr.addr_len);
   auto port = reinterpret_cast<sockaddr_in*>(&rcv1_addr.addr)->sin_port;
 
   // Bind the second socket to the same address:port as the first.
-  ASSERT_THAT(bind(rcvr2->get(), reinterpret_cast<sockaddr*>(&rcv1_addr.addr),
-                   rcv_addr_sz),
+  ASSERT_THAT(bind(rcvr2->get(), AsSockAddr(&rcv1_addr.addr), rcv_addr_sz),
               SyscallSucceedsWithValue(0));
 
   // Bind the non-receiving socket to an ephemeral port.
   auto norecv_addr = V4Any();
-  ASSERT_THAT(bind(norcv->get(), reinterpret_cast<sockaddr*>(&norecv_addr.addr),
-                   norecv_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(norcv->get(), AsSockAddr(&norecv_addr.addr), norecv_addr.addr_len),
+      SyscallSucceedsWithValue(0));
 
   // Broadcast a test message.
   auto dst_addr = V4Broadcast();
   reinterpret_cast<sockaddr_in*>(&dst_addr.addr)->sin_port = port;
   constexpr char kTestMsg[] = "hello, world";
-  EXPECT_THAT(
-      sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-             reinterpret_cast<sockaddr*>(&dst_addr.addr), dst_addr.addr_len),
-      SyscallSucceedsWithValue(sizeof(kTestMsg)));
+  EXPECT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
+                     AsSockAddr(&dst_addr.addr), dst_addr.addr_len),
+              SyscallSucceedsWithValue(sizeof(kTestMsg)));
 
   // Verify that the receiving sockets received the test message.
   char buf[sizeof(kTestMsg)] = {};
@@ -130,15 +127,14 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
 
   // Bind the first socket the ANY address and let the system assign a port.
   auto rcv1_addr = V4Any();
-  ASSERT_THAT(bind(rcvr1->get(), reinterpret_cast<sockaddr*>(&rcv1_addr.addr),
-                   rcv1_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(rcvr1->get(), AsSockAddr(&rcv1_addr.addr), rcv1_addr.addr_len),
+      SyscallSucceedsWithValue(0));
   // Retrieve port number from first socket so that it can be bound to the
   // second socket.
   socklen_t rcv_addr_sz = rcv1_addr.addr_len;
   ASSERT_THAT(
-      getsockname(rcvr1->get(), reinterpret_cast<sockaddr*>(&rcv1_addr.addr),
-                  &rcv_addr_sz),
+      getsockname(rcvr1->get(), AsSockAddr(&rcv1_addr.addr), &rcv_addr_sz),
       SyscallSucceedsWithValue(0));
   EXPECT_EQ(rcv_addr_sz, rcv1_addr.addr_len);
   auto port = reinterpret_cast<sockaddr_in*>(&rcv1_addr.addr)->sin_port;
@@ -146,26 +142,25 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   // Bind the second socket to the broadcast address.
   auto rcv2_addr = V4Broadcast();
   reinterpret_cast<sockaddr_in*>(&rcv2_addr.addr)->sin_port = port;
-  ASSERT_THAT(bind(rcvr2->get(), reinterpret_cast<sockaddr*>(&rcv2_addr.addr),
-                   rcv2_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(rcvr2->get(), AsSockAddr(&rcv2_addr.addr), rcv2_addr.addr_len),
+      SyscallSucceedsWithValue(0));
 
   // Bind the non-receiving socket to the unicast ethernet address.
   auto norecv_addr = rcv1_addr;
   reinterpret_cast<sockaddr_in*>(&norecv_addr.addr)->sin_addr =
       eth_if_addr_.sin_addr;
-  ASSERT_THAT(bind(norcv->get(), reinterpret_cast<sockaddr*>(&norecv_addr.addr),
-                   norecv_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(norcv->get(), AsSockAddr(&norecv_addr.addr), norecv_addr.addr_len),
+      SyscallSucceedsWithValue(0));
 
   // Broadcast a test message.
   auto dst_addr = V4Broadcast();
   reinterpret_cast<sockaddr_in*>(&dst_addr.addr)->sin_port = port;
   constexpr char kTestMsg[] = "hello, world";
-  EXPECT_THAT(
-      sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-             reinterpret_cast<sockaddr*>(&dst_addr.addr), dst_addr.addr_len),
-      SyscallSucceedsWithValue(sizeof(kTestMsg)));
+  EXPECT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
+                     AsSockAddr(&dst_addr.addr), dst_addr.addr_len),
+              SyscallSucceedsWithValue(sizeof(kTestMsg)));
 
   // Verify that the receiving sockets received the test message.
   char buf[sizeof(kTestMsg)] = {};
@@ -199,12 +194,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
 
   // Bind the sender to the broadcast address.
   auto src_addr = V4Broadcast();
-  ASSERT_THAT(bind(sender->get(), reinterpret_cast<sockaddr*>(&src_addr.addr),
-                   src_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(sender->get(), AsSockAddr(&src_addr.addr), src_addr.addr_len),
+      SyscallSucceedsWithValue(0));
   socklen_t src_sz = src_addr.addr_len;
-  ASSERT_THAT(getsockname(sender->get(),
-                          reinterpret_cast<sockaddr*>(&src_addr.addr), &src_sz),
+  ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&src_addr.addr), &src_sz),
               SyscallSucceedsWithValue(0));
   EXPECT_EQ(src_sz, src_addr.addr_len);
 
@@ -213,10 +207,9 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   reinterpret_cast<sockaddr_in*>(&dst_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&src_addr.addr)->sin_port;
   constexpr char kTestMsg[] = "hello, world";
-  EXPECT_THAT(
-      sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-             reinterpret_cast<sockaddr*>(&dst_addr.addr), dst_addr.addr_len),
-      SyscallSucceedsWithValue(sizeof(kTestMsg)));
+  EXPECT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
+                     AsSockAddr(&dst_addr.addr), dst_addr.addr_len),
+              SyscallSucceedsWithValue(sizeof(kTestMsg)));
 
   // Verify that the message was received.
   char buf[sizeof(kTestMsg)] = {};
@@ -241,12 +234,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
 
   // Bind the sender to the ANY address.
   auto src_addr = V4Any();
-  ASSERT_THAT(bind(sender->get(), reinterpret_cast<sockaddr*>(&src_addr.addr),
-                   src_addr.addr_len),
-              SyscallSucceedsWithValue(0));
+  ASSERT_THAT(
+      bind(sender->get(), AsSockAddr(&src_addr.addr), src_addr.addr_len),
+      SyscallSucceedsWithValue(0));
   socklen_t src_sz = src_addr.addr_len;
-  ASSERT_THAT(getsockname(sender->get(),
-                          reinterpret_cast<sockaddr*>(&src_addr.addr), &src_sz),
+  ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&src_addr.addr), &src_sz),
               SyscallSucceedsWithValue(0));
   EXPECT_EQ(src_sz, src_addr.addr_len);
 
@@ -255,10 +247,9 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   reinterpret_cast<sockaddr_in*>(&dst_addr.addr)->sin_port =
       reinterpret_cast<sockaddr_in*>(&src_addr.addr)->sin_port;
   constexpr char kTestMsg[] = "hello, world";
-  EXPECT_THAT(
-      sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-             reinterpret_cast<sockaddr*>(&dst_addr.addr), dst_addr.addr_len),
-      SyscallSucceedsWithValue(sizeof(kTestMsg)));
+  EXPECT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
+                     AsSockAddr(&dst_addr.addr), dst_addr.addr_len),
+              SyscallSucceedsWithValue(sizeof(kTestMsg)));
 
   // Verify that the message was received.
   char buf[sizeof(kTestMsg)] = {};
@@ -280,7 +271,7 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendBroadcast) {
   constexpr char kTestMsg[] = "hello, world";
 
   EXPECT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-                     reinterpret_cast<sockaddr*>(&addr.addr), addr.addr_len),
+                     AsSockAddr(&addr.addr), addr.addr_len),
               SyscallFailsWithErrno(EACCES));
 }
 
@@ -294,19 +285,17 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendUnicastOnUnbound) {
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = htonl(INADDR_ANY);
   addr.sin_port = htons(0);
-  ASSERT_THAT(bind(rcvr->get(), reinterpret_cast<struct sockaddr*>(&addr),
-                   sizeof(addr)),
+  ASSERT_THAT(bind(rcvr->get(), AsSockAddr(&addr), sizeof(addr)),
               SyscallSucceedsWithValue(0));
   memset(&addr, 0, sizeof(addr));
   socklen_t addr_sz = sizeof(addr);
-  ASSERT_THAT(getsockname(rcvr->get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), &addr_sz),
+  ASSERT_THAT(getsockname(rcvr->get(), AsSockAddr(&addr), &addr_sz),
               SyscallSucceedsWithValue(0));
 
   // Send a test message to the receiver.
   constexpr char kTestMsg[] = "hello, world";
   ASSERT_THAT(sendto(sender->get(), kTestMsg, sizeof(kTestMsg), 0,
-                     reinterpret_cast<struct sockaddr*>(&addr), addr_sz),
+                     AsSockAddr(&addr), addr_sz),
               SyscallSucceedsWithValue(sizeof(kTestMsg)));
   char buf[sizeof(kTestMsg)] = {};
   ASSERT_THAT(recv(rcvr->get(), buf, sizeof(buf), 0),
@@ -326,13 +315,12 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   auto socket = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
   auto bind_addr = V4Any();
-  ASSERT_THAT(bind(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                   bind_addr.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(socket->get(), AsSockAddr(&bind_addr.addr), bind_addr.addr_len),
+      SyscallSucceeds());
   socklen_t bind_addr_len = bind_addr.addr_len;
   ASSERT_THAT(
-      getsockname(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                  &bind_addr_len),
+      getsockname(socket->get(), AsSockAddr(&bind_addr.addr), &bind_addr_len),
       SyscallSucceeds());
   EXPECT_EQ(bind_addr_len, bind_addr.addr_len);
 
@@ -342,10 +330,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
       reinterpret_cast<sockaddr_in*>(&bind_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -361,13 +349,12 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticastSelf) {
   auto socket = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
   auto bind_addr = V4Any();
-  ASSERT_THAT(bind(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                   bind_addr.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(socket->get(), AsSockAddr(&bind_addr.addr), bind_addr.addr_len),
+      SyscallSucceeds());
   socklen_t bind_addr_len = bind_addr.addr_len;
   ASSERT_THAT(
-      getsockname(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                  &bind_addr_len),
+      getsockname(socket->get(), AsSockAddr(&bind_addr.addr), &bind_addr_len),
       SyscallSucceeds());
   EXPECT_EQ(bind_addr_len, bind_addr.addr_len);
 
@@ -384,10 +371,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticastSelf) {
       reinterpret_cast<sockaddr_in*>(&bind_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -405,13 +392,12 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   auto socket = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
   auto bind_addr = V4Any();
-  ASSERT_THAT(bind(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                   bind_addr.addr_len),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(socket->get(), AsSockAddr(&bind_addr.addr), bind_addr.addr_len),
+      SyscallSucceeds());
   socklen_t bind_addr_len = bind_addr.addr_len;
   ASSERT_THAT(
-      getsockname(socket->get(), reinterpret_cast<sockaddr*>(&bind_addr.addr),
-                  &bind_addr_len),
+      getsockname(socket->get(), AsSockAddr(&bind_addr.addr), &bind_addr_len),
       SyscallSucceeds());
   EXPECT_EQ(bind_addr_len, bind_addr.addr_len);
 
@@ -433,10 +419,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
       reinterpret_cast<sockaddr_in*>(&bind_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(socket->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -460,13 +446,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticastNoGroup) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -477,10 +461,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticastNoGroup) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -499,13 +483,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticast) {
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -523,10 +505,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest, TestSendMulticast) {
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -547,13 +529,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -576,10 +556,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we did not receive the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -600,13 +580,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   // Bind the second FD to the v4 any address to ensure that we can receive the
   // multicast packet.
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -629,10 +607,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
       reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)->sin_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -661,13 +639,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
     // Bind to ANY to receive multicast packets.
-    ASSERT_THAT(
-        bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-             receiver_addr.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                     receiver_addr.addr_len),
+                SyscallSucceeds());
     socklen_t receiver_addr_len = receiver_addr.addr_len;
-    ASSERT_THAT(getsockname(receiver->get(),
-                            reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+    ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                             &receiver_addr_len),
                 SyscallSucceeds());
     EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -696,10 +672,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   reinterpret_cast<sockaddr_in*>(&send_addr.addr)->sin_port = bound_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
   for (auto& receiver : receivers) {
     char recv_buf[sizeof(send_buf)] = {};
     ASSERT_THAT(
@@ -727,13 +703,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
     ASSERT_THAT(setsockopt(receiver->get(), SOL_SOCKET, SO_REUSEPORT,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-             receiver_addr.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                     receiver_addr.addr_len),
+                SyscallSucceeds());
     socklen_t receiver_addr_len = receiver_addr.addr_len;
-    ASSERT_THAT(getsockname(receiver->get(),
-                            reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+    ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                             &receiver_addr_len),
                 SyscallSucceeds());
     EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -765,10 +739,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   reinterpret_cast<sockaddr_in*>(&send_addr.addr)->sin_port = bound_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
   for (auto& receiver : receivers) {
     char recv_buf[sizeof(send_buf)] = {};
     ASSERT_THAT(
@@ -798,13 +772,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
     ASSERT_THAT(setsockopt(receiver->get(), SOL_SOCKET, SO_REUSEPORT,
                            &kSockOptOn, sizeof(kSockOptOn)),
                 SyscallSucceeds());
-    ASSERT_THAT(
-        bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-             receiver_addr.addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                     receiver_addr.addr_len),
+                SyscallSucceeds());
     socklen_t receiver_addr_len = receiver_addr.addr_len;
-    ASSERT_THAT(getsockname(receiver->get(),
-                            reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+    ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                             &receiver_addr_len),
                 SyscallSucceeds());
     EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -840,10 +812,10 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   reinterpret_cast<sockaddr_in*>(&send_addr.addr)->sin_port = bound_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
   for (auto& receiver : receivers) {
     char recv_buf[sizeof(send_buf)] = {};
     ASSERT_THAT(
@@ -863,13 +835,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   auto receiver = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -887,15 +857,13 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   // receiver side).
   auto sendto_addr = V4Multicast();
   reinterpret_cast<sockaddr_in*>(&sendto_addr.addr)->sin_port = receiver_port;
-  ASSERT_THAT(RetryEINTR(connect)(
-                  sender->get(), reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                  sendto_addr.addr_len),
+  ASSERT_THAT(RetryEINTR(connect)(sender->get(), AsSockAddr(&sendto_addr.addr),
+                                  sendto_addr.addr_len),
               SyscallSucceeds());
   auto sender_addr = V4EmptyAddress();
-  ASSERT_THAT(
-      getsockname(sender->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-                  &sender_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&sender_addr.addr),
+                          &sender_addr.addr_len),
+              SyscallSucceeds());
   ASSERT_EQ(sizeof(struct sockaddr_in), sender_addr.addr_len);
   sockaddr_in* sender_addr_in =
       reinterpret_cast<sockaddr_in*>(&sender_addr.addr);
@@ -910,8 +878,7 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   auto src_addr = V4EmptyAddress();
   ASSERT_THAT(
       RetryEINTR(recvfrom)(receiver->get(), recv_buf, sizeof(recv_buf), 0,
-                           reinterpret_cast<sockaddr*>(&src_addr.addr),
-                           &src_addr.addr_len),
+                           AsSockAddr(&src_addr.addr), &src_addr.addr_len),
       SyscallSucceedsWithValue(sizeof(recv_buf)));
   ASSERT_EQ(sizeof(struct sockaddr_in), src_addr.addr_len);
   sockaddr_in* src_addr_in = reinterpret_cast<sockaddr_in*>(&src_addr.addr);
@@ -931,13 +898,11 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   // Create receiver, bind to ANY and join the multicast group.
   auto receiver = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
   auto receiver_addr = V4Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -964,18 +929,17 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
   auto sendto_addr = V4Multicast();
   reinterpret_cast<sockaddr_in*>(&sendto_addr.addr)->sin_port = receiver_port;
   char send_buf[4] = {};
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr.addr),
-                                 sendto_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&sendto_addr.addr), sendto_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Receive a multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
   auto src_addr = V4EmptyAddress();
   ASSERT_THAT(
       RetryEINTR(recvfrom)(receiver->get(), recv_buf, sizeof(recv_buf), 0,
-                           reinterpret_cast<sockaddr*>(&src_addr.addr),
-                           &src_addr.addr_len),
+                           AsSockAddr(&src_addr.addr), &src_addr.addr_len),
       SyscallSucceedsWithValue(sizeof(recv_buf)));
   ASSERT_EQ(sizeof(struct sockaddr_in), src_addr.addr_len);
   sockaddr_in* src_addr_in = reinterpret_cast<sockaddr_in*>(&src_addr.addr);
@@ -1000,9 +964,9 @@ TEST_P(IPv4UDPUnboundExternalNetworkingSocketTest,
 
   // Create sender and bind to eth interface.
   auto sender = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
-  ASSERT_THAT(bind(sender->get(), reinterpret_cast<sockaddr*>(&eth_if_addr_),
-                   sizeof(eth_if_addr_)),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      bind(sender->get(), AsSockAddr(&eth_if_addr_), sizeof(eth_if_addr_)),
+      SyscallSucceeds());
 
   // Run through all possible combinations of index and address for
   // IP_MULTICAST_IF that selects the loopback interface.
diff --git a/test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc b/test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc
index bcbd2feac..96df17c1c 100644
--- a/test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc
+++ b/test/syscalls/linux/socket_ipv4_udp_unbound_loopback_nogotsan.cc
@@ -35,12 +35,10 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest,
   constexpr int kClients = 65536;
   // Bind the first socket to the loopback and take note of the selected port.
   auto addr = V4Loopback();
-  ASSERT_THAT(bind(receiver1->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                   addr.addr_len),
+  ASSERT_THAT(bind(receiver1->get(), AsSockAddr(&addr.addr), addr.addr_len),
               SyscallSucceeds());
   socklen_t addr_len = addr.addr_len;
-  ASSERT_THAT(getsockname(receiver1->get(),
-                          reinterpret_cast<sockaddr*>(&addr.addr), &addr_len),
+  ASSERT_THAT(getsockname(receiver1->get(), AsSockAddr(&addr.addr), &addr_len),
               SyscallSucceeds());
   EXPECT_EQ(addr_len, addr.addr_len);
 
@@ -50,8 +48,7 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest,
   for (int i = 0; i < kClients; i++) {
     auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
-    int ret = connect(s->get(), reinterpret_cast<sockaddr*>(&addr.addr),
-                      addr.addr_len);
+    int ret = connect(s->get(), AsSockAddr(&addr.addr), addr.addr_len);
     if (ret == 0) {
       sockets.push_back(std::move(s));
       continue;
@@ -73,8 +70,7 @@ TEST_P(IPv4UDPUnboundSocketNogotsanTest, UDPBindPortExhaustion_NoRandomSave) {
   for (int i = 0; i < kClients; i++) {
     auto s = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
-    int ret =
-        bind(s->get(), reinterpret_cast<sockaddr*>(&addr.addr), addr.addr_len);
+    int ret = bind(s->get(), AsSockAddr(&addr.addr), addr.addr_len);
     if (ret == 0) {
       sockets.push_back(std::move(s));
       continue;
diff --git a/test/syscalls/linux/socket_ipv4_udp_unbound_netlink.cc b/test/syscalls/linux/socket_ipv4_udp_unbound_netlink.cc
index 9a9ddc297..410e06f40 100644
--- a/test/syscalls/linux/socket_ipv4_udp_unbound_netlink.cc
+++ b/test/syscalls/linux/socket_ipv4_udp_unbound_netlink.cc
@@ -56,10 +56,9 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, JoinSubnet) {
   ASSERT_EQ(1, inet_pton(AF_INET, "192.0.2.2",
                          &(reinterpret_cast<sockaddr_in*>(&sender_addr.addr)
                                ->sin_addr.s_addr)));
-  ASSERT_THAT(
-      bind(snd_sock->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(snd_sock->get(), AsSockAddr(&sender_addr.addr),
+                   sender_addr.addr_len),
+              SyscallSucceeds());
 
   // Send the packet to an unassigned address but an address that is in the
   // subnet associated with the loopback interface.
@@ -69,23 +68,20 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, JoinSubnet) {
   ASSERT_EQ(1, inet_pton(AF_INET, "192.0.2.254",
                          &(reinterpret_cast<sockaddr_in*>(&receiver_addr.addr)
                                ->sin_addr.s_addr)));
-  ASSERT_THAT(
-      bind(rcv_sock->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(rcv_sock->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(rcv_sock->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(rcv_sock->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   ASSERT_EQ(receiver_addr_len, receiver_addr.addr_len);
   char send_buf[kSendBufSize];
   RandomizeBuffer(send_buf, kSendBufSize);
-  ASSERT_THAT(
-      RetryEINTR(sendto)(snd_sock->get(), send_buf, kSendBufSize, 0,
-                         reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-                         receiver_addr.addr_len),
-      SyscallSucceedsWithValue(kSendBufSize));
+  ASSERT_THAT(RetryEINTR(sendto)(snd_sock->get(), send_buf, kSendBufSize, 0,
+                                 AsSockAddr(&receiver_addr.addr),
+                                 receiver_addr.addr_len),
+              SyscallSucceedsWithValue(kSendBufSize));
 
   // Check that we received the packet.
   char recv_buf[kSendBufSize] = {};
@@ -155,14 +151,12 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, ReuseAddrSubnetDirectedBroadcast) {
           << "socks[" << idx << "]";
 
       if (bind_wildcard) {
-        ASSERT_THAT(
-            bind(sock->get(), reinterpret_cast<sockaddr*>(&any_address.addr),
-                 any_address.addr_len),
-            SyscallSucceeds())
+        ASSERT_THAT(bind(sock->get(), AsSockAddr(&any_address.addr),
+                         any_address.addr_len),
+                    SyscallSucceeds())
             << "socks[" << idx << "]";
       } else {
-        ASSERT_THAT(bind(sock->get(),
-                         reinterpret_cast<sockaddr*>(&broadcast_address.addr),
+        ASSERT_THAT(bind(sock->get(), AsSockAddr(&broadcast_address.addr),
                          broadcast_address.addr_len),
                     SyscallSucceeds())
             << "socks[" << idx << "]";
@@ -179,11 +173,10 @@ TEST_P(IPv4UDPUnboundSocketNetlinkTest, ReuseAddrSubnetDirectedBroadcast) {
   // the sending socket).
   for (long unsigned int w = 0; w < socks.size(); w++) {
     auto& w_sock = socks[w];
-    ASSERT_THAT(
-        RetryEINTR(sendto)(w_sock->get(), send_buf, kSendBufSize, 0,
-                           reinterpret_cast<sockaddr*>(&broadcast_address.addr),
-                           broadcast_address.addr_len),
-        SyscallSucceedsWithValue(kSendBufSize))
+    ASSERT_THAT(RetryEINTR(sendto)(w_sock->get(), send_buf, kSendBufSize, 0,
+                                   AsSockAddr(&broadcast_address.addr),
+                                   broadcast_address.addr_len),
+                SyscallSucceedsWithValue(kSendBufSize))
         << "write socks[" << w << "]";
 
     // Check that we received the packet on all sockets.
diff --git a/test/syscalls/linux/socket_ipv6_udp_unbound.cc b/test/syscalls/linux/socket_ipv6_udp_unbound.cc
index 08526468e..a4e3371f4 100644
--- a/test/syscalls/linux/socket_ipv6_udp_unbound.cc
+++ b/test/syscalls/linux/socket_ipv6_udp_unbound.cc
@@ -47,29 +47,25 @@ TEST_P(IPv6UDPUnboundSocketTest, SetAndReceiveIPReceiveOrigDstAddr) {
   int level = SOL_IPV6;
   int type = IPV6_RECVORIGDSTADDR;
 
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
 
   // Retrieve the port bound by the receiver.
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
 
-  ASSERT_THAT(
-      connect(sender->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-              receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sender->get(), AsSockAddr(&receiver_addr.addr),
+                      receiver_addr.addr_len),
+              SyscallSucceeds());
 
   // Get address and port bound by the sender.
   sockaddr_storage sender_addr_storage;
   socklen_t sender_addr_len = sizeof(sender_addr_storage);
-  ASSERT_THAT(getsockname(sender->get(),
-                          reinterpret_cast<sockaddr*>(&sender_addr_storage),
+  ASSERT_THAT(getsockname(sender->get(), AsSockAddr(&sender_addr_storage),
                           &sender_addr_len),
               SyscallSucceeds());
   ASSERT_EQ(sender_addr_len, sizeof(struct sockaddr_in6));
diff --git a/test/syscalls/linux/socket_ipv6_udp_unbound_external_networking.cc b/test/syscalls/linux/socket_ipv6_udp_unbound_external_networking.cc
index 7364a1ea5..8390f7c3b 100644
--- a/test/syscalls/linux/socket_ipv6_udp_unbound_external_networking.cc
+++ b/test/syscalls/linux/socket_ipv6_udp_unbound_external_networking.cc
@@ -24,13 +24,11 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
   auto receiver = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
 
   auto receiver_addr = V6Any();
-  ASSERT_THAT(
-      bind(receiver->get(), reinterpret_cast<sockaddr*>(&receiver_addr.addr),
-           receiver_addr.addr_len),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
   socklen_t receiver_addr_len = receiver_addr.addr_len;
-  ASSERT_THAT(getsockname(receiver->get(),
-                          reinterpret_cast<sockaddr*>(&receiver_addr.addr),
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
                           &receiver_addr_len),
               SyscallSucceeds());
   EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
@@ -50,8 +48,7 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
   // Set the sender to the loopback interface.
   auto sender_addr = V6Loopback();
   ASSERT_THAT(
-      bind(sender->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-           sender_addr.addr_len),
+      bind(sender->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
       SyscallSucceeds());
 
   // Send a multicast packet.
@@ -60,10 +57,10 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
       reinterpret_cast<sockaddr_in6*>(&receiver_addr.addr)->sin6_port;
   char send_buf[200];
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
 
   // Check that we received the multicast packet.
   char recv_buf[sizeof(send_buf)] = {};
@@ -77,10 +74,10 @@ TEST_P(IPv6UDPUnboundExternalNetworkingSocketTest, TestJoinLeaveMulticast) {
                          &group_req, sizeof(group_req)),
               SyscallSucceeds());
   RandomizeBuffer(send_buf, sizeof(send_buf));
-  ASSERT_THAT(RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
-                                 reinterpret_cast<sockaddr*>(&send_addr.addr),
-                                 send_addr.addr_len),
-              SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
   ASSERT_THAT(RetryEINTR(recv)(receiver->get(), recv_buf, sizeof(recv_buf),
                                MSG_DONTWAIT),
               SyscallFailsWithErrno(EAGAIN));
diff --git a/test/syscalls/linux/socket_ipv6_udp_unbound_netlink.cc b/test/syscalls/linux/socket_ipv6_udp_unbound_netlink.cc
index 2ee218231..48aace78a 100644
--- a/test/syscalls/linux/socket_ipv6_udp_unbound_netlink.cc
+++ b/test/syscalls/linux/socket_ipv6_udp_unbound_netlink.cc
@@ -44,9 +44,9 @@ TEST_P(IPv6UDPUnboundSocketNetlinkTest, JoinSubnet) {
                          reinterpret_cast<sockaddr_in6*>(&sender_addr.addr)
                              ->sin6_addr.s6_addr));
   auto sock = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
-  EXPECT_THAT(bind(sock->get(), reinterpret_cast<sockaddr*>(&sender_addr.addr),
-                   sender_addr.addr_len),
-              SyscallFailsWithErrno(EADDRNOTAVAIL));
+  EXPECT_THAT(
+      bind(sock->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
+      SyscallFailsWithErrno(EADDRNOTAVAIL));
 }
 
 }  // namespace testing
diff --git a/test/syscalls/linux/socket_test_util.cc b/test/syscalls/linux/socket_test_util.cc
index b2a96086c..9e3a129cf 100644
--- a/test/syscalls/linux/socket_test_util.cc
+++ b/test/syscalls/linux/socket_test_util.cc
@@ -82,8 +82,7 @@ Creator<SocketPair> AcceptBindSocketPairCreator(bool abstract, int domain,
     RETURN_ERROR_IF_SYSCALL_FAIL(bound = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
     RETURN_ERROR_IF_SYSCALL_FAIL(
-        bind(bound, reinterpret_cast<struct sockaddr*>(&bind_addr),
-             sizeof(bind_addr)));
+        bind(bound, AsSockAddr(&bind_addr), sizeof(bind_addr)));
     MaybeSave();  // Successful bind.
     RETURN_ERROR_IF_SYSCALL_FAIL(listen(bound, /* backlog = */ 5));
     MaybeSave();  // Successful listen.
@@ -92,8 +91,7 @@ Creator<SocketPair> AcceptBindSocketPairCreator(bool abstract, int domain,
     RETURN_ERROR_IF_SYSCALL_FAIL(connected = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
     RETURN_ERROR_IF_SYSCALL_FAIL(
-        connect(connected, reinterpret_cast<struct sockaddr*>(&bind_addr),
-                sizeof(bind_addr)));
+        connect(connected, AsSockAddr(&bind_addr), sizeof(bind_addr)));
     MaybeSave();  // Successful connect.
 
     int accepted;
@@ -145,22 +143,22 @@ Creator<SocketPair> BidirectionalBindSocketPairCreator(bool abstract,
     RETURN_ERROR_IF_SYSCALL_FAIL(sock1 = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
     RETURN_ERROR_IF_SYSCALL_FAIL(
-        bind(sock1, reinterpret_cast<struct sockaddr*>(&addr1), sizeof(addr1)));
+        bind(sock1, AsSockAddr(&addr1), sizeof(addr1)));
     MaybeSave();  // Successful bind.
 
     int sock2;
     RETURN_ERROR_IF_SYSCALL_FAIL(sock2 = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
     RETURN_ERROR_IF_SYSCALL_FAIL(
-        bind(sock2, reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)));
+        bind(sock2, AsSockAddr(&addr2), sizeof(addr2)));
     MaybeSave();  // Successful bind.
 
-    RETURN_ERROR_IF_SYSCALL_FAIL(connect(
-        sock1, reinterpret_cast<struct sockaddr*>(&addr2), sizeof(addr2)));
+    RETURN_ERROR_IF_SYSCALL_FAIL(
+        connect(sock1, AsSockAddr(&addr2), sizeof(addr2)));
     MaybeSave();  // Successful connect.
 
-    RETURN_ERROR_IF_SYSCALL_FAIL(connect(
-        sock2, reinterpret_cast<struct sockaddr*>(&addr1), sizeof(addr1)));
+    RETURN_ERROR_IF_SYSCALL_FAIL(
+        connect(sock2, AsSockAddr(&addr1), sizeof(addr1)));
     MaybeSave();  // Successful connect.
 
     // Cleanup no longer needed resources.
@@ -206,15 +204,15 @@ Creator<SocketPair> SocketpairGoferSocketPairCreator(int domain, int type,
     int sock1;
     RETURN_ERROR_IF_SYSCALL_FAIL(sock1 = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
-    RETURN_ERROR_IF_SYSCALL_FAIL(connect(
-        sock1, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
+    RETURN_ERROR_IF_SYSCALL_FAIL(
+        connect(sock1, AsSockAddr(&addr), sizeof(addr)));
     MaybeSave();  // Successful connect.
 
     int sock2;
     RETURN_ERROR_IF_SYSCALL_FAIL(sock2 = socket(domain, type, protocol));
     MaybeSave();  // Successful socket creation.
-    RETURN_ERROR_IF_SYSCALL_FAIL(connect(
-        sock2, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
+    RETURN_ERROR_IF_SYSCALL_FAIL(
+        connect(sock2, AsSockAddr(&addr), sizeof(addr)));
     MaybeSave();  // Successful connect.
 
     // Make and close another socketpair to ensure that the duped ends of the
@@ -228,8 +226,8 @@ Creator<SocketPair> SocketpairGoferSocketPairCreator(int domain, int type,
     for (int i = 0; i < 2; i++) {
       int sock;
       RETURN_ERROR_IF_SYSCALL_FAIL(sock = socket(domain, type, protocol));
-      RETURN_ERROR_IF_SYSCALL_FAIL(connect(
-          sock, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
+      RETURN_ERROR_IF_SYSCALL_FAIL(
+          connect(sock, AsSockAddr(&addr), sizeof(addr)));
       RETURN_ERROR_IF_SYSCALL_FAIL(close(sock));
     }
 
@@ -308,11 +306,9 @@ template <typename T>
 PosixErrorOr<T> BindIP(int fd, bool dual_stack) {
   T addr = {};
   LocalhostAddr(&addr, dual_stack);
-  RETURN_ERROR_IF_SYSCALL_FAIL(
-      bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)));
+  RETURN_ERROR_IF_SYSCALL_FAIL(bind(fd, AsSockAddr(&addr), sizeof(addr)));
   socklen_t addrlen = sizeof(addr);
-  RETURN_ERROR_IF_SYSCALL_FAIL(
-      getsockname(fd, reinterpret_cast<struct sockaddr*>(&addr), &addrlen));
+  RETURN_ERROR_IF_SYSCALL_FAIL(getsockname(fd, AsSockAddr(&addr), &addrlen));
   return addr;
 }
 
@@ -329,9 +325,8 @@ CreateTCPConnectAcceptSocketPair(int bound, int connected, int type,
                                  bool dual_stack, T bind_addr) {
   int connect_result = 0;
   RETURN_ERROR_IF_SYSCALL_FAIL(
-      (connect_result = RetryEINTR(connect)(
-           connected, reinterpret_cast<struct sockaddr*>(&bind_addr),
-           sizeof(bind_addr))) == -1 &&
+      (connect_result = RetryEINTR(connect)(connected, AsSockAddr(&bind_addr),
+                                            sizeof(bind_addr))) == -1 &&
               errno == EINPROGRESS
           ? 0
           : connect_result);
@@ -703,7 +698,7 @@ PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
   }
 
   RETURN_ERROR_IF_SYSCALL_FAIL(
-      bind(fd.get(), reinterpret_cast<sockaddr*>(&storage), storage_size));
+      bind(fd.get(), AsSockAddr(&storage), storage_size));
 
   // If the user specified 0 as the port, we will return the port that the
   // kernel gave us, otherwise we will validate that this socket bound to the
@@ -711,8 +706,7 @@ PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
   sockaddr_storage bound_storage = {};
   socklen_t bound_storage_size = sizeof(bound_storage);
   RETURN_ERROR_IF_SYSCALL_FAIL(
-      getsockname(fd.get(), reinterpret_cast<sockaddr*>(&bound_storage),
-                  &bound_storage_size));
+      getsockname(fd.get(), AsSockAddr(&bound_storage), &bound_storage_size));
 
   int available_port = -1;
   if (bound_storage.ss_family == AF_INET) {
diff --git a/test/syscalls/linux/socket_test_util.h b/test/syscalls/linux/socket_test_util.h
index b3ab286b8..f7ba90130 100644
--- a/test/syscalls/linux/socket_test_util.h
+++ b/test/syscalls/linux/socket_test_util.h
@@ -520,6 +520,20 @@ uint16_t UDPChecksum(struct iphdr iphdr, struct udphdr udphdr,
 uint16_t ICMPChecksum(struct icmphdr icmphdr, const char* payload,
                       ssize_t payload_len);
 
+// Convenient functions for reinterpreting common types to sockaddr pointer.
+inline sockaddr* AsSockAddr(sockaddr_storage* s) {
+  return reinterpret_cast<sockaddr*>(s);
+}
+inline sockaddr* AsSockAddr(sockaddr_in* s) {
+  return reinterpret_cast<sockaddr*>(s);
+}
+inline sockaddr* AsSockAddr(sockaddr_in6* s) {
+  return reinterpret_cast<sockaddr*>(s);
+}
+inline sockaddr* AsSockAddr(sockaddr_un* s) {
+  return reinterpret_cast<sockaddr*>(s);
+}
+
 namespace internal {
 PosixErrorOr<int> TryPortAvailable(int port, AddressFamily family,
                                    SocketType type, bool reuse_addr);
diff --git a/test/syscalls/linux/tcp_socket.cc b/test/syscalls/linux/tcp_socket.cc
index 7341cf1a6..38073edcc 100644
--- a/test/syscalls/linux/tcp_socket.cc
+++ b/test/syscalls/linux/tcp_socket.cc
@@ -139,20 +139,16 @@ void TcpSocketTest::SetUp() {
   socklen_t addrlen = sizeof(addr);
 
   // Bind to some port then start listening.
-  ASSERT_THAT(
-      bind(listener_, reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(listener_, AsSockAddr(&addr), addrlen), SyscallSucceeds());
 
   ASSERT_THAT(listen(listener_, SOMAXCONN), SyscallSucceeds());
 
   // Get the address we're listening on, then connect to it. We need to do this
   // because we're allowing the stack to pick a port for us.
-  ASSERT_THAT(getsockname(listener_, reinterpret_cast<struct sockaddr*>(&addr),
-                          &addrlen),
+  ASSERT_THAT(getsockname(listener_, AsSockAddr(&addr), &addrlen),
               SyscallSucceeds());
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  first_fd, reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(first_fd, AsSockAddr(&addr), addrlen),
               SyscallSucceeds());
 
   // Get the initial send buffer size.
@@ -229,10 +225,9 @@ TEST_P(TcpSocketTest, SenderAddressIgnored) {
   socklen_t addrlen = sizeof(addr);
   memset(&addr, 0, sizeof(addr));
 
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), 0,
-                           reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
-      SyscallSucceedsWithValue(3));
+  ASSERT_THAT(RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), 0,
+                                   AsSockAddr(&addr), &addrlen),
+              SyscallSucceedsWithValue(3));
 
   // Check that addr remains zeroed-out.
   const char* ptr = reinterpret_cast<char*>(&addr);
@@ -250,10 +245,9 @@ TEST_P(TcpSocketTest, SenderAddressIgnoredOnPeek) {
   socklen_t addrlen = sizeof(addr);
   memset(&addr, 0, sizeof(addr));
 
-  ASSERT_THAT(
-      RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), MSG_PEEK,
-                           reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
-      SyscallSucceedsWithValue(3));
+  ASSERT_THAT(RetryEINTR(recvfrom)(second_fd, buf, sizeof(buf), MSG_PEEK,
+                                   AsSockAddr(&addr), &addrlen),
+              SyscallSucceedsWithValue(3));
 
   // Check that addr remains zeroed-out.
   const char* ptr = reinterpret_cast<char*>(&addr);
@@ -268,10 +262,9 @@ TEST_P(TcpSocketTest, SendtoAddressIgnored) {
   addr.ss_family = GetParam();  // FIXME(b/63803955)
 
   char data = '\0';
-  EXPECT_THAT(
-      RetryEINTR(sendto)(first_fd, &data, sizeof(data), 0,
-                         reinterpret_cast<sockaddr*>(&addr), sizeof(addr)),
-      SyscallSucceedsWithValue(1));
+  EXPECT_THAT(RetryEINTR(sendto)(first_fd, &data, sizeof(data), 0,
+                                 AsSockAddr(&addr), sizeof(addr)),
+              SyscallSucceedsWithValue(1));
 }
 
 TEST_P(TcpSocketTest, WritevZeroIovec) {
@@ -869,10 +862,9 @@ TEST_P(SimpleTcpSocketTest, SendtoWithAddressUnconnected) {
   sockaddr_storage addr =
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   char data = '\0';
-  EXPECT_THAT(
-      RetryEINTR(sendto)(fd, &data, sizeof(data), 0,
-                         reinterpret_cast<sockaddr*>(&addr), sizeof(addr)),
-      SyscallFailsWithErrno(EPIPE));
+  EXPECT_THAT(RetryEINTR(sendto)(fd, &data, sizeof(data), 0, AsSockAddr(&addr),
+                                 sizeof(addr)),
+              SyscallFailsWithErrno(EPIPE));
 }
 
 TEST_P(SimpleTcpSocketTest, GetPeerNameUnconnected) {
@@ -883,7 +875,7 @@ TEST_P(SimpleTcpSocketTest, GetPeerNameUnconnected) {
 
   sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(getpeername(fd, reinterpret_cast<sockaddr*>(&addr), &addrlen),
+  EXPECT_THAT(getpeername(fd, AsSockAddr(&addr), &addrlen),
               SyscallFailsWithErrno(ENOTCONN));
 }
 
@@ -974,24 +966,20 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRetry) {
   socklen_t addrlen = sizeof(addr);
 
   // Bind to some port but don't listen yet.
-  ASSERT_THAT(
-      bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
+              SyscallSucceeds());
 
   // Get the address we're bound to, then connect to it. We need to do this
   // because we're allowing the stack to pick a port for us.
-  ASSERT_THAT(getsockname(listener.get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
+  ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
               SyscallSucceeds());
 
   FileDescriptor connector =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetParam(), SOCK_STREAM, IPPROTO_TCP));
 
   // Verify that connect fails.
-  ASSERT_THAT(
-      RetryEINTR(connect)(connector.get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallFailsWithErrno(ECONNREFUSED));
+  ASSERT_THAT(RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
+              SyscallFailsWithErrno(ECONNREFUSED));
 
   // Now start listening
   ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
@@ -1000,17 +988,14 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRetry) {
   //   failed first connect should succeed.
   if (IsRunningOnGvisor()) {
     ASSERT_THAT(
-        RetryEINTR(connect)(connector.get(),
-                            reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+        RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
         SyscallFailsWithErrno(ECONNABORTED));
     return;
   }
 
   // Verify that connect now succeeds.
-  ASSERT_THAT(
-      RetryEINTR(connect)(connector.get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(RetryEINTR(connect)(connector.get(), AsSockAddr(&addr), addrlen),
+              SyscallSucceeds());
 
   // Accept the connection.
   const FileDescriptor accepted =
@@ -1030,13 +1015,11 @@ PosixErrorOr<FileDescriptor> nonBlockingConnectNoListener(const int family,
   int b_sock;
   RETURN_ERROR_IF_SYSCALL_FAIL(b_sock = socket(family, sock_type, IPPROTO_TCP));
   FileDescriptor b(b_sock);
-  EXPECT_THAT(bind(b.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-              SyscallSucceeds());
+  EXPECT_THAT(bind(b.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
 
   // Get the address bound by the listening socket.
-  EXPECT_THAT(
-      getsockname(b.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(b.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
 
   // Now create another socket and issue a connect on this one. This connect
   // should fail as there is no listener.
@@ -1046,8 +1029,7 @@ PosixErrorOr<FileDescriptor> nonBlockingConnectNoListener(const int family,
 
   // Now connect to the bound address and this should fail as nothing
   // is listening on the bound address.
-  EXPECT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  EXPECT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(EINPROGRESS));
 
   // Wait for the connect to fail.
@@ -1078,8 +1060,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListener) {
   opts &= ~O_NONBLOCK;
   EXPECT_THAT(fcntl(s.get(), F_SETFL, opts), SyscallSucceeds());
   // Try connecting again.
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(ECONNABORTED));
 }
 
@@ -1094,8 +1075,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListenerRead) {
   unsigned char c;
   ASSERT_THAT(read(s.get(), &c, 1), SyscallFailsWithErrno(ECONNREFUSED));
   ASSERT_THAT(read(s.get(), &c, 1), SyscallSucceedsWithValue(0));
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(ECONNABORTED));
 }
 
@@ -1111,8 +1091,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectNoListenerPeek) {
   ASSERT_THAT(recv(s.get(), &c, 1, MSG_PEEK),
               SyscallFailsWithErrno(ECONNREFUSED));
   ASSERT_THAT(recv(s.get(), &c, 1, MSG_PEEK), SyscallSucceedsWithValue(0));
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(ECONNABORTED));
 }
 
@@ -1125,15 +1104,11 @@ TEST_P(SimpleTcpSocketTest, SelfConnectSendRecv_NoRandomSave) {
   const FileDescriptor s =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetParam(), SOCK_STREAM, IPPROTO_TCP));
 
-  ASSERT_THAT(
-      (bind)(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT((bind)(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
   // Get the bound port.
-  ASSERT_THAT(
-      getsockname(s.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(getsockname(s.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallSucceeds());
 
   constexpr int kBufSz = 1 << 20;  // 1 MiB
@@ -1182,14 +1157,11 @@ TEST_P(SimpleTcpSocketTest, SelfConnectSend_NoRandomSave) {
       setsockopt(s.get(), SOL_TCP, TCP_MAXSEG, &max_seg, sizeof(max_seg)),
       SyscallSucceeds());
 
-  ASSERT_THAT(bind(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(bind(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
   // Get the bound port.
-  ASSERT_THAT(
-      getsockname(s.get(), reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(getsockname(s.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallSucceeds());
 
   std::vector<char> writebuf(512 << 10);  // 512 KiB.
@@ -1213,9 +1185,8 @@ void NonBlockingConnect(int family, int16_t pollMask) {
   socklen_t addrlen = sizeof(addr);
 
   // Bind to some port then start listening.
-  ASSERT_THAT(
-      bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
+              SyscallSucceeds());
 
   ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
 
@@ -1228,12 +1199,10 @@ void NonBlockingConnect(int family, int16_t pollMask) {
   opts |= O_NONBLOCK;
   ASSERT_THAT(fcntl(s.get(), F_SETFL, opts), SyscallSucceeds());
 
-  ASSERT_THAT(getsockname(listener.get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
+  ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
               SyscallSucceeds());
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(EINPROGRESS));
 
   int t;
@@ -1276,21 +1245,18 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRemoteClose) {
   socklen_t addrlen = sizeof(addr);
 
   // Bind to some port then start listening.
-  ASSERT_THAT(
-      bind(listener.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(listener.get(), AsSockAddr(&addr), addrlen),
+              SyscallSucceeds());
 
   ASSERT_THAT(listen(listener.get(), SOMAXCONN), SyscallSucceeds());
 
   FileDescriptor s = ASSERT_NO_ERRNO_AND_VALUE(
       Socket(GetParam(), SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
 
-  ASSERT_THAT(getsockname(listener.get(),
-                          reinterpret_cast<struct sockaddr*>(&addr), &addrlen),
+  ASSERT_THAT(getsockname(listener.get(), AsSockAddr(&addr), &addrlen),
               SyscallSucceeds());
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(EINPROGRESS));
 
   int t;
@@ -1305,12 +1271,10 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRemoteClose) {
   EXPECT_THAT(RetryEINTR(poll)(&poll_fd, 1, 10000),
               SyscallSucceedsWithValue(1));
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallSucceeds());
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(EISCONN));
 }
 
@@ -1325,8 +1289,7 @@ TEST_P(SimpleTcpSocketTest, BlockingConnectRefused) {
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   socklen_t addrlen = sizeof(addr);
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(ECONNREFUSED));
 
   // Avoiding triggering save in destructor of s.
@@ -1346,17 +1309,14 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   socklen_t bound_addrlen = sizeof(bound_addr);
 
-  ASSERT_THAT(
-      bind(bound_s.get(), reinterpret_cast<struct sockaddr*>(&bound_addr),
-           bound_addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(bound_s.get(), AsSockAddr(&bound_addr), bound_addrlen),
+              SyscallSucceeds());
 
   // Get the addresses the socket is bound to because the port is chosen by the
   // stack.
-  ASSERT_THAT(getsockname(bound_s.get(),
-                          reinterpret_cast<struct sockaddr*>(&bound_addr),
-                          &bound_addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      getsockname(bound_s.get(), AsSockAddr(&bound_addr), &bound_addrlen),
+      SyscallSucceeds());
 
   // Create, initialize, and bind the socket that is used to test connecting to
   // the non-listening port.
@@ -1367,16 +1327,13 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   socklen_t client_addrlen = sizeof(client_addr);
 
+  ASSERT_THAT(bind(client_s.get(), AsSockAddr(&client_addr), client_addrlen),
+              SyscallSucceeds());
+
   ASSERT_THAT(
-      bind(client_s.get(), reinterpret_cast<struct sockaddr*>(&client_addr),
-           client_addrlen),
+      getsockname(client_s.get(), AsSockAddr(&client_addr), &client_addrlen),
       SyscallSucceeds());
 
-  ASSERT_THAT(getsockname(client_s.get(),
-                          reinterpret_cast<struct sockaddr*>(&client_addr),
-                          &client_addrlen),
-              SyscallSucceeds());
-
   // Now the test: connect to the bound but not listening socket with the
   // client socket. The bound socket should return a RST and cause the client
   // socket to return an error and clean itself up immediately.
@@ -1392,10 +1349,8 @@ TEST_P(SimpleTcpSocketTest, CleanupOnConnectionRefused) {
 
   // Test binding to the address from the client socket. This should be okay
   // if it was dropped correctly.
-  ASSERT_THAT(
-      bind(new_s.get(), reinterpret_cast<struct sockaddr*>(&client_addr),
-           client_addrlen),
-      SyscallSucceeds());
+  ASSERT_THAT(bind(new_s.get(), AsSockAddr(&client_addr), client_addrlen),
+              SyscallSucceeds());
 
   // Attempt #2, with the new socket and reused addr our connect should fail in
   // the same way as before, not with an EADDRINUSE.
@@ -1428,8 +1383,7 @@ TEST_P(SimpleTcpSocketTest, NonBlockingConnectRefused) {
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   socklen_t addrlen = sizeof(addr);
 
-  ASSERT_THAT(RetryEINTR(connect)(
-                  s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
+  ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
               SyscallFailsWithErrno(EINPROGRESS));
 
   // We don't need to specify any events to get POLLHUP or POLLERR as these
@@ -1720,8 +1674,7 @@ TEST_P(SimpleTcpSocketTest, TCPConnectSoRcvBufRace) {
       ASSERT_NO_ERRNO_AND_VALUE(InetLoopbackAddr(GetParam()));
   socklen_t addrlen = sizeof(addr);
 
-  RetryEINTR(connect)(s.get(), reinterpret_cast<struct sockaddr*>(&addr),
-                      addrlen);
+  RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen);
   int buf_sz = 1 << 18;
   EXPECT_THAT(
       setsockopt(s.get(), SOL_SOCKET, SO_RCVBUF, &buf_sz, sizeof(buf_sz)),
@@ -2034,8 +1987,7 @@ TEST_P(SimpleTcpSocketTest, GetSocketAcceptConnWithShutdown) {
   socklen_t addrlen = sizeof(addr);
 
   // Bind to some port then start listening.
-  ASSERT_THAT(bind(s.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen),
-              SyscallSucceeds());
+  ASSERT_THAT(bind(s.get(), AsSockAddr(&addr), addrlen), SyscallSucceeds());
 
   ASSERT_THAT(listen(s.get(), SOMAXCONN), SyscallSucceeds());
 
@@ -2062,10 +2014,8 @@ TEST_P(SimpleTcpSocketTest, ConnectUnspecifiedAddress) {
   auto do_connect = [&addr, addrlen]() {
     FileDescriptor s = ASSERT_NO_ERRNO_AND_VALUE(
         Socket(addr.ss_family, SOCK_STREAM, IPPROTO_TCP));
-    ASSERT_THAT(
-        RetryEINTR(connect)(s.get(), reinterpret_cast<struct sockaddr*>(&addr),
-                            addrlen),
-        SyscallFailsWithErrno(ECONNREFUSED));
+    ASSERT_THAT(RetryEINTR(connect)(s.get(), AsSockAddr(&addr), addrlen),
+                SyscallFailsWithErrno(ECONNREFUSED));
   };
   do_connect();
   // Test the v4 mapped address as well.
diff --git a/test/syscalls/linux/tuntap.cc b/test/syscalls/linux/tuntap.cc
index 13ed0d68a..93ee11870 100644
--- a/test/syscalls/linux/tuntap.cc
+++ b/test/syscalls/linux/tuntap.cc
@@ -397,8 +397,7 @@ TEST_F(TuntapTest, SendUdpTriggersArpResolution) {
       .sin_port = htons(42),
       .sin_addr = {.s_addr = kTapPeerIPAddr},
   };
-  ASSERT_THAT(sendto(sock, "hello", 5, 0, reinterpret_cast<sockaddr*>(&remote),
-                     sizeof(remote)),
+  ASSERT_THAT(sendto(sock, "hello", 5, 0, AsSockAddr(&remote), sizeof(remote)),
               SyscallSucceeds());
 
   struct inpkt {
@@ -498,7 +497,7 @@ TEST_F(TuntapTest, WriteHangBug155928773) {
       .sin_addr = {.s_addr = kTapIPAddr},
   };
   // Return values do not matter in this test.
-  connect(sock, reinterpret_cast<struct sockaddr*>(&remote), sizeof(remote));
+  connect(sock, AsSockAddr(&remote), sizeof(remote));
   write(sock, "hello", 5);
 }
 
diff --git a/test/syscalls/linux/udp_bind.cc b/test/syscalls/linux/udp_bind.cc
index 6d92bdbeb..f68d78aa2 100644
--- a/test/syscalls/linux/udp_bind.cc
+++ b/test/syscalls/linux/udp_bind.cc
@@ -83,27 +83,24 @@ TEST_P(SendtoTest, Sendto) {
       ASSERT_NO_ERRNO_AND_VALUE(Socket(param.recv_domain, SOCK_DGRAM, 0));
 
   if (param.send_addr_len > 0) {
-    ASSERT_THAT(bind(s1.get(), reinterpret_cast<sockaddr*>(&param.send_addr),
-                     param.send_addr_len),
-                SyscallSucceeds());
+    ASSERT_THAT(
+        bind(s1.get(), AsSockAddr(&param.send_addr), param.send_addr_len),
+        SyscallSucceeds());
   }
 
   if (param.connect_addr_len > 0) {
-    ASSERT_THAT(
-        connect(s1.get(), reinterpret_cast<sockaddr*>(&param.connect_addr),
-                param.connect_addr_len),
-        SyscallSucceeds());
+    ASSERT_THAT(connect(s1.get(), AsSockAddr(&param.connect_addr),
+                        param.connect_addr_len),
+                SyscallSucceeds());
   }
 
-  ASSERT_THAT(bind(s2.get(), reinterpret_cast<sockaddr*>(&param.recv_addr),
-                   param.recv_addr_len),
+  ASSERT_THAT(bind(s2.get(), AsSockAddr(&param.recv_addr), param.recv_addr_len),
               SyscallSucceeds());
 
   struct sockaddr_storage real_recv_addr = {};
   socklen_t real_recv_addr_len = param.recv_addr_len;
   ASSERT_THAT(
-      getsockname(s2.get(), reinterpret_cast<sockaddr*>(&real_recv_addr),
-                  &real_recv_addr_len),
+      getsockname(s2.get(), AsSockAddr(&real_recv_addr), &real_recv_addr_len),
       SyscallSucceeds());
 
   ASSERT_EQ(real_recv_addr_len, param.recv_addr_len);
@@ -116,23 +113,22 @@ TEST_P(SendtoTest, Sendto) {
 
   char buf[20] = {};
   if (!param.sendto_errnos.empty()) {
-    ASSERT_THAT(RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
-                                   reinterpret_cast<sockaddr*>(&sendto_addr),
-                                   param.sendto_addr_len),
-                SyscallFailsWithErrno(ElementOf(param.sendto_errnos)));
+    ASSERT_THAT(
+        RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
+                           AsSockAddr(&sendto_addr), param.sendto_addr_len),
+        SyscallFailsWithErrno(ElementOf(param.sendto_errnos)));
     return;
   }
 
-  ASSERT_THAT(RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
-                                 reinterpret_cast<sockaddr*>(&sendto_addr),
-                                 param.sendto_addr_len),
-              SyscallSucceedsWithValue(sizeof(buf)));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(s1.get(), buf, sizeof(buf), 0,
+                         AsSockAddr(&sendto_addr), param.sendto_addr_len),
+      SyscallSucceedsWithValue(sizeof(buf)));
 
   struct sockaddr_storage got_addr = {};
   socklen_t got_addr_len = sizeof(sockaddr_storage);
   ASSERT_THAT(RetryEINTR(recvfrom)(s2.get(), buf, sizeof(buf), 0,
-                                   reinterpret_cast<sockaddr*>(&got_addr),
-                                   &got_addr_len),
+                                   AsSockAddr(&got_addr), &got_addr_len),
               SyscallSucceedsWithValue(sizeof(buf)));
 
   ASSERT_GT(got_addr_len, sizeof(sockaddr_in_common));
@@ -140,8 +136,7 @@ TEST_P(SendtoTest, Sendto) {
 
   struct sockaddr_storage sender_addr = {};
   socklen_t sender_addr_len = sizeof(sockaddr_storage);
-  ASSERT_THAT(getsockname(s1.get(), reinterpret_cast<sockaddr*>(&sender_addr),
-                          &sender_addr_len),
+  ASSERT_THAT(getsockname(s1.get(), AsSockAddr(&sender_addr), &sender_addr_len),
               SyscallSucceeds());
 
   ASSERT_GT(sender_addr_len, sizeof(sockaddr_in_common));
diff --git a/test/syscalls/linux/udp_socket.cc b/test/syscalls/linux/udp_socket.cc
index 16eeeb5c6..4aa29037a 100644
--- a/test/syscalls/linux/udp_socket.cc
+++ b/test/syscalls/linux/udp_socket.cc
@@ -138,7 +138,7 @@ void UdpSocketTest::SetUp() {
   bind_ =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetFamily(), SOCK_DGRAM, IPPROTO_UDP));
   memset(&bind_addr_storage_, 0, sizeof(bind_addr_storage_));
-  bind_addr_ = reinterpret_cast<struct sockaddr*>(&bind_addr_storage_);
+  bind_addr_ = AsSockAddr(&bind_addr_storage_);
 
   sock_ =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetFamily(), SOCK_DGRAM, IPPROTO_UDP));
@@ -153,15 +153,13 @@ int UdpSocketTest::GetFamily() {
 
 PosixError UdpSocketTest::BindLoopback() {
   bind_addr_storage_ = InetLoopbackAddr();
-  struct sockaddr* bind_addr_ =
-      reinterpret_cast<struct sockaddr*>(&bind_addr_storage_);
+  struct sockaddr* bind_addr_ = AsSockAddr(&bind_addr_storage_);
   return BindSocket(bind_.get(), bind_addr_);
 }
 
 PosixError UdpSocketTest::BindAny() {
   bind_addr_storage_ = InetAnyAddr();
-  struct sockaddr* bind_addr_ =
-      reinterpret_cast<struct sockaddr*>(&bind_addr_storage_);
+  struct sockaddr* bind_addr_ = AsSockAddr(&bind_addr_storage_);
   return BindSocket(bind_.get(), bind_addr_);
 }
 
@@ -195,7 +193,7 @@ socklen_t UdpSocketTest::GetAddrLength() {
 sockaddr_storage UdpSocketTest::InetAnyAddr() {
   struct sockaddr_storage addr;
   memset(&addr, 0, sizeof(addr));
-  reinterpret_cast<struct sockaddr*>(&addr)->sa_family = GetFamily();
+  AsSockAddr(&addr)->sa_family = GetFamily();
 
   if (GetFamily() == AF_INET) {
     auto sin = reinterpret_cast<struct sockaddr_in*>(&addr);
@@ -213,7 +211,7 @@ sockaddr_storage UdpSocketTest::InetAnyAddr() {
 sockaddr_storage UdpSocketTest::InetLoopbackAddr() {
   struct sockaddr_storage addr;
   memset(&addr, 0, sizeof(addr));
-  reinterpret_cast<struct sockaddr*>(&addr)->sa_family = GetFamily();
+  AsSockAddr(&addr)->sa_family = GetFamily();
 
   if (GetFamily() == AF_INET) {
     auto sin = reinterpret_cast<struct sockaddr_in*>(&addr);
@@ -229,7 +227,7 @@ sockaddr_storage UdpSocketTest::InetLoopbackAddr() {
 
 void UdpSocketTest::Disconnect(int sockfd) {
   sockaddr_storage addr_storage = InetAnyAddr();
-  sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  sockaddr* addr = AsSockAddr(&addr_storage);
   socklen_t addrlen = sizeof(addr_storage);
 
   addr->sa_family = AF_UNSPEC;
@@ -265,19 +263,16 @@ TEST_P(UdpSocketTest, Getsockname) {
   // Check that we're not bound.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getsockname(bind_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(bind_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
   EXPECT_EQ(addrlen, addrlen_);
   struct sockaddr_storage any = InetAnyAddr();
-  EXPECT_EQ(memcmp(&addr, reinterpret_cast<struct sockaddr*>(&any), addrlen_),
-            0);
+  EXPECT_EQ(memcmp(&addr, AsSockAddr(&any), addrlen_), 0);
 
   ASSERT_NO_ERRNO(BindLoopback());
 
-  EXPECT_THAT(
-      getsockname(bind_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(bind_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
 
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(memcmp(&addr, bind_addr_, addrlen_), 0);
@@ -289,17 +284,15 @@ TEST_P(UdpSocketTest, Getpeername) {
   // Check that we're not connected.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallFailsWithErrno(ENOTCONN));
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallFailsWithErrno(ENOTCONN));
 
   // Connect, then check that we get the right address.
   ASSERT_THAT(connect(sock_.get(), bind_addr_, addrlen_), SyscallSucceeds());
 
   addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(memcmp(&addr, bind_addr_, addrlen_), 0);
 }
@@ -322,9 +315,8 @@ TEST_P(UdpSocketTest, SendNotConnected) {
   // Check that we're bound now.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_NE(*Port(&addr), 0);
 }
@@ -338,9 +330,8 @@ TEST_P(UdpSocketTest, ConnectBinds) {
   // Check that we're bound now.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_NE(*Port(&addr), 0);
 }
@@ -361,9 +352,8 @@ TEST_P(UdpSocketTest, Bind) {
   // Check that we're still bound to the original address.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getsockname(bind_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(bind_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(memcmp(&addr, bind_addr_, addrlen_), 0);
 }
@@ -383,7 +373,7 @@ TEST_P(UdpSocketTest, ConnectWriteToInvalidPort) {
   // same time.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
   socklen_t addrlen = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   FileDescriptor s =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetFamily(), SOCK_DGRAM, IPPROTO_UDP));
   ASSERT_THAT(bind(s.get(), addr, addrlen), SyscallSucceeds());
@@ -417,7 +407,7 @@ TEST_P(UdpSocketTest, ConnectSimultaneousWriteToInvalidPort) {
   // same time.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
   socklen_t addrlen = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   FileDescriptor s =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetFamily(), SOCK_DGRAM, IPPROTO_UDP));
   ASSERT_THAT(bind(s.get(), addr, addrlen), SyscallSucceeds());
@@ -465,18 +455,17 @@ TEST_P(UdpSocketTest, ReceiveAfterDisconnect) {
 
     struct sockaddr_storage addr;
     socklen_t addrlen = sizeof(addr);
-    EXPECT_THAT(
-        getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-        SyscallSucceeds());
+    EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &addrlen),
+                SyscallSucceeds());
     EXPECT_EQ(addrlen, addrlen_);
 
     // Send from sock to bind_.
     char buf[512];
     RandomizeBuffer(buf, sizeof(buf));
 
-    ASSERT_THAT(sendto(bind_.get(), buf, sizeof(buf), 0,
-                       reinterpret_cast<sockaddr*>(&addr), addrlen),
-                SyscallSucceedsWithValue(sizeof(buf)));
+    ASSERT_THAT(
+        sendto(bind_.get(), buf, sizeof(buf), 0, AsSockAddr(&addr), addrlen),
+        SyscallSucceedsWithValue(sizeof(buf)));
 
     // Receive the data.
     char received[sizeof(buf)];
@@ -499,21 +488,18 @@ TEST_P(UdpSocketTest, Connect) {
   // Check that we're connected to the right peer.
   struct sockaddr_storage peer;
   socklen_t peerlen = sizeof(peer);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&peer), &peerlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&peer), &peerlen),
+              SyscallSucceeds());
   EXPECT_EQ(peerlen, addrlen_);
   EXPECT_EQ(memcmp(&peer, bind_addr_, addrlen_), 0);
 
   // Try to bind after connect.
   struct sockaddr_storage any = InetAnyAddr();
-  EXPECT_THAT(
-      bind(sock_.get(), reinterpret_cast<struct sockaddr*>(&any), addrlen_),
-      SyscallFailsWithErrno(EINVAL));
+  EXPECT_THAT(bind(sock_.get(), AsSockAddr(&any), addrlen_),
+              SyscallFailsWithErrno(EINVAL));
 
   struct sockaddr_storage bind2_storage = InetLoopbackAddr();
-  struct sockaddr* bind2_addr =
-      reinterpret_cast<struct sockaddr*>(&bind2_storage);
+  struct sockaddr* bind2_addr = AsSockAddr(&bind2_storage);
   FileDescriptor bind2 =
       ASSERT_NO_ERRNO_AND_VALUE(Socket(GetFamily(), SOCK_DGRAM, IPPROTO_UDP));
   ASSERT_NO_ERRNO(BindSocket(bind2.get(), bind2_addr));
@@ -523,9 +509,8 @@ TEST_P(UdpSocketTest, Connect) {
 
   // Check that peer name changed.
   peerlen = sizeof(peer);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&peer), &peerlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&peer), &peerlen),
+              SyscallSucceeds());
   EXPECT_EQ(peerlen, addrlen_);
   EXPECT_EQ(memcmp(&peer, bind2_addr, addrlen_), 0);
 }
@@ -535,15 +520,13 @@ TEST_P(UdpSocketTest, ConnectAnyZero) {
   SKIP_IF(IsRunningOnGvisor());
 
   struct sockaddr_storage any = InetAnyAddr();
-  EXPECT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&any), addrlen_),
-      SyscallSucceeds());
+  EXPECT_THAT(connect(sock_.get(), AsSockAddr(&any), addrlen_),
+              SyscallSucceeds());
 
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallFailsWithErrno(ENOTCONN));
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallFailsWithErrno(ENOTCONN));
 }
 
 TEST_P(UdpSocketTest, ConnectAnyWithPort) {
@@ -552,24 +535,21 @@ TEST_P(UdpSocketTest, ConnectAnyWithPort) {
 
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
 }
 
 TEST_P(UdpSocketTest, DisconnectAfterConnectAny) {
   // TODO(138658473): Enable when we can connect to port 0 with gVisor.
   SKIP_IF(IsRunningOnGvisor());
   struct sockaddr_storage any = InetAnyAddr();
-  EXPECT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&any), addrlen_),
-      SyscallSucceeds());
+  EXPECT_THAT(connect(sock_.get(), AsSockAddr(&any), addrlen_),
+              SyscallSucceeds());
 
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallFailsWithErrno(ENOTCONN));
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallFailsWithErrno(ENOTCONN));
 
   Disconnect(sock_.get());
 }
@@ -580,9 +560,8 @@ TEST_P(UdpSocketTest, DisconnectAfterConnectAnyWithPort) {
 
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
 
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(*Port(&bind_addr_storage_), *Port(&addr));
@@ -595,7 +574,7 @@ TEST_P(UdpSocketTest, DisconnectAfterBind) {
 
   // Bind to the next port above bind_.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_NO_ERRNO(BindSocket(sock_.get(), addr));
 
@@ -604,15 +583,14 @@ TEST_P(UdpSocketTest, DisconnectAfterBind) {
 
   struct sockaddr_storage unspec = {};
   unspec.ss_family = AF_UNSPEC;
-  EXPECT_THAT(connect(sock_.get(), reinterpret_cast<sockaddr*>(&unspec),
-                      sizeof(unspec.ss_family)),
-              SyscallSucceeds());
+  EXPECT_THAT(
+      connect(sock_.get(), AsSockAddr(&unspec), sizeof(unspec.ss_family)),
+      SyscallSucceeds());
 
   // Check that we're still bound.
   socklen_t addrlen = sizeof(unspec);
-  EXPECT_THAT(
-      getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&unspec), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&unspec), &addrlen),
+              SyscallSucceeds());
 
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(memcmp(addr, &unspec, addrlen_), 0);
@@ -626,7 +604,7 @@ TEST_P(UdpSocketTest, BindToAnyConnnectToLocalhost) {
   ASSERT_NO_ERRNO(BindAny());
 
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   socklen_t addrlen = sizeof(addr);
 
@@ -653,7 +631,7 @@ TEST_P(UdpSocketTest, DisconnectAfterBindToAny) {
   ASSERT_NO_ERRNO(BindLoopback());
 
   struct sockaddr_storage any_storage = InetAnyAddr();
-  struct sockaddr* any = reinterpret_cast<struct sockaddr*>(&any_storage);
+  struct sockaddr* any = AsSockAddr(&any_storage);
   SetPort(&any_storage, *Port(&bind_addr_storage_) + 1);
 
   ASSERT_NO_ERRNO(BindSocket(sock_.get(), any));
@@ -666,24 +644,22 @@ TEST_P(UdpSocketTest, DisconnectAfterBindToAny) {
   // Check that we're still bound.
   struct sockaddr_storage addr;
   socklen_t addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallSucceeds());
+  EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallSucceeds());
 
   EXPECT_EQ(addrlen, addrlen_);
   EXPECT_EQ(memcmp(&addr, any, addrlen), 0);
 
   addrlen = sizeof(addr);
-  EXPECT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-      SyscallFailsWithErrno(ENOTCONN));
+  EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&addr), &addrlen),
+              SyscallFailsWithErrno(ENOTCONN));
 }
 
 TEST_P(UdpSocketTest, Disconnect) {
   ASSERT_NO_ERRNO(BindLoopback());
 
   struct sockaddr_storage any_storage = InetAnyAddr();
-  struct sockaddr* any = reinterpret_cast<struct sockaddr*>(&any_storage);
+  struct sockaddr* any = AsSockAddr(&any_storage);
   SetPort(&any_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_NO_ERRNO(BindSocket(sock_.get(), any));
 
@@ -694,29 +670,25 @@ TEST_P(UdpSocketTest, Disconnect) {
     // Check that we're connected to the right peer.
     struct sockaddr_storage peer;
     socklen_t peerlen = sizeof(peer);
-    EXPECT_THAT(
-        getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&peer), &peerlen),
-        SyscallSucceeds());
+    EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&peer), &peerlen),
+                SyscallSucceeds());
     EXPECT_EQ(peerlen, addrlen_);
     EXPECT_EQ(memcmp(&peer, bind_addr_, addrlen_), 0);
 
     // Try to disconnect.
     struct sockaddr_storage addr = {};
     addr.ss_family = AF_UNSPEC;
-    EXPECT_THAT(connect(sock_.get(), reinterpret_cast<sockaddr*>(&addr),
-                        sizeof(addr.ss_family)),
+    EXPECT_THAT(connect(sock_.get(), AsSockAddr(&addr), sizeof(addr.ss_family)),
                 SyscallSucceeds());
 
     peerlen = sizeof(peer);
-    EXPECT_THAT(
-        getpeername(sock_.get(), reinterpret_cast<sockaddr*>(&peer), &peerlen),
-        SyscallFailsWithErrno(ENOTCONN));
+    EXPECT_THAT(getpeername(sock_.get(), AsSockAddr(&peer), &peerlen),
+                SyscallFailsWithErrno(ENOTCONN));
 
     // Check that we're still bound.
     socklen_t addrlen = sizeof(addr);
-    EXPECT_THAT(
-        getsockname(sock_.get(), reinterpret_cast<sockaddr*>(&addr), &addrlen),
-        SyscallSucceeds());
+    EXPECT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &addrlen),
+                SyscallSucceeds());
     EXPECT_EQ(addrlen, addrlen_);
     EXPECT_EQ(*Port(&addr), *Port(&any_storage));
   }
@@ -733,7 +705,7 @@ TEST_P(UdpSocketTest, SendToAddressOtherThanConnected) {
   ASSERT_NO_ERRNO(BindLoopback());
 
   struct sockaddr_storage addr_storage = InetAnyAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
 
   ASSERT_THAT(connect(sock_.get(), bind_addr_, addrlen_), SyscallSucceeds());
@@ -881,7 +853,7 @@ TEST_P(UdpSocketTest, ZerolengthWriteAllowed) {
   ASSERT_NO_ERRNO(BindLoopback());
   // Connect to loopback:bind_addr_+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -910,7 +882,7 @@ TEST_P(UdpSocketTest, ZerolengthWriteAllowedNonBlockRead) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -961,7 +933,7 @@ TEST_P(UdpSocketTest, SendAndReceiveConnected) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -987,13 +959,13 @@ TEST_P(UdpSocketTest, ReceiveFromNotConnected) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
   // Bind sock to loopback:bind_addr_port+2.
   struct sockaddr_storage addr2_storage = InetLoopbackAddr();
-  struct sockaddr* addr2 = reinterpret_cast<struct sockaddr*>(&addr2_storage);
+  struct sockaddr* addr2 = AsSockAddr(&addr2_storage);
   SetPort(&addr2_storage, *Port(&bind_addr_storage_) + 2);
   ASSERT_THAT(bind(sock_.get(), addr2, addrlen_), SyscallSucceeds());
 
@@ -1013,7 +985,7 @@ TEST_P(UdpSocketTest, ReceiveBeforeConnect) {
 
   // Bind sock to loopback:bind_addr_port+2.
   struct sockaddr_storage addr2_storage = InetLoopbackAddr();
-  struct sockaddr* addr2 = reinterpret_cast<struct sockaddr*>(&addr2_storage);
+  struct sockaddr* addr2 = AsSockAddr(&addr2_storage);
   SetPort(&addr2_storage, *Port(&bind_addr_storage_) + 2);
   ASSERT_THAT(bind(sock_.get(), addr2, addrlen_), SyscallSucceeds());
 
@@ -1026,7 +998,7 @@ TEST_P(UdpSocketTest, ReceiveBeforeConnect) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -1050,7 +1022,7 @@ TEST_P(UdpSocketTest, ReceiveFrom) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -1069,7 +1041,7 @@ TEST_P(UdpSocketTest, ReceiveFrom) {
   struct sockaddr_storage addr2;
   socklen_t addr2len = sizeof(addr2);
   EXPECT_THAT(recvfrom(bind_.get(), received, sizeof(received), 0,
-                       reinterpret_cast<sockaddr*>(&addr2), &addr2len),
+                       AsSockAddr(&addr2), &addr2len),
               SyscallSucceedsWithValue(sizeof(received)));
   EXPECT_EQ(memcmp(buf, received, sizeof(buf)), 0);
   EXPECT_EQ(addr2len, addrlen_);
@@ -1093,7 +1065,7 @@ TEST_P(UdpSocketTest, ReadShutdownNonblockPendingData) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -1149,7 +1121,7 @@ TEST_P(UdpSocketTest, ReadShutdownSameSocketResetsShutdownState) {
 
   // Connect to loopback:bind_addr_port+1.
   struct sockaddr_storage addr_storage = InetLoopbackAddr();
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  struct sockaddr* addr = AsSockAddr(&addr_storage);
   SetPort(&addr_storage, *Port(&bind_addr_storage_) + 1);
   ASSERT_THAT(connect(bind_.get(), addr, addrlen_), SyscallSucceeds());
 
@@ -2051,68 +2023,57 @@ TEST_P(UdpSocketTest, SendToZeroPort) {
 
   // Sending to an invalid port should fail.
   SetPort(&addr, 0);
-  EXPECT_THAT(sendto(sock_.get(), buf, sizeof(buf), 0,
-                     reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)),
-              SyscallFailsWithErrno(EINVAL));
+  EXPECT_THAT(
+      sendto(sock_.get(), buf, sizeof(buf), 0, AsSockAddr(&addr), sizeof(addr)),
+      SyscallFailsWithErrno(EINVAL));
 
   SetPort(&addr, 1234);
-  EXPECT_THAT(sendto(sock_.get(), buf, sizeof(buf), 0,
-                     reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)),
-              SyscallSucceedsWithValue(sizeof(buf)));
+  EXPECT_THAT(
+      sendto(sock_.get(), buf, sizeof(buf), 0, AsSockAddr(&addr), sizeof(addr)),
+      SyscallSucceedsWithValue(sizeof(buf)));
 }
 
 TEST_P(UdpSocketTest, ConnectToZeroPortUnbound) {
   struct sockaddr_storage addr = InetLoopbackAddr();
   SetPort(&addr, 0);
-  ASSERT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen_),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sock_.get(), AsSockAddr(&addr), addrlen_),
+              SyscallSucceeds());
 }
 
 TEST_P(UdpSocketTest, ConnectToZeroPortBound) {
   struct sockaddr_storage addr = InetLoopbackAddr();
-  ASSERT_NO_ERRNO(
-      BindSocket(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr)));
+  ASSERT_NO_ERRNO(BindSocket(sock_.get(), AsSockAddr(&addr)));
 
   SetPort(&addr, 0);
-  ASSERT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen_),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sock_.get(), AsSockAddr(&addr), addrlen_),
+              SyscallSucceeds());
   socklen_t len = sizeof(sockaddr_storage);
-  ASSERT_THAT(
-      getsockname(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr), &len),
-      SyscallSucceeds());
+  ASSERT_THAT(getsockname(sock_.get(), AsSockAddr(&addr), &len),
+              SyscallSucceeds());
   ASSERT_EQ(len, addrlen_);
 }
 
 TEST_P(UdpSocketTest, ConnectToZeroPortConnected) {
   struct sockaddr_storage addr = InetLoopbackAddr();
-  ASSERT_NO_ERRNO(
-      BindSocket(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr)));
+  ASSERT_NO_ERRNO(BindSocket(sock_.get(), AsSockAddr(&addr)));
 
   // Connect to an address with non-zero port should succeed.
-  ASSERT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen_),
-      SyscallSucceeds());
+  ASSERT_THAT(connect(sock_.get(), AsSockAddr(&addr), addrlen_),
+              SyscallSucceeds());
   sockaddr_storage peername;
   socklen_t peerlen = sizeof(peername);
-  ASSERT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<struct sockaddr*>(&peername),
-                  &peerlen),
-      SyscallSucceeds());
+  ASSERT_THAT(getpeername(sock_.get(), AsSockAddr(&peername), &peerlen),
+              SyscallSucceeds());
   ASSERT_EQ(peerlen, addrlen_);
   ASSERT_EQ(memcmp(&peername, &addr, addrlen_), 0);
 
   // However connect() to an address with port 0 will make the following
   // getpeername() fail.
   SetPort(&addr, 0);
-  ASSERT_THAT(
-      connect(sock_.get(), reinterpret_cast<struct sockaddr*>(&addr), addrlen_),
-      SyscallSucceeds());
-  ASSERT_THAT(
-      getpeername(sock_.get(), reinterpret_cast<struct sockaddr*>(&peername),
-                  &peerlen),
-      SyscallFailsWithErrno(ENOTCONN));
+  ASSERT_THAT(connect(sock_.get(), AsSockAddr(&addr), addrlen_),
+              SyscallSucceeds());
+  ASSERT_THAT(getpeername(sock_.get(), AsSockAddr(&peername), &peerlen),
+              SyscallFailsWithErrno(ENOTCONN));
 }
 
 INSTANTIATE_TEST_SUITE_P(AllInetTests, UdpSocketTest,
@@ -2133,8 +2094,7 @@ TEST(UdpInet6SocketTest, ConnectInet4Sockaddr) {
       SyscallSucceeds());
   sockaddr_storage sockname;
   socklen_t len = sizeof(sockaddr_storage);
-  ASSERT_THAT(getsockname(sock_.get(),
-                          reinterpret_cast<struct sockaddr*>(&sockname), &len),
+  ASSERT_THAT(getsockname(sock_.get(), AsSockAddr(&sockname), &len),
               SyscallSucceeds());
   ASSERT_EQ(sockname.ss_family, AF_INET6);
   ASSERT_EQ(len, sizeof(sockaddr_in6));