net/dns/dns_transaction.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/dns/dns_transaction.h"
   6
   7 #include <deque>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/rand_util.h"
  19 #include "base/stl_util.h"
  20 #include "base/strings/string_piece.h"
  21 #include "base/threading/non_thread_safe.h"
  22 #include "base/timer/timer.h"
  23 #include "base/values.h"
  24 #include "net/base/big_endian.h"
  25 #include "net/base/completion_callback.h"
  26 #include "net/base/dns_util.h"
  27 #include "net/base/io_buffer.h"
  28 #include "net/base/ip_endpoint.h"
  29 #include "net/base/net_errors.h"
  30 #include "net/base/net_log.h"
  31 #include "net/dns/dns_protocol.h"
  32 #include "net/dns/dns_query.h"
  33 #include "net/dns/dns_response.h"
  34 #include "net/dns/dns_session.h"
  35 #include "net/socket/stream_socket.h"
  36 #include "net/udp/datagram_client_socket.h"
  37
  38 namespace net {
  39
  40 namespace {
  41
  42 // Provide a common macro to simplify code and readability. We must use a
  43 // macro as the underlying HISTOGRAM macro creates static variables.
  44 #define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
  45     base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromHours(1), 100)
  46
  47 // Count labels in the fully-qualified name in DNS format.
  48 int CountLabels(const std::string& name) {
  49   size_t count = 0;
  50   for (size_t i = 0; i < name.size() && name[i]; i += name[i] + 1)
  51     ++count;
  52   return count;
  53 }
  54
  55 bool IsIPLiteral(const std::string& hostname) {
  56   IPAddressNumber ip;
  57   return ParseIPLiteralToNumber(hostname, &ip);
  58 }
  59
  60 base::Value* NetLogStartCallback(const std::string* hostname,
  61                            uint16 qtype,
  62                            NetLog::LogLevel /* log_level */) {
  63   base::DictionaryValue* dict = new base::DictionaryValue();
  64   dict->SetString("hostname", *hostname);
  65   dict->SetInteger("query_type", qtype);
  66   return dict;
  67 };
  68
  69 // ----------------------------------------------------------------------------
  70
  71 // A single asynchronous DNS exchange, which consists of sending out a
  72 // DNS query, waiting for a response, and returning the response that it
  73 // matches. Logging is done in the socket and in the outer DnsTransaction.
  74 class DnsAttempt {
  75  public:
  76   explicit DnsAttempt(unsigned server_index)
  77       : result_(ERR_FAILED), server_index_(server_index) {}
  78
  79   virtual ~DnsAttempt() {}
  80   // Starts the attempt. Returns ERR_IO_PENDING if cannot complete synchronously
  81   // and calls |callback| upon completion.
  82   virtual int Start(const CompletionCallback& callback) = 0;
  83
  84   // Returns the query of this attempt.
  85   virtual const DnsQuery* GetQuery() const = 0;
  86
  87   // Returns the response or NULL if has not received a matching response from
  88   // the server.
  89   virtual const DnsResponse* GetResponse() const = 0;
  90
  91   // Returns the net log bound to the source of the socket.
  92   virtual const BoundNetLog& GetSocketNetLog() const = 0;
  93
  94   // Returns the index of the destination server within DnsConfig::nameservers.
  95   unsigned server_index() const { return server_index_; }
  96
  97   // Returns a Value representing the received response, along with a reference
  98   // to the NetLog source source of the UDP socket used.  The request must have
  99   // completed before this is called.
 100   base::Value* NetLogResponseCallback(NetLog::LogLevel log_level) const {
 101     DCHECK(GetResponse()->IsValid());
 102
 103     base::DictionaryValue* dict = new base::DictionaryValue();
 104     dict->SetInteger("rcode", GetResponse()->rcode());
 105     dict->SetInteger("answer_count", GetResponse()->answer_count());
 106     GetSocketNetLog().source().AddToEventParameters(dict);
 107     return dict;
 108   }
 109
 110   void set_result(int result) {
 111     result_ = result;
 112   }
 113
 114   // True if current attempt is pending (waiting for server response).
 115   bool is_pending() const {
 116     return result_ == ERR_IO_PENDING;
 117   }
 118
 119   // True if attempt is completed (received server response).
 120   bool is_completed() const {
 121     return (result_ == OK) || (result_ == ERR_NAME_NOT_RESOLVED) ||
 122         (result_ == ERR_DNS_SERVER_REQUIRES_TCP);
 123   }
 124
 125  private:
 126   // Result of last operation.
 127   int result_;
 128
 129   const unsigned server_index_;
 130 };
 131
 132 class DnsUDPAttempt : public DnsAttempt {
 133  public:
 134   DnsUDPAttempt(unsigned server_index,
 135                 scoped_ptr<DnsSession::SocketLease> socket_lease,
 136                 scoped_ptr<DnsQuery> query)
 137       : DnsAttempt(server_index),
 138         next_state_(STATE_NONE),
 139         received_malformed_response_(false),
 140         socket_lease_(socket_lease.Pass()),
 141         query_(query.Pass()) {}
 142
 143   // DnsAttempt:
 144   virtual int Start(const CompletionCallback& callback) OVERRIDE {
 145     DCHECK_EQ(STATE_NONE, next_state_);
 146     callback_ = callback;
 147     start_time_ = base::TimeTicks::Now();
 148     next_state_ = STATE_SEND_QUERY;
 149     return DoLoop(OK);
 150   }
 151
 152   virtual const DnsQuery* GetQuery() const OVERRIDE {
 153     return query_.get();
 154   }
 155
 156   virtual const DnsResponse* GetResponse() const OVERRIDE {
 157     const DnsResponse* resp = response_.get();
 158     return (resp != NULL && resp->IsValid()) ? resp : NULL;
 159   }
 160
 161   virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
 162     return socket_lease_->socket()->NetLog();
 163   }
 164
 165  private:
 166   enum State {
 167     STATE_SEND_QUERY,
 168     STATE_SEND_QUERY_COMPLETE,
 169     STATE_READ_RESPONSE,
 170     STATE_READ_RESPONSE_COMPLETE,
 171     STATE_NONE,
 172   };
 173
 174   DatagramClientSocket* socket() {
 175     return socket_lease_->socket();
 176   }
 177
 178   int DoLoop(int result) {
 179     CHECK_NE(STATE_NONE, next_state_);
 180     int rv = result;
 181     do {
 182       State state = next_state_;
 183       next_state_ = STATE_NONE;
 184       switch (state) {
 185         case STATE_SEND_QUERY:
 186           rv = DoSendQuery();
 187           break;
 188         case STATE_SEND_QUERY_COMPLETE:
 189           rv = DoSendQueryComplete(rv);
 190           break;
 191         case STATE_READ_RESPONSE:
 192           rv = DoReadResponse();
 193           break;
 194         case STATE_READ_RESPONSE_COMPLETE:
 195           rv = DoReadResponseComplete(rv);
 196           break;
 197         default:
 198           NOTREACHED();
 199           break;
 200       }
 201     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 202
 203     set_result(rv);
 204     // If we received a malformed response, and are now waiting for another one,
 205     // indicate to the transaction that the server might be misbehaving.
 206     if (rv == ERR_IO_PENDING && received_malformed_response_)
 207       return ERR_DNS_MALFORMED_RESPONSE;
 208     if (rv == OK) {
 209       DCHECK_EQ(STATE_NONE, next_state_);
 210       DNS_HISTOGRAM("AsyncDNS.UDPAttemptSuccess",
 211                     base::TimeTicks::Now() - start_time_);
 212     } else if (rv != ERR_IO_PENDING) {
 213       DNS_HISTOGRAM("AsyncDNS.UDPAttemptFail",
 214                     base::TimeTicks::Now() - start_time_);
 215     }
 216     return rv;
 217   }
 218
 219   int DoSendQuery() {
 220     next_state_ = STATE_SEND_QUERY_COMPLETE;
 221     return socket()->Write(query_->io_buffer(),
 222                            query_->io_buffer()->size(),
 223                            base::Bind(&DnsUDPAttempt::OnIOComplete,
 224                                       base::Unretained(this)));
 225   }
 226
 227   int DoSendQueryComplete(int rv) {
 228     DCHECK_NE(ERR_IO_PENDING, rv);
 229     if (rv < 0)
 230       return rv;
 231
 232     // Writing to UDP should not result in a partial datagram.
 233     if (rv != query_->io_buffer()->size())
 234       return ERR_MSG_TOO_BIG;
 235
 236     next_state_ = STATE_READ_RESPONSE;
 237     return OK;
 238   }
 239
 240   int DoReadResponse() {
 241     next_state_ = STATE_READ_RESPONSE_COMPLETE;
 242     response_.reset(new DnsResponse());
 243     return socket()->Read(response_->io_buffer(),
 244                           response_->io_buffer()->size(),
 245                           base::Bind(&DnsUDPAttempt::OnIOComplete,
 246                                      base::Unretained(this)));
 247   }
 248
 249   int DoReadResponseComplete(int rv) {
 250     DCHECK_NE(ERR_IO_PENDING, rv);
 251     if (rv < 0)
 252       return rv;
 253
 254     DCHECK(rv);
 255     if (!response_->InitParse(rv, *query_)) {
 256       // Other implementations simply ignore mismatched responses. Since each
 257       // DnsUDPAttempt binds to a different port, we might find that responses
 258       // to previously timed out queries lead to failures in the future.
 259       // Our solution is to make another attempt, in case the query truly
 260       // failed, but keep this attempt alive, in case it was a false alarm.
 261       received_malformed_response_ = true;
 262       next_state_ = STATE_READ_RESPONSE;
 263       return OK;
 264     }
 265     if (response_->flags() & dns_protocol::kFlagTC)
 266       return ERR_DNS_SERVER_REQUIRES_TCP;
 267     // TODO(szym): Extract TTL for NXDOMAIN results. http://crbug.com/115051
 268     if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
 269       return ERR_NAME_NOT_RESOLVED;
 270     if (response_->rcode() != dns_protocol::kRcodeNOERROR)
 271       return ERR_DNS_SERVER_FAILED;
 272
 273     return OK;
 274   }
 275
 276   void OnIOComplete(int rv) {
 277     rv = DoLoop(rv);
 278     if (rv != ERR_IO_PENDING)
 279       callback_.Run(rv);
 280   }
 281
 282   State next_state_;
 283   bool received_malformed_response_;
 284   base::TimeTicks start_time_;
 285
 286   scoped_ptr<DnsSession::SocketLease> socket_lease_;
 287   scoped_ptr<DnsQuery> query_;
 288
 289   scoped_ptr<DnsResponse> response_;
 290
 291   CompletionCallback callback_;
 292
 293   DISALLOW_COPY_AND_ASSIGN(DnsUDPAttempt);
 294 };
 295
 296 class DnsTCPAttempt : public DnsAttempt {
 297  public:
 298   DnsTCPAttempt(unsigned server_index,
 299                 scoped_ptr<StreamSocket> socket,
 300                 scoped_ptr<DnsQuery> query)
 301       : DnsAttempt(server_index),
 302         next_state_(STATE_NONE),
 303         socket_(socket.Pass()),
 304         query_(query.Pass()),
 305         length_buffer_(new IOBufferWithSize(sizeof(uint16))),
 306         response_length_(0) {}
 307
 308   // DnsAttempt:
 309   virtual int Start(const CompletionCallback& callback) OVERRIDE {
 310     DCHECK_EQ(STATE_NONE, next_state_);
 311     callback_ = callback;
 312     start_time_ = base::TimeTicks::Now();
 313     next_state_ = STATE_CONNECT_COMPLETE;
 314     int rv = socket_->Connect(base::Bind(&DnsTCPAttempt::OnIOComplete,
 315                                          base::Unretained(this)));
 316     if (rv == ERR_IO_PENDING) {
 317       set_result(rv);
 318       return rv;
 319     }
 320     return DoLoop(rv);
 321   }
 322
 323   virtual const DnsQuery* GetQuery() const OVERRIDE {
 324     return query_.get();
 325   }
 326
 327   virtual const DnsResponse* GetResponse() const OVERRIDE {
 328     const DnsResponse* resp = response_.get();
 329     return (resp != NULL && resp->IsValid()) ? resp : NULL;
 330   }
 331
 332   virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
 333     return socket_->NetLog();
 334   }
 335
 336  private:
 337   enum State {
 338     STATE_CONNECT_COMPLETE,
 339     STATE_SEND_LENGTH,
 340     STATE_SEND_QUERY,
 341     STATE_READ_LENGTH,
 342     STATE_READ_RESPONSE,
 343     STATE_NONE,
 344   };
 345
 346   int DoLoop(int result) {
 347     CHECK_NE(STATE_NONE, next_state_);
 348     int rv = result;
 349     do {
 350       State state = next_state_;
 351       next_state_ = STATE_NONE;
 352       switch (state) {
 353         case STATE_CONNECT_COMPLETE:
 354           rv = DoConnectComplete(rv);
 355           break;
 356         case STATE_SEND_LENGTH:
 357           rv = DoSendLength(rv);
 358           break;
 359         case STATE_SEND_QUERY:
 360           rv = DoSendQuery(rv);
 361           break;
 362         case STATE_READ_LENGTH:
 363           rv = DoReadLength(rv);
 364           break;
 365         case STATE_READ_RESPONSE:
 366           rv = DoReadResponse(rv);
 367           break;
 368         default:
 369           NOTREACHED();
 370           break;
 371       }
 372     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 373
 374     set_result(rv);
 375     if (rv == OK) {
 376       DCHECK_EQ(STATE_NONE, next_state_);
 377       DNS_HISTOGRAM("AsyncDNS.TCPAttemptSuccess",
 378                     base::TimeTicks::Now() - start_time_);
 379     } else if (rv != ERR_IO_PENDING) {
 380       DNS_HISTOGRAM("AsyncDNS.TCPAttemptFail",
 381                     base::TimeTicks::Now() - start_time_);
 382     }
 383     return rv;
 384   }
 385
 386   int DoConnectComplete(int rv) {
 387     DCHECK_NE(ERR_IO_PENDING, rv);
 388     if (rv < 0)
 389       return rv;
 390
 391     WriteBigEndian<uint16>(length_buffer_->data(), query_->io_buffer()->size());
 392     buffer_ =
 393         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
 394     next_state_ = STATE_SEND_LENGTH;
 395     return OK;
 396   }
 397
 398   int DoSendLength(int rv) {
 399     DCHECK_NE(ERR_IO_PENDING, rv);
 400     if (rv < 0)
 401       return rv;
 402
 403     buffer_->DidConsume(rv);
 404     if (buffer_->BytesRemaining() > 0) {
 405       next_state_ = STATE_SEND_LENGTH;
 406       return socket_->Write(
 407           buffer_.get(),
 408           buffer_->BytesRemaining(),
 409           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
 410     }
 411     buffer_ = new DrainableIOBuffer(query_->io_buffer(),
 412                                     query_->io_buffer()->size());
 413     next_state_ = STATE_SEND_QUERY;
 414     return OK;
 415   }
 416
 417   int DoSendQuery(int rv) {
 418     DCHECK_NE(ERR_IO_PENDING, rv);
 419     if (rv < 0)
 420       return rv;
 421
 422     buffer_->DidConsume(rv);
 423     if (buffer_->BytesRemaining() > 0) {
 424       next_state_ = STATE_SEND_QUERY;
 425       return socket_->Write(
 426           buffer_.get(),
 427           buffer_->BytesRemaining(),
 428           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
 429     }
 430     buffer_ =
 431         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
 432     next_state_ = STATE_READ_LENGTH;
 433     return OK;
 434   }
 435
 436   int DoReadLength(int rv) {
 437     DCHECK_NE(ERR_IO_PENDING, rv);
 438     if (rv < 0)
 439       return rv;
 440
 441     buffer_->DidConsume(rv);
 442     if (buffer_->BytesRemaining() > 0) {
 443       next_state_ = STATE_READ_LENGTH;
 444       return socket_->Read(
 445           buffer_.get(),
 446           buffer_->BytesRemaining(),
 447           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
 448     }
 449     ReadBigEndian<uint16>(length_buffer_->data(), &response_length_);
 450     // Check if advertised response is too short. (Optimization only.)
 451     if (response_length_ < query_->io_buffer()->size())
 452       return ERR_DNS_MALFORMED_RESPONSE;
 453     // Allocate more space so that DnsResponse::InitParse sanity check passes.
 454     response_.reset(new DnsResponse(response_length_ + 1));
 455     buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
 456     next_state_ = STATE_READ_RESPONSE;
 457     return OK;
 458   }
 459
 460   int DoReadResponse(int rv) {
 461     DCHECK_NE(ERR_IO_PENDING, rv);
 462     if (rv < 0)
 463       return rv;
 464
 465     buffer_->DidConsume(rv);
 466     if (buffer_->BytesRemaining() > 0) {
 467       next_state_ = STATE_READ_RESPONSE;
 468       return socket_->Read(
 469           buffer_.get(),
 470           buffer_->BytesRemaining(),
 471           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
 472     }
 473     if (!response_->InitParse(buffer_->BytesConsumed(), *query_))
 474       return ERR_DNS_MALFORMED_RESPONSE;
 475     if (response_->flags() & dns_protocol::kFlagTC)
 476       return ERR_UNEXPECTED;
 477     // TODO(szym): Frankly, none of these are expected.
 478     if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
 479       return ERR_NAME_NOT_RESOLVED;
 480     if (response_->rcode() != dns_protocol::kRcodeNOERROR)
 481       return ERR_DNS_SERVER_FAILED;
 482
 483     return OK;
 484   }
 485
 486   void OnIOComplete(int rv) {
 487     rv = DoLoop(rv);
 488     if (rv != ERR_IO_PENDING)
 489       callback_.Run(rv);
 490   }
 491
 492   State next_state_;
 493   base::TimeTicks start_time_;
 494
 495   scoped_ptr<StreamSocket> socket_;
 496   scoped_ptr<DnsQuery> query_;
 497   scoped_refptr<IOBufferWithSize> length_buffer_;
 498   scoped_refptr<DrainableIOBuffer> buffer_;
 499
 500   uint16 response_length_;
 501   scoped_ptr<DnsResponse> response_;
 502
 503   CompletionCallback callback_;
 504
 505   DISALLOW_COPY_AND_ASSIGN(DnsTCPAttempt);
 506 };
 507
 508 // ----------------------------------------------------------------------------
 509
 510 // Implements DnsTransaction. Configuration is supplied by DnsSession.
 511 // The suffix list is built according to the DnsConfig from the session.
 512 // The timeout for each DnsUDPAttempt is given by DnsSession::NextTimeout.
 513 // The first server to attempt on each query is given by
 514 // DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
 515 // Each server is attempted DnsConfig::attempts times.
 516 class DnsTransactionImpl : public DnsTransaction,
 517                            public base::NonThreadSafe,
 518                            public base::SupportsWeakPtr<DnsTransactionImpl> {
 519  public:
 520   DnsTransactionImpl(DnsSession* session,
 521                      const std::string& hostname,
 522                      uint16 qtype,
 523                      const DnsTransactionFactory::CallbackType& callback,
 524                      const BoundNetLog& net_log)
 525     : session_(session),
 526       hostname_(hostname),
 527       qtype_(qtype),
 528       callback_(callback),
 529       net_log_(net_log),
 530       qnames_initial_size_(0),
 531       attempts_count_(0),
 532       had_tcp_attempt_(false),
 533       first_server_index_(0) {
 534     DCHECK(session_.get());
 535     DCHECK(!hostname_.empty());
 536     DCHECK(!callback_.is_null());
 537     DCHECK(!IsIPLiteral(hostname_));
 538   }
 539
 540   virtual ~DnsTransactionImpl() {
 541     if (!callback_.is_null()) {
 542       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
 543                                         ERR_ABORTED);
 544     }  // otherwise logged in DoCallback or Start
 545   }
 546
 547   virtual const std::string& GetHostname() const OVERRIDE {
 548     DCHECK(CalledOnValidThread());
 549     return hostname_;
 550   }
 551
 552   virtual uint16 GetType() const OVERRIDE {
 553     DCHECK(CalledOnValidThread());
 554     return qtype_;
 555   }
 556
 557   virtual void Start() OVERRIDE {
 558     DCHECK(!callback_.is_null());
 559     DCHECK(attempts_.empty());
 560     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
 561                         base::Bind(&NetLogStartCallback, &hostname_, qtype_));
 562     AttemptResult result(PrepareSearch(), NULL);
 563     if (result.rv == OK) {
 564       qnames_initial_size_ = qnames_.size();
 565       if (qtype_ == dns_protocol::kTypeA)
 566         UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchStart", qnames_.size());
 567       result = ProcessAttemptResult(StartQuery());
 568     }
 569
 570     // Must always return result asynchronously, to avoid reentrancy.
 571     if (result.rv != ERR_IO_PENDING) {
 572       base::MessageLoop::current()->PostTask(
 573           FROM_HERE,
 574           base::Bind(&DnsTransactionImpl::DoCallback, AsWeakPtr(), result));
 575     }
 576   }
 577
 578  private:
 579   // Wrapper for the result of a DnsUDPAttempt.
 580   struct AttemptResult {
 581     AttemptResult(int rv, const DnsAttempt* attempt)
 582         : rv(rv), attempt(attempt) {}
 583
 584     int rv;
 585     const DnsAttempt* attempt;
 586   };
 587
 588   // Prepares |qnames_| according to the DnsConfig.
 589   int PrepareSearch() {
 590     const DnsConfig& config = session_->config();
 591
 592     std::string labeled_hostname;
 593     if (!DNSDomainFromDot(hostname_, &labeled_hostname))
 594       return ERR_INVALID_ARGUMENT;
 595
 596     if (hostname_[hostname_.size() - 1] == '.') {
 597       // It's a fully-qualified name, no suffix search.
 598       qnames_.push_back(labeled_hostname);
 599       return OK;
 600     }
 601
 602     int ndots = CountLabels(labeled_hostname) - 1;
 603
 604     if (ndots > 0 && !config.append_to_multi_label_name) {
 605       qnames_.push_back(labeled_hostname);
 606       return OK;
 607     }
 608
 609     // Set true when |labeled_hostname| is put on the list.
 610     bool had_hostname = false;
 611
 612     if (ndots >= config.ndots) {
 613       qnames_.push_back(labeled_hostname);
 614       had_hostname = true;
 615     }
 616
 617     std::string qname;
 618     for (size_t i = 0; i < config.search.size(); ++i) {
 619       // Ignore invalid (too long) combinations.
 620       if (!DNSDomainFromDot(hostname_ + "." + config.search[i], &qname))
 621         continue;
 622       if (qname.size() == labeled_hostname.size()) {
 623         if (had_hostname)
 624           continue;
 625         had_hostname = true;
 626       }
 627       qnames_.push_back(qname);
 628     }
 629
 630     if (ndots > 0 && !had_hostname)
 631       qnames_.push_back(labeled_hostname);
 632
 633     return qnames_.empty() ? ERR_DNS_SEARCH_EMPTY : OK;
 634   }
 635
 636   void DoCallback(AttemptResult result) {
 637     DCHECK(!callback_.is_null());
 638     DCHECK_NE(ERR_IO_PENDING, result.rv);
 639     const DnsResponse* response = result.attempt ?
 640         result.attempt->GetResponse() : NULL;
 641     CHECK(result.rv != OK || response != NULL);
 642
 643     timer_.Stop();
 644     RecordLostPacketsIfAny();
 645     if (result.rv == OK)
 646       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountSuccess", attempts_count_);
 647     else
 648       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountFail", attempts_count_);
 649
 650     if (response && qtype_ == dns_protocol::kTypeA) {
 651       UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchRemain", qnames_.size());
 652       UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchDone",
 653                            qnames_initial_size_ - qnames_.size());
 654     }
 655
 656     DnsTransactionFactory::CallbackType callback = callback_;
 657     callback_.Reset();
 658
 659     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION, result.rv);
 660     callback.Run(this, result.rv, response);
 661   }
 662
 663   // Makes another attempt at the current name, |qnames_.front()|, using the
 664   // next nameserver.
 665   AttemptResult MakeAttempt() {
 666     unsigned attempt_number = attempts_.size();
 667
 668     uint16 id = session_->NextQueryId();
 669     scoped_ptr<DnsQuery> query;
 670     if (attempts_.empty()) {
 671       query.reset(new DnsQuery(id, qnames_.front(), qtype_));
 672     } else {
 673       query.reset(attempts_[0]->GetQuery()->CloneWithNewId(id));
 674     }
 675
 676     const DnsConfig& config = session_->config();
 677
 678     unsigned server_index =
 679         (first_server_index_ + attempt_number) % config.nameservers.size();
 680     // Skip over known failed servers.
 681     server_index = session_->NextGoodServerIndex(server_index);
 682
 683     scoped_ptr<DnsSession::SocketLease> lease =
 684         session_->AllocateSocket(server_index, net_log_.source());
 685
 686     bool got_socket = !!lease.get();
 687
 688     DnsUDPAttempt* attempt =
 689         new DnsUDPAttempt(server_index, lease.Pass(), query.Pass());
 690
 691     attempts_.push_back(attempt);
 692     ++attempts_count_;
 693
 694     if (!got_socket)
 695       return AttemptResult(ERR_CONNECTION_REFUSED, NULL);
 696
 697     net_log_.AddEvent(
 698         NetLog::TYPE_DNS_TRANSACTION_ATTEMPT,
 699         attempt->GetSocketNetLog().source().ToEventParametersCallback());
 700
 701     int rv = attempt->Start(
 702         base::Bind(&DnsTransactionImpl::OnUdpAttemptComplete,
 703                    base::Unretained(this), attempt_number,
 704                    base::TimeTicks::Now()));
 705     if (rv == ERR_IO_PENDING) {
 706       base::TimeDelta timeout = session_->NextTimeout(server_index,
 707                                                       attempt_number);
 708       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
 709     }
 710     return AttemptResult(rv, attempt);
 711   }
 712
 713   AttemptResult MakeTCPAttempt(const DnsAttempt* previous_attempt) {
 714     DCHECK(previous_attempt);
 715     DCHECK(!had_tcp_attempt_);
 716
 717     unsigned server_index = previous_attempt->server_index();
 718
 719     scoped_ptr<StreamSocket> socket(
 720         session_->CreateTCPSocket(server_index, net_log_.source()));
 721
 722     // TODO(szym): Reuse the same id to help the server?
 723     uint16 id = session_->NextQueryId();
 724     scoped_ptr<DnsQuery> query(
 725         previous_attempt->GetQuery()->CloneWithNewId(id));
 726
 727     RecordLostPacketsIfAny();
 728     // Cancel all other attempts, no point waiting on them.
 729     attempts_.clear();
 730
 731     unsigned attempt_number = attempts_.size();
 732
 733     DnsTCPAttempt* attempt = new DnsTCPAttempt(server_index, socket.Pass(),
 734                                                query.Pass());
 735
 736     attempts_.push_back(attempt);
 737     ++attempts_count_;
 738     had_tcp_attempt_ = true;
 739
 740     net_log_.AddEvent(
 741         NetLog::TYPE_DNS_TRANSACTION_TCP_ATTEMPT,
 742         attempt->GetSocketNetLog().source().ToEventParametersCallback());
 743
 744     int rv = attempt->Start(base::Bind(&DnsTransactionImpl::OnAttemptComplete,
 745                                        base::Unretained(this),
 746                                        attempt_number));
 747     if (rv == ERR_IO_PENDING) {
 748       // Custom timeout for TCP attempt.
 749       base::TimeDelta timeout = timer_.GetCurrentDelay() * 2;
 750       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
 751     }
 752     return AttemptResult(rv, attempt);
 753   }
 754
 755   // Begins query for the current name. Makes the first attempt.
 756   AttemptResult StartQuery() {
 757     std::string dotted_qname = DNSDomainToString(qnames_.front());
 758     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION_QUERY,
 759                         NetLog::StringCallback("qname", &dotted_qname));
 760
 761     first_server_index_ = session_->NextFirstServerIndex();
 762     RecordLostPacketsIfAny();
 763     attempts_.clear();
 764     had_tcp_attempt_ = false;
 765     return MakeAttempt();
 766   }
 767
 768   void OnUdpAttemptComplete(unsigned attempt_number,
 769                             base::TimeTicks start,
 770                             int rv) {
 771     DCHECK_LT(attempt_number, attempts_.size());
 772     const DnsAttempt* attempt = attempts_[attempt_number];
 773     if (attempt->GetResponse()) {
 774       session_->RecordRTT(attempt->server_index(),
 775                           base::TimeTicks::Now() - start);
 776     }
 777     OnAttemptComplete(attempt_number, rv);
 778   }
 779
 780   void OnAttemptComplete(unsigned attempt_number, int rv) {
 781     if (callback_.is_null())
 782       return;
 783     DCHECK_LT(attempt_number, attempts_.size());
 784     const DnsAttempt* attempt = attempts_[attempt_number];
 785     AttemptResult result = ProcessAttemptResult(AttemptResult(rv, attempt));
 786     if (result.rv != ERR_IO_PENDING)
 787       DoCallback(result);
 788   }
 789
 790   // Record packet loss for any incomplete attempts.
 791   void RecordLostPacketsIfAny() {
 792     // Loop through attempts until we find first that is completed
 793     size_t first_completed = 0;
 794     for (first_completed = 0; first_completed < attempts_.size();
 795         ++first_completed) {
 796       if (attempts_[first_completed]->is_completed())
 797         break;
 798     }
 799     // If there were no completed attempts, then we must be offline, so don't
 800     // record any attempts as lost packets.
 801     if (first_completed == attempts_.size())
 802       return;
 803
 804     size_t num_servers = session_->config().nameservers.size();
 805     std::vector<int> server_attempts(num_servers);
 806     for (size_t i = 0; i < first_completed; ++i) {
 807       unsigned server_index = attempts_[i]->server_index();
 808       int server_attempt = server_attempts[server_index]++;
 809       // Don't record lost packet unless attempt is in pending state.
 810       if (!attempts_[i]->is_pending())
 811         continue;
 812       session_->RecordLostPacket(server_index, server_attempt);
 813     }
 814   }
 815
 816   void LogResponse(const DnsAttempt* attempt) {
 817     if (attempt && attempt->GetResponse()) {
 818       net_log_.AddEvent(
 819           NetLog::TYPE_DNS_TRANSACTION_RESPONSE,
 820           base::Bind(&DnsAttempt::NetLogResponseCallback,
 821                      base::Unretained(attempt)));
 822     }
 823   }
 824
 825   bool MoreAttemptsAllowed() const {
 826     if (had_tcp_attempt_)
 827       return false;
 828     const DnsConfig& config = session_->config();
 829     return attempts_.size() < config.attempts * config.nameservers.size();
 830   }
 831
 832   // Resolves the result of a DnsAttempt until a terminal result is reached
 833   // or it will complete asynchronously (ERR_IO_PENDING).
 834   AttemptResult ProcessAttemptResult(AttemptResult result) {
 835     while (result.rv != ERR_IO_PENDING) {
 836       LogResponse(result.attempt);
 837
 838       switch (result.rv) {
 839         case OK:
 840           session_->RecordServerSuccess(result.attempt->server_index());
 841           net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION_QUERY,
 842                                             result.rv);
 843           DCHECK(result.attempt);
 844           DCHECK(result.attempt->GetResponse());
 845           return result;
 846         case ERR_NAME_NOT_RESOLVED:
 847           session_->RecordServerSuccess(result.attempt->server_index());
 848           net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION_QUERY,
 849                                             result.rv);
 850           // Try next suffix.
 851           qnames_.pop_front();
 852           if (qnames_.empty()) {
 853             return AttemptResult(ERR_NAME_NOT_RESOLVED, NULL);
 854           } else {
 855             result = StartQuery();
 856           }
 857           break;
 858         case ERR_CONNECTION_REFUSED:
 859         case ERR_DNS_TIMED_OUT:
 860           if (result.attempt)
 861             session_->RecordServerFailure(result.attempt->server_index());
 862           if (MoreAttemptsAllowed()) {
 863             result = MakeAttempt();
 864           } else {
 865             return result;
 866           }
 867           break;
 868         case ERR_DNS_SERVER_REQUIRES_TCP:
 869           result = MakeTCPAttempt(result.attempt);
 870           break;
 871         default:
 872           // Server failure.
 873           DCHECK(result.attempt);
 874           if (result.attempt != attempts_.back()) {
 875             // This attempt already timed out. Ignore it.
 876             session_->RecordServerFailure(result.attempt->server_index());
 877             return AttemptResult(ERR_IO_PENDING, NULL);
 878           }
 879           if (MoreAttemptsAllowed()) {
 880             result = MakeAttempt();
 881           } else if (result.rv == ERR_DNS_MALFORMED_RESPONSE &&
 882                      !had_tcp_attempt_) {
 883             // For UDP only, ignore the response and wait until the last attempt
 884             // times out.
 885             return AttemptResult(ERR_IO_PENDING, NULL);
 886           } else {
 887             return AttemptResult(result.rv, NULL);
 888           }
 889           break;
 890       }
 891     }
 892     return result;
 893   }
 894
 895   void OnTimeout() {
 896     if (callback_.is_null())
 897       return;
 898     DCHECK(!attempts_.empty());
 899     AttemptResult result = ProcessAttemptResult(
 900         AttemptResult(ERR_DNS_TIMED_OUT, attempts_.back()));
 901     if (result.rv != ERR_IO_PENDING)
 902       DoCallback(result);
 903   }
 904
 905   scoped_refptr<DnsSession> session_;
 906   std::string hostname_;
 907   uint16 qtype_;
 908   // Cleared in DoCallback.
 909   DnsTransactionFactory::CallbackType callback_;
 910
 911   BoundNetLog net_log_;
 912
 913   // Search list of fully-qualified DNS names to query next (in DNS format).
 914   std::deque<std::string> qnames_;
 915   size_t qnames_initial_size_;
 916
 917   // List of attempts for the current name.
 918   ScopedVector<DnsAttempt> attempts_;
 919   // Count of attempts, not reset when |attempts_| vector is cleared.
 920   int  attempts_count_;
 921   bool had_tcp_attempt_;
 922
 923   // Index of the first server to try on each search query.
 924   int first_server_index_;
 925
 926   base::OneShotTimer<DnsTransactionImpl> timer_;
 927
 928   DISALLOW_COPY_AND_ASSIGN(DnsTransactionImpl);
 929 };
 930
 931 // ----------------------------------------------------------------------------
 932
 933 // Implementation of DnsTransactionFactory that returns instances of
 934 // DnsTransactionImpl.
 935 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
 936  public:
 937   explicit DnsTransactionFactoryImpl(DnsSession* session) {
 938     session_ = session;
 939   }
 940
 941   virtual scoped_ptr<DnsTransaction> CreateTransaction(
 942       const std::string& hostname,
 943       uint16 qtype,
 944       const CallbackType& callback,
 945       const BoundNetLog& net_log) OVERRIDE {
 946     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
 947         session_.get(), hostname, qtype, callback, net_log));
 948   }
 949
 950  private:
 951   scoped_refptr<DnsSession> session_;
 952 };
 953
 954 }  // namespace
 955
 956 // static
 957 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
 958     DnsSession* session) {
 959   return scoped_ptr<DnsTransactionFactory>(
 960       new DnsTransactionFactoryImpl(session));
 961 }
 962
 963 }  // namespace net