Guard socket file descriptor in UDPSocketLibevent

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 <net/if.h>
 #include <netdb.h>
-#include <net/if.h>
 #include <netinet/in.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 
 #include "base/callback.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/network_activity_monitor.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/udp_net_log_parameters.h"
 
+#if defined(OS_MACOSX)
+// Needed temporarily to debug crbug.com/461246.
+// TODO(sergeyu): Remove once the bug is resolved.
+#include <dlfcn.h>
+#include <pthread.h>
+#endif  // defined(OS_MACOSX)
 
 namespace net {
 
 namespace {
 
 const int kBindRetries = 10;
 const int kPortStart = 1024;
 const int kPortEnd = 65535;
 
 #if defined(OS_MACOSX)
 
 // Returns IPv4 address in network order.
 int GetIPv4AddressFromIndex(int socket, uint32 index, uint32* address){
   if (!index) {
     *address = htonl(INADDR_ANY);
     return OK;
   }
   ifreq ifr;
   ifr.ifr_addr.sa_family = AF_INET;
   if (!if_indextoname(index, ifr.ifr_name))
     return MapSystemError(errno);
   int rv = ioctl(socket, SIOCGIFADDR, &ifr);
   if (rv == -1)
     return MapSystemError(errno);
   *address = reinterpret_cast<sockaddr_in*>(&ifr.ifr_addr)->sin_addr.s_addr;
   return OK;
 }
 
+// On OSX the file descriptor is guarded to detect the cause of
+// crbug.com/461246. sys/guarded.h is not included in the SDK, so the API needs
+// to be defined here.
+// TODO(sergeyu): Removed this code once the bug is resolved.
+
+typedef uint64_t guardid_t;
+
+typedef int (*GuardedCloseNpFunction)(int fd, const guardid_t* guard);
+typedef int (*ChangeFdguardNpFunction)(int fd,
+                                       const guardid_t* guard,
+                                       u_int flags,
+                                       const guardid_t* nguard,
+                                       u_int nflags,
+                                       int* fdflagsp);
+
+void* g_libsystem_handle = nullptr;

[Mark Mentovai, 2015/04/02 18:21:57]

This is only used in InitGuardedFunctions, make it a static void* in that
function.

[Sergey Ulanov, 2015/04/02 18:28:19]

Done. It doesn't need to be static.

+GuardedCloseNpFunction g_guarded_close_np = nullptr;
+ChangeFdguardNpFunction g_change_fdguard_np = nullptr;
+
+static pthread_once_t g_guarded_functions_once = PTHREAD_ONCE_INIT;

[Mark Mentovai, 2015/04/02 18:21:57]

You’re in an unnamed namespace, you shouldn’t have static on this or on the
function that follows.

[Sergey Ulanov, 2015/04/02 18:28:18]

Done.

+
+static void InitGuardedFunctions() {
+  g_libsystem_handle = dlopen("/usr/lib/libSystem.dylib", 0);

[Mark Mentovai, 2015/04/02 18:21:57]

Use RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD, not 0.

[Sergey Ulanov, 2015/04/02 18:28:18]

Done.

+  if (g_libsystem_handle) {
+    g_guarded_close_np = reinterpret_cast<GuardedCloseNpFunction>(
+        dlsym(g_libsystem_handle, "guarded_close_np"));
+    g_change_fdguard_np = reinterpret_cast<ChangeFdguardNpFunction>(
+        dlsym(g_libsystem_handle, "change_fdguard_np"));
+
+    // If for any reason only one of the functions is found, set both of them to
+    // nullptr.
+    if (!g_guarded_close_np || !g_change_fdguard_np) {
+      g_guarded_close_np = nullptr;
+      g_change_fdguard_np = nullptr;
+    }
+  }
+}
+
+int change_fdguard_np(int fd, const guardid_t* guard, u_int flags,
+                      const guardid_t* nguard, u_int nflags, int* fdflagsp) {
+  CHECK_EQ(pthread_once(&g_guarded_functions_once, InitGuardedFunctions), 0);
+  // Older version of OSX may not support guarded API.
+  if (!g_change_fdguard_np)
+    return 0;
+  return g_change_fdguard_np(fd, guard, flags, nguard, nflags, fdflagsp);
+}
+
+int guarded_close_np(int fd, const guardid_t* guard) {
+  // Older version of OSX may not support guarded API.
+  if (!g_guarded_close_np)
+    return close(fd);
+
+  return g_guarded_close_np(fd, guard);
+}
+
+const unsigned int GUARD_CLOSE = 1u << 0;
+const unsigned int GUARD_DUP = 1u << 1;
+
+const guardid_t kSocketFdGuard = 0xD712BC0BC9A4EAD4;
+
 #endif  // OS_MACOSX
 
 }  // namespace
 
 UDPSocketLibevent::UDPSocketLibevent(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     net::NetLog* net_log,
     const net::NetLog::Source& source)
         : socket_(kInvalidSocket),
@@ skipping 22 matching lines @@
 }
 
 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 defined(OS_MACOSX)
+  PCHECK(change_fdguard_np(socket_, NULL, 0, &kSocketFdGuard,
+                           GUARD_CLOSE | GUARD_DUP, NULL) == 0);
+#endif  // OS_MACOSX
   if (SetNonBlocking(socket_)) {
     const int err = MapSystemError(errno);
     Close();
     return err;
   }
   return OK;
 }
 
 void UDPSocketLibevent::Close() {
   DCHECK(CalledOnValidThread());
 
   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 defined(OS_MACOSX)
+  PCHECK(IGNORE_EINTR(guarded_close_np(socket_, &kSocketFdGuard)) == 0);
+#else
   PCHECK(IGNORE_EINTR(close(socket_)) == 0);
+#endif  // OS_MACOSX
 
   socket_ = kInvalidSocket;
   addr_family_ = 0;
   is_connected_ = false;
 }
 
 int UDPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
   if (!is_connected())
@@ skipping 603 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketLibevent::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net