Remove timing limitation to set Broadcast, ReceiveBuffer, and SendBuffer options from UDPSocket.

net/udp/udp_socket_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/udp/udp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
@@ skipping 237 matching lines @@
 
 
 //-----------------------------------------------------------------------------
 
 UDPSocketWin::UDPSocketWin(DatagramSocket::BindType bind_type,
                            const RandIntCallback& rand_int_cb,
                            net::NetLog* net_log,
                            const net::NetLog::Source& source)
     : socket_(INVALID_SOCKET),
       addr_family_(0),
+      is_connected_(false),
       socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
       multicast_interface_(0),
       multicast_time_to_live_(1),
       bind_type_(bind_type),
       rand_int_cb_(rand_int_cb),
       recv_from_address_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)),
       qos_handle_(NULL),
       qos_flow_id_(0) {
   EnsureWinsockInit();
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketWin::~UDPSocketWin() {
   Close();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
+int UDPSocketWin::Open(AddressFamily address_family) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(socket_, INVALID_SOCKET);
+
+  addr_family_ = ConvertAddressFamily(address_family);
+  socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
+  if (socket_ == INVALID_SOCKET)
+    return MapSystemError(WSAGetLastError());
+  core_ = new Core(this);
+  return OK;
+}
+
 void UDPSocketWin::Close() {
   DCHECK(CalledOnValidThread());
 
-  if (!is_connected())
+  if (socket_ == INVALID_SOCKET)
     return;
 
   if (qos_handle_) {
     QwaveAPI::Get().CloseHandle(qos_handle_);
   }
 
   // Zero out any pending read/write callback state.
   read_callback_.Reset();
   recv_from_address_ = NULL;
   write_callback_.Reset();
 
   base::TimeTicks start_time = base::TimeTicks::Now();
   closesocket(socket_);
   UMA_HISTOGRAM_TIMES("Net.UDPSocketWinClose",
                       base::TimeTicks::Now() - start_time);
   socket_ = INVALID_SOCKET;
   addr_family_ = 0;
+  is_connected_ = false;
 
   core_->Detach();
   core_ = NULL;
 }
 
 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
@@ skipping 90 matching lines @@
   if (nwrite != ERR_IO_PENDING)
     return nwrite;
 
   if (address)
     send_to_address_.reset(new IPEndPoint(*address));
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::Connect(const IPEndPoint& address) {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   net_log_.BeginEvent(NetLog::TYPE_UDP_CONNECT,
                       CreateNetLogUDPConnectCallback(&address));
   int rv = InternalConnect(address);
-  if (rv != OK)
-    Close();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_UDP_CONNECT, rv);
+  is_connected_ = (rv == OK);
   return rv;
 }
 
 int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
   DCHECK(!is_connected());
   DCHECK(!remote_address_.get());
-  int addr_family = address.GetSockAddrFamily();
-  int rv = CreateSocket(addr_family);
-  if (rv < 0)
-    return rv;
 
+  int rv = 0;
   if (bind_type_ == DatagramSocket::RANDOM_BIND) {
     // Construct IPAddressNumber of appropriate size (IPv4 or IPv6) of 0s,
     // representing INADDR_ANY or in6addr_any.
-    size_t addr_size =
-        addr_family == AF_INET ? kIPv4AddressSize : kIPv6AddressSize;
+    size_t addr_size = (address.GetSockAddrFamily() == AF_INET) ?
+        kIPv4AddressSize : kIPv6AddressSize;
     IPAddressNumber addr_any(addr_size);
     rv = RandomBind(addr_any);
   }
   // else connect() does the DatagramSocket::DEFAULT_BIND
 
   if (rv < 0) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.UdpSocketRandomBindErrorCode", -rv);
-    Close();
     return rv;
   }
 
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
   rv = connect(socket_, storage.addr, storage.addr_len);
