src/net/dns/mdns_client_impl.cc

   1 // Copyright 2013 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/mdns_client_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop_proxy.h"
   9 #include "base/stl_util.h"
  10 #include "base/time/default_clock.h"
  11 #include "net/base/dns_util.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/base/net_log.h"
  14 #include "net/base/rand_callback.h"
  15 #include "net/dns/dns_protocol.h"
  16 #include "net/dns/record_rdata.h"
  17 #include "net/udp/datagram_socket.h"
  18
  19 // TODO(gene): Remove this temporary method of disabling NSEC support once it
  20 // becomes clear whether this feature should be
  21 // supported. http://crbug.com/255232
  22 #define ENABLE_NSEC
  23
  24 namespace net {
  25
  26 namespace {
  27 const unsigned MDnsTransactionTimeoutSeconds = 3;
  28 }
  29
  30 MDnsConnection::SocketHandler::SocketHandler(
  31     MDnsConnection* connection, const IPEndPoint& multicast_addr,
  32     MDnsConnection::SocketFactory* socket_factory)
  33     : socket_(socket_factory->CreateSocket()), connection_(connection),
  34       response_(new DnsResponse(dns_protocol::kMaxMulticastSize)),
  35       multicast_addr_(multicast_addr) {
  36 }
  37
  38 MDnsConnection::SocketHandler::~SocketHandler() {
  39 }
  40
  41 int MDnsConnection::SocketHandler::Start() {
  42   return DoLoop(0);
  43 }
  44
  45 int MDnsConnection::SocketHandler::DoLoop(int rv) {
  46   do {
  47     if (rv > 0)
  48       connection_->OnDatagramReceived(response_.get(), recv_addr_, rv);
  49
  50     rv = socket_->RecvFrom(
  51         response_->io_buffer(),
  52         response_->io_buffer()->size(),
  53         &recv_addr_,
  54         base::Bind(&MDnsConnection::SocketHandler::OnDatagramReceived,
  55                    base::Unretained(this)));
  56   } while (rv > 0);
  57
  58   if (rv != ERR_IO_PENDING)
  59     return rv;
  60
  61   return OK;
  62 }
  63
  64 void MDnsConnection::SocketHandler::OnDatagramReceived(int rv) {
  65   if (rv >= OK)
  66     rv = DoLoop(rv);
  67
  68   if (rv != OK)
  69     connection_->OnError(this, rv);
  70 }
  71
  72 int MDnsConnection::SocketHandler::Send(IOBuffer* buffer, unsigned size) {
  73   return socket_->SendTo(
  74       buffer, size, multicast_addr_,
  75       base::Bind(&MDnsConnection::SocketHandler::SendDone,
  76                  base::Unretained(this) ));
  77 }
  78
  79 void MDnsConnection::SocketHandler::SendDone(int rv) {
  80   // TODO(noamsml): Retry logic.
  81 }
  82
  83 int MDnsConnection::SocketHandler::Bind() {
  84   IPAddressNumber address_any(multicast_addr_.address().size());
  85
  86   IPEndPoint bind_endpoint(address_any, multicast_addr_.port());
  87
  88   socket_->AllowAddressReuse();
  89   int rv = socket_->Listen(bind_endpoint);
  90
  91   if (rv < OK) return rv;
  92
  93   socket_->SetMulticastLoopbackMode(false);
  94
  95   return socket_->JoinGroup(multicast_addr_.address());
  96 }
  97
  98 MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
  99       delegate_(delegate) {
 100 }
 101
 102 MDnsConnection::~MDnsConnection() {
 103 }
 104
 105 bool MDnsConnection::Init(MDnsConnection::SocketFactory* socket_factory) {
 106   // TODO(vitalybuka): crbug.com/297690 Make socket_factory return list
 107   // of initialized sockets.
 108   socket_handlers_.push_back(
 109       new SocketHandler(this, GetMDnsIPEndPoint(ADDRESS_FAMILY_IPV4),
 110                         socket_factory));
 111   socket_handlers_.push_back(
 112       new SocketHandler(this, GetMDnsIPEndPoint(ADDRESS_FAMILY_IPV6),
 113                         socket_factory));
 114
 115   for (size_t i = 0; i < socket_handlers_.size();) {
 116     int rv = socket_handlers_[i]->Bind();
 117     if (rv != OK) {
 118       socket_handlers_.erase(socket_handlers_.begin() + i);
 119       VLOG(1) << "Bind failed, socket=" << i << ", error=" << rv;
 120     } else {
 121       ++i;
 122     }
 123   }
 124
 125   // All unbound sockets need to be bound before processing untrusted input.
 126   // This is done for security reasons, so that an attacker can't get an unbound
 127   // socket.
 128   for (size_t i = 0; i < socket_handlers_.size();) {
 129     int rv = socket_handlers_[i]->Start();
 130     if (rv != OK) {
 131       socket_handlers_.erase(socket_handlers_.begin() + i);
 132       VLOG(1) << "Start failed, socket=" << i << ", error=" << rv;
 133     } else {
 134       ++i;
 135     }
 136   }
 137   VLOG(1) << "Sockets ready:" << socket_handlers_.size();
 138   return !socket_handlers_.empty();
 139 }
 140
 141 bool MDnsConnection::Send(IOBuffer* buffer, unsigned size) {
 142   bool success = false;
 143   for (size_t i = 0; i < socket_handlers_.size(); ++i) {
 144     int rv = socket_handlers_[i]->Send(buffer, size);
 145     if (rv >= OK || rv == ERR_IO_PENDING) {
 146       success = true;
 147     } else {
 148       VLOG(1) << "Send failed, socket=" << i << ", error=" << rv;
 149     }
 150   }
 151   return success;
 152 }
 153
 154 void MDnsConnection::OnError(SocketHandler* loop,
 155                              int error) {
 156   // TODO(noamsml): Specific handling of intermittent errors that can be handled
 157   // in the connection.
 158   delegate_->OnConnectionError(error);
 159 }
 160
 161 void MDnsConnection::OnDatagramReceived(
 162     DnsResponse* response,
 163     const IPEndPoint& recv_addr,
 164     int bytes_read) {
 165   // TODO(noamsml): More sophisticated error handling.
 166   DCHECK_GT(bytes_read, 0);
 167   delegate_->HandlePacket(response, bytes_read);
 168 }
 169
 170 class MDnsConnectionSocketFactoryImpl
 171     : public MDnsConnection::SocketFactory {
 172  public:
 173   MDnsConnectionSocketFactoryImpl();
 174   virtual ~MDnsConnectionSocketFactoryImpl();
 175
 176   virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE;
 177 };
 178
 179 MDnsConnectionSocketFactoryImpl::MDnsConnectionSocketFactoryImpl() {
 180 }
 181
 182 MDnsConnectionSocketFactoryImpl::~MDnsConnectionSocketFactoryImpl() {
 183 }
 184
 185 scoped_ptr<DatagramServerSocket>
 186 MDnsConnectionSocketFactoryImpl::CreateSocket() {
 187   return scoped_ptr<DatagramServerSocket>(new UDPServerSocket(
 188       NULL, NetLog::Source()));
 189 }
 190
 191 // static
 192 scoped_ptr<MDnsConnection::SocketFactory>
 193 MDnsConnection::SocketFactory::CreateDefault() {
 194   return scoped_ptr<MDnsConnection::SocketFactory>(
 195       new MDnsConnectionSocketFactoryImpl);
 196 }
 197
 198 MDnsClientImpl::Core::Core(MDnsClientImpl* client)
 199     : client_(client), connection_(new MDnsConnection(this)) {
 200 }
 201
 202 MDnsClientImpl::Core::~Core() {
 203   STLDeleteValues(&listeners_);
 204 }
 205
 206 bool MDnsClientImpl::Core::Init(MDnsConnection::SocketFactory* socket_factory) {
 207   return connection_->Init(socket_factory);
 208 }
 209
 210 bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, std::string name) {
 211   std::string name_dns;
 212   if (!DNSDomainFromDot(name, &name_dns))
 213     return false;
 214
 215   DnsQuery query(0, name_dns, rrtype);
 216   query.set_flags(0);  // Remove the RD flag from the query. It is unneeded.
 217
 218   return connection_->Send(query.io_buffer(), query.io_buffer()->size());
 219 }
 220
 221 void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
 222                                         int bytes_read) {
 223   unsigned offset;
 224   // Note: We store cache keys rather than record pointers to avoid
 225   // erroneous behavior in case a packet contains multiple exclusive
 226   // records with the same type and name.
 227   std::map<MDnsCache::Key, MDnsListener::UpdateType> update_keys;
 228
 229   if (!response->InitParseWithoutQuery(bytes_read)) {
 230     LOG(WARNING) << "Could not understand an mDNS packet.";
 231     return;  // Message is unreadable.
 232   }
 233
 234   // TODO(noamsml): duplicate query suppression.
 235   if (!(response->flags() & dns_protocol::kFlagResponse))
 236     return;  // Message is a query. ignore it.
 237
 238   DnsRecordParser parser = response->Parser();
 239   unsigned answer_count = response->answer_count() +
 240       response->additional_answer_count();
 241
 242   for (unsigned i = 0; i < answer_count; i++) {
 243     offset = parser.GetOffset();
 244     scoped_ptr<const RecordParsed> record = RecordParsed::CreateFrom(
 245         &parser, base::Time::Now());
 246
 247     if (!record) {
 248       LOG(WARNING) << "Could not understand an mDNS record.";
 249
 250       if (offset == parser.GetOffset()) {
 251         LOG(WARNING) << "Abandoned parsing the rest of the packet.";
 252         return;  // The parser did not advance, abort reading the packet.
 253       } else {
 254         continue;  // We may be able to extract other records from the packet.
 255       }
 256     }
 257
 258     if ((record->klass() & dns_protocol::kMDnsClassMask) !=
 259         dns_protocol::kClassIN) {
 260       LOG(WARNING) << "Received an mDNS record with non-IN class. Ignoring.";
 261       continue;  // Ignore all records not in the IN class.
 262     }
 263
 264     MDnsCache::Key update_key = MDnsCache::Key::CreateFor(record.get());
 265     MDnsCache::UpdateType update = cache_.UpdateDnsRecord(record.Pass());
 266
 267     // Cleanup time may have changed.
 268     ScheduleCleanup(cache_.next_expiration());
 269
 270     if (update != MDnsCache::NoChange) {
 271       MDnsListener::UpdateType update_external;
 272
 273       switch (update) {
 274         case MDnsCache::RecordAdded:
 275           update_external = MDnsListener::RECORD_ADDED;
 276           break;
 277         case MDnsCache::RecordChanged:
 278           update_external = MDnsListener::RECORD_CHANGED;
 279           break;
 280         case MDnsCache::NoChange:
 281         default:
 282           NOTREACHED();
 283           // Dummy assignment to suppress compiler warning.
 284           update_external = MDnsListener::RECORD_CHANGED;
 285           break;
 286       }
 287
 288       update_keys.insert(std::make_pair(update_key, update_external));
 289     }
 290   }
 291
 292   for (std::map<MDnsCache::Key, MDnsListener::UpdateType>::iterator i =
 293            update_keys.begin(); i != update_keys.end(); i++) {
 294     const RecordParsed* record = cache_.LookupKey(i->first);
 295     if (!record)
 296       continue;
 297
 298     if (record->type() == dns_protocol::kTypeNSEC) {
 299 #if defined(ENABLE_NSEC)
 300       NotifyNsecRecord(record);
 301 #endif
 302     } else {
 303       AlertListeners(i->second, ListenerKey(record->name(), record->type()),
 304                      record);
 305     }
 306   }
 307 }
 308
 309 void MDnsClientImpl::Core::NotifyNsecRecord(const RecordParsed* record) {
 310   DCHECK_EQ(dns_protocol::kTypeNSEC, record->type());
 311   const NsecRecordRdata* rdata = record->rdata<NsecRecordRdata>();
 312   DCHECK(rdata);
 313
 314   // Remove all cached records matching the nonexistent RR types.
 315   std::vector<const RecordParsed*> records_to_remove;
 316
 317   cache_.FindDnsRecords(0, record->name(), &records_to_remove,
 318                         base::Time::Now());
 319
 320   for (std::vector<const RecordParsed*>::iterator i = records_to_remove.begin();
 321        i != records_to_remove.end(); i++) {
 322     if ((*i)->type() == dns_protocol::kTypeNSEC)
 323       continue;
 324     if (!rdata->GetBit((*i)->type())) {
 325       scoped_ptr<const RecordParsed> record_removed = cache_.RemoveRecord((*i));
 326       DCHECK(record_removed);
 327       OnRecordRemoved(record_removed.get());
 328     }
 329   }
 330
 331   // Alert all listeners waiting for the nonexistent RR types.
 332   ListenerMap::iterator i =
 333       listeners_.upper_bound(ListenerKey(record->name(), 0));
 334   for (; i != listeners_.end() && i->first.first == record->name(); i++) {
 335     if (!rdata->GetBit(i->first.second)) {
 336       FOR_EACH_OBSERVER(MDnsListenerImpl, *i->second, AlertNsecRecord());
 337     }
 338   }
 339 }
 340
 341 void MDnsClientImpl::Core::OnConnectionError(int error) {
 342   // TODO(noamsml): On connection error, recreate connection and flush cache.
 343 }
 344
 345 void MDnsClientImpl::Core::AlertListeners(
 346     MDnsListener::UpdateType update_type,
 347     const ListenerKey& key,
 348     const RecordParsed* record) {
 349   ListenerMap::iterator listener_map_iterator = listeners_.find(key);
 350   if (listener_map_iterator == listeners_.end()) return;
 351
 352   FOR_EACH_OBSERVER(MDnsListenerImpl, *listener_map_iterator->second,
 353                     AlertDelegate(update_type, record));
 354 }
 355
 356 void MDnsClientImpl::Core::AddListener(
 357     MDnsListenerImpl* listener) {
 358   ListenerKey key(listener->GetName(), listener->GetType());
 359   std::pair<ListenerMap::iterator, bool> observer_insert_result =
 360       listeners_.insert(
 361           make_pair(key, static_cast<ObserverList<MDnsListenerImpl>*>(NULL)));
 362
 363   // If an equivalent key does not exist, actually create the observer list.
 364   if (observer_insert_result.second)
 365     observer_insert_result.first->second = new ObserverList<MDnsListenerImpl>();
 366
 367   ObserverList<MDnsListenerImpl>* observer_list =
 368       observer_insert_result.first->second;
 369
 370   observer_list->AddObserver(listener);
 371 }
 372
 373 void MDnsClientImpl::Core::RemoveListener(MDnsListenerImpl* listener) {
 374   ListenerKey key(listener->GetName(), listener->GetType());
 375   ListenerMap::iterator observer_list_iterator = listeners_.find(key);
 376
 377   DCHECK(observer_list_iterator != listeners_.end());
 378   DCHECK(observer_list_iterator->second->HasObserver(listener));
 379
 380   observer_list_iterator->second->RemoveObserver(listener);
 381
 382   // Remove the observer list from the map if it is empty
 383   if (!observer_list_iterator->second->might_have_observers()) {
 384     // Schedule the actual removal for later in case the listener removal
 385     // happens while iterating over the observer list.
 386     base::MessageLoop::current()->PostTask(
 387         FROM_HERE, base::Bind(
 388             &MDnsClientImpl::Core::CleanupObserverList, AsWeakPtr(), key));
 389   }
 390 }
 391
 392 void MDnsClientImpl::Core::CleanupObserverList(const ListenerKey& key) {
 393   ListenerMap::iterator found = listeners_.find(key);
 394   if (found != listeners_.end() && !found->second->might_have_observers()) {
 395     delete found->second;
 396     listeners_.erase(found);
 397   }
 398 }
 399
 400 void MDnsClientImpl::Core::ScheduleCleanup(base::Time cleanup) {
 401   // Cleanup is already scheduled, no need to do anything.
 402   if (cleanup == scheduled_cleanup_) return;
 403   scheduled_cleanup_ = cleanup;
 404
 405   // This cancels the previously scheduled cleanup.
 406   cleanup_callback_.Reset(base::Bind(
 407       &MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
 408
 409   // If |cleanup| is empty, then no cleanup necessary.
 410   if (cleanup != base::Time()) {
 411     base::MessageLoop::current()->PostDelayedTask(
 412         FROM_HERE,
 413         cleanup_callback_.callback(),
 414         cleanup - base::Time::Now());
 415   }
 416 }
 417
 418 void MDnsClientImpl::Core::DoCleanup() {
 419   cache_.CleanupRecords(base::Time::Now(), base::Bind(
 420       &MDnsClientImpl::Core::OnRecordRemoved, base::Unretained(this)));
 421
 422   ScheduleCleanup(cache_.next_expiration());
 423 }
 424
 425 void MDnsClientImpl::Core::OnRecordRemoved(
 426     const RecordParsed* record) {
 427   AlertListeners(MDnsListener::RECORD_REMOVED,
 428                  ListenerKey(record->name(), record->type()), record);
 429 }
 430
 431 void MDnsClientImpl::Core::QueryCache(
 432     uint16 rrtype, const std::string& name,
 433     std::vector<const RecordParsed*>* records) const {
 434   cache_.FindDnsRecords(rrtype, name, records, base::Time::Now());
 435 }
 436
 437 MDnsClientImpl::MDnsClientImpl(
 438     scoped_ptr<MDnsConnection::SocketFactory> socket_factory)
 439     : socket_factory_(socket_factory.Pass()) {
 440 }
 441
 442 MDnsClientImpl::~MDnsClientImpl() {
 443 }
 444
 445 bool MDnsClientImpl::StartListening() {
 446   DCHECK(!core_.get());
 447   core_.reset(new Core(this));
 448   if (!core_->Init(socket_factory_.get())) {
 449     core_.reset();
 450     return false;
 451   }
 452   return true;
 453 }
 454
 455 void MDnsClientImpl::StopListening() {
 456   core_.reset();
 457 }
 458
 459 bool MDnsClientImpl::IsListening() const {
 460   return core_.get() != NULL;
 461 }
 462
 463 scoped_ptr<MDnsListener> MDnsClientImpl::CreateListener(
 464     uint16 rrtype,
 465     const std::string& name,
 466     MDnsListener::Delegate* delegate) {
 467   return scoped_ptr<net::MDnsListener>(
 468       new MDnsListenerImpl(rrtype, name, delegate, this));
 469 }
 470
 471 scoped_ptr<MDnsTransaction> MDnsClientImpl::CreateTransaction(
 472     uint16 rrtype,
 473     const std::string& name,
 474     int flags,
 475     const MDnsTransaction::ResultCallback& callback) {
 476   return scoped_ptr<MDnsTransaction>(
 477       new MDnsTransactionImpl(rrtype, name, flags, callback, this));
 478 }
 479
 480 MDnsListenerImpl::MDnsListenerImpl(
 481     uint16 rrtype,
 482     const std::string& name,
 483     MDnsListener::Delegate* delegate,
 484     MDnsClientImpl* client)
 485     : rrtype_(rrtype), name_(name), client_(client), delegate_(delegate),
 486       started_(false) {
 487 }
 488
 489 bool MDnsListenerImpl::Start() {
 490   DCHECK(!started_);
 491
 492   started_ = true;
 493
 494   DCHECK(client_->core());
 495   client_->core()->AddListener(this);
 496
 497   return true;
 498 }
 499
 500 MDnsListenerImpl::~MDnsListenerImpl() {
 501   if (started_) {
 502     DCHECK(client_->core());
 503     client_->core()->RemoveListener(this);
 504   }
 505 }
 506
 507 const std::string& MDnsListenerImpl::GetName() const {
 508   return name_;
 509 }
 510
 511 uint16 MDnsListenerImpl::GetType() const {
 512   return rrtype_;
 513 }
 514
 515 void MDnsListenerImpl::AlertDelegate(MDnsListener::UpdateType update_type,
 516                                      const RecordParsed* record) {
 517   DCHECK(started_);
 518   delegate_->OnRecordUpdate(update_type, record);
 519 }
 520
 521 void MDnsListenerImpl::AlertNsecRecord() {
 522   DCHECK(started_);
 523   delegate_->OnNsecRecord(name_, rrtype_);
 524 }
 525
 526 MDnsTransactionImpl::MDnsTransactionImpl(
 527     uint16 rrtype,
 528     const std::string& name,
 529     int flags,
 530     const MDnsTransaction::ResultCallback& callback,
 531     MDnsClientImpl* client)
 532     : rrtype_(rrtype), name_(name), callback_(callback), client_(client),
 533       started_(false), flags_(flags) {
 534   DCHECK((flags_ & MDnsTransaction::FLAG_MASK) == flags_);
 535   DCHECK(flags_ & MDnsTransaction::QUERY_CACHE ||
 536          flags_ & MDnsTransaction::QUERY_NETWORK);
 537 }
 538
 539 MDnsTransactionImpl::~MDnsTransactionImpl() {
 540   timeout_.Cancel();
 541 }
 542
 543 bool MDnsTransactionImpl::Start() {
 544   DCHECK(!started_);
 545   started_ = true;
 546
 547   base::WeakPtr<MDnsTransactionImpl> weak_this = AsWeakPtr();
 548   if (flags_ & MDnsTransaction::QUERY_CACHE) {
 549     ServeRecordsFromCache();
 550
 551     if (!weak_this || !is_active()) return true;
 552   }
 553
 554   if (flags_ & MDnsTransaction::QUERY_NETWORK) {
 555     return QueryAndListen();
 556   }
 557
 558   // If this is a cache only query, signal that the transaction is over
 559   // immediately.
 560   SignalTransactionOver();
 561   return true;
 562 }
 563
 564 const std::string& MDnsTransactionImpl::GetName() const {
 565   return name_;
 566 }
 567
 568 uint16 MDnsTransactionImpl::GetType() const {
 569   return rrtype_;
 570 }
 571
 572 void MDnsTransactionImpl::CacheRecordFound(const RecordParsed* record) {
 573   DCHECK(started_);
 574   OnRecordUpdate(MDnsListener::RECORD_ADDED, record);
 575 }
 576
 577 void MDnsTransactionImpl::TriggerCallback(MDnsTransaction::Result result,
 578                                           const RecordParsed* record) {
 579   DCHECK(started_);
 580   if (!is_active()) return;
 581
 582   // Ensure callback is run after touching all class state, so that
 583   // the callback can delete the transaction.
 584   MDnsTransaction::ResultCallback callback = callback_;
 585
 586   // Reset the transaction if it expects a single result, or if the result
 587   // is a final one (everything except for a record).
 588   if (flags_ & MDnsTransaction::SINGLE_RESULT ||
 589       result != MDnsTransaction::RESULT_RECORD) {
 590     Reset();
 591   }
 592
 593   callback.Run(result, record);
 594 }
 595
 596 void MDnsTransactionImpl::Reset() {
 597   callback_.Reset();
 598   listener_.reset();
 599   timeout_.Cancel();
 600 }
 601
 602 void MDnsTransactionImpl::OnRecordUpdate(MDnsListener::UpdateType update,
 603                                          const RecordParsed* record) {
 604   DCHECK(started_);
 605   if (update ==  MDnsListener::RECORD_ADDED ||
 606       update == MDnsListener::RECORD_CHANGED)
 607     TriggerCallback(MDnsTransaction::RESULT_RECORD, record);
 608 }
 609
 610 void MDnsTransactionImpl::SignalTransactionOver() {
 611   DCHECK(started_);
 612   if (flags_ & MDnsTransaction::SINGLE_RESULT) {
 613     TriggerCallback(MDnsTransaction::RESULT_NO_RESULTS, NULL);
 614   } else {
 615     TriggerCallback(MDnsTransaction::RESULT_DONE, NULL);
 616   }
 617 }
 618
 619 void MDnsTransactionImpl::ServeRecordsFromCache() {
 620   std::vector<const RecordParsed*> records;
 621   base::WeakPtr<MDnsTransactionImpl> weak_this = AsWeakPtr();
 622
 623   if (client_->core()) {
 624     client_->core()->QueryCache(rrtype_, name_, &records);
 625     for (std::vector<const RecordParsed*>::iterator i = records.begin();
 626          i != records.end() && weak_this; ++i) {
 627       weak_this->TriggerCallback(MDnsTransaction::RESULT_RECORD, *i);
 628     }
 629
 630 #if defined(ENABLE_NSEC)
 631     if (records.empty()) {
 632       DCHECK(weak_this);
 633       client_->core()->QueryCache(dns_protocol::kTypeNSEC, name_, &records);
 634       if (!records.empty()) {
 635         const NsecRecordRdata* rdata =
 636             records.front()->rdata<NsecRecordRdata>();
 637         DCHECK(rdata);
 638         if (!rdata->GetBit(rrtype_))
 639           weak_this->TriggerCallback(MDnsTransaction::RESULT_NSEC, NULL);
 640       }
 641     }
 642 #endif
 643   }
 644 }
 645
 646 bool MDnsTransactionImpl::QueryAndListen() {
 647   listener_ = client_->CreateListener(rrtype_, name_, this);
 648   if (!listener_->Start())
 649     return false;
 650
 651   DCHECK(client_->core());
 652   if (!client_->core()->SendQuery(rrtype_, name_))
 653     return false;
 654
 655   timeout_.Reset(base::Bind(&MDnsTransactionImpl::SignalTransactionOver,
 656                             AsWeakPtr()));
 657   base::MessageLoop::current()->PostDelayedTask(
 658       FROM_HERE,
 659       timeout_.callback(),
 660       base::TimeDelta::FromSeconds(MDnsTransactionTimeoutSeconds));
 661
 662   return true;
 663 }
 664
 665 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
 666   TriggerCallback(RESULT_NSEC, NULL);
 667 }
 668
 669 void MDnsTransactionImpl::OnCachePurged() {
 670   // TODO(noamsml): Cache purge situations not yet implemented
 671 }
 672
 673 }  // namespace net