http_response_info.cc 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  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. #include "net/http/http_response_info.h"
  5. #include "base/logging.h"
  6. #include "base/numerics/safe_conversions.h"
  7. #include "base/pickle.h"
  8. #include "base/time/time.h"
  9. #include "net/base/net_errors.h"
  10. #include "net/cert/sct_status_flags.h"
  11. #include "net/cert/signed_certificate_timestamp.h"
  12. #include "net/cert/x509_certificate.h"
  13. #include "net/http/http_response_headers.h"
  14. #include "net/ssl/ssl_cert_request_info.h"
  15. #include "net/ssl/ssl_connection_status_flags.h"
  16. #include "net/third_party/quiche/src/quiche/quic/core/quic_versions.h"
  17. #include "third_party/boringssl/src/include/openssl/ssl.h"
  18. using base::Time;
  19. namespace net {
  20. namespace {
  21. bool KeyExchangeGroupIsValid(int ssl_connection_status) {
  22. // TLS 1.3 and later always treat the field correctly.
  23. if (SSLConnectionStatusToVersion(ssl_connection_status) >=
  24. SSL_CONNECTION_VERSION_TLS1_3) {
  25. return true;
  26. }
  27. // Prior to TLS 1.3, only ECDHE ciphers have groups.
  28. const SSL_CIPHER* cipher = SSL_get_cipher_by_value(
  29. SSLConnectionStatusToCipherSuite(ssl_connection_status));
  30. return cipher && SSL_CIPHER_get_kx_nid(cipher) == NID_kx_ecdhe;
  31. }
  32. } // namespace
  33. // These values can be bit-wise combined to form the flags field of the
  34. // serialized HttpResponseInfo.
  35. enum {
  36. // The version of the response info used when persisting response info.
  37. RESPONSE_INFO_VERSION = 3,
  38. // The minimum version supported for deserializing response info.
  39. RESPONSE_INFO_MINIMUM_VERSION = 3,
  40. // We reserve up to 8 bits for the version number.
  41. RESPONSE_INFO_VERSION_MASK = 0xFF,
  42. // This bit is set if the response info has a cert at the end.
  43. // Version 1 serialized only the end-entity certificate, while subsequent
  44. // versions include the available certificate chain.
  45. RESPONSE_INFO_HAS_CERT = 1 << 8,
  46. // This bit was historically set if the response info had a security-bits
  47. // field (security strength, in bits, of the SSL connection) at the end.
  48. RESPONSE_INFO_HAS_SECURITY_BITS = 1 << 9,
  49. // This bit is set if the response info has a cert status at the end.
  50. RESPONSE_INFO_HAS_CERT_STATUS = 1 << 10,
  51. // This bit is set if the response info has vary header data.
  52. RESPONSE_INFO_HAS_VARY_DATA = 1 << 11,
  53. // This bit is set if the request was cancelled before completion.
  54. RESPONSE_INFO_TRUNCATED = 1 << 12,
  55. // This bit is set if the response was received via SPDY.
  56. RESPONSE_INFO_WAS_SPDY = 1 << 13,
  57. // This bit is set if the request has ALPN negotiated.
  58. RESPONSE_INFO_WAS_ALPN = 1 << 14,
  59. // This bit is set if the request was fetched via an explicit proxy.
  60. RESPONSE_INFO_WAS_PROXY = 1 << 15,
  61. // This bit is set if the response info has an SSL connection status field.
  62. // This contains the ciphersuite used to fetch the resource as well as the
  63. // protocol version, compression method and whether SSLv3 fallback was used.
  64. RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS = 1 << 16,
  65. // This bit is set if the response info has protocol version.
  66. RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL = 1 << 17,
  67. // This bit is set if the response info has connection info.
  68. RESPONSE_INFO_HAS_CONNECTION_INFO = 1 << 18,
  69. // This bit is set if the request has http authentication.
  70. RESPONSE_INFO_USE_HTTP_AUTHENTICATION = 1 << 19,
  71. // This bit is set if ssl_info has SCTs.
  72. RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS = 1 << 20,
  73. RESPONSE_INFO_UNUSED_SINCE_PREFETCH = 1 << 21,
  74. // This bit is set if the response has a key exchange group.
  75. RESPONSE_INFO_HAS_KEY_EXCHANGE_GROUP = 1 << 22,
  76. // This bit is set if ssl_info recorded that PKP was bypassed due to a local
  77. // trust anchor.
  78. RESPONSE_INFO_PKP_BYPASSED = 1 << 23,
  79. // This bit is set if stale_revalidate_time is stored.
  80. RESPONSE_INFO_HAS_STALENESS = 1 << 24,
  81. // This bit is set if the response has a peer signature algorithm.
  82. RESPONSE_INFO_HAS_PEER_SIGNATURE_ALGORITHM = 1 << 25,
  83. // This bit is set if the response is a prefetch whose reuse should be
  84. // restricted in some way.
  85. RESPONSE_INFO_RESTRICTED_PREFETCH = 1 << 26,
  86. // This bit is set if the response has a nonempty `dns_aliases` entry.
  87. RESPONSE_INFO_HAS_DNS_ALIASES = 1 << 27,
  88. // This bit is set for an entry in the single-keyed cache that has been marked
  89. // unusable due to the checksum not matching.
  90. RESPONSE_INFO_SINGLE_KEYED_CACHE_ENTRY_UNUSABLE = 1 << 28,
  91. // This bit is set if the response has `encrypted_client_hello` set.
  92. RESPONSE_INFO_ENCRYPTED_CLIENT_HELLO = 1 << 29,
  93. // This enum only has a few bits (`1 << 31` is the limit). If allocating the
  94. // last flag, instead allocate it as `RESPONSE_INFO_HAS_EXTRA_FLAGS` to
  95. // signal another flags word.
  96. };
  97. HttpResponseInfo::ConnectionInfoCoarse HttpResponseInfo::ConnectionInfoToCoarse(
  98. ConnectionInfo info) {
  99. switch (info) {
  100. case CONNECTION_INFO_HTTP0_9:
  101. case CONNECTION_INFO_HTTP1_0:
  102. case CONNECTION_INFO_HTTP1_1:
  103. return CONNECTION_INFO_COARSE_HTTP1;
  104. case CONNECTION_INFO_HTTP2:
  105. case CONNECTION_INFO_DEPRECATED_SPDY2:
  106. case CONNECTION_INFO_DEPRECATED_SPDY3:
  107. case CONNECTION_INFO_DEPRECATED_HTTP2_14:
  108. case CONNECTION_INFO_DEPRECATED_HTTP2_15:
  109. return CONNECTION_INFO_COARSE_HTTP2;
  110. case CONNECTION_INFO_QUIC_UNKNOWN_VERSION:
  111. case CONNECTION_INFO_QUIC_32:
  112. case CONNECTION_INFO_QUIC_33:
  113. case CONNECTION_INFO_QUIC_34:
  114. case CONNECTION_INFO_QUIC_35:
  115. case CONNECTION_INFO_QUIC_36:
  116. case CONNECTION_INFO_QUIC_37:
  117. case CONNECTION_INFO_QUIC_38:
  118. case CONNECTION_INFO_QUIC_39:
  119. case CONNECTION_INFO_QUIC_40:
  120. case CONNECTION_INFO_QUIC_41:
  121. case CONNECTION_INFO_QUIC_42:
  122. case CONNECTION_INFO_QUIC_43:
  123. case CONNECTION_INFO_QUIC_44:
  124. case CONNECTION_INFO_QUIC_45:
  125. case CONNECTION_INFO_QUIC_46:
  126. case CONNECTION_INFO_QUIC_47:
  127. case CONNECTION_INFO_QUIC_Q048:
  128. case CONNECTION_INFO_QUIC_T048:
  129. case CONNECTION_INFO_QUIC_Q049:
  130. case CONNECTION_INFO_QUIC_T049:
  131. case CONNECTION_INFO_QUIC_Q050:
  132. case CONNECTION_INFO_QUIC_T050:
  133. case CONNECTION_INFO_QUIC_Q099:
  134. case CONNECTION_INFO_QUIC_T099:
  135. case CONNECTION_INFO_QUIC_999:
  136. case CONNECTION_INFO_QUIC_DRAFT_25:
  137. case CONNECTION_INFO_QUIC_DRAFT_27:
  138. case CONNECTION_INFO_QUIC_DRAFT_28:
  139. case CONNECTION_INFO_QUIC_DRAFT_29:
  140. case CONNECTION_INFO_QUIC_T051:
  141. case CONNECTION_INFO_QUIC_RFC_V1:
  142. case CONNECTION_INFO_QUIC_2_DRAFT_1:
  143. return CONNECTION_INFO_COARSE_QUIC;
  144. case CONNECTION_INFO_UNKNOWN:
  145. return CONNECTION_INFO_COARSE_OTHER;
  146. case NUM_OF_CONNECTION_INFOS:
  147. NOTREACHED();
  148. return CONNECTION_INFO_COARSE_OTHER;
  149. }
  150. NOTREACHED();
  151. return CONNECTION_INFO_COARSE_OTHER;
  152. }
  153. HttpResponseInfo::HttpResponseInfo() = default;
  154. HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs) = default;
  155. HttpResponseInfo::~HttpResponseInfo() = default;
  156. HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) =
  157. default;
  158. bool HttpResponseInfo::InitFromPickle(const base::Pickle& pickle,
  159. bool* response_truncated) {
  160. base::PickleIterator iter(pickle);
  161. // Read flags and verify version
  162. int flags;
  163. if (!iter.ReadInt(&flags))
  164. return false;
  165. int version = flags & RESPONSE_INFO_VERSION_MASK;
  166. if (version < RESPONSE_INFO_MINIMUM_VERSION ||
  167. version > RESPONSE_INFO_VERSION) {
  168. DLOG(ERROR) << "unexpected response info version: " << version;
  169. return false;
  170. }
  171. // Read request-time
  172. int64_t time_val;
  173. if (!iter.ReadInt64(&time_val))
  174. return false;
  175. request_time = Time::FromInternalValue(time_val);
  176. was_cached = true; // Set status to show cache resurrection.
  177. // Read response-time
  178. if (!iter.ReadInt64(&time_val))
  179. return false;
  180. response_time = Time::FromInternalValue(time_val);
  181. // Read response-headers
  182. headers = base::MakeRefCounted<HttpResponseHeaders>(&iter);
  183. if (headers->response_code() == -1)
  184. return false;
  185. // Read ssl-info
  186. if (flags & RESPONSE_INFO_HAS_CERT) {
  187. ssl_info.cert = X509Certificate::CreateFromPickle(&iter);
  188. if (!ssl_info.cert.get())
  189. return false;
  190. }
  191. if (flags & RESPONSE_INFO_HAS_CERT_STATUS) {
  192. CertStatus cert_status;
  193. if (!iter.ReadUInt32(&cert_status))
  194. return false;
  195. ssl_info.cert_status = cert_status;
  196. }
  197. if (flags & RESPONSE_INFO_HAS_SECURITY_BITS) {
  198. // The security_bits field has been removed from ssl_info. For backwards
  199. // compatibility, we should still read the value out of iter.
  200. int security_bits;
  201. if (!iter.ReadInt(&security_bits))
  202. return false;
  203. }
  204. if (flags & RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS) {
  205. int connection_status;
  206. if (!iter.ReadInt(&connection_status))
  207. return false;
  208. // SSLv3 is gone, so drop cached entries that were loaded over SSLv3.
  209. if (SSLConnectionStatusToVersion(connection_status) ==
  210. SSL_CONNECTION_VERSION_SSL3) {
  211. return false;
  212. }
  213. ssl_info.connection_status = connection_status;
  214. }
  215. // Signed Certificate Timestamps are no longer persisted to the cache, so
  216. // ignore them when reading them out.
  217. if (flags & RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS) {
  218. int num_scts;
  219. if (!iter.ReadInt(&num_scts))
  220. return false;
  221. for (int i = 0; i < num_scts; ++i) {
  222. scoped_refptr<ct::SignedCertificateTimestamp> sct(
  223. ct::SignedCertificateTimestamp::CreateFromPickle(&iter));
  224. uint16_t status;
  225. if (!sct.get() || !iter.ReadUInt16(&status))
  226. return false;
  227. }
  228. }
  229. // Read vary-data
  230. if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
  231. if (!vary_data.InitFromPickle(&iter))
  232. return false;
  233. }
  234. // Read socket_address.
  235. std::string socket_address_host;
  236. if (!iter.ReadString(&socket_address_host))
  237. return false;
  238. // If the host was written, we always expect the port to follow.
  239. uint16_t socket_address_port;
  240. if (!iter.ReadUInt16(&socket_address_port))
  241. return false;
  242. IPAddress ip_address;
  243. if (ip_address.AssignFromIPLiteral(socket_address_host)) {
  244. remote_endpoint = IPEndPoint(ip_address, socket_address_port);
  245. } else if (ParseURLHostnameToAddress(socket_address_host, &ip_address)) {
  246. remote_endpoint = IPEndPoint(ip_address, socket_address_port);
  247. }
  248. // Read protocol-version.
  249. if (flags & RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL) {
  250. if (!iter.ReadString(&alpn_negotiated_protocol))
  251. return false;
  252. }
  253. // Read connection info.
  254. if (flags & RESPONSE_INFO_HAS_CONNECTION_INFO) {
  255. int value;
  256. if (!iter.ReadInt(&value))
  257. return false;
  258. if (value > static_cast<int>(CONNECTION_INFO_UNKNOWN) &&
  259. value < static_cast<int>(NUM_OF_CONNECTION_INFOS)) {
  260. connection_info = static_cast<ConnectionInfo>(value);
  261. }
  262. }
  263. // Read key_exchange_group
  264. if (flags & RESPONSE_INFO_HAS_KEY_EXCHANGE_GROUP) {
  265. int key_exchange_group;
  266. if (!iter.ReadInt(&key_exchange_group))
  267. return false;
  268. // Historically, the key_exchange_group field was key_exchange_info which
  269. // conflated a number of different values based on the cipher suite, so some
  270. // values must be discarded. See https://crbug.com/639421.
  271. if (KeyExchangeGroupIsValid(ssl_info.connection_status))
  272. ssl_info.key_exchange_group = key_exchange_group;
  273. }
  274. // Read staleness time.
  275. if (flags & RESPONSE_INFO_HAS_STALENESS) {
  276. if (!iter.ReadInt64(&time_val))
  277. return false;
  278. stale_revalidate_timeout = base::Time() + base::Microseconds(time_val);
  279. }
  280. was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
  281. was_alpn_negotiated = (flags & RESPONSE_INFO_WAS_ALPN) != 0;
  282. was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
  283. *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
  284. did_use_http_auth = (flags & RESPONSE_INFO_USE_HTTP_AUTHENTICATION) != 0;
  285. unused_since_prefetch = (flags & RESPONSE_INFO_UNUSED_SINCE_PREFETCH) != 0;
  286. restricted_prefetch = (flags & RESPONSE_INFO_RESTRICTED_PREFETCH) != 0;
  287. single_keyed_cache_entry_unusable =
  288. (flags & RESPONSE_INFO_SINGLE_KEYED_CACHE_ENTRY_UNUSABLE) != 0;
  289. ssl_info.pkp_bypassed = (flags & RESPONSE_INFO_PKP_BYPASSED) != 0;
  290. // Read peer_signature_algorithm.
  291. if (flags & RESPONSE_INFO_HAS_PEER_SIGNATURE_ALGORITHM) {
  292. int peer_signature_algorithm;
  293. if (!iter.ReadInt(&peer_signature_algorithm) ||
  294. !base::IsValueInRangeForNumericType<uint16_t>(
  295. peer_signature_algorithm)) {
  296. return false;
  297. }
  298. ssl_info.peer_signature_algorithm =
  299. base::checked_cast<uint16_t>(peer_signature_algorithm);
  300. }
  301. // Read DNS aliases.
  302. if (flags & RESPONSE_INFO_HAS_DNS_ALIASES) {
  303. int num_aliases;
  304. if (!iter.ReadInt(&num_aliases))
  305. return false;
  306. std::string alias;
  307. for (int i = 0; i < num_aliases; i++) {
  308. if (!iter.ReadString(&alias))
  309. return false;
  310. dns_aliases.insert(alias);
  311. }
  312. }
  313. ssl_info.encrypted_client_hello =
  314. (flags & RESPONSE_INFO_ENCRYPTED_CLIENT_HELLO) != 0;
  315. return true;
  316. }
  317. void HttpResponseInfo::Persist(base::Pickle* pickle,
  318. bool skip_transient_headers,
  319. bool response_truncated) const {
  320. int flags = RESPONSE_INFO_VERSION;
  321. if (ssl_info.is_valid()) {
  322. flags |= RESPONSE_INFO_HAS_CERT;
  323. flags |= RESPONSE_INFO_HAS_CERT_STATUS;
  324. if (ssl_info.key_exchange_group != 0)
  325. flags |= RESPONSE_INFO_HAS_KEY_EXCHANGE_GROUP;
  326. if (ssl_info.connection_status != 0)
  327. flags |= RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS;
  328. if (ssl_info.peer_signature_algorithm != 0)
  329. flags |= RESPONSE_INFO_HAS_PEER_SIGNATURE_ALGORITHM;
  330. }
  331. if (vary_data.is_valid())
  332. flags |= RESPONSE_INFO_HAS_VARY_DATA;
  333. if (response_truncated)
  334. flags |= RESPONSE_INFO_TRUNCATED;
  335. if (was_fetched_via_spdy)
  336. flags |= RESPONSE_INFO_WAS_SPDY;
  337. if (was_alpn_negotiated) {
  338. flags |= RESPONSE_INFO_WAS_ALPN;
  339. flags |= RESPONSE_INFO_HAS_ALPN_NEGOTIATED_PROTOCOL;
  340. }
  341. if (was_fetched_via_proxy)
  342. flags |= RESPONSE_INFO_WAS_PROXY;
  343. if (connection_info != CONNECTION_INFO_UNKNOWN)
  344. flags |= RESPONSE_INFO_HAS_CONNECTION_INFO;
  345. if (did_use_http_auth)
  346. flags |= RESPONSE_INFO_USE_HTTP_AUTHENTICATION;
  347. if (unused_since_prefetch)
  348. flags |= RESPONSE_INFO_UNUSED_SINCE_PREFETCH;
  349. if (restricted_prefetch)
  350. flags |= RESPONSE_INFO_RESTRICTED_PREFETCH;
  351. if (single_keyed_cache_entry_unusable)
  352. flags |= RESPONSE_INFO_SINGLE_KEYED_CACHE_ENTRY_UNUSABLE;
  353. if (ssl_info.pkp_bypassed)
  354. flags |= RESPONSE_INFO_PKP_BYPASSED;
  355. if (!stale_revalidate_timeout.is_null())
  356. flags |= RESPONSE_INFO_HAS_STALENESS;
  357. if (!dns_aliases.empty())
  358. flags |= RESPONSE_INFO_HAS_DNS_ALIASES;
  359. if (ssl_info.encrypted_client_hello)
  360. flags |= RESPONSE_INFO_ENCRYPTED_CLIENT_HELLO;
  361. pickle->WriteInt(flags);
  362. pickle->WriteInt64(request_time.ToInternalValue());
  363. pickle->WriteInt64(response_time.ToInternalValue());
  364. HttpResponseHeaders::PersistOptions persist_options =
  365. HttpResponseHeaders::PERSIST_RAW;
  366. if (skip_transient_headers) {
  367. persist_options = HttpResponseHeaders::PERSIST_SANS_COOKIES |
  368. HttpResponseHeaders::PERSIST_SANS_CHALLENGES |
  369. HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP |
  370. HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE |
  371. HttpResponseHeaders::PERSIST_SANS_RANGES |
  372. HttpResponseHeaders::PERSIST_SANS_SECURITY_STATE;
  373. }
  374. headers->Persist(pickle, persist_options);
  375. if (ssl_info.is_valid()) {
  376. ssl_info.cert->Persist(pickle);
  377. pickle->WriteUInt32(ssl_info.cert_status);
  378. if (ssl_info.connection_status != 0)
  379. pickle->WriteInt(ssl_info.connection_status);
  380. }
  381. if (vary_data.is_valid())
  382. vary_data.Persist(pickle);
  383. pickle->WriteString(remote_endpoint.ToStringWithoutPort());
  384. pickle->WriteUInt16(remote_endpoint.port());
  385. if (was_alpn_negotiated)
  386. pickle->WriteString(alpn_negotiated_protocol);
  387. if (connection_info != CONNECTION_INFO_UNKNOWN)
  388. pickle->WriteInt(static_cast<int>(connection_info));
  389. if (ssl_info.is_valid() && ssl_info.key_exchange_group != 0)
  390. pickle->WriteInt(ssl_info.key_exchange_group);
  391. if (flags & RESPONSE_INFO_HAS_STALENESS) {
  392. pickle->WriteInt64(
  393. (stale_revalidate_timeout - base::Time()).InMicroseconds());
  394. }
  395. if (ssl_info.is_valid() && ssl_info.peer_signature_algorithm != 0)
  396. pickle->WriteInt(ssl_info.peer_signature_algorithm);
  397. if (!dns_aliases.empty()) {
  398. pickle->WriteInt(dns_aliases.size());
  399. for (const auto& alias : dns_aliases)
  400. pickle->WriteString(alias);
  401. }
  402. }
  403. bool HttpResponseInfo::DidUseQuic() const {
  404. switch (connection_info) {
  405. case CONNECTION_INFO_UNKNOWN:
  406. case CONNECTION_INFO_HTTP1_1:
  407. case CONNECTION_INFO_DEPRECATED_SPDY2:
  408. case CONNECTION_INFO_DEPRECATED_SPDY3:
  409. case CONNECTION_INFO_HTTP2:
  410. case CONNECTION_INFO_DEPRECATED_HTTP2_14:
  411. case CONNECTION_INFO_DEPRECATED_HTTP2_15:
  412. case CONNECTION_INFO_HTTP0_9:
  413. case CONNECTION_INFO_HTTP1_0:
  414. return false;
  415. case CONNECTION_INFO_QUIC_UNKNOWN_VERSION:
  416. case CONNECTION_INFO_QUIC_32:
  417. case CONNECTION_INFO_QUIC_33:
  418. case CONNECTION_INFO_QUIC_34:
  419. case CONNECTION_INFO_QUIC_35:
  420. case CONNECTION_INFO_QUIC_36:
  421. case CONNECTION_INFO_QUIC_37:
  422. case CONNECTION_INFO_QUIC_38:
  423. case CONNECTION_INFO_QUIC_39:
  424. case CONNECTION_INFO_QUIC_40:
  425. case CONNECTION_INFO_QUIC_41:
  426. case CONNECTION_INFO_QUIC_42:
  427. case CONNECTION_INFO_QUIC_43:
  428. case CONNECTION_INFO_QUIC_44:
  429. case CONNECTION_INFO_QUIC_45:
  430. case CONNECTION_INFO_QUIC_46:
  431. case CONNECTION_INFO_QUIC_47:
  432. case CONNECTION_INFO_QUIC_Q048:
  433. case CONNECTION_INFO_QUIC_T048:
  434. case CONNECTION_INFO_QUIC_Q049:
  435. case CONNECTION_INFO_QUIC_T049:
  436. case CONNECTION_INFO_QUIC_Q050:
  437. case CONNECTION_INFO_QUIC_T050:
  438. case CONNECTION_INFO_QUIC_Q099:
  439. case CONNECTION_INFO_QUIC_T099:
  440. case CONNECTION_INFO_QUIC_999:
  441. case CONNECTION_INFO_QUIC_DRAFT_25:
  442. case CONNECTION_INFO_QUIC_DRAFT_27:
  443. case CONNECTION_INFO_QUIC_DRAFT_28:
  444. case CONNECTION_INFO_QUIC_DRAFT_29:
  445. case CONNECTION_INFO_QUIC_T051:
  446. case CONNECTION_INFO_QUIC_RFC_V1:
  447. case CONNECTION_INFO_QUIC_2_DRAFT_1:
  448. return true;
  449. case NUM_OF_CONNECTION_INFOS:
  450. NOTREACHED();
  451. return false;
  452. }
  453. NOTREACHED();
  454. return false;
  455. }
  456. // static
  457. std::string HttpResponseInfo::ConnectionInfoToString(
  458. ConnectionInfo connection_info) {
  459. switch (connection_info) {
  460. case CONNECTION_INFO_UNKNOWN:
  461. return "unknown";
  462. case CONNECTION_INFO_HTTP1_1:
  463. return "http/1.1";
  464. case CONNECTION_INFO_DEPRECATED_SPDY2:
  465. NOTREACHED();
  466. return "";
  467. case CONNECTION_INFO_DEPRECATED_SPDY3:
  468. return "spdy/3";
  469. // Since ConnectionInfo is persisted to disk, deprecated values have to be
  470. // handled. Note that h2-14 and h2-15 are essentially wire compatible with
  471. // h2.
  472. // Intentional fallthrough.
  473. case CONNECTION_INFO_DEPRECATED_HTTP2_14:
  474. case CONNECTION_INFO_DEPRECATED_HTTP2_15:
  475. case CONNECTION_INFO_HTTP2:
  476. return "h2";
  477. case CONNECTION_INFO_QUIC_UNKNOWN_VERSION:
  478. return "http/2+quic";
  479. case CONNECTION_INFO_QUIC_32:
  480. return "http/2+quic/32";
  481. case CONNECTION_INFO_QUIC_33:
  482. return "http/2+quic/33";
  483. case CONNECTION_INFO_QUIC_34:
  484. return "http/2+quic/34";
  485. case CONNECTION_INFO_QUIC_35:
  486. return "http/2+quic/35";
  487. case CONNECTION_INFO_QUIC_36:
  488. return "http/2+quic/36";
  489. case CONNECTION_INFO_QUIC_37:
  490. return "http/2+quic/37";
  491. case CONNECTION_INFO_QUIC_38:
  492. return "http/2+quic/38";
  493. case CONNECTION_INFO_QUIC_39:
  494. return "http/2+quic/39";
  495. case CONNECTION_INFO_QUIC_40:
  496. return "http/2+quic/40";
  497. case CONNECTION_INFO_QUIC_41:
  498. return "http/2+quic/41";
  499. case CONNECTION_INFO_QUIC_42:
  500. return "http/2+quic/42";
  501. case CONNECTION_INFO_QUIC_43:
  502. return "http/2+quic/43";
  503. case CONNECTION_INFO_QUIC_44:
  504. return "http/2+quic/44";
  505. case CONNECTION_INFO_QUIC_45:
  506. return "http/2+quic/45";
  507. case CONNECTION_INFO_QUIC_46:
  508. return "http/2+quic/46";
  509. case CONNECTION_INFO_QUIC_47:
  510. return "http/2+quic/47";
  511. case CONNECTION_INFO_QUIC_Q048:
  512. return "h3-Q048";
  513. case CONNECTION_INFO_QUIC_T048:
  514. return "h3-T048";
  515. case CONNECTION_INFO_QUIC_Q049:
  516. return "h3-Q049";
  517. case CONNECTION_INFO_QUIC_T049:
  518. return "h3-T049";
  519. case CONNECTION_INFO_QUIC_Q050:
  520. return "h3-Q050";
  521. case CONNECTION_INFO_QUIC_T050:
  522. return "h3-T050";
  523. case CONNECTION_INFO_QUIC_Q099:
  524. return "h3-Q099";
  525. case CONNECTION_INFO_QUIC_DRAFT_25:
  526. return "h3-25";
  527. case CONNECTION_INFO_QUIC_DRAFT_27:
  528. return "h3-27";
  529. case CONNECTION_INFO_QUIC_DRAFT_28:
  530. return "h3-28";
  531. case CONNECTION_INFO_QUIC_DRAFT_29:
  532. return "h3-29";
  533. case CONNECTION_INFO_QUIC_T099:
  534. return "h3-T099";
  535. case CONNECTION_INFO_HTTP0_9:
  536. return "http/0.9";
  537. case CONNECTION_INFO_HTTP1_0:
  538. return "http/1.0";
  539. case CONNECTION_INFO_QUIC_999:
  540. return "http2+quic/999";
  541. case CONNECTION_INFO_QUIC_T051:
  542. return "h3-T051";
  543. case CONNECTION_INFO_QUIC_RFC_V1:
  544. return "h3";
  545. case CONNECTION_INFO_QUIC_2_DRAFT_1:
  546. return "h3/quic2draft01";
  547. case NUM_OF_CONNECTION_INFOS:
  548. break;
  549. }
  550. NOTREACHED();
  551. return "";
  552. }
  553. } // namespace net