In-browser DNS-based service discovery system

chrome/browser/local_discovery/service_discovery_client_impl.cc

+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/memory/singleton.h"
+#include "base/message_loop_proxy.h"
+#include "base/stl_util.h"
+#include "chrome/browser/local_discovery/service_discovery_client_impl.h"
+#include "net/dns/dns_protocol.h"
+#include "net/dns/record_rdata.h"
+
+namespace local_discovery {
+
+ServiceDiscoveryClientImpl::ServiceDiscoveryClientImpl() {
+}
+
+ServiceDiscoveryClientImpl::~ServiceDiscoveryClientImpl() {
+}
+
+// static
+ServiceDiscoveryClientImpl* ServiceDiscoveryClientImpl::GetInstance() {
+  return Singleton<ServiceDiscoveryClientImpl>::get();
+}
+
+scoped_ptr<ServiceWatcher> ServiceDiscoveryClientImpl::CreateServiceWatcher(
+    const std::string& service_type,
+    ServiceWatcher::Delegate* delegate) {
+  return scoped_ptr<ServiceWatcher>(new ServiceWatcherImpl(
+      service_type,  delegate));
+}
+
+scoped_ptr<ServiceResolver> ServiceDiscoveryClientImpl::CreateServiceResolver(
+    const std::string& service_name,
+    const ServiceResolver::ResolveCompleteCallback& callback) {
+  return scoped_ptr<ServiceResolver>(new ServiceResolverImpl(
+      service_name, callback));
+}
+
+ServiceWatcherImpl::ServiceWatcherImpl(
+    const std::string& service_type,
+    ServiceWatcher::Delegate* delegate)
+    : service_type_(service_type), delegate_(delegate), started_(false) {
+}
+
+bool ServiceWatcherImpl::Start() {
+  DCHECK(!started_);
+  listener_ = net::MDnsClient::GetInstance()->CreateListener(
+      net::dns_protocol::kTypePTR, service_type_, this);
+  if (!listener_->Start())
+    return false;
+
+  started_ = true;
+  return true;
+}
+
+ServiceWatcherImpl::~ServiceWatcherImpl() {
+  STLDeleteValues(&services_);
+}
+
+void ServiceWatcherImpl::GetAvailableServices(
+    std::vector<std::string>* services) const {
+  DCHECK(started_);
+  DCHECK(services);
+  services->reserve(services_.size());
+  for (std::map<std::string, ServiceListeners*>::const_iterator i =
+           services_.begin(); i != services_.end(); i++) {
+    services->push_back(i->first);
+  }
+}
+
+void ServiceWatcherImpl::DiscoverNewServices(bool force_update) {
+  DCHECK(started_);
+  if (force_update) services_.clear();

[Vitaly Buka (NO REVIEWS), 2013/06/18 23:01:46]

please break if

[Noam Samuel, 2013/06/19 18:46:22]

Done.

+  CreateTransaction(true /*network*/, false /*cache*/, force_update,
+                    &transaction_network_);
+}
+
+void ServiceWatcherImpl::ReadCachedServices() {
+  DCHECK(started_);
+  CreateTransaction(false /*network*/, true /*cache*/, false /*force refresh*/,
+                    &transaction_cache_);
+}
+
+bool ServiceWatcherImpl::CreateTransaction(
+    bool network, bool cache, bool force_refresh,
+    scoped_ptr<net::MDnsTransaction>* transaction) {
+  int transaction_flags = 0;
+  if (network)
+    transaction_flags |= net::MDnsTransaction::QUERY_NETWORK;
+
+  if (cache)
+    transaction_flags |= net::MDnsTransaction::QUERY_CACHE;
+
+  // TODO(noamsml): Add flag for force_refresh when supported.
+
+  if (transaction_flags) {
+    *transaction = net::MDnsClient::GetInstance()->CreateTransaction(
+        net::dns_protocol::kTypePTR, service_type_, transaction_flags,
+        base::Bind(&ServiceWatcherImpl::OnTransactionResponse,
+                   base::Unretained(this), transaction));
+    return (*transaction)->Start();
+  }
+
+  return true;
+}
+
+std::string ServiceWatcherImpl::GetServiceType() const {
+  return listener_->GetName();
+}
+
+void ServiceWatcherImpl::OnRecordUpdate(
+    net::MDnsListener::UpdateType update,
+    const net::RecordParsed* record) {
+  DCHECK(started_);
+  if (record->type() == net::dns_protocol::kTypePTR) {
+    DCHECK(record->name() == GetServiceType());
+    const net::PtrRecordRdata* rdata = record->rdata<net::PtrRecordRdata>();
+
+    switch (update) {
+      case net::MDnsListener::RECORD_ADDED:
+        AddService(rdata->ptrdomain());
+        break;
+      case net::MDnsListener::RECORD_CHANGED:
+        NOTREACHED();
+        break;
+      case net::MDnsListener::RECORD_REMOVED:
+        RemoveService(rdata->ptrdomain());
+        break;
+    }
+  } else {
+    DCHECK(record->type() == net::dns_protocol::kTypeSRV ||
+           record->type() == net::dns_protocol::kTypeTXT);
+    DCHECK(services_.find(record->name()) != services_.end());

[gene, 2013/06/18 23:46:53]

PTR may easily arrive after SRV, will it cause problems here?

[Noam Samuel, 2013/06/19 18:46:22]

The service won't be notified as "updated" if that's the case since there will
be no listener for the SRV record when it arrives. I might posit it's a problem
if SRV arrives immediately after PTR and causes a spurious update notification.
It's not a huge problem, though, so I'm OK deferring it to another CL.

[gene, 2013/06/19 22:48:03]

Could you please add a comment here, explaining that service must be present in
the services_ list already, if we get TXT/SRV record update?

On 2013/06/19 18:46:22, Noam Samuel wrote:

+
+    delegate_->OnServiceChanged(record->name());
+  }
+}
+
+void ServiceWatcherImpl::OnCachePurged() {
+  // Not yet implemented.
+}
+
+void ServiceWatcherImpl::OnTransactionResponse(
+    scoped_ptr<net::MDnsTransaction>* transaction,
+    net::MDnsTransaction::Result result,
+    const net::RecordParsed* record) {
+  DCHECK(started_);
+  if (result == net::MDnsTransaction::RESULT_RECORD) {
+    const net::PtrRecordRdata* rdata = record->rdata<net::PtrRecordRdata>();
+    DCHECK(rdata);

[gene, 2013/06/18 23:46:53]

Do you want to have DCHECK() here, or if() and politely handle wrong response?

[Noam Samuel, 2013/06/19 18:46:22]

Since the only transaction we have is a PTR record transaction, and the MDns
layer should be passing only PTR records as responses, I'd posit a DCHECK is
perfectly legitimate here.

+    AddService(rdata->ptrdomain());
+  } else if (result == net::MDnsTransaction::RESULT_DONE) {
+    transaction->reset();
+  }
+
+  // Do nothing for NSEC records. It is an error for hosts to broadcast an NSEC
+  // record for PTR records on any name.
+}
+
+ServiceWatcherImpl::ServiceListeners::ServiceListeners(
+    const std::string& service_name,
+    ServiceWatcherImpl* watcher) {
+  srv_listener_ = net::MDnsClient::GetInstance()->CreateListener(
+      net::dns_protocol::kTypeSRV, service_name, watcher);
+  txt_listener_ = net::MDnsClient::GetInstance()->CreateListener(
+      net::dns_protocol::kTypeTXT, service_name, watcher);
+}
+
+ServiceWatcherImpl::ServiceListeners::~ServiceListeners() {
+}
+
+bool ServiceWatcherImpl::ServiceListeners::Start() {
+  if (!srv_listener_->Start())
+    return false;
+  return txt_listener_->Start();

[gene, 2013/06/18 23:46:53]

Is there are problems if src listener will start and txt don't?

[Noam Samuel, 2013/06/19 18:46:22]

It seems unlikely that would happen. If it does, the service watcher will not
deliver change notifications for changes in the TXT records of that service.
Ideally we should tunnel this error upwards.

+}
+
+void ServiceWatcherImpl::AddService(const std::string& service) {
+  DCHECK(started_);
+  std::pair<std::map<std::string, ServiceListeners*>::iterator, bool> found =

[gene, 2013/06/18 23:46:53]

consider typedef std::map<std::string, ServiceListeners*> to simplify this line

[Noam Samuel, 2013/06/19 18:46:22]

Done.

+      services_.insert(make_pair(service,

[gene, 2013/06/18 23:46:53]

services_.find() can make this code a bit more readable

[Noam Samuel, 2013/06/19 18:46:22]

Services_.insert() will do one lookup instead of two.

+                                 static_cast<ServiceListeners*>(NULL)));
+  if (found.second) {  // Newly inserted.
+    found.first->second = new ServiceListeners(service, this);

[gene, 2013/06/18 23:46:53]

Do you want to keep found.first->second as a scoped_ptr vs. ServiceListeners* ?

[Noam Samuel, 2013/06/19 18:46:22]

scoped_ptr doesn't play nice with STL containers. Using linked_ptr.

+    bool success = found.first->second->Start();
+    DCHECK(success);
+    delegate_->OnServiceStatusChanged(true, service);
+  }
+}
+
+void ServiceWatcherImpl::RemoveService(const std::string& service) {
+  DCHECK(started_);
+  std::map<std::string, ServiceListeners*>::iterator found =
+      services_.find(service);
+  if (found != services_.end()) {
+    delete found->second;  // Delete the listeners
+    services_.erase(found);  // Erase the service
+    delegate_->OnServiceStatusChanged(false, service);
+  }
+}
+
+void ServiceWatcherImpl::OnNsecRecord(const std::string& name,
+                                          unsigned rrtype) {
+  // Do nothing. It is an error for hosts to broadcast an NSEC record for PTR
+  // on any name.
+}
+
+ServiceResolverImpl::ServiceResolverImpl(
+    const std::string& service_name,
+    const ResolveCompleteCallback& callback)
+    : service_name_(service_name), callback_(callback),
+      is_resolving_(false), has_resolved_(false), metadata_resolved_(false),
+      address_resolved_(false), current_service_index_(0) {
+}
+
+bool ServiceResolverImpl::StartResolving() {
+  if (!CreateTxtTransaction())
+    return false;
+  if (!CreateSrvTransaction())
+    return false;
+  is_resolving_ = true;
+  address_resolved_ = false;
+  metadata_resolved_ = false;
+  return true;
+}
+
+bool ServiceResolverImpl::IsResolving() const {
+  return is_resolving_;
+}
+
+bool ServiceResolverImpl::HasResolved() const {
+  return has_resolved_;
+}
+
+ServiceResolverImpl::~ServiceResolverImpl() {
+}
+
+bool ServiceResolverImpl::CreateTxtTransaction() {
+  txt_transaction_ = net::MDnsClient::GetInstance()->CreateTransaction(
+      net::dns_protocol::kTypeTXT, service_name_,
+      net::MDnsTransaction::SINGLE_RESULT | net::MDnsTransaction::QUERY_CACHE |
+      net::MDnsTransaction::QUERY_NETWORK,
+      base::Bind(&ServiceResolverImpl::TxtRecordTransactionResponse,
+                 AsWeakPtr()));
+  return txt_transaction_->Start();
+}
+
+// TODO(noamsml): quick-resolve for AAAA records.  Since A records tend to be in
+void ServiceResolverImpl::CreateATransaction() {
+  a_transaction_ = net::MDnsClient::GetInstance()->CreateTransaction(
+      net::dns_protocol::kTypeA,
+      staging_service()->address.host(),
+      net::MDnsTransaction::SINGLE_RESULT | net::MDnsTransaction::QUERY_CACHE,
+      base::Bind(&ServiceResolverImpl::ARecordTransactionResponse,
+                 AsWeakPtr()));
+  a_transaction_->Start();
+}
+
+bool ServiceResolverImpl::CreateSrvTransaction() {
+  srv_transaction_ = net::MDnsClient::GetInstance()->CreateTransaction(
+      net::dns_protocol::kTypeSRV, service_name_,
+      net::MDnsTransaction::SINGLE_RESULT | net::MDnsTransaction::QUERY_CACHE |
+      net::MDnsTransaction::QUERY_NETWORK,
+      base::Bind(&ServiceResolverImpl::SrvRecordTransactionResponse,
+                 AsWeakPtr()));
+  return srv_transaction_->Start();
+}
+
+std::string ServiceResolverImpl::GetHumanReadableName() const {
+  // TODO(noamsml): Once we have escaping working, get this to
+  // parse escaped domains.
+  size_t first_period = service_name_.find_first_of('.');
+  return service_name_.substr(0, first_period);
+}
+
+std::string ServiceResolverImpl::GetType() const {
+  // TODO(noamsml): Once we have escaping working, get this to
+  // parse escaped domains.
+  size_t first_period = service_name_.find_first_of('.');
+  if (first_period == std::string::npos)
+    return "";
+  return service_name_.substr(first_period+1);
+}
+
+std::string ServiceResolverImpl::GetName() const {
+  return service_name_;
+}
+
+void ServiceResolverImpl::SrvRecordTransactionResponse(
+    net::MDnsTransaction::Result status, const net::RecordParsed* record) {
+  srv_transaction_.reset();
+  if (status == net::MDnsTransaction::RESULT_RECORD) {
+    DCHECK(record);
+    staging_service()->address = RecordToAddress(record);
+    staging_service()->last_seen = record->time_created();
+    CreateATransaction();
+  } else {
+    txt_transaction_.reset();
+    srv_transaction_.reset();
+    a_transaction_.reset();
+    is_resolving_ = false;
+    callback_.Run(MDnsStatusToRequestStatus(status));
+  }
+}
+
+void ServiceResolverImpl::TxtRecordTransactionResponse(
+    net::MDnsTransaction::Result status, const net::RecordParsed* record) {
+  txt_transaction_.reset();
+  if (status == net::MDnsTransaction::RESULT_RECORD) {
+    DCHECK(record);
+    staging_service()->metadata = RecordToMetadata(record);
+  } else {
+    staging_service()->metadata = std::vector<std::string>();
+  }
+
+  metadata_resolved_ = true;
+  AlertCallbackIfReady();
+}
+
+void ServiceResolverImpl::ARecordTransactionResponse(
+    net::MDnsTransaction::Result status, const net::RecordParsed* record) {
+  a_transaction_.reset();
+
+  if (status == net::MDnsTransaction::RESULT_RECORD) {
+    DCHECK(record);
+    staging_service()->ip_address = RecordToIPAddress(record);
+  } else {
+    staging_service()->ip_address = net::IPAddressNumber();
+  }
+
+  address_resolved_ = true;
+  AlertCallbackIfReady();
+}
+
+void ServiceResolverImpl::AlertCallbackIfReady() {
+  if (metadata_resolved_ && address_resolved_) {
+    txt_transaction_.reset();
+    srv_transaction_.reset();
+    a_transaction_.reset();
+    has_resolved_ = true;
+    is_resolving_ = false;
+    current_service_index_ = (current_service_index_ + 1) % 2;
+    callback_.Run(STATUS_SUCCESS);
+  }
+}
+
+const Service& ServiceResolverImpl::GetService() const {
+  return services_[current_service_index_];
+}
+
+ServiceResolver::RequestStatus ServiceResolverImpl::MDnsStatusToRequestStatus(
+    net::MDnsTransaction::Result status) const {
+  switch (status) {
+    case net::MDnsTransaction::RESULT_RECORD:
+      return ServiceResolver::STATUS_SUCCESS;
+    case net::MDnsTransaction::RESULT_NO_RESULTS:
+      return ServiceResolver::STATUS_TIMEOUT;
+    case net::MDnsTransaction::RESULT_NSEC:
+      return ServiceResolver::STATUS_KNOWN_NONEXISTENT;
+    case net::MDnsTransaction::RESULT_DONE:
+      NOTREACHED();
+      return ServiceResolver::STATUS_TIMEOUT;
+  }
+}
+
+const std::vector<std::string>& ServiceResolverImpl::RecordToMetadata(
+    const net::RecordParsed* record) const {
+  DCHECK(record->type() == net::dns_protocol::kTypeTXT);
+  const net::TxtRecordRdata* txt_rdata = record->rdata<net::TxtRecordRdata>();
+  DCHECK(txt_rdata);
+  return txt_rdata->texts();
+}
+
+net::HostPortPair ServiceResolverImpl::RecordToAddress(
+    const net::RecordParsed* record) const {
+  DCHECK(record->type() == net::dns_protocol::kTypeSRV);
+  const net::SrvRecordRdata* srv_rdata = record->rdata<net::SrvRecordRdata>();
+  DCHECK(srv_rdata);
+  return net::HostPortPair(srv_rdata->target(), srv_rdata->port());
+}
+
+const net::IPAddressNumber& ServiceResolverImpl::RecordToIPAddress(
+    const net::RecordParsed* record) const {
+  DCHECK(record->type() == net::dns_protocol::kTypeA);
+  const net::ARecordRdata* a_rdata = record->rdata<net::ARecordRdata>();
+  DCHECK(a_rdata);
+  return a_rdata->address();
+}
+
+}  // namespace local_discovery