Enable IPv6 temporary address filtering on iOS

webrtc/base/network.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include "webrtc/base/network.h"
 
 #if defined(WEBRTC_POSIX)
 // linux/if.h can't be included at the same time as the posix sys/if.h, and
 // it's transitively required by linux/route.h, so include that version on
 // linux instead of the standard posix one.
 #if defined(WEBRTC_LINUX)
 #include <linux/if.h>
 #include <linux/route.h>
 #elif !defined(__native_client__)
 #include <net/if.h>
 #endif
-#include <sys/socket.h>
-#include <sys/utsname.h>
-#include <sys/ioctl.h>
-#include <unistd.h>
-#include <errno.h>
-
-#if defined(WEBRTC_ANDROID)
-#include "webrtc/base/ifaddrs-android.h"
-#elif !defined(__native_client__)
-#include <ifaddrs.h>
-#endif
-
 #endif  // WEBRTC_POSIX
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #include <Iphlpapi.h>
+#else
+#include "webrtc/base/ifaddrs_converter.h"
 #endif
 
 #include <stdio.h>
 
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socket.h"  // includes something that makes windows happy
@@ skipping 68 matching lines @@
     case ADAPTER_TYPE_VPN:
       return "VPN";
     case ADAPTER_TYPE_LOOPBACK:
       return "Loopback";
     default:
       RTC_DCHECK(false) << "Invalid type " << type;
       return std::string();
   }
 }
 
-bool IsIgnoredIPv6(const IPAddress& ip) {
+bool IsIgnoredIPv6(const InterfaceAddress& ip) {
   if (ip.family() != AF_INET6) {
     return false;
   }
 
   // Link-local addresses require scope id to be bound successfully.
   // However, our IPAddress structure doesn't carry that so the
   // information is lost and causes binding failure.
   if (IPIsLinkLocal(ip)) {
     return true;
   }
 
   // Any MAC based IPv6 should be avoided to prevent the MAC tracking.
   if (IPIsMacBased(ip)) {
     return true;
   }
 
+  // Ignore deprecated IPv6.
+  if (ip.ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED) {
+    return true;
+  }
+
   return false;
 }
 
 }  // namespace
 
 // These addresses are used as the targets to find out the default local address
 // on a multi-homed endpoint. They are actually DNS servers.
 const char kPublicIPv4Host[] = "8.8.8.8";
 const char kPublicIPv6Host[] = "2001:4860:4860::8888";
 const int kPublicPort = 53;  // DNS port.
@@ skipping 227 matching lines @@
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   ASSERT(false);
   LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
   return false;
 }
 
 #elif defined(WEBRTC_POSIX)
 void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
+                                         IfAddrsConverter* ifaddrs_converter,
                                          bool include_ignored,
                                          NetworkList* networks) const {
   NetworkMap current_networks;
+
   for (struct ifaddrs* cursor = interfaces;
        cursor != NULL; cursor = cursor->ifa_next) {
     IPAddress prefix;
     IPAddress mask;
-    IPAddress ip;
+    InterfaceAddress ip;
     int scope_id = 0;
 
     // Some interfaces may not have address assigned.
-    if (!cursor->ifa_addr || !cursor->ifa_netmask)
+    if (!cursor->ifa_addr || !cursor->ifa_netmask) {
       continue;
+    }
+    // Skip ones which are down.
+    if (!(cursor->ifa_flags & IFF_RUNNING)) {
+      continue;
+    }
+    // Skip unknown family.
+    if (cursor->ifa_addr->sa_family != AF_INET &&
+        cursor->ifa_addr->sa_family != AF_INET6) {
+      continue;
+    }
+    // Skip IPv6 if not enabled.
+    if (cursor->ifa_addr->sa_family == AF_INET6 && !ipv6_enabled()) {
+      continue;
+    }
+    // Convert to InterfaceAddress.
+    if (!ifaddrs_converter->ConvertIfAddrsToIPAddress(cursor, &ip, &mask)) {
+      continue;
+    }
 
-    switch (cursor->ifa_addr->sa_family) {
-      case AF_INET: {
-        ip = IPAddress(
-            reinterpret_cast<sockaddr_in*>(cursor->ifa_addr)->sin_addr);
-        mask = IPAddress(
-            reinterpret_cast<sockaddr_in*>(cursor->ifa_netmask)->sin_addr);
-        break;
-      }
-      case AF_INET6: {
-        if (ipv6_enabled()) {
-          ip = IPAddress(
-              reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_addr);
-
-          if (IsIgnoredIPv6(ip)) {
-            continue;
-          }
-
-          mask = IPAddress(
-              reinterpret_cast<sockaddr_in6*>(cursor->ifa_netmask)->sin6_addr);
-          scope_id =
-              reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
-          break;
-        } else {
-          continue;
-        }
-      }
-      default: {
+    // Special case for IPv6 address.
+    if (cursor->ifa_addr->sa_family == AF_INET6) {
+      if (IsIgnoredIPv6(ip)) {
         continue;
       }
+      scope_id =
+          reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
     }
 
     int prefix_length = CountIPMaskBits(mask);
     prefix = TruncateIP(ip, prefix_length);
     std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
                                      prefix, prefix_length);
     auto existing_network = current_networks.find(key);
     if (existing_network == current_networks.end()) {
       AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
       if (cursor->ifa_flags & IFF_LOOPBACK) {
@@ skipping 25 matching lines @@
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   struct ifaddrs* interfaces;
   int error = getifaddrs(&interfaces);
   if (error != 0) {
     LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
     return false;
   }
 
-  ConvertIfAddrs(interfaces, include_ignored, networks);
+  rtc::scoped_ptr<IfAddrsConverter> ifaddrs_converter(CreateIfAddrsConverter());
+  ConvertIfAddrs(interfaces, ifaddrs_converter.get(), include_ignored,
+                 networks);
 
   freeifaddrs(interfaces);
   return true;
 }
 
 #elif defined(WEBRTC_WIN)
 
 unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
               const IPAddress& ip, IPAddress* prefix) {
   IPAddress current_prefix;
@@ skipping 424 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc