src/net/quic/quic_config.h

   1 // Copyright (c) 2013 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_QUIC_QUIC_CONFIG_H_
   6 #define NET_QUIC_QUIC_CONFIG_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "net/quic/quic_protocol.h"
  12 #include "net/quic/quic_time.h"
  13
  14 namespace net {
  15
  16 namespace test {
  17 class QuicConfigPeer;
  18 }  // namespace test
  19
  20 class CryptoHandshakeMessage;
  21
  22 // Describes whether or not a given QuicTag is required or optional in the
  23 // handshake message.
  24 enum QuicConfigPresence {
  25   // This negotiable value can be absent from the handshake message. Default
  26   // value is selected as the negotiated value in such a case.
  27   PRESENCE_OPTIONAL,
  28   // This negotiable value is required in the handshake message otherwise the
  29   // Process*Hello function returns an error.
  30   PRESENCE_REQUIRED,
  31 };
  32
  33 // Whether the CryptoHandshakeMessage is from the client or server.
  34 enum HelloType {
  35   CLIENT,
  36   SERVER,
  37 };
  38
  39 // An abstract base class that stores a value that can be sent in CHLO/SHLO
  40 // message. These values can be OPTIONAL or REQUIRED, depending on |presence_|.
  41 class NET_EXPORT_PRIVATE QuicConfigValue {
  42  public:
  43   QuicConfigValue(QuicTag tag, QuicConfigPresence presence);
  44   virtual ~QuicConfigValue();
  45
  46   // Serialises tag name and value(s) to |out|.
  47   virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const = 0;
  48
  49   // Selects a mutually acceptable value from those offered in |peer_hello|
  50   // and those defined in the subclass.
  51   virtual QuicErrorCode ProcessPeerHello(
  52       const CryptoHandshakeMessage& peer_hello,
  53       HelloType hello_type,
  54       std::string* error_details) = 0;
  55
  56  protected:
  57   const QuicTag tag_;
  58   const QuicConfigPresence presence_;
  59 };
  60
  61 class NET_EXPORT_PRIVATE QuicNegotiableValue : public QuicConfigValue {
  62  public:
  63   QuicNegotiableValue(QuicTag tag, QuicConfigPresence presence);
  64   ~QuicNegotiableValue() override;
  65
  66   bool negotiated() const {
  67     return negotiated_;
  68   }
  69
  70  protected:
  71   void set_negotiated(bool negotiated) { negotiated_ = negotiated; }
  72
  73  private:
  74   bool negotiated_;
  75 };
  76
  77 class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
  78  public:
  79   // Default and max values default to 0.
  80   QuicNegotiableUint32(QuicTag name, QuicConfigPresence presence);
  81   ~QuicNegotiableUint32() override;
  82
  83   // Sets the maximum possible value that can be achieved after negotiation and
  84   // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg
  85   // doesn't contain a value corresponding to |name_|. |max| is serialised via
  86   // ToHandshakeMessage call if |negotiated_| is false.
  87   void set(uint32 max, uint32 default_value);
  88
  89   // Returns the value negotiated if |negotiated_| is true, otherwise returns
  90   // default_value_ (used to set default values before negotiation finishes).
  91   uint32 GetUint32() const;
  92
  93   // Serialises |name_| and value to |out|. If |negotiated_| is true then
  94   // |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
  95   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
  96
  97   // Sets |negotiated_value_| to the minimum of |max_value_| and the
  98   // corresponding value from |peer_hello|. If the corresponding value is
  99   // missing and PRESENCE_OPTIONAL then |negotiated_value_| is set to
 100   // |default_value_|.
 101   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 102                                  HelloType hello_type,
 103                                  std::string* error_details) override;
 104
 105  private:
 106   uint32 max_value_;
 107   uint32 default_value_;
 108   uint32 negotiated_value_;
 109 };
 110
 111 class NET_EXPORT_PRIVATE QuicNegotiableTag : public QuicNegotiableValue {
 112  public:
 113   QuicNegotiableTag(QuicTag name, QuicConfigPresence presence);
 114   ~QuicNegotiableTag() override;
 115
 116   // Sets the possible values that |negotiated_tag_| can take after negotiation
 117   // and the default value that |negotiated_tag_| takes if OPTIONAL and *HLO
 118   // msg doesn't contain tag |name_|.
 119   void set(const QuicTagVector& possible_values, QuicTag default_value);
 120
 121   // Returns the negotiated tag if |negotiated_| is true, otherwise returns
 122   // |default_value_| (used to set default values before negotiation finishes).
 123   QuicTag GetTag() const;
 124
 125   // Serialises |name_| and vector (either possible or negotiated) to |out|. If
 126   // |negotiated_| is true then |negotiated_tag_| is serialised, otherwise
 127   // |possible_values_| is serialised.
 128   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 129
 130   // Selects the tag common to both tags in |client_hello| for |name_| and
 131   // |possible_values_| with preference to tag in |possible_values_|. The
 132   // selected tag is set as |negotiated_tag_|.
 133   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 134                                  HelloType hello_type,
 135                                  std::string* error_details) override;
 136
 137  private:
 138   // Reads the vector corresponding to |name_| from |msg| into |out|. If the
 139   // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set
 140   // to |possible_values_|.
 141   QuicErrorCode ReadVector(const CryptoHandshakeMessage& msg,
 142                            const QuicTag** out,
 143                            size_t* out_length,
 144                            std::string* error_details) const;
 145
 146   QuicTag negotiated_tag_;
 147   QuicTagVector possible_values_;
 148   QuicTag default_value_;
 149 };
 150
 151 // Stores uint32 from CHLO or SHLO messages that are not negotiated.
 152 class NET_EXPORT_PRIVATE QuicFixedUint32 : public QuicConfigValue {
 153  public:
 154   QuicFixedUint32(QuicTag name, QuicConfigPresence presence);
 155   ~QuicFixedUint32() override;
 156
 157   bool HasSendValue() const;
 158
 159   uint32 GetSendValue() const;
 160
 161   void SetSendValue(uint32 value);
 162
 163   bool HasReceivedValue() const;
 164
 165   uint32 GetReceivedValue() const;
 166
 167   void SetReceivedValue(uint32 value);
 168
 169   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
 170   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 171
 172   // Sets |value_| to the corresponding value from |peer_hello_| if it exists.
 173   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 174                                  HelloType hello_type,
 175                                  std::string* error_details) override;
 176
 177  private:
 178   uint32 send_value_;
 179   bool has_send_value_;
 180   uint32 receive_value_;
 181   bool has_receive_value_;
 182 };
 183
 184 // Stores tag from CHLO or SHLO messages that are not negotiated.
 185 class NET_EXPORT_PRIVATE QuicFixedTag : public QuicConfigValue {
 186  public:
 187   QuicFixedTag(QuicTag name, QuicConfigPresence presence);
 188   ~QuicFixedTag() override;
 189
 190   bool HasSendValue() const;
 191
 192   QuicTag GetSendValue() const;
 193
 194   void SetSendValue(QuicTag value);
 195
 196   bool HasReceivedValue() const;
 197
 198   QuicTag GetReceivedValue() const;
 199
 200   void SetReceivedValue(QuicTag value);
 201
 202   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
 203   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 204
 205   // Sets |value_| to the corresponding value from |client_hello_| if it exists.
 206   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 207                                  HelloType hello_type,
 208                                  std::string* error_details) override;
 209
 210  private:
 211   QuicTag send_value_;
 212   bool has_send_value_;
 213   QuicTag receive_value_;
 214   bool has_receive_value_;
 215 };
 216
 217 // Stores tag from CHLO or SHLO messages that are not negotiated.
 218 class NET_EXPORT_PRIVATE QuicFixedTagVector : public QuicConfigValue {
 219  public:
 220   QuicFixedTagVector(QuicTag name, QuicConfigPresence presence);
 221   ~QuicFixedTagVector() override;
 222
 223   bool HasSendValues() const;
 224
 225   QuicTagVector GetSendValues() const;
 226
 227   void SetSendValues(const QuicTagVector& values);
 228
 229   bool HasReceivedValues() const;
 230
 231   QuicTagVector GetReceivedValues() const;
 232
 233   void SetReceivedValues(const QuicTagVector& values);
 234
 235   // If has_send_value is true, serialises |tag_vector_| and |send_value_| to
 236   // |out|.
 237   void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 238
 239   // Sets |receive_values_| to the corresponding value from |client_hello_| if
 240   // it exists.
 241   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 242                                  HelloType hello_type,
 243                                  std::string* error_details) override;
 244
 245  private:
 246   QuicTagVector send_values_;
 247   bool has_send_values_;
 248   QuicTagVector receive_values_;
 249   bool has_receive_values_;
 250 };
 251
 252 // QuicConfig contains non-crypto configuration options that are negotiated in
 253 // the crypto handshake.
 254 class NET_EXPORT_PRIVATE QuicConfig {
 255  public:
 256   QuicConfig();
 257   ~QuicConfig();
 258
 259   void SetCongestionFeedback(const QuicTagVector& congestion_feedback,
 260                              QuicTag default_congestion_feedback);
 261
 262   QuicTag CongestionFeedback() const;
 263
 264   void SetConnectionOptionsToSend(const QuicTagVector& connection_options);
 265
 266   bool HasReceivedConnectionOptions() const;
 267
 268   QuicTagVector ReceivedConnectionOptions() const;
 269
 270   bool HasSendConnectionOptions() const;
 271
 272   QuicTagVector SendConnectionOptions() const;
 273
 274   void SetIdleConnectionStateLifetime(
 275       QuicTime::Delta max_idle_connection_state_lifetime,
 276       QuicTime::Delta default_idle_conection_state_lifetime);
 277
 278   QuicTime::Delta IdleConnectionStateLifetime() const;
 279
 280   QuicTime::Delta KeepaliveTimeout() const;
 281
 282   void SetMaxStreamsPerConnection(size_t max_streams, size_t default_streams);
 283
 284   uint32 MaxStreamsPerConnection() const;
 285
 286   void set_max_time_before_crypto_handshake(
 287       QuicTime::Delta max_time_before_crypto_handshake) {
 288     max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
 289   }
 290
 291   QuicTime::Delta max_time_before_crypto_handshake() const {
 292     return max_time_before_crypto_handshake_;
 293   }
 294
 295   void set_max_idle_time_before_crypto_handshake(
 296       QuicTime::Delta max_idle_time_before_crypto_handshake) {
 297     max_idle_time_before_crypto_handshake_ =
 298         max_idle_time_before_crypto_handshake;
 299   }
 300
 301   QuicTime::Delta max_idle_time_before_crypto_handshake() const {
 302     return max_idle_time_before_crypto_handshake_;
 303   }
 304
 305   void set_max_undecryptable_packets(size_t max_undecryptable_packets) {
 306     max_undecryptable_packets_ = max_undecryptable_packets;
 307   }
 308
 309   size_t max_undecryptable_packets() const {
 310     return max_undecryptable_packets_;
 311   }
 312
 313   bool HasSetBytesForConnectionIdToSend() const;
 314
 315   // Sets the peer's connection id length, in bytes.
 316   void SetBytesForConnectionIdToSend(uint32 bytes);
 317
 318   bool HasReceivedBytesForConnectionId() const;
 319
 320   uint32 ReceivedBytesForConnectionId() const;
 321
 322   // Sets the peer's default initial congestion window in packets.
 323   void SetInitialCongestionWindowToSend(size_t initial_window);
 324
 325   bool HasReceivedInitialCongestionWindow() const;
 326
 327   uint32 ReceivedInitialCongestionWindow() const;
 328
 329   // Sets an estimated initial round trip time in us.
 330   void SetInitialRoundTripTimeUsToSend(size_t rtt_us);
 331
 332   bool HasReceivedInitialRoundTripTimeUs() const;
 333
 334   uint32 ReceivedInitialRoundTripTimeUs() const;
 335
 336   bool HasInitialRoundTripTimeUsToSend() const;
 337
 338   uint32 GetInitialRoundTripTimeUsToSend() const;
 339
 340   // TODO(rjshade): Remove all InitialFlowControlWindow methods when removing
 341   // QUIC_VERSION_19.
 342   // Sets an initial stream flow control window size to transmit to the peer.
 343   void SetInitialFlowControlWindowToSend(uint32 window_bytes);
 344
 345   uint32 GetInitialFlowControlWindowToSend() const;
 346
 347   bool HasReceivedInitialFlowControlWindowBytes() const;
 348
 349   uint32 ReceivedInitialFlowControlWindowBytes() const;
 350
 351   // Sets an initial stream flow control window size to transmit to the peer.
 352   void SetInitialStreamFlowControlWindowToSend(uint32 window_bytes);
 353
 354   uint32 GetInitialStreamFlowControlWindowToSend() const;
 355
 356   bool HasReceivedInitialStreamFlowControlWindowBytes() const;
 357
 358   uint32 ReceivedInitialStreamFlowControlWindowBytes() const;
 359
 360   // Sets an initial session flow control window size to transmit to the peer.
 361   void SetInitialSessionFlowControlWindowToSend(uint32 window_bytes);
 362
 363   uint32 GetInitialSessionFlowControlWindowToSend() const;
 364
 365   bool HasReceivedInitialSessionFlowControlWindowBytes() const;
 366
 367   uint32 ReceivedInitialSessionFlowControlWindowBytes() const;
 368
 369   // Sets socket receive buffer to transmit to the peer.
 370   void SetSocketReceiveBufferToSend(uint32 window_bytes);
 371
 372   uint32 GetSocketReceiveBufferToSend() const;
 373
 374   bool HasReceivedSocketReceiveBuffer() const;
 375
 376   uint32 ReceivedSocketReceiveBuffer() const;
 377
 378   bool negotiated() const;
 379
 380   // ToHandshakeMessage serialises the settings in this object as a series of
 381   // tags /value pairs and adds them to |out|.
 382   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
 383
 384   // Calls ProcessPeerHello on each negotiable parameter. On failure returns
 385   // the corresponding QuicErrorCode and sets detailed error in |error_details|.
 386   QuicErrorCode ProcessPeerHello(const CryptoHandshakeMessage& peer_hello,
 387                                  HelloType hello_type,
 388                                  std::string* error_details);
 389
 390  private:
 391   friend class test::QuicConfigPeer;
 392
 393   // SetDefaults sets the members to sensible, default values.
 394   void SetDefaults();
 395
 396   // Configurations options that are not negotiated.
 397   // Maximum time the session can be alive before crypto handshake is finished.
 398   QuicTime::Delta max_time_before_crypto_handshake_;
 399   // Maximum idle time before the crypto handshake has completed.
 400   QuicTime::Delta max_idle_time_before_crypto_handshake_;
 401   // Maximum number of undecryptable packets stored before CHLO/SHLO.
 402   size_t max_undecryptable_packets_;
 403
 404   // Congestion control feedback type.
 405   QuicNegotiableTag congestion_feedback_;
 406   // Connection options.
 407   QuicFixedTagVector connection_options_;
 408   // Idle connection state lifetime
 409   QuicNegotiableUint32 idle_connection_state_lifetime_seconds_;
 410   // Keepalive timeout, or 0 to turn off keepalive probes
 411   QuicNegotiableUint32 keepalive_timeout_seconds_;
 412   // Maximum number of streams that the connection can support.
 413   QuicNegotiableUint32 max_streams_per_connection_;
 414   // The number of bytes required for the connection ID.
 415   QuicFixedUint32 bytes_for_connection_id_;
 416   // Initial congestion window in packets.
 417   QuicFixedUint32 initial_congestion_window_;
 418   // Initial round trip time estimate in microseconds.
 419   QuicFixedUint32 initial_round_trip_time_us_;
 420
 421   // TODO(rjshade): Remove when removing QUIC_VERSION_19.
 422   // Initial flow control receive window in bytes.
 423   QuicFixedUint32 initial_flow_control_window_bytes_;
 424
 425   // Initial stream flow control receive window in bytes.
 426   QuicFixedUint32 initial_stream_flow_control_window_bytes_;
 427   // Initial session flow control receive window in bytes.
 428   QuicFixedUint32 initial_session_flow_control_window_bytes_;
 429
 430   // Socket receive buffer in bytes.
 431   QuicFixedUint32 socket_receive_buffer_;
 432 };
 433
 434 }  // namespace net
 435
 436 #endif  // NET_QUIC_QUIC_CONFIG_H_