| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef NET_QUIC_QUIC_CONFIG_H_ |
| #define NET_QUIC_QUIC_CONFIG_H_ |
| |
| #include <string> |
| |
| #include "base/basictypes.h" |
| #include "net/quic/crypto/crypto_handshake.h" |
| #include "net/quic/quic_protocol.h" |
| #include "net/quic/quic_time.h" |
| #include "net/quic/quic_utils.h" |
| |
| namespace net { |
| |
| class NET_EXPORT_PRIVATE QuicNegotiableValue { |
| public: |
| enum Presence { |
| // This negotiable value can be absent from the handshake message. Default |
| // value is selected as the negotiated value in such a case. |
| PRESENCE_OPTIONAL, |
| // This negotiable value is required in the handshake message otherwise the |
| // Process*Hello function returns an error. |
| PRESENCE_REQUIRED, |
| }; |
| |
| QuicNegotiableValue(QuicTag tag, Presence presence); |
| |
| bool negotiated() const { |
| return negotiated_; |
| } |
| |
| protected: |
| const QuicTag tag_; |
| const Presence presence_; |
| bool negotiated_; |
| }; |
| |
| class NET_EXPORT_PRIVATE QuicNegotiableUint32 : public QuicNegotiableValue { |
| public: |
| // Default and max values default to 0. |
| QuicNegotiableUint32(QuicTag name, Presence presence); |
| |
| // Sets the maximum possible value that can be achieved after negotiation and |
| // also the default values to be assumed if PRESENCE_OPTIONAL and the *HLO msg |
| // doesn't contain a value corresponding to |name_|. |max| is serialised via |
| // ToHandshakeMessage call if |negotiated_| is false. |
| void set(uint32 max, uint32 default_value); |
| |
| // Returns the value negotiated if |negotiated_| is true, otherwise returns |
| // default_value_ (used to set default values before negotiation finishes). |
| uint32 GetUint32() const; |
| |
| // Serialises |name_| and value to |out|. If |negotiated_| is true then |
| // |negotiated_value_| is serialised, otherwise |max_value_| is serialised. |
| void ToHandshakeMessage(CryptoHandshakeMessage* out) const; |
| |
| // Sets |negotiated_value_| to the minimum of |max_value_| and the |
| // corresponding value from |client_hello|. If the corresponding value is |
| // missing and PRESENCE_OPTIONAL then |negotiated_value_| is set to |
| // |default_value_|. |
| QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello, |
| std::string* error_details); |
| |
| // Sets the |negotiated_value_| to the corresponding value from |
| // |server_hello|. Returns error if the value received in |server_hello| is |
| // greater than |max_value_|. If the corresponding value is missing and |
| // PRESENCE_OPTIONAL then |negotiated_value_| is set to |0|, |
| QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello, |
| std::string* error_details); |
| |
| private: |
| // Reads the value corresponding to |name_| from |msg| into |out|. If the |
| // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set |
| // to |max_value_|. |
| QuicErrorCode ReadUint32(const CryptoHandshakeMessage& msg, |
| uint32* out, |
| std::string* error_details) const; |
| |
| uint32 max_value_; |
| uint32 default_value_; |
| uint32 negotiated_value_; |
| }; |
| |
| class NET_EXPORT_PRIVATE QuicNegotiableTag : public QuicNegotiableValue { |
| public: |
| QuicNegotiableTag(QuicTag name, Presence presence); |
| ~QuicNegotiableTag(); |
| |
| // Sets the possible values that |negotiated_tag_| can take after negotiation |
| // and the default value that |negotiated_tag_| takes if OPTIONAL and *HLO |
| // msg doesn't contain tag |name_|. |
| void set(const QuicTagVector& possible_values, QuicTag default_value); |
| |
| // Returns the negotiated tag if |negotiated_| is true, otherwise returns |
| // |default_value_| (used to set default values before negotiation finishes). |
| QuicTag GetTag() const; |
| |
| // Serialises |name_| and vector (either possible or negotiated) to |out|. If |
| // |negotiated_| is true then |negotiated_tag_| is serialised, otherwise |
| // |possible_values_| is serialised. |
| void ToHandshakeMessage(CryptoHandshakeMessage* out) const; |
| |
| // Selects the tag common to both tags in |client_hello| for |name_| and |
| // |possible_values_| with preference to tag in |possible_values_|. The |
| // selected tag is set as |negotiated_tag_|. |
| QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello, |
| std::string* error_details); |
| |
| // Sets the value for |name_| tag in |server_hello| as |negotiated_value_|. |
| // Returns error if the value received in |server_hello| isn't present in |
| // |possible_values_|. |
| QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello, |
| std::string* error_details); |
| |
| private: |
| // Reads the vector corresponding to |name_| from |msg| into |out|. If the |
| // |name_| is absent in |msg| and |presence_| is set to OPTIONAL |out| is set |
| // to |possible_values_|. |
| QuicErrorCode ReadVector(const CryptoHandshakeMessage& msg, |
| const QuicTag** out, |
| size_t* out_length, |
| std::string* error_details) const; |
| |
| QuicTag negotiated_tag_; |
| QuicTagVector possible_values_; |
| QuicTag default_value_; |
| }; |
| |
| // QuicConfig contains non-crypto configuration options that are negotiated in |
| // the crypto handshake. |
| class NET_EXPORT_PRIVATE QuicConfig { |
| public: |
| QuicConfig(); |
| ~QuicConfig(); |
| |
| void set_congestion_control(const QuicTagVector& congestion_control, |
| QuicTag default_congestion_control); |
| |
| QuicTag congestion_control() const; |
| |
| void set_idle_connection_state_lifetime( |
| QuicTime::Delta max_idle_connection_state_lifetime, |
| QuicTime::Delta default_idle_conection_state_lifetime); |
| |
| QuicTime::Delta idle_connection_state_lifetime() const; |
| |
| QuicTime::Delta keepalive_timeout() const; |
| |
| void set_max_streams_per_connection(size_t max_streams, |
| size_t default_streams); |
| |
| uint32 max_streams_per_connection() const; |
| |
| void set_max_time_before_crypto_handshake( |
| QuicTime::Delta max_time_before_crypto_handshake); |
| |
| QuicTime::Delta max_time_before_crypto_handshake() const; |
| |
| // Sets the server's TCP sender's max and default initial congestion window |
| // in packets. |
| void set_server_initial_congestion_window(size_t max_initial_window, |
| size_t default_initial_window); |
| |
| uint32 server_initial_congestion_window() const; |
| |
| // Sets an estimated initial round trip time in us. |
| void set_initial_round_trip_time_us(size_t max_rtt, size_t default_rtt); |
| |
| uint32 initial_round_trip_time_us() const; |
| |
| bool negotiated(); |
| |
| // SetDefaults sets the members to sensible, default values. |
| void SetDefaults(); |
| |
| // ToHandshakeMessage serializes the settings in this object as a series of |
| // tags /value pairs and adds them to |out|. |
| void ToHandshakeMessage(CryptoHandshakeMessage* out) const; |
| |
| // Calls ProcessClientHello on each negotiable parameter. On failure returns |
| // the corresponding QuicErrorCode and sets detailed error in |error_details|. |
| QuicErrorCode ProcessClientHello(const CryptoHandshakeMessage& client_hello, |
| std::string* error_details); |
| |
| // Calls ProcessServerHello on each negotiable parameter. On failure returns |
| // the corresponding QuicErrorCode and sets detailed error in |error_details|. |
| QuicErrorCode ProcessServerHello(const CryptoHandshakeMessage& server_hello, |
| std::string* error_details); |
| |
| private: |
| // Congestion control feedback type. |
| QuicNegotiableTag congestion_control_; |
| // Idle connection state lifetime |
| QuicNegotiableUint32 idle_connection_state_lifetime_seconds_; |
| // Keepalive timeout, or 0 to turn off keepalive probes |
| QuicNegotiableUint32 keepalive_timeout_seconds_; |
| // Maximum number of streams that the connection can support. |
| QuicNegotiableUint32 max_streams_per_connection_; |
| // Maximum time till the session can be alive before crypto handshake is |
| // finished. (Not negotiated). |
| QuicTime::Delta max_time_before_crypto_handshake_; |
| // Initial congestion window in packets. |
| QuicNegotiableUint32 server_initial_congestion_window_; |
| // Initial round trip time estimate in microseconds. |
| QuicNegotiableUint32 initial_round_trip_time_us_; |
| }; |
| |
| } // namespace net |
| |
| #endif // NET_QUIC_QUIC_CONFIG_H_ |