mdns_client_impl.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
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
24namespace net {
25
26namespace {
27
28const 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.
33const double kListenerRefreshRatio1 = 0.85;
34const double kListenerRefreshRatio2 = 0.95;
35const unsigned kMillisecondsPerSecond = 1000;
36
37}  // namespace
38
39void 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
52MDnsConnection::SocketHandler::SocketHandler(
53    scoped_ptr<DatagramServerSocket> socket,
54    MDnsConnection* connection)
55    : socket_(socket.Pass()),
56      connection_(connection),
57      response_(dns_protocol::kMaxMulticastSize) {
58}
59
60MDnsConnection::SocketHandler::~SocketHandler() {
61}
62
63int 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
74int 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
93void 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
101int 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
107void MDnsConnection::SocketHandler::SendDone(int rv) {
108  // TODO(noamsml): Retry logic.
109}
110
111MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
112      delegate_(delegate) {
113}
114
115MDnsConnection::~MDnsConnection() {
116}
117
118bool 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
144bool 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
157void 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
164void 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
173MDnsClientImpl::Core::Core(MDnsClientImpl* client)
174    : client_(client), connection_(new MDnsConnection(this)) {
175}
176
177MDnsClientImpl::Core::~Core() {
178  STLDeleteValues(&listeners_);
179}
180
181bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
182  return connection_->Init(socket_factory);
183}
184
185bool 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
196void 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
265void 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
297void MDnsClientImpl::Core::OnConnectionError(int error) {
298  // TODO(noamsml): On connection error, recreate connection and flush cache.
299}
300
301void 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
312void 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
329void 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
348void 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
356void 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
374void 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
381void MDnsClientImpl::Core::OnRecordRemoved(
382    const RecordParsed* record) {
383  AlertListeners(MDnsCache::RecordRemoved,
384                 ListenerKey(record->name(), record->type()), record);
385}
386
387void 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
393MDnsClientImpl::MDnsClientImpl() {
394}
395
396MDnsClientImpl::~MDnsClientImpl() {
397}
398
399bool 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
409void MDnsClientImpl::StopListening() {
410  core_.reset();
411}
412
413bool MDnsClientImpl::IsListening() const {
414  return core_.get() != NULL;
415}
416
417scoped_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
425scoped_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
434MDnsListenerImpl::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
443MDnsListenerImpl::~MDnsListenerImpl() {
444  if (started_) {
445    DCHECK(client_->core());
446    client_->core()->RemoveListener(this);
447  }
448}
449
450bool 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
461void 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
473const std::string& MDnsListenerImpl::GetName() const {
474  return name_;
475}
476
477uint16 MDnsListenerImpl::GetType() const {
478  return rrtype_;
479}
480
481void 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
517void MDnsListenerImpl::AlertNsecRecord() {
518  DCHECK(started_);
519  delegate_->OnNsecRecord(name_, rrtype_);
520}
521
522void 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
559void MDnsListenerImpl::DoRefresh() {
560  client_->core()->SendQuery(rrtype_, name_);
561}
562
563MDnsTransactionImpl::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
576MDnsTransactionImpl::~MDnsTransactionImpl() {
577  timeout_.Cancel();
578}
579
580bool 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
601const std::string& MDnsTransactionImpl::GetName() const {
602  return name_;
603}
604
605uint16 MDnsTransactionImpl::GetType() const {
606  return rrtype_;
607}
608
609void MDnsTransactionImpl::CacheRecordFound(const RecordParsed* record) {
610  DCHECK(started_);
611  OnRecordUpdate(MDnsListener::RECORD_ADDED, record);
612}
613
614void 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
633void MDnsTransactionImpl::Reset() {
634  callback_.Reset();
635  listener_.reset();
636  timeout_.Cancel();
637}
638
639void 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
647void 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
656void 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
683bool 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
702void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
703  TriggerCallback(RESULT_NSEC, NULL);
704}
705
706void MDnsTransactionImpl::OnCachePurged() {
707  // TODO(noamsml): Cache purge situations not yet implemented
708}
709
710}  // namespace net
711