net/url_request/url_request_ftp_job.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/url_request/url_request_ftp_job.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "net/base/auth.h"
  11 #include "net/base/host_port_pair.h"
  12 #include "net/base/load_flags.h"
  13 #include "net/base/net_errors.h"
  14 #include "net/base/net_util.h"
  15 #include "net/ftp/ftp_auth_cache.h"
  16 #include "net/ftp/ftp_response_info.h"
  17 #include "net/ftp/ftp_transaction_factory.h"
  18 #include "net/http/http_response_headers.h"
  19 #include "net/http/http_transaction_factory.h"
  20 #include "net/url_request/url_request.h"
  21 #include "net/url_request/url_request_context.h"
  22 #include "net/url_request/url_request_error_job.h"
  23
  24 namespace net {
  25
  26 URLRequestFtpJob::URLRequestFtpJob(
  27     URLRequest* request,
  28     NetworkDelegate* network_delegate,
  29     FtpTransactionFactory* ftp_transaction_factory,
  30     FtpAuthCache* ftp_auth_cache)
  31     : URLRequestJob(request, network_delegate),
  32       priority_(DEFAULT_PRIORITY),
  33       proxy_service_(request_->context()->proxy_service()),
  34       pac_request_(NULL),
  35       http_response_info_(NULL),
  36       read_in_progress_(false),
  37       ftp_transaction_factory_(ftp_transaction_factory),
  38       ftp_auth_cache_(ftp_auth_cache),
  39       weak_factory_(this) {
  40   DCHECK(proxy_service_);
  41   DCHECK(ftp_transaction_factory);
  42   DCHECK(ftp_auth_cache);
  43 }
  44
  45 URLRequestFtpJob::~URLRequestFtpJob() {
  46   if (pac_request_)
  47     proxy_service_->CancelPacRequest(pac_request_);
  48 }
  49
  50 bool URLRequestFtpJob::IsSafeRedirect(const GURL& location) {
  51   // Disallow all redirects.
  52   return false;
  53 }
  54
  55 bool URLRequestFtpJob::GetMimeType(std::string* mime_type) const {
  56   if (proxy_info_.is_direct()) {
  57     if (ftp_transaction_->GetResponseInfo()->is_directory_listing) {
  58       *mime_type = "text/vnd.chromium.ftp-dir";
  59       return true;
  60     }
  61   } else {
  62     // No special handling of MIME type is needed. As opposed to direct FTP
  63     // transaction, we do not get a raw directory listing to parse.
  64     return http_transaction_->GetResponseInfo()->
  65         headers->GetMimeType(mime_type);
  66   }
  67   return false;
  68 }
  69
  70 void URLRequestFtpJob::GetResponseInfo(HttpResponseInfo* info) {
  71   if (http_response_info_)
  72     *info = *http_response_info_;
  73 }
  74
  75 HostPortPair URLRequestFtpJob::GetSocketAddress() const {
  76   if (proxy_info_.is_direct()) {
  77     if (!ftp_transaction_)
  78       return HostPortPair();
  79     return ftp_transaction_->GetResponseInfo()->socket_address;
  80   } else {
  81     if (!http_transaction_)
  82       return HostPortPair();
  83     return http_transaction_->GetResponseInfo()->socket_address;
  84   }
  85 }
  86
  87 void URLRequestFtpJob::SetPriority(RequestPriority priority) {
  88   priority_ = priority;
  89   if (http_transaction_)
  90     http_transaction_->SetPriority(priority);
  91 }
  92
  93 void URLRequestFtpJob::Start() {
  94   DCHECK(!pac_request_);
  95   DCHECK(!ftp_transaction_);
  96   DCHECK(!http_transaction_);
  97
  98   int rv = OK;
  99   if (request_->load_flags() & LOAD_BYPASS_PROXY) {
 100     proxy_info_.UseDirect();
 101   } else {
 102     DCHECK_EQ(request_->context()->proxy_service(), proxy_service_);
 103     rv = proxy_service_->ResolveProxy(
 104         request_->url(),
 105         &proxy_info_,
 106         base::Bind(&URLRequestFtpJob::OnResolveProxyComplete,
 107                    base::Unretained(this)),
 108         &pac_request_,
 109         request_->net_log());
 110
 111     if (rv == ERR_IO_PENDING)
 112       return;
 113   }
 114   OnResolveProxyComplete(rv);
 115 }
 116
 117 void URLRequestFtpJob::Kill() {
 118   if (ftp_transaction_)
 119     ftp_transaction_.reset();
 120   if (http_transaction_)
 121     http_transaction_.reset();
 122   URLRequestJob::Kill();
 123   weak_factory_.InvalidateWeakPtrs();
 124 }
 125
 126 void URLRequestFtpJob::OnResolveProxyComplete(int result) {
 127   pac_request_ = NULL;
 128
 129   if (result != OK) {
 130     OnStartCompletedAsync(result);
 131     return;
 132   }
 133
 134   // Remove unsupported proxies from the list.
 135   proxy_info_.RemoveProxiesWithoutScheme(
 136       ProxyServer::SCHEME_DIRECT |
 137       ProxyServer::SCHEME_HTTP |
 138       ProxyServer::SCHEME_HTTPS);
 139
 140   // TODO(phajdan.jr): Implement proxy fallback, http://crbug.com/171495 .
 141   if (proxy_info_.is_direct())
 142     StartFtpTransaction();
 143   else if (proxy_info_.is_http() || proxy_info_.is_https())
 144     StartHttpTransaction();
 145   else
 146     OnStartCompletedAsync(ERR_NO_SUPPORTED_PROXIES);
 147 }
 148
 149 void URLRequestFtpJob::StartFtpTransaction() {
 150   // Create a transaction.
 151   DCHECK(!ftp_transaction_);
 152
 153   ftp_request_info_.url = request_->url();
 154   ftp_transaction_.reset(ftp_transaction_factory_->CreateTransaction());
 155
 156   // No matter what, we want to report our status as IO pending since we will
 157   // be notifying our consumer asynchronously via OnStartCompleted.
 158   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 159   int rv;
 160   if (ftp_transaction_) {
 161     rv = ftp_transaction_->Start(
 162         &ftp_request_info_,
 163         base::Bind(&URLRequestFtpJob::OnStartCompleted,
 164                    base::Unretained(this)),
 165         request_->net_log());
 166     if (rv == ERR_IO_PENDING)
 167       return;
 168   } else {
 169     rv = ERR_FAILED;
 170   }
 171   // The transaction started synchronously, but we need to notify the
 172   // URLRequest delegate via the message loop.
 173   OnStartCompletedAsync(rv);
 174 }
 175
 176 void URLRequestFtpJob::StartHttpTransaction() {
 177   // Create a transaction.
 178   DCHECK(!http_transaction_);
 179
 180   // Do not cache FTP responses sent through HTTP proxy.
 181   request_->SetLoadFlags(request_->load_flags() |
 182                          LOAD_DISABLE_CACHE |
 183                          LOAD_DO_NOT_SAVE_COOKIES |
 184                          LOAD_DO_NOT_SEND_COOKIES);
 185
 186   http_request_info_.url = request_->url();
 187   http_request_info_.method = request_->method();
 188   http_request_info_.load_flags = request_->load_flags();
 189
 190   int rv = request_->context()->http_transaction_factory()->CreateTransaction(
 191       priority_, &http_transaction_);
 192   if (rv == OK) {
 193     rv = http_transaction_->Start(
 194         &http_request_info_,
 195         base::Bind(&URLRequestFtpJob::OnStartCompleted,
 196                   base::Unretained(this)),
 197         request_->net_log());
 198     if (rv == ERR_IO_PENDING)
 199       return;
 200   }
 201   // The transaction started synchronously, but we need to notify the
 202   // URLRequest delegate via the message loop.
 203   OnStartCompletedAsync(rv);
 204 }
 205
 206 void URLRequestFtpJob::OnStartCompleted(int result) {
 207   // Clear the IO_PENDING status
 208   SetStatus(URLRequestStatus());
 209
 210   // Note that ftp_transaction_ may be NULL due to a creation failure.
 211   if (ftp_transaction_) {
 212     // FTP obviously doesn't have HTTP Content-Length header. We have to pass
 213     // the content size information manually.
 214     set_expected_content_size(
 215         ftp_transaction_->GetResponseInfo()->expected_content_size);
 216   }
 217
 218   if (result == OK) {
 219     if (http_transaction_) {
 220       http_response_info_ = http_transaction_->GetResponseInfo();
 221       SetProxyServer(http_response_info_->proxy_server);
 222
 223       if (http_response_info_->headers->response_code() == 401 ||
 224           http_response_info_->headers->response_code() == 407) {
 225         HandleAuthNeededResponse();
 226         return;
 227       }
 228     }
 229     NotifyHeadersComplete();
 230   } else if (ftp_transaction_ &&
 231              ftp_transaction_->GetResponseInfo()->needs_auth) {
 232     HandleAuthNeededResponse();
 233     return;
 234   } else {
 235     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
 236   }
 237 }
 238
 239 void URLRequestFtpJob::OnStartCompletedAsync(int result) {
 240   base::MessageLoop::current()->PostTask(
 241       FROM_HERE,
 242       base::Bind(&URLRequestFtpJob::OnStartCompleted,
 243                  weak_factory_.GetWeakPtr(), result));
 244 }
 245
 246 void URLRequestFtpJob::OnReadCompleted(int result) {
 247   read_in_progress_ = false;
 248   if (result == 0) {
 249     NotifyDone(URLRequestStatus());
 250   } else if (result < 0) {
 251     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
 252   } else {
 253     // Clear the IO_PENDING status
 254     SetStatus(URLRequestStatus());
 255   }
 256   NotifyReadComplete(result);
 257 }
 258
 259 void URLRequestFtpJob::RestartTransactionWithAuth() {
 260   DCHECK(auth_data_.get() && auth_data_->state == AUTH_STATE_HAVE_AUTH);
 261
 262   // No matter what, we want to report our status as IO pending since we will
 263   // be notifying our consumer asynchronously via OnStartCompleted.
 264   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 265
 266   int rv;
 267   if (proxy_info_.is_direct()) {
 268     rv = ftp_transaction_->RestartWithAuth(
 269         auth_data_->credentials,
 270         base::Bind(&URLRequestFtpJob::OnStartCompleted,
 271                    base::Unretained(this)));
 272   } else {
 273     rv = http_transaction_->RestartWithAuth(
 274         auth_data_->credentials,
 275         base::Bind(&URLRequestFtpJob::OnStartCompleted,
 276                    base::Unretained(this)));
 277   }
 278   if (rv == ERR_IO_PENDING)
 279     return;
 280
 281   OnStartCompletedAsync(rv);
 282 }
 283
 284 LoadState URLRequestFtpJob::GetLoadState() const {
 285   if (proxy_info_.is_direct()) {
 286     return ftp_transaction_ ?
 287         ftp_transaction_->GetLoadState() : LOAD_STATE_IDLE;
 288   } else {
 289     return http_transaction_ ?
 290         http_transaction_->GetLoadState() : LOAD_STATE_IDLE;
 291   }
 292 }
 293
 294 bool URLRequestFtpJob::NeedsAuth() {
 295   return auth_data_.get() && auth_data_->state == AUTH_STATE_NEED_AUTH;
 296 }
 297
 298 void URLRequestFtpJob::GetAuthChallengeInfo(
 299     scoped_refptr<AuthChallengeInfo>* result) {
 300   DCHECK(NeedsAuth());
 301
 302   if (http_response_info_) {
 303     *result = http_response_info_->auth_challenge;
 304     return;
 305   }
 306
 307   scoped_refptr<AuthChallengeInfo> auth_info(new AuthChallengeInfo);
 308   auth_info->is_proxy = false;
 309   auth_info->challenger = HostPortPair::FromURL(request_->url());
 310   // scheme and realm are kept empty.
 311   DCHECK(auth_info->scheme.empty());
 312   DCHECK(auth_info->realm.empty());
 313   result->swap(auth_info);
 314 }
 315
 316 void URLRequestFtpJob::SetAuth(const AuthCredentials& credentials) {
 317   DCHECK(ftp_transaction_ || http_transaction_);
 318   DCHECK(NeedsAuth());
 319
 320   auth_data_->state = AUTH_STATE_HAVE_AUTH;
 321   auth_data_->credentials = credentials;
 322
 323   if (ftp_transaction_) {
 324     ftp_auth_cache_->Add(request_->url().GetOrigin(),
 325                          auth_data_->credentials);
 326   }
 327
 328   RestartTransactionWithAuth();
 329 }
 330
 331 void URLRequestFtpJob::CancelAuth() {
 332   DCHECK(ftp_transaction_ || http_transaction_);
 333   DCHECK(NeedsAuth());
 334
 335   auth_data_->state = AUTH_STATE_CANCELED;
 336
 337   // Once the auth is cancelled, we proceed with the request as though
 338   // there were no auth.  Schedule this for later so that we don't cause
 339   // any recursing into the caller as a result of this call.
 340   OnStartCompletedAsync(OK);
 341 }
 342
 343 UploadProgress URLRequestFtpJob::GetUploadProgress() const {
 344   return UploadProgress();
 345 }
 346
 347 bool URLRequestFtpJob::ReadRawData(IOBuffer* buf,
 348                                    int buf_size,
 349                                    int *bytes_read) {
 350   DCHECK_NE(buf_size, 0);
 351   DCHECK(bytes_read);
 352   DCHECK(!read_in_progress_);
 353
 354   int rv;
 355   if (proxy_info_.is_direct()) {
 356     rv = ftp_transaction_->Read(buf, buf_size,
 357                                 base::Bind(&URLRequestFtpJob::OnReadCompleted,
 358                                            base::Unretained(this)));
 359   } else {
 360     rv = http_transaction_->Read(buf, buf_size,
 361                                  base::Bind(&URLRequestFtpJob::OnReadCompleted,
 362                                             base::Unretained(this)));
 363   }
 364
 365   if (rv >= 0) {
 366     *bytes_read = rv;
 367     return true;
 368   }
 369
 370   if (rv == ERR_IO_PENDING) {
 371     read_in_progress_ = true;
 372     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 373   } else {
 374     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 375   }
 376   return false;
 377 }
 378
 379 void URLRequestFtpJob::HandleAuthNeededResponse() {
 380   GURL origin = request_->url().GetOrigin();
 381
 382   if (auth_data_.get()) {
 383     if (auth_data_->state == AUTH_STATE_CANCELED) {
 384       NotifyHeadersComplete();
 385       return;
 386     }
 387
 388     if (ftp_transaction_ && auth_data_->state == AUTH_STATE_HAVE_AUTH)
 389       ftp_auth_cache_->Remove(origin, auth_data_->credentials);
 390   } else {
 391     auth_data_ = new AuthData;
 392   }
 393   auth_data_->state = AUTH_STATE_NEED_AUTH;
 394
 395   FtpAuthCache::Entry* cached_auth = NULL;
 396   if (ftp_transaction_ && ftp_transaction_->GetResponseInfo()->needs_auth)
 397     cached_auth = ftp_auth_cache_->Lookup(origin);
 398   if (cached_auth) {
 399     // Retry using cached auth data.
 400     SetAuth(cached_auth->credentials);
 401   } else {
 402     // Prompt for a username/password.
 403     NotifyHeadersComplete();
 404   }
 405 }
 406
 407 }  // namespace net