@fails-components/webtransport 0.0.6 → 0.0.8

package/platform/quiche_platform_impl/quic_udp_socket_winsock.cc

@@ -21,630 +21,712 @@
 #if defined(__linux__) && !defined(__ANDROID__)
 #define QUIC_UDP_SOCKET_SUPPORT_TTL 1
 #endif
-namespace quic {
-namespace {
+namespace quic
+{
+  namespace
+  {
 
 #if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
 #define QUIC_UDP_SOCKET_SUPPORT_LINUX_TIMESTAMPING 1
-// This is the structure that SO_TIMESTAMPING fills into the cmsg header.
-// It is well-defined, but does not have a definition in a public header.
-// See https://www.kernel.org/doc/Documentation/networking/timestamping.txt
-// for more information.
-struct LinuxSoTimestamping {
-  // The converted system time of the timestamp.
-  struct timespec systime;
-  // Deprecated; serves only as padding.
-  struct timespec hwtimetrans;
-  // The raw hardware timestamp.
-  struct timespec hwtimeraw;
-};
-const size_t kCmsgSpaceForRecvTimestamp =
-    CMSG_SPACE(sizeof(LinuxSoTimestamping));
+    // This is the structure that SO_TIMESTAMPING fills into the cmsg header.
+    // It is well-defined, but does not have a definition in a public header.
+    // See https://www.kernel.org/doc/Documentation/networking/timestamping.txt
+    // for more information.
+    struct LinuxSoTimestamping
+    {
+      // The converted system time of the timestamp.
+      struct timespec systime;
+      // Deprecated; serves only as padding.
+      struct timespec hwtimetrans;
+      // The raw hardware timestamp.
+      struct timespec hwtimeraw;
+    };
+    const size_t kCmsgSpaceForRecvTimestamp =
+        CMSG_SPACE(sizeof(LinuxSoTimestamping));
 #else
-const size_t kCmsgSpaceForRecvTimestamp = 0;
+    const size_t kCmsgSpaceForRecvTimestamp = 0;
 #endif
 
-const size_t kMinCmsgSpaceForRead =
-    CMSG_SPACE(sizeof(uint32_t))       // Dropped packet count
-    + CMSG_SPACE(sizeof(in_pktinfo))   // V4 Self IP
-    + CMSG_SPACE(sizeof(in6_pktinfo))  // V6 Self IP
-    + kCmsgSpaceForRecvTimestamp + CMSG_SPACE(sizeof(int))  // TTL
-    + kCmsgSpaceForGooglePacketHeader;
-
-void SetV4SelfIpInControlMessage(const QuicIpAddress& self_address,
-                                 cmsghdr* cmsg) {
-  QUICHE_DCHECK(self_address.IsIPv4());
-  in_pktinfo* pktinfo = reinterpret_cast<in_pktinfo*>(WSA_CMSG_DATA(cmsg));
-  memset(pktinfo, 0, sizeof(in_pktinfo));
-  pktinfo->ipi_ifindex = 0;
-  std::string address_string = self_address.ToPackedString();
-  memcpy(&pktinfo->ipi_addr, address_string.c_str(),
-         address_string.length());
-}
-
-void SetV6SelfIpInControlMessage(const QuicIpAddress& self_address,
-                                 cmsghdr* cmsg) {
-  QUICHE_DCHECK(self_address.IsIPv6());
-  in6_pktinfo* pktinfo = reinterpret_cast<in6_pktinfo*>(WSA_CMSG_DATA(cmsg));
-  memset(pktinfo, 0, sizeof(in6_pktinfo));
-  std::string address_string = self_address.ToPackedString();
-  memcpy(&pktinfo->ipi6_addr, address_string.c_str(), address_string.length());
-}
-
-void PopulatePacketInfoFromControlMessage(struct cmsghdr* cmsg,
-                                          QuicUdpPacketInfo* packet_info,
-                                          BitMask64 packet_info_interested) {
-#if defined(__linux__) && defined(SO_RXQ_OVFL)
-  if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_RXQ_OVFL) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::DROPPED_PACKETS)) {
-      packet_info->SetDroppedPackets(
-          *(reinterpret_cast<uint32_t*> WSA_CMSG_DATA(cmsg)));
+    const size_t kMinCmsgSpaceForRead =
+        CMSG_SPACE(sizeof(uint32_t))                           // Dropped packet count
+        + CMSG_SPACE(sizeof(in_pktinfo))                       // V4 Self IP
+        + CMSG_SPACE(sizeof(in6_pktinfo))                      // V6 Self IP
+        + kCmsgSpaceForRecvTimestamp + CMSG_SPACE(sizeof(int)) // TTL
+        + kCmsgSpaceForGooglePacketHeader;
+
+    void SetV4SelfIpInControlMessage(const QuicIpAddress &self_address,
+                                     cmsghdr *cmsg)
+    {
+      QUICHE_DCHECK(self_address.IsIPv4());
+      in_pktinfo *pktinfo = reinterpret_cast<in_pktinfo *>(WSA_CMSG_DATA(cmsg));
+      memset(pktinfo, 0, sizeof(in_pktinfo));
+      pktinfo->ipi_ifindex = 0;
+      std::string address_string = self_address.ToPackedString();
+      memcpy(&pktinfo->ipi_addr, address_string.c_str(),
+             address_string.length());
     }
-    return;
-  }
+
+    void SetV6SelfIpInControlMessage(const QuicIpAddress &self_address,
+                                     cmsghdr *cmsg)
+    {
+      QUICHE_DCHECK(self_address.IsIPv6());
+      in6_pktinfo *pktinfo = reinterpret_cast<in6_pktinfo *>(WSA_CMSG_DATA(cmsg));
+      memset(pktinfo, 0, sizeof(in6_pktinfo));
+      std::string address_string = self_address.ToPackedString();
+      memcpy(&pktinfo->ipi6_addr, address_string.c_str(), address_string.length());
+    }
+
+    void PopulatePacketInfoFromControlMessage(struct cmsghdr *cmsg,
+                                              QuicUdpPacketInfo *packet_info,
+                                              BitMask64 packet_info_interested)
+    {
+#if defined(__linux__) && defined(SO_RXQ_OVFL)
+      if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_RXQ_OVFL)
+      {
+        if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::DROPPED_PACKETS))
+        {
+          packet_info->SetDroppedPackets(
+              *(reinterpret_cast<uint32_t *> WSA_CMSG_DATA(cmsg)));
+        }
+        return;
+      }
 #endif
 
 #if defined(QUIC_UDP_SOCKET_SUPPORT_LINUX_TIMESTAMPING)
