Determine connection type in NetworkChangeNotifierLinux.

net/base/address_tracker_linux.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/base/address_tracker_linux.h"
 
 #include <errno.h>
 #include <linux/if.h>
 #include <sys/ioctl.h>
 
+#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/thread_restrictions.h"
+#include "net/base/net_util_linux.h"
 
 namespace net {
 namespace internal {
 
 namespace {
 
 // Retrieves address from NETLINK address message.
 // Sets |really_deprecated| for IPv6 addresses with preferred lifetimes of 0.
 bool GetAddress(const struct nlmsghdr* header,
                 IPAddressNumber* out,
@@ skipping 45 matching lines @@
     }
   }
   if (local)
     address = local;
   if (!address)
     return false;
   out->assign(address, address + address_length);
   return true;
 }
 
-// Returns the name for the interface with interface index |interface_index|.
-// The return value points to a function-scoped static so it may be changed by
-// subsequent calls. This function could be replaced with if_indextoname() but
-// net/if.h cannot be mixed with linux/if.h so we'll stick with exclusively
-// talking to the kernel and not the C library.
-const char* GetInterfaceName(int interface_index) {
-  int ioctl_socket = socket(AF_INET, SOCK_DGRAM, 0);
-  if (ioctl_socket < 0)
-    return "";
-  static struct ifreq ifr;
-  memset(&ifr, 0, sizeof(ifr));
-  ifr.ifr_ifindex = interface_index;
-  int rv = ioctl(ioctl_socket, SIOCGIFNAME, &ifr);
-  close(ioctl_socket);
-  if (rv != 0)
-    return "";
-  return ifr.ifr_name;
-}
-
 }  // namespace
 
+// static
+char* AddressTrackerLinux::GetInterfaceName(int interface_index, char* buf) {
+  memset(buf, 0, IFNAMSIZ);
+  base::ScopedFD ioctl_socket(socket(AF_INET, SOCK_DGRAM, 0));
+  if (!ioctl_socket.is_valid())
+    return buf;
+
+  static struct ifreq ifr;

[pauljensen, 2015/01/28 21:15:55]

um this shouldn't be static...that would make this function thread-unsafe

[derekjchow1, 2015/01/29 00:35:04]

Done.

+  memset(&ifr, 0, sizeof(ifr));

[pauljensen, 2015/01/28 21:15:55]

could we combine this line into the above line using " = {}"

[derekjchow1, 2015/01/29 00:35:04]

Done.

+  ifr.ifr_ifindex = interface_index;

[pauljensen, 2015/01/28 21:15:55]

could we combine this line into the above declaration using " = { .ifr_ifindex =
interface_index };

[derekjchow1, 2015/01/29 00:35:04]

Done.

+  int rv = ioctl(ioctl_socket.get(), SIOCGIFNAME, &ifr);
+  if (rv != 0)
+    return buf;
+
+  strncpy(buf, ifr.ifr_name, IFNAMSIZ - 1);
+  return buf;

[pauljensen, 2015/01/28 21:15:55]

could we combine the last 6 lines of this function down to:
if (ioctl(...) == 0)
  strncpy(buf, ...)
return buf;

[derekjchow1, 2015/01/29 00:35:04]

Done.

+}
+
 AddressTrackerLinux::AddressTrackerLinux()
     : get_interface_name_(GetInterfaceName),
       address_callback_(base::Bind(&base::DoNothing)),
       link_callback_(base::Bind(&base::DoNothing)),
       tunnel_callback_(base::Bind(&base::DoNothing)),
       netlink_fd_(-1),
-      is_offline_(true),
-      is_offline_initialized_(false),
-      is_offline_initialized_cv_(&is_offline_lock_),
+      connection_type_initialized_(false),
+      connection_type_initialized_cv_(&connection_type_lock_),
+      current_connection_type_(NetworkChangeNotifier::CONNECTION_NONE),
       tracking_(false) {
 }
 
 AddressTrackerLinux::AddressTrackerLinux(const base::Closure& address_callback,
                                          const base::Closure& link_callback,
                                          const base::Closure& tunnel_callback)
     : get_interface_name_(GetInterfaceName),
       address_callback_(address_callback),
       link_callback_(link_callback),
       tunnel_callback_(tunnel_callback),
       netlink_fd_(-1),
