net/proxy/proxy_script_fetcher_impl.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/proxy/proxy_script_fetcher_impl.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/profiler/scoped_tracker.h"
  11 #include "base/strings/string_util.h"
  12 #include "net/base/data_url.h"
  13 #include "net/base/io_buffer.h"
  14 #include "net/base/load_flags.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/base/net_string_util.h"
  17 #include "net/base/request_priority.h"
  18 #include "net/cert/cert_status_flags.h"
  19 #include "net/http/http_response_headers.h"
  20 #include "net/url_request/url_request_context.h"
  21
  22 // TODO(eroman):
  23 //   - Support auth-prompts (http://crbug.com/77366)
  24
  25 namespace net {
  26
  27 namespace {
  28
  29 // The maximum size (in bytes) allowed for a PAC script. Responses exceeding
  30 // this will fail with ERR_FILE_TOO_BIG.
  31 const int kDefaultMaxResponseBytes = 1048576;  // 1 megabyte
  32
  33 // The maximum duration (in milliseconds) allowed for fetching the PAC script.
  34 // Responses exceeding this will fail with ERR_TIMED_OUT.
  35 const int kDefaultMaxDurationMs = 300000;  // 5 minutes
  36
  37 // Returns true if |mime_type| is one of the known PAC mime type.
  38 bool IsPacMimeType(const std::string& mime_type) {
  39   static const char * const kSupportedPacMimeTypes[] = {
  40     "application/x-ns-proxy-autoconfig",
  41     "application/x-javascript-config",
  42   };
  43   for (size_t i = 0; i < arraysize(kSupportedPacMimeTypes); ++i) {
  44     if (LowerCaseEqualsASCII(mime_type, kSupportedPacMimeTypes[i]))
  45       return true;
  46   }
  47   return false;
  48 }
  49
  50 // Converts |bytes| (which is encoded by |charset|) to UTF16, saving the resul
  51 // to |*utf16|.
  52 // If |charset| is empty, then we don't know what it was and guess.
  53 void ConvertResponseToUTF16(const std::string& charset,
  54                             const std::string& bytes,
  55                             base::string16* utf16) {
  56   const char* codepage;
  57
  58   if (charset.empty()) {
  59     // Assume ISO-8859-1 if no charset was specified.
  60     codepage = kCharsetLatin1;
  61   } else {
  62     // Otherwise trust the charset that was provided.
  63     codepage = charset.c_str();
  64   }
  65
  66   // Be generous in the conversion -- if any characters lie outside of |charset|
  67   // (i.e. invalid), then substitute them with U+FFFD rather than failing.
  68   ConvertToUTF16WithSubstitutions(bytes, codepage, utf16);
  69 }
  70
  71 }  // namespace
  72
  73 ProxyScriptFetcherImpl::ProxyScriptFetcherImpl(
  74     URLRequestContext* url_request_context)
  75     : url_request_context_(url_request_context),
  76       buf_(new IOBuffer(kBufSize)),
  77       next_id_(0),
  78       cur_request_id_(0),
  79       result_code_(OK),
  80       result_text_(NULL),
  81       max_response_bytes_(kDefaultMaxResponseBytes),
  82       max_duration_(base::TimeDelta::FromMilliseconds(kDefaultMaxDurationMs)),
  83       weak_factory_(this) {
  84   DCHECK(url_request_context);
  85 }
  86
  87 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
  88   // The URLRequest's destructor will cancel the outstanding request, and
  89   // ensure that the delegate (this) is not called again.
  90 }
  91
  92 base::TimeDelta ProxyScriptFetcherImpl::SetTimeoutConstraint(
  93     base::TimeDelta timeout) {
  94   base::TimeDelta prev = max_duration_;
  95   max_duration_ = timeout;
  96   return prev;
  97 }
  98
  99 size_t ProxyScriptFetcherImpl::SetSizeConstraint(size_t size_bytes) {
 100   size_t prev = max_response_bytes_;
 101   max_response_bytes_ = size_bytes;
 102   return prev;
 103 }
 104
 105 void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
 106   DCHECK_EQ(request, cur_request_.get());
 107
 108   // Use |result_code_| as the request's error if we have already set it to
 109   // something specific.
 110   if (result_code_ == OK && !request->status().is_success())
 111     result_code_ = request->status().error();
 112
 113   FetchCompleted();
 114 }
 115
 116 int ProxyScriptFetcherImpl::Fetch(
 117     const GURL& url, base::string16* text, const CompletionCallback& callback) {
 118   // It is invalid to call Fetch() while a request is already in progress.
 119   DCHECK(!cur_request_.get());
 120   DCHECK(!callback.is_null());
 121   DCHECK(text);
 122
 123   // Handle base-64 encoded data-urls that contain custom PAC scripts.
 124   if (url.SchemeIs("data")) {
 125     std::string mime_type;
 126     std::string charset;
 127     std::string data;
 128     if (!DataURL::Parse(url, &mime_type, &charset, &data))
 129       return ERR_FAILED;
 130
 131     ConvertResponseToUTF16(charset, data, text);
 132     return OK;
 133   }
 134
 135   cur_request_ =
 136       url_request_context_->CreateRequest(url, DEFAULT_PRIORITY, this, NULL);
 137   cur_request_->set_method("GET");
 138
 139   // Make sure that the PAC script is downloaded using a direct connection,
 140   // to avoid circular dependencies (fetching is a part of proxy resolution).
 141   // Also disable the use of the disk cache. The cache is disabled so that if
 142   // the user switches networks we don't potentially use the cached response
 143   // from old network when we should in fact be re-fetching on the new network.
 144   // If the PAC script is hosted on an HTTPS server we bypass revocation
 145   // checking in order to avoid a circular dependency when attempting to fetch
 146   // the OCSP response or CRL. We could make the revocation check go direct but
 147   // the proxy might be the only way to the outside world.
 148   cur_request_->SetLoadFlags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE |
 149                              LOAD_DISABLE_CERT_REVOCATION_CHECKING);
 150
 151   // Save the caller's info for notification on completion.
 152   callback_ = callback;
 153   result_text_ = text;
 154
 155   bytes_read_so_far_.clear();
 156
 157   // Post a task to timeout this request if it takes too long.
 158   cur_request_id_ = ++next_id_;
 159   base::MessageLoop::current()->PostDelayedTask(
 160       FROM_HERE,
 161       base::Bind(&ProxyScriptFetcherImpl::OnTimeout,
 162                  weak_factory_.GetWeakPtr(),
 163                  cur_request_id_),
 164       max_duration_);
 165
 166   // Start the request.
 167   cur_request_->Start();
 168   return ERR_IO_PENDING;
 169 }
 170
 171 void ProxyScriptFetcherImpl::Cancel() {
 172   // ResetCurRequestState will free the URLRequest, which will cause
 173   // cancellation.
 174   ResetCurRequestState();
 175 }
 176
 177 URLRequestContext* ProxyScriptFetcherImpl::GetRequestContext() const {
 178   return url_request_context_;
 179 }
 180
 181 void ProxyScriptFetcherImpl::OnAuthRequired(URLRequest* request,
 182                                             AuthChallengeInfo* auth_info) {
 183   DCHECK_EQ(request, cur_request_.get());
 184   // TODO(eroman): http://crbug.com/77366
 185   LOG(WARNING) << "Auth required to fetch PAC script, aborting.";
 186   result_code_ = ERR_NOT_IMPLEMENTED;
 187   request->CancelAuth();
 188 }
 189
 190 void ProxyScriptFetcherImpl::OnSSLCertificateError(URLRequest* request,
 191                                                    const SSLInfo& ssl_info,
 192                                                    bool fatal) {
 193   DCHECK_EQ(request, cur_request_.get());
 194   // Revocation check failures are not fatal.
 195   if (IsCertStatusMinorError(ssl_info.cert_status)) {
 196     request->ContinueDespiteLastError();
 197     return;
 198   }
 199   LOG(WARNING) << "SSL certificate error when fetching PAC script, aborting.";
 200   // Certificate errors are in same space as net errors.
 201   result_code_ = MapCertStatusToNetError(ssl_info.cert_status);
 202   request->Cancel();
 203 }
 204
 205 void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request) {
 206   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 207   tracked_objects::ScopedTracker tracking_profile(
 208       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 209           "423948 ProxyScriptFetcherImpl::OnResponseStarted"));
 210
 211   DCHECK_EQ(request, cur_request_.get());
 212
 213   if (!request->status().is_success()) {
 214     OnResponseCompleted(request);
 215     return;
 216   }
 217
 218   // Require HTTP responses to have a success status code.
 219   if (request->url().SchemeIsHTTPOrHTTPS()) {
 220     // NOTE about status codes: We are like Firefox 3 in this respect.
 221     // {IE 7, Safari 3, Opera 9.5} do not care about the status code.
 222     if (request->GetResponseCode() != 200) {
 223       VLOG(1) << "Fetched PAC script had (bad) status line: "
 224               << request->response_headers()->GetStatusLine();
 225       result_code_ = ERR_PAC_STATUS_NOT_OK;
 226       request->Cancel();
 227       return;
 228     }
 229
 230     // NOTE about mime types: We do not enforce mime types on PAC files.
 231     // This is for compatibility with {IE 7, Firefox 3, Opera 9.5}. We will
 232     // however log mismatches to help with debugging.
 233     std::string mime_type;
 234     cur_request_->GetMimeType(&mime_type);
 235     if (!IsPacMimeType(mime_type)) {
 236       VLOG(1) << "Fetched PAC script does not have a proper mime type: "
 237               << mime_type;
 238     }
 239   }
 240
 241   ReadBody(request);
 242 }
 243
 244 void ProxyScriptFetcherImpl::OnReadCompleted(URLRequest* request,
 245                                              int num_bytes) {
 246   // TODO(vadimt): Remove ScopedTracker below once crbug.com/423948 is fixed.
 247   tracked_objects::ScopedTracker tracking_profile(
 248       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 249           "423948 ProxyScriptFetcherImpl::OnReadCompleted"));
 250
 251   DCHECK_EQ(request, cur_request_.get());
 252   if (ConsumeBytesRead(request, num_bytes)) {
 253     // Keep reading.
 254     ReadBody(request);
 255   }
 256 }
 257
 258 void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
 259   // Read as many bytes as are available synchronously.
 260   while (true) {
 261     int num_bytes;
 262     if (!request->Read(buf_.get(), kBufSize, &num_bytes)) {
 263       // Check whether the read failed synchronously.
 264       if (!request->status().is_io_pending())
 265         OnResponseCompleted(request);
 266       return;
 267     }
 268     if (!ConsumeBytesRead(request, num_bytes))
 269       return;
 270   }
 271 }
 272
 273 bool ProxyScriptFetcherImpl::ConsumeBytesRead(URLRequest* request,
 274                                               int num_bytes) {
 275   if (num_bytes <= 0) {
 276     // Error while reading, or EOF.
 277     OnResponseCompleted(request);
 278     return false;
 279   }
 280
 281   // Enforce maximum size bound.
 282   if (num_bytes + bytes_read_so_far_.size() >
 283       static_cast<size_t>(max_response_bytes_)) {
 284     result_code_ = ERR_FILE_TOO_BIG;
 285     request->Cancel();
 286     return false;
 287   }
 288
 289   bytes_read_so_far_.append(buf_->data(), num_bytes);
 290   return true;
 291 }
 292
 293 void ProxyScriptFetcherImpl::FetchCompleted() {
 294   if (result_code_ == OK) {
 295     // The caller expects the response to be encoded as UTF16.
 296     std::string charset;
 297     cur_request_->GetCharset(&charset);
 298     ConvertResponseToUTF16(charset, bytes_read_so_far_, result_text_);
 299   } else {
 300     // On error, the caller expects empty string for bytes.
 301     result_text_->clear();
 302   }
 303
 304   int result_code = result_code_;
 305   CompletionCallback callback = callback_;
 306
 307   ResetCurRequestState();
 308
 309   callback.Run(result_code);
 310 }
 311
 312 void ProxyScriptFetcherImpl::ResetCurRequestState() {
 313   cur_request_.reset();
 314   cur_request_id_ = 0;
 315   callback_.Reset();
 316   result_code_ = OK;
 317   result_text_ = NULL;
 318 }
 319
 320 void ProxyScriptFetcherImpl::OnTimeout(int id) {
 321   // Timeout tasks may outlive the URLRequest they reference. Make sure it
 322   // is still applicable.
 323   if (cur_request_id_ != id)
 324     return;
 325
 326   DCHECK(cur_request_.get());
 327   result_code_ = ERR_TIMED_OUT;
 328   cur_request_->Cancel();
 329 }
 330
 331 }  // namespace net