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

net/udp/udp_socket_libevent.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_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <net/if.h>
@@ skipping 49 matching lines @@
 
 }  // namespace
 
 UDPSocketLibevent::UDPSocketLibevent(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     net::NetLog* net_log,
     const net::NetLog::Source& source)
         : socket_(kInvalidSocket),
           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),
           read_watcher_(this),
           write_watcher_(this),
           read_buf_len_(0),
           recv_from_address_(NULL),
           write_buf_len_(0),
           net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketLibevent::~UDPSocketLibevent() {
   Close();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
+int UDPSocketLibevent::Open(AddressFamily address_family) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(socket_, kInvalidSocket);
+
+  addr_family_ = ConvertAddressFamily(address_family);
+  socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, 0);
+  if (socket_ == kInvalidSocket)
+    return MapSystemError(errno);
+  if (SetNonBlocking(socket_)) {
+    const int err = MapSystemError(errno);
+    Close();
+    return err;
+  }
+  return OK;
+}
+
 void UDPSocketLibevent::Close() {
   DCHECK(CalledOnValidThread());
 
-  if (!is_connected())
+  if (socket_ == kInvalidSocket)
     return;
 
   // Zero out any pending read/write callback state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
   read_callback_.Reset();
   recv_from_address_ = NULL;
   write_buf_ = NULL;
   write_buf_len_ = 0;
   write_callback_.Reset();
   send_to_address_.reset();
 
   bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
   ok = write_socket_watcher_.StopWatchingFileDescriptor();
   DCHECK(ok);
 
   if (IGNORE_EINTR(close(socket_)) < 0)
     PLOG(ERROR) << "close";
 
   socket_ = kInvalidSocket;
   addr_family_ = 0;
+  is_connected_ = false;
 }
 
 int UDPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (!remote_address_.get()) {
     SockaddrStorage storage;
@@ skipping 108 matching lines @@
   write_buf_len_ = buf_len;
   DCHECK(!send_to_address_.get());
   if (address) {
     send_to_address_.reset(new IPEndPoint(*address));
   }
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketLibevent::Connect(const IPEndPoint& address) {
+  DCHECK_NE(socket_, kInvalidSocket);
   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 UDPSocketLibevent::InternalConnect(const IPEndPoint& address) {
   DCHECK(CalledOnValidThread());
   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)) {
-    Close();
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
-  }
 
   rv = HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len));
-  if (rv < 0) {
-    // Close() may change the current errno. Map errno beforehand.
-    int result = MapSystemError(errno);
-    Close();
-    return result;
-  }
+  if (rv < 0)
+    return MapSystemError(errno);
 
   remote_address_.reset(new IPEndPoint(address));
   return rv;
 }
 
 int UDPSocketLibevent::Bind(const IPEndPoint& address) {
+  DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   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;
-  }
+
+  is_connected_ = true;
   local_address_.reset();
   return rv;
 }
 
 int UDPSocketLibevent::SetReceiveBufferSize(int32 size) {
+  DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
-  int last_error = errno;
-  DCHECK(!rv) << "Could not set socket receive buffer size: " << last_error;
-  return rv == 0 ? OK : MapSystemError(last_error);
+  return rv == 0 ? OK : MapSystemError(errno);
 }
 
 int UDPSocketLibevent::SetSendBufferSize(int32 size) {
+  DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
-  int last_error = errno;
-  DCHECK(!rv) << "Could not set socket send buffer size: " << last_error;
-  return rv == 0 ? OK : MapSystemError(last_error);
+  return rv == 0 ? OK : MapSystemError(errno);
 }
 
-void UDPSocketLibevent::AllowAddressReuse() {
+int UDPSocketLibevent::AllowAddressReuse() {
+  DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
   DCHECK(!is_connected());
-
-  socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+  int true_value = 1;
+  int rv = setsockopt(
+      socket_, SOL_SOCKET, SO_REUSEADDR, &true_value, sizeof(true_value));
+  return rv == 0 ? OK : MapSystemError(errno);
 }
 
-void UDPSocketLibevent::AllowBroadcast() {
+int UDPSocketLibevent::SetBroadcast(bool broadcast) {
+  DCHECK_NE(socket_, kInvalidSocket);
   DCHECK(CalledOnValidThread());
-  DCHECK(!is_connected());
-
-  socket_options_ |= SOCKET_OPTION_BROADCAST;
+  int value = broadcast ? 1 : 0;
+  int rv;
+#if defined(OS_MACOSX)
+  // SO_REUSEPORT on OSX permits multiple processes to each receive
+  // UDP multicast or broadcast datagrams destined for the bound
+  // port.
+  rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value));
+#else
+  rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST, &value, sizeof(value));
+#endif  // defined(OS_MACOSX)
+  return rv == 0 ? OK : MapSystemError(errno);
 }
 
 void UDPSocketLibevent::ReadWatcher::OnFileCanReadWithoutBlocking(int) {
   if (!socket_->read_callback_.is_null())
     socket_->DidCompleteRead();
 }
 
 void UDPSocketLibevent::WriteWatcher::OnFileCanWriteWithoutBlocking(int) {
   if (!socket_->write_callback_.is_null())
     socket_->DidCompleteWrite();
@@ skipping 52 matching lines @@
         CreateNetLogUDPDataTranferCallback(
             result, bytes,
             is_address_valid ? &address : NULL));
   }
 
   base::StatsCounter read_bytes("udp.read_bytes");
   read_bytes.Add(result);
   NetworkActivityMonitor::GetInstance()->IncrementBytesReceived(result);
 }
 
-int UDPSocketLibevent::CreateSocket(int addr_family) {
-  addr_family_ = addr_family;
-  socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, 0);
-  if (socket_ == kInvalidSocket)
-    return MapSystemError(errno);
-  if (SetNonBlocking(socket_)) {
-    const int err = MapSystemError(errno);
-    Close();
-    return err;
-  }
-  return OK;
-}
-
 void UDPSocketLibevent::DidCompleteWrite() {
   int result =
       InternalSendTo(write_buf_.get(), write_buf_len_, send_to_address_.get());
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
     send_to_address_.reset();
     write_socket_watcher_.StopWatchingFileDescriptor();
     DoWriteCallback(result);
@@ skipping 67 matching lines @@
                             0,
                             addr,
                             storage.addr_len));
   if (result < 0)
     result = MapSystemError(errno);
   if (result != ERR_IO_PENDING)
     LogWrite(result, buf->data(), address);
   return result;
 }
 
-int UDPSocketLibevent::SetSocketOptions() {
-  int true_value = 1;
-  if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &true_value,
-                        sizeof(true_value));
-    if (rv < 0)
-      return MapSystemError(errno);
-  }
-  if (socket_options_ & SOCKET_OPTION_BROADCAST) {
-    int rv;
-#if defined(OS_MACOSX)
-    // SO_REUSEPORT on OSX permits multiple processes to each receive
-    // UDP multicast or broadcast datagrams destined for the bound
-    // port.
-    rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEPORT, &true_value,
-                    sizeof(true_value));
-#else
-    rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST, &true_value,
-                    sizeof(true_value));
-#endif  // defined(OS_MACOSX)
-    if (rv < 0)
-      return MapSystemError(errno);
-  }
-
+int UDPSocketLibevent::SetMulticastOptions() {
   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
     int rv;
     if (addr_family_ == AF_INET) {
       u_char loop = 0;
       rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_LOOP,
                       &loop, sizeof(loop));
     } else {
       u_int loop = 0;
       rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
                       &loop, sizeof(loop));
@@ skipping 215 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketLibevent::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net