Add NetLog support to UDP sockets.

net/udp/udp_socket_win.cc

 // 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/metrics/stats_counters.h"
 #include "base/rand_util.h"
+#include "net/base/address_list_net_log_param.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"
 #include "net/base/winsock_util.h"
+#include "net/udp/udp_data_transfer_param.h"
 
 namespace {
 
 static const int kBindRetries = 10;
 static const int kPortStart = 1024;
 static const int kPortEnd = 65535;
 
 }  // namespace net
 
 namespace net {
@@ skipping 13 matching lines @@
                            net::NetLog* net_log,
                            const net::NetLog::Source& source)
     : socket_(INVALID_SOCKET),
       bind_type_(bind_type),
       rand_int_cb_(rand_int_cb),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(write_delegate_(this)),
       recv_from_address_(NULL),
       read_callback_(NULL),
       write_callback_(NULL),
-      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_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();
   if (bind_type == DatagramSocket::RANDOM_BIND)
@@ skipping 78 matching lines @@
                            IPEndPoint* address,
                            OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(INVALID_SOCKET, socket_);
   DCHECK(!read_callback_);
   DCHECK(!recv_from_address_);
   DCHECK(callback);  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
 
   int nread = InternalRecvFrom(buf, buf_len, address);
-  if (nread != ERR_IO_PENDING)
+  if (nread != ERR_IO_PENDING) {
+    if (nread < 0)
+      net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, nread);
     return nread;
+  }
 
   read_iobuffer_ = buf;
   read_callback_ = callback;
   recv_from_address_ = address;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::Write(IOBuffer* buf,
                         int buf_len,
                         OldCompletionCallback* callback) {
   return SendToOrWrite(buf, buf_len, NULL, callback);
 }
 
 int UDPSocketWin::SendTo(IOBuffer* buf,
                          int buf_len,
                          const IPEndPoint& address,
                          OldCompletionCallback* callback) {
   return SendToOrWrite(buf, buf_len, &address, callback);
 }
 
 int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
                                 int buf_len,
                                 const IPEndPoint* address,
                                 OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(INVALID_SOCKET, socket_);
   DCHECK(!write_callback_);
   DCHECK(callback);  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
+  DCHECK(!send_to_address_.get());
 
   int nwrite = InternalSendTo(buf, buf_len, address);
-  if (nwrite != ERR_IO_PENDING)
+  if (nwrite != ERR_IO_PENDING) {
+    if (nwrite < 0)
+      net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, nwrite);
     return nwrite;
+  }
 
+  if (address)
+    send_to_address_.reset(new IPEndPoint(*address));
   write_iobuffer_ = buf;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::Connect(const IPEndPoint& address) {
+  net_log_.BeginEvent(
+      NetLog::TYPE_UDP_CONNECT,
+      make_scoped_refptr(new NetLogStringParameter("address",
+                                                   address.ToString())));
+  int rv = InternalConnect(address);
+  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_UDP_CONNECT, rv);
+  return rv;
+}
+
+int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
   DCHECK(!is_connected());
   DCHECK(!remote_address_.get());
   int rv = CreateSocket(address);
   if (rv < 0)
     return rv;
 
   if (bind_type_ == DatagramSocket::RANDOM_BIND)
     rv = RandomBind(address);
   // else connect() does the DatagramSocket::DEFAULT_BIND
 
@@ skipping 54 matching lines @@
   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 : MapSystemError(WSAGetLastError());
   if (ok) {
-    if (!ProcessSuccessfulRead(num_bytes, recv_from_address_))
+    if (!ProcessSuccessfulRead(num_bytes, read_iobuffer_->data(),
+                               recv_from_address_)) {
       result = ERR_FAILED;
+    }
   }
+  if (result < 0)
+    net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, result);
   read_iobuffer_ = NULL;
   recv_from_address_ = NULL;
   DoReadCallback(result);
 }
 
-bool UDPSocketWin::ProcessSuccessfulRead(int num_bytes, IPEndPoint* address) {
+bool UDPSocketWin::ProcessSuccessfulRead(int num_bytes, const char* bytes,
+                                         IPEndPoint* address) const {
   base::StatsCounter read_bytes("udp.read_bytes");
   read_bytes.Add(num_bytes);
 
-  // Convert address.
-  if (address) {
-    struct sockaddr* addr =
-        reinterpret_cast<struct sockaddr*>(&recv_addr_storage_);
+  const struct sockaddr* addr =
+      reinterpret_cast<const struct sockaddr*>(&recv_addr_storage_);
+
+  // Convert address.  If address is NULL, use a variable on the stack to
+  // hold the address, for logging.
+  IPEndPoint address_on_stack;
+  if (!address) {
+    if (address_on_stack.FromSockAddr(addr, recv_addr_len_))
+      address = &address_on_stack;
+  } else {
     if (!address->FromSockAddr(addr, recv_addr_len_))
       return false;
   }
 
+  net_log_.AddEvent(
+      NetLog::TYPE_UDP_BYTES_RECEIVED,
+      make_scoped_refptr(
+          new UDPDataTransferNetLogParam(num_bytes, bytes,
+                                         net_log_.IsLoggingBytes(),
+                                         address)));
+
   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 : MapSystemError(WSAGetLastError());
-  if (ok)
-    ProcessSuccessfulWrite(num_bytes);
+  if (ok) {
+    ProcessSuccessfulWrite(num_bytes, write_iobuffer_->data(),
+                           send_to_address_.get());
+  } else {
+    net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, result);
+  }
+  send_to_address_.reset();
   write_iobuffer_ = NULL;
   DoWriteCallback(result);
 }
 
-void UDPSocketWin::ProcessSuccessfulWrite(int num_bytes) {
+void UDPSocketWin::ProcessSuccessfulWrite(int num_bytes,
+                                          const char* bytes,
+                                          const IPEndPoint* address) const {
+  net_log_.AddEvent(
+      NetLog::TYPE_UDP_BYTES_SENT,
+      make_scoped_refptr(
+          new UDPDataTransferNetLogParam(num_bytes, bytes,
+                                         net_log_.IsLoggingBytes(),
+                                         address)));
   base::StatsCounter write_bytes("udp.write_bytes");
   write_bytes.Add(num_bytes);
 }
 
 int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
                                    IPEndPoint* address) {
   recv_addr_len_ = sizeof(recv_addr_storage_);
   struct sockaddr* addr =
       reinterpret_cast<struct sockaddr*>(&recv_addr_storage_);
 
   WSABUF read_buffer;
   read_buffer.buf = buf->data();
   read_buffer.len = buf_len;
 
   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)) {
-      if (!ProcessSuccessfulRead(num, address))
+      if (!ProcessSuccessfulRead(num, buf->data(), address))
         return ERR_FAILED;
       return static_cast<int>(num);
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING)
       return MapSystemError(os_error);
   }
   read_watcher_.StartWatching(read_overlapped_.hEvent, &read_delegate_);
   return ERR_IO_PENDING;
@@ skipping 18 matching lines @@
   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);
   if (rv == 0) {
     if (ResetEventIfSignaled(write_overlapped_.hEvent)) {
-      ProcessSuccessfulWrite(num);
+      ProcessSuccessfulWrite(num, buf->data(), address);
       return static_cast<int>(num);
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING)
       return MapSystemError(os_error);
   }
 
   write_watcher_.StartWatching(write_overlapped_.hEvent, &write_delegate_);
   return ERR_IO_PENDING;
@@ skipping 17 matching lines @@
 
   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));
 }
 
 }  // namespace net