-  if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMPING) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::RECV_TIMESTAMP)) {
-      LinuxSoTimestamping* linux_ts =
-          reinterpret_cast<LinuxSoTimestamping*>(WSA_CMSG_DATA(cmsg));
-      timespec* ts = &linux_ts->systime;
-      int64_t usec = (static_cast<int64_t>(ts->tv_sec) * 1000 * 1000) +
-                     (static_cast<int64_t>(ts->tv_nsec) / 1000);
-      packet_info->SetReceiveTimestamp(
-          QuicWallTime::FromUNIXMicroseconds(usec));
-    }
-    return;
-  }
+      if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMPING)
+      {
+        if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::RECV_TIMESTAMP))
+        {
+          LinuxSoTimestamping *linux_ts =
+              reinterpret_cast<LinuxSoTimestamping *>(WSA_CMSG_DATA(cmsg));
+          timespec *ts = &linux_ts->systime;
+          int64_t usec = (static_cast<int64_t>(ts->tv_sec) * 1000 * 1000) +
+                         (static_cast<int64_t>(ts->tv_nsec) / 1000);
+          packet_info->SetReceiveTimestamp(
+              QuicWallTime::FromUNIXMicroseconds(usec));
+        }
+        return;
+      }
 #endif
 
-  if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_SELF_IP)) {
-      const in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>(WSA_CMSG_DATA(cmsg));
-      const char* addr_data = reinterpret_cast<const char*>(&info->ipi6_addr);
-      int addr_len = sizeof(in6_addr);
-      QuicIpAddress self_v6_ip;
-      if (self_v6_ip.FromPackedString(addr_data, addr_len)) {
-        packet_info->SetSelfV6Ip(self_v6_ip);
-      } else {
-        QUIC_BUG(quic_bug_10751_1) << "QuicIpAddress::FromPackedString failed";
+      if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO)
+      {
+        if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_SELF_IP))
+        {
+          const in6_pktinfo *info = reinterpret_cast<in6_pktinfo *>(WSA_CMSG_DATA(cmsg));
+          const char *addr_data = reinterpret_cast<const char *>(&info->ipi6_addr);
+          int addr_len = sizeof(in6_addr);
+          QuicIpAddress self_v6_ip;
+          if (self_v6_ip.FromPackedString(addr_data, addr_len))
+          {
+            packet_info->SetSelfV6Ip(self_v6_ip);
+          }
+          else
+          {
+            QUIC_BUG(quic_bug_10751_1) << "QuicIpAddress::FromPackedString failed";
+          }
+        }
+        return;
       }
-    }
-    return;
-  }
 
-  if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V4_SELF_IP)) {
-      const in_pktinfo* info = reinterpret_cast<in_pktinfo*>(WSA_CMSG_DATA(cmsg));
-      const char* addr_data = reinterpret_cast<const char*>(&info->ipi_addr);
-      int addr_len = sizeof(in_addr);
-      QuicIpAddress self_v4_ip;
-      if (self_v4_ip.FromPackedString(addr_data, addr_len)) {
-        packet_info->SetSelfV4Ip(self_v4_ip);
-      } else {
-        QUIC_BUG(quic_bug_10751_2) << "QuicIpAddress::FromPackedString failed";
+      if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
+      {
+        if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V4_SELF_IP))
+        {
+          const in_pktinfo *info = reinterpret_cast<in_pktinfo *>(WSA_CMSG_DATA(cmsg));
+          const char *addr_data = reinterpret_cast<const char *>(&info->ipi_addr);
+          int addr_len = sizeof(in_addr);
+          QuicIpAddress self_v4_ip;
+          if (self_v4_ip.FromPackedString(addr_data, addr_len))
+          {
+            packet_info->SetSelfV4Ip(self_v4_ip);
+          }
+          else
+          {
+            QUIC_BUG(quic_bug_10751_2) << "QuicIpAddress::FromPackedString failed";
+          }
+        }
+        return;
       }
-    }
-    return;
-  }
 
-  if ((cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_TTL) ||
-      (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT)) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::TTL)) {
-      packet_info->SetTtl(*(reinterpret_cast<int*>(WSA_CMSG_DATA(cmsg))));
-    }
-    return;
-  }
+      if ((cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_TTL) ||
+          (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT))
+      {
+        if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::TTL))
+        {
+          packet_info->SetTtl(*(reinterpret_cast<int *>(WSA_CMSG_DATA(cmsg))));
+        }
+        return;
+      }
 
