intranet_redirect_detector.cc revision 868fa2fe829687343ffae624259930155e16dbd8
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 "chrome/browser/intranet_redirect_detector.h" 6 7#include "base/bind.h" 8#include "base/command_line.h" 9#include "base/prefs/pref_registry_simple.h" 10#include "base/prefs/pref_service.h" 11#include "base/rand_util.h" 12#include "base/stl_util.h" 13#include "base/strings/utf_string_conversions.h" 14#include "chrome/browser/browser_process.h" 15#include "chrome/common/chrome_switches.h" 16#include "chrome/common/pref_names.h" 17#include "net/base/load_flags.h" 18#include "net/base/net_errors.h" 19#include "net/base/registry_controlled_domains/registry_controlled_domain.h" 20#include "net/url_request/url_fetcher.h" 21#include "net/url_request/url_request_context_getter.h" 22#include "net/url_request/url_request_status.h" 23 24const size_t IntranetRedirectDetector::kNumCharsInHostnames = 10; 25 26IntranetRedirectDetector::IntranetRedirectDetector() 27 : redirect_origin_(g_browser_process->local_state()->GetString( 28 prefs::kLastKnownIntranetRedirectOrigin)), 29 weak_factory_(this), 30 in_sleep_(true) { 31 // Because this function can be called during startup, when kicking off a URL 32 // fetch can eat up 20 ms of time, we delay seven seconds, which is hopefully 33 // long enough to be after startup, but still get results back quickly. 34 // Ideally, instead of this timer, we'd do something like "check if the 35 // browser is starting up, and if so, come back later", but there is currently 36 // no function to do this. 37 static const int kStartFetchDelaySeconds = 7; 38 base::MessageLoop::current()->PostDelayedTask(FROM_HERE, 39 base::Bind(&IntranetRedirectDetector::FinishSleep, 40 weak_factory_.GetWeakPtr()), 41 base::TimeDelta::FromSeconds(kStartFetchDelaySeconds)); 42 43 net::NetworkChangeNotifier::AddIPAddressObserver(this); 44} 45 46IntranetRedirectDetector::~IntranetRedirectDetector() { 47 net::NetworkChangeNotifier::RemoveIPAddressObserver(this); 48 STLDeleteElements(&fetchers_); 49} 50 51// static 52GURL IntranetRedirectDetector::RedirectOrigin() { 53 const IntranetRedirectDetector* const detector = 54 g_browser_process->intranet_redirect_detector(); 55 return detector ? detector->redirect_origin_ : GURL(); 56} 57 58// static 59void IntranetRedirectDetector::RegisterPrefs(PrefRegistrySimple* registry) { 60 registry->RegisterStringPref(prefs::kLastKnownIntranetRedirectOrigin, 61 std::string()); 62} 63 64void IntranetRedirectDetector::FinishSleep() { 65 in_sleep_ = false; 66 67 // If another fetch operation is still running, cancel it. 68 STLDeleteElements(&fetchers_); 69 resulting_origins_.clear(); 70 71 // The detector is not needed in Chrome Frame since we have no omnibox there. 72 const CommandLine* cmd_line = CommandLine::ForCurrentProcess(); 73 if (cmd_line->HasSwitch(switches::kDisableBackgroundNetworking) || 74 cmd_line->HasSwitch(switches::kChromeFrame)) 75 return; 76 77 DCHECK(fetchers_.empty() && resulting_origins_.empty()); 78 79 // Start three fetchers on random hostnames. 80 for (size_t i = 0; i < 3; ++i) { 81 std::string url_string("http://"); 82 for (size_t j = 0; j < kNumCharsInHostnames; ++j) 83 url_string += ('a' + base::RandInt(0, 'z' - 'a')); 84 GURL random_url(url_string + '/'); 85 net::URLFetcher* fetcher = net::URLFetcher::Create( 86 random_url, net::URLFetcher::HEAD, this); 87 // We don't want these fetches to affect existing state in the profile. 88 fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE | 89 net::LOAD_DO_NOT_SAVE_COOKIES | 90 net::LOAD_DO_NOT_SEND_COOKIES); 91 fetcher->SetRequestContext(g_browser_process->system_request_context()); 92 fetcher->Start(); 93 fetchers_.insert(fetcher); 94 } 95} 96 97void IntranetRedirectDetector::OnURLFetchComplete( 98 const net::URLFetcher* source) { 99 // Delete the fetcher on this function's exit. 100 Fetchers::iterator fetcher = fetchers_.find( 101 const_cast<net::URLFetcher*>(source)); 102 DCHECK(fetcher != fetchers_.end()); 103 scoped_ptr<net::URLFetcher> clean_up_fetcher(*fetcher); 104 fetchers_.erase(fetcher); 105 106 // If any two fetches result in the same domain/host, we set the redirect 107 // origin to that; otherwise we set it to nothing. 108 if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) { 109 if ((resulting_origins_.empty()) || 110 ((resulting_origins_.size() == 1) && 111 resulting_origins_.front().is_valid())) { 112 resulting_origins_.push_back(GURL()); 113 return; 114 } 115 redirect_origin_ = GURL(); 116 } else { 117 DCHECK(source->GetURL().is_valid()); 118 GURL origin(source->GetURL().GetOrigin()); 119 if (resulting_origins_.empty()) { 120 resulting_origins_.push_back(origin); 121 return; 122 } 123 if (net::registry_controlled_domains::SameDomainOrHost( 124 resulting_origins_.front(), 125 origin, 126 net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)) { 127 redirect_origin_ = origin; 128 if (!fetchers_.empty()) { 129 // Cancel remaining fetch, we don't need it. 130 DCHECK(fetchers_.size() == 1); 131 delete (*fetchers_.begin()); 132 fetchers_.clear(); 133 } 134 } 135 if (resulting_origins_.size() == 1) { 136 resulting_origins_.push_back(origin); 137 return; 138 } 139 DCHECK(resulting_origins_.size() == 2); 140 const bool same_domain_or_host = 141 net::registry_controlled_domains::SameDomainOrHost( 142 resulting_origins_.back(), 143 origin, 144 net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES); 145 redirect_origin_ = same_domain_or_host ? origin : GURL(); 146 } 147 148 g_browser_process->local_state()->SetString( 149 prefs::kLastKnownIntranetRedirectOrigin, redirect_origin_.is_valid() ? 150 redirect_origin_.spec() : std::string()); 151} 152 153void IntranetRedirectDetector::OnIPAddressChanged() { 154 // If a request is already scheduled, do not scheduled yet another one. 155 if (in_sleep_) 156 return; 157 158 // Since presumably many programs open connections after network changes, 159 // delay this a little bit. 160 in_sleep_ = true; 161 static const int kNetworkSwitchDelayMS = 1000; 162 base::MessageLoop::current()->PostDelayedTask(FROM_HERE, 163 base::Bind(&IntranetRedirectDetector::FinishSleep, 164 weak_factory_.GetWeakPtr()), 165 base::TimeDelta::FromMilliseconds(kNetworkSwitchDelayMS)); 166} 167 168IntranetRedirectHostResolverProc::IntranetRedirectHostResolverProc( 169 net::HostResolverProc* previous) 170 : net::HostResolverProc(previous) { 171} 172 173int IntranetRedirectHostResolverProc::Resolve( 174 const std::string& host, 175 net::AddressFamily address_family, 176 net::HostResolverFlags host_resolver_flags, 177 net::AddressList* addrlist, 178 int* os_error) { 179 // We'd love to just ask the IntranetRedirectDetector, but we may not be on 180 // the same thread. So just use the heuristic that any all-lowercase a-z 181 // hostname with the right number of characters is likely from the detector 182 // (and thus should be blocked). 183 return ((host.length() == IntranetRedirectDetector::kNumCharsInHostnames) && 184 (host.find_first_not_of("abcdefghijklmnopqrstuvwxyz") == 185 std::string::npos)) ? 186 net::ERR_NAME_NOT_RESOLVED : 187 ResolveUsingPrevious(host, address_family, host_resolver_flags, addrlist, 188 os_error); 189} 190