net/dns/mock_host_resolver.cc

   1 // Copyright (c) 2012 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/mock_host_resolver.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_split.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/threading/platform_thread.h"
  17 #include "net/base/ip_endpoint.h"
  18 #include "net/base/net_errors.h"
  19 #include "net/base/net_util.h"
  20 #include "net/base/test_completion_callback.h"
  21 #include "net/dns/host_cache.h"
  22
  23 #if defined(OS_WIN)
  24 #include "net/base/winsock_init.h"
  25 #endif
  26
  27 namespace net {
  28
  29 namespace {
  30
  31 // Cache size for the MockCachingHostResolver.
  32 const unsigned kMaxCacheEntries = 100;
  33 // TTL for the successful resolutions. Failures are not cached.
  34 const unsigned kCacheEntryTTLSeconds = 60;
  35
  36 }  // namespace
  37
  38 int ParseAddressList(const std::string& host_list,
  39                      const std::string& canonical_name,
  40                      AddressList* addrlist) {
  41   *addrlist = AddressList();
  42   std::vector<std::string> addresses;
  43   base::SplitString(host_list, ',', &addresses);
  44   addrlist->set_canonical_name(canonical_name);
  45   for (size_t index = 0; index < addresses.size(); ++index) {
  46     IPAddressNumber ip_number;
  47     if (!ParseIPLiteralToNumber(addresses[index], &ip_number)) {
  48       LOG(WARNING) << "Not a supported IP literal: " << addresses[index];
  49       return ERR_UNEXPECTED;
  50     }
  51     addrlist->push_back(IPEndPoint(ip_number, -1));
  52   }
  53   return OK;
  54 }
  55
  56 struct MockHostResolverBase::Request {
  57   Request(const RequestInfo& req_info,
  58           AddressList* addr,
  59           const CompletionCallback& cb)
  60       : info(req_info), addresses(addr), callback(cb) {}
  61   RequestInfo info;
  62   AddressList* addresses;
  63   CompletionCallback callback;
  64 };
  65
  66 MockHostResolverBase::~MockHostResolverBase() {
  67   STLDeleteValues(&requests_);
  68 }
  69
  70 int MockHostResolverBase::Resolve(const RequestInfo& info,
  71                                   RequestPriority priority,
  72                                   AddressList* addresses,
  73                                   const CompletionCallback& callback,
  74                                   RequestHandle* handle,
  75                                   const BoundNetLog& net_log) {
  76   DCHECK(CalledOnValidThread());
  77   last_request_priority_ = priority;
  78   num_resolve_++;
  79   size_t id = next_request_id_++;
  80   int rv = ResolveFromIPLiteralOrCache(info, addresses);
  81   if (rv != ERR_DNS_CACHE_MISS) {
  82     return rv;
  83   }
  84   if (synchronous_mode_) {
  85     return ResolveProc(id, info, addresses);
  86   }
  87   // Store the request for asynchronous resolution
  88   Request* req = new Request(info, addresses, callback);
  89   requests_[id] = req;
  90   if (handle)
  91     *handle = reinterpret_cast<RequestHandle>(id);
  92
  93   if (!ondemand_mode_) {
  94     base::MessageLoop::current()->PostTask(
  95         FROM_HERE,
  96         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
  97   }
  98
  99   return ERR_IO_PENDING;
 100 }
 101
 102 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
 103                                            AddressList* addresses,
 104                                            const BoundNetLog& net_log) {
 105   num_resolve_from_cache_++;
 106   DCHECK(CalledOnValidThread());
 107   next_request_id_++;
 108   int rv = ResolveFromIPLiteralOrCache(info, addresses);
 109   return rv;
 110 }
 111
 112 void MockHostResolverBase::CancelRequest(RequestHandle handle) {
 113   DCHECK(CalledOnValidThread());
 114   size_t id = reinterpret_cast<size_t>(handle);
 115   RequestMap::iterator it = requests_.find(id);
 116   if (it != requests_.end()) {
 117     scoped_ptr<Request> req(it->second);
 118     requests_.erase(it);
 119   } else {
 120     NOTREACHED() << "CancelRequest must NOT be called after request is "
 121         "complete or canceled.";
 122   }
 123 }
 124
 125 HostCache* MockHostResolverBase::GetHostCache() {
 126   return cache_.get();
 127 }
 128
 129 void MockHostResolverBase::ResolveAllPending() {
 130   DCHECK(CalledOnValidThread());
 131   DCHECK(ondemand_mode_);
 132   for (RequestMap::iterator i = requests_.begin(); i != requests_.end(); ++i) {
 133     base::MessageLoop::current()->PostTask(
 134         FROM_HERE,
 135         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
 136   }
 137 }
 138
 139 // start id from 1 to distinguish from NULL RequestHandle
 140 MockHostResolverBase::MockHostResolverBase(bool use_caching)
 141     : last_request_priority_(DEFAULT_PRIORITY),
 142       synchronous_mode_(false),
 143       ondemand_mode_(false),
 144       next_request_id_(1),
 145       num_resolve_(0),
 146       num_resolve_from_cache_(0) {
 147   rules_ = CreateCatchAllHostResolverProc();
 148
 149   if (use_caching) {
 150     cache_.reset(new HostCache(kMaxCacheEntries));
 151   }
 152 }
 153
 154 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
 155                                                       AddressList* addresses) {
 156   IPAddressNumber ip;
 157   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
 158     // This matches the behavior HostResolverImpl.
 159     if (info.address_family() != ADDRESS_FAMILY_UNSPECIFIED &&
 160         info.address_family() != GetAddressFamily(ip)) {
 161       return ERR_NAME_NOT_RESOLVED;
 162     }
 163
 164     *addresses = AddressList::CreateFromIPAddress(ip, info.port());
 165     if (info.host_resolver_flags() & HOST_RESOLVER_CANONNAME)
 166       addresses->SetDefaultCanonicalName();
 167     return OK;
 168   }
 169   int rv = ERR_DNS_CACHE_MISS;
 170   if (cache_.get() && info.allow_cached_response()) {
 171     HostCache::Key key(info.hostname(),
 172                        info.address_family(),
 173                        info.host_resolver_flags());
 174     const HostCache::Entry* entry = cache_->Lookup(key, base::TimeTicks::Now());
 175     if (entry) {
 176       rv = entry->error;
 177       if (rv == OK)
 178         *addresses = AddressList::CopyWithPort(entry->addrlist, info.port());
 179     }
 180   }
 181   return rv;
 182 }
 183
 184 int MockHostResolverBase::ResolveProc(size_t id,
 185                                       const RequestInfo& info,
 186                                       AddressList* addresses) {
 187   AddressList addr;
 188   int rv = rules_->Resolve(info.hostname(),
 189                            info.address_family(),
 190                            info.host_resolver_flags(),
 191                            &addr,
 192                            NULL);
 193   if (cache_.get()) {
 194     HostCache::Key key(info.hostname(),
 195                        info.address_family(),
 196                        info.host_resolver_flags());
 197     // Storing a failure with TTL 0 so that it overwrites previous value.
 198     base::TimeDelta ttl;
 199     if (rv == OK)
 200       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
 201     cache_->Set(key, HostCache::Entry(rv, addr), base::TimeTicks::Now(), ttl);
 202   }
 203   if (rv == OK)
 204     *addresses = AddressList::CopyWithPort(addr, info.port());
 205   return rv;
 206 }
 207
 208 void MockHostResolverBase::ResolveNow(size_t id) {
 209   RequestMap::iterator it = requests_.find(id);
 210   if (it == requests_.end())
 211     return;  // was canceled
 212
 213   scoped_ptr<Request> req(it->second);
 214   requests_.erase(it);
 215   int rv = ResolveProc(id, req->info, req->addresses);
 216   if (!req->callback.is_null())
 217     req->callback.Run(rv);
 218 }
 219
 220 //-----------------------------------------------------------------------------
 221
 222 struct RuleBasedHostResolverProc::Rule {
 223   enum ResolverType {
 224     kResolverTypeFail,
 225     kResolverTypeSystem,
 226     kResolverTypeIPLiteral,
 227   };
 228
 229   ResolverType resolver_type;
 230   std::string host_pattern;
 231   AddressFamily address_family;
 232   HostResolverFlags host_resolver_flags;
 233   std::string replacement;
 234   std::string canonical_name;
 235   int latency_ms;  // In milliseconds.
 236
 237   Rule(ResolverType resolver_type,
 238        const std::string& host_pattern,
 239        AddressFamily address_family,
 240        HostResolverFlags host_resolver_flags,
 241        const std::string& replacement,
 242        const std::string& canonical_name,
 243        int latency_ms)
 244       : resolver_type(resolver_type),
 245         host_pattern(host_pattern),
 246         address_family(address_family),
 247         host_resolver_flags(host_resolver_flags),
 248         replacement(replacement),
 249         canonical_name(canonical_name),
 250         latency_ms(latency_ms) {}
 251 };
 252
 253 RuleBasedHostResolverProc::RuleBasedHostResolverProc(HostResolverProc* previous)
 254     : HostResolverProc(previous) {
 255 }
 256
 257 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
 258                                         const std::string& replacement) {
 259   AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
 260                           replacement);
 261 }
 262
 263 void RuleBasedHostResolverProc::AddRuleForAddressFamily(
 264     const std::string& host_pattern,
 265     AddressFamily address_family,
 266     const std::string& replacement) {
 267   DCHECK(!replacement.empty());
 268   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
 269       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
 270   Rule rule(Rule::kResolverTypeSystem,
 271             host_pattern,
 272             address_family,
 273             flags,
 274             replacement,
 275             std::string(),
 276             0);
 277   rules_.push_back(rule);
 278 }
 279
 280 void RuleBasedHostResolverProc::AddIPLiteralRule(
 281     const std::string& host_pattern,
 282     const std::string& ip_literal,
 283     const std::string& canonical_name) {
 284   // Literals are always resolved to themselves by HostResolverImpl,
 285   // consequently we do not support remapping them.
 286   IPAddressNumber ip_number;
 287   DCHECK(!ParseIPLiteralToNumber(host_pattern, &ip_number));
 288   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
 289       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
 290   if (!canonical_name.empty())
 291     flags |= HOST_RESOLVER_CANONNAME;
 292   Rule rule(Rule::kResolverTypeIPLiteral, host_pattern,
 293             ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal, canonical_name,
 294             0);
 295   rules_.push_back(rule);
 296 }
 297
 298 void RuleBasedHostResolverProc::AddRuleWithLatency(
 299     const std::string& host_pattern,
 300     const std::string& replacement,
 301     int latency_ms) {
 302   DCHECK(!replacement.empty());
 303   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
 304       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
 305   Rule rule(Rule::kResolverTypeSystem,
 306             host_pattern,
 307             ADDRESS_FAMILY_UNSPECIFIED,
 308             flags,
 309             replacement,
 310             std::string(),
 311             latency_ms);
 312   rules_.push_back(rule);
 313 }
 314
 315 void RuleBasedHostResolverProc::AllowDirectLookup(
 316     const std::string& host_pattern) {
 317   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
 318       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
 319   Rule rule(Rule::kResolverTypeSystem,
 320             host_pattern,
 321             ADDRESS_FAMILY_UNSPECIFIED,
 322             flags,
 323             std::string(),
 324             std::string(),
 325             0);
 326   rules_.push_back(rule);
 327 }
 328
 329 void RuleBasedHostResolverProc::AddSimulatedFailure(
 330     const std::string& host_pattern) {
 331   HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY |
 332       HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
 333   Rule rule(Rule::kResolverTypeFail,
 334             host_pattern,
 335             ADDRESS_FAMILY_UNSPECIFIED,
 336             flags,
 337             std::string(),
 338             std::string(),
 339             0);
 340   rules_.push_back(rule);
 341 }
 342
 343 void RuleBasedHostResolverProc::ClearRules() {
 344   rules_.clear();
 345 }
 346
 347 int RuleBasedHostResolverProc::Resolve(const std::string& host,
 348                                        AddressFamily address_family,
 349                                        HostResolverFlags host_resolver_flags,
 350                                        AddressList* addrlist,
 351                                        int* os_error) {
 352   RuleList::iterator r;
 353   for (r = rules_.begin(); r != rules_.end(); ++r) {
 354     bool matches_address_family =
 355         r->address_family == ADDRESS_FAMILY_UNSPECIFIED ||
 356         r->address_family == address_family;
 357     // Ignore HOST_RESOLVER_SYSTEM_ONLY, since it should have no impact on
 358     // whether a rule matches.
 359     HostResolverFlags flags = host_resolver_flags & ~HOST_RESOLVER_SYSTEM_ONLY;
 360     // Flags match if all of the bitflags in host_resolver_flags are enabled
 361     // in the rule's host_resolver_flags. However, the rule may have additional
 362     // flags specified, in which case the flags should still be considered a
 363     // match.
 364     bool matches_flags = (r->host_resolver_flags & flags) == flags;
 365     if (matches_flags && matches_address_family &&
 366         MatchPattern(host, r->host_pattern)) {
 367       if (r->latency_ms != 0) {
 368         base::PlatformThread::Sleep(
 369             base::TimeDelta::FromMilliseconds(r->latency_ms));
 370       }
 371
 372       // Remap to a new host.
 373       const std::string& effective_host =
 374           r->replacement.empty() ? host : r->replacement;
 375
 376       // Apply the resolving function to the remapped hostname.
 377       switch (r->resolver_type) {
 378         case Rule::kResolverTypeFail:
 379           return ERR_NAME_NOT_RESOLVED;
 380         case Rule::kResolverTypeSystem:
 381 #if defined(OS_WIN)
 382           net::EnsureWinsockInit();
 383 #endif
 384           return SystemHostResolverCall(effective_host,
 385                                         address_family,
 386                                         host_resolver_flags,
 387                                         addrlist, os_error);
 388         case Rule::kResolverTypeIPLiteral:
 389           return ParseAddressList(effective_host,
 390                                   r->canonical_name,
 391                                   addrlist);
 392         default:
 393           NOTREACHED();
 394           return ERR_UNEXPECTED;
 395       }
 396     }
 397   }
 398   return ResolveUsingPrevious(host, address_family,
 399                               host_resolver_flags, addrlist, os_error);
 400 }
 401
 402 RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 403 }
 404
 405 RuleBasedHostResolverProc* CreateCatchAllHostResolverProc() {
 406   RuleBasedHostResolverProc* catchall = new RuleBasedHostResolverProc(NULL);
 407   catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost");
 408
 409   // Next add a rules-based layer the use controls.
 410   return new RuleBasedHostResolverProc(catchall);
 411 }
 412
 413 //-----------------------------------------------------------------------------
 414
 415 int HangingHostResolver::Resolve(const RequestInfo& info,
 416                                  RequestPriority priority,
 417                                  AddressList* addresses,
 418                                  const CompletionCallback& callback,
 419                                  RequestHandle* out_req,
 420                                  const BoundNetLog& net_log) {
 421   return ERR_IO_PENDING;
 422 }
 423
 424 int HangingHostResolver::ResolveFromCache(const RequestInfo& info,
 425                                           AddressList* addresses,
 426                                           const BoundNetLog& net_log) {
 427   return ERR_DNS_CACHE_MISS;
 428 }
 429
 430 //-----------------------------------------------------------------------------
 431
 432 ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc() {}
 433
 434 ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc(
 435     HostResolverProc* proc) {
 436   Init(proc);
 437 }
 438
 439 ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() {
 440   HostResolverProc* old_proc =
 441       HostResolverProc::SetDefault(previous_proc_.get());
 442   // The lifetimes of multiple instances must be nested.
 443   CHECK_EQ(old_proc, current_proc_);
 444 }
 445
 446 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
 447   current_proc_ = proc;
 448   previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
 449   current_proc_->SetLastProc(previous_proc_.get());
 450 }
 451
 452 }  // namespace net