| OLD | NEW |
|---|
| (Empty) |
| 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, 0)); | |
| 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_.get()); | |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master