net/base/address_tracker_linux.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_BASE_ADDRESS_TRACKER_LINUX_H_
   6 #define NET_BASE_ADDRESS_TRACKER_LINUX_H_
   7
   8 #include <sys/socket.h>  // Needed to include netlink.
   9 // Mask superfluous definition of |struct net|. This is fixed in Linux 2.6.38.
  10 #define net net_kernel
  11 #include <linux/rtnetlink.h>
  12 #undef net
  13
  14 #include <map>
  15
  16 #include "base/basictypes.h"
  17 #include "base/callback.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/containers/hash_tables.h"
  20 #include "base/message_loop/message_loop.h"
  21 #include "base/synchronization/condition_variable.h"
  22 #include "base/synchronization/lock.h"
  23 #include "base/threading/thread_checker.h"
  24 #include "net/base/net_util.h"
  25 #include "net/base/network_change_notifier.h"
  26
  27 namespace net {
  28 namespace internal {
  29
  30 // Keeps track of network interface addresses using rtnetlink. Used by
  31 // NetworkChangeNotifier to provide signals to registered IPAddressObservers.
  32 class NET_EXPORT_PRIVATE AddressTrackerLinux :
  33     public base::MessageLoopForIO::Watcher {
  34  public:
  35   typedef std::map<IPAddressNumber, struct ifaddrmsg> AddressMap;
  36
  37   // Non-tracking version constructor: it takes a snapshot of the
  38   // current system configuration. Once Init() returns, the
  39   // configuration is available through GetOnlineLinks() and
  40   // GetAddressMap().
  41   AddressTrackerLinux();
  42
  43   // Tracking version constructor: it will run |address_callback| when
  44   // the AddressMap changes, |link_callback| when the list of online
  45   // links changes, and |tunnel_callback| when the list of online
  46   // tunnels changes.
  47   // |ignored_interfaces| is the list of interfaces to ignore.  Changes to an
  48   // ignored interface will not cause any callback to be run. An ignored
  49   // interface will not have entries in GetAddressMap() and GetOnlineLinks().
  50   // NOTE: Only ignore interfaces not used to connect to the internet. Adding
  51   // interfaces used to connect to the internet can cause critical network
  52   // changed signals to be lost allowing incorrect stale state to persist.
  53   AddressTrackerLinux(const base::Closure& address_callback,
  54                       const base::Closure& link_callback,
  55                       const base::Closure& tunnel_callback,
  56                       const base::hash_set<std::string>& ignored_interfaces);
  57   ~AddressTrackerLinux() override;
  58
  59   // In tracking mode, it starts watching the system configuration for
  60   // changes. The current thread must have a MessageLoopForIO. In
  61   // non-tracking mode, once Init() returns, a snapshot of the system
  62   // configuration is available through GetOnlineLinks() and
  63   // GetAddressMap().
  64   void Init();
  65
  66   AddressMap GetAddressMap() const;
  67
  68   // Returns set of interface indicies for online interfaces.
  69   base::hash_set<int> GetOnlineLinks() const;
  70
  71   // Implementation of NetworkChangeNotifierLinux::GetCurrentConnectionType().
  72   // Safe to call from any thread, but will block until Init() has completed.
  73   NetworkChangeNotifier::ConnectionType GetCurrentConnectionType();
  74
  75   // Returns the name for the interface with interface index |interface_index|.
  76   // |buf| should be a pointer to an array of size IFNAMSIZ. The returned
  77   // pointer will point to |buf|. This function acts like if_indextoname which
  78   // cannot be used as net/if.h cannot be mixed with linux/if.h. We'll stick
  79   // with exclusively talking to the kernel and not the C library.
  80   static char* GetInterfaceName(int interface_index, char* buf);
  81
  82  private:
  83   friend class AddressTrackerLinuxTest;
  84
  85   // In tracking mode, holds |lock| while alive. In non-tracking mode,
  86   // enforces single-threaded access.
  87   class AddressTrackerAutoLock {
  88    public:
  89     AddressTrackerAutoLock(const AddressTrackerLinux& tracker,
  90                            base::Lock& lock);
  91     ~AddressTrackerAutoLock();
  92
  93    private:
  94     const AddressTrackerLinux& tracker_;
  95     base::Lock& lock_;
  96     DISALLOW_COPY_AND_ASSIGN(AddressTrackerAutoLock);
  97   };
  98
  99   // A function that returns the name of an interface given the interface index
 100   // in |interface_index|. |ifname| should be a buffer of size IFNAMSIZ. The
 101   // function should return a pointer to |ifname|.
 102   typedef char* (*GetInterfaceNameFunction)(int interface_index, char* ifname);
 103
 104   // Sets |*address_changed| to indicate whether |address_map_| changed and
 105   // sets |*link_changed| to indicate if |online_links_| changed and sets
 106   // |*tunnel_changed| to indicate if |online_links_| changed with regards to a
 107   // tunnel interface while reading messages from |netlink_fd_|.
 108   void ReadMessages(bool* address_changed,
 109                     bool* link_changed,
 110                     bool* tunnel_changed);
 111
 112   // Sets |*address_changed| to true if |address_map_| changed, sets
 113   // |*link_changed| to true if |online_links_| changed, sets |*tunnel_changed|
 114   // to true if |online_links_| changed with regards to a tunnel interface while
 115   // reading the message from |buffer|.
 116   void HandleMessage(char* buffer,
 117                      size_t length,
 118                      bool* address_changed,
 119                      bool* link_changed,
 120                      bool* tunnel_changed);
 121
 122   // Call when some part of initialization failed; forces online and unblocks.
 123   void AbortAndForceOnline();
 124
 125   // MessageLoopForIO::Watcher:
 126   void OnFileCanReadWithoutBlocking(int fd) override;
 127   void OnFileCanWriteWithoutBlocking(int /* fd */) override;
 128
 129   // Close |netlink_fd_|
 130   void CloseSocket();
 131
 132   // Does |interface_index| refer to a tunnel interface?
 133   bool IsTunnelInterface(int interface_index) const;
 134
 135   // Is interface with index |interface_index| in list of ignored interfaces?
 136   bool IsInterfaceIgnored(int interface_index) const;
 137
 138   // Updates current_connection_type_ based on the network list.
 139   void UpdateCurrentConnectionType();
 140
 141   // Gets the name of an interface given the interface index |interface_index|.
 142   // May return empty string if it fails but should not return NULL. This is
 143   // overridden by tests.
 144   GetInterfaceNameFunction get_interface_name_;
 145
 146   base::Closure address_callback_;
 147   base::Closure link_callback_;
 148   base::Closure tunnel_callback_;
 149
 150   int netlink_fd_;
 151   base::MessageLoopForIO::FileDescriptorWatcher watcher_;
 152
 153   mutable base::Lock address_map_lock_;
 154   AddressMap address_map_;
 155
 156   // Set of interface indices for links that are currently online.
 157   mutable base::Lock online_links_lock_;
 158   base::hash_set<int> online_links_;
 159
 160   // Set of interface names that should be ignored.
 161   const base::hash_set<std::string> ignored_interfaces_;
 162
 163   base::Lock connection_type_lock_;
 164   bool connection_type_initialized_;
 165   base::ConditionVariable connection_type_initialized_cv_;
 166   NetworkChangeNotifier::ConnectionType current_connection_type_;
 167   bool tracking_;
 168
 169   // Used to verify single-threaded access in non-tracking mode.
 170   base::ThreadChecker thread_checker_;
 171 };
 172
 173 }  // namespace internal
 174 }  // namespace net
 175
 176 #endif  // NET_BASE_ADDRESS_TRACKER_LINUX_H_