-  if (packet_info_interested.IsSet(
-          QuicUdpPacketInfoBit::GOOGLE_PACKET_HEADER)) {
-    BufferSpan google_packet_headers;
-    if (GetGooglePacketHeadersFromControlMessage(
-            cmsg, &google_packet_headers.buffer,
-            &google_packet_headers.buffer_len)) {
-      packet_info->SetGooglePacketHeaders(google_packet_headers);
+      if (packet_info_interested.IsSet(
+              QuicUdpPacketInfoBit::GOOGLE_PACKET_HEADER))
+      {
+        BufferSpan google_packet_headers;
+        if (GetGooglePacketHeadersFromControlMessage(
+                cmsg, &google_packet_headers.buffer,
+                &google_packet_headers.buffer_len))
+        {
+          packet_info->SetGooglePacketHeaders(google_packet_headers);
+        }
+      }
     }
-  }
-}
-
-bool NextCmsg(WSAMSG* hdr, char* control_buffer, size_t control_buffer_len,
-              int cmsg_level, int cmsg_type, size_t data_size,
-              cmsghdr** cmsg /*in, out*/) {
-  // msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
-  // return nullptr.
-  hdr->Control.len += CMSG_SPACE(data_size);
-  if (hdr->Control.len > control_buffer_len) {
-    return false;
-  }
-
-  if ((*cmsg) == nullptr) {
-    QUICHE_DCHECK_EQ(nullptr, hdr->Control.buf);
-    memset(control_buffer, 0, control_buffer_len);
-    hdr->Control.buf = control_buffer;
-    (*cmsg) = CMSG_FIRSTHDR(hdr);
-  } else {
-    QUICHE_DCHECK_NE(nullptr, hdr->Control.buf);
-    (*cmsg) = CMSG_NXTHDR(hdr, (*cmsg));
-  }
 
-  if (nullptr == (*cmsg)) {
-    return false;
-  }
+    bool NextCmsg(WSAMSG *hdr, char *control_buffer, size_t control_buffer_len,
+                  int cmsg_level, int cmsg_type, size_t data_size,
+                  cmsghdr **cmsg /*in, out*/)
+    {
+      // msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
+      // return nullptr.
+      hdr->Control.len += CMSG_SPACE(data_size);
+      if (hdr->Control.len > control_buffer_len)
+      {
+        return false;
+      }
 
-  (*cmsg)->cmsg_len = CMSG_LEN(data_size);
-  (*cmsg)->cmsg_level = cmsg_level;
-  (*cmsg)->cmsg_type = cmsg_type;
+      if ((*cmsg) == nullptr)
+      {
+        QUICHE_DCHECK_EQ(nullptr, hdr->Control.buf);
+        memset(control_buffer, 0, control_buffer_len);
+        hdr->Control.buf = control_buffer;
+        (*cmsg) = CMSG_FIRSTHDR(hdr);
+      }
+      else
+      {
+        QUICHE_DCHECK_NE(nullptr, hdr->Control.buf);
+        (*cmsg) = CMSG_NXTHDR(hdr, (*cmsg));
+      }
 
-  return true;
-}
-}  // namespace
+      if (nullptr == (*cmsg))
+      {
+        return false;
+      }
 
+      (*cmsg)->cmsg_len = CMSG_LEN(data_size);
+      (*cmsg)->cmsg_level = cmsg_level;
+      (*cmsg)->cmsg_type = cmsg_type;
 
-LPFN_WSARECVMSG WSARecvMsg = nullptr;
-LPFN_WSASENDMSG WSASendMsg = nullptr;
+      return true;
+    }
+  } // namespace
 
-WSADATA WSAData;
+  LPFN_WSARECVMSG WSARecvMsg = nullptr;
+  LPFN_WSASENDMSG WSASendMsg = nullptr;
 
-bool initSockets()
-{
-  int res;
+  WSADATA WSAData;
 
-  // Initialize Winsock
-  res = WSAStartup(MAKEWORD(2, 2), &WSAData);
-  if (res != 0)
+  bool initSockets()
   {
-    QUIC_LOG_FIRST_N(ERROR, 100)
-        << "WSAStartup failed: %d\n"
-        << res;
-    return false;
-  }
+    int res;
 
-  SOCKET sock = INVALID_SOCKET;
-  sock = socket(AF_INET, SOCK_DGRAM, 0);
+    // Initialize Winsock
+    res = WSAStartup(MAKEWORD(2, 2), &WSAData);
+    if (res != 0)
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "WSAStartup failed: %d\n"
+          << res;
+      return false;
+    }
 
-  // should we buffer this somewhere? Does it take time...
-  GUID grv = WSAID_WSARECVMSG;
-  DWORD dwBytesReturned = 0;
-  if (WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &grv, sizeof(grv), &WSARecvMsg, sizeof(WSARecvMsg),
-               &dwBytesReturned, NULL, NULL) != 0)
-  {
-    QUIC_LOG_FIRST_N(ERROR, 100)
-        << "WSARecvMsg is not available ";
-    return false;
-  }
+    SOCKET sock = INVALID_SOCKET;
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
 
-  // should we buffer this somewhere? Does it take time...
-  GUID gsnd = WSAID_WSASENDMSG;
-  if (WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &gsnd, sizeof(gsnd), &WSASendMsg, sizeof(WSASendMsg),
-               &dwBytesReturned, NULL, NULL) != 0)
-  {
-    QUIC_LOG_FIRST_N(ERROR, 100)
-        << "WSASendMsg is not available ";
-    return false;
-  }
-   closesocket(sock);
-   return true;
-}
+    // should we buffer this somewhere? Does it take time...
+    GUID grv = WSAID_WSARECVMSG;
+    DWORD dwBytesReturned = 0;
+    if (WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &grv, sizeof(grv), &WSARecvMsg, sizeof(WSARecvMsg),
+                 &dwBytesReturned, NULL, NULL) != 0)
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "WSARecvMsg is not available ";
+      return false;
+    }
 
-bool destroySockets()
-{
-  WSACleanup();
-  return true;
-}
-
-QuicUdpSocketFd QuicUdpSocketApi::Create(int address_family,
-                                         int receive_buffer_size,
-                                         int send_buffer_size, bool ipv6_only) {
-  // QUICHE_DCHECK here so the program exits early(before reading packets) in
-  // debug mode. This should have been a static_assert, however it can't be done
-  // on ios/osx because CMSG_SPACE isn't a constant expression there.
-  QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
-
-  absl::StatusOr<SocketFd> socket =
-      socket_api::CreateSocket(FromPlatformAddressFamily(address_family),
-                               socket_api::SocketProtocol::kUdp,
-                               /*blocking=*/false);
-
-  if (!socket.ok()) {
-    QUIC_LOG_FIRST_N(ERROR, 100)
-        << "UDP non-blocking socket creation for address_family="
-        << address_family << " failed: " << socket.status();
-    return kQuicInvalidSocketFd;
+    // should we buffer this somewhere? Does it take time...
+    GUID gsnd = WSAID_WSASENDMSG;
+    if (WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &gsnd, sizeof(gsnd), &WSASendMsg, sizeof(WSASendMsg),
+                 &dwBytesReturned, NULL, NULL) != 0)
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "WSASendMsg is not available ";
+      return false;
+    }
+    closesocket(sock);
+    return true;
   }
 
