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