components/captive_portal/captive_portal_detector.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 "components/captive_portal/captive_portal_detector.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "net/base/load_flags.h"
  10 #include "net/http/http_response_headers.h"
  11 #include "net/http/http_util.h"
  12 #include "net/url_request/url_request_status.h"
  13
  14 namespace captive_portal {
  15
  16 const char CaptivePortalDetector::kDefaultURL[] =
  17     "http://www.gstatic.com/generate_204";
  18
  19 CaptivePortalDetector::CaptivePortalDetector(
  20     const scoped_refptr<net::URLRequestContextGetter>& request_context)
  21     : request_context_(request_context) {
  22 }
  23
  24 CaptivePortalDetector::~CaptivePortalDetector() {
  25 }
  26
  27 void CaptivePortalDetector::DetectCaptivePortal(
  28     const GURL& url,
  29     const DetectionCallback& detection_callback) {
  30   DCHECK(CalledOnValidThread());
  31   DCHECK(!FetchingURL());
  32   DCHECK(detection_callback_.is_null());
  33
  34   detection_callback_ = detection_callback;
  35
  36   // The first 0 means this can use a TestURLFetcherFactory in unit tests.
  37   url_fetcher_ = net::URLFetcher::Create(0, url, net::URLFetcher::GET, this);
  38   url_fetcher_->SetAutomaticallyRetryOn5xx(false);
  39   url_fetcher_->SetRequestContext(request_context_.get());
  40
  41   // Can't safely use net::LOAD_DISABLE_CERT_REVOCATION_CHECKING here,
  42   // since then the connection may be reused without checking the cert.
  43   url_fetcher_->SetLoadFlags(
  44       net::LOAD_BYPASS_CACHE |
  45       net::LOAD_DO_NOT_SAVE_COOKIES |
  46       net::LOAD_DO_NOT_SEND_COOKIES |
  47       net::LOAD_DO_NOT_SEND_AUTH_DATA);
  48   url_fetcher_->Start();
  49 }
  50
  51 void CaptivePortalDetector::Cancel() {
  52   url_fetcher_.reset();
  53   detection_callback_.Reset();
  54 }
  55
  56 void CaptivePortalDetector::OnURLFetchComplete(const net::URLFetcher* source) {
  57   DCHECK(CalledOnValidThread());
  58   DCHECK(FetchingURL());
  59   DCHECK_EQ(url_fetcher_.get(), source);
  60   DCHECK(!detection_callback_.is_null());
  61
  62   Results results;
  63   GetCaptivePortalResultFromResponse(url_fetcher_.get(), &results);
  64   DetectionCallback callback = detection_callback_;
  65   url_fetcher_.reset();
  66   detection_callback_.Reset();
  67   callback.Run(results);
  68 }
  69
  70 // Takes a net::URLFetcher that has finished trying to retrieve the test
  71 // URL, and returns a CaptivePortalService::Result based on its result.
  72 void CaptivePortalDetector::GetCaptivePortalResultFromResponse(
  73     const net::URLFetcher* url_fetcher,
  74     Results* results) const {
  75   DCHECK(results);
  76   DCHECK(!url_fetcher->GetStatus().is_io_pending());
  77
  78   results->result = captive_portal::RESULT_NO_RESPONSE;
  79   results->response_code = url_fetcher->GetResponseCode();
  80   results->retry_after_delta = base::TimeDelta();
  81   results->landing_url = url_fetcher->GetURL();
  82
  83   // If there's a network error of some sort when fetching a file via HTTP,
  84   // there may be a networking problem, rather than a captive portal.
  85   // TODO(mmenke):  Consider special handling for redirects that end up at
  86   //                errors, especially SSL certificate errors.
  87   if (url_fetcher->GetStatus().status() != net::URLRequestStatus::SUCCESS)
  88     return;
  89
  90   // In the case of 503 errors, look for the Retry-After header.
  91   if (results->response_code == 503) {
  92     net::HttpResponseHeaders* headers = url_fetcher->GetResponseHeaders();
  93     std::string retry_after_string;
  94
  95     // If there's no Retry-After header, nothing else to do.
  96     if (!headers->EnumerateHeader(NULL, "Retry-After", &retry_after_string))
  97       return;
  98
  99     base::TimeDelta retry_after_delta;
 100     if (net::HttpUtil::ParseRetryAfterHeader(retry_after_string,
 101                                              GetCurrentTime(),
 102                                              &retry_after_delta)) {
 103       results->retry_after_delta = retry_after_delta;
 104     }
 105
 106     return;
 107   }
 108
 109   // A 511 response (Network Authentication Required) means that the user needs
 110   // to login to whatever server issued the response.
 111   // See:  http://tools.ietf.org/html/rfc6585
 112   if (results->response_code == 511) {
 113     results->result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
 114     return;
 115   }
 116
 117   // Other non-2xx/3xx HTTP responses may indicate server errors.
 118   if (results->response_code >= 400 || results->response_code < 200)
 119     return;
 120
 121   // A 204 response code indicates there's no captive portal.
 122   if (results->response_code == 204) {
 123     results->result = captive_portal::RESULT_INTERNET_CONNECTED;
 124     return;
 125   }
 126
 127   // Otherwise, assume it's a captive portal.
 128   results->result = captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL;
 129 }
 130
 131 base::Time CaptivePortalDetector::GetCurrentTime() const {
 132   if (time_for_testing_.is_null())
 133     return base::Time::Now();
 134   else
 135     return time_for_testing_;
 136 }
 137
 138 bool CaptivePortalDetector::FetchingURL() const {
 139   return url_fetcher_.get() != NULL;
 140 }
 141
 142 }  // namespace captive_portal