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