net/http/http_response_info.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/http/http_response_info.h"
   6
   7 #include "base/logging.h"
   8 #include "base/pickle.h"
   9 #include "base/time/time.h"
  10 #include "net/base/auth.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/cert/x509_certificate.h"
  14 #include "net/http/http_response_headers.h"
  15 #include "net/ssl/ssl_cert_request_info.h"
  16
  17 using base::Time;
  18
  19 namespace net {
  20
  21 namespace {
  22
  23 X509Certificate::PickleType GetPickleTypeForVersion(int version) {
  24   switch (version) {
  25     case 1:
  26       return X509Certificate::PICKLETYPE_SINGLE_CERTIFICATE;
  27     case 2:
  28       return X509Certificate::PICKLETYPE_CERTIFICATE_CHAIN_V2;
  29     case 3:
  30     default:
  31       return X509Certificate::PICKLETYPE_CERTIFICATE_CHAIN_V3;
  32   }
  33 }
  34
  35 }  // namespace
  36
  37 // These values can be bit-wise combined to form the flags field of the
  38 // serialized HttpResponseInfo.
  39 enum {
  40   // The version of the response info used when persisting response info.
  41   RESPONSE_INFO_VERSION = 3,
  42
  43   // The minimum version supported for deserializing response info.
  44   RESPONSE_INFO_MINIMUM_VERSION = 1,
  45
  46   // We reserve up to 8 bits for the version number.
  47   RESPONSE_INFO_VERSION_MASK = 0xFF,
  48
  49   // This bit is set if the response info has a cert at the end.
  50   // Version 1 serialized only the end-entity certificate, while subsequent
  51   // versions include the available certificate chain.
  52   RESPONSE_INFO_HAS_CERT = 1 << 8,
  53
  54   // This bit is set if the response info has a security-bits field (security
  55   // strength, in bits, of the SSL connection) at the end.
  56   RESPONSE_INFO_HAS_SECURITY_BITS = 1 << 9,
  57
  58   // This bit is set if the response info has a cert status at the end.
  59   RESPONSE_INFO_HAS_CERT_STATUS = 1 << 10,
  60
  61   // This bit is set if the response info has vary header data.
  62   RESPONSE_INFO_HAS_VARY_DATA = 1 << 11,
  63
  64   // This bit is set if the request was cancelled before completion.
  65   RESPONSE_INFO_TRUNCATED = 1 << 12,
  66
  67   // This bit is set if the response was received via SPDY.
  68   RESPONSE_INFO_WAS_SPDY = 1 << 13,
  69
  70   // This bit is set if the request has NPN negotiated.
  71   RESPONSE_INFO_WAS_NPN = 1 << 14,
  72
  73   // This bit is set if the request was fetched via an explicit proxy.
  74   RESPONSE_INFO_WAS_PROXY = 1 << 15,
  75
  76   // This bit is set if the response info has an SSL connection status field.
  77   // This contains the ciphersuite used to fetch the resource as well as the
  78   // protocol version, compression method and whether SSLv3 fallback was used.
  79   RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS = 1 << 16,
  80
  81   // This bit is set if the response info has protocol version.
  82   RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL = 1 << 17,
  83
  84   // This bit is set if the response info has connection info.
  85   RESPONSE_INFO_HAS_CONNECTION_INFO = 1 << 18,
  86
  87   // This bit is set if the request has http authentication.
  88   RESPONSE_INFO_USE_HTTP_AUTHENTICATION = 1 << 19,
  89
  90   // TODO(darin): Add other bits to indicate alternate request methods.
  91   // For now, we don't support storing those.
  92 };
  93
  94 HttpResponseInfo::HttpResponseInfo()
  95     : was_cached(false),
  96       server_data_unavailable(false),
  97       network_accessed(false),
  98       was_fetched_via_spdy(false),
  99       was_npn_negotiated(false),
 100       was_fetched_via_proxy(false),
 101       did_use_http_auth(false),
 102       connection_info(CONNECTION_INFO_UNKNOWN) {
 103 }
 104
 105 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
 106     : was_cached(rhs.was_cached),
 107       server_data_unavailable(rhs.server_data_unavailable),
 108       network_accessed(rhs.network_accessed),
 109       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
 110       was_npn_negotiated(rhs.was_npn_negotiated),
 111       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
 112       did_use_http_auth(rhs.did_use_http_auth),
 113       socket_address(rhs.socket_address),
 114       npn_negotiated_protocol(rhs.npn_negotiated_protocol),
 115       connection_info(rhs.connection_info),
 116       request_time(rhs.request_time),
 117       response_time(rhs.response_time),
 118       auth_challenge(rhs.auth_challenge),
 119       cert_request_info(rhs.cert_request_info),
 120       ssl_info(rhs.ssl_info),
 121       headers(rhs.headers),
 122       vary_data(rhs.vary_data),
 123       metadata(rhs.metadata) {
 124 }
 125
 126 HttpResponseInfo::~HttpResponseInfo() {
 127 }
 128
 129 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
 130   was_cached = rhs.was_cached;
 131   server_data_unavailable = rhs.server_data_unavailable;
 132   network_accessed = rhs.network_accessed;
 133   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
 134   was_npn_negotiated = rhs.was_npn_negotiated;
 135   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
 136   did_use_http_auth = rhs.did_use_http_auth;
 137   socket_address = rhs.socket_address;
 138   npn_negotiated_protocol = rhs.npn_negotiated_protocol;
 139   connection_info = rhs.connection_info;
 140   request_time = rhs.request_time;
 141   response_time = rhs.response_time;
 142   auth_challenge = rhs.auth_challenge;
 143   cert_request_info = rhs.cert_request_info;
 144   ssl_info = rhs.ssl_info;
 145   headers = rhs.headers;
 146   vary_data = rhs.vary_data;
 147   metadata = rhs.metadata;
 148   return *this;
 149 }
 150
 151 bool HttpResponseInfo::InitFromPickle(const Pickle& pickle,
 152                                       bool* response_truncated) {
 153   PickleIterator iter(pickle);
 154
 155   // Read flags and verify version
 156   int flags;
 157   if (!pickle.ReadInt(&iter, &flags))
 158     return false;
 159   int version = flags & RESPONSE_INFO_VERSION_MASK;
 160   if (version < RESPONSE_INFO_MINIMUM_VERSION ||
 161       version > RESPONSE_INFO_VERSION) {
 162     DLOG(ERROR) << "unexpected response info version: " << version;
 163     return false;
 164   }
 165
 166   // Read request-time
 167   int64 time_val;
 168   if (!pickle.ReadInt64(&iter, &time_val))
 169     return false;
 170   request_time = Time::FromInternalValue(time_val);
 171   was_cached = true;  // Set status to show cache resurrection.
 172
 173   // Read response-time
 174   if (!pickle.ReadInt64(&iter, &time_val))
 175     return false;
 176   response_time = Time::FromInternalValue(time_val);
 177
 178   // Read response-headers
 179   headers = new HttpResponseHeaders(pickle, &iter);
 180   if (headers->response_code() == -1)
 181     return false;
 182
 183   // Read ssl-info
 184   if (flags & RESPONSE_INFO_HAS_CERT) {
 185     X509Certificate::PickleType type = GetPickleTypeForVersion(version);
 186     ssl_info.cert = X509Certificate::CreateFromPickle(pickle, &iter, type);
 187     if (!ssl_info.cert.get())
 188       return false;
 189   }
 190   if (flags & RESPONSE_INFO_HAS_CERT_STATUS) {
 191     CertStatus cert_status;
 192     if (!pickle.ReadUInt32(&iter, &cert_status))
 193       return false;
 194     ssl_info.cert_status = cert_status;
 195   }
 196   if (flags & RESPONSE_INFO_HAS_SECURITY_BITS) {
 197     int security_bits;
 198     if (!pickle.ReadInt(&iter, &security_bits))
 199       return false;
 200     ssl_info.security_bits = security_bits;
 201   }
 202
 203   if (flags & RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS) {
 204     int connection_status;
 205     if (!pickle.ReadInt(&iter, &connection_status))
 206       return false;
 207     ssl_info.connection_status = connection_status;
 208   }
 209
 210   // Read vary-data
 211   if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
 212     if (!vary_data.InitFromPickle(pickle, &iter))
 213       return false;
 214   }
 215
 216   // Read socket_address.
 217   std::string socket_address_host;
 218   if (pickle.ReadString(&iter, &socket_address_host)) {
 219     // If the host was written, we always expect the port to follow.
 220     uint16 socket_address_port;
 221     if (!pickle.ReadUInt16(&iter, &socket_address_port))
 222       return false;
 223     socket_address = HostPortPair(socket_address_host, socket_address_port);
 224   } else if (version > 1) {
 225     // socket_address was not always present in version 1 of the response
 226     // info, so we don't fail if it can't be read.
 227     return false;
 228   }
 229
 230   // Read protocol-version.
 231   if (flags & RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL) {
 232     if (!pickle.ReadString(&iter, &npn_negotiated_protocol))
 233       return false;
 234   }
 235
 236   // Read connection info.
 237   if (flags & RESPONSE_INFO_HAS_CONNECTION_INFO) {
 238     int value;
 239     if (!pickle.ReadInt(&iter, &value))
 240       return false;
 241
 242     if (value > static_cast<int>(CONNECTION_INFO_UNKNOWN) &&
 243         value < static_cast<int>(NUM_OF_CONNECTION_INFOS)) {
 244       connection_info = static_cast<ConnectionInfo>(value);
 245     }
 246   }
 247
 248   was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
 249
 250   was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
 251
 252   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 253
 254   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
 255
 256   did_use_http_auth = (flags & RESPONSE_INFO_USE_HTTP_AUTHENTICATION) != 0;
 257
 258   return true;
 259 }
 260
 261 void HttpResponseInfo::Persist(Pickle* pickle,
 262                                bool skip_transient_headers,
 263                                bool response_truncated) const {
 264   int flags = RESPONSE_INFO_VERSION;
 265   if (ssl_info.is_valid()) {
 266     flags |= RESPONSE_INFO_HAS_CERT;
 267     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
 268     if (ssl_info.security_bits != -1)
 269       flags |= RESPONSE_INFO_HAS_SECURITY_BITS;
 270     if (ssl_info.connection_status != 0)
 271       flags |= RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS;
 272   }
 273   if (vary_data.is_valid())
 274     flags |= RESPONSE_INFO_HAS_VARY_DATA;
 275   if (response_truncated)
 276     flags |= RESPONSE_INFO_TRUNCATED;
 277   if (was_fetched_via_spdy)
 278     flags |= RESPONSE_INFO_WAS_SPDY;
 279   if (was_npn_negotiated) {
 280     flags |= RESPONSE_INFO_WAS_NPN;
 281     flags |= RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL;
 282   }
 283   if (was_fetched_via_proxy)
 284     flags |= RESPONSE_INFO_WAS_PROXY;
 285   if (connection_info != CONNECTION_INFO_UNKNOWN)
 286     flags |= RESPONSE_INFO_HAS_CONNECTION_INFO;
 287   if (did_use_http_auth)
 288     flags |= RESPONSE_INFO_USE_HTTP_AUTHENTICATION;
 289
 290   pickle->WriteInt(flags);
 291   pickle->WriteInt64(request_time.ToInternalValue());
 292   pickle->WriteInt64(response_time.ToInternalValue());
 293
 294   net::HttpResponseHeaders::PersistOptions persist_options =
 295       net::HttpResponseHeaders::PERSIST_RAW;
 296
 297   if (skip_transient_headers) {
 298     persist_options =
 299         net::HttpResponseHeaders::PERSIST_SANS_COOKIES |
 300         net::HttpResponseHeaders::PERSIST_SANS_CHALLENGES |
 301         net::HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP |
 302         net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE |
 303         net::HttpResponseHeaders::PERSIST_SANS_RANGES |
 304         net::HttpResponseHeaders::PERSIST_SANS_SECURITY_STATE;
 305   }
 306
 307   headers->Persist(pickle, persist_options);
 308
 309   if (ssl_info.is_valid()) {
 310     ssl_info.cert->Persist(pickle);
 311     pickle->WriteUInt32(ssl_info.cert_status);
 312     if (ssl_info.security_bits != -1)
 313       pickle->WriteInt(ssl_info.security_bits);
 314     if (ssl_info.connection_status != 0)
 315       pickle->WriteInt(ssl_info.connection_status);
 316   }
 317
 318   if (vary_data.is_valid())
 319     vary_data.Persist(pickle);
 320
 321   pickle->WriteString(socket_address.host());
 322   pickle->WriteUInt16(socket_address.port());
 323
 324   if (was_npn_negotiated)
 325     pickle->WriteString(npn_negotiated_protocol);
 326
 327   if (connection_info != CONNECTION_INFO_UNKNOWN)
 328     pickle->WriteInt(static_cast<int>(connection_info));
 329 }
 330
 331 HttpResponseInfo::ConnectionInfo HttpResponseInfo::ConnectionInfoFromNextProto(
 332     NextProto next_proto) {
 333   switch (next_proto) {
 334     case kProtoSPDY2:
 335       return CONNECTION_INFO_SPDY2;
 336     case kProtoSPDY3:
 337     case kProtoSPDY31:
 338       return CONNECTION_INFO_SPDY3;
 339     case kProtoSPDY4a2:
 340       return CONNECTION_INFO_SPDY4A2;
 341     case kProtoHTTP2Draft04:
 342       return CONNECTION_INFO_HTTP2_DRAFT_04;
 343     case kProtoQUIC1SPDY3:
 344       return CONNECTION_INFO_QUIC1_SPDY3;
 345
 346     case kProtoUnknown:
 347     case kProtoHTTP11:
 348     case kProtoSPDY1:
 349     case kProtoSPDY21:
 350       break;
 351   }
 352
 353   NOTREACHED();
 354   return CONNECTION_INFO_UNKNOWN;
 355 }
 356
 357 // static
 358 std::string HttpResponseInfo::ConnectionInfoToString(
 359     ConnectionInfo connection_info) {
 360   switch (connection_info) {
 361     case CONNECTION_INFO_UNKNOWN:
 362       return "unknown";
 363     case CONNECTION_INFO_HTTP1:
 364       return "http/1";
 365     case CONNECTION_INFO_SPDY2:
 366       return "spdy/2";
 367     case CONNECTION_INFO_SPDY3:
 368       return "spdy/3";
 369     case CONNECTION_INFO_SPDY4A2:
 370       return "spdy/4a2";
 371     case CONNECTION_INFO_HTTP2_DRAFT_04:
 372       return "HTTP-draft-04/2.0";
 373     case CONNECTION_INFO_QUIC1_SPDY3:
 374       return "quic/1+spdy/3";
 375     case NUM_OF_CONNECTION_INFOS:
 376       break;
 377   }
 378   NOTREACHED();
 379   return "";
 380 }
 381
 382 }  // namespace net