Cache for mDNS records

net/dns/mdns_cache.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 "net/dns/mdns_cache.h"
+
+#include <utility>
+
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "net/dns/dns_protocol.h"
+#include "net/dns/record_parsed.h"
+#include "net/dns/record_rdata.h"
+
+// TODO(noamsml): Recursive CNAME closure (backwards and forwards).
+
+namespace net {
+
+// The effective TTL given to records with a nominal zero TTL.
+// Allows time for hosts to send updated records, as detailed in RFC 6762
+// Section 10.1.
+static const unsigned kZeroTTLSeconds = 1;
+
+MDnsCache::DnsRecordCacheKey::DnsRecordCacheKey(unsigned type,
+                                                const std::string& name,
+                                                const std::string& optional)
+    : type_(type), name_(name), optional_(optional) {
+}
+
+MDnsCache::DnsRecordCacheKey::DnsRecordCacheKey(
+    const MDnsCache::DnsRecordCacheKey& other)
+    : type_(other.type_), name_(other.name_), optional_(other.optional_) {
+}
+
+
+MDnsCache::DnsRecordCacheKey& MDnsCache::DnsRecordCacheKey::operator=(
+    const MDnsCache::DnsRecordCacheKey& other) {
+  type_ = other.type_;
+  name_ = other.name_;
+  optional_ = other.optional_;
+  return *this;
+}
+
+MDnsCache::DnsRecordCacheKey::~DnsRecordCacheKey() {
+}
+
+bool MDnsCache::DnsRecordCacheKey::operator<(
+    const MDnsCache::DnsRecordCacheKey& key) const {
+  if (type_ != key.type_)
+    return type_ < key.type_;
+
+  if (name_ != key.name_)
+    return name_ < key.name_;
+
+  if (optional_ != key.optional_)
+    return optional_ < key.optional_;
+  return false;  // keys are equal
+}
+
+bool MDnsCache::DnsRecordCacheKey::operator==(
+    const MDnsCache::DnsRecordCacheKey& key) const {
+  return type_ == key.type_ && name_ == key.name_ && optional_ == key.optional_;
+}
+
+MDnsCache::MDnsCache() {
+}
+
+MDnsCache::~MDnsCache() {
+  Clear();
+}
+
+void MDnsCache::Clear() {
+  next_expiration_ = base::Time();
+  STLDeleteValues(&mdns_cache_);
+}
+
+MDnsCache::UpdateType MDnsCache::UpdateDnsRecord(
+    scoped_ptr<const RecordParsed> record) {
+  UpdateType type = NoChange;
+
+  MDnsCache::DnsRecordCacheKey cache_key = MDnsCache::DnsRecordCacheKey(
+      record->type(),
+      record->name(),
+      GetOptionalFieldForRecord(record.get()));
+
+  base::Time expiration = GetEffectiveExpiration(record.get());
+  if (next_expiration_ == base::Time() || expiration < next_expiration_) {
+    next_expiration_ = expiration;
+  }
+
+  std::pair<MDnsCacheMap::iterator, bool> insert_result =
+      mdns_cache_.insert(std::make_pair(cache_key, (const RecordParsed*)NULL));
+
+  if (insert_result.second) {
+    type = RecordAdded;
+    insert_result.first->second = record.release();
+  } else {
+    const RecordParsed* other_record = insert_result.first->second;
+
+    if (!record->IsEqual(other_record, true)) {
+      type = RecordChanged;
+    }
+    delete other_record;
+    insert_result.first->second = record.release();
+  }
+
+  return type;
+}
+
+void MDnsCache::CleanupRecords(
+    base::Time now,
+    const RecordRemovedCallback& record_removed_callback) {
+  base::Time next_expiration;
+
+  // We are guaranteed that |next_expiration_| will be at or before the next
+  // expiration. This allows clients to eagrely call CleanupRecords with
+  // impunity.
+  if (now < next_expiration_) return;
+
+  for (MDnsCacheMap::iterator i = mdns_cache_.begin();
+       i != mdns_cache_.end(); ) {
+    base::Time expiration = GetEffectiveExpiration(i->second);
+    if (now >= expiration) {
+      record_removed_callback.Run(i->second);
+      delete i->second;
+      mdns_cache_.erase(i++);
+    } else {
+      if (next_expiration == base::Time() ||  expiration < next_expiration) {
+        next_expiration = expiration;
+      }
+      ++i;
+    }
+  }
+
+  next_expiration_ = next_expiration;
+}
+
+void MDnsCache::FindDnsRecords(unsigned type,
+                               const std::string& name,
+                               std::vector<const RecordParsed*>* results,
+                               base::Time now) {
+  DCHECK(results);
+  results->clear();
+
+  MDnsCacheMap::iterator i =
+      mdns_cache_.lower_bound(DnsRecordCacheKey(type, name, ""));
+  for (; i != mdns_cache_.end(); ++i) {
+    if (i->first.type() != type ||
+        (!name.empty() && i->first.name() != name)) {
+      break;
+    }
+
+    const RecordParsed* record = i->second;
+
+    // Records are deleted only upon request to make this op idempotent

[szym, 2013/05/20 19:35:15]

The op would still be idempotent (same result) if you did delete expired
results, but I think it's reasonable to only remove them in CleanupRecords.

Anyway, please mark FindDnsRecords const.

[Noam Samuel, 2013/05/20 21:07:02]

Fixed comment. 

On 2013/05/20 19:35:15, szym wrote:

+    if (now >= GetEffectiveExpiration(record)) continue;
+
+    results->push_back(record);
+  }
+}
+
+std::string MDnsCache::GetOptionalFieldForRecord(const RecordParsed* record) {

[szym, 2013/05/20 19:35:15]

Mark const.

[Noam Samuel, 2013/05/20 21:07:02]

Done.

+  switch (record->type()) {
+    case PtrRecordRdata::kType: {
+      const PtrRecordRdata* rdata = record->rdata<PtrRecordRdata>();
+      return rdata->ptrdomain();
+    }
+    default:  // Most records are considered unique for our purposes
+      return "";
+  }
+}
+
+base::Time MDnsCache::GetEffectiveExpiration(const RecordParsed* record) {

[szym, 2013/05/20 19:35:15]

Mark const.

[Noam Samuel, 2013/05/20 21:07:02]

Done.

+  base::TimeDelta ttl;
+
+  if (record->ttl()) {
+    ttl = base::TimeDelta::FromSeconds(record->ttl());
+  } else {
+    ttl = base::TimeDelta::FromSeconds(kZeroTTLSeconds);
+  }
+
+  return record->time_created() + ttl;
+}
+
+}  // namespace net