-      is_offline_(true),
-      is_offline_initialized_(false),
-      is_offline_initialized_cv_(&is_offline_lock_),
+      connection_type_initialized_(false),
+      connection_type_initialized_cv_(&connection_type_lock_),
+      current_connection_type_(NetworkChangeNotifier::CONNECTION_NONE),
       tracking_(true) {
   DCHECK(!address_callback.is_null());
   DCHECK(!link_callback.is_null());
 }
 
 AddressTrackerLinux::~AddressTrackerLinux() {
   CloseSocket();
 }
 
 void AddressTrackerLinux::Init() {
@@ skipping 63 matching lines @@
                            sizeof(peer)));
   if (rv < 0) {
     PLOG(ERROR) << "Could not send NETLINK request";
     AbortAndForceOnline();
     return;
   }
 
   // Consume pending message to populate links_online_, but don't notify.
   ReadMessages(&address_changed, &link_changed, &tunnel_changed);
   {
-    AddressTrackerAutoLock lock(*this, is_offline_lock_);
-    is_offline_initialized_ = true;
-    is_offline_initialized_cv_.Signal();
+    AddressTrackerAutoLock lock(*this, connection_type_lock_);
+    connection_type_initialized_ = true;
+    connection_type_initialized_cv_.Signal();
   }
 
   if (tracking_) {
     rv = base::MessageLoopForIO::current()->WatchFileDescriptor(
         netlink_fd_, true, base::MessageLoopForIO::WATCH_READ, &watcher_, this);
     if (rv < 0) {
       PLOG(ERROR) << "Could not watch NETLINK socket";
       AbortAndForceOnline();
       return;
     }
   }
 }
 
 void AddressTrackerLinux::AbortAndForceOnline() {
   CloseSocket();
-  AddressTrackerAutoLock lock(*this, is_offline_lock_);
-  is_offline_ = false;
-  is_offline_initialized_ = true;
-  is_offline_initialized_cv_.Signal();
+  AddressTrackerAutoLock lock(*this, connection_type_lock_);
+  current_connection_type_ = NetworkChangeNotifier::CONNECTION_UNKNOWN;
+  connection_type_initialized_ = true;
+  connection_type_initialized_cv_.Signal();
 }
 
 AddressTrackerLinux::AddressMap AddressTrackerLinux::GetAddressMap() const {
   AddressTrackerAutoLock lock(*this, address_map_lock_);
   return address_map_;
 }
 
 base::hash_set<int> AddressTrackerLinux::GetOnlineLinks() const {
   AddressTrackerAutoLock lock(*this, online_links_lock_);
   return online_links_;
 }
 
 NetworkChangeNotifier::ConnectionType
 AddressTrackerLinux::GetCurrentConnectionType() {
   // http://crbug.com/125097
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
-  AddressTrackerAutoLock lock(*this, is_offline_lock_);
-  // Make sure the initial offline state is set before returning.
-  while (!is_offline_initialized_) {
-    is_offline_initialized_cv_.Wait();
+  AddressTrackerAutoLock lock(*this, connection_type_lock_);
+  // Make sure the initial connection type is set before returning.
+  while (!connection_type_initialized_) {
+    connection_type_initialized_cv_.Wait();
   }
-  // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
-  // http://crbug.com/160537
-  return is_offline_ ? NetworkChangeNotifier::CONNECTION_NONE :
-                       NetworkChangeNotifier::CONNECTION_UNKNOWN;
+  return current_connection_type_;
 }
 
 void AddressTrackerLinux::ReadMessages(bool* address_changed,
                                        bool* link_changed,
                                        bool* tunnel_changed) {
   *address_changed = false;
   *link_changed = false;
   *tunnel_changed = false;
   char buffer[4096];
   bool first_loop = true;
   for (;;) {
     int rv = HANDLE_EINTR(recv(netlink_fd_,
                                buffer,
                                sizeof(buffer),
                                // Block the first time through loop.
                                first_loop ? 0 : MSG_DONTWAIT));
     first_loop = false;
     if (rv == 0) {
       LOG(ERROR) << "Unexpected shutdown of NETLINK socket.";
       return;
     }
     if (rv < 0) {
       if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
         break;
       PLOG(ERROR) << "Failed to recv from netlink socket";
       return;
     }
     HandleMessage(buffer, rv, address_changed, link_changed, tunnel_changed);
   }
-  if (*link_changed) {
-    bool is_offline;
-    {
-      AddressTrackerAutoLock lock(*this, online_links_lock_);
-      is_offline = online_links_.empty();
-    }
-    AddressTrackerAutoLock lock(*this, is_offline_lock_);
-    is_offline_ = is_offline;
-  }
+  if (*link_changed || *address_changed)
+    UpdateCurrentConnectionType();
 }
 
 void AddressTrackerLinux::HandleMessage(char* buffer,
                                         size_t length,
                                         bool* address_changed,
                                         bool* link_changed,
                                         bool* tunnel_changed) {
   DCHECK(buffer);
   for (struct nlmsghdr* header = reinterpret_cast<struct nlmsghdr*>(buffer);
        NLMSG_OK(header, length);
@@ skipping 43 matching lines @@
         }
       } break;
       case RTM_NEWLINK: {
         const struct ifinfomsg* msg =
             reinterpret_cast<struct ifinfomsg*>(NLMSG_DATA(header));
         if (!(msg->ifi_flags & IFF_LOOPBACK) && (msg->ifi_flags & IFF_UP) &&
             (msg->ifi_flags & IFF_LOWER_UP) && (msg->ifi_flags & IFF_RUNNING)) {
           AddressTrackerAutoLock lock(*this, online_links_lock_);
           if (online_links_.insert(msg->ifi_index).second) {
             *link_changed = true;
-            if (IsTunnelInterface(msg))
+            if (IsTunnelInterface(msg->ifi_index))
               *tunnel_changed = true;
           }
         } else {
           AddressTrackerAutoLock lock(*this, online_links_lock_);
           if (online_links_.erase(msg->ifi_index)) {
             *link_changed = true;
-            if (IsTunnelInterface(msg))
+            if (IsTunnelInterface(msg->ifi_index))
               *tunnel_changed = true;
           }
         }
       } break;
       case RTM_DELLINK: {
         const struct ifinfomsg* msg =
             reinterpret_cast<struct ifinfomsg*>(NLMSG_DATA(header));
         AddressTrackerAutoLock lock(*this, online_links_lock_);
         if (online_links_.erase(msg->ifi_index)) {
           *link_changed = true;
-          if (IsTunnelInterface(msg))
+          if (IsTunnelInterface(msg->ifi_index))
             *tunnel_changed = true;
         }
       } break;
       default:
         break;
     }
   }
 }
 
 void AddressTrackerLinux::OnFileCanReadWithoutBlocking(int fd) {
@@ skipping 11 matching lines @@
 }
 
 void AddressTrackerLinux::OnFileCanWriteWithoutBlocking(int /* fd */) {}
 
 void AddressTrackerLinux::CloseSocket() {
   if (netlink_fd_ >= 0 && IGNORE_EINTR(close(netlink_fd_)) < 0)
     PLOG(ERROR) << "Could not close NETLINK socket.";
   netlink_fd_ = -1;
 }
 
