chrome/browser/local_discovery/privet_url_fetcher.cc

   1 // Copyright 2013 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/local_discovery/privet_url_fetcher.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/json/json_reader.h"
  11 #include "base/memory/singleton.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/rand_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/local_discovery/privet_constants.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "net/base/load_flags.h"
  19 #include "net/http/http_status_code.h"
  20 #include "net/url_request/url_request_status.h"
  21
  22 namespace local_discovery {
  23
  24 namespace {
  25
  26 typedef std::map<std::string, std::string> TokenMap;
  27
  28 struct TokenMapHolder {
  29  public:
  30   static TokenMapHolder* GetInstance() {
  31     return Singleton<TokenMapHolder>::get();
  32   }
  33
  34   TokenMap map;
  35 };
  36
  37 const char kXPrivetTokenHeaderPrefix[] = "X-Privet-Token: ";
  38 const char kPrivetV3AuthTokenHeaderPrefix[] = "Authorization: ";
  39 const char kRangeHeaderFormat[] = "Range: bytes=%d-%d";
  40 const char kXPrivetEmptyToken[] = "\"\"";
  41 const char kPrivetAuthTokenUnknown[] = "Unknown";
  42 const int kPrivetMaxRetries = 20;
  43 const int kPrivetTimeoutOnError = 5;
  44 const int kHTTPErrorCodeInvalidXPrivetToken = 418;
  45
  46 std::string MakeRangeHeader(int start, int end) {
  47   DCHECK_GE(start, 0);
  48   DCHECK_GT(end, 0);
  49   DCHECK_GT(end, start);
  50   return base::StringPrintf(kRangeHeaderFormat, start, end);
  51 }
  52
  53 }  // namespace
  54
  55 void PrivetURLFetcher::Delegate::OnNeedPrivetToken(
  56     PrivetURLFetcher* fetcher,
  57     const TokenCallback& callback) {
  58   OnError(fetcher, TOKEN_ERROR);
  59 }
  60
  61 std::string PrivetURLFetcher::Delegate::GetAuthToken() {
  62   return kPrivetAuthTokenUnknown;
  63 }
  64
  65 bool PrivetURLFetcher::Delegate::OnRawData(PrivetURLFetcher* fetcher,
  66                                            bool response_is_file,
  67                                            const std::string& data_string,
  68                                            const base::FilePath& data_file) {
  69   return false;
  70 }
  71
  72 PrivetURLFetcher::PrivetURLFetcher(
  73     const GURL& url,
  74     net::URLFetcher::RequestType request_type,
  75     net::URLRequestContextGetter* request_context,
  76     PrivetURLFetcher::Delegate* delegate)
  77     : url_(url),
  78       request_type_(request_type),
  79       request_context_(request_context),
  80       delegate_(delegate),
  81       do_not_retry_on_transient_error_(false),
  82       send_empty_privet_token_(false),
  83       has_byte_range_(false),
  84       make_response_file_(false),
  85       v3_mode_(false),
  86       byte_range_start_(0),
  87       byte_range_end_(0),
  88       tries_(0),
  89       weak_factory_(this) {
  90 }
  91
  92 PrivetURLFetcher::~PrivetURLFetcher() {
  93 }
  94
  95 // static
  96 void PrivetURLFetcher::SetTokenForHost(const std::string& host,
  97                                        const std::string& token) {
  98   TokenMapHolder::GetInstance()->map[host] = token;
  99 }
 100
 101 // static
 102 void PrivetURLFetcher::ResetTokenMapForTests() {
 103   TokenMapHolder::GetInstance()->map.clear();
 104 }
 105
 106 void PrivetURLFetcher::DoNotRetryOnTransientError() {
 107   DCHECK(tries_ == 0);
 108   do_not_retry_on_transient_error_ = true;
 109 }
 110
 111 void PrivetURLFetcher::SendEmptyPrivetToken() {
 112   DCHECK(tries_ == 0);
 113   send_empty_privet_token_ = true;
 114 }
 115
 116 std::string PrivetURLFetcher::GetPrivetAccessToken() {
 117   if (send_empty_privet_token_) {
 118     return std::string();
 119   }
 120
 121   TokenMapHolder* token_map_holder = TokenMapHolder::GetInstance();
 122   TokenMap::iterator found = token_map_holder->map.find(GetHostString());
 123   return found != token_map_holder->map.end() ? found->second : std::string();
 124 }
 125
 126 std::string PrivetURLFetcher::GetHostString() {
 127   return url_.GetOrigin().spec();
 128 }
 129
 130 void PrivetURLFetcher::SaveResponseToFile() {
 131   DCHECK(tries_ == 0);
 132   make_response_file_ = true;
 133 }
 134
 135 void PrivetURLFetcher::V3Mode() {
 136   v3_mode_ = true;
 137 }
 138
 139 void PrivetURLFetcher::SetByteRange(int start, int end) {
 140   DCHECK(tries_ == 0);
 141   byte_range_start_ = start;
 142   byte_range_end_ = end;
 143   has_byte_range_ = true;
 144 }
 145
 146 void PrivetURLFetcher::Try() {
 147   tries_++;
 148   if (tries_ < kPrivetMaxRetries) {
 149
 150
 151     url_fetcher_.reset(net::URLFetcher::Create(url_, request_type_, this));
 152     // Privet requests are relevant to hosts on local network only.
 153     url_fetcher_->SetLoadFlags(url_fetcher_->GetLoadFlags() |
 154                                net::LOAD_BYPASS_PROXY |
 155                                net::LOAD_DISABLE_CACHE);
 156     url_fetcher_->SetRequestContext(request_context_.get());
 157
 158     if (v3_mode_) {
 159       url_fetcher_->AddExtraRequestHeader(
 160           std::string(kPrivetV3AuthTokenHeaderPrefix) +
 161           delegate_->GetAuthToken());
 162     } else {
 163       std::string token = GetPrivetAccessToken();
 164
 165       if (token.empty())
 166         token = kXPrivetEmptyToken;
 167
 168       url_fetcher_->AddExtraRequestHeader(
 169           std::string(kXPrivetTokenHeaderPrefix) + token);
 170     }
 171
 172     if (has_byte_range_) {
 173       url_fetcher_->AddExtraRequestHeader(
 174           MakeRangeHeader(byte_range_start_, byte_range_end_));
 175     }
 176
 177     if (make_response_file_) {
 178       url_fetcher_->SaveResponseToTemporaryFile(
 179           content::BrowserThread::GetMessageLoopProxyForThread(
 180               content::BrowserThread::FILE));
 181     }
 182
 183     // URLFetcher requires us to set upload data for POST requests.
 184     if (request_type_ == net::URLFetcher::POST) {
 185       if (!upload_file_path_.empty()) {
 186         url_fetcher_->SetUploadFilePath(
 187             upload_content_type_,
 188             upload_file_path_,
 189             0 /*offset*/,
 190             kuint64max /*length*/,
 191             content::BrowserThread::GetMessageLoopProxyForThread(
 192                 content::BrowserThread::FILE));
 193       } else {
 194         url_fetcher_->SetUploadData(upload_content_type_, upload_data_);
 195       }
 196     }
 197
 198     url_fetcher_->Start();
 199   } else {
 200     delegate_->OnError(this, RETRY_ERROR);
 201   }
 202 }
 203
 204 void PrivetURLFetcher::Start() {
 205   DCHECK_EQ(tries_, 0);  // We haven't called |Start()| yet.
 206
 207   if (!send_empty_privet_token_ && !v3_mode_) {
 208     std::string privet_access_token;
 209     privet_access_token = GetPrivetAccessToken();
 210     if (privet_access_token.empty()) {
 211       RequestTokenRefresh();
 212       return;
 213     }
 214   }
 215
 216   Try();
 217 }
 218
 219 void PrivetURLFetcher::SetUploadData(const std::string& upload_content_type,
 220                                      const std::string& upload_data) {
 221   DCHECK(upload_file_path_.empty());
 222   upload_content_type_ = upload_content_type;
 223   upload_data_ = upload_data;
 224 }
 225
 226 void PrivetURLFetcher::SetUploadFilePath(
 227     const std::string& upload_content_type,
 228     const base::FilePath& upload_file_path) {
 229   DCHECK(upload_data_.empty());
 230   upload_content_type_ = upload_content_type;
 231   upload_file_path_ = upload_file_path;
 232 }
 233
 234 void PrivetURLFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
 235   if (source->GetResponseCode() == net::HTTP_SERVICE_UNAVAILABLE ||
 236       source->GetResponseCode() == net::URLFetcher::RESPONSE_CODE_INVALID) {
 237     ScheduleRetry(kPrivetTimeoutOnError);
 238     return;
 239   }
 240
 241   if (!OnURLFetchCompleteDoNotParseData(source)) {
 242     // Byte ranges should only be used when we're not parsing the data
 243     // as JSON.
 244     DCHECK(!has_byte_range_);
 245
 246     // We should only be saving raw data to a file.
 247     DCHECK(!make_response_file_);
 248
 249     OnURLFetchCompleteParseData(source);
 250   }
 251 }
 252
 253 // Note that this function returns "true" in error cases to indicate
 254 // that it has fully handled the responses.
 255 bool PrivetURLFetcher::OnURLFetchCompleteDoNotParseData(
 256     const net::URLFetcher* source) {
 257   if (source->GetResponseCode() == kHTTPErrorCodeInvalidXPrivetToken) {
 258     RequestTokenRefresh();
 259     return true;
 260   }
 261
 262   if (source->GetResponseCode() != net::HTTP_OK &&
 263       source->GetResponseCode() != net::HTTP_PARTIAL_CONTENT &&
 264       source->GetResponseCode() != net::HTTP_BAD_REQUEST) {
 265     delegate_->OnError(this, RESPONSE_CODE_ERROR);
 266     return true;
 267   }
 268
 269   if (make_response_file_) {
 270     base::FilePath response_file_path;
 271
 272     if (!source->GetResponseAsFilePath(true, &response_file_path)) {
 273       delegate_->OnError(this, URL_FETCH_ERROR);
 274       return true;
 275     }
 276
 277     return delegate_->OnRawData(this, true, std::string(), response_file_path);
 278   } else {
 279     std::string response_str;
 280
 281     if (!source->GetResponseAsString(&response_str)) {
 282       delegate_->OnError(this, URL_FETCH_ERROR);
 283       return true;
 284     }
 285
 286     return delegate_->OnRawData(this, false, response_str, base::FilePath());
 287   }
 288 }
 289
 290 void PrivetURLFetcher::OnURLFetchCompleteParseData(
 291     const net::URLFetcher* source) {
 292   // Response contains error description.
 293   bool is_error_response = false;
 294   if (v3_mode_ && source->GetResponseCode() == net::HTTP_BAD_REQUEST) {
 295     is_error_response = true;
 296   } else if (source->GetResponseCode() != net::HTTP_OK) {
 297     delegate_->OnError(this, RESPONSE_CODE_ERROR);
 298     return;
 299   }
 300
 301   std::string response_str;
 302   if (!source->GetResponseAsString(&response_str)) {
 303     delegate_->OnError(this, URL_FETCH_ERROR);
 304     return;
 305   }
 306
 307   base::JSONReader json_reader(base::JSON_ALLOW_TRAILING_COMMAS);
 308   scoped_ptr<base::Value> value;
 309
 310   value.reset(json_reader.ReadToValue(response_str));
 311
 312   if (!value) {
 313     delegate_->OnError(this, JSON_PARSE_ERROR);
 314     return;
 315   }
 316
 317   const base::DictionaryValue* dictionary_value = NULL;
 318
 319   if (!value->GetAsDictionary(&dictionary_value)) {
 320     delegate_->OnError(this, JSON_PARSE_ERROR);
 321     return;
 322   }
 323
 324   std::string error;
 325   if (!v3_mode_ && dictionary_value->GetString(kPrivetKeyError, &error)) {
 326     if (error == kPrivetErrorInvalidXPrivetToken) {
 327       RequestTokenRefresh();
 328       return;
 329     } else if (PrivetErrorTransient(error)) {
 330       if (!do_not_retry_on_transient_error_) {
 331         int timeout_seconds;
 332         if (!dictionary_value->GetInteger(kPrivetKeyTimeout,
 333                                           &timeout_seconds)) {
 334           timeout_seconds = kPrivetDefaultTimeout;
 335         }
 336
 337         ScheduleRetry(timeout_seconds);
 338         return;
 339       }
 340     }
 341     is_error_response = true;
 342   }
 343
 344   delegate_->OnParsedJson(this, *dictionary_value, is_error_response);
 345 }
 346
 347 void PrivetURLFetcher::ScheduleRetry(int timeout_seconds) {
 348   double random_scaling_factor =
 349       1 + base::RandDouble() * kPrivetMaximumTimeRandomAddition;
 350
 351   int timeout_seconds_randomized =
 352       static_cast<int>(timeout_seconds * random_scaling_factor);
 353
 354   timeout_seconds_randomized =
 355       std::max(timeout_seconds_randomized, kPrivetMinimumTimeout);
 356
 357   base::MessageLoop::current()->PostDelayedTask(
 358       FROM_HERE,
 359       base::Bind(&PrivetURLFetcher::Try, weak_factory_.GetWeakPtr()),
 360       base::TimeDelta::FromSeconds(timeout_seconds_randomized));
 361 }
 362
 363 void PrivetURLFetcher::RequestTokenRefresh() {
 364   delegate_->OnNeedPrivetToken(
 365       this,
 366       base::Bind(&PrivetURLFetcher::RefreshToken, weak_factory_.GetWeakPtr()));
 367 }
 368
 369 void PrivetURLFetcher::RefreshToken(const std::string& token) {
 370   if (token.empty()) {
 371     delegate_->OnError(this, TOKEN_ERROR);
 372   } else {
 373     SetTokenForHost(GetHostString(), token);
 374     Try();
 375   }
 376 }
 377
 378 bool PrivetURLFetcher::PrivetErrorTransient(const std::string& error) {
 379   return (error == kPrivetErrorDeviceBusy) ||
 380          (error == kPrivetV3ErrorDeviceBusy) ||
 381          (error == kPrivetErrorPendingUserAction) ||
 382          (error == kPrivetErrorPrinterBusy);
 383 }
 384
 385 }  // namespace local_discovery