-  SetGoogleSocketOptions(socket.value());
-
-  if (!SetupSocket(socket.value(), address_family, receive_buffer_size,
-                   send_buffer_size, ipv6_only)) {
-    Destroy(socket.value());
-    return kQuicInvalidSocketFd;
+  bool destroySockets()
+  {
+    WSACleanup();
+    return true;
   }
 
-  return socket.value();
-}
+  QuicUdpSocketFd QuicUdpSocketApi::Create(int address_family,
+                                           int receive_buffer_size,
+                                           int send_buffer_size, bool ipv6_only)
+  {
+    // QUICHE_DCHECK here so the program exits early(before reading packets) in
+    // debug mode. This should have been a static_assert, however it can't be done
+    // on ios/osx because CMSG_SPACE isn't a constant expression there.
+    QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
+
+    absl::StatusOr<SocketFd> socket =
+        socket_api::CreateSocket(quiche::FromPlatformAddressFamily(address_family),
+                                 socket_api::SocketProtocol::kUdp,
+                                 /*blocking=*/false);
+
+    if (!socket.ok())
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "UDP non-blocking socket creation for address_family="
+          << address_family << " failed: " << socket.status();
+      return kQuicInvalidSocketFd;
+    }
 
-bool QuicUdpSocketApi::SetupSocket(QuicUdpSocketFd fd, int address_family,
-                                   int receive_buffer_size,
-                                   int send_buffer_size, bool ipv6_only) {
-  // Receive buffer size.
-  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<const char*>(&receive_buffer_size),
-                 sizeof(receive_buffer_size)) != 0) {
-    QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket recv size";
-    return false;
-  }
+    SetGoogleSocketOptions(socket.value());
 
-  // Send buffer size.
-  if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char*>(&send_buffer_size),
-                 sizeof(send_buffer_size)) != 0) {
-    QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket send size";
-    return false;
+    if (!SetupSocket(socket.value(), address_family, receive_buffer_size,
+                     send_buffer_size, ipv6_only))
+    {
+      Destroy(socket.value());
+      return kQuicInvalidSocketFd;
+    }
+
+    return socket.value();
   }
 
-  if (!(address_family == AF_INET6 && ipv6_only)) {
-    if (!EnableReceiveSelfIpAddressForV4(fd)) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Failed to enable receiving of self v4 ip";
+  bool QuicUdpSocketApi::SetupSocket(QuicUdpSocketFd fd, int address_family,
+                                     int receive_buffer_size,
+                                     int send_buffer_size, bool ipv6_only)
+  {
+    // Receive buffer size.
+    if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<const char *>(&receive_buffer_size),
+                   sizeof(receive_buffer_size)) != 0)
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket recv size";
       return false;
     }
-  }
 
-  if (address_family == AF_INET6) {
-    if (!EnableReceiveSelfIpAddressForV6(fd)) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Failed to enable receiving of self v6 ip";
+    // Send buffer size.
+    if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&send_buffer_size),
+                   sizeof(send_buffer_size)) != 0)
+    {
+      QUIC_LOG_FIRST_N(ERROR, 100) << "Failed to set socket send size";
       return false;
     }
-  }
 
-  return true;
-}
+    if (!(address_family == AF_INET6 && ipv6_only))
+    {
+      if (!EnableReceiveSelfIpAddressForV4(fd))
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Failed to enable receiving of self v4 ip";
+        return false;
+      }
+    }
 
-void QuicUdpSocketApi::Destroy(QuicUdpSocketFd fd) {
-  if (fd != kQuicInvalidSocketFd) {
-    absl::Status result = socket_api::Close(fd);
-    if (!result.ok()) {
-      QUIC_LOG_FIRST_N(WARNING, 100)
-          << "Failed to close UDP socket with error " << result;
+    if (address_family == AF_INET6)
+    {
+      if (!EnableReceiveSelfIpAddressForV6(fd))
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Failed to enable receiving of self v6 ip";
+        return false;
+      }
     }
+
+    return true;
   }
-}
 
-bool QuicUdpSocketApi::Bind(QuicUdpSocketFd fd, QuicSocketAddress address) {
-  sockaddr_storage addr = address.generic_address();
-  int addr_len =
-      address.host().IsIPv4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
-  return 0 == bind(fd, reinterpret_cast<sockaddr*>(&addr), addr_len);
-}
+  void QuicUdpSocketApi::Destroy(QuicUdpSocketFd fd)
+  {
+    if (fd != kQuicInvalidSocketFd)
+    {
+      absl::Status result = socket_api::Close(fd);
+      if (!result.ok())
+      {
+        QUIC_LOG_FIRST_N(WARNING, 100)
+            << "Failed to close UDP socket with error " << result;
+      }
+    }
+  }
+
+  bool QuicUdpSocketApi::Bind(QuicUdpSocketFd fd, QuicSocketAddress address)
+  {
+    sockaddr_storage addr = address.generic_address();
+    int addr_len =
+        address.host().IsIPv4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
+    return 0 == bind(fd, reinterpret_cast<sockaddr *>(&addr), addr_len);
+  }
 
-bool QuicUdpSocketApi::EnableDroppedPacketCount(QuicUdpSocketFd fd) {
+  bool QuicUdpSocketApi::EnableDroppedPacketCount(QuicUdpSocketFd fd)
+  {
 #if defined(__linux__) && defined(SO_RXQ_OVFL)
-  int get_overflow = 1;
-  return 0 == setsockopt(fd, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
-                         sizeof(get_overflow));
+    int get_overflow = 1;
+    return 0 == setsockopt(fd, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
+                           sizeof(get_overflow));
 #else
-  (void)fd;
-  return false;
+    (void)fd;
+    return false;
 #endif
-}
-
-bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV4(QuicUdpSocketFd fd) {
-  int get_self_ip = 1;
-  return 0 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO, reinterpret_cast<const char*>(&get_self_ip),
-                         sizeof(get_self_ip));
-}
-
-bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV6(QuicUdpSocketFd fd) {
-  int get_self_ip = 1;
-  // was IPV6_RECVPKTINFO
-  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, reinterpret_cast<const char*>(&get_self_ip),
-                         sizeof(get_self_ip));
-}
-
-bool QuicUdpSocketApi::EnableReceiveTimestamp(QuicUdpSocketFd fd) {
+  }
+
+  bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV4(QuicUdpSocketFd fd)
+  {
+    int get_self_ip = 1;
+    return 0 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO, reinterpret_cast<const char *>(&get_self_ip),
+                           sizeof(get_self_ip));
+  }
+
+  bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV6(QuicUdpSocketFd fd)
+  {
+    int get_self_ip = 1;
+    // was IPV6_RECVPKTINFO
+    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_PKTINFO, reinterpret_cast<const char *>(&get_self_ip),
+                           sizeof(get_self_ip));
+  }
+
+  bool QuicUdpSocketApi::EnableReceiveTimestamp(QuicUdpSocketFd fd)
+  {
 #if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
-  int timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE;
-  return 0 == setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &timestamping,
-                         sizeof(timestamping));
+    int timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE;
+    return 0 == setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &timestamping,
+                           sizeof(timestamping));
 #else
