UDP sockets implementation for windows.

net/udp/udp_socket_win.cc

Index: net/udp/udp_socket_win.cc
diff --git a/net/udp/udp_socket_win.cc b/net/udp/udp_socket_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ee4b8d001deda633a55a771cc24a0e546c8a4458
--- /dev/null
+++ b/net/udp/udp_socket_win.cc
@@ -0,0 +1,452 @@
+// Copyright (c) 2011 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"
+#include "base/memory_debug.h"
+#include "base/metrics/stats_counters.h"
+#include "net/base/io_buffer.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_log.h"
+#include "net/base/net_util.h"
+#include "net/base/winsock_init.h"
+
+namespace net {
+
+namespace {
+
+// Assert that the (manual-reset) event object is not signaled.
+void AssertEventNotSignaled(WSAEVENT hEvent) {

[Mike Belshe, 2011/03/10 06:53:38]

Since this code (AssertEventNotSignaled and ResaetEventIfSignaled) are
duplicated in the tcp_client_socket_win and here, should we move to net_util?

[Sergey Ulanov, 2011/03/11 00:54:37]

Moved it all to net/base/winsock_util.cc .

+  DWORD wait_rv = WaitForSingleObject(hEvent, 0);
+  if (wait_rv != WAIT_TIMEOUT) {
+    DWORD err = ERROR_SUCCESS;
+    if (wait_rv == WAIT_FAILED)
+      err = GetLastError();
+    CHECK(false);  // Crash.
+    // This LOG statement is unreachable since we have already crashed, but it
+    // should prevent the compiler from optimizing away the |wait_rv| and
+    // |err| variables so they appear nicely on the stack in crash dumps.
+    VLOG(1) << "wait_rv=" << wait_rv << ", err=" << err;
+  }
+}
+
+// If the (manual-reset) event object is signaled, resets it and returns true.
+// Otherwise, does nothing and returns false.  Called after a Winsock function
+// succeeds synchronously
+//
+// Our testing shows that except in rare cases (when running inside QEMU),
+// the event object is already signaled at this point, so we call this method
+// to avoid a context switch in common cases.  This is just a performance
+// optimization.  The code still works if this function simply returns false.
+bool ResetEventIfSignaled(WSAEVENT hEvent) {
+  // TODO(wtc): Remove the CHECKs after enough testing.
+  DWORD wait_rv = WaitForSingleObject(hEvent, 0);
+  if (wait_rv == WAIT_TIMEOUT)
+    return false;  // The event object is not signaled.
+  CHECK_EQ(WAIT_OBJECT_0, wait_rv);
+  BOOL ok = WSAResetEvent(hEvent);
+  CHECK(ok);
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+
+int MapWinsockError(int os_error) {
+  // There are numerous Winsock error codes, but these are the ones we thus far
+  // find interesting.
+  switch (os_error) {
+    case WSAEACCES:
+      return ERR_ACCESS_DENIED;
+    case WSAENETDOWN:
+      return ERR_INTERNET_DISCONNECTED;
+    case WSAETIMEDOUT:
+      return ERR_TIMED_OUT;
+    case WSAECONNRESET:
+    case WSAENETRESET:  // Related to keep-alive
+      return ERR_CONNECTION_RESET;
+    case WSAECONNABORTED:
+      return ERR_CONNECTION_ABORTED;
+    case WSAECONNREFUSED:
+      return ERR_CONNECTION_REFUSED;
+    case WSA_IO_INCOMPLETE:
+    case WSAEDISCON:
+      // WSAEDISCON is returned by WSARecv or WSARecvFrom for message-oriented
+      // sockets (where a return value of zero means a zero-byte message) to
+      // indicate graceful connection shutdown.  We should not ever see this
+      // error code for TCP sockets, which are byte stream oriented.
+      LOG(DFATAL) << "Unexpected error " << os_error
+                  << " mapped to net::ERR_UNEXPECTED";
+      return ERR_UNEXPECTED;
+    case WSAEHOSTUNREACH:
+    case WSAENETUNREACH:
+      return ERR_ADDRESS_UNREACHABLE;
+    case WSAEADDRNOTAVAIL:
+      return ERR_ADDRESS_INVALID;
+    case WSAENOTCONN:
+      return ERR_SOCKET_NOT_CONNECTED;
+    case ERROR_SUCCESS:
+      return OK;
+    default:
+      LOG(WARNING) << "Unknown error " << os_error
+                   << " mapped to net::ERR_FAILED";
+      return ERR_FAILED;
+  }
+}
+
+}  // namespace
+
+//-----------------------------------------------------------------------------
+
+void UDPSocketWin::ReadDelegate::OnObjectSignaled(HANDLE object) {
+  DCHECK_EQ(object, socket_->read_overlapped_.hEvent);
+  socket_->DidCompleteRead();
+}
+
+void UDPSocketWin::WriteDelegate::OnObjectSignaled(HANDLE object) {
+  DCHECK_EQ(object, socket_->write_overlapped_.hEvent);
+  socket_->DidCompleteWrite();
+}
+
+UDPSocketWin::UDPSocketWin(net::NetLog* net_log,
+                           const net::NetLog::Source& source)
+    : socket_(INVALID_SOCKET),
+      read_buf_len_(0),
+      recv_from_address_(NULL),
+      write_buf_len_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(read_delegate_(this)),

[Mike Belshe, 2011/03/10 06:53:38]

nit: for argument ordering, read_delegate should follow socket_, line 120.

[Sergey Ulanov, 2011/03/11 00:54:37]

Done.

+      ALLOW_THIS_IN_INITIALIZER_LIST(write_delegate_(this)),
+      read_callback_(NULL),
+      write_callback_(NULL),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
+  EnsureWinsockInit();
+  scoped_refptr<NetLog::EventParameters> params;
+  if (source.is_valid())
+    params = new NetLogSourceParameter("source_dependency", source);
+  net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE, params);
+  memset(&read_overlapped_, 0, sizeof(read_overlapped_));
+  read_overlapped_.hEvent = WSACreateEvent();
+  memset(&write_overlapped_, 0, sizeof(write_overlapped_));
+  write_overlapped_.hEvent = WSACreateEvent();

[Mike Belshe, 2011/03/10 06:53:38]

should we also:
  memset(&read_buffer_, 0, sizeof(read_buffer_));
  memset(&write_buffer_, 0, sizeof(write_buffer_));

[Sergey Ulanov, 2011/03/11 00:54:37]

I don't think it is neccessary: WSABUF has only two members, and we set both
explicitly before reading/writing.

+}
+
+UDPSocketWin::~UDPSocketWin() {
+  Close();
+  net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE, NULL);
+}
+
+void UDPSocketWin::Close() {
+  DCHECK(CalledOnValidThread());
+
+  if (!is_connected())
+    return;
+
+  if (read_callback_)
+    DoReadCallback(ERR_ABORTED);
+  if (write_callback_)
+    DoReadCallback(ERR_ABORTED);
+
+  read_watcher_.StopWatching();
+  write_watcher_.StopWatching();
+
+  closesocket(socket_);
+  socket_ = INVALID_SOCKET;
+}
+
+int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(address);
+  if (!is_connected())
+    return ERR_SOCKET_NOT_CONNECTED;
+
+  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))
+      return MapWinsockError(WSAGetLastError());
+    scoped_ptr<IPEndPoint> address(new IPEndPoint());
+    if (!address->FromSockAddr(addr, 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;
+
+  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))
+      return MapWinsockError(WSAGetLastError());
+    scoped_ptr<IPEndPoint> address(new IPEndPoint());
+    if (!address->FromSockAddr(addr, addr_len))
+      return ERR_FAILED;
+    local_address_.reset(address.release());
+  }
+
+  *address = *local_address_;
+  return OK;
+}
+
+int UDPSocketWin::RecvFrom(IOBuffer* buf,
+                           int buf_len,
+                           IPEndPoint* address,
+                           CompletionCallback* callback) {
+  DCHECK(!recv_from_address_);
+  recv_from_address_ = address;
+  return Read(buf, buf_len, callback);
+}
+
+int UDPSocketWin::Read(IOBuffer* buf,
+                       int buf_len,
+                       CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(INVALID_SOCKET, socket_);
+  DCHECK(!read_callback_);
+  DCHECK(callback);  // Synchronous operation not supported.
+  DCHECK_GT(buf_len, 0);
+
+  read_buffer_.buf = buf->data();
+  read_buffer_.len = buf_len;

[Mike Belshe, 2011/03/10 06:53:38]

Note:  I liked what you did in the libevent.cc changes - you make InternalRead()
take the buf/len as arguments, and then you moved lines 224/225 down to after
the InternalRead if it returned ERR_IO_PENDING.

[Sergey Ulanov, 2011/03/11 00:54:37]

Added the same arguments in InternalRead() here

+
+  int nread = InternalRead();
+  if (nread != ERR_IO_PENDING)
+    return nread;
+
+  read_iobuffer_ = buf;
+  read_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+
+int UDPSocketWin::SendTo(IOBuffer* buf,
+                              int buf_len,

[Mike Belshe, 2011/03/10 06:53:38]

nit spacing

[Sergey Ulanov, 2011/03/11 00:54:37]

Done.

+                              const IPEndPoint& address,
+                              CompletionCallback* callback) {
+  send_to_address_.reset(new IPEndPoint(address));
+  return Write(buf, buf_len, callback);
+}
+
+int UDPSocketWin::Write(IOBuffer* buf,
+                        int buf_len,
+                        CompletionCallback* callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(INVALID_SOCKET, socket_);
+  DCHECK(!write_callback_);
+  DCHECK(callback);  // Synchronous operation not supported.
+  DCHECK_GT(buf_len, 0);
+
+  write_buffer_.buf = buf->data();
+  write_buffer_.len = buf_len;
+
+  int nwrite = InternalWrite();
+  if (nwrite != ERR_IO_PENDING)
+    return nwrite;
+
+  write_iobuffer_ = buf;
+  write_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+
+int UDPSocketWin::Connect(const IPEndPoint& address) {
+  DCHECK(!is_connected());
+  DCHECK(!remote_address_.get());
+  int rv = CreateSocket(address);
+  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))
+    return ERR_FAILED;
+
+  rv = connect(socket_, addr, addr_len);
+  if (rv < 0)
+    return MapWinsockError(WSAGetLastError());
+
+  remote_address_.reset(new IPEndPoint(address));
+  return rv;
+}
+
+int UDPSocketWin::Bind(const IPEndPoint& address) {
+  DCHECK(!is_connected());
+  DCHECK(!local_address_.get());
+  int rv = CreateSocket(address);
+  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))
+    return ERR_FAILED;
+
+  rv = bind(socket_, addr, addr_len);
+  if (rv < 0)
+    return MapWinsockError(WSAGetLastError());
+
+  local_address_.reset(new IPEndPoint(address));
+  return rv;
+}
+
+int UDPSocketWin::CreateSocket(const IPEndPoint& address) {
+  socket_ = socket(address.GetFamily(), SOCK_DGRAM, 0);
+  if (socket_ == INVALID_SOCKET)
+    return MapWinsockError(WSAGetLastError());
+  if (SetNonBlocking(socket_)) {

[Mike Belshe, 2011/03/10 06:53:38]

I don't think we want this SetNonBlocking call - is this the
net_util::SetNonBlocking?

In this case, we're using the overlapped IO APIs, and those should suffice,
right?

[Sergey Ulanov, 2011/03/11 00:54:37]

Done.

+    const int err = MapWinsockError(WSAGetLastError());
+    Close();
+    return err;
+  }
+  return OK;
+}
+
+void UDPSocketWin::DoReadCallback(int rv) {
+  DCHECK_NE(rv, ERR_IO_PENDING);
+  DCHECK(read_callback_);
+
+  // since Run may result in Read being called, clear read_callback_ up front.
+  CompletionCallback* c = read_callback_;
+  read_callback_ = NULL;
+  recv_from_address_ = NULL;
+  c->Run(rv);
+}
+
+void UDPSocketWin::DoWriteCallback(int rv) {
+  DCHECK_NE(rv, ERR_IO_PENDING);
+  DCHECK(write_callback_);
+
+  // since Run may result in Write being called, clear write_callback_ up front.
+  CompletionCallback* c = write_callback_;
+  write_callback_ = NULL;
+  send_to_address_.reset();
+  c->Run(rv);
+}
+
+void UDPSocketWin::DidCompleteRead() {
+  DWORD num_bytes, flags;
+  BOOL ok = WSAGetOverlappedResult(socket_, &read_overlapped_,
+                                   &num_bytes, FALSE, &flags);
+  WSAResetEvent(read_overlapped_.hEvent);
+  int result = ok ? num_bytes : MapWinsockError(WSAGetLastError());
+  if (ok) {
+    if (!ProcessSuccessfulRead(num_bytes))
+      result = ERR_FAILED;
+  }
+  read_iobuffer_ = NULL;

[Mike Belshe, 2011/03/10 06:53:38]

I think you should zero out the read_buffer_ in here.  Otherwise, we're still
pointing to the last Read() call's buffer (should be benign...).

[Sergey Ulanov, 2011/03/11 00:54:37]

Oh, I've found this in MSDN:

If this function is completed in an overlapped manner, it is the Winsock service
provider's responsibility to capture the WSABUF structures before returning from
this call. This enables applications to build stack-based WSABUF arrays pointed
to by the lpBuffers parameter.

So we don't need read_buffer_ and write_buffer_ to be members! Removing them

+  DoReadCallback(result);
+}
+
+bool UDPSocketWin::ProcessSuccessfulRead(int num_bytes) {
+  static base::StatsCounter read_bytes("udp.read_bytes");
+  read_bytes.Add(num_bytes);
+
+  // Convert address.
+  if (recv_from_address_) {
+    struct sockaddr* addr =
+        reinterpret_cast<struct sockaddr*>(&recv_addr_storage_);
+    if (!recv_from_address_->FromSockAddr(addr, recv_addr_len_))
+      return false;
+  }
+
+  return true;
+}
+
+void UDPSocketWin::DidCompleteWrite() {
+  DWORD num_bytes, flags;
+  BOOL ok = WSAGetOverlappedResult(socket_, &write_overlapped_,
+                                   &num_bytes, FALSE, &flags);
+  WSAResetEvent(write_overlapped_.hEvent);
+  int result = ok ? num_bytes : MapWinsockError(WSAGetLastError());
+  if (ok)
+    ProcessSuccessfulWrite(num_bytes);
+  write_iobuffer_ = NULL;
+  DoWriteCallback(result);
+}
+
+void UDPSocketWin::ProcessSuccessfulWrite(int num_bytes) {
+  static base::StatsCounter write_bytes("udp.write_bytes");
+  write_bytes.Add(num_bytes);
+}
+
+int UDPSocketWin::InternalRead() {

[Mike Belshe, 2011/03/10 06:53:38]

DCHECK(read_buffer_.buf)

[Sergey Ulanov, 2011/03/11 00:54:37]

Not needed anymore, as I removed read_buffer_

+  recv_addr_len_ = sizeof(recv_addr_storage_);
+  struct sockaddr* addr =
+      reinterpret_cast<struct sockaddr*>(&recv_addr_storage_);
+  DWORD flags = 0;
+  DWORD num;
+  AssertEventNotSignaled(read_overlapped_.hEvent);
+  int rv = WSARecvFrom(socket_, &read_buffer_, 1, &num, &flags,
+                       addr, &recv_addr_len_, &read_overlapped_, NULL);
+  if (rv == 0) {
+    if (ResetEventIfSignaled(read_overlapped_.hEvent)) {
+      // Because of how WSARecv fills memory when used asynchronously, Purify
+      // isn't able to detect that it's been initialized, so it scans for 0xcd
+      // in the buffer and reports UMRs (uninitialized memory reads) for those
+      // individual bytes. We override that in PURIFY builds to avoid the
+      // false error reports.
+      // See bug 5297.
+      base::MemoryDebug::MarkAsInitialized(read_buffer_.buf, num);
+      if (!ProcessSuccessfulRead(num))
+        return ERR_FAILED;
+      return static_cast<int>(num);
+    }
+  } else {
+    int os_error = WSAGetLastError();
+    if (os_error != WSA_IO_PENDING)
+      return MapWinsockError(os_error);
+  }
+  read_watcher_.StartWatching(read_overlapped_.hEvent, &read_delegate_);
+  return ERR_IO_PENDING;
+}
+
+int UDPSocketWin::InternalWrite() {

[Mike Belshe, 2011/03/10 06:53:38]

DCHECK(write_buffer_.buf);

[Sergey Ulanov, 2011/03/11 00:54:37]

same here.

+  struct sockaddr_storage addr_storage;
+  size_t addr_len = sizeof(addr_storage);
+  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+
+  // Convert address.
+  if (!send_to_address_.get()) {
+    addr = NULL;
+    addr_len = 0;
+  } else {
+    if (!send_to_address_->ToSockAddr(addr, &addr_len))
+      return ERR_FAILED;
+  }
+
+  DWORD flags = 0;
+  DWORD num;
+  AssertEventNotSignaled(write_overlapped_.hEvent);
+  int rv = WSASendTo(socket_, &write_buffer_, 1, &num, flags,
+                     addr, addr_len, &write_overlapped_, NULL);
+  if (rv == 0) {
+    if (ResetEventIfSignaled(write_overlapped_.hEvent)) {
+      ProcessSuccessfulWrite(num);
+      return static_cast<int>(num);
+    }
+  } else {
+    int os_error = WSAGetLastError();
+    if (os_error != WSA_IO_PENDING)
+      return MapWinsockError(os_error);
+  }
+
+  write_watcher_.StartWatching(write_overlapped_.hEvent, &write_delegate_);
+  return ERR_IO_PENDING;
+}
+
+}  // namespace net