Detect IPv6 interface is temporary or not.

net/base/net_util_posix.cc

 // Copyright (c) 2011 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.h"
 
 #include <sys/types.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.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"
 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 #if !defined(OS_ANDROID)
 #include <ifaddrs.h>
 #endif
 #include <net/if.h>
 #include <netinet/in.h>
 
+#if defined(OS_MACOSX) || defined(OS_BSD)
+#include <netinet/in_var.h>
+#include <sys/ioctl.h>
+#endif
+
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
 #endif
 
 namespace net {
 
+namespace {
+
+#if !defined(OS_ANDROID)
+
+struct NET_EXPORT NetworkInterfaceInfo {
+  NetworkInterfaceInfo() : permanent(true) {}
+
+  bool permanent;  // IPv6 has notion of temporary address. If the address is
+                   // IPv6 and it's temporary this field will be set to false.

[agl, 2014/03/27 14:52:53]

remove "set to"

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+  NetworkInterface interface;
+};
+
+// This method will remove permanent IPv6 address, if a temporary address

[agl, 2014/03/27 14:52:53]

remove comma

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+// is available for same network interface.
+void PruneIPv6Addresses(std::vector<NetworkInterfaceInfo>* infos) {

[agl, 2014/03/27 14:52:53]

I would go nuts with the name in order to make this clear, Blink style:

RemovePermanentIPv6AddressesWhereTemporaryExists

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

I Agree. 
On 2014/03/27 14:52:53, agl wrote:

+  // First find a temporary address. If available find permanent address
+  // belonging to same interface. If available remove it.
+
+  // Pushing all IPv6 temp addresses to a different list.
+  std::vector<NetworkInterfaceInfo> temp_ipv6_list;
+  std::vector<NetworkInterfaceInfo>::iterator iter = infos->begin();

[agl, 2014/03/27 14:52:53]

If you just just |i| for iter then you can use |j| rather than |piter|, below.

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+  for (; iter != infos->end(); ++iter) {

[agl, 2014/03/27 14:52:53]

do the assignment of iter in the first for clause.

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+    if (iter->permanent && iter->interface.address.size() == kIPv6AddressSize) {

[agl, 2014/03/27 14:52:53]

This is pushing permanent addresses into a list called temp_ipv6_list and also
contradicts the comment on L55.

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Yea, I discovered that later.
On 2014/03/27 14:52:53, agl wrote:

+      temp_ipv6_list.push_back(*iter);
+      iter = infos->erase(iter);
+    }
+  }
+
+  // Search for permenent address belonging to same network interface.
+  iter = temp_ipv6_list.begin();

[agl, 2014/03/27 14:52:53]

move into the for loop.

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+  for (; iter != temp_ipv6_list.end(); ++iter) {
+    std::string name = iter->interface.name;

[agl, 2014/03/27 14:52:53]

const &?

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

not needed.
On 2014/03/27 14:52:53, agl wrote:

+    std::vector<NetworkInterfaceInfo>::iterator piter = infos->begin();
+    for (; piter != infos->end(); ++piter) {
+      if (piter->interface.address.size() == kIPv4AddressSize)
+        continue;
+      if (piter->interface.name != iter->interface.name)

[agl, 2014/03/27 14:52:53]

RHS should be |name|?

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

removed now.
On 2014/03/27 14:52:53, agl wrote:

+        continue;
+      DCHECK_EQ(piter->interface.address.size(), kIPv6AddressSize);
+      piter = infos->erase(piter);
+    }
+  }

[agl, 2014/03/27 14:52:53]

Isn't it easier to do one pass building a set?:

set<string> ifaces_with_temp_addrs

for addr in addrs {
  if is_temp(addr) {
    ifaces_with_temp_addrs.add(addr.iface)
  }
}

for addr in addrs {
  if is_permanent(addr) && ifaces_with_temp_addrs.contains(addr.iface) {
    addrs.remove(addr)
  }
}

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Cool, that makes life bit easy.
On 2014/03/27 14:52:53, agl wrote:

+
+  // Push temp addresses back to original list.
+  iter = temp_ipv6_list.begin();
+  for (; iter != temp_ipv6_list.end(); ++iter) {
+    infos->push_back(*iter);
+  }
+
+  // TODO(mallinath) Above logic seems to be it "quirky", find better solution.
+}
+
+#endif
+
+}  // namespace
+
 bool FileURLToFilePath(const GURL& url, base::FilePath* path) {
   *path = base::FilePath();
   std::string& file_path_str = const_cast<std::string&>(path->value());
   file_path_str.clear();
 
   if (!url.is_valid())
     return false;
 
   // Firefox seems to ignore the "host" of a file url if there is one. That is,
   // file://foo/bar.txt maps to /bar.txt.
@@ skipping 14 matching lines @@
     new_path = old_path;
     ReplaceSubstringsAfterOffset(&new_path, 0, "//", "/");
     old_path.swap(new_path);
   } while (new_path != old_path);
 
   file_path_str.assign(old_path);
 
   return !file_path_str.empty();
 }
 
