Reimplements net::AddressList without struct addrinfo.

net/udp/udp_socket_win.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/udp/udp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 75 matching lines @@
   closesocket(socket_);
   socket_ = INVALID_SOCKET;
 }
 
 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
+  // TODO(szym): Simplify. http://crbug.com/126152
   if (!remote_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    int addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getpeername(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getpeername(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     remote_address_.reset(address.release());
   }
 
   *address = *remote_address_;
   return OK;
 }
 
 int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
+  // TODO(szym): Simplify. http://crbug.com/126152
   if (!local_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    socklen_t addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getsockname(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getsockname(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     local_address_.reset(address.release());
   }
 
   *address = *local_address_;
   return OK;
 }
 
 int UDPSocketWin::Read(IOBuffer* buf,
                        int buf_len,
@@ skipping 74 matching lines @@
   if (rv < 0)
     return rv;
 
   if (bind_type_ == DatagramSocket::RANDOM_BIND)
     rv = RandomBind(address);
   // else connect() does the DatagramSocket::DEFAULT_BIND
 
   if (rv < 0)
     return rv;
 
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_FAILED;
 
-  rv = connect(socket_, addr, addr_len);
+  rv = connect(socket_, storage.addr, storage.addr_len);
   if (rv < 0)
     return MapSystemError(WSAGetLastError());
 
   remote_address_.reset(new IPEndPoint(address));
   return rv;
 }
 
 int UDPSocketWin::Bind(const IPEndPoint& address) {
   DCHECK(!is_connected());
   int rv = CreateSocket(address);
@@ skipping 156 matching lines @@
       LogRead(result, NULL);
       return result;
     }
   }
   read_watcher_.StartWatching(read_overlapped_.hEvent, &read_delegate_);
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
                                  const IPEndPoint* address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-
+  SockaddrStorage storage;
+  struct sockaddr* addr = storage.addr;
   // Convert address.
   if (!address) {
     addr = NULL;

[eroman, 2012/05/04 01:08:41]

IMPORTANT: This translations scares me since there is drift between |addr| and
|storate.addr|, which is just an invitation for problems :) Either make |addr|
be a reference, or replace all occurrences of |addr| --> |storage.addr|.

[szym, 2012/05/04 02:38:29]

This is the only exception to using storage.addr. I need to check if passing
non-NULL sockaddr with 0-length to WSASendTo will behave as passing NULL would.
If it does, I'll go back to storage.addr.

-    addr_len = 0;
+    storage.addr_len = 0;
   } else {
-    if (!address->ToSockAddr(addr, &addr_len)) {
+    if (!address->ToSockAddr(storage.addr, &storage.addr_len)) {
       int result = ERR_FAILED;
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
   WSABUF write_buffer;
   write_buffer.buf = buf->data();
   write_buffer.len = buf_len;
 
   DWORD flags = 0;
   DWORD num;
   AssertEventNotSignaled(write_overlapped_.hEvent);
   int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags,
-                     addr, addr_len, &write_overlapped_, NULL);
+                     addr, storage.addr_len, &write_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(write_overlapped_.hEvent)) {
       int result = num;
       LogWrite(result, buf->data(), address);
       return result;
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING) {
       int result = MapSystemError(os_error);
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
   write_watcher_.StartWatching(write_overlapped_.hEvent, &write_delegate_);
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::DoBind(const IPEndPoint& address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_UNEXPECTED;
-  int rv = bind(socket_, addr, addr_len);
+  int rv = bind(socket_, storage.addr, storage.addr_len);
   return rv < 0 ? MapSystemError(WSAGetLastError()) : rv;
 }
 
 int UDPSocketWin::RandomBind(const IPEndPoint& address) {
   DCHECK(bind_type_ == DatagramSocket::RANDOM_BIND && !rand_int_cb_.is_null());
 
   // Construct IPAddressNumber of appropriate size (IPv4 or IPv6) of 0s.
   IPAddressNumber ip(address.address().size());
 
   for (int i = 0; i < kBindRetries; ++i) {
     int rv = DoBind(IPEndPoint(ip, rand_int_cb_.Run(kPortStart, kPortEnd)));
     if (rv == OK || rv != ERR_ADDRESS_IN_USE)
       return rv;
   }
   return DoBind(IPEndPoint(ip, 0));
 }
 
 bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
   const struct sockaddr* addr =
       reinterpret_cast<const struct sockaddr*>(&recv_addr_storage_);
   return address->FromSockAddr(addr, recv_addr_len_);
 }
 
 }  // namespace net