Multi-networking with Android L.

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>
 
+#include <dlfcn.h>
+
 #ifdef MEMORY_SANITIZER
 #include <sanitizer/msan_interface.h>
 #endif
 
 #if defined(WEBRTC_POSIX)
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/select.h>
@@ skipping 63 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;
+static const int ERR_NETWORK_CHANGED = -21;
+static const int ERR_FAILED = -1;
+static const uint32_t INVALID_NETWORK_HANDLE = 0xFFFFFFFF;
+
 class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> {
  public:
   PhysicalSocket(PhysicalSocketServer* ss, SOCKET s = INVALID_SOCKET)
     : ss_(ss), s_(s), enabled_events_(0), error_(0),
       state_((s == INVALID_SOCKET) ? CS_CLOSED : CS_CONNECTED),
       resolver_(NULL) {
 #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
@@ skipping 64 matching lines @@
     UpdateLastError();
 #if !defined(NDEBUG)
     if (0 == err) {
       dbg_addr_ = "Bound @ ";
       dbg_addr_.append(GetLocalAddress().ToString());
     }
 #endif
     return err;
   }
 
+  int BindToNetwork(NetworkHandle network) override {
+    LOG(LS_INFO) << "Bind socket " << s_ << " to network " << network;
+    if (network == INVALID_NETWORK_HANDLE)
+      return -1;
+#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
+    // Android prior to Lollipop didn't have support for binding sockets to
+    // networks.
+    // if (base::android::BuildInfo::GetInstance()->sdk_int() <
+    //    base::android::SDK_VERSION_LOLLIPOP) {
+    //  return ERR_NOT_IMPLEMENTED;
+    //}
+
+    // 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";
+      LOG(LS_ERROR) << "Load Library " << net_library_path;
+      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) << "symbole 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;
+#else
+    return ERR_NOT_IMPLEMENTED;
+#endif
+  }
+
   int Connect(const SocketAddress& addr) override {
     // TODO: 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 937 matching lines @@
 
     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