-  (void)fd;
-  return false;
+    (void)fd;
+    return false;
 #endif
-}
+  }
 
-bool QuicUdpSocketApi::EnableReceiveTtlForV4(QuicUdpSocketFd fd) {
+  bool QuicUdpSocketApi::EnableReceiveTtlForV4(QuicUdpSocketFd fd)
+  {
 #if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
-  int get_ttl = 1;
-  return 0 == setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &get_ttl, sizeof(get_ttl));
+    int get_ttl = 1;
+    return 0 == setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &get_ttl, sizeof(get_ttl));
 #else
-  (void)fd;
-  return false;
+    (void)fd;
+    return false;
 #endif
-}
+  }
 
-bool QuicUdpSocketApi::EnableReceiveTtlForV6(QuicUdpSocketFd fd) {
+  bool QuicUdpSocketApi::EnableReceiveTtlForV6(QuicUdpSocketFd fd)
+  {
 #if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
-  int get_ttl = 1;
-  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &get_ttl,
-                         sizeof(get_ttl));
+    int get_ttl = 1;
+    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &get_ttl,
+                           sizeof(get_ttl));
 #else
-  (void)fd;
-  return false;
+    (void)fd;
+    return false;
 #endif
-}
-
-bool QuicUdpSocketApi::WaitUntilReadable(QuicUdpSocketFd fd,
-                                         QuicTime::Delta timeout) {
-  fd_set read_fds;
-  FD_ZERO(&read_fds);
-  FD_SET(fd, &read_fds);
-
-  timeval select_timeout;
-  select_timeout.tv_sec = timeout.ToSeconds();
-  select_timeout.tv_usec = timeout.ToMicroseconds() % 1000000;
-
-  return 1 == select(1 + fd, &read_fds, nullptr, nullptr, &select_timeout);
-}
-
-void QuicUdpSocketApi::ReadPacket(QuicUdpSocketFd fd,
-                                  BitMask64 packet_info_interested,
-                                  ReadPacketResult* result) {
-  result->ok = false;
-  BufferSpan& packet_buffer = result->packet_buffer;
-  BufferSpan& control_buffer = result->control_buffer;
-  QuicUdpPacketInfo* packet_info = &result->packet_info;
-
-  QUICHE_DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
-
-  ULONG bufferlen = packet_buffer.buffer_len;
-  WSABUF iov = { bufferlen, const_cast<char*>(packet_buffer.buffer)};
-  struct sockaddr_storage raw_peer_address;
-
-  if (control_buffer.buffer_len > 0) {
-    reinterpret_cast<struct cmsghdr*>(control_buffer.buffer)->cmsg_len =
-        control_buffer.buffer_len;
   }
 
-  WSAMSG hdr;
-  hdr.name = reinterpret_cast<LPSOCKADDR> (&raw_peer_address);
-  hdr.namelen = sizeof(raw_peer_address);
-  hdr.lpBuffers = &iov;
-  hdr.dwBufferCount = 1;
-  hdr.dwFlags = 0;
-  hdr.Control.buf = control_buffer.buffer;
-  hdr.Control.len = control_buffer.buffer_len;
-
-
+  bool QuicUdpSocketApi::WaitUntilReadable(QuicUdpSocketFd fd,
+                                           QuicTime::Delta timeout)
+  {
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(fd, &read_fds);
 
-  DWORD bytes_read = 0;
+    timeval select_timeout;
+    select_timeout.tv_sec = timeout.ToSeconds();
+    select_timeout.tv_usec = timeout.ToMicroseconds() % 1000000;
 
-  int ret = WSARecvMsg(fd, &hdr, &bytes_read, nullptr, nullptr);
-  if (ret == SOCKET_ERROR) {
-    const int error_num = WSAGetLastError();
-    if (error_num != WSAEWOULDBLOCK) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Error reading packet: " << error_num;
-    }
-    return;
+    return 1 == select(1 + fd, &read_fds, nullptr, nullptr, &select_timeout);
   }
 
-  if (ABSL_PREDICT_FALSE(hdr.dwFlags & MSG_CTRUNC)) {
-    QUIC_BUG(quic_bug_10751_3)
-        << "Control buffer too small. size:" << control_buffer.buffer_len;
-    return;
-  }
+  void QuicUdpSocketApi::ReadPacket(QuicUdpSocketFd fd,
+                                    BitMask64 packet_info_interested,
+                                    ReadPacketResult *result)
+  {
+    result->ok = false;
+    BufferSpan &packet_buffer = result->packet_buffer;
+    BufferSpan &control_buffer = result->control_buffer;
+    QuicUdpPacketInfo *packet_info = &result->packet_info;
 
-  if (ABSL_PREDICT_FALSE(hdr.dwFlags & MSG_TRUNC) ||
-      // Normally "bytes_read > packet_buffer.buffer_len" implies the MSG_TRUNC
-      // bit is set, but it is not the case if tested with config=android_arm64.
-      static_cast<size_t>(bytes_read) > packet_buffer.buffer_len) {
-    QUIC_LOG_FIRST_N(WARNING, 100)
-        << "Received truncated QUIC packet: buffer size:"
-        << packet_buffer.buffer_len << " packet size:" << bytes_read;
-    return;
-  }
+    QUICHE_DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
 
-  packet_buffer.buffer_len = bytes_read;
-  if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
-    packet_info->SetPeerAddress(QuicSocketAddress(raw_peer_address));
-  }
+    ULONG bufferlen = packet_buffer.buffer_len;
+    WSABUF iov = {bufferlen, const_cast<char *>(packet_buffer.buffer)};
+    struct sockaddr_storage raw_peer_address;
 
-  if (hdr.Control.len > 0) {
-    for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
-         cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
-      BitMask64 prior_bitmask = packet_info->bitmask();
-      PopulatePacketInfoFromControlMessage(cmsg, packet_info,
-                                           packet_info_interested);
-      if (packet_info->bitmask() == prior_bitmask) {
-        QUIC_DLOG(INFO) << "Ignored cmsg_level:" << cmsg->cmsg_level
-                        << ", cmsg_type:" << cmsg->cmsg_type;
-      }
+    if (control_buffer.buffer_len > 0)
+    {
+      reinterpret_cast<struct cmsghdr *>(control_buffer.buffer)->cmsg_len =
+          control_buffer.buffer_len;
     }
-  }
-
-  result->ok = true;
-}
 