-  if (rv < 0) {
-    // Close() may change the last error. Map it beforehand.
-    int result = MapSystemError(WSAGetLastError());
-    Close();
-    return result;
-  }
+  if (rv < 0)
+    return MapSystemError(WSAGetLastError());
 
   remote_address_.reset(new IPEndPoint(address));
   return rv;
 }
 
 int UDPSocketWin::Bind(const IPEndPoint& address) {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!is_connected());
-  int rv = CreateSocket(address.GetSockAddrFamily());
+
+  int rv = SetMulticastOptions();
   if (rv < 0)
     return rv;
-  rv = SetSocketOptions();
-  if (rv < 0) {
-    Close();
+
+  rv = DoBind(address);
+  if (rv < 0)
     return rv;
-  }
-  rv = DoBind(address);
-  if (rv < 0) {
-    Close();
-    return rv;
-  }
+
   local_address_.reset();
+  is_connected_ = true;
   return rv;
 }
 
-int UDPSocketWin::CreateSocket(int addr_family) {
-  addr_family_ = addr_family;
-  socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
-  if (socket_ == INVALID_SOCKET)
-    return MapSystemError(WSAGetLastError());
-  core_ = new Core(this);
-  return OK;
-}
-
 int UDPSocketWin::SetReceiveBufferSize(int32 size) {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
 
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32 actual_size = 0;
   int option_size = sizeof(actual_size);
   rv = getsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
                   reinterpret_cast<char*>(&actual_size), &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableReceiveBuffer",
                               actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE;
 }
 
 int UDPSocketWin::SetSendBufferSize(int32 size) {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32 actual_size = 0;
   int option_size = sizeof(actual_size);
   rv = getsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
                   reinterpret_cast<char*>(&actual_size), &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableSendBuffer",
                               actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE;
 }
 
-void UDPSocketWin::AllowAddressReuse() {
+int UDPSocketWin::AllowAddressReuse() {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(CalledOnValidThread());
   DCHECK(!is_connected());
 
-  socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+  BOOL true_value = TRUE;
+  int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
+                      reinterpret_cast<const char*>(&true_value),
+                      sizeof(true_value));
+  return rv == 0 ? OK : MapSystemError(WSAGetLastError());
 }
 
-void UDPSocketWin::AllowBroadcast() {
+int UDPSocketWin::SetBroadcast(bool broadcast) {
+  DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(CalledOnValidThread());
-  DCHECK(!is_connected());
 
-  socket_options_ |= SOCKET_OPTION_BROADCAST;
+  BOOL value = broadcast ? TRUE : FALSE;
+  int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
+                      reinterpret_cast<const char*>(&value), sizeof(value));
+  return rv == 0 ? OK : MapSystemError(WSAGetLastError());
 }
 
 void UDPSocketWin::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   DCHECK(!read_callback_.is_null());
 
   // since Run may result in Read being called, clear read_callback_ up front.
   CompletionCallback c = read_callback_;
   read_callback_.Reset();
   c.Run(rv);
@@ skipping 159 matching lines @@
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
   core_->WatchForWrite();
   core_->write_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
-int UDPSocketWin::SetSocketOptions() {
-  BOOL true_value = 1;
-  if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
-                        reinterpret_cast<const char*>(&true_value),
-                        sizeof(true_value));
-    if (rv < 0)
-      return MapSystemError(WSAGetLastError());
-  }
-  if (socket_options_ & SOCKET_OPTION_BROADCAST) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
-                        reinterpret_cast<const char*>(&true_value),
-                        sizeof(true_value));
-    if (rv < 0)
-      return MapSystemError(WSAGetLastError());
-  }
+int UDPSocketWin::SetMulticastOptions() {
   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
     DWORD loop = 0;
     int protocol_level =
         addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
     int option =
         addr_family_ == AF_INET ? IP_MULTICAST_LOOP: IPV6_MULTICAST_LOOP;
     int rv = setsockopt(socket_, protocol_level, option,
                         reinterpret_cast<const char*>(&loop), sizeof(loop));
     if (rv < 0)
       return MapSystemError(WSAGetLastError());
@@ skipping 273 matching lines @@
               NULL);
 
   return OK;
 }
 
 void UDPSocketWin::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net