-bool GetNetworkList(NetworkInterfaceList* networks,
-                    HostScopeVirtualInterfacePolicy policy) {
+bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
 #if defined(OS_ANDROID)
   std::string network_list = android::GetNetworkList();
   base::StringTokenizer network_interfaces(network_list, "\n");
   while (network_interfaces.GetNext()) {
     std::string network_item = network_interfaces.token();
     base::StringTokenizer network_tokenizer(network_item, "\t");
     CHECK(network_tokenizer.GetNext());
     std::string name = network_tokenizer.token();
 
     CHECK(network_tokenizer.GetNext());
     std::string interface_address = network_tokenizer.token();
     IPAddressNumber address;
     size_t network_prefix = 0;
     CHECK(ParseCIDRBlock(network_tokenizer.token(),
                          &address,
                          &network_prefix));
 
     CHECK(network_tokenizer.GetNext());
     uint32 index = 0;
     CHECK(base::StringToUint(network_tokenizer.token(), &index));
 
     networks->push_back(
         NetworkInterface(name, name, index, address, network_prefix));
   }
   return true;
 #else
   // getifaddrs() may require IO operations.
   base::ThreadRestrictions::AssertIOAllowed();
 
+  int ioctl_socket = -1;
+  if (policy & INCLUDE_IPV6_TEMP_ADDRESS_IF_AVAILABLE) {
+    // we need a socket to query information about temporary address.
+    ioctl_socket = socket(AF_INET6, SOCK_DGRAM, 0);
+    DCHECK_GT(ioctl_socket, 0);
+  }
+
   ifaddrs *interfaces;
   if (getifaddrs(&interfaces) < 0) {
     PLOG(ERROR) << "getifaddrs";
     return false;
   }
 
+  std::vector<NetworkInterfaceInfo> network_infos;
+
   // Enumerate the addresses assigned to network interfaces which are up.
   for (ifaddrs *interface = interfaces;
        interface != NULL;
        interface = interface->ifa_next) {
     // Skip loopback interfaces, and ones which are down.
     if (!(IFF_UP & interface->ifa_flags))
       continue;
     if (IFF_LOOPBACK & interface->ifa_flags)
       continue;
     // Skip interfaces with no address configured.
@@ skipping 21 matching lines @@
           addr_in->sin_addr.s_addr == 0) {
         continue;
       }
     } else {
       // Skip non-IP addresses.
       continue;
     }
 
     const std::string& name = interface->ifa_name;
     // Filter out VMware interfaces, typically named vmnet1 and vmnet8.
-    if (policy == EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES &&
+    if (policy & EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES &&
         ((name.find("vmnet") != std::string::npos) ||
          (name.find("vnic") != std::string::npos))) {
       continue;
     }
+
+    NetworkInterfaceInfo network_info;
+#if defined(OS_MACOSX) || defined(OS_BSD)
+    // Check if this is a temporary address. Currently this is only supported
+    // on Mac.
+    if (policy & INCLUDE_IPV6_TEMP_ADDRESS_IF_AVAILABLE &&
+        ioctl_socket > 0 && addr->sa_family == AF_INET6) {

[agl, 2014/03/27 14:52:53]

ioctl_socket >= 0

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

+      struct in6_ifreq ifr = {};
+      strncpy(ifr.ifr_name, interface->ifa_name, sizeof(ifr.ifr_name) - 1);
+      memcpy(&ifr.ifr_ifru.ifru_addr, interface->ifa_addr,
+             interface->ifa_addr->sa_len);
+      int rv = ioctl(ioctl_socket, SIOCGIFAFLAG_IN6, &ifr);
+      if (rv >= 0) {
+        network_info.permanent = !(ifr.ifr_ifru.ifru_flags & IN6_IFF_TEMPORARY);
+      }
+    }
+#endif
+
     IPEndPoint address;
     if (address.FromSockAddr(addr, addr_size)) {
       uint8 net_mask = 0;
       if (interface->ifa_netmask) {
         // If not otherwise set, assume the same sa_family as ifa_addr.
         if (interface->ifa_netmask->sa_family == 0) {
           interface->ifa_netmask->sa_family = addr->sa_family;
         }
         IPEndPoint netmask;
         if (netmask.FromSockAddr(interface->ifa_netmask, addr_size)) {
           net_mask = MaskPrefixLength(netmask.address());
         }
       }
+      network_info.interface = NetworkInterface(
+          name, name, if_nametoindex(name.c_str()),
+          address.address(), net_mask);
 
-      networks->push_back(
-          NetworkInterface(name, name, if_nametoindex(name.c_str()),
-                           address.address(), net_mask));
+      network_infos.push_back(network_info);
     }
   }
+  freeifaddrs(interfaces);
+  close(ioctl_socket);

[agl, 2014/03/27 14:52:53]

guard this by an if - we shouldn't call close(-1) if we can help it.

[Mallinath (Gone from Chromium), 2014/03/27 19:04:18]

Done.

 
-  freeifaddrs(interfaces);
+  if (policy & INCLUDE_IPV6_TEMP_ADDRESS_IF_AVAILABLE) {
+    PruneIPv6Addresses(&network_infos);
+  }
 
+  for (size_t i = 0; i < network_infos.size(); ++i) {
+    networks->push_back(network_infos[i].interface);
+  }
   return true;
 #endif
 }
 
 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 }
 
 }  // namespace net