Add TLS-SRP (RFC 5054) support

net/url_request/url_request_http_job.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cookie_policy.h"
 #include "net/base/cookie_store.h"
 #include "net/base/filter.h"
 #include "net/base/transport_security_state.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/ssl_cert_request_info.h"
@@ skipping 50 matching lines @@
   const bool include_subdomains_;
   scoped_refptr<TransportSecurityState> sts_;
 };
 
 }  // namespace
 
 // TODO(darin): make sure the port blocking code is not lost
 // static
 URLRequestJob* URLRequestHttpJob::Factory(URLRequest* request,
                                           const std::string& scheme) {
-  DCHECK(scheme == "http" || scheme == "https");
+  DCHECK(scheme == "http" || scheme == "https" || scheme == "httpsv");
 
   int port = request->url().IntPort();
   if (!IsPortAllowedByDefault(port) && !IsPortAllowedByOverride(port))
     return new URLRequestErrorJob(request, ERR_UNSAFE_PORT);
 
   if (!request->context() ||
       !request->context()->http_transaction_factory()) {
     NOTREACHED() << "requires a valid context";
     return new URLRequestErrorJob(request, ERR_INVALID_ARGUMENT);
   }
@@ skipping 21 matching lines @@
   return new URLRequestHttpJob(request);
 }
 
 
 URLRequestHttpJob::URLRequestHttpJob(URLRequest* request)
     : URLRequestJob(request),
       response_info_(NULL),
       response_cookies_save_index_(0),
       proxy_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       server_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
+      tls_login_auth_data_(request->GetTLSLoginAuthData()),
       ALLOW_THIS_IN_INITIALIZER_LIST(can_get_cookies_callback_(
           this, &URLRequestHttpJob::OnCanGetCookiesCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(can_set_cookie_callback_(
           this, &URLRequestHttpJob::OnCanSetCookieCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
           this, &URLRequestHttpJob::OnStartCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
           this, &URLRequestHttpJob::OnReadCompleted)),
       read_in_progress_(false),
       transaction_(NULL),
@@ skipping 75 matching lines @@
     rv = transaction_->RestartWithAuth(username_, password_, &start_callback_);
     username_.clear();
     password_.clear();
   } else {
     DCHECK(request_->context());
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         &transaction_);
     if (rv == OK) {
+      if (tls_login_auth_data_->state == AUTH_STATE_HAVE_AUTH) {
+        transaction_->SetTLSLoginAuthData(tls_login_auth_data_);
+      }
+
       rv = transaction_->Start(
           &request_info_, &start_callback_, request_->net_log());
       // Make sure the context is alive for the duration of the
       // transaction.
       context_ = request_->context();
     }
   }
 
   if (rv == ERR_IO_PENDING)
     return;
@@ skipping 328 matching lines @@
   } else if (ShouldTreatAsCertificateError(result)) {
     // We encountered an SSL certificate error.  Ask our delegate to decide
     // what we should do.
     // TODO(wtc): also pass ssl_info.cert_status, or just pass the whole
     // ssl_info.
     request_->delegate()->OnSSLCertificateError(
         request_, result, transaction_->GetResponseInfo()->ssl_info.cert);
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     request_->delegate()->OnCertificateRequested(
         request_, transaction_->GetResponseInfo()->cert_request_info);
+  } else if (result == ERR_TLS_CLIENT_LOGIN_NEEDED ||
+             result == ERR_TLS_CLIENT_LOGIN_FAILED) {
+    DCHECK(transaction_->GetResponseInfo());
+    DCHECK(transaction_->GetResponseInfo()->login_request_info.get());
+    request_->delegate()->OnTLSLoginRequired(
+        request_, transaction_->GetResponseInfo()->login_request_info);
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 void URLRequestHttpJob::OnReadCompleted(int result) {
   read_in_progress_ = false;
 
   if (result == 0) {
     NotifyDone(URLRequestStatus());
@@ skipping 178 matching lines @@
   // We only allow redirects to certain "safe" protocols.  This does not
   // restrict redirects to externally handled protocols.  Our consumer would
   // need to take care of those.
 
   if (!URLRequest::IsHandledURL(location))
     return true;
 
   static const char* kSafeSchemes[] = {
     "http",
     "https",
+    "httpsv",
     "ftp"
   };
 
   for (size_t i = 0; i < arraysize(kSafeSchemes); ++i) {
     if (location.SchemeIs(kSafeSchemes[i]))
       return true;
   }
 
   return false;
 }
@@ skipping 69 matching lines @@
   // OnAuthRequired.
   //
   // We have to do this via InvokeLater to avoid "recursing" the consumer.
   //
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(
           &URLRequestHttpJob::OnStartCompleted, OK));
 }
 
+void URLRequestHttpJob::CancelTLSLogin() {
+  // These will be reset in OnStartCompleted.
+  response_info_ = NULL;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &URLRequestHttpJob::OnStartCompleted,
+          ERR_ABORTED));
+}
+
 void URLRequestHttpJob::ContinueWithCertificate(
     X509Certificate* client_cert) {
   DCHECK(transaction_.get());
 
   DCHECK(!response_info_) << "should not have a response yet";
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
 
   int rv = transaction_->RestartWithCertificate(client_cert, &start_callback_);
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(
           &URLRequestHttpJob::OnStartCompleted, rv));
 }
 
+void URLRequestHttpJob::ContinueWithTLSLogin() {
+  DCHECK(tls_login_auth_data_->state == AUTH_STATE_HAVE_AUTH);
+
+  transaction_->SetTLSLoginAuthData(tls_login_auth_data_);
+
+  DCHECK(transaction_.get());
+
+  DCHECK(!response_info_) << "should not have a response yet";
+
+  // No matter what, we want to report our status as IO pending since we will
+  // be notifying our consumer asynchronously via OnStartCompleted.
+  SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+
+  int rv = transaction_->RestartWithTLSLogin(&start_callback_);
+  if (rv == ERR_IO_PENDING)
+    return;
+
+  // The transaction started synchronously, but we need to notify the
+  // URLRequest delegate via the message loop.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &URLRequestHttpJob::OnStartCompleted, rv));
+}
+
 void URLRequestHttpJob::ContinueDespiteLastError() {
   // If the transaction was destroyed, then the job was cancelled.
   if (!transaction_.get())
     return;
 
   DCHECK(!response_info_) << "should not have a response yet";
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
@@ skipping 59 matching lines @@
     // At shutdown time, care is taken to be sure that we don't delete this
     // globally useful instance "too soon," so this check is just defensive
     // coding to assure that IF the system is shutting down, we don't have any
     // problem if the manager was deleted ahead of time.
     if (manager)  // Defensive programming.
       manager->FetchDictionary(request_info_.url, sdch_dictionary_url_);
   }
 }
 
 }  // namespace net