Implement SSL client authentication for Windows....

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
+#include "net/base/ssl_cert_request_info.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_util.h"
 #include "net/http/partial_data.h"
 
@@ skipping 126 matching lines @@
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
                 this, &Transaction::OnCacheReadCompleted))) {
   }
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, CompletionCallback*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
+  virtual int RestartWithCertificate(X509Certificate* client_cert,
+                                     CompletionCallback* callback);
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
   virtual bool IsReadyToRestartForAuth();
   virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback*);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
   virtual uint64 GetUploadProgress(void) const;
 
   // The transaction has the following modes, which apply to how it may access
@@ skipping 63 matching lines @@
   // to fetch it.  Returns a network error code.
   int ContinuePartialCacheValidation();
 
   // Called to begin a network transaction.  Returns network error code.
   int BeginNetworkRequest();
 
   // Called to restart a network transaction after an error.  Returns network
   // error code.
   int RestartNetworkRequest();
 
+  // Called to restart a network transaction with a client certificate.
+  // Returns network error code.
+  int RestartNetworkRequestWithCertificate(X509Certificate* client_cert);
+
   // Called to restart a network transaction with authentication credentials.
   // Returns network error code.
   int RestartNetworkRequestWithAuth(const std::wstring& username,
                                     const std::wstring& password);
 
   // Called to determine if we need to validate the cache entry before using it.
   bool RequiresValidation();
 
   // Called to make the request conditional (to ask the server if the cached
   // copy is valid).  Returns true if able to make the request conditional.
@@ skipping 145 matching lines @@
     return ERR_UNEXPECTED;
 
   int rv = RestartNetworkRequest();
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
+int HttpCache::Transaction::RestartWithCertificate(
+    X509Certificate* client_cert,
+    CompletionCallback* callback) {
+  DCHECK(callback);
+
+  // ensure that we only have one asynchronous call at a time.
+  DCHECK(!callback_);
+
+  if (revoked())
+    return ERR_UNEXPECTED;
+
+  int rv = RestartNetworkRequestWithCertificate(client_cert);
+
+  if (rv == ERR_IO_PENDING)
+    callback_ = callback;
+
+  return rv;
+}
+
 int HttpCache::Transaction::RestartWithAuth(
     const std::wstring& username,
     const std::wstring& password,
     CompletionCallback* callback) {
   DCHECK(auth_response_.headers);
   DCHECK(callback);
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
@@ skipping 65 matching lines @@
     DCHECK(!callback_);
     callback_ = callback;
   }
   return rv;
 }
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
   if (auth_response_.headers)
     return &auth_response_;
-  return (response_.headers || response_.ssl_info.cert) ? &response_ : NULL;
+  return (response_.headers || response_.ssl_info.cert ||
+          response_.cert_request_info) ? &response_ : NULL;
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
   if (network_trans_.get())
     return network_trans_->GetLoadState();
   if (entry_ || !request_)
     return LOAD_STATE_IDLE;
   return LOAD_STATE_WAITING_FOR_CACHE;
 }
 
@@ skipping 285 matching lines @@
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
 
   int rv = network_trans_->RestartIgnoringLastError(&network_info_callback_);
   if (rv != ERR_IO_PENDING)
     OnNetworkInfoAvailable(rv);
   return rv;
 }
 
+int HttpCache::Transaction::RestartNetworkRequestWithCertificate(
+    X509Certificate* client_cert) {
+  DCHECK(mode_ & WRITE || mode_ == NONE);
+  DCHECK(network_trans_.get());
+
+  int rv = network_trans_->RestartWithCertificate(client_cert,
+                                                  &network_info_callback_);
+  if (rv != ERR_IO_PENDING)
+    OnNetworkInfoAvailable(rv);
+  return rv;
+}
+
 int HttpCache::Transaction::RestartNetworkRequestWithAuth(
     const std::wstring& username,
     const std::wstring& password) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
 
   int rv = network_trans_->RestartWithAuth(username, password,
                                            &network_info_callback_);
   if (rv != ERR_IO_PENDING)
     OnNetworkInfoAvailable(rv);
@@ skipping 267 matching lines @@
         if (result >= 0 || result == net::ERR_IO_PENDING)
           return;
       }
     }
   } else if (IsCertificateError(result)) {
     const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     // If we get a certificate error, then there is a certificate in ssl_info,
     // so GetResponseInfo() should never returns NULL here.
     DCHECK(response);
     response_.ssl_info = response->ssl_info;
+  } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
+    const HttpResponseInfo* response = network_trans_->GetResponseInfo();
+    DCHECK(response);
+    response_.cert_request_info = response->cert_request_info;
   }
   HandleResult(result);
 }
 
 void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
   DoNetworkReadCompleted(result);
 }
 
 int HttpCache::Transaction::DoNetworkReadCompleted(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
@@ skipping 593 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net