[net/dns] Test IPv6 support via UDP connect (measurement)

net/dns/host_resolver_impl.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/dns/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 26 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/dns/address_sorter.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 #include "net/dns/host_resolver_proc.h"
+#include "net/socket/client_socket_factory.h"
+#include "net/udp/datagram_client_socket.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 namespace {
 
 // Limit the size of hostnames that will be resolved to combat issues in
@@ skipping 103 matching lines @@
   const size_t kSuffixLenTrimmed = kSuffixLen - 1;
   if (hostname[hostname.size() - 1] == '.') {
     return hostname.size() > kSuffixLen &&
         !hostname.compare(hostname.size() - kSuffixLen, kSuffixLen, kSuffix);
   }
   return hostname.size() > kSuffixLenTrimmed &&
       !hostname.compare(hostname.size() - kSuffixLenTrimmed, kSuffixLenTrimmed,
                         kSuffix, kSuffixLenTrimmed);
 }
 
+// Attempts to connect a UDP socket to |dest|:80.
+int AttemptRoute(const IPAddressNumber& dest) {
+  scoped_ptr<DatagramClientSocket> socket(
+      ClientSocketFactory::GetDefaultFactory()->CreateDatagramClientSocket(
+          DatagramSocket::DEFAULT_BIND,
+          RandIntCallback(),
+          NULL,
+          NetLog::Source()));
+  return socket->Connect(IPEndPoint(dest, 80));

[lorenzo, 2013/04/11 07:28:14]

Do you need to check that the address is a global address as well? That's what
the existing IPv6 probe does I think.

It's possible that some operating systems (perhaps OS X; Linux doesn't do this),
will try to connect to a global address even if they only have a link-local
address (which is very unlikely to work). On these systems, the connection probe
could return success even if there was no global address present on the machine.

If that's the case, you can call getsockname() to get the IP address the OS
picked for the connection and see if it's a global address.

+}
+
 // Provide a common macro to simplify code and readability. We must use a
 // macro as the underlying HISTOGRAM macro creates static variables.
 #define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
     base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromHours(1), 100)
 
 // A macro to simplify code and readability.
 #define DNS_HISTOGRAM_BY_PRIORITY(basename, priority, time) \
   do { \
     switch (priority) { \
       case HIGHEST: DNS_HISTOGRAM(basename "_HIGHEST", time); break; \
@@ skipping 701 matching lines @@
 
   BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcTask);
 };
 
 //-----------------------------------------------------------------------------
 
 // Wraps a call to TestIPv6Support to be executed on the WorkerPool as it takes
 // 40-100ms.
+// TODO(szym): Remove altogether, if IPv6ActiveProbe works.
 class HostResolverImpl::IPv6ProbeJob {
  public:
   IPv6ProbeJob(const base::WeakPtr<HostResolverImpl>& resolver, NetLog* net_log)
       : resolver_(resolver),
         net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_IPV6_PROBE_JOB)),
         result_(false, IPV6_SUPPORT_MAX, OK) {
     DCHECK(resolver);
     net_log_.BeginEvent(NetLog::TYPE_IPV6_PROBE_RUNNING);
     const bool kIsSlow = true;
     base::WorkerPool::PostTaskAndReply(
@@ skipping 950 matching lines @@
 void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
   DCHECK(CalledOnValidThread());
   default_address_family_ = address_family;
   ipv6_probe_monitoring_ = false;
 }
 
 AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
   return default_address_family_;
 }
 
+// TODO(szym): Remove this API altogether if IPv6ActiveProbe works.
 void HostResolverImpl::ProbeIPv6Support() {
   DCHECK(CalledOnValidThread());
   DCHECK(!ipv6_probe_monitoring_);
   ipv6_probe_monitoring_ = true;
   OnIPAddressChanged();
 }
 
 void HostResolverImpl::SetDnsClientEnabled(bool enabled) {
   DCHECK(CalledOnValidThread());
 #if defined(ENABLE_BUILT_IN_DNS)
@@ skipping 145 matching lines @@
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
     const RequestInfo& info) const {
   HostResolverFlags effective_flags =
       info.host_resolver_flags() | additional_resolver_flags_;
   AddressFamily effective_address_family = info.address_family();
+
+  if (info.address_family() == ADDRESS_FAMILY_UNSPECIFIED) {
+    base::TimeTicks start_time = base::TimeTicks::Now();
+    // Google DNS address.
+    const uint8 kIPv6Address[] =
+        { 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
+    int rv6 = AttemptRoute(
+        IPAddressNumber(kIPv6Address, kIPv6Address + arraysize(kIPv6Address)));
+
+    UMA_HISTOGRAM_TIMES("Net.IPv6ConnectDuration",
+                        base::TimeTicks::Now() - start_time);
+    if (rv6 == OK) {
+      UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectSuccessMatch",
+          default_address_family_ == ADDRESS_FAMILY_UNSPECIFIED);
+    } else {
+      UMA_HISTOGRAM_BOOLEAN("Net.IPv6ConnectFailureMatch",
+          default_address_family_ != ADDRESS_FAMILY_UNSPECIFIED);
+    }
+  }
+
   if (effective_address_family == ADDRESS_FAMILY_UNSPECIFIED &&
       default_address_family_ != ADDRESS_FAMILY_UNSPECIFIED) {
     effective_address_family = default_address_family_;
     if (ipv6_probe_monitoring_)
       effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
   }
+
   return Key(info.hostname(), effective_address_family, effective_flags);
 }
 
 void HostResolverImpl::AbortAllInProgressJobs() {
   // In Abort, a Request callback could spawn new Jobs with matching keys, so
   // first collect and remove all running jobs from |jobs_|.
   ScopedVector<Job> jobs_to_abort;
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ) {
     Job* job = it->second;
     if (job->is_running()) {
@@ skipping 134 matching lines @@
   }
   DnsConfig dns_config;
   NetworkChangeNotifier::GetDnsConfig(&dns_config);
   dns_client_->SetConfig(dns_config);
   num_dns_failures_ = 0;
   if (dns_config.IsValid())
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
 }
 
 }  // namespace net