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.
5 #include "net/dns/mdns_client_impl.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"
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
27 const unsigned MDnsTransactionTimeoutSeconds = 3;
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) {
38 MDnsConnection::SocketHandler::~SocketHandler() {
41 int MDnsConnection::SocketHandler::Start() {
45 int MDnsConnection::SocketHandler::DoLoop(int rv) {
48 connection_->OnDatagramReceived(response_.get(), recv_addr_, rv);
50 rv = socket_->RecvFrom(
51 response_->io_buffer(),
52 response_->io_buffer()->size(),
54 base::Bind(&MDnsConnection::SocketHandler::OnDatagramReceived,
55 base::Unretained(this)));
58 if (rv != ERR_IO_PENDING)
64 void MDnsConnection::SocketHandler::OnDatagramReceived(int rv) {
69 connection_->OnError(this, rv);
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) ));
79 void MDnsConnection::SocketHandler::SendDone(int rv) {
80 // TODO(noamsml): Retry logic.
83 int MDnsConnection::SocketHandler::Bind() {
84 IPAddressNumber address_any(multicast_addr_.address().size());
86 IPEndPoint bind_endpoint(address_any, multicast_addr_.port());
88 socket_->AllowAddressReuse();
89 int rv = socket_->Listen(bind_endpoint);
91 if (rv < OK) return rv;
93 socket_->SetMulticastLoopbackMode(false);
95 return socket_->JoinGroup(multicast_addr_.address());
98 MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
102 MDnsConnection::~MDnsConnection() {
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),
111 socket_handlers_.push_back(
112 new SocketHandler(this, GetMDnsIPEndPoint(ADDRESS_FAMILY_IPV6),
115 for (size_t i = 0; i < socket_handlers_.size();) {
116 int rv = socket_handlers_[i]->Bind();
118 socket_handlers_.erase(socket_handlers_.begin() + i);
119 VLOG(1) << "Bind failed, socket=" << i << ", error=" << rv;
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
128 for (size_t i = 0; i < socket_handlers_.size();) {
129 int rv = socket_handlers_[i]->Start();
131 socket_handlers_.erase(socket_handlers_.begin() + i);
132 VLOG(1) << "Start failed, socket=" << i << ", error=" << rv;
137 VLOG(1) << "Sockets ready:" << socket_handlers_.size();
138 return !socket_handlers_.empty();
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) {
148 VLOG(1) << "Send failed, socket=" << i << ", error=" << rv;
154 void MDnsConnection::OnError(SocketHandler* loop,
156 // TODO(noamsml): Specific handling of intermittent errors that can be handled
157 // in the connection.
158 delegate_->OnConnectionError(error);
161 void MDnsConnection::OnDatagramReceived(
162 DnsResponse* response,
163 const IPEndPoint& recv_addr,
165 // TODO(noamsml): More sophisticated error handling.
166 DCHECK_GT(bytes_read, 0);
167 delegate_->HandlePacket(response, bytes_read);
170 class MDnsConnectionSocketFactoryImpl
171 : public MDnsConnection::SocketFactory {
173 MDnsConnectionSocketFactoryImpl();
174 virtual ~MDnsConnectionSocketFactoryImpl();
176 virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE;
179 MDnsConnectionSocketFactoryImpl::MDnsConnectionSocketFactoryImpl() {
182 MDnsConnectionSocketFactoryImpl::~MDnsConnectionSocketFactoryImpl() {
185 scoped_ptr<DatagramServerSocket>
186 MDnsConnectionSocketFactoryImpl::CreateSocket() {
187 return scoped_ptr<DatagramServerSocket>(new UDPServerSocket(
188 NULL, NetLog::Source()));
192 scoped_ptr<MDnsConnection::SocketFactory>
193 MDnsConnection::SocketFactory::CreateDefault() {
194 return scoped_ptr<MDnsConnection::SocketFactory>(
195 new MDnsConnectionSocketFactoryImpl);
198 MDnsClientImpl::Core::Core(MDnsClientImpl* client)
199 : client_(client), connection_(new MDnsConnection(this)) {
202 MDnsClientImpl::Core::~Core() {
203 STLDeleteValues(&listeners_);
206 bool MDnsClientImpl::Core::Init(MDnsConnection::SocketFactory* socket_factory) {
207 return connection_->Init(socket_factory);
210 bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, std::string name) {
211 std::string name_dns;
212 if (!DNSDomainFromDot(name, &name_dns))
215 DnsQuery query(0, name_dns, rrtype);
216 query.set_flags(0); // Remove the RD flag from the query. It is unneeded.
218 return connection_->Send(query.io_buffer(), query.io_buffer()->size());
221 void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
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;
229 if (!response->InitParseWithoutQuery(bytes_read)) {
230 LOG(WARNING) << "Could not understand an mDNS packet.";
231 return; // Message is unreadable.
234 // TODO(noamsml): duplicate query suppression.
235 if (!(response->flags() & dns_protocol::kFlagResponse))
236 return; // Message is a query. ignore it.
238 DnsRecordParser parser = response->Parser();
239 unsigned answer_count = response->answer_count() +
240 response->additional_answer_count();
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());
248 LOG(WARNING) << "Could not understand an mDNS record.";
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.
254 continue; // We may be able to extract other records from the packet.
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.
264 MDnsCache::Key update_key = MDnsCache::Key::CreateFor(record.get());
265 MDnsCache::UpdateType update = cache_.UpdateDnsRecord(record.Pass());
267 // Cleanup time may have changed.
268 ScheduleCleanup(cache_.next_expiration());
270 if (update != MDnsCache::NoChange) {
271 MDnsListener::UpdateType update_external;
274 case MDnsCache::RecordAdded:
275 update_external = MDnsListener::RECORD_ADDED;
277 case MDnsCache::RecordChanged:
278 update_external = MDnsListener::RECORD_CHANGED;
280 case MDnsCache::NoChange:
283 // Dummy assignment to suppress compiler warning.
284 update_external = MDnsListener::RECORD_CHANGED;
288 update_keys.insert(std::make_pair(update_key, update_external));
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);
298 if (record->type() == dns_protocol::kTypeNSEC) {
299 #if defined(ENABLE_NSEC)
300 NotifyNsecRecord(record);
303 AlertListeners(i->second, ListenerKey(record->name(), record->type()),
309 void MDnsClientImpl::Core::NotifyNsecRecord(const RecordParsed* record) {
310 DCHECK_EQ(dns_protocol::kTypeNSEC, record->type());
311 const NsecRecordRdata* rdata = record->rdata<NsecRecordRdata>();
314 // Remove all cached records matching the nonexistent RR types.
315 std::vector<const RecordParsed*> records_to_remove;
317 cache_.FindDnsRecords(0, record->name(), &records_to_remove,
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)
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());
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());
341 void MDnsClientImpl::Core::OnConnectionError(int error) {
342 // TODO(noamsml): On connection error, recreate connection and flush cache.
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;
352 FOR_EACH_OBSERVER(MDnsListenerImpl, *listener_map_iterator->second,
353 AlertDelegate(update_type, record));
356 void MDnsClientImpl::Core::AddListener(
357 MDnsListenerImpl* listener) {
358 ListenerKey key(listener->GetName(), listener->GetType());
359 std::pair<ListenerMap::iterator, bool> observer_insert_result =
361 make_pair(key, static_cast<ObserverList<MDnsListenerImpl>*>(NULL)));
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>();
367 ObserverList<MDnsListenerImpl>* observer_list =
368 observer_insert_result.first->second;
370 observer_list->AddObserver(listener);
373 void MDnsClientImpl::Core::RemoveListener(MDnsListenerImpl* listener) {
374 ListenerKey key(listener->GetName(), listener->GetType());
375 ListenerMap::iterator observer_list_iterator = listeners_.find(key);
377 DCHECK(observer_list_iterator != listeners_.end());
378 DCHECK(observer_list_iterator->second->HasObserver(listener));
380 observer_list_iterator->second->RemoveObserver(listener);
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));
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);
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;
405 // This cancels the previously scheduled cleanup.
406 cleanup_callback_.Reset(base::Bind(
407 &MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
409 // If |cleanup| is empty, then no cleanup necessary.
410 if (cleanup != base::Time()) {
411 base::MessageLoop::current()->PostDelayedTask(
413 cleanup_callback_.callback(),
414 cleanup - base::Time::Now());
418 void MDnsClientImpl::Core::DoCleanup() {
419 cache_.CleanupRecords(base::Time::Now(), base::Bind(
420 &MDnsClientImpl::Core::OnRecordRemoved, base::Unretained(this)));
422 ScheduleCleanup(cache_.next_expiration());
425 void MDnsClientImpl::Core::OnRecordRemoved(
426 const RecordParsed* record) {
427 AlertListeners(MDnsListener::RECORD_REMOVED,
428 ListenerKey(record->name(), record->type()), record);
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());
437 MDnsClientImpl::MDnsClientImpl(
438 scoped_ptr<MDnsConnection::SocketFactory> socket_factory)
439 : socket_factory_(socket_factory.Pass()) {
442 MDnsClientImpl::~MDnsClientImpl() {
445 bool MDnsClientImpl::StartListening() {
446 DCHECK(!core_.get());
447 core_.reset(new Core(this));
448 if (!core_->Init(socket_factory_.get())) {
455 void MDnsClientImpl::StopListening() {
459 bool MDnsClientImpl::IsListening() const {
460 return core_.get() != NULL;
463 scoped_ptr<MDnsListener> MDnsClientImpl::CreateListener(
465 const std::string& name,
466 MDnsListener::Delegate* delegate) {
467 return scoped_ptr<net::MDnsListener>(
468 new MDnsListenerImpl(rrtype, name, delegate, this));
471 scoped_ptr<MDnsTransaction> MDnsClientImpl::CreateTransaction(
473 const std::string& name,
475 const MDnsTransaction::ResultCallback& callback) {
476 return scoped_ptr<MDnsTransaction>(
477 new MDnsTransactionImpl(rrtype, name, flags, callback, this));
480 MDnsListenerImpl::MDnsListenerImpl(
482 const std::string& name,
483 MDnsListener::Delegate* delegate,
484 MDnsClientImpl* client)
485 : rrtype_(rrtype), name_(name), client_(client), delegate_(delegate),
489 bool MDnsListenerImpl::Start() {
494 DCHECK(client_->core());
495 client_->core()->AddListener(this);
500 MDnsListenerImpl::~MDnsListenerImpl() {
502 DCHECK(client_->core());
503 client_->core()->RemoveListener(this);
507 const std::string& MDnsListenerImpl::GetName() const {
511 uint16 MDnsListenerImpl::GetType() const {
515 void MDnsListenerImpl::AlertDelegate(MDnsListener::UpdateType update_type,
516 const RecordParsed* record) {
518 delegate_->OnRecordUpdate(update_type, record);
521 void MDnsListenerImpl::AlertNsecRecord() {
523 delegate_->OnNsecRecord(name_, rrtype_);
526 MDnsTransactionImpl::MDnsTransactionImpl(
528 const std::string& name,
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);
539 MDnsTransactionImpl::~MDnsTransactionImpl() {
543 bool MDnsTransactionImpl::Start() {
547 base::WeakPtr<MDnsTransactionImpl> weak_this = AsWeakPtr();
548 if (flags_ & MDnsTransaction::QUERY_CACHE) {
549 ServeRecordsFromCache();
551 if (!weak_this || !is_active()) return true;
554 if (flags_ & MDnsTransaction::QUERY_NETWORK) {
555 return QueryAndListen();
558 // If this is a cache only query, signal that the transaction is over
560 SignalTransactionOver();
564 const std::string& MDnsTransactionImpl::GetName() const {
568 uint16 MDnsTransactionImpl::GetType() const {
572 void MDnsTransactionImpl::CacheRecordFound(const RecordParsed* record) {
574 OnRecordUpdate(MDnsListener::RECORD_ADDED, record);
577 void MDnsTransactionImpl::TriggerCallback(MDnsTransaction::Result result,
578 const RecordParsed* record) {
580 if (!is_active()) return;
582 // Ensure callback is run after touching all class state, so that
583 // the callback can delete the transaction.
584 MDnsTransaction::ResultCallback callback = callback_;
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) {
593 callback.Run(result, record);
596 void MDnsTransactionImpl::Reset() {
602 void MDnsTransactionImpl::OnRecordUpdate(MDnsListener::UpdateType update,
603 const RecordParsed* record) {
605 if (update == MDnsListener::RECORD_ADDED ||
606 update == MDnsListener::RECORD_CHANGED)
607 TriggerCallback(MDnsTransaction::RESULT_RECORD, record);
610 void MDnsTransactionImpl::SignalTransactionOver() {
612 if (flags_ & MDnsTransaction::SINGLE_RESULT) {
613 TriggerCallback(MDnsTransaction::RESULT_NO_RESULTS, NULL);
615 TriggerCallback(MDnsTransaction::RESULT_DONE, NULL);
619 void MDnsTransactionImpl::ServeRecordsFromCache() {
620 std::vector<const RecordParsed*> records;
621 base::WeakPtr<MDnsTransactionImpl> weak_this = AsWeakPtr();
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);
630 #if defined(ENABLE_NSEC)
631 if (records.empty()) {
633 client_->core()->QueryCache(dns_protocol::kTypeNSEC, name_, &records);
634 if (!records.empty()) {
635 const NsecRecordRdata* rdata =
636 records.front()->rdata<NsecRecordRdata>();
638 if (!rdata->GetBit(rrtype_))
639 weak_this->TriggerCallback(MDnsTransaction::RESULT_NSEC, NULL);
646 bool MDnsTransactionImpl::QueryAndListen() {
647 listener_ = client_->CreateListener(rrtype_, name_, this);
648 if (!listener_->Start())
651 DCHECK(client_->core());
652 if (!client_->core()->SendQuery(rrtype_, name_))
655 timeout_.Reset(base::Bind(&MDnsTransactionImpl::SignalTransactionOver,
657 base::MessageLoop::current()->PostDelayedTask(
660 base::TimeDelta::FromSeconds(MDnsTransactionTimeoutSeconds));
665 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
666 TriggerCallback(RESULT_NSEC, NULL);
669 void MDnsTransactionImpl::OnCachePurged() {
670 // TODO(noamsml): Cache purge situations not yet implemented