Home | History | Annotate | Download | only in udp 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/udp/udp_socket_win.h"
      6 
      7 #include <mstcpip.h>
      8 
      9 #include "base/callback.h"
     10 #include "base/lazy_instance.h"
     11 #include "base/logging.h"
     12 #include "base/message_loop/message_loop.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/metrics/sparse_histogram.h"
     15 #include "base/metrics/stats_counters.h"
     16 #include "base/rand_util.h"
     17 #include "net/base/io_buffer.h"
     18 #include "net/base/ip_endpoint.h"
     19 #include "net/base/net_errors.h"
     20 #include "net/base/net_log.h"
     21 #include "net/base/net_util.h"
     22 #include "net/base/winsock_init.h"
     23 #include "net/base/winsock_util.h"
     24 #include "net/socket/socket_descriptor.h"
     25 #include "net/udp/udp_net_log_parameters.h"
     26 
     27 namespace {
     28 
     29 const int kBindRetries = 10;
     30 const int kPortStart = 1024;
     31 const int kPortEnd = 65535;
     32 
     33 }  // namespace
     34 
     35 namespace net {
     36 
     37 // This class encapsulates all the state that has to be preserved as long as
     38 // there is a network IO operation in progress. If the owner UDPSocketWin
     39 // is destroyed while an operation is in progress, the Core is detached and it
     40 // lives until the operation completes and the OS doesn't reference any resource
     41 // declared on this class anymore.
     42 class UDPSocketWin::Core : public base::RefCounted<Core> {
     43  public:
     44   explicit Core(UDPSocketWin* socket);
     45 
     46   // Start watching for the end of a read or write operation.
     47   void WatchForRead();
     48   void WatchForWrite();
     49 
     50   // The UDPSocketWin is going away.
     51   void Detach() { socket_ = NULL; }
     52 
     53   // The separate OVERLAPPED variables for asynchronous operation.
     54   OVERLAPPED read_overlapped_;
     55   OVERLAPPED write_overlapped_;
     56 
     57   // The buffers used in Read() and Write().
     58   scoped_refptr<IOBuffer> read_iobuffer_;
     59   scoped_refptr<IOBuffer> write_iobuffer_;
     60 
     61   // The address storage passed to WSARecvFrom().
     62   SockaddrStorage recv_addr_storage_;
     63 
     64  private:
     65   friend class base::RefCounted<Core>;
     66 
     67   class ReadDelegate : public base::win::ObjectWatcher::Delegate {
     68    public:
     69     explicit ReadDelegate(Core* core) : core_(core) {}
     70     virtual ~ReadDelegate() {}
     71 
     72     // base::ObjectWatcher::Delegate methods:
     73     virtual void OnObjectSignaled(HANDLE object);
     74 
     75    private:
     76     Core* const core_;
     77   };
     78 
     79   class WriteDelegate : public base::win::ObjectWatcher::Delegate {
     80    public:
     81     explicit WriteDelegate(Core* core) : core_(core) {}
     82     virtual ~WriteDelegate() {}
     83 
     84     // base::ObjectWatcher::Delegate methods:
     85     virtual void OnObjectSignaled(HANDLE object);
     86 
     87    private:
     88     Core* const core_;
     89   };
     90 
     91   ~Core();
     92 
     93   // The socket that created this object.
     94   UDPSocketWin* socket_;
     95 
     96   // |reader_| handles the signals from |read_watcher_|.
     97   ReadDelegate reader_;
     98   // |writer_| handles the signals from |write_watcher_|.
     99   WriteDelegate writer_;
    100 
    101   // |read_watcher_| watches for events from Read().
    102   base::win::ObjectWatcher read_watcher_;
    103   // |write_watcher_| watches for events from Write();
    104   base::win::ObjectWatcher write_watcher_;
    105 
    106   DISALLOW_COPY_AND_ASSIGN(Core);
    107 };
    108 
    109 UDPSocketWin::Core::Core(UDPSocketWin* socket)
    110     : socket_(socket),
    111       reader_(this),
    112       writer_(this) {
    113   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
    114   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
    115 
    116   read_overlapped_.hEvent = WSACreateEvent();
    117   write_overlapped_.hEvent = WSACreateEvent();
    118 }
    119 
    120 UDPSocketWin::Core::~Core() {
    121   // Make sure the message loop is not watching this object anymore.
    122   read_watcher_.StopWatching();
    123   write_watcher_.StopWatching();
    124 
    125   WSACloseEvent(read_overlapped_.hEvent);
    126   memset(&read_overlapped_, 0xaf, sizeof(read_overlapped_));
    127   WSACloseEvent(write_overlapped_.hEvent);
    128   memset(&write_overlapped_, 0xaf, sizeof(write_overlapped_));
    129 }
    130 
    131 void UDPSocketWin::Core::WatchForRead() {
    132   // We grab an extra reference because there is an IO operation in progress.
    133   // Balanced in ReadDelegate::OnObjectSignaled().
    134   AddRef();
    135   read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_);
    136 }
    137 
    138 void UDPSocketWin::Core::WatchForWrite() {
    139   // We grab an extra reference because there is an IO operation in progress.
    140   // Balanced in WriteDelegate::OnObjectSignaled().
    141   AddRef();
    142   write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_);
    143 }
    144 
    145 void UDPSocketWin::Core::ReadDelegate::OnObjectSignaled(HANDLE object) {
    146   DCHECK_EQ(object, core_->read_overlapped_.hEvent);
    147   if (core_->socket_)
    148     core_->socket_->DidCompleteRead();
    149 
    150   core_->Release();
    151 }
    152 
    153 void UDPSocketWin::Core::WriteDelegate::OnObjectSignaled(HANDLE object) {
    154   DCHECK_EQ(object, core_->write_overlapped_.hEvent);
    155   if (core_->socket_)
    156     core_->socket_->DidCompleteWrite();
    157 
    158   core_->Release();
    159 }
    160 //-----------------------------------------------------------------------------
    161 
    162 QwaveAPI::QwaveAPI() : qwave_supported_(false) {
    163   HMODULE qwave = LoadLibrary(L"qwave.dll");
    164   if (!qwave)
    165     return;
    166   create_handle_func_ =
    167       (CreateHandleFn)GetProcAddress(qwave, "QOSCreateHandle");
    168   close_handle_func_ =
    169       (CloseHandleFn)GetProcAddress(qwave, "QOSCloseHandle");
    170   add_socket_to_flow_func_ =
    171       (AddSocketToFlowFn)GetProcAddress(qwave, "QOSAddSocketToFlow");
    172   remove_socket_from_flow_func_ =
    173       (RemoveSocketFromFlowFn)GetProcAddress(qwave, "QOSRemoveSocketFromFlow");
    174   set_flow_func_ = (SetFlowFn)GetProcAddress(qwave, "QOSSetFlow");
    175 
    176   if (create_handle_func_ && close_handle_func_ &&
    177       add_socket_to_flow_func_ && remove_socket_from_flow_func_ &&
    178       set_flow_func_) {
    179     qwave_supported_ = true;
    180   }
    181 }
    182 
    183 QwaveAPI& QwaveAPI::Get() {
    184   static base::LazyInstance<QwaveAPI>::Leaky lazy_qwave =
    185     LAZY_INSTANCE_INITIALIZER;
    186   return lazy_qwave.Get();
    187 }
    188 
    189 bool QwaveAPI::qwave_supported() const {
    190   return qwave_supported_;
    191 }
    192 BOOL QwaveAPI::CreateHandle(PQOS_VERSION version, PHANDLE handle) {
    193   return create_handle_func_(version, handle);
    194 }
    195 BOOL QwaveAPI::CloseHandle(HANDLE handle) {
    196   return close_handle_func_(handle);
    197 }
    198 
    199 BOOL QwaveAPI::AddSocketToFlow(HANDLE handle,
    200                                SOCKET socket,
    201                                PSOCKADDR addr,
    202                                QOS_TRAFFIC_TYPE traffic_type,
    203                                DWORD flags,
    204                                PQOS_FLOWID flow_id) {
    205   return add_socket_to_flow_func_(handle,
    206                                   socket,
    207                                   addr,
    208                                   traffic_type,
    209                                   flags,
    210                                   flow_id);
    211 }
    212 
    213 BOOL QwaveAPI::RemoveSocketFromFlow(HANDLE handle,
    214                                     SOCKET socket,
    215                                     QOS_FLOWID flow_id,
    216                                     DWORD reserved) {
    217   return remove_socket_from_flow_func_(handle, socket, flow_id, reserved);
    218 }
    219 
    220 BOOL QwaveAPI::SetFlow(HANDLE handle,
    221                        QOS_FLOWID flow_id,
    222                        QOS_SET_FLOW op,
    223                        ULONG size,
    224                        PVOID data,
    225                        DWORD reserved,
    226                        LPOVERLAPPED overlapped) {
    227   return set_flow_func_(handle,
    228                         flow_id,
    229                         op,
    230                         size,
    231                         data,
    232                         reserved,
    233                         overlapped);
    234 }
    235 
    236 
    237 //-----------------------------------------------------------------------------
    238 
    239 UDPSocketWin::UDPSocketWin(DatagramSocket::BindType bind_type,
    240                            const RandIntCallback& rand_int_cb,
    241                            net::NetLog* net_log,
    242                            const net::NetLog::Source& source)
    243     : socket_(INVALID_SOCKET),
    244       addr_family_(0),
    245       socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
    246       multicast_interface_(0),
    247       multicast_time_to_live_(1),
    248       bind_type_(bind_type),
    249       rand_int_cb_(rand_int_cb),
    250       recv_from_address_(NULL),
    251       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)),
    252       qos_handle_(NULL),
    253       qos_flow_id_(0) {
    254   EnsureWinsockInit();
    255   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
    256                       source.ToEventParametersCallback());
    257   if (bind_type == DatagramSocket::RANDOM_BIND)
    258     DCHECK(!rand_int_cb.is_null());
    259 }
    260 
    261 UDPSocketWin::~UDPSocketWin() {
    262   Close();
    263   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
    264 }
    265 
    266 void UDPSocketWin::Close() {
    267   DCHECK(CalledOnValidThread());
    268 
    269   if (!is_connected())
    270     return;
    271 
    272   if (qos_handle_) {
    273     QwaveAPI::Get().CloseHandle(qos_handle_);
    274   }
    275 
    276   // Zero out any pending read/write callback state.
    277   read_callback_.Reset();
    278   recv_from_address_ = NULL;
    279   write_callback_.Reset();
    280 
    281   base::TimeTicks start_time = base::TimeTicks::Now();
    282   closesocket(socket_);
    283   UMA_HISTOGRAM_TIMES("Net.UDPSocketWinClose",
    284                       base::TimeTicks::Now() - start_time);
    285   socket_ = INVALID_SOCKET;
    286   addr_family_ = 0;
    287 
    288   core_->Detach();
    289   core_ = NULL;
    290 }
    291 
    292 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
    293   DCHECK(CalledOnValidThread());
    294   DCHECK(address);
    295   if (!is_connected())
    296     return ERR_SOCKET_NOT_CONNECTED;
    297 
    298   // TODO(szym): Simplify. http://crbug.com/126152
    299   if (!remote_address_.get()) {
    300     SockaddrStorage storage;
    301     if (getpeername(socket_, storage.addr, &storage.addr_len))
    302       return MapSystemError(WSAGetLastError());
    303     scoped_ptr<IPEndPoint> address(new IPEndPoint());
    304     if (!address->FromSockAddr(storage.addr, storage.addr_len))
    305       return ERR_ADDRESS_INVALID;
    306     remote_address_.reset(address.release());
    307   }
    308 
    309   *address = *remote_address_;
    310   return OK;
    311 }
    312 
    313 int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
    314   DCHECK(CalledOnValidThread());
    315   DCHECK(address);
    316   if (!is_connected())
    317     return ERR_SOCKET_NOT_CONNECTED;
    318 
    319   // TODO(szym): Simplify. http://crbug.com/126152
    320   if (!local_address_.get()) {
    321     SockaddrStorage storage;
    322     if (getsockname(socket_, storage.addr, &storage.addr_len))
    323       return MapSystemError(WSAGetLastError());
    324     scoped_ptr<IPEndPoint> address(new IPEndPoint());
    325     if (!address->FromSockAddr(storage.addr, storage.addr_len))
    326       return ERR_ADDRESS_INVALID;
    327     local_address_.reset(address.release());
    328     net_log_.AddEvent(NetLog::TYPE_UDP_LOCAL_ADDRESS,
    329                       CreateNetLogUDPConnectCallback(local_address_.get()));
    330   }
    331 
    332   *address = *local_address_;
    333   return OK;
    334 }
    335 
    336 int UDPSocketWin::Read(IOBuffer* buf,
    337                        int buf_len,
    338                        const CompletionCallback& callback) {
    339   return RecvFrom(buf, buf_len, NULL, callback);
    340 }
    341 
    342 int UDPSocketWin::RecvFrom(IOBuffer* buf,
    343                            int buf_len,
    344                            IPEndPoint* address,
    345                            const CompletionCallback& callback) {
    346   DCHECK(CalledOnValidThread());
    347   DCHECK_NE(INVALID_SOCKET, socket_);
    348   CHECK(read_callback_.is_null());
    349   DCHECK(!recv_from_address_);
    350   DCHECK(!callback.is_null());  // Synchronous operation not supported.
    351   DCHECK_GT(buf_len, 0);
    352 
    353   int nread = InternalRecvFrom(buf, buf_len, address);
    354   if (nread != ERR_IO_PENDING)
    355     return nread;
    356 
    357   read_callback_ = callback;
    358   recv_from_address_ = address;
    359   return ERR_IO_PENDING;
    360 }
    361 
    362 int UDPSocketWin::Write(IOBuffer* buf,
    363                         int buf_len,
    364                         const CompletionCallback& callback) {
    365   return SendToOrWrite(buf, buf_len, NULL, callback);
    366 }
    367 
    368 int UDPSocketWin::SendTo(IOBuffer* buf,
    369                          int buf_len,
    370                          const IPEndPoint& address,
    371                          const CompletionCallback& callback) {
    372   return SendToOrWrite(buf, buf_len, &address, callback);
    373 }
    374 
    375 int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
    376                                 int buf_len,
    377                                 const IPEndPoint* address,
    378                                 const CompletionCallback& callback) {
    379   DCHECK(CalledOnValidThread());
    380   DCHECK_NE(INVALID_SOCKET, socket_);
    381   CHECK(write_callback_.is_null());
    382   DCHECK(!callback.is_null());  // Synchronous operation not supported.
    383   DCHECK_GT(buf_len, 0);
    384   DCHECK(!send_to_address_.get());
    385 
    386   int nwrite = InternalSendTo(buf, buf_len, address);
    387   if (nwrite != ERR_IO_PENDING)
    388     return nwrite;
    389 
    390   if (address)
    391     send_to_address_.reset(new IPEndPoint(*address));
    392   write_callback_ = callback;
    393   return ERR_IO_PENDING;
    394 }
    395 
    396 int UDPSocketWin::Connect(const IPEndPoint& address) {
    397   net_log_.BeginEvent(NetLog::TYPE_UDP_CONNECT,
    398                       CreateNetLogUDPConnectCallback(&address));
    399   int rv = InternalConnect(address);
    400   if (rv != OK)
    401     Close();
    402   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_UDP_CONNECT, rv);
    403   return rv;
    404 }
    405 
    406 int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
    407   DCHECK(!is_connected());
    408   DCHECK(!remote_address_.get());
    409   int addr_family = address.GetSockAddrFamily();
    410   int rv = CreateSocket(addr_family);
    411   if (rv < 0)
    412     return rv;
    413 
    414   if (bind_type_ == DatagramSocket::RANDOM_BIND) {
    415     // Construct IPAddressNumber of appropriate size (IPv4 or IPv6) of 0s,
    416     // representing INADDR_ANY or in6addr_any.
    417     size_t addr_size =
    418         addr_family == AF_INET ? kIPv4AddressSize : kIPv6AddressSize;
    419     IPAddressNumber addr_any(addr_size);
    420     rv = RandomBind(addr_any);
    421   }
    422   // else connect() does the DatagramSocket::DEFAULT_BIND
    423 
    424   if (rv < 0) {
    425     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.UdpSocketRandomBindErrorCode", -rv);
    426     Close();
    427     return rv;
    428   }
    429 
    430   SockaddrStorage storage;
    431   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
    432     return ERR_ADDRESS_INVALID;
    433 
    434   rv = connect(socket_, storage.addr, storage.addr_len);
    435   if (rv < 0) {
    436     // Close() may change the last error. Map it beforehand.
    437     int result = MapSystemError(WSAGetLastError());
    438     Close();
    439     return result;
    440   }
    441 
    442   remote_address_.reset(new IPEndPoint(address));
    443   return rv;
    444 }
    445 
    446 int UDPSocketWin::Bind(const IPEndPoint& address) {
    447   DCHECK(!is_connected());
    448   int rv = CreateSocket(address.GetSockAddrFamily());
    449   if (rv < 0)
    450     return rv;
    451   rv = SetSocketOptions();
    452   if (rv < 0) {
    453     Close();
    454     return rv;
    455   }
    456   rv = DoBind(address);
    457   if (rv < 0) {
    458     Close();
    459     return rv;
    460   }
    461   local_address_.reset();
    462   return rv;
    463 }
    464 
    465 int UDPSocketWin::CreateSocket(int addr_family) {
    466   addr_family_ = addr_family;
    467   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
    468   if (socket_ == INVALID_SOCKET)
    469     return MapSystemError(WSAGetLastError());
    470   core_ = new Core(this);
    471   return OK;
    472 }
    473 
    474 int UDPSocketWin::SetReceiveBufferSize(int32 size) {
    475   DCHECK(CalledOnValidThread());
    476   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
    477                       reinterpret_cast<const char*>(&size), sizeof(size));
    478   if (rv != 0)
    479     return MapSystemError(WSAGetLastError());
    480 
    481   // According to documentation, setsockopt may succeed, but we need to check
    482   // the results via getsockopt to be sure it works on Windows.
    483   int32 actual_size = 0;
    484   int option_size = sizeof(actual_size);
    485   rv = getsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
    486                   reinterpret_cast<char*>(&actual_size), &option_size);
    487   if (rv != 0)
    488     return MapSystemError(WSAGetLastError());
    489   if (actual_size >= size)
    490     return OK;
    491   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableReceiveBuffer",
    492                               actual_size, 1000, 1000000, 50);
    493   return ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE;
    494 }
    495 
    496 int UDPSocketWin::SetSendBufferSize(int32 size) {
    497   DCHECK(CalledOnValidThread());
    498   int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
    499                       reinterpret_cast<const char*>(&size), sizeof(size));
    500   if (rv != 0)
    501     return MapSystemError(WSAGetLastError());
    502   // According to documentation, setsockopt may succeed, but we need to check
    503   // the results via getsockopt to be sure it works on Windows.
    504   int32 actual_size = 0;
    505   int option_size = sizeof(actual_size);
    506   rv = getsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
    507                   reinterpret_cast<char*>(&actual_size), &option_size);
    508   if (rv != 0)
    509     return MapSystemError(WSAGetLastError());
    510   if (actual_size >= size)
    511     return OK;
    512   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableSendBuffer",
    513                               actual_size, 1000, 1000000, 50);
    514   return ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE;
    515 }
    516 
    517 void UDPSocketWin::AllowAddressReuse() {
    518   DCHECK(CalledOnValidThread());
    519   DCHECK(!is_connected());
    520 
    521   socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
    522 }
    523 
    524 void UDPSocketWin::AllowBroadcast() {
    525   DCHECK(CalledOnValidThread());
    526   DCHECK(!is_connected());
    527 
    528   socket_options_ |= SOCKET_OPTION_BROADCAST;
    529 }
    530 
    531 void UDPSocketWin::DoReadCallback(int rv) {
    532   DCHECK_NE(rv, ERR_IO_PENDING);
    533   DCHECK(!read_callback_.is_null());
    534 
    535   // since Run may result in Read being called, clear read_callback_ up front.
    536   CompletionCallback c = read_callback_;
    537   read_callback_.Reset();
    538   c.Run(rv);
    539 }
    540 
    541 void UDPSocketWin::DoWriteCallback(int rv) {
    542   DCHECK_NE(rv, ERR_IO_PENDING);
    543   DCHECK(!write_callback_.is_null());
    544 
    545   // since Run may result in Write being called, clear write_callback_ up front.
    546   CompletionCallback c = write_callback_;
    547   write_callback_.Reset();
    548   c.Run(rv);
    549 }
    550 
    551 void UDPSocketWin::DidCompleteRead() {
    552   DWORD num_bytes, flags;
    553   BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
    554                                    &num_bytes, FALSE, &flags);
    555   WSAResetEvent(core_->read_overlapped_.hEvent);
    556   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
    557   // Convert address.
    558   if (recv_from_address_ && result >= 0) {
    559     if (!ReceiveAddressToIPEndpoint(recv_from_address_))
    560       result = ERR_ADDRESS_INVALID;
    561   }
    562   LogRead(result, core_->read_iobuffer_->data());
    563   core_->read_iobuffer_ = NULL;
    564   recv_from_address_ = NULL;
    565   DoReadCallback(result);
    566 }
    567 
    568 void UDPSocketWin::LogRead(int result, const char* bytes) const {
    569   if (result < 0) {
    570     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, result);
    571     return;
    572   }
    573 
    574   if (net_log_.IsLogging()) {
    575     // Get address for logging, if |address| is NULL.
    576     IPEndPoint address;
    577     bool is_address_valid = ReceiveAddressToIPEndpoint(&address);
    578     net_log_.AddEvent(
    579         NetLog::TYPE_UDP_BYTES_RECEIVED,
    580         CreateNetLogUDPDataTranferCallback(
    581             result, bytes,
    582             is_address_valid ? &address : NULL));
    583   }
    584 
    585   base::StatsCounter read_bytes("udp.read_bytes");
    586   read_bytes.Add(result);
    587 }
    588 
    589 void UDPSocketWin::DidCompleteWrite() {
    590   DWORD num_bytes, flags;
    591   BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
    592                                    &num_bytes, FALSE, &flags);
    593   WSAResetEvent(core_->write_overlapped_.hEvent);
    594   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
    595   LogWrite(result, core_->write_iobuffer_->data(), send_to_address_.get());
    596 
    597   send_to_address_.reset();
    598   core_->write_iobuffer_ = NULL;
    599   DoWriteCallback(result);
    600 }
    601 
    602 void UDPSocketWin::LogWrite(int result,
    603                             const char* bytes,
    604                             const IPEndPoint* address) const {
    605   if (result < 0) {
    606     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, result);
    607     return;
    608   }
    609 
    610   if (net_log_.IsLogging()) {
    611     net_log_.AddEvent(
    612         NetLog::TYPE_UDP_BYTES_SENT,
    613         CreateNetLogUDPDataTranferCallback(result, bytes, address));
    614   }
    615 
    616   base::StatsCounter write_bytes("udp.write_bytes");
    617   write_bytes.Add(result);
    618 }
    619 
    620 int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
    621                                    IPEndPoint* address) {
    622   DCHECK(!core_->read_iobuffer_);
    623   SockaddrStorage& storage = core_->recv_addr_storage_;
    624   storage.addr_len = sizeof(storage.addr_storage);
    625 
    626   WSABUF read_buffer;
    627   read_buffer.buf = buf->data();
    628   read_buffer.len = buf_len;
    629 
    630   DWORD flags = 0;
    631   DWORD num;
    632   CHECK_NE(INVALID_SOCKET, socket_);
    633   AssertEventNotSignaled(core_->read_overlapped_.hEvent);
    634   int rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr,
    635                        &storage.addr_len, &core_->read_overlapped_, NULL);
    636   if (rv == 0) {
    637     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
    638       int result = num;
    639       // Convert address.
    640       if (address && result >= 0) {
    641         if (!ReceiveAddressToIPEndpoint(address))
    642           result = ERR_ADDRESS_INVALID;
    643       }
    644       LogRead(result, buf->data());
    645       return result;
    646     }
    647   } else {
    648     int os_error = WSAGetLastError();
    649     if (os_error != WSA_IO_PENDING) {
    650       int result = MapSystemError(os_error);
    651       LogRead(result, NULL);
    652       return result;
    653     }
    654   }
    655   core_->WatchForRead();
    656   core_->read_iobuffer_ = buf;
    657   return ERR_IO_PENDING;
    658 }
    659 
    660 int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
    661                                  const IPEndPoint* address) {
    662   DCHECK(!core_->write_iobuffer_);
    663   SockaddrStorage storage;
    664   struct sockaddr* addr = storage.addr;
    665   // Convert address.
    666   if (!address) {
    667     addr = NULL;
    668     storage.addr_len = 0;
    669   } else {
    670     if (!address->ToSockAddr(addr, &storage.addr_len)) {
    671       int result = ERR_ADDRESS_INVALID;
    672       LogWrite(result, NULL, NULL);
    673       return result;
    674     }
    675   }
    676 
    677   WSABUF write_buffer;
    678   write_buffer.buf = buf->data();
    679   write_buffer.len = buf_len;
    680 
    681   DWORD flags = 0;
    682   DWORD num;
    683   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
    684   int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags,
    685                      addr, storage.addr_len, &core_->write_overlapped_, NULL);
    686   if (rv == 0) {
    687     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
    688       int result = num;
    689       LogWrite(result, buf->data(), address);
    690       return result;
    691     }
    692   } else {
    693     int os_error = WSAGetLastError();
    694     if (os_error != WSA_IO_PENDING) {
    695       int result = MapSystemError(os_error);
    696       LogWrite(result, NULL, NULL);
    697       return result;
    698     }
    699   }
    700 
    701   core_->WatchForWrite();
    702   core_->write_iobuffer_ = buf;
    703   return ERR_IO_PENDING;
    704 }
    705 
    706 int UDPSocketWin::SetSocketOptions() {
    707   BOOL true_value = 1;
    708   if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
    709     int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
    710                         reinterpret_cast<const char*>(&true_value),
    711                         sizeof(true_value));
    712     if (rv < 0)
    713       return MapSystemError(WSAGetLastError());
    714   }
    715   if (socket_options_ & SOCKET_OPTION_BROADCAST) {
    716     int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
    717                         reinterpret_cast<const char*>(&true_value),
    718                         sizeof(true_value));
    719     if (rv < 0)
    720       return MapSystemError(WSAGetLastError());
    721   }
    722   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
    723     DWORD loop = 0;
    724     int protocol_level =
    725         addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
    726     int option =
    727         addr_family_ == AF_INET ? IP_MULTICAST_LOOP: IPV6_MULTICAST_LOOP;
    728     int rv = setsockopt(socket_, protocol_level, option,
    729                         reinterpret_cast<const char*>(&loop), sizeof(loop));
    730     if (rv < 0)
    731       return MapSystemError(WSAGetLastError());
    732   }
    733   if (multicast_time_to_live_ != 1) {
    734     DWORD hops = multicast_time_to_live_;
    735     int protocol_level =
    736         addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
    737     int option =
    738         addr_family_ == AF_INET ? IP_MULTICAST_TTL: IPV6_MULTICAST_HOPS;
    739     int rv = setsockopt(socket_, protocol_level, option,
    740                         reinterpret_cast<const char*>(&hops), sizeof(hops));
    741     if (rv < 0)
    742       return MapSystemError(WSAGetLastError());
    743   }
    744   if (multicast_interface_ != 0) {
    745     switch (addr_family_) {
    746       case AF_INET: {
    747         in_addr address;
    748         address.s_addr = htonl(multicast_interface_);
    749         int rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_IF,
    750                             reinterpret_cast<const char*>(&address),
    751                             sizeof(address));
    752         if (rv)
    753           return MapSystemError(WSAGetLastError());
    754         break;
    755       }
    756       case AF_INET6: {
    757         uint32 interface_index = multicast_interface_;
    758         int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_IF,
    759                             reinterpret_cast<const char*>(&interface_index),
    760                             sizeof(interface_index));
    761         if (rv)
    762           return MapSystemError(WSAGetLastError());
    763         break;
    764       }
    765       default:
    766         NOTREACHED() << "Invalid address family";
    767         return ERR_ADDRESS_INVALID;
    768     }
    769   }
    770   return OK;
    771 }
    772 
    773 int UDPSocketWin::DoBind(const IPEndPoint& address) {
    774   SockaddrStorage storage;
    775   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
    776     return ERR_ADDRESS_INVALID;
    777   int rv = bind(socket_, storage.addr, storage.addr_len);
    778   if (rv == 0)
    779     return OK;
    780   int last_error = WSAGetLastError();
    781   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.UdpSocketBindErrorFromWinOS", last_error);
    782   // Map some codes that are special to bind() separately.
    783   // * WSAEACCES: If a port is already bound to a socket, WSAEACCES may be
    784   //   returned instead of WSAEADDRINUSE, depending on whether the socket
    785   //   option SO_REUSEADDR or SO_EXCLUSIVEADDRUSE is set and whether the
    786   //   conflicting socket is owned by a different user account. See the MSDN
    787   //   page "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" for the gory details.
    788   if (last_error == WSAEACCES || last_error == WSAEADDRNOTAVAIL)
    789     return ERR_ADDRESS_IN_USE;
    790   return MapSystemError(last_error);
    791 }
    792 
    793 int UDPSocketWin::RandomBind(const IPAddressNumber& address) {
    794   DCHECK(bind_type_ == DatagramSocket::RANDOM_BIND && !rand_int_cb_.is_null());
    795 
    796   for (int i = 0; i < kBindRetries; ++i) {
    797     int rv = DoBind(IPEndPoint(address,
    798                                rand_int_cb_.Run(kPortStart, kPortEnd)));
    799     if (rv == OK || rv != ERR_ADDRESS_IN_USE)
    800       return rv;
    801   }
    802   return DoBind(IPEndPoint(address, 0));
    803 }
    804 
    805 bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
    806   SockaddrStorage& storage = core_->recv_addr_storage_;
    807   return address->FromSockAddr(storage.addr, storage.addr_len);
    808 }
    809 
    810 int UDPSocketWin::JoinGroup(
    811     const IPAddressNumber& group_address) const {
    812   DCHECK(CalledOnValidThread());
    813   if (!is_connected())
    814     return ERR_SOCKET_NOT_CONNECTED;
    815 
    816   switch (group_address.size()) {
    817     case kIPv4AddressSize: {
    818       if (addr_family_ != AF_INET)
    819         return ERR_ADDRESS_INVALID;
    820       ip_mreq mreq;
    821       mreq.imr_interface.s_addr = htonl(multicast_interface_);
    822       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
    823       int rv = setsockopt(socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP,
    824                           reinterpret_cast<const char*>(&mreq),
    825                           sizeof(mreq));
    826       if (rv)
    827         return MapSystemError(WSAGetLastError());
    828       return OK;
    829     }
    830     case kIPv6AddressSize: {
    831       if (addr_family_ != AF_INET6)
    832         return ERR_ADDRESS_INVALID;
    833       ipv6_mreq mreq;
    834       mreq.ipv6mr_interface = multicast_interface_;
    835       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
    836       int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
    837                           reinterpret_cast<const char*>(&mreq),
    838                           sizeof(mreq));
    839       if (rv)
    840         return MapSystemError(WSAGetLastError());
    841       return OK;
    842     }
    843     default:
    844       NOTREACHED() << "Invalid address family";
    845       return ERR_ADDRESS_INVALID;
    846   }
    847 }
    848 
    849 int UDPSocketWin::LeaveGroup(
    850     const IPAddressNumber& group_address) const {
    851   DCHECK(CalledOnValidThread());
    852   if (!is_connected())
    853     return ERR_SOCKET_NOT_CONNECTED;
    854 
    855   switch (group_address.size()) {
    856     case kIPv4AddressSize: {
    857       if (addr_family_ != AF_INET)
    858         return ERR_ADDRESS_INVALID;
    859       ip_mreq mreq;
    860       mreq.imr_interface.s_addr = htonl(multicast_interface_);
    861       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
    862       int rv = setsockopt(socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP,
    863                           reinterpret_cast<const char*>(&mreq), sizeof(mreq));
    864       if (rv)
    865         return MapSystemError(WSAGetLastError());
    866       return OK;
    867     }
    868     case kIPv6AddressSize: {
    869       if (addr_family_ != AF_INET6)
    870         return ERR_ADDRESS_INVALID;
    871       ipv6_mreq mreq;
    872       mreq.ipv6mr_interface = multicast_interface_;
    873       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
    874       int rv = setsockopt(socket_, IPPROTO_IPV6, IP_DROP_MEMBERSHIP,
    875                           reinterpret_cast<const char*>(&mreq), sizeof(mreq));
    876       if (rv)
    877         return MapSystemError(WSAGetLastError());
    878       return OK;
    879     }
    880     default:
    881       NOTREACHED() << "Invalid address family";
    882       return ERR_ADDRESS_INVALID;
    883   }
    884 }
    885 
    886 int UDPSocketWin::SetMulticastInterface(uint32 interface_index) {
    887   DCHECK(CalledOnValidThread());
    888   if (is_connected())
    889     return ERR_SOCKET_IS_CONNECTED;
    890   multicast_interface_ = interface_index;
    891   return OK;
    892 }
    893 
    894 int UDPSocketWin::SetMulticastTimeToLive(int time_to_live) {
    895   DCHECK(CalledOnValidThread());
    896   if (is_connected())
    897     return ERR_SOCKET_IS_CONNECTED;
    898 
    899   if (time_to_live < 0 || time_to_live > 255)
    900     return ERR_INVALID_ARGUMENT;
    901   multicast_time_to_live_ = time_to_live;
    902   return OK;
    903 }
    904 
    905 int UDPSocketWin::SetMulticastLoopbackMode(bool loopback) {
    906   DCHECK(CalledOnValidThread());
    907   if (is_connected())
    908     return ERR_SOCKET_IS_CONNECTED;
    909 
    910   if (loopback)
    911     socket_options_ |= SOCKET_OPTION_MULTICAST_LOOP;
    912   else
    913     socket_options_ &= ~SOCKET_OPTION_MULTICAST_LOOP;
    914   return OK;
    915 }
    916 
    917 int UDPSocketWin::SetDiffServCodePoint(DiffServCodePoint dscp) {
    918   if (dscp == DSCP_NO_CHANGE) {
    919     return OK;
    920   }
    921 
    922   if (!is_connected())
    923     return ERR_SOCKET_NOT_CONNECTED;
    924 
    925   QwaveAPI& qos(QwaveAPI::Get());
    926 
    927   if (!qos.qwave_supported())
    928     return ERROR_NOT_SUPPORTED;
    929 
    930   if (qos_handle_ == NULL) {
    931     QOS_VERSION version;
    932     version.MajorVersion = 1;
    933     version.MinorVersion = 0;
    934     qos.CreateHandle(&version, &qos_handle_);
    935     if (qos_handle_ == NULL)
    936       return ERROR_NOT_SUPPORTED;
    937   }
    938 
    939   QOS_TRAFFIC_TYPE traffic_type = QOSTrafficTypeBestEffort;
    940   switch (dscp) {
    941     case DSCP_CS0:
    942       traffic_type = QOSTrafficTypeBestEffort;
    943       break;
    944     case DSCP_CS1:
    945       traffic_type = QOSTrafficTypeBackground;
    946       break;
    947     case DSCP_AF11:
    948     case DSCP_AF12:
    949     case DSCP_AF13:
    950     case DSCP_CS2:
    951     case DSCP_AF21:
    952     case DSCP_AF22:
    953     case DSCP_AF23:
    954     case DSCP_CS3:
    955     case DSCP_AF31:
    956     case DSCP_AF32:
    957     case DSCP_AF33:
    958     case DSCP_CS4:
    959       traffic_type = QOSTrafficTypeExcellentEffort;
    960       break;
    961     case DSCP_AF41:
    962     case DSCP_AF42:
    963     case DSCP_AF43:
    964     case DSCP_CS5:
    965       traffic_type = QOSTrafficTypeAudioVideo;
    966       break;
    967     case DSCP_EF:
    968     case DSCP_CS6:
    969       traffic_type = QOSTrafficTypeVoice;
    970       break;
    971     case DSCP_CS7:
    972       traffic_type = QOSTrafficTypeControl;
    973       break;
    974     case DSCP_NO_CHANGE:
    975       NOTREACHED();
    976       break;
    977   }
    978   if (qos_flow_id_ != 0) {
    979     qos.RemoveSocketFromFlow(qos_handle_, NULL, qos_flow_id_, 0);
    980     qos_flow_id_ = 0;
    981   }
    982   if (!qos.AddSocketToFlow(qos_handle_,
    983                            socket_,
    984                            NULL,
    985                            traffic_type,
    986                            QOS_NON_ADAPTIVE_FLOW,
    987                            &qos_flow_id_)) {
    988     DWORD err = GetLastError();
    989     if (err == ERROR_DEVICE_REINITIALIZATION_NEEDED) {
    990       qos.CloseHandle(qos_handle_);
    991       qos_flow_id_ = 0;
    992       qos_handle_ = 0;
    993     }
    994     return MapSystemError(err);
    995   }
    996   // This requires admin rights, and may fail, if so we ignore it
    997   // as AddSocketToFlow should still do *approximately* the right thing.
    998   DWORD buf = dscp;
    999   qos.SetFlow(qos_handle_,
   1000               qos_flow_id_,
   1001               QOSSetOutgoingDSCPValue,
   1002               sizeof(buf),
   1003               &buf,
   1004               0,
   1005               NULL);
   1006 
   1007   return OK;
   1008 }
   1009 
   1010 void UDPSocketWin::DetachFromThread() {
   1011   base::NonThreadSafe::DetachFromThread();
   1012 }
   1013 
   1014 }  // namespace net
   1015