Bind a socket to a network if the network handle is set.

webrtc/base/physicalsocketserver.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #if defined(_MSC_VER) && _MSC_VER < 1300
 #pragma warning(disable:4786)
 #endif
 
 #include <assert.h>
 
 #ifdef MEMORY_SANITIZER
 #include <sanitizer/msan_interface.h>
 #endif
 
 #if defined(WEBRTC_POSIX)
+#include <dlfcn.h>
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/select.h>
 #include <unistd.h>
 #include <signal.h>
 #endif
 
 #if defined(WEBRTC_WIN)
@@ skipping 57 matching lines @@
     68,     // Official minimum
     0,      // End of list marker
 };
 
 static const int IP_HEADER_SIZE = 20u;
 static const int IPV6_HEADER_SIZE = 40u;
 static const int ICMP_HEADER_SIZE = 8u;
 static const int ICMP_PING_TIMEOUT_MILLIS = 10000u;
 #endif
 
+static const int ERR_NOT_IMPLEMENTED = -11;
+
+#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
+static const int ERR_NETWORK_CHANGED = -21;
+static const int ERR_FAILED = -1;
+static const uint32_t INVALID_NETWORK_HANDLE = 0xFFFFFFFF;

[pthatcher1, 2016/01/06 21:58:46]

Where do these values come from?

[honghaiz3, 2016/01/12 20:36:42]

From the Chromium code. I changed them to an enum now. 

+#endif
+
 PhysicalSocket::PhysicalSocket(PhysicalSocketServer* ss, SOCKET s)
   : ss_(ss), s_(s), enabled_events_(0), error_(0),
     state_((s == INVALID_SOCKET) ? CS_CLOSED : CS_CONNECTED),
     resolver_(nullptr) {
 #if defined(WEBRTC_WIN)
   // EnsureWinsockInit() ensures that winsock is initialized. The default
   // version of this function doesn't do anything because winsock is
   // initialized by constructor of a static object. If neccessary libjingle
   // users can link it with a different version of this function by replacing
   // win32socketinit.cc. See win32socketinit.cc for more details.
@@ skipping 61 matching lines @@
   UpdateLastError();
 #if !defined(NDEBUG)
   if (0 == err) {
     dbg_addr_ = "Bound @ ";
     dbg_addr_.append(GetLocalAddress().ToString());
   }
 #endif
   return err;
 }
 
+int PhysicalSocket::BindToNetwork(NetworkHandle network) {
+#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
+  LOG(LS_INFO) << "Bind socket " << s_ << " to network handle " << network;
+  // Android prior to Lollipop didn't have support for binding sockets to
+  // networks. However, it should not have reached here in that case
+  // because the default network handle is invalid.
+  ASSERT(network != INVALID_NETWORK_HANDLE);
+
+  // NOTE: This does rely on Android implementation details, but
+  // these details are unlikely to change.
+  typedef int (*SetNetworkForSocket)(unsigned netId, int socketFd);
+  static SetNetworkForSocket setNetworkForSocket;
+  // This is racy, but all racers should come out with the same answer so it
+  // shouldn't matter.
+  if (setNetworkForSocket == nullptr) {
+    // Android's netd client library should always be loaded in our address
+    // space as it shims libc functions like connect().
+    const std::string net_library_path = "libnetd_client.so";
+    void* lib = dlopen(net_library_path.c_str(), RTLD_LAZY);
+    if (lib == nullptr) {
+      LOG(LS_ERROR) << "Library " << net_library_path << " not found!";
+      return ERR_NOT_IMPLEMENTED;
+    }
+    setNetworkForSocket = reinterpret_cast<SetNetworkForSocket>(
+        dlsym(lib, "setNetworkForSocket"));
+  }
+  if (setNetworkForSocket == nullptr) {
+    LOG(LS_ERROR) << "Symbol setNetworkForSocket not found ";
+    return ERR_NOT_IMPLEMENTED;
+  }
+  int rv = setNetworkForSocket(network, s_);
+  // If |network| has since disconnected, |rv| will be ENONET.  Surface this as
+  // ERR_NETWORK_CHANGED, rather than MapSystemError(ENONET) which gives back
+  // the less descriptive ERR_FAILED.
+  if (rv == ENONET)
+    return ERR_NETWORK_CHANGED;
+  return ERR_FAILED;

[pthatcher1, 2016/01/06 21:58:46]

For readability, can you move this into its own Android-specific function,
something like BindAndroidSocketToNetwork?

[honghaiz3, 2016/01/12 20:36:42]

Done.

+#else
+  ASSERT(false);
+  return ERR_NOT_IMPLEMENTED;
+#endif
+}
+
 int PhysicalSocket::Connect(const SocketAddress& addr) {
   // TODO(pthatcher): Implicit creation is required to reconnect...
   // ...but should we make it more explicit?
   if (state_ != CS_CLOSED) {
     SetError(EALREADY);
     return SOCKET_ERROR;
   }
   if (addr.IsUnresolvedIP()) {
     LOG(LS_VERBOSE) << "Resolving addr in PhysicalSocket::Connect";
     resolver_ = new AsyncResolver();
@@ skipping 930 matching lines @@
     return false;
 
   state_ = CS_CLOSED;
   signal_close_ = false;
   SignalCloseEvent(this, signal_err_);
   return true;
 }
 
 int SocketDispatcher::next_id_ = 0;
 
-#endif  // WEBRTC_WIN 
+#endif  // WEBRTC_WIN
 
 // Sets the value of a boolean value to false when signaled.
 class Signaler : public EventDispatcher {
  public:
   Signaler(PhysicalSocketServer* ss, bool* pf)
       : EventDispatcher(ss), pf_(pf) {
   }
   ~Signaler() override { }
 
   void OnEvent(uint32_t ff, int err) override {
@@ skipping 473 matching lines @@
       break;
     cmsElapsed = TimeSince(msStart);
     if ((cmsWait != kForever) && (cmsElapsed >= cmsWait)) {
        break;
     }
   }
 
   // Done
   return true;
 }
-#endif  // WEBRTC_WIN 
+#endif  // WEBRTC_WIN
 
 }  // namespace rtc