-size_t QuicUdpSocketApi::ReadMultiplePackets(QuicUdpSocketFd fd,
-                                             BitMask64 packet_info_interested,
-                                             ReadPacketResults* results) {
- // Potential TODO WinSock supports similar stuff                                             
-#if defined(__linux__) && !defined(__ANDROID__)
-  // Use recvmmsg.
-  size_t hdrs_size = sizeof(mmsghdr) * results->size();
-  mmsghdr* hdrs = static_cast<mmsghdr*>(alloca(hdrs_size));
-  memset(hdrs, 0, hdrs_size);
-
-  struct TempPerPacketData {
-    iovec iov;
-    sockaddr_storage raw_peer_address;
-  };
-  TempPerPacketData* packet_data_array = static_cast<TempPerPacketData*>(
-      alloca(sizeof(TempPerPacketData) * results->size()));
-
-  for (size_t i = 0; i < results->size(); ++i) {
-    (*results)[i].ok = false;
-
-    msghdr* hdr = &hdrs[i].msg_hdr;
-    TempPerPacketData* packet_data = &packet_data_array[i];
-    packet_data->iov.iov_base = (*results)[i].packet_buffer.buffer;
-    packet_data->iov.iov_len = (*results)[i].packet_buffer.buffer_len;
-
-    hdr->msg_name = &packet_data->raw_peer_address;
-    hdr->msg_namelen = sizeof(sockaddr_storage);
-    hdr->msg_iov = &packet_data->iov;
-    hdr->msg_iovlen = 1;
-    hdr->msg_flags = 0;
-    hdr->msg_control = (*results)[i].control_buffer.buffer;
-    hdr->msg_controllen = (*results)[i].control_buffer.buffer_len;
-
-    QUICHE_DCHECK_GE(hdr->msg_controllen, kMinCmsgSpaceForRead);
-  }
-  // If MSG_TRUNC is set on Linux, recvmmsg will return the real packet size in
-  // |hdrs[i].msg_len| even if packet buffer is too small to receive it.
-  int packets_read = recvmmsg(fd, hdrs, results->size(), MSG_TRUNC, nullptr);
-  if (packets_read <= 0) {
-    const int error_num = errno;
-    if (error_num != EAGAIN) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Error reading packets: " << strerror(error_num);
-    }
-    return 0;
-  }
-
-  for (int i = 0; i < packets_read; ++i) {
-    if (hdrs[i].msg_len == 0) {
-      continue;
+    WSAMSG hdr;
+    hdr.name = reinterpret_cast<LPSOCKADDR>(&raw_peer_address);
+    hdr.namelen = sizeof(raw_peer_address);
+    hdr.lpBuffers = &iov;
+    hdr.dwBufferCount = 1;
+    hdr.dwFlags = 0;
+    hdr.Control.buf = control_buffer.buffer;
+    hdr.Control.len = control_buffer.buffer_len;
+
+    DWORD bytes_read = 0;
+
+    int ret = WSARecvMsg(fd, &hdr, &bytes_read, nullptr, nullptr);
+    if (ret == SOCKET_ERROR)
+    {
+      const int error_num = WSAGetLastError();
+      if (error_num != WSAEWOULDBLOCK)
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Error reading packet: " << error_num;
+      }
+      return;
     }
 
-    msghdr& hdr = hdrs[i].msg_hdr;
-    if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_CTRUNC)) {
-      QUIC_BUG(quic_bug_10751_4) << "Control buffer too small. size:"
-                                 << (*results)[i].control_buffer.buffer_len
-                                 << ", need:" << hdr.msg_controllen;
-      continue;
+    if (ABSL_PREDICT_FALSE(hdr.dwFlags & MSG_CTRUNC))
+    {
+      QUIC_BUG(quic_bug_10751_3)
+          << "Control buffer too small. size:" << control_buffer.buffer_len;
+      return;
     }
 
-    if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_TRUNC)) {
+    if (ABSL_PREDICT_FALSE(hdr.dwFlags & MSG_TRUNC) ||
+        // Normally "bytes_read > packet_buffer.buffer_len" implies the MSG_TRUNC
+        // bit is set, but it is not the case if tested with config=android_arm64.
+        static_cast<size_t>(bytes_read) > packet_buffer.buffer_len)
+    {
       QUIC_LOG_FIRST_N(WARNING, 100)
           << "Received truncated QUIC packet: buffer size:"
-          << (*results)[i].packet_buffer.buffer_len
-          << " packet size:" << hdrs[i].msg_len;
-      continue;
+          << packet_buffer.buffer_len << " packet size:" << bytes_read;
+      return;
     }
 
-    (*results)[i].ok = true;
-    (*results)[i].packet_buffer.buffer_len = hdrs[i].msg_len;
-
-    QuicUdpPacketInfo* packet_info = &(*results)[i].packet_info;
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
-      packet_info->SetPeerAddress(
-          QuicSocketAddress(packet_data_array[i].raw_peer_address));
+    packet_buffer.buffer_len = bytes_read;
+    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS))
+    {
+      packet_info->SetPeerAddress(QuicSocketAddress(raw_peer_address));
     }
 
