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/crypto/crypto_handshake.h"
  12 #include "net/quic/quic_protocol.h"
  13 #include "net/quic/quic_time.h"
  14 #include "net/quic/quic_utils.h"
  15
  16 namespace net {
  17
  18 class NET_EXPORT_PRIVATE QuicNegotiableValue {
  19  public:
  20   enum Presence {
  21     // This negotiable value can be absent from the handshake message. Default
  22     // value is selected as the negotiated value in such a case.
  23     PRESENCE_OPTIONAL,
  24     // This negotiable value is required in the handshake message otherwise the
  25     // Process*Hello function returns an error.
  26     PRESENCE_REQUIRED,
  27   };
  28
  29   QuicNegotiableValue(QuicTag tag, Presence presence);
  30
  31   bool negotiated() const {
  32     return negotiated_;
  33   }
  34
  35  protected:
  36   const QuicTag tag_;
  37   const Presence presence_;
  38   bool negotiated_;
  39 };
  40
  41 class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue {
  42  public:
  43   // Default and max values default to 0.
  44   QuicNegotiableUint32(QuicTag name, Presence presence);
  45
  46   // Sets the maximum possible value that can be achieved after negotiation and
  47   // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg
  48   // doesn't contain a value corresponding to |name_|. |max| is serialised via
  49   // ToHandshakeMessage call if |negotiated_| is false.
  50   void set(uint32 max, uint32 default_value);
  51
  52   // Returns the value negotiated if |negotiated_| is true, otherwise returns
  53   // default_value_ (used to set default values before negotiation finishes).
  54   uint32 GetUint32() const;
  55
  56   // Serialises |name_| and value to |out|. If |negotiated_| is true then
  57   // |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
  58   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
  59
  60   // Sets |negotiated_value_| to the minimum of |max_value_| and the
  61   // corresponding value from |client_hello|. If the corresponding value is
  62   // missing and PRESENCE_OPTIONAL then |negotiated_value_| is set to
  63   // |default_value_|.
  64   QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello,
  65                                    std::string* error_details);
  66
  67   // Sets the |negotiated_value_| to the corresponding value from
  68   // |server_hello|. Returns error if the value received in |server_hello| is
  69   // greater than |max_value_|. If the corresponding value is missing and
  70   // PRESENCE_OPTIONAL then |negotiated_value_| is set to |0|,
  71   QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello,
  72                                    std::string* error_details);
  73
  74  private:
  75   // Reads the value corresponding to |name_| from |msg| into |out|. If the
  76   // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set
  77   // to |max_value_|.
  78   QuicErrorCode ReadUint32(const CryptoHandshakeMessage& msg,
  79                            uint32* out,
  80                            std::string* error_details) const;
  81
  82   uint32 max_value_;
  83   uint32 default_value_;
  84   uint32 negotiated_value_;
  85 };
  86
  87 class NET_EXPORT_PRIVATE QuicNegotiableTag : public QuicNegotiableValue {
  88  public:
  89   QuicNegotiableTag(QuicTag name, Presence presence);
  90   ~QuicNegotiableTag();
  91
  92   // Sets the possible values that |negotiated_tag_| can take after negotiation
  93   // and the default value that |negotiated_tag_| takes if OPTIONAL and *HLO
  94   // msg doesn't contain tag |name_|.
  95   void set(const QuicTagVector& possible_values, QuicTag default_value);
  96
  97   // Returns the negotiated tag if |negotiated_| is true, otherwise returns
  98   // |default_value_| (used to set default values before negotiation finishes).
  99   QuicTag GetTag() const;
 100
 101   // Serialises |name_| and vector (either possible or negotiated) to |out|. If
 102   // |negotiated_| is true then |negotiated_tag_| is serialised, otherwise
 103   // |possible_values_| is serialised.
 104   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
 105
 106   // Selects the tag common to both tags in |client_hello| for |name_| and
 107   // |possible_values_| with preference to tag in |possible_values_|. The
 108   // selected tag is set as |negotiated_tag_|.
 109   QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello,
 110                                    std::string* error_details);
 111
 112   // Sets the value for |name_| tag in |server_hello| as |negotiated_value_|.
 113   // Returns error if the value received in |server_hello| isn't present in
 114   // |possible_values_|.
 115   QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello,
 116                                    std::string* error_details);
 117
 118  private:
 119   // Reads the vector corresponding to |name_| from |msg| into |out|. If the
 120   // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set
 121   // to |possible_values_|.
 122   QuicErrorCode ReadVector(const CryptoHandshakeMessage& msg,
 123                            const QuicTag** out,
 124                            size_t* out_length,
 125                            std::string* error_details) const;
 126
 127   QuicTag negotiated_tag_;
 128   QuicTagVector possible_values_;
 129   QuicTag default_value_;
 130 };
 131
 132 // QuicConfig contains non-crypto configuration options that are negotiated in
 133 // the crypto handshake.
 134 class NET_EXPORT_PRIVATE QuicConfig {
 135  public:
 136   QuicConfig();
 137   ~QuicConfig();
 138
 139   void set_congestion_control(const QuicTagVector& congestion_control,
 140                               QuicTag default_congestion_control);
 141
 142   QuicTag congestion_control() const;
 143
 144   void set_idle_connection_state_lifetime(
 145       QuicTime::Delta max_idle_connection_state_lifetime,
 146       QuicTime::Delta default_idle_conection_state_lifetime);
 147
 148   QuicTime::Delta idle_connection_state_lifetime() const;
 149
 150   QuicTime::Delta keepalive_timeout() const;
 151
 152   void set_max_streams_per_connection(size_t max_streams,
 153                                       size_t default_streams);
 154
 155   uint32 max_streams_per_connection() const;
 156
 157   void set_max_time_before_crypto_handshake(
 158       QuicTime::Delta max_time_before_crypto_handshake);
 159
 160   QuicTime::Delta max_time_before_crypto_handshake() const;
 161
 162   // Sets the server's TCP sender's max and default initial congestion window
 163   // in packets.
 164   void set_server_initial_congestion_window(size_t max_initial_window,
 165                                             size_t default_initial_window);
 166
 167   uint32 server_initial_congestion_window() const;
 168
 169   // Sets an estimated initial round trip time in us.
 170   void set_initial_round_trip_time_us(size_t max_rtt, size_t default_rtt);
 171
 172   uint32 initial_round_trip_time_us() const;
 173
 174   bool negotiated();
 175
 176   // SetDefaults sets the members to sensible, default values.
 177   void SetDefaults();
 178
 179   // ToHandshakeMessage serializes the settings in this object as a series of
 180   // tags /value pairs and adds them to |out|.
 181   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
 182
 183   // Calls ProcessClientHello on each negotiable parameter. On failure returns
 184   // the corresponding QuicErrorCode and sets detailed error in |error_details|.
 185   QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello,
 186                                    std::string* error_details);
 187
 188   // Calls ProcessServerHello on each negotiable parameter. On failure returns
 189   // the corresponding QuicErrorCode and sets detailed error in |error_details|.
 190   QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello,
 191                                    std::string* error_details);
 192
 193  private:
 194   // Congestion control feedback type.
 195   QuicNegotiableTag congestion_control_;
 196   // Idle connection state lifetime
 197   QuicNegotiableUint32 idle_connection_state_lifetime_seconds_;
 198   // Keepalive timeout, or 0 to turn off keepalive probes
 199   QuicNegotiableUint32 keepalive_timeout_seconds_;
 200   // Maximum number of streams that the connection can support.
 201   QuicNegotiableUint32 max_streams_per_connection_;
 202   // Maximum time till the session can be alive before crypto handshake is
 203   // finished. (Not negotiated).
 204   QuicTime::Delta max_time_before_crypto_handshake_;
 205   // Initial congestion window in packets.
 206   QuicNegotiableUint32 server_initial_congestion_window_;
 207   // Initial round trip time estimate in microseconds.
 208   QuicNegotiableUint32 initial_round_trip_time_us_;
 209 };
 210
 211 }  // namespace net
 212
 213 #endif  // NET_QUIC_QUIC_CONFIG_H_