Determine connection type in NetworkChangeNotifierLinux.

net/base/net_util_linux.cc

 // Copyright (c) 2014 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/net_util_linux.h"
 
-#include <net/if.h>
-#include <netinet/in.h>
+#include <linux/if.h>
+#include <linux/wireless.h>
+#include <sys/ioctl.h>

[pauljensen, 2015/01/13 13:14:30]

I think this should be moved below <set> for alphabetical reasons

[derekjchow1, 2015/01/13 21:32:39]

Done.

 #include <set>
 #include <sys/types.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 43 matching lines @@
 namespace internal {
 
 inline const unsigned char* GetIPAddressData(const IPAddressNumber& ip) {
 #if defined(OS_ANDROID)
   return ip.begin();
 #else
   return ip.data();
 #endif
 }
 
+char* GetInterfaceName(unsigned int interface_index, char* buf) {
+  int ioctl_socket = socket(AF_INET, SOCK_DGRAM, 0);
+  if (ioctl_socket < 0) {
+    strncpy(buf, "", IFNAMSIZ);

[pauljensen, 2015/01/13 13:14:30]

Can we remove this strncpy and add a memset(buf, 0, IFNAMSIZ) at the beginning
of the function?

[derekjchow1, 2015/01/13 21:32:35]

Done.

+    return buf;
+  }
+  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) {
+    strncpy(buf, "", IFNAMSIZ);

[pauljensen, 2015/01/13 13:14:30]

Ditto.

[derekjchow1, 2015/01/13 21:32:35]

Done.

+    return buf;
+  }
+  strncpy(buf, ifr.ifr_name, IFNAMSIZ);

[pauljensen, 2015/01/13 13:14:30]

This could result in an unterminated string causing other parts of the code to
read off the end of the arrays.  If we memset() the string to 0's at the
beginning of the function I think we should make this only copy IFNAMSIZ-1
bytes.

[derekjchow1, 2015/01/13 21:32:35]

Done.

+  return buf;
+}
+
+NetworkChangeNotifier::ConnectionType GetInterfaceConnectionType(
+    std::string ifname) {
+  NetworkChangeNotifier::ConnectionType type =
+      NetworkChangeNotifier::CONNECTION_UNKNOWN;
+
+  int s = socket(AF_INET, SOCK_STREAM, 0);
+  if (s == -1) {
+    return type;
+  }
+
+  struct iwreq pwrq;
+  memset(&pwrq, 0, sizeof(pwrq));
+  strncpy(pwrq.ifr_name, ifname.c_str(), IFNAMSIZ);
+
+  if (ioctl(s, SIOCGIWNAME, &pwrq) != -1) {
+    type = NetworkChangeNotifier::CONNECTION_WIFI;
+  } else {
+    type = NetworkChangeNotifier::CONNECTION_UNKNOWN;
+  }
+
+  close(s);
+  return type;
+}
+
 bool GetNetworkListImpl(
     NetworkInterfaceList* networks,
     int policy,
     const base::hash_set<int>& online_links,
     const internal::AddressTrackerLinux::AddressMap& address_map,
     GetInterfaceNameFunction get_interface_name) {
   std::map<int, std::string> ifnames;
 
   for (internal::AddressTrackerLinux::AddressMap::const_iterator it =
            address_map.begin();
@@ skipping 23 matching lines @@
       if (!TryConvertNativeToNetIPAttributes(it->second.ifa_flags,
                                              &ip_attributes))
         continue;
     }
 
     // Find the name of this link.
     std::map<int, std::string>::const_iterator itname =
         ifnames.find(it->second.ifa_index);
     std::string ifname;
     if (itname == ifnames.end()) {
-      char buffer[IF_NAMESIZE] = {0};
+      char buffer[IFNAMSIZ] = {0};
       if (get_interface_name(it->second.ifa_index, buffer)) {
         ifname = ifnames[it->second.ifa_index] = buffer;
       } else {
         // Ignore addresses whose interface name can't be retrieved.
         continue;
       }
     } else {
       ifname = itname->second;
     }
 
     // Based on the interface name and policy, determine whether we
     // should ignore it.
     if (ShouldIgnoreInterface(ifname, policy))
       continue;
 
+    NetworkChangeNotifier::ConnectionType type =
+        GetInterfaceConnectionType(ifname);
+
     networks->push_back(
-        NetworkInterface(ifname, ifname, it->second.ifa_index,
-                         NetworkChangeNotifier::CONNECTION_UNKNOWN, it->first,
+        NetworkInterface(ifname, ifname, it->second.ifa_index, type, it->first,
                          it->second.ifa_prefixlen, ip_attributes));
   }
 
   return true;
 }
 
 }  // namespace internal
 
 bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
   if (networks == NULL)
     return false;
 
   internal::AddressTrackerLinux tracker;
   tracker.Init();
 
-  return internal::GetNetworkListImpl(networks, policy,
-                                      tracker.GetOnlineLinks(),
-                                      tracker.GetAddressMap(), &if_indextoname);
+  return internal::GetNetworkListImpl(
+      networks, policy, tracker.GetOnlineLinks(), tracker.GetAddressMap(),
+      &internal::GetInterfaceName);
 }
 
 }  // namespace net