net/http/http_server_properties.h

   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 #ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_H_
   6 #define NET_HTTP_HTTP_SERVER_PROPERTIES_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include "base/basictypes.h"
  11 #include "base/containers/mru_cache.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/time/time.h"
  14 #include "net/base/host_port_pair.h"
  15 #include "net/base/net_export.h"
  16 #include "net/base/net_util.h"
  17 #include "net/quic/quic_bandwidth.h"
  18 #include "net/socket/next_proto.h"
  19 #include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
  20 #include "net/spdy/spdy_protocol.h"
  21
  22 namespace base {
  23 class Value;
  24 }
  25
  26 namespace net {
  27
  28 struct SSLConfig;
  29
  30 enum AlternateProtocolUsage {
  31   // Alternate Protocol was used without racing a normal connection.
  32   ALTERNATE_PROTOCOL_USAGE_NO_RACE = 0,
  33   // Alternate Protocol was used by winning a race with a normal connection.
  34   ALTERNATE_PROTOCOL_USAGE_WON_RACE = 1,
  35   // Alternate Protocol was not used by losing a race with a normal connection.
  36   ALTERNATE_PROTOCOL_USAGE_LOST_RACE = 2,
  37   // Alternate Protocol was not used because no Alternate-Protocol information
  38   // was available when the request was issued, but an Alternate-Protocol header
  39   // was present in the response.
  40   ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING = 3,
  41   // Alternate Protocol was not used because it was marked broken.
  42   ALTERNATE_PROTOCOL_USAGE_BROKEN = 4,
  43   // Maximum value for the enum.
  44   ALTERNATE_PROTOCOL_USAGE_MAX,
  45 };
  46
  47 // Log a histogram to reflect |usage|.
  48 NET_EXPORT void HistogramAlternateProtocolUsage(AlternateProtocolUsage usage);
  49
  50 enum BrokenAlternateProtocolLocation {
  51   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB = 0,
  52   BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY = 1,
  53   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT = 2,
  54   BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN = 3,
  55   BROKEN_ALTERNATE_PROTOCOL_LOCATION_MAX,
  56 };
  57
  58 // Log a histogram to reflect |location|.
  59 NET_EXPORT void HistogramBrokenAlternateProtocolLocation(
  60     BrokenAlternateProtocolLocation location);
  61
  62 enum AlternateProtocol {
  63   DEPRECATED_NPN_SPDY_2 = 0,
  64   ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION = DEPRECATED_NPN_SPDY_2,
  65   NPN_SPDY_MINIMUM_VERSION = DEPRECATED_NPN_SPDY_2,
  66   NPN_SPDY_3,
  67   NPN_SPDY_3_1,
  68   NPN_SPDY_4_14,  // HTTP/2 draft-14
  69   NPN_SPDY_4,     // HTTP/2
  70   NPN_SPDY_MAXIMUM_VERSION = NPN_SPDY_4,
  71   QUIC,
  72   ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION = QUIC,
  73   UNINITIALIZED_ALTERNATE_PROTOCOL,
  74 };
  75
  76 // Simply returns whether |protocol| is between
  77 // ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION and
  78 // ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION (inclusive).
  79 NET_EXPORT bool IsAlternateProtocolValid(AlternateProtocol protocol);
  80
  81 enum AlternateProtocolSize {
  82   NUM_VALID_ALTERNATE_PROTOCOLS =
  83     ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION -
  84     ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION + 1,
  85 };
  86
  87 NET_EXPORT const char* AlternateProtocolToString(AlternateProtocol protocol);
  88 NET_EXPORT AlternateProtocol AlternateProtocolFromString(
  89     const std::string& str);
  90 NET_EXPORT_PRIVATE AlternateProtocol AlternateProtocolFromNextProto(
  91     NextProto next_proto);
  92
  93 // (protocol, host, port) triple as defined in
  94 // https://tools.ietf.org/id/draft-ietf-httpbis-alt-svc-06.html
  95 struct NET_EXPORT AlternativeService {
  96   AlternativeService()
  97       : protocol(UNINITIALIZED_ALTERNATE_PROTOCOL), host(), port(0) {}
  98
  99   AlternativeService(AlternateProtocol protocol,
 100                      const std::string& host,
 101                      uint16 port)
 102       : protocol(protocol), host(host), port(port) {}
 103
 104   AlternativeService(AlternateProtocol protocol,
 105                      const HostPortPair& host_port_pair)
 106       : protocol(protocol),
 107         host(host_port_pair.host()),
 108         port(host_port_pair.port()) {}
 109
 110   AlternativeService(const AlternativeService& alternative_service) = default;
 111   AlternativeService& operator=(const AlternativeService& alternative_service) =
 112       default;
 113
 114   HostPortPair host_port_pair() const { return HostPortPair(host, port); }
 115
 116   bool operator==(const AlternativeService& other) const {
 117     return protocol == other.protocol && host == other.host &&
 118            port == other.port;
 119   }
 120
 121   bool operator!=(const AlternativeService& other) const {
 122     return !this->operator==(other);
 123   }
 124
 125   bool operator<(const AlternativeService& other) const {
 126     if (protocol != other.protocol)
 127       return protocol < other.protocol;
 128     if (host != other.host)
 129       return host < other.host;
 130     return port < other.port;
 131   }
 132
 133   std::string ToString() const;
 134
 135   AlternateProtocol protocol;
 136   std::string host;
 137   uint16 port;
 138 };
 139
 140 struct NET_EXPORT AlternativeServiceInfo {
 141   AlternativeServiceInfo() : alternative_service(), probability(0.0) {}
 142
 143   AlternativeServiceInfo(const AlternativeService& alternative_service,
 144                          double probability)
 145       : alternative_service(alternative_service), probability(probability) {}
 146
 147   AlternativeServiceInfo(AlternateProtocol protocol,
 148                          const std::string& host,
 149                          uint16 port,
 150                          double probability)
 151       : alternative_service(protocol, host, port), probability(probability) {}
 152
 153   AlternativeServiceInfo(
 154       const AlternativeServiceInfo& alternative_service_info) = default;
 155   AlternativeServiceInfo& operator=(
 156       const AlternativeServiceInfo& alternative_service_info) = default;
 157
 158   bool operator==(const AlternativeServiceInfo& other) const {
 159     return alternative_service == other.alternative_service &&
 160            probability == other.probability;
 161   }
 162
 163   bool operator!=(const AlternativeServiceInfo& other) const {
 164     return !this->operator==(other);
 165   }
 166
 167   std::string ToString() const;
 168
 169   AlternativeService alternative_service;
 170   double probability;
 171 };
 172
 173 struct NET_EXPORT SupportsQuic {
 174   SupportsQuic() : used_quic(false) {}
 175   SupportsQuic(bool used_quic, const std::string& address)
 176       : used_quic(used_quic),
 177         address(address) {}
 178
 179   bool Equals(const SupportsQuic& other) const {
 180     return used_quic == other.used_quic && address == other.address;
 181   }
 182
 183   bool used_quic;
 184   std::string address;
 185 };
 186
 187 struct NET_EXPORT ServerNetworkStats {
 188   ServerNetworkStats() : bandwidth_estimate(QuicBandwidth::Zero()) {}
 189
 190   bool operator==(const ServerNetworkStats& other) const {
 191     return srtt == other.srtt && bandwidth_estimate == other.bandwidth_estimate;
 192   }
 193
 194   bool operator!=(const ServerNetworkStats& other) const {
 195     return !this->operator==(other);
 196   }
 197
 198   base::TimeDelta srtt;
 199   QuicBandwidth bandwidth_estimate;
 200 };
 201
 202 typedef base::MRUCache<HostPortPair, AlternativeServiceInfo>
 203     AlternativeServiceMap;
 204 typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
 205 typedef base::MRUCache<HostPortPair, ServerNetworkStats> ServerNetworkStatsMap;
 206
 207 extern const char kAlternateProtocolHeader[];
 208
 209 // The interface for setting/retrieving the HTTP server properties.
 210 // Currently, this class manages servers':
 211 // * SPDY support (based on NPN results)
 212 // * alternative service support
 213 // * Spdy Settings (like CWND ID field)
 214 class NET_EXPORT HttpServerProperties {
 215  public:
 216   HttpServerProperties() {}
 217   virtual ~HttpServerProperties() {}
 218
 219   // Gets a weak pointer for this object.
 220   virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
 221
 222   // Deletes all data.
 223   virtual void Clear() = 0;
 224
 225   // Returns true if |server| supports a network protocol which honors
 226   // request prioritization.
 227   virtual bool SupportsRequestPriority(const HostPortPair& server) = 0;
 228
 229   // Returns the value set by SetSupportsSpdy(). If not set, returns false.
 230   virtual bool GetSupportsSpdy(const HostPortPair& server) = 0;
 231
 232   // Add |server| into the persistent store. Should only be called from IO
 233   // thread.
 234   virtual void SetSupportsSpdy(const HostPortPair& server,
 235                                bool support_spdy) = 0;
 236
 237   // Returns true if |server| has required HTTP/1.1 via HTTP/2 error code.
 238   virtual bool RequiresHTTP11(const HostPortPair& server) = 0;
 239
 240   // Require HTTP/1.1 on subsequent connections.  Not persisted.
 241   virtual void SetHTTP11Required(const HostPortPair& server) = 0;
 242
 243   // Modify SSLConfig to force HTTP/1.1.
 244   static void ForceHTTP11(SSLConfig* ssl_config);
 245
 246   // Modify SSLConfig to force HTTP/1.1 if necessary.
 247   virtual void MaybeForceHTTP11(const HostPortPair& server,
 248                                 SSLConfig* ssl_config) = 0;
 249
 250   // Returns the alternative service for |origin| if it has probability equal to
 251   // or exceeding threshold, or else the forced AlternateProtocol if there is
 252   // one, or else one with UNINITIALIZED_ALTERNATE_PROTOCOL.
 253   virtual AlternativeService GetAlternativeService(
 254       const HostPortPair& origin) = 0;
 255
 256   // Sets the alternative service for |origin|.
 257   virtual void SetAlternativeService(
 258       const HostPortPair& origin,
 259       const AlternativeService& alternative_service,
 260       double alternative_probability) = 0;
 261
 262   // Marks |alternative_service| as broken.
 263   virtual void MarkAlternativeServiceBroken(
 264       const AlternativeService& alternative_service) = 0;
 265
 266   // Marks |alternative_service| as recently broken.
 267   virtual void MarkAlternativeServiceRecentlyBroken(
 268       const AlternativeService& alternative_service) = 0;
 269
 270   // Returns true iff |alternative_service| is currently broken.
 271   virtual bool IsAlternativeServiceBroken(
 272       const AlternativeService& alternative_service) const = 0;
 273
 274   // Returns true iff |alternative_service| was recently broken.
 275   virtual bool WasAlternativeServiceRecentlyBroken(
 276       const AlternativeService& alternative_service) = 0;
 277
 278   // Confirms that |alternative_service| is working.
 279   virtual void ConfirmAlternativeService(
 280       const AlternativeService& alternative_service) = 0;
 281
 282   // Clears the alternative service for |origin|.
 283   virtual void ClearAlternativeService(const HostPortPair& origin) = 0;
 284
 285   // Returns all alternative service mappings.
 286   virtual const AlternativeServiceMap& alternative_service_map() const = 0;
 287
 288   // Returns all alternative service mappings as human readable strings.
 289   virtual scoped_ptr<base::Value> GetAlternativeServiceInfoAsValue() const = 0;
 290
 291   // Sets the threshold to be used when evaluating alternative service
 292   // advertisments. Only advertisements with a probability greater than or equal
 293   // to |threshold| will be honored. |threshold| must be between 0.0 and 1.0
 294   // inclusive. Hence, a threshold of 0.0 implies that all advertisements will
 295   // be honored.
 296   virtual void SetAlternativeServiceProbabilityThreshold(double threshold) = 0;
 297
 298   // Gets a reference to the SettingsMap stored for a host.
 299   // If no settings are stored, returns an empty SettingsMap.
 300   virtual const SettingsMap& GetSpdySettings(
 301       const HostPortPair& host_port_pair) = 0;
 302
 303   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
 304   // is to be persisted.
 305   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
 306                               SpdySettingsIds id,
 307                               SpdySettingsFlags flags,
 308                               uint32 value) = 0;
 309
 310   // Clears all SPDY settings for a host.
 311   virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
 312
 313   // Clears all SPDY settings for all hosts.
 314   virtual void ClearAllSpdySettings() = 0;
 315
 316   // Returns all persistent SPDY settings.
 317   virtual const SpdySettingsMap& spdy_settings_map() const = 0;
 318
 319   virtual bool GetSupportsQuic(IPAddressNumber* last_address) const = 0;
 320
 321   virtual void SetSupportsQuic(bool used_quic,
 322                                const IPAddressNumber& last_address) = 0;
 323
 324   // Sets |stats| for |host_port_pair|.
 325   virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
 326                                      ServerNetworkStats stats) = 0;
 327
 328   virtual const ServerNetworkStats* GetServerNetworkStats(
 329       const HostPortPair& host_port_pair) = 0;
 330
 331   virtual const ServerNetworkStatsMap& server_network_stats_map() const = 0;
 332
 333  private:
 334   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 335 };
 336
 337 }  // namespace net
 338
 339 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_