Add TLS-SRP (RFC 5054) support

net/http/http_response_info.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/http/http_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time.h"
 #include "net/base/auth.h"
@@ skipping 38 matching lines @@
   // This bit is set if the request has NPN negotiated.
   RESPONSE_INFO_WAS_NPN = 1 << 14,
 
   // This bit is set if the request was fetched via an explicit proxy.
   RESPONSE_INFO_WAS_PROXY = 1 << 15,
 
   // This bit is set if response could use alternate protocol. However, browser
   // will ingore the alternate protocol if spdy is not enabled.
   RESPONSE_INFO_WAS_ALTERNATE_PROTOCOL_AVAILABLE = 1 << 16,
 
+  // This bit is set if the response info has a TLS username.
+  RESPONSE_INFO_HAS_TLS_USERNAME = 1 << 17,
+
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       was_fetched_via_spdy(false),
       was_npn_negotiated(false),
       was_alternate_protocol_available(false),
       was_fetched_via_proxy(false) {
 }
 
 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
     : was_cached(rhs.was_cached),
       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
       was_npn_negotiated(rhs.was_npn_negotiated),
       was_alternate_protocol_available(rhs.was_alternate_protocol_available),
       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
       request_time(rhs.request_time),
       response_time(rhs.response_time),
       auth_challenge(rhs.auth_challenge),
       cert_request_info(rhs.cert_request_info),
+      login_request_info(rhs.login_request_info),
       ssl_info(rhs.ssl_info),
       headers(rhs.headers),
       vary_data(rhs.vary_data),
       metadata(rhs.metadata) {
 }
 
 HttpResponseInfo::~HttpResponseInfo() {
 }
 
 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
   was_cached = rhs.was_cached;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   was_npn_negotiated = rhs.was_npn_negotiated;
   was_alternate_protocol_available = rhs.was_alternate_protocol_available;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
   request_time = rhs.request_time;
   response_time = rhs.response_time;
   auth_challenge = rhs.auth_challenge;
   cert_request_info = rhs.cert_request_info;
+  login_request_info = rhs.login_request_info;
   ssl_info = rhs.ssl_info;
   headers = rhs.headers;
   vary_data = rhs.vary_data;
   metadata = rhs.metadata;
   return *this;
 }
 
 bool HttpResponseInfo::InitFromPickle(const Pickle& pickle,
                                       bool* response_truncated) {
   void* iter = NULL;
@@ skipping 22 matching lines @@
 
   // read response-headers
   headers = new HttpResponseHeaders(pickle, &iter);
   DCHECK_NE(headers->response_code(), -1);
 
   // read ssl-info
   if (flags & RESPONSE_INFO_HAS_CERT) {
     ssl_info.cert =
         X509Certificate::CreateFromPickle(pickle, &iter);
   }
+  if (flags & RESPONSE_INFO_HAS_TLS_USERNAME) {
+    string16 tls_username;
+    if (!pickle.ReadString16(&iter, &tls_username))
+      return false;
+    ssl_info.tls_username = tls_username;
+  }
   if (flags & RESPONSE_INFO_HAS_CERT_STATUS) {
     int cert_status;
     if (!pickle.ReadInt(&iter, &cert_status))
       return false;
     ssl_info.cert_status = cert_status;
   }
   if (flags & RESPONSE_INFO_HAS_SECURITY_BITS) {
     int security_bits;
     if (!pickle.ReadInt(&iter, &security_bits))
       return false;
@@ skipping 18 matching lines @@
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) ? true : false;
 
   return true;
 }
 
 void HttpResponseInfo::Persist(Pickle* pickle,
                                bool skip_transient_headers,
                                bool response_truncated) const {
   int flags = RESPONSE_INFO_VERSION;
   if (ssl_info.is_valid()) {
-    flags |= RESPONSE_INFO_HAS_CERT;
+    if (ssl_info.cert.get())
+      flags |= RESPONSE_INFO_HAS_CERT;
+    if (!ssl_info.tls_username.empty())
+      flags |= RESPONSE_INFO_HAS_TLS_USERNAME;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
     if (ssl_info.security_bits != -1)
       flags |= RESPONSE_INFO_HAS_SECURITY_BITS;
     // TODO(wtc): we should persist ssl_info.connection_status.
   }
   if (vary_data.is_valid())
     flags |= RESPONSE_INFO_HAS_VARY_DATA;
   if (response_truncated)
     flags |= RESPONSE_INFO_TRUNCATED;
   if (was_fetched_via_spdy)
@@ skipping 17 matching lines @@
         net::HttpResponseHeaders::PERSIST_SANS_COOKIES |
         net::HttpResponseHeaders::PERSIST_SANS_CHALLENGES |
         net::HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP |
         net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE |
         net::HttpResponseHeaders::PERSIST_SANS_RANGES;
   }
 
   headers->Persist(pickle, persist_options);
 
   if (ssl_info.is_valid()) {
-    ssl_info.cert->Persist(pickle);
+    if (flags & RESPONSE_INFO_HAS_CERT)
+      ssl_info.cert->Persist(pickle);
+    if (flags & RESPONSE_INFO_HAS_TLS_USERNAME)
+      pickle->WriteString16(ssl_info.tls_username);
     pickle->WriteInt(ssl_info.cert_status);
     if (ssl_info.security_bits != -1)
       pickle->WriteInt(ssl_info.security_bits);
   }
 
   if (vary_data.is_valid())
     vary_data.Persist(pickle);
 }
 
 }  // namespace net