net/udp/udp_socket_win.cc

   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/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/metrics/stats_counters.h"
  14 #include "base/posix/eintr_wrapper.h"
  15 #include "base/rand_util.h"
  16 #include "net/base/io_buffer.h"
  17 #include "net/base/ip_endpoint.h"
  18 #include "net/base/net_errors.h"
  19 #include "net/base/net_log.h"
  20 #include "net/base/net_util.h"
  21 #include "net/base/winsock_init.h"
  22 #include "net/base/winsock_util.h"
  23 #include "net/udp/udp_net_log_parameters.h"
  24
  25 namespace {
  26
  27 const int kBindRetries = 10;
  28 const int kPortStart = 1024;
  29 const int kPortEnd = 65535;
  30
  31 }  // namespace
  32
  33 namespace net {
  34
  35 // This class encapsulates all the state that has to be preserved as long as
  36 // there is a network IO operation in progress. If the owner UDPSocketWin
  37 // is destroyed while an operation is in progress, the Core is detached and it
  38 // lives until the operation completes and the OS doesn't reference any resource
  39 // declared on this class anymore.
  40 class UDPSocketWin::Core : public base::RefCounted<Core> {
  41  public:
  42   explicit Core(UDPSocketWin* socket);
  43
  44   // Start watching for the end of a read or write operation.
  45   void WatchForRead();
  46   void WatchForWrite();
  47
  48   // The UDPSocketWin is going away.
  49   void Detach() { socket_ = NULL; }
  50
  51   // The separate OVERLAPPED variables for asynchronous operation.
  52   OVERLAPPED read_overlapped_;
  53   OVERLAPPED write_overlapped_;
  54
  55   // The buffers used in Read() and Write().
  56   scoped_refptr<IOBuffer> read_iobuffer_;
  57   scoped_refptr<IOBuffer> write_iobuffer_;
  58
  59   // The address storage passed to WSARecvFrom().
  60   SockaddrStorage recv_addr_storage_;
  61
  62  private:
  63   friend class base::RefCounted<Core>;
  64
  65   class ReadDelegate : public base::win::ObjectWatcher::Delegate {
  66    public:
  67     explicit ReadDelegate(Core* core) : core_(core) {}
  68     virtual ~ReadDelegate() {}
  69
  70     // base::ObjectWatcher::Delegate methods:
  71     virtual void OnObjectSignaled(HANDLE object);
  72
  73    private:
  74     Core* const core_;
  75   };
  76
  77   class WriteDelegate : public base::win::ObjectWatcher::Delegate {
  78    public:
  79     explicit WriteDelegate(Core* core) : core_(core) {}
  80     virtual ~WriteDelegate() {}
  81
  82     // base::ObjectWatcher::Delegate methods:
  83     virtual void OnObjectSignaled(HANDLE object);
  84
  85    private:
  86     Core* const core_;
  87   };
  88
  89   ~Core();
  90
  91   // The socket that created this object.
  92   UDPSocketWin* socket_;
  93
  94   // |reader_| handles the signals from |read_watcher_|.
  95   ReadDelegate reader_;
  96   // |writer_| handles the signals from |write_watcher_|.
  97   WriteDelegate writer_;
  98
  99   // |read_watcher_| watches for events from Read().
 100   base::win::ObjectWatcher read_watcher_;
 101   // |write_watcher_| watches for events from Write();
 102   base::win::ObjectWatcher write_watcher_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(Core);
 105 };
 106
 107 UDPSocketWin::Core::Core(UDPSocketWin* socket)
 108     : socket_(socket),
 109       reader_(this),
 110       writer_(this) {
 111   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
 112   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
 113
 114   read_overlapped_.hEvent = WSACreateEvent();
 115   write_overlapped_.hEvent = WSACreateEvent();
 116 }
 117
 118 UDPSocketWin::Core::~Core() {
 119   // Make sure the message loop is not watching this object anymore.
 120   read_watcher_.StopWatching();
 121   write_watcher_.StopWatching();
 122
 123   WSACloseEvent(read_overlapped_.hEvent);
 124   memset(&read_overlapped_, 0xaf, sizeof(read_overlapped_));
 125   WSACloseEvent(write_overlapped_.hEvent);
 126   memset(&write_overlapped_, 0xaf, sizeof(write_overlapped_));
 127 }
 128
 129 void UDPSocketWin::Core::WatchForRead() {
 130   // We grab an extra reference because there is an IO operation in progress.
 131   // Balanced in ReadDelegate::OnObjectSignaled().
 132   AddRef();
 133   read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_);
 134 }
 135
 136 void UDPSocketWin::Core::WatchForWrite() {
 137   // We grab an extra reference because there is an IO operation in progress.
 138   // Balanced in WriteDelegate::OnObjectSignaled().
 139   AddRef();
 140   write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_);
 141 }
 142
 143 void UDPSocketWin::Core::ReadDelegate::OnObjectSignaled(HANDLE object) {
 144   DCHECK_EQ(object, core_->read_overlapped_.hEvent);
 145   if (core_->socket_)
 146     core_->socket_->DidCompleteRead();
 147
 148   core_->Release();
 149 }
 150
 151 void UDPSocketWin::Core::WriteDelegate::OnObjectSignaled(HANDLE object) {
 152   DCHECK_EQ(object, core_->write_overlapped_.hEvent);
 153   if (core_->socket_)
 154     core_->socket_->DidCompleteWrite();
 155
 156   core_->Release();
 157 }
 158
 159 //-----------------------------------------------------------------------------
 160
 161 UDPSocketWin::UDPSocketWin(DatagramSocket::BindType bind_type,
 162                            const RandIntCallback& rand_int_cb,
 163                            net::NetLog* net_log,
 164                            const net::NetLog::Source& source)
 165     : socket_(INVALID_SOCKET),
 166       addr_family_(0),
 167       socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
 168       multicast_time_to_live_(1),
 169       bind_type_(bind_type),
 170       rand_int_cb_(rand_int_cb),
 171       recv_from_address_(NULL),
 172       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
 173   EnsureWinsockInit();
 174   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
 175                       source.ToEventParametersCallback());
 176   if (bind_type == DatagramSocket::RANDOM_BIND)
 177     DCHECK(!rand_int_cb.is_null());
 178 }
 179
 180 UDPSocketWin::~UDPSocketWin() {
 181   Close();
 182   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 183 }
 184
 185 void UDPSocketWin::Close() {
 186   DCHECK(CalledOnValidThread());
 187
 188   if (!is_connected())
 189     return;
 190
 191   // Zero out any pending read/write callback state.
 192   read_callback_.Reset();
 193   recv_from_address_ = NULL;
 194   write_callback_.Reset();
 195
 196   base::TimeTicks start_time = base::TimeTicks::Now();
 197   closesocket(socket_);
 198   UMA_HISTOGRAM_TIMES("Net.UDPSocketWinClose",
 199                       base::TimeTicks::Now() - start_time);
 200   socket_ = INVALID_SOCKET;
 201   addr_family_ = 0;
 202
 203   core_->Detach();
 204   core_ = NULL;
 205 }
 206
 207 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
 208   DCHECK(CalledOnValidThread());
 209   DCHECK(address);
 210   if (!is_connected())
 211     return ERR_SOCKET_NOT_CONNECTED;
 212
 213   // TODO(szym): Simplify. http://crbug.com/126152
 214   if (!remote_address_.get()) {
 215     SockaddrStorage storage;
 216     if (getpeername(socket_, storage.addr, &storage.addr_len))
 217       return MapSystemError(WSAGetLastError());
 218     scoped_ptr<IPEndPoint> address(new IPEndPoint());
 219     if (!address->FromSockAddr(storage.addr, storage.addr_len))
 220       return ERR_ADDRESS_INVALID;
 221     remote_address_.reset(address.release());
 222   }
 223
 224   *address = *remote_address_;
 225   return OK;
 226 }
 227
 228 int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
 229   DCHECK(CalledOnValidThread());
 230   DCHECK(address);
 231   if (!is_connected())
 232     return ERR_SOCKET_NOT_CONNECTED;
 233
 234   // TODO(szym): Simplify. http://crbug.com/126152
 235   if (!local_address_.get()) {
 236     SockaddrStorage storage;
 237     if (getsockname(socket_, storage.addr, &storage.addr_len))
 238       return MapSystemError(WSAGetLastError());
 239     scoped_ptr<IPEndPoint> address(new IPEndPoint());
 240     if (!address->FromSockAddr(storage.addr, storage.addr_len))
 241       return ERR_ADDRESS_INVALID;
 242     local_address_.reset(address.release());
 243     net_log_.AddEvent(NetLog::TYPE_UDP_LOCAL_ADDRESS,
 244                       CreateNetLogUDPConnectCallback(local_address_.get()));
 245   }
 246
 247   *address = *local_address_;
 248   return OK;
 249 }
 250
 251 int UDPSocketWin::Read(IOBuffer* buf,
 252                        int buf_len,
 253                        const CompletionCallback& callback) {
 254   return RecvFrom(buf, buf_len, NULL, callback);
 255 }
 256
 257 int UDPSocketWin::RecvFrom(IOBuffer* buf,
 258                            int buf_len,
 259                            IPEndPoint* address,
 260                            const CompletionCallback& callback) {
 261   DCHECK(CalledOnValidThread());
 262   DCHECK_NE(INVALID_SOCKET, socket_);
 263   DCHECK(read_callback_.is_null());
 264   DCHECK(!recv_from_address_);
 265   DCHECK(!callback.is_null());  // Synchronous operation not supported.
 266   DCHECK_GT(buf_len, 0);
 267
 268   int nread = InternalRecvFrom(buf, buf_len, address);
 269   if (nread != ERR_IO_PENDING)
 270     return nread;
 271
 272   read_callback_ = callback;
 273   recv_from_address_ = address;
 274   return ERR_IO_PENDING;
 275 }
 276
 277 int UDPSocketWin::Write(IOBuffer* buf,
 278                         int buf_len,
 279                         const CompletionCallback& callback) {
 280   return SendToOrWrite(buf, buf_len, NULL, callback);
 281 }
 282
 283 int UDPSocketWin::SendTo(IOBuffer* buf,
 284                          int buf_len,
 285                          const IPEndPoint& address,
 286                          const CompletionCallback& callback) {
 287   return SendToOrWrite(buf, buf_len, &address, callback);
 288 }
 289
 290 int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
 291                                 int buf_len,
 292                                 const IPEndPoint* address,
 293                                 const CompletionCallback& callback) {
 294   DCHECK(CalledOnValidThread());
 295   DCHECK_NE(INVALID_SOCKET, socket_);
 296   DCHECK(write_callback_.is_null());
 297   DCHECK(!callback.is_null());  // Synchronous operation not supported.
 298   DCHECK_GT(buf_len, 0);
 299   DCHECK(!send_to_address_.get());
 300
 301   int nwrite = InternalSendTo(buf, buf_len, address);
 302   if (nwrite != ERR_IO_PENDING)
 303     return nwrite;
 304
 305   if (address)
 306     send_to_address_.reset(new IPEndPoint(*address));
 307   write_callback_ = callback;
 308   return ERR_IO_PENDING;
 309 }
 310
 311 int UDPSocketWin::Connect(const IPEndPoint& address) {
 312   net_log_.BeginEvent(NetLog::TYPE_UDP_CONNECT,
 313                       CreateNetLogUDPConnectCallback(&address));
 314   int rv = InternalConnect(address);
 315   if (rv != OK)
 316     Close();
 317   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_UDP_CONNECT, rv);
 318   return rv;
 319 }
 320
 321 int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
 322   DCHECK(!is_connected());
 323   DCHECK(!remote_address_.get());
 324   int rv = CreateSocket(address);
 325   if (rv < 0)
 326     return rv;
 327
 328   if (bind_type_ == DatagramSocket::RANDOM_BIND)
 329     rv = RandomBind(address);
 330   // else connect() does the DatagramSocket::DEFAULT_BIND
 331
 332   if (rv < 0) {
 333     Close();
 334     return rv;
 335   }
 336
 337   SockaddrStorage storage;
 338   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
 339     return ERR_ADDRESS_INVALID;
 340
 341   rv = connect(socket_, storage.addr, storage.addr_len);
 342   if (rv < 0) {
 343     // Close() may change the last error. Map it beforehand.
 344     int result = MapSystemError(WSAGetLastError());
 345     Close();
 346     return result;
 347   }
 348
 349   remote_address_.reset(new IPEndPoint(address));
 350   return rv;
 351 }
 352
 353 int UDPSocketWin::Bind(const IPEndPoint& address) {
 354   DCHECK(!is_connected());
 355   int rv = CreateSocket(address);
 356   if (rv < 0)
 357     return rv;
 358   rv = SetSocketOptions();
 359   if (rv < 0) {
 360     Close();
 361     return rv;
 362   }
 363   rv = DoBind(address);
 364   if (rv < 0) {
 365     Close();
 366     return rv;
 367   }
 368   local_address_.reset();
 369   return rv;
 370 }
 371
 372 int UDPSocketWin::CreateSocket(const IPEndPoint& address) {
 373   addr_family_ = address.GetSockAddrFamily();
 374   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
 375   if (socket_ == INVALID_SOCKET)
 376     return MapSystemError(WSAGetLastError());
 377   core_ = new Core(this);
 378   return OK;
 379 }
 380
 381 bool UDPSocketWin::SetReceiveBufferSize(int32 size) {
 382   DCHECK(CalledOnValidThread());
 383   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
 384                       reinterpret_cast<const char*>(&size), sizeof(size));
 385   DCHECK(!rv) << "Could not set socket receive buffer size: " << errno;
 386   return rv == 0;
 387 }
 388
 389 bool UDPSocketWin::SetSendBufferSize(int32 size) {
 390   DCHECK(CalledOnValidThread());
 391   int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
 392                       reinterpret_cast<const char*>(&size), sizeof(size));
 393   DCHECK(!rv) << "Could not set socket send buffer size: " << errno;
 394   return rv == 0;
 395 }
 396
 397 void UDPSocketWin::AllowAddressReuse() {
 398   DCHECK(CalledOnValidThread());
 399   DCHECK(!is_connected());
 400
 401   socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
 402 }
 403
 404 void UDPSocketWin::AllowBroadcast() {
 405   DCHECK(CalledOnValidThread());
 406   DCHECK(!is_connected());
 407
 408   socket_options_ |= SOCKET_OPTION_BROADCAST;
 409 }
 410
 411 void UDPSocketWin::DoReadCallback(int rv) {
 412   DCHECK_NE(rv, ERR_IO_PENDING);
 413   DCHECK(!read_callback_.is_null());
 414
 415   // since Run may result in Read being called, clear read_callback_ up front.
 416   CompletionCallback c = read_callback_;
 417   read_callback_.Reset();
 418   c.Run(rv);
 419 }
 420
 421 void UDPSocketWin::DoWriteCallback(int rv) {
 422   DCHECK_NE(rv, ERR_IO_PENDING);
 423   DCHECK(!write_callback_.is_null());
 424
 425   // since Run may result in Write being called, clear write_callback_ up front.
 426   CompletionCallback c = write_callback_;
 427   write_callback_.Reset();
 428   c.Run(rv);
 429 }
 430
 431 void UDPSocketWin::DidCompleteRead() {
 432   DWORD num_bytes, flags;
 433   BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
 434                                    &num_bytes, FALSE, &flags);
 435   WSAResetEvent(core_->read_overlapped_.hEvent);
 436   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
 437   // Convert address.
 438   if (recv_from_address_ && result >= 0) {
 439     if (!ReceiveAddressToIPEndpoint(recv_from_address_))
 440       result = ERR_ADDRESS_INVALID;
 441   }
 442   LogRead(result, core_->read_iobuffer_->data());
 443   core_->read_iobuffer_ = NULL;
 444   recv_from_address_ = NULL;
 445   DoReadCallback(result);
 446 }
 447
 448 void UDPSocketWin::LogRead(int result, const char* bytes) const {
 449   if (result < 0) {
 450     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, result);
 451     return;
 452   }
 453
 454   if (net_log_.IsLoggingAllEvents()) {
 455     // Get address for logging, if |address| is NULL.
 456     IPEndPoint address;
 457     bool is_address_valid = ReceiveAddressToIPEndpoint(&address);
 458     net_log_.AddEvent(
 459         NetLog::TYPE_UDP_BYTES_RECEIVED,
 460         CreateNetLogUDPDataTranferCallback(
 461             result, bytes,
 462             is_address_valid ? &address : NULL));
 463   }
 464
 465   base::StatsCounter read_bytes("udp.read_bytes");
 466   read_bytes.Add(result);
 467 }
 468
 469 void UDPSocketWin::DidCompleteWrite() {
 470   DWORD num_bytes, flags;
 471   BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
 472                                    &num_bytes, FALSE, &flags);
 473   WSAResetEvent(core_->write_overlapped_.hEvent);
 474   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
 475   LogWrite(result, core_->write_iobuffer_->data(), send_to_address_.get());
 476
 477   send_to_address_.reset();
 478   core_->write_iobuffer_ = NULL;
 479   DoWriteCallback(result);
 480 }
 481
 482 void UDPSocketWin::LogWrite(int result,
 483                             const char* bytes,
 484                             const IPEndPoint* address) const {
 485   if (result < 0) {
 486     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, result);
 487     return;
 488   }
 489
 490   if (net_log_.IsLoggingAllEvents()) {
 491     net_log_.AddEvent(
 492         NetLog::TYPE_UDP_BYTES_SENT,
 493         CreateNetLogUDPDataTranferCallback(result, bytes, address));
 494   }
 495
 496   base::StatsCounter write_bytes("udp.write_bytes");
 497   write_bytes.Add(result);
 498 }
 499
 500 int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
 501                                    IPEndPoint* address) {
 502   DCHECK(!core_->read_iobuffer_);
 503   SockaddrStorage& storage = core_->recv_addr_storage_;
 504   storage.addr_len = sizeof(storage.addr_storage);
 505
 506   WSABUF read_buffer;
 507   read_buffer.buf = buf->data();
 508   read_buffer.len = buf_len;
 509
 510   DWORD flags = 0;
 511   DWORD num;
 512   CHECK_NE(INVALID_SOCKET, socket_);
 513   AssertEventNotSignaled(core_->read_overlapped_.hEvent);
 514   int rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr,
 515                        &storage.addr_len, &core_->read_overlapped_, NULL);
 516   if (rv == 0) {
 517     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
 518       int result = num;
 519       // Convert address.
 520       if (address && result >= 0) {
 521         if (!ReceiveAddressToIPEndpoint(address))
 522           result = ERR_FAILED;
 523       }
 524       LogRead(result, buf->data());
 525       return result;
 526     }
 527   } else {
 528     int os_error = WSAGetLastError();
 529     if (os_error != WSA_IO_PENDING) {
 530       int result = MapSystemError(os_error);
 531       LogRead(result, NULL);
 532       return result;
 533     }
 534   }
 535   core_->WatchForRead();
 536   core_->read_iobuffer_ = buf;
 537   return ERR_IO_PENDING;
 538 }
 539
 540 int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
 541                                  const IPEndPoint* address) {
 542   DCHECK(!core_->write_iobuffer_);
 543   SockaddrStorage storage;
 544   struct sockaddr* addr = storage.addr;
 545   // Convert address.
 546   if (!address) {
 547     addr = NULL;
 548     storage.addr_len = 0;
 549   } else {
 550     if (!address->ToSockAddr(addr, &storage.addr_len)) {
 551       int result = ERR_FAILED;
 552       LogWrite(result, NULL, NULL);
 553       return result;
 554     }
 555   }
 556
 557   WSABUF write_buffer;
 558   write_buffer.buf = buf->data();
 559   write_buffer.len = buf_len;
 560
 561   DWORD flags = 0;
 562   DWORD num;
 563   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
 564   int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags,
 565                      addr, storage.addr_len, &core_->write_overlapped_, NULL);
 566   if (rv == 0) {
 567     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
 568       int result = num;
 569       LogWrite(result, buf->data(), address);
 570       return result;
 571     }
 572   } else {
 573     int os_error = WSAGetLastError();
 574     if (os_error != WSA_IO_PENDING) {
 575       int result = MapSystemError(os_error);
 576       LogWrite(result, NULL, NULL);
 577       return result;
 578     }
 579   }
 580
 581   core_->WatchForWrite();
 582   core_->write_iobuffer_ = buf;
 583   return ERR_IO_PENDING;
 584 }
 585
 586 int UDPSocketWin::SetSocketOptions() {
 587   BOOL true_value = 1;
 588   if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
 589     int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
 590                         reinterpret_cast<const char*>(&true_value),
 591                         sizeof(true_value));
 592     if (rv < 0)
 593       return MapSystemError(WSAGetLastError());
 594   }
 595   if (socket_options_ & SOCKET_OPTION_BROADCAST) {
 596     int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
 597                         reinterpret_cast<const char*>(&true_value),
 598                         sizeof(true_value));
 599     if (rv < 0)
 600       return MapSystemError(WSAGetLastError());
 601   }
 602   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
 603     DWORD loop = 0;
 604     int protocol_level =
 605         addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
 606     int option =
 607         addr_family_ == AF_INET ? IP_MULTICAST_LOOP: IPV6_MULTICAST_LOOP;
 608     int rv = setsockopt(socket_, protocol_level, option,
 609                         reinterpret_cast<const char*>(&loop), sizeof(loop));
 610     if (rv < 0)
 611       return MapSystemError(WSAGetLastError());
 612   }
 613   if (multicast_time_to_live_ != 1) {
 614     DWORD hops = multicast_time_to_live_;
 615     int protocol_level =
 616         addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
 617     int option =
 618         addr_family_ == AF_INET ? IP_MULTICAST_TTL: IPV6_MULTICAST_HOPS;
 619     int rv = setsockopt(socket_, protocol_level, option,
 620                         reinterpret_cast<const char*>(&hops), sizeof(hops));
 621     if (rv < 0)
 622       return MapSystemError(WSAGetLastError());
 623   }
 624   return OK;
 625 }
 626
 627 int UDPSocketWin::DoBind(const IPEndPoint& address) {
 628   SockaddrStorage storage;
 629   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
 630     return ERR_ADDRESS_INVALID;
 631   int rv = bind(socket_, storage.addr, storage.addr_len);
 632   return rv < 0 ? MapSystemError(WSAGetLastError()) : rv;
 633 }
 634
 635 int UDPSocketWin::RandomBind(const IPEndPoint& address) {
 636   DCHECK(bind_type_ == DatagramSocket::RANDOM_BIND && !rand_int_cb_.is_null());
 637
 638   // Construct IPAddressNumber of appropriate size (IPv4 or IPv6) of 0s.
 639   IPAddressNumber ip(address.address().size());
 640
 641   for (int i = 0; i < kBindRetries; ++i) {
 642     int rv = DoBind(IPEndPoint(ip, rand_int_cb_.Run(kPortStart, kPortEnd)));
 643     if (rv == OK || rv != ERR_ADDRESS_IN_USE)
 644       return rv;
 645   }
 646   return DoBind(IPEndPoint(ip, 0));
 647 }
 648
 649 bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
 650   SockaddrStorage& storage = core_->recv_addr_storage_;
 651   return address->FromSockAddr(storage.addr, storage.addr_len);
 652 }
 653
 654 int UDPSocketWin::JoinGroup(
 655     const IPAddressNumber& group_address) const {
 656   DCHECK(CalledOnValidThread());
 657   if (!is_connected())
 658     return ERR_SOCKET_NOT_CONNECTED;
 659
 660   switch (group_address.size()) {
 661     case kIPv4AddressSize: {
 662       if (addr_family_ != AF_INET)
 663         return ERR_ADDRESS_INVALID;
 664       ip_mreq mreq;
 665       mreq.imr_interface.s_addr = INADDR_ANY;
 666       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
 667       int rv = setsockopt(socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 668                           reinterpret_cast<const char*>(&mreq),
 669                           sizeof(mreq));
 670       if (rv)
 671         return MapSystemError(WSAGetLastError());
 672       return OK;
 673     }
 674     case kIPv6AddressSize: {
 675       if (addr_family_ != AF_INET6)
 676         return ERR_ADDRESS_INVALID;
 677       ipv6_mreq mreq;
 678       mreq.ipv6mr_interface = 0;  // 0 indicates default multicast interface.
 679       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
 680       int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
 681                           reinterpret_cast<const char*>(&mreq),
 682                           sizeof(mreq));
 683       if (rv)
 684         return MapSystemError(WSAGetLastError());
 685       return OK;
 686     }
 687     default:
 688       NOTREACHED() << "Invalid address family";
 689       return ERR_ADDRESS_INVALID;
 690   }
 691 }
 692
 693 int UDPSocketWin::LeaveGroup(
 694     const IPAddressNumber& group_address) const {
 695   DCHECK(CalledOnValidThread());
 696   if (!is_connected())
 697     return ERR_SOCKET_NOT_CONNECTED;
 698
 699   switch (group_address.size()) {
 700     case kIPv4AddressSize: {
 701       if (addr_family_ != AF_INET)
 702         return ERR_ADDRESS_INVALID;
 703       ip_mreq mreq;
 704       mreq.imr_interface.s_addr = INADDR_ANY;
 705       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
 706       int rv = setsockopt(socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP,
 707                       reinterpret_cast<const char*>(&mreq),
 708                       sizeof(mreq));
 709       if (rv)
 710         return MapSystemError(WSAGetLastError());
 711       return OK;
 712     }
 713     case kIPv6AddressSize: {
 714       if (addr_family_ != AF_INET6)
 715         return ERR_ADDRESS_INVALID;
 716       ipv6_mreq mreq;
 717       mreq.ipv6mr_interface = 0;  // 0 indicates default multicast interface.
 718       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
 719       int rv = setsockopt(socket_, IPPROTO_IPV6, IP_DROP_MEMBERSHIP,
 720                       reinterpret_cast<const char*>(&mreq),
 721                       sizeof(mreq));
 722       if (rv)
 723         return MapSystemError(WSAGetLastError());
 724       return OK;
 725     }
 726     default:
 727       NOTREACHED() << "Invalid address family";
 728       return ERR_ADDRESS_INVALID;
 729   }
 730 }
 731
 732 int UDPSocketWin::SetMulticastTimeToLive(int time_to_live) {
 733   DCHECK(CalledOnValidThread());
 734   if (is_connected())
 735     return ERR_SOCKET_IS_CONNECTED;
 736
 737   if (time_to_live < 0 || time_to_live > 255)
 738     return ERR_INVALID_ARGUMENT;
 739   multicast_time_to_live_ = time_to_live;
 740   return OK;
 741 }
 742
 743 int UDPSocketWin::SetMulticastLoopbackMode(bool loopback) {
 744   DCHECK(CalledOnValidThread());
 745   if (is_connected())
 746     return ERR_SOCKET_IS_CONNECTED;
 747
 748   if (loopback)
 749     socket_options_ |= SOCKET_OPTION_MULTICAST_LOOP;
 750   else
 751     socket_options_ &= ~SOCKET_OPTION_MULTICAST_LOOP;
 752   return OK;
 753 }
 754
 755 }  // namespace net