-bool AddressTrackerLinux::IsTunnelInterface(const struct ifinfomsg* msg) const {
+bool AddressTrackerLinux::IsTunnelInterface(int interface_index) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
-  return strncmp(get_interface_name_(msg->ifi_index), "tun", 3) == 0;
+  char buf[IFNAMSIZ] = {0};
+  return strncmp(get_interface_name_(interface_index, buf), "tun", 3) == 0;
+}
+
+void AddressTrackerLinux::UpdateCurrentConnectionType() {
+  NetworkChangeNotifier::ConnectionType type =
+      NetworkChangeNotifier::CONNECTION_NONE;
+  AddressTrackerLinux::AddressMap address_map = GetAddressMap();
+  base::hash_set<int> online_links = GetOnlineLinks();
+
+  // Strip out tunnel interfaces from online_links
+  for (base::hash_set<int>::const_iterator it = online_links.begin();
+       it != online_links.end(); ++it) {
+    if (IsTunnelInterface(*it))
+      online_links.erase(it);

[pauljensen, 2015/01/28 21:15:55]

this won't work: |it| becomes invalid after erase() call.
I think we can use the new C++11 return value for erase() like so:
for (base::hash_set<int>::const_iterator it = online_links.begin();
     it != online_links.end();) {
   if (IsTunnelInterface(*it)) {
       it = online_links.erase(it);
   } else {
       ++it;
   }

[derekjchow1, 2015/01/29 00:35:04]

https://code.google.com/p/chromium/codesearch#chromium/src/base/containers/ha...

Only MSVC uses a C++11 implementation of base::hash_set, so this won't work on
linux. To work around this, I used a temporary iterator instead. PTAL. If you
don't think this works I will create a new hash_set with the non-tunnel
interfaces instead.

+  }
+
+  NetworkInterfaceList networks;
+  if (GetNetworkListImpl(&networks, 0, online_links, address_map,
+                         get_interface_name_)) {
+    type = NetworkChangeNotifier::ConnectionTypeFromInterfaceList(networks);
+  } else {
+    type = online_links.empty() ? NetworkChangeNotifier::CONNECTION_NONE
+                                : NetworkChangeNotifier::CONNECTION_UNKNOWN;
+  }
+
+  AddressTrackerAutoLock lock(*this, connection_type_lock_);
+  current_connection_type_ = type;
 }
 
 AddressTrackerLinux::AddressTrackerAutoLock::AddressTrackerAutoLock(
     const AddressTrackerLinux& tracker,
     base::Lock& lock)
     : tracker_(tracker), lock_(lock) {
   if (tracker_.tracking_) {
     lock_.Acquire();
   } else {
     DCHECK(tracker_.thread_checker_.CalledOnValidThread());
   }
 }
 
 AddressTrackerLinux::AddressTrackerAutoLock::~AddressTrackerAutoLock() {
   if (tracker_.tracking_) {
     lock_.AssertAcquired();
     lock_.Release();
   }
 }
 
 }  // namespace internal
 }  // namespace net