Revert 39996 - Refine IPv6 probe to require that the client has an IPv6 addre...

net/base/net_util.cc

 // Copyright (c) 2009 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 <algorithm>
 #include <map>
 #include <unicode/ucnv.h>
 #include <unicode/uidna.h>
 #include <unicode/ulocdata.h>
 #include <unicode/uniset.h>
 #include <unicode/uscript.h>
 #include <unicode/uset.h>
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <wspiapi.h>  // Needed for Win2k compat.
 #elif defined(OS_POSIX)
+#include <netdb.h>
+#include <sys/socket.h>
 #include <fcntl.h>
-#include <ifaddrs.h>
-#include <netdb.h>
-#include <net/if.h>
-#include <sys/socket.h>
 #endif
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/string_escape.h"
@@ skipping 213 matching lines @@
   ucnv_close(converter);
   if (U_FAILURE(err)) {
     return false;
   }
   output->resize(length);
   return true;
 }
 
 bool DecodeWord(const std::string& encoded_word,
                 const std::string& referrer_charset,
-                bool* is_rfc2047,
+                bool *is_rfc2047,
                 std::string* output) {
   if (!IsStringASCII(encoded_word)) {
     // Try UTF-8, referrer_charset and the native OS default charset in turn.
     if (IsStringUTF8(encoded_word)) {
       *output = encoded_word;
     } else {
       std::wstring wide_output;
       if (!referrer_charset.empty() &&
           base::CodepageToWide(encoded_word, referrer_charset.c_str(),
                                base::OnStringConversionError::FAIL,
@@ skipping 1263 matching lines @@
             allowed_ports.substr(last, length))));
       last = i + 1;
     }
   }
   explicitly_allowed_ports = ports;
 }
 
 enum IPv6SupportStatus {
   IPV6_CANNOT_CREATE_SOCKETS,
   IPV6_CAN_CREATE_SOCKETS,
-  IPV6_GETIFADDRS_FAILED,
-  IPV6_GLOBAL_ADDRESS_MISSING,
-  IPV6_GLOBAL_ADDRESS_PRESENT,
   IPV6_SUPPORT_MAX  // Bounding values for enumeration.
 };
 
 static void IPv6SupportResults(IPv6SupportStatus result) {
   static bool run_once = false;
-  if (run_once) {
-    run_once = true;
-    UMA_HISTOGRAM_ENUMERATION("Net.IPv6Status", result, IPV6_SUPPORT_MAX);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("Net.IPv6Status_retest", result,
-                              IPV6_SUPPORT_MAX);
-  }
+  if (run_once)
+    return;
+  run_once = true;
+  UMA_HISTOGRAM_ENUMERATION("Net.IPv6Status", result, IPV6_SUPPORT_MAX);
 }
 
 // TODO(jar): The following is a simple estimate of IPv6 support.  We may need
 // to do a test resolution, and a test connection, to REALLY verify support.
 // static
 bool IPv6Supported() {
 #if defined(OS_POSIX)
-  int test_socket = socket(AF_INET6, SOCK_STREAM, 0);
+  int test_socket;
+
+  test_socket = socket(AF_INET6, SOCK_STREAM, 0);
   if (test_socket == -1) {
     IPv6SupportResults(IPV6_CANNOT_CREATE_SOCKETS);
     return false;
   }
+
   close(test_socket);
-
-  // Check to see if any interface has a IPv6 address.
-  struct ifaddrs* interface_addr = NULL;
-  int rv = getifaddrs(&interface_addr);
-  if (rv != 0) {
-     IPv6SupportResults(IPV6_GETIFADDRS_FAILED);
-     return true;  // Don't yet block IPv6.
-  }
-
-  bool found_ipv6 = false;
-  for (struct ifaddrs* interface = interface_addr;
-       interface != NULL;
-       interface = interface->ifa_next) {
-    if (!(IFF_UP & interface->ifa_flags))
-      continue;
-    if (IFF_LOOPBACK & interface->ifa_flags)
-      continue;
-    struct sockaddr* addr = interface->ifa_addr;
-    if (!addr)
-      continue;
-    if (addr->sa_family != AF_INET6)
-      continue;
-    // Safe cast since this is AF_INET6.
-    struct sockaddr_in6* addr_in6 =
-      reinterpret_cast<struct sockaddr_in6*>(addr);
-    struct in6_addr* sin6_addr = &addr_in6->sin6_addr;
-    if (IN6_IS_ADDR_LOOPBACK(sin6_addr) || IN6_IS_ADDR_LINKLOCAL(sin6_addr))
-      continue;
-    found_ipv6 = true;
-    break;
-  }
-  freeifaddrs(interface_addr);
-  if (!found_ipv6) {
-    IPv6SupportResults(IPV6_GLOBAL_ADDRESS_MISSING);
-    return false;
-  }
-
-  IPv6SupportResults(IPV6_GLOBAL_ADDRESS_PRESENT);
+  IPv6SupportResults(IPV6_CAN_CREATE_SOCKETS);
   return true;
 #elif defined(OS_WIN)
   EnsureWinsockInit();
-  SOCKET test_socket = socket(AF_INET6, SOCK_STREAM, 0);
+  SOCKET test_socket;
+
+  test_socket = socket(AF_INET6, SOCK_STREAM, 0);
   if (test_socket == INVALID_SOCKET) {
     IPv6SupportResults(IPV6_CANNOT_CREATE_SOCKETS);
     return false;
   }
+
   closesocket(test_socket);
   IPv6SupportResults(IPV6_CAN_CREATE_SOCKETS);
   return true;
 #else
   NOTIMPLEMENTED();
   return true;
 #endif  // defined(various platforms)
 }
 
+
 }  // namespace net