-    if (hdr.msg_controllen > 0) {
-      for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
-           cmsg = CMSG_NXTHDR(&hdr, cmsg)) {
+    if (hdr.Control.len > 0)
+    {
+      for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
+           cmsg = CMSG_NXTHDR(&hdr, cmsg))
+      {
+        BitMask64 prior_bitmask = packet_info->bitmask();
         PopulatePacketInfoFromControlMessage(cmsg, packet_info,
                                              packet_info_interested);
+        if (packet_info->bitmask() == prior_bitmask)
+        {
+          QUIC_DLOG(INFO) << "Ignored cmsg_level:" << cmsg->cmsg_level
+                          << ", cmsg_type:" << cmsg->cmsg_type;
+        }
       }
     }
+
+    result->ok = true;
   }
-  return packets_read;
+
+  size_t QuicUdpSocketApi::ReadMultiplePackets(QuicUdpSocketFd fd,
+                                               BitMask64 packet_info_interested,
+                                               ReadPacketResults *results)
+  {
+    // Potential TODO WinSock supports similar stuff
+#if defined(__linux__) && !defined(__ANDROID__)
+    // Use recvmmsg.
+    size_t hdrs_size = sizeof(mmsghdr) * results->size();
+    mmsghdr *hdrs = static_cast<mmsghdr *>(alloca(hdrs_size));
+    memset(hdrs, 0, hdrs_size);
+
+    struct TempPerPacketData
+    {
+      iovec iov;
+      sockaddr_storage raw_peer_address;
+    };
+    TempPerPacketData *packet_data_array = static_cast<TempPerPacketData *>(
+        alloca(sizeof(TempPerPacketData) * results->size()));
+
+    for (size_t i = 0; i < results->size(); ++i)
+    {
+      (*results)[i].ok = false;
+
+      msghdr *hdr = &hdrs[i].msg_hdr;
+      TempPerPacketData *packet_data = &packet_data_array[i];
+      packet_data->iov.iov_base = (*results)[i].packet_buffer.buffer;
+      packet_data->iov.iov_len = (*results)[i].packet_buffer.buffer_len;
+
+      hdr->msg_name = &packet_data->raw_peer_address;
+      hdr->msg_namelen = sizeof(sockaddr_storage);
+      hdr->msg_iov = &packet_data->iov;
+      hdr->msg_iovlen = 1;
+      hdr->msg_flags = 0;
+      hdr->msg_control = (*results)[i].control_buffer.buffer;
+      hdr->msg_controllen = (*results)[i].control_buffer.buffer_len;
+
+      QUICHE_DCHECK_GE(hdr->msg_controllen, kMinCmsgSpaceForRead);
+    }
+    // If MSG_TRUNC is set on Linux, recvmmsg will return the real packet size in
+    // |hdrs[i].msg_len| even if packet buffer is too small to receive it.
+    int packets_read = recvmmsg(fd, hdrs, results->size(), MSG_TRUNC, nullptr);
+    if (packets_read <= 0)
+    {
+      const int error_num = errno;
+      if (error_num != EAGAIN)
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Error reading packets: " << strerror(error_num);
+      }
+      return 0;
+    }
+
+    for (int i = 0; i < packets_read; ++i)
+    {
+      if (hdrs[i].msg_len == 0)
+      {
+        continue;
+      }
+
+      msghdr &hdr = hdrs[i].msg_hdr;
+      if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_CTRUNC))
+      {
+        QUIC_BUG(quic_bug_10751_4) << "Control buffer too small. size:"
+                                   << (*results)[i].control_buffer.buffer_len
+                                   << ", need:" << hdr.msg_controllen;
+        continue;
+      }
+
+      if (ABSL_PREDICT_FALSE(hdr.msg_flags & MSG_TRUNC))
+      {
+        QUIC_LOG_FIRST_N(WARNING, 100)
+            << "Received truncated QUIC packet: buffer size:"
+            << (*results)[i].packet_buffer.buffer_len
+            << " packet size:" << hdrs[i].msg_len;
+        continue;
+      }
+
+      (*results)[i].ok = true;
+      (*results)[i].packet_buffer.buffer_len = hdrs[i].msg_len;
+
+      QuicUdpPacketInfo *packet_info = &(*results)[i].packet_info;
+      if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS))
+      {
+        packet_info->SetPeerAddress(
+            QuicSocketAddress(packet_data_array[i].raw_peer_address));
+      }
+
+      if (hdr.msg_controllen > 0)
+      {
+        for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
+             cmsg = CMSG_NXTHDR(&hdr, cmsg))
+        {
+          PopulatePacketInfoFromControlMessage(cmsg, packet_info,
+                                               packet_info_interested);
+        }
+      }
+    }
+    return packets_read;
 #else
