Adding non-tracking mode support to AddressTracker.

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>
 
@@ skipping 79 matching lines @@
   ifr.ifr_ifindex = interface_index;
   int rv = ioctl(ioctl_socket, SIOCGIFNAME, &ifr);
   close(ioctl_socket);
   if (rv != 0)
     return "";
   return ifr.ifr_name;
 }
 
 }  // namespace
 
+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_),
+      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_) {
+      is_offline_initialized_cv_(&is_offline_lock_),
+      tracking_(true) {
   DCHECK(!address_callback.is_null());
   DCHECK(!link_callback.is_null());
 }
 
 AddressTrackerLinux::~AddressTrackerLinux() {
   CloseSocket();
 }
 
 void AddressTrackerLinux::Init() {
   netlink_fd_ = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
   if (netlink_fd_ < 0) {
     PLOG(ERROR) << "Could not create NETLINK socket";
     AbortAndForceOnline();
     return;
   }
 
-  // Request notifications.
-  struct sockaddr_nl addr = {};
-  addr.nl_family = AF_NETLINK;
-  addr.nl_pid = getpid();
-  // TODO(szym): Track RTMGRP_LINK as well for ifi_type, http://crbug.com/113993
-  addr.nl_groups = RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NOTIFY |
-      RTMGRP_LINK;
-  int rv = bind(netlink_fd_,
-                reinterpret_cast<struct sockaddr*>(&addr),
-                sizeof(addr));
-  if (rv < 0) {
-    PLOG(ERROR) << "Could not bind NETLINK socket";
-    AbortAndForceOnline();
-    return;
+  int rv;
+
+  if (tracking_) {
+    // Request notifications.
+    struct sockaddr_nl addr = {};
+    addr.nl_family = AF_NETLINK;
+    addr.nl_pid = getpid();
+    // TODO(szym): Track RTMGRP_LINK as well for ifi_type,
+    // http://crbug.com/113993
+    addr.nl_groups =
+        RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NOTIFY | RTMGRP_LINK;
+    rv = bind(
+        netlink_fd_, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
+    if (rv < 0) {
+      PLOG(ERROR) << "Could not bind NETLINK socket";
+      AbortAndForceOnline();
+      return;
+    }
   }
 
   // Request dump of addresses.
   struct sockaddr_nl peer = {};
   peer.nl_family = AF_NETLINK;
 
   struct {
     struct nlmsghdr header;
     struct rtgenmsg msg;
   } request = {};
@@ skipping 28 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);
   {
-    base::AutoLock lock(is_offline_lock_);
+    AddressTrackerAutoLock lock(*this, is_offline_lock_);
     is_offline_initialized_ = true;
     is_offline_initialized_cv_.Signal();
   }
 
-  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;
+  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();
-  base::AutoLock lock(is_offline_lock_);
+  AddressTrackerAutoLock lock(*this, is_offline_lock_);
   is_offline_ = false;
   is_offline_initialized_ = true;
   is_offline_initialized_cv_.Signal();
 }
 
 AddressTrackerLinux::AddressMap AddressTrackerLinux::GetAddressMap() const {
-  base::AutoLock lock(address_map_lock_);
+  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;
-  base::AutoLock lock(is_offline_lock_);
+  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();
   }
   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
   // http://crbug.com/160537
   return is_offline_ ? NetworkChangeNotifier::CONNECTION_NONE :
                        NetworkChangeNotifier::CONNECTION_UNKNOWN;
 }
 
@@ skipping 16 matching lines @@
       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) {
-    base::AutoLock lock(is_offline_lock_);
-    is_offline_ = online_links_.empty();
+    bool is_offline;
+    {
+      AddressTrackerAutoLock lock(*this, online_links_lock_);
+      is_offline = online_links_.empty();
+    }
+    AddressTrackerAutoLock lock(*this, is_offline_lock_);
+    is_offline_ = is_offline;
   }
 }
 
 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);
        header = NLMSG_NEXT(header, length)) {
     switch (header->nlmsg_type) {
       case NLMSG_DONE:
         return;
       case NLMSG_ERROR: {
         const struct nlmsgerr* msg =
             reinterpret_cast<struct nlmsgerr*>(NLMSG_DATA(header));
         LOG(ERROR) << "Unexpected netlink error " << msg->error << ".";
       } return;
       case RTM_NEWADDR: {
         IPAddressNumber address;
         bool really_deprecated;
         if (GetAddress(header, &address, &really_deprecated)) {
-          base::AutoLock lock(address_map_lock_);
+          AddressTrackerAutoLock lock(*this, address_map_lock_);
           struct ifaddrmsg* msg =
               reinterpret_cast<struct ifaddrmsg*>(NLMSG_DATA(header));
           // Routers may frequently (every few seconds) output the IPv6 ULA
           // prefix which can cause the linux kernel to frequently output two
           // back-to-back messages, one without the deprecated flag and one with
           // the deprecated flag but both with preferred lifetimes of 0. Avoid
           // interpretting this as an actual change by canonicalizing the two
           // messages by setting the deprecated flag based on the preferred
           // lifetime also.  http://crbug.com/268042
           if (really_deprecated)
             msg->ifa_flags |= IFA_F_DEPRECATED;
           // Only indicate change if the address is new or ifaddrmsg info has
           // changed.
           AddressMap::iterator it = address_map_.find(address);
           if (it == address_map_.end()) {
             address_map_.insert(it, std::make_pair(address, *msg));
             *address_changed = true;
           } else if (memcmp(&it->second, msg, sizeof(*msg))) {
             it->second = *msg;
             *address_changed = true;
           }
         }
       } break;
       case RTM_DELADDR: {
         IPAddressNumber address;
         if (GetAddress(header, &address, NULL)) {
-          base::AutoLock lock(address_map_lock_);
+          AddressTrackerAutoLock lock(*this, address_map_lock_);
           if (address_map_.erase(address))
             *address_changed = true;
         }
       } 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))
               *tunnel_changed = true;
           }
         } else {
+          AddressTrackerAutoLock lock(*this, online_links_lock_);
           if (online_links_.erase(msg->ifi_index)) {
             *link_changed = true;
             if (IsTunnelInterface(msg))
               *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))
             *tunnel_changed = true;
         }
       } break;
       default:
         break;
     }
   }
@@ skipping 21 matching lines @@
   netlink_fd_ = -1;
 }
 
 bool AddressTrackerLinux::IsTunnelInterface(const struct ifinfomsg* msg) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
   return strncmp(get_interface_name_(msg->ifi_index), "tun", 3) == 0;
 }
 
 }  // namespace internal
 }  // namespace net