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
27namespace {
28
29const int kBindRetries = 10;
30const int kPortStart = 1024;
31const int kPortEnd = 65535;
32
33}  // namespace
34
35namespace 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.
42class 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
109UDPSocketWin::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
120UDPSocketWin::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
131void 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
138void 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
145void 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
153void 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
162QwaveAPI::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
183QwaveAPI& QwaveAPI::Get() {
184  static base::LazyInstance<QwaveAPI>::Leaky lazy_qwave =
185    LAZY_INSTANCE_INITIALIZER;
186  return lazy_qwave.Get();
187}
188
189bool QwaveAPI::qwave_supported() const {
190  return qwave_supported_;
191}
192BOOL QwaveAPI::CreateHandle(PQOS_VERSION version, PHANDLE handle) {
193  return create_handle_func_(version, handle);
194}
195BOOL QwaveAPI::CloseHandle(HANDLE handle) {
196  return close_handle_func_(handle);
197}
198
199BOOL 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
213BOOL 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
220BOOL 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
239UDPSocketWin::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
261UDPSocketWin::~UDPSocketWin() {
262  Close();
263  net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
264}
265
266void 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
292int 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
313int 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
336int UDPSocketWin::Read(IOBuffer* buf,
337                       int buf_len,
338                       const CompletionCallback& callback) {
339  return RecvFrom(buf, buf_len, NULL, callback);
340}
341
342int 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
362int UDPSocketWin::Write(IOBuffer* buf,
363                        int buf_len,
364                        const CompletionCallback& callback) {
365  return SendToOrWrite(buf, buf_len, NULL, callback);
366}
367
368int 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
375int 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
396int 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
406int 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
446int 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
465int 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
474int 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
496int 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
517void UDPSocketWin::AllowAddressReuse() {
518  DCHECK(CalledOnValidThread());
519  DCHECK(!is_connected());
520
521  socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
522}
523
524void UDPSocketWin::AllowBroadcast() {
525  DCHECK(CalledOnValidThread());
526  DCHECK(!is_connected());
527
528  socket_options_ |= SOCKET_OPTION_BROADCAST;
529}
530
531void 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
541void 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
551void 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
568void 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
589void 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
602void 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
620int 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
660int 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
706int 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
773int 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
793int 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
805bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
806  SockaddrStorage& storage = core_->recv_addr_storage_;
807  return address->FromSockAddr(storage.addr, storage.addr_len);
808}
809
810int 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
849int 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
886int 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
894int 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
905int 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
917int 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
1010void UDPSocketWin::DetachFromThread() {
1011  base::NonThreadSafe::DetachFromThread();
1012}
1013
1014}  // namespace net
1015