-  size_t num_packets = 0;
-  for (ReadPacketResult& result : *results) {
-    result.ok = false;
-  }
-  for (ReadPacketResult& result : *results) {
-    ReadPacket(fd, packet_info_interested, &result);
-    if (!result.ok && WSAGetLastError() == WSAEWOULDBLOCK) {
-      break;
+    size_t num_packets = 0;
+    for (ReadPacketResult &result : *results)
+    {
+      result.ok = false;
     }
-    ++num_packets;
-  }
-  return num_packets;
+    for (ReadPacketResult &result : *results)
+    {
+      ReadPacket(fd, packet_info_interested, &result);
+      if (!result.ok && WSAGetLastError() == WSAEWOULDBLOCK)
+      {
+        break;
+      }
+      ++num_packets;
+    }
+    return num_packets;
 #endif
-}
-
-WriteResult QuicUdpSocketApi::WritePacket(
-    QuicUdpSocketFd fd, const char* packet_buffer, size_t packet_buffer_len,
-    const QuicUdpPacketInfo& packet_info) {
-  if (!packet_info.HasValue(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
-    return WriteResult(WRITE_STATUS_ERROR, EINVAL);
   }
 
-  char control_buffer[512];
-  sockaddr_storage raw_peer_address =
-      packet_info.peer_address().generic_address();
-  ULONG bufferlen = packet_buffer_len;
-  WSABUF iov = {bufferlen, const_cast<char*>(packet_buffer)};
-
-  WSAMSG hdr;
-  hdr.name = reinterpret_cast<LPSOCKADDR> (&raw_peer_address);
-  hdr.namelen = packet_info.peer_address().host().IsIPv4()
-                        ? sizeof(sockaddr_in)
-                        : sizeof(sockaddr_in6);
-  hdr.lpBuffers = &iov;
-  hdr.dwBufferCount = 1;
-  hdr.dwFlags = 0;
-  hdr.Control.buf = nullptr;
-  hdr.Control.len = 0;
-
-
-  cmsghdr* cmsg = nullptr;
-
-  // Set self IP.
-  if (packet_info.HasValue(QuicUdpPacketInfoBit::V4_SELF_IP) &&
-      packet_info.self_v4_ip().IsInitialized()) {
-    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IP,
-                  IP_PKTINFO, sizeof(in_pktinfo), &cmsg)) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Not enough buffer to set self v4 ip address.";
+  WriteResult QuicUdpSocketApi::WritePacket(
+      QuicUdpSocketFd fd, const char *packet_buffer, size_t packet_buffer_len,
+      const QuicUdpPacketInfo &packet_info)
+  {
+    if (!packet_info.HasValue(QuicUdpPacketInfoBit::PEER_ADDRESS))
+    {
       return WriteResult(WRITE_STATUS_ERROR, EINVAL);
     }
-    SetV4SelfIpInControlMessage(packet_info.self_v4_ip(), cmsg);
-  } else if (packet_info.HasValue(QuicUdpPacketInfoBit::V6_SELF_IP) &&
-             packet_info.self_v6_ip().IsInitialized()) {
-    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IPV6,
-                  IPV6_PKTINFO, sizeof(in6_pktinfo), &cmsg)) {
-      QUIC_LOG_FIRST_N(ERROR, 100)
-          << "Not enough buffer to set self v6 ip address.";
-      return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+
+    char control_buffer[512];
+    sockaddr_storage raw_peer_address =
+        packet_info.peer_address().generic_address();
+    ULONG bufferlen = packet_buffer_len;
+    WSABUF iov = {bufferlen, const_cast<char *>(packet_buffer)};
+
+    WSAMSG hdr;
+    hdr.name = reinterpret_cast<LPSOCKADDR>(&raw_peer_address);
+    hdr.namelen = packet_info.peer_address().host().IsIPv4()
+                      ? sizeof(sockaddr_in)
+                      : sizeof(sockaddr_in6);
+    hdr.lpBuffers = &iov;
+    hdr.dwBufferCount = 1;
+    hdr.dwFlags = 0;
+    hdr.Control.buf = nullptr;
+    hdr.Control.len = 0;
+
+    cmsghdr *cmsg = nullptr;
+
+    // Set self IP.
+    if (packet_info.HasValue(QuicUdpPacketInfoBit::V4_SELF_IP) &&
+        packet_info.self_v4_ip().IsInitialized())
+    {
+      if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IP,
+                    IP_PKTINFO, sizeof(in_pktinfo), &cmsg))
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Not enough buffer to set self v4 ip address.";
+        return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+      }
+      SetV4SelfIpInControlMessage(packet_info.self_v4_ip(), cmsg);
+    }
+    else if (packet_info.HasValue(QuicUdpPacketInfoBit::V6_SELF_IP) &&
+             packet_info.self_v6_ip().IsInitialized())
+    {
+      if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IPV6,
+                    IPV6_PKTINFO, sizeof(in6_pktinfo), &cmsg))
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100)
+            << "Not enough buffer to set self v6 ip address.";
+        return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+      }
+      SetV6SelfIpInControlMessage(packet_info.self_v6_ip(), cmsg);
     }
-    SetV6SelfIpInControlMessage(packet_info.self_v6_ip(), cmsg);
-  }
 
 #if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
-  // Set ttl.
-  if (packet_info.HasValue(QuicUdpPacketInfoBit::TTL)) {
-    int cmsg_level =
-        packet_info.peer_address().host().IsIPv4() ? IPPROTO_IP : IPPROTO_IPV6;
-    int cmsg_type =
-        packet_info.peer_address().host().IsIPv4() ? IP_TTL : IPV6_HOPLIMIT;
-    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), cmsg_level,
-                  cmsg_type, sizeof(int), &cmsg)) {
-      QUIC_LOG_FIRST_N(ERROR, 100) << "Not enough buffer to set ttl.";
-      return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+    // Set ttl.
+    if (packet_info.HasValue(QuicUdpPacketInfoBit::TTL))
+    {
+      int cmsg_level =
+          packet_info.peer_address().host().IsIPv4() ? IPPROTO_IP : IPPROTO_IPV6;
+      int cmsg_type =
+          packet_info.peer_address().host().IsIPv4() ? IP_TTL : IPV6_HOPLIMIT;
+      if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), cmsg_level,
+                    cmsg_type, sizeof(int), &cmsg))
+      {
+        QUIC_LOG_FIRST_N(ERROR, 100) << "Not enough buffer to set ttl.";
+        return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+      }
+      *reinterpret_cast<int *>(WSA_CMSG_DATA(cmsg)) = packet_info.ttl();
     }
-    *reinterpret_cast<int*>(WSA_CMSG_DATA(cmsg)) = packet_info.ttl();
-  }
 #endif
 
-
-  int rc;
-  DWORD bytessend;
-  do {
-    rc = WSASendMsg(fd, &hdr, 0, &bytessend, nullptr, nullptr);
-  } while (rc == SOCKET_ERROR &&  WSAGetLastError() == WSAEINTR); 
-  if (bytessend >= 0) {
-    return WriteResult(WRITE_STATUS_OK, bytessend);
+    int rc;
+    DWORD bytessend;
+    do
+    {
+      rc = WSASendMsg(fd, &hdr, 0, &bytessend, nullptr, nullptr);
+    } while (rc == SOCKET_ERROR && WSAGetLastError() == WSAEINTR);
+    if (bytessend >= 0)
+    {
+      return WriteResult(WRITE_STATUS_OK, bytessend);
+    }
+    int error = WSAGetLastError();
+    return WriteResult((error == WSAEWOULDBLOCK)
+                           ? WRITE_STATUS_BLOCKED
+                           : WRITE_STATUS_ERROR,
+                       error);
   }
-  int error = WSAGetLastError();
-  return WriteResult(( error == WSAEWOULDBLOCK )
-                         ? WRITE_STATUS_BLOCKED
-                         : WRITE_STATUS_ERROR,
-                     error);
-}
-
-}  // namespace quic
+
+} // namespace quic