Home | History | Annotate | Download | only in dns 
      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/big_endian.h"
     12 #include "base/bind.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "base/memory/scoped_vector.h"
     16 #include "base/memory/weak_ptr.h"
     17 #include "base/message_loop/message_loop.h"
     18 #include "base/metrics/histogram.h"
     19 #include "base/rand_util.h"
     20 #include "base/stl_util.h"
     21 #include "base/strings/string_piece.h"
     22 #include "base/threading/non_thread_safe.h"
     23 #include "base/timer/timer.h"
     24 #include "base/values.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_LENGTH_COMPLETE,
    343     STATE_READ_RESPONSE,
    344     STATE_READ_RESPONSE_COMPLETE,
    345     STATE_NONE,
    346   };
    347 
    348   int DoLoop(int result) {
    349     CHECK_NE(STATE_NONE, next_state_);
    350     int rv = result;
    351     do {
    352       State state = next_state_;
    353       next_state_ = STATE_NONE;
    354       switch (state) {
    355         case STATE_CONNECT_COMPLETE:
    356           rv = DoConnectComplete(rv);
    357           break;
    358         case STATE_SEND_LENGTH:
    359           rv = DoSendLength(rv);
    360           break;
    361         case STATE_SEND_QUERY:
    362           rv = DoSendQuery(rv);
    363           break;
    364         case STATE_READ_LENGTH:
    365           rv = DoReadLength(rv);
    366           break;
    367         case STATE_READ_LENGTH_COMPLETE:
    368           rv = DoReadLengthComplete(rv);
    369           break;
    370         case STATE_READ_RESPONSE:
    371           rv = DoReadResponse(rv);
    372           break;
    373         case STATE_READ_RESPONSE_COMPLETE:
    374           rv = DoReadResponseComplete(rv);
    375           break;
    376         default:
    377           NOTREACHED();
    378           break;
    379       }
    380     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
    381 
    382     set_result(rv);
    383     if (rv == OK) {
    384       DCHECK_EQ(STATE_NONE, next_state_);
    385       DNS_HISTOGRAM("AsyncDNS.TCPAttemptSuccess",
    386                     base::TimeTicks::Now() - start_time_);
    387     } else if (rv != ERR_IO_PENDING) {
    388       DNS_HISTOGRAM("AsyncDNS.TCPAttemptFail",
    389                     base::TimeTicks::Now() - start_time_);
    390     }
    391     return rv;
    392   }
    393 
    394   int DoConnectComplete(int rv) {
    395     DCHECK_NE(ERR_IO_PENDING, rv);
    396     if (rv < 0)
    397       return rv;
    398 
    399     base::WriteBigEndian<uint16>(length_buffer_->data(),
    400                                  query_->io_buffer()->size());
    401     buffer_ =
    402         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
    403     next_state_ = STATE_SEND_LENGTH;
    404     return OK;
    405   }
    406 
    407   int DoSendLength(int rv) {
    408     DCHECK_NE(ERR_IO_PENDING, rv);
    409     if (rv < 0)
    410       return rv;
    411 
    412     buffer_->DidConsume(rv);
    413     if (buffer_->BytesRemaining() > 0) {
    414       next_state_ = STATE_SEND_LENGTH;
    415       return socket_->Write(
    416           buffer_.get(),
    417           buffer_->BytesRemaining(),
    418           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
    419     }
    420     buffer_ = new DrainableIOBuffer(query_->io_buffer(),
    421                                     query_->io_buffer()->size());
    422     next_state_ = STATE_SEND_QUERY;
    423     return OK;
    424   }
    425 
    426   int DoSendQuery(int rv) {
    427     DCHECK_NE(ERR_IO_PENDING, rv);
    428     if (rv < 0)
    429       return rv;
    430 
    431     buffer_->DidConsume(rv);
    432     if (buffer_->BytesRemaining() > 0) {
    433       next_state_ = STATE_SEND_QUERY;
    434       return socket_->Write(
    435           buffer_.get(),
    436           buffer_->BytesRemaining(),
    437           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
    438     }
    439     buffer_ =
    440         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
    441     next_state_ = STATE_READ_LENGTH;
    442     return OK;
    443   }
    444 
    445   int DoReadLength(int rv) {
    446     DCHECK_EQ(OK, rv);
    447 
    448     next_state_ = STATE_READ_LENGTH_COMPLETE;
    449     return ReadIntoBuffer();
    450   }
    451 
    452   int DoReadLengthComplete(int rv) {
    453     DCHECK_NE(ERR_IO_PENDING, rv);
    454     if (rv < 0)
    455       return rv;
    456     if (rv == 0)
    457       return ERR_CONNECTION_CLOSED;
    458 
    459     buffer_->DidConsume(rv);
    460     if (buffer_->BytesRemaining() > 0) {
    461       next_state_ = STATE_READ_LENGTH;
    462       return OK;
    463     }
    464 
    465     base::ReadBigEndian<uint16>(length_buffer_->data(), &response_length_);
    466     // Check if advertised response is too short. (Optimization only.)
    467     if (response_length_ < query_->io_buffer()->size())
    468       return ERR_DNS_MALFORMED_RESPONSE;
    469     // Allocate more space so that DnsResponse::InitParse sanity check passes.
    470     response_.reset(new DnsResponse(response_length_ + 1));
    471     buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
    472     next_state_ = STATE_READ_RESPONSE;
    473     return OK;
    474   }
    475 
    476   int DoReadResponse(int rv) {
    477     DCHECK_EQ(OK, rv);
    478 
    479     next_state_ = STATE_READ_RESPONSE_COMPLETE;
    480     return ReadIntoBuffer();
    481   }
    482 
    483   int DoReadResponseComplete(int rv) {
    484     DCHECK_NE(ERR_IO_PENDING, rv);
    485     if (rv < 0)
    486       return rv;
    487     if (rv == 0)
    488       return ERR_CONNECTION_CLOSED;
    489 
    490     buffer_->DidConsume(rv);
    491     if (buffer_->BytesRemaining() > 0) {
    492       next_state_ = STATE_READ_RESPONSE;
    493       return OK;
    494     }
    495 
    496     if (!response_->InitParse(buffer_->BytesConsumed(), *query_))
    497       return ERR_DNS_MALFORMED_RESPONSE;
    498     if (response_->flags() & dns_protocol::kFlagTC)
    499       return ERR_UNEXPECTED;
    500     // TODO(szym): Frankly, none of these are expected.
    501     if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
    502       return ERR_NAME_NOT_RESOLVED;
    503     if (response_->rcode() != dns_protocol::kRcodeNOERROR)
    504       return ERR_DNS_SERVER_FAILED;
    505 
    506     return OK;
    507   }
    508 
    509   void OnIOComplete(int rv) {
    510     rv = DoLoop(rv);
    511     if (rv != ERR_IO_PENDING)
    512       callback_.Run(rv);
    513   }
    514 
    515   int ReadIntoBuffer() {
    516     return socket_->Read(
    517         buffer_.get(),
    518         buffer_->BytesRemaining(),
    519         base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
    520   }
    521 
    522   State next_state_;
    523   base::TimeTicks start_time_;
    524 
    525   scoped_ptr<StreamSocket> socket_;
    526   scoped_ptr<DnsQuery> query_;
    527   scoped_refptr<IOBufferWithSize> length_buffer_;
    528   scoped_refptr<DrainableIOBuffer> buffer_;
    529 
    530   uint16 response_length_;
    531   scoped_ptr<DnsResponse> response_;
    532 
    533   CompletionCallback callback_;
    534 
    535   DISALLOW_COPY_AND_ASSIGN(DnsTCPAttempt);
    536 };
    537 
    538 // ----------------------------------------------------------------------------
    539 
    540 // Implements DnsTransaction. Configuration is supplied by DnsSession.
    541 // The suffix list is built according to the DnsConfig from the session.
    542 // The timeout for each DnsUDPAttempt is given by DnsSession::NextTimeout.
    543 // The first server to attempt on each query is given by
    544 // DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
    545 // Each server is attempted DnsConfig::attempts times.
    546 class DnsTransactionImpl : public DnsTransaction,
    547                            public base::NonThreadSafe,
    548                            public base::SupportsWeakPtr<DnsTransactionImpl> {
    549  public:
    550   DnsTransactionImpl(DnsSession* session,
    551                      const std::string& hostname,
    552                      uint16 qtype,
    553                      const DnsTransactionFactory::CallbackType& callback,
    554                      const BoundNetLog& net_log)
    555     : session_(session),
    556       hostname_(hostname),
    557       qtype_(qtype),
    558       callback_(callback),
    559       net_log_(net_log),
    560       qnames_initial_size_(0),
    561       attempts_count_(0),
    562       had_tcp_attempt_(false),
    563       first_server_index_(0) {
    564     DCHECK(session_.get());
    565     DCHECK(!hostname_.empty());
    566     DCHECK(!callback_.is_null());
    567     DCHECK(!IsIPLiteral(hostname_));
    568   }
    569 
    570   virtual ~DnsTransactionImpl() {
    571     if (!callback_.is_null()) {
    572       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
    573                                         ERR_ABORTED);
    574     }  // otherwise logged in DoCallback or Start
    575   }
    576 
    577   virtual const std::string& GetHostname() const OVERRIDE {
    578     DCHECK(CalledOnValidThread());
    579     return hostname_;
    580   }
    581 
    582   virtual uint16 GetType() const OVERRIDE {
    583     DCHECK(CalledOnValidThread());
    584     return qtype_;
    585   }
    586 
    587   virtual void Start() OVERRIDE {
    588     DCHECK(!callback_.is_null());
    589     DCHECK(attempts_.empty());
    590     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
    591                         base::Bind(&NetLogStartCallback, &hostname_, qtype_));
    592     AttemptResult result(PrepareSearch(), NULL);
    593     if (result.rv == OK) {
    594       qnames_initial_size_ = qnames_.size();
    595       if (qtype_ == dns_protocol::kTypeA)
    596         UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchStart", qnames_.size());
    597       result = ProcessAttemptResult(StartQuery());
    598     }
    599 
    600     // Must always return result asynchronously, to avoid reentrancy.
    601     if (result.rv != ERR_IO_PENDING) {
    602       base::MessageLoop::current()->PostTask(
    603           FROM_HERE,
    604           base::Bind(&DnsTransactionImpl::DoCallback, AsWeakPtr(), result));
    605     }
    606   }
    607 
    608  private:
    609   // Wrapper for the result of a DnsUDPAttempt.
    610   struct AttemptResult {
    611     AttemptResult(int rv, const DnsAttempt* attempt)
    612         : rv(rv), attempt(attempt) {}
    613 
    614     int rv;
    615     const DnsAttempt* attempt;
    616   };
    617 
    618   // Prepares |qnames_| according to the DnsConfig.
    619   int PrepareSearch() {
    620     const DnsConfig& config = session_->config();
    621 
    622     std::string labeled_hostname;
    623     if (!DNSDomainFromDot(hostname_, &labeled_hostname))
    624       return ERR_INVALID_ARGUMENT;
    625 
    626     if (hostname_[hostname_.size() - 1] == '.') {
    627       // It's a fully-qualified name, no suffix search.
    628       qnames_.push_back(labeled_hostname);
    629       return OK;
    630     }
    631 
    632     int ndots = CountLabels(labeled_hostname) - 1;
    633 
    634     if (ndots > 0 && !config.append_to_multi_label_name) {
    635       qnames_.push_back(labeled_hostname);
    636       return OK;
    637     }
    638 
    639     // Set true when |labeled_hostname| is put on the list.
    640     bool had_hostname = false;
    641 
    642     if (ndots >= config.ndots) {
    643       qnames_.push_back(labeled_hostname);
    644       had_hostname = true;
    645     }
    646 
    647     std::string qname;
    648     for (size_t i = 0; i < config.search.size(); ++i) {
    649       // Ignore invalid (too long) combinations.
    650       if (!DNSDomainFromDot(hostname_ + "." + config.search[i], &qname))
    651         continue;
    652       if (qname.size() == labeled_hostname.size()) {
    653         if (had_hostname)
    654           continue;
    655         had_hostname = true;
    656       }
    657       qnames_.push_back(qname);
    658     }
    659 
    660     if (ndots > 0 && !had_hostname)
    661       qnames_.push_back(labeled_hostname);
    662 
    663     return qnames_.empty() ? ERR_DNS_SEARCH_EMPTY : OK;
    664   }
    665 
    666   void DoCallback(AttemptResult result) {
    667     DCHECK(!callback_.is_null());
    668     DCHECK_NE(ERR_IO_PENDING, result.rv);
    669     const DnsResponse* response = result.attempt ?
    670         result.attempt->GetResponse() : NULL;
    671     CHECK(result.rv != OK || response != NULL);
    672 
    673     timer_.Stop();
    674     RecordLostPacketsIfAny();
    675     if (result.rv == OK)
    676       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountSuccess", attempts_count_);
    677     else
    678       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountFail", attempts_count_);
    679 
    680     if (response && qtype_ == dns_protocol::kTypeA) {
    681       UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchRemain", qnames_.size());
    682       UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchDone",
    683                            qnames_initial_size_ - qnames_.size());
    684     }
    685 
    686     DnsTransactionFactory::CallbackType callback = callback_;
    687     callback_.Reset();
    688 
    689     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION, result.rv);
    690     callback.Run(this, result.rv, response);
    691   }
    692 
    693   // Makes another attempt at the current name, |qnames_.front()|, using the
    694   // next nameserver.
    695   AttemptResult MakeAttempt() {
    696     unsigned attempt_number = attempts_.size();
    697 
    698     uint16 id = session_->NextQueryId();
    699     scoped_ptr<DnsQuery> query;
    700     if (attempts_.empty()) {
    701       query.reset(new DnsQuery(id, qnames_.front(), qtype_));
    702     } else {
    703       query.reset(attempts_[0]->GetQuery()->CloneWithNewId(id));
    704     }
    705 
    706     const DnsConfig& config = session_->config();
    707 
    708     unsigned server_index =
    709         (first_server_index_ + attempt_number) % config.nameservers.size();
    710     // Skip over known failed servers.
    711     server_index = session_->NextGoodServerIndex(server_index);
    712 
    713     scoped_ptr<DnsSession::SocketLease> lease =
    714         session_->AllocateSocket(server_index, net_log_.source());
    715 
    716     bool got_socket = !!lease.get();
    717 
    718     DnsUDPAttempt* attempt =
    719         new DnsUDPAttempt(server_index, lease.Pass(), query.Pass());
    720 
    721     attempts_.push_back(attempt);
    722     ++attempts_count_;
    723 
    724     if (!got_socket)
    725       return AttemptResult(ERR_CONNECTION_REFUSED, NULL);
    726 
    727     net_log_.AddEvent(
    728         NetLog::TYPE_DNS_TRANSACTION_ATTEMPT,
    729         attempt->GetSocketNetLog().source().ToEventParametersCallback());
    730 
    731     int rv = attempt->Start(
    732         base::Bind(&DnsTransactionImpl::OnUdpAttemptComplete,
    733                    base::Unretained(this), attempt_number,
    734                    base::TimeTicks::Now()));
    735     if (rv == ERR_IO_PENDING) {
    736       base::TimeDelta timeout = session_->NextTimeout(server_index,
    737                                                       attempt_number);
    738       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
    739     }
    740     return AttemptResult(rv, attempt);
    741   }
    742 
    743   AttemptResult MakeTCPAttempt(const DnsAttempt* previous_attempt) {
    744     DCHECK(previous_attempt);
    745     DCHECK(!had_tcp_attempt_);
    746 
    747     unsigned server_index = previous_attempt->server_index();
    748 
    749     scoped_ptr<StreamSocket> socket(
    750         session_->CreateTCPSocket(server_index, net_log_.source()));
    751 
    752     // TODO(szym): Reuse the same id to help the server?
    753     uint16 id = session_->NextQueryId();
    754     scoped_ptr<DnsQuery> query(
    755         previous_attempt->GetQuery()->CloneWithNewId(id));
    756 
    757     RecordLostPacketsIfAny();
    758     // Cancel all other attempts, no point waiting on them.
    759     attempts_.clear();
    760 
    761     unsigned attempt_number = attempts_.size();
    762 
    763     DnsTCPAttempt* attempt = new DnsTCPAttempt(server_index, socket.Pass(),
    764                                                query.Pass());
    765 
    766     attempts_.push_back(attempt);
    767     ++attempts_count_;
    768     had_tcp_attempt_ = true;
    769 
    770     net_log_.AddEvent(
    771         NetLog::TYPE_DNS_TRANSACTION_TCP_ATTEMPT,
    772         attempt->GetSocketNetLog().source().ToEventParametersCallback());
    773 
    774     int rv = attempt->Start(base::Bind(&DnsTransactionImpl::OnAttemptComplete,
    775                                        base::Unretained(this),
    776                                        attempt_number));
    777     if (rv == ERR_IO_PENDING) {
    778       // Custom timeout for TCP attempt.
    779       base::TimeDelta timeout = timer_.GetCurrentDelay() * 2;
    780       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
    781     }
    782     return AttemptResult(rv, attempt);
    783   }
    784 
    785   // Begins query for the current name. Makes the first attempt.
    786   AttemptResult StartQuery() {
    787     std::string dotted_qname = DNSDomainToString(qnames_.front());
    788     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION_QUERY,
    789                         NetLog::StringCallback("qname", &dotted_qname));
    790 
    791     first_server_index_ = session_->NextFirstServerIndex();
    792     RecordLostPacketsIfAny();
    793     attempts_.clear();
    794     had_tcp_attempt_ = false;
    795     return MakeAttempt();
    796   }
    797 
    798   void OnUdpAttemptComplete(unsigned attempt_number,
    799                             base::TimeTicks start,
    800                             int rv) {
    801     DCHECK_LT(attempt_number, attempts_.size());
    802     const DnsAttempt* attempt = attempts_[attempt_number];
    803     if (attempt->GetResponse()) {
    804       session_->RecordRTT(attempt->server_index(),
    805                           base::TimeTicks::Now() - start);
    806     }
    807     OnAttemptComplete(attempt_number, rv);
    808   }
    809 
    810   void OnAttemptComplete(unsigned attempt_number, int rv) {
    811     if (callback_.is_null())
    812       return;
    813     DCHECK_LT(attempt_number, attempts_.size());
    814     const DnsAttempt* attempt = attempts_[attempt_number];
    815     AttemptResult result = ProcessAttemptResult(AttemptResult(rv, attempt));
    816     if (result.rv != ERR_IO_PENDING)
    817       DoCallback(result);
    818   }
    819 
    820   // Record packet loss for any incomplete attempts.
    821   void RecordLostPacketsIfAny() {
    822     // Loop through attempts until we find first that is completed
    823     size_t first_completed = 0;
    824     for (first_completed = 0; first_completed < attempts_.size();
    825         ++first_completed) {
    826       if (attempts_[first_completed]->is_completed())
    827         break;
    828     }
    829     // If there were no completed attempts, then we must be offline, so don't
    830     // record any attempts as lost packets.
    831     if (first_completed == attempts_.size())
    832       return;
    833 
    834     size_t num_servers = session_->config().nameservers.size();
    835     std::vector<int> server_attempts(num_servers);
    836     for (size_t i = 0; i < first_completed; ++i) {
    837       unsigned server_index = attempts_[i]->server_index();
    838       int server_attempt = server_attempts[server_index]++;
    839       // Don't record lost packet unless attempt is in pending state.
    840       if (!attempts_[i]->is_pending())
    841         continue;
    842       session_->RecordLostPacket(server_index, server_attempt);
    843     }
    844   }
    845 
    846   void LogResponse(const DnsAttempt* attempt) {
    847     if (attempt && attempt->GetResponse()) {
    848       net_log_.AddEvent(
    849           NetLog::TYPE_DNS_TRANSACTION_RESPONSE,
    850           base::Bind(&DnsAttempt::NetLogResponseCallback,
    851                      base::Unretained(attempt)));
    852     }
    853   }
    854 
    855   bool MoreAttemptsAllowed() const {
    856     if (had_tcp_attempt_)
    857       return false;
    858     const DnsConfig& config = session_->config();
    859     return attempts_.size() < config.attempts * config.nameservers.size();
    860   }
    861 
    862   // Resolves the result of a DnsAttempt until a terminal result is reached
    863   // or it will complete asynchronously (ERR_IO_PENDING).
    864   AttemptResult ProcessAttemptResult(AttemptResult result) {
    865     while (result.rv != ERR_IO_PENDING) {
    866       LogResponse(result.attempt);
    867 
    868       switch (result.rv) {
    869         case OK:
    870           session_->RecordServerSuccess(result.attempt->server_index());
    871           net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION_QUERY,
    872                                             result.rv);
    873           DCHECK(result.attempt);
    874           DCHECK(result.attempt->GetResponse());
    875           return result;
    876         case ERR_NAME_NOT_RESOLVED:
    877           session_->RecordServerSuccess(result.attempt->server_index());
    878           net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION_QUERY,
    879                                             result.rv);
    880           // Try next suffix.
    881           qnames_.pop_front();
    882           if (qnames_.empty()) {
    883             return AttemptResult(ERR_NAME_NOT_RESOLVED, NULL);
    884           } else {
    885             result = StartQuery();
    886           }
    887           break;
    888         case ERR_CONNECTION_REFUSED:
    889         case ERR_DNS_TIMED_OUT:
    890           if (result.attempt)
    891             session_->RecordServerFailure(result.attempt->server_index());
    892           if (MoreAttemptsAllowed()) {
    893             result = MakeAttempt();
    894           } else {
    895             return result;
    896           }
    897           break;
    898         case ERR_DNS_SERVER_REQUIRES_TCP:
    899           result = MakeTCPAttempt(result.attempt);
    900           break;
    901         default:
    902           // Server failure.
    903           DCHECK(result.attempt);
    904           if (result.attempt != attempts_.back()) {
    905             // This attempt already timed out. Ignore it.
    906             session_->RecordServerFailure(result.attempt->server_index());
    907             return AttemptResult(ERR_IO_PENDING, NULL);
    908           }
    909           if (MoreAttemptsAllowed()) {
    910             result = MakeAttempt();
    911           } else if (result.rv == ERR_DNS_MALFORMED_RESPONSE &&
    912                      !had_tcp_attempt_) {
    913             // For UDP only, ignore the response and wait until the last attempt
    914             // times out.
    915             return AttemptResult(ERR_IO_PENDING, NULL);
    916           } else {
    917             return AttemptResult(result.rv, NULL);
    918           }
    919           break;
    920       }
    921     }
    922     return result;
    923   }
    924 
    925   void OnTimeout() {
    926     if (callback_.is_null())
    927       return;
    928     DCHECK(!attempts_.empty());
    929     AttemptResult result = ProcessAttemptResult(
    930         AttemptResult(ERR_DNS_TIMED_OUT, attempts_.back()));
    931     if (result.rv != ERR_IO_PENDING)
    932       DoCallback(result);
    933   }
    934 
    935   scoped_refptr<DnsSession> session_;
    936   std::string hostname_;
    937   uint16 qtype_;
    938   // Cleared in DoCallback.
    939   DnsTransactionFactory::CallbackType callback_;
    940 
    941   BoundNetLog net_log_;
    942 
    943   // Search list of fully-qualified DNS names to query next (in DNS format).
    944   std::deque<std::string> qnames_;
    945   size_t qnames_initial_size_;
    946 
    947   // List of attempts for the current name.
    948   ScopedVector<DnsAttempt> attempts_;
    949   // Count of attempts, not reset when |attempts_| vector is cleared.
    950   int  attempts_count_;
    951   bool had_tcp_attempt_;
    952 
    953   // Index of the first server to try on each search query.
    954   int first_server_index_;
    955 
    956   base::OneShotTimer<DnsTransactionImpl> timer_;
    957 
    958   DISALLOW_COPY_AND_ASSIGN(DnsTransactionImpl);
    959 };
    960 
    961 // ----------------------------------------------------------------------------
    962 
    963 // Implementation of DnsTransactionFactory that returns instances of
    964 // DnsTransactionImpl.
    965 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
    966  public:
    967   explicit DnsTransactionFactoryImpl(DnsSession* session) {
    968     session_ = session;
    969   }
    970 
    971   virtual scoped_ptr<DnsTransaction> CreateTransaction(
    972       const std::string& hostname,
    973       uint16 qtype,
    974       const CallbackType& callback,
    975       const BoundNetLog& net_log) OVERRIDE {
    976     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
    977         session_.get(), hostname, qtype, callback, net_log));
    978   }
    979 
    980  private:
    981   scoped_refptr<DnsSession> session_;
    982 };
    983 
    984 }  // namespace
    985 
    986 // static
    987 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
    988     DnsSession* session) {
    989   return scoped_ptr<DnsTransactionFactory>(
    990       new DnsTransactionFactoryImpl(session));
    991 }
    992 
    993 }  // namespace net
    994