Add WiFi SSID getter to NetworkChangeNotifier.

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 <linux/wireless.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 {
@@ skipping 52 matching lines @@
     }
   }
   if (local)
     address = local;
   if (!address)
     return false;
   out->assign(address, address + address_length);
   return true;
 }
 
+std::string GetInterfaceSSID(const std::string& ifname) {
+  int ioctl_socket = socket(AF_INET, SOCK_DGRAM, 0);
+  if (ioctl_socket < 0)
+    return "";
+  struct iwreq wreq;
+  memset(&wreq, 0, sizeof(wreq));
+  strncpy(wreq.ifr_name, ifname.c_str(), IFNAMSIZ - 1);
+
+  char ssid[IW_ESSID_MAX_SIZE + 1] = {0};
+  wreq.u.essid.pointer = ssid;
+  wreq.u.essid.length = IW_ESSID_MAX_SIZE;
+  int rv = ioctl(ioctl_socket, SIOCGIWESSID, &wreq);
+  close(ioctl_socket);
+  return (rv == 0) ? ssid : "";
+}
+
 }  // 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;
 
   struct ifreq ifr = {};
   ifr.ifr_ifindex = interface_index;
 
   if (ioctl(ioctl_socket.get(), SIOCGIFNAME, &ifr) == 0)
     strncpy(buf, ifr.ifr_name, IFNAMSIZ - 1);
   return buf;
 }
 
+// static
+std::string AddressTrackerLinux::ConnectionSSIDFromInterfaceList(
+    const NetworkInterfaceList& interfaces,
+    GetInterfaceSSIDFunction get_interface_ssid) {
+  std::string connected_ssid;
+  bool first = true;
+  for (size_t i = 0; i < interfaces.size(); ++i) {
+    if (interfaces[i].type != NetworkChangeNotifier::CONNECTION_WIFI)
+      return "";
+    std::string ssid = get_interface_ssid(interfaces[i].name);
+    if (first) {
+      first = false;
+      connected_ssid = ssid;
+    } else if (ssid != connected_ssid) {
+      return "";
+    }
+  }
+  return connected_ssid;
+}
+
 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),
       connection_type_initialized_(false),
       connection_type_initialized_cv_(&connection_type_lock_),
       current_connection_type_(NetworkChangeNotifier::CONNECTION_NONE),
       tracking_(false) {
@@ skipping 108 matching lines @@
     }
   }
 }
 
 void AddressTrackerLinux::AbortAndForceOnline() {
   CloseSocket();
   AddressTrackerAutoLock lock(*this, connection_type_lock_);
   current_connection_type_ = NetworkChangeNotifier::CONNECTION_UNKNOWN;
   connection_type_initialized_ = true;
   connection_type_initialized_cv_.Signal();
+  current_wifi_ssid_ = "";
 }
 
 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, connection_type_lock_);
   // Make sure the initial connection type is set before returning.
   while (!connection_type_initialized_) {
     connection_type_initialized_cv_.Wait();
   }
   return current_connection_type_;
 }
 
+std::string AddressTrackerLinux::GetCurrentWiFiSSID() {
+  // Don't wait for initialization, return an empty SSID if not initialized.
+  AddressTrackerAutoLock lock(*this, wifi_ssid_lock_);
+  return current_wifi_ssid_;
+}
+
 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 || *address_changed)
-    UpdateCurrentConnectionType();
+    UpdateCurrentConnectionTypeAndSSID();
 }
 
 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 99 matching lines @@
     PLOG(ERROR) << "Could not close NETLINK socket.";
   netlink_fd_ = -1;
 }
 
 bool AddressTrackerLinux::IsTunnelInterface(int interface_index) const {
   // Linux kernel drivers/net/tun.c uses "tun" name prefix.
   char buf[IFNAMSIZ] = {0};
   return strncmp(get_interface_name_(interface_index, buf), "tun", 3) == 0;
 }
 
-void AddressTrackerLinux::UpdateCurrentConnectionType() {
+void AddressTrackerLinux::UpdateCurrentConnectionTypeAndSSID() {
   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();) {
     if (IsTunnelInterface(*it)) {
       base::hash_set<int>::const_iterator tunnel_it = it;
       ++it;
       online_links.erase(*tunnel_it);
     } else {
       ++it;
     }
   }
 
   NetworkInterfaceList networks;
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::CONNECTION_NONE;
+  std::string ssid;
   if (GetNetworkListImpl(&networks, 0, online_links, address_map,
                          get_interface_name_)) {
     type = NetworkChangeNotifier::ConnectionTypeFromInterfaceList(networks);
+    ssid = ConnectionSSIDFromInterfaceList(networks, GetInterfaceSSID);
   } else {
     type = online_links.empty() ? NetworkChangeNotifier::CONNECTION_NONE
                                 : NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
-  AddressTrackerAutoLock lock(*this, connection_type_lock_);
-  current_connection_type_ = type;
+  {
+    AddressTrackerAutoLock lock(*this, connection_type_lock_);
+    current_connection_type_ = type;
+  }
+  {
+    AddressTrackerAutoLock lock(*this, wifi_ssid_lock_);
+    current_wifi_ssid_ = ssid;
+  }
 }
 
 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