net/quic/quic_config.cc

   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 #include "net/quic/quic_config.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "net/quic/quic_sent_packet_manager.h"
  11
  12 using std::string;
  13
  14 namespace net {
  15
  16 QuicNegotiableValue::QuicNegotiableValue(QuicTag tag, Presence presence)
  17     : tag_(tag),
  18       presence_(presence),
  19       negotiated_(false) {
  20 }
  21
  22 QuicNegotiableUint32::QuicNegotiableUint32(QuicTag tag, Presence presence)
  23     : QuicNegotiableValue(tag, presence),
  24       max_value_(0),
  25       default_value_(0) {
  26 }
  27
  28 void QuicNegotiableUint32::set(uint32 max, uint32 default_value) {
  29   DCHECK_LE(default_value, max);
  30   max_value_ = max;
  31   default_value_ = default_value;
  32 }
  33
  34 uint32 QuicNegotiableUint32::GetUint32() const {
  35   if (negotiated_) {
  36     return negotiated_value_;
  37   }
  38   return default_value_;
  39 }
  40
  41 void QuicNegotiableUint32::ToHandshakeMessage(
  42     CryptoHandshakeMessage* out) const {
  43   if (negotiated_) {
  44     out->SetValue(tag_, negotiated_value_);
  45   } else {
  46     out->SetValue(tag_, max_value_);
  47   }
  48 }
  49
  50 QuicErrorCode QuicNegotiableUint32::ReadUint32(
  51     const CryptoHandshakeMessage& msg,
  52     uint32* out,
  53     string* error_details) const {
  54   DCHECK(error_details != NULL);
  55   QuicErrorCode error = msg.GetUint32(tag_, out);
  56   switch (error) {
  57     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
  58       if (presence_ == QuicNegotiableValue::PRESENCE_REQUIRED) {
  59         *error_details = "Missing " + QuicUtils::TagToString(tag_);
  60         break;
  61       }
  62       error = QUIC_NO_ERROR;
  63       *out = default_value_;
  64
  65     case QUIC_NO_ERROR:
  66       break;
  67     default:
  68       *error_details = "Bad " + QuicUtils::TagToString(tag_);
  69       break;
  70   }
  71   return error;
  72 }
  73
  74 QuicErrorCode QuicNegotiableUint32::ProcessClientHello(
  75     const CryptoHandshakeMessage& client_hello,
  76     string* error_details) {
  77   DCHECK(!negotiated_);
  78   DCHECK(error_details != NULL);
  79   uint32 value;
  80   QuicErrorCode error = ReadUint32(client_hello, &value, error_details);
  81   if (error != QUIC_NO_ERROR) {
  82     return error;
  83   }
  84
  85   negotiated_ = true;
  86   negotiated_value_ = std::min(value, max_value_);
  87
  88   return QUIC_NO_ERROR;
  89 }
  90
  91 QuicErrorCode QuicNegotiableUint32::ProcessServerHello(
  92     const CryptoHandshakeMessage& server_hello,
  93     string* error_details) {
  94   DCHECK(!negotiated_);
  95   DCHECK(error_details != NULL);
  96   uint32 value;
  97   QuicErrorCode error = ReadUint32(server_hello, &value, error_details);
  98   if (error != QUIC_NO_ERROR) {
  99     return error;
 100   }
 101
 102   if (value > max_value_) {
 103     *error_details = "Invalid value received for " +
 104         QuicUtils::TagToString(tag_);
 105     return QUIC_INVALID_NEGOTIATED_VALUE;
 106   }
 107
 108   negotiated_ = true;
 109   negotiated_value_ = value;
 110   return QUIC_NO_ERROR;
 111 }
 112
 113 QuicNegotiableTag::QuicNegotiableTag(QuicTag tag, Presence presence)
 114     : QuicNegotiableValue(tag, presence),
 115       negotiated_tag_(0),
 116       default_value_(0) {
 117 }
 118
 119 QuicNegotiableTag::~QuicNegotiableTag() {}
 120
 121 void QuicNegotiableTag::set(const QuicTagVector& possible,
 122                             QuicTag default_value) {
 123   DCHECK(std::find(possible.begin(), possible.end(), default_value) !=
 124             possible.end());
 125   possible_values_ = possible;
 126   default_value_ = default_value;
 127 }
 128
 129 QuicTag QuicNegotiableTag::GetTag() const {
 130   if (negotiated_) {
 131     return negotiated_tag_;
 132   }
 133   return default_value_;
 134 }
 135
 136 void QuicNegotiableTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 137   if (negotiated_) {
 138     // Because of the way we serialize and parse handshake messages we can
 139     // serialize this as value and still parse it as a vector.
 140     out->SetValue(tag_, negotiated_tag_);
 141   } else {
 142     out->SetVector(tag_, possible_values_);
 143   }
 144 }
 145
 146 QuicErrorCode QuicNegotiableTag::ReadVector(
 147     const CryptoHandshakeMessage& msg,
 148     const QuicTag** out,
 149     size_t* out_length,
 150     string* error_details) const {
 151   DCHECK(error_details != NULL);
 152   QuicErrorCode error = msg.GetTaglist(tag_, out, out_length);
 153   switch (error) {
 154     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
 155       if (presence_ == PRESENCE_REQUIRED) {
 156         *error_details = "Missing " + QuicUtils::TagToString(tag_);
 157         break;
 158       }
 159       error = QUIC_NO_ERROR;
 160       *out_length = 1;
 161       *out = &default_value_;
 162
 163     case QUIC_NO_ERROR:
 164       break;
 165     default:
 166       *error_details = "Bad " + QuicUtils::TagToString(tag_);
 167       break;
 168   }
 169   return error;
 170 }
 171
 172 QuicErrorCode QuicNegotiableTag::ProcessClientHello(
 173     const CryptoHandshakeMessage& client_hello,
 174     string* error_details) {
 175   DCHECK(!negotiated_);
 176   DCHECK(error_details != NULL);
 177   const QuicTag* received_tags;
 178   size_t received_tags_length;
 179   QuicErrorCode error = ReadVector(client_hello, &received_tags,
 180                                    &received_tags_length, error_details);
 181   if (error != QUIC_NO_ERROR) {
 182     return error;
 183   }
 184
 185   QuicTag negotiated_tag;
 186   if (!QuicUtils::FindMutualTag(possible_values_,
 187                                 received_tags,
 188                                 received_tags_length,
 189                                 QuicUtils::LOCAL_PRIORITY,
 190                                 &negotiated_tag,
 191                                 NULL)) {
 192     *error_details = "Unsuported " + QuicUtils::TagToString(tag_);
 193     return QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP;
 194   }
 195
 196   negotiated_ = true;
 197   negotiated_tag_ = negotiated_tag;
 198   return QUIC_NO_ERROR;
 199 }
 200
 201 QuicErrorCode QuicNegotiableTag::ProcessServerHello(
 202     const CryptoHandshakeMessage& server_hello,
 203     string* error_details) {
 204   DCHECK(!negotiated_);
 205   DCHECK(error_details != NULL);
 206   const QuicTag* received_tags;
 207   size_t received_tags_length;
 208   QuicErrorCode error = ReadVector(server_hello, &received_tags,
 209                                    &received_tags_length, error_details);
 210   if (error != QUIC_NO_ERROR) {
 211     return error;
 212   }
 213
 214   if (received_tags_length != 1 ||
 215       std::find(possible_values_.begin(), possible_values_.end(),
 216                 *received_tags) == possible_values_.end()) {
 217     *error_details = "Invalid " + QuicUtils::TagToString(tag_);
 218     return QUIC_INVALID_NEGOTIATED_VALUE;
 219   }
 220
 221   negotiated_ = true;
 222   negotiated_tag_ = *received_tags;
 223   return QUIC_NO_ERROR;
 224 }
 225
 226 QuicConfig::QuicConfig() :
 227     congestion_control_(kCGST, QuicNegotiableValue::PRESENCE_REQUIRED),
 228     idle_connection_state_lifetime_seconds_(
 229         kICSL, QuicNegotiableValue::PRESENCE_REQUIRED),
 230     keepalive_timeout_seconds_(kKATO, QuicNegotiableValue::PRESENCE_OPTIONAL),
 231     max_streams_per_connection_(kMSPC, QuicNegotiableValue::PRESENCE_REQUIRED),
 232     max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
 233     server_initial_congestion_window_(
 234         kSWND, QuicNegotiableValue::PRESENCE_OPTIONAL),
 235     initial_round_trip_time_us_(kIRTT, QuicNegotiableValue::PRESENCE_OPTIONAL) {
 236   // All optional non-zero parameters should be initialized here.
 237   server_initial_congestion_window_.set(kMaxInitialWindow,
 238                                         kDefaultInitialWindow);
 239 }
 240
 241 QuicConfig::~QuicConfig() {}
 242
 243 void QuicConfig::set_congestion_control(
 244     const QuicTagVector& congestion_control,
 245     QuicTag default_congestion_control) {
 246   congestion_control_.set(congestion_control, default_congestion_control);
 247 }
 248
 249 QuicTag QuicConfig::congestion_control() const {
 250   return congestion_control_.GetTag();
 251 }
 252
 253 void QuicConfig::set_idle_connection_state_lifetime(
 254     QuicTime::Delta max_idle_connection_state_lifetime,
 255     QuicTime::Delta default_idle_conection_state_lifetime) {
 256   idle_connection_state_lifetime_seconds_.set(
 257       max_idle_connection_state_lifetime.ToSeconds(),
 258       default_idle_conection_state_lifetime.ToSeconds());
 259 }
 260
 261 QuicTime::Delta QuicConfig::idle_connection_state_lifetime() const {
 262   return QuicTime::Delta::FromSeconds(
 263       idle_connection_state_lifetime_seconds_.GetUint32());
 264 }
 265
 266 QuicTime::Delta QuicConfig::keepalive_timeout() const {
 267   return QuicTime::Delta::FromSeconds(
 268       keepalive_timeout_seconds_.GetUint32());
 269 }
 270
 271 void QuicConfig::set_max_streams_per_connection(size_t max_streams,
 272                                                 size_t default_streams) {
 273   max_streams_per_connection_.set(max_streams, default_streams);
 274 }
 275
 276 uint32 QuicConfig::max_streams_per_connection() const {
 277   return max_streams_per_connection_.GetUint32();
 278 }
 279
 280 void QuicConfig::set_max_time_before_crypto_handshake(
 281     QuicTime::Delta max_time_before_crypto_handshake) {
 282   max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
 283 }
 284
 285 QuicTime::Delta QuicConfig::max_time_before_crypto_handshake() const {
 286   return max_time_before_crypto_handshake_;
 287 }
 288
 289 void QuicConfig::set_server_initial_congestion_window(size_t max_initial_window,
 290                                                size_t default_initial_window) {
 291   server_initial_congestion_window_.set(max_initial_window,
 292                                         default_initial_window);
 293 }
 294
 295 uint32 QuicConfig::server_initial_congestion_window() const {
 296   return server_initial_congestion_window_.GetUint32();
 297 }
 298
 299 void QuicConfig::set_initial_round_trip_time_us(size_t max_rtt,
 300                                                 size_t default_rtt) {
 301   initial_round_trip_time_us_.set(max_rtt, default_rtt);
 302 }
 303
 304 uint32 QuicConfig::initial_round_trip_time_us() const {
 305   return initial_round_trip_time_us_.GetUint32();
 306 }
 307
 308 bool QuicConfig::negotiated() {
 309   // TODO(ianswett): Add the negotiated parameters once and iterate over all
 310   // of them in negotiated, ToHandshakeMessage, ProcessClientHello, and
 311   // ProcessServerHello.
 312   return congestion_control_.negotiated() &&
 313       idle_connection_state_lifetime_seconds_.negotiated() &&
 314       keepalive_timeout_seconds_.negotiated() &&
 315       max_streams_per_connection_.negotiated() &&
 316       server_initial_congestion_window_.negotiated() &&
 317       initial_round_trip_time_us_.negotiated();
 318 }
 319
 320 void QuicConfig::SetDefaults() {
 321   QuicTagVector congestion_control;
 322   if (FLAGS_enable_quic_pacing) {
 323     congestion_control.push_back(kPACE);
 324   }
 325   congestion_control.push_back(kQBIC);
 326   congestion_control_.set(congestion_control, kQBIC);
 327   idle_connection_state_lifetime_seconds_.set(kDefaultTimeoutSecs,
 328                                               kDefaultInitialTimeoutSecs);
 329   // kKATO is optional. Return 0 if not negotiated.
 330   keepalive_timeout_seconds_.set(0, 0);
 331   max_streams_per_connection_.set(kDefaultMaxStreamsPerConnection,
 332                                   kDefaultMaxStreamsPerConnection);
 333   max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
 334       kDefaultMaxTimeForCryptoHandshakeSecs);
 335   server_initial_congestion_window_.set(kDefaultInitialWindow,
 336                                         kDefaultInitialWindow);
 337 }
 338
 339 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 340   congestion_control_.ToHandshakeMessage(out);
 341   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
 342   keepalive_timeout_seconds_.ToHandshakeMessage(out);
 343   max_streams_per_connection_.ToHandshakeMessage(out);
 344   server_initial_congestion_window_.ToHandshakeMessage(out);
 345   // TODO(ianswett): Don't transmit parameters which are optional and not set.
 346   initial_round_trip_time_us_.ToHandshakeMessage(out);
 347 }
 348
 349 QuicErrorCode QuicConfig::ProcessClientHello(
 350     const CryptoHandshakeMessage& client_hello,
 351     string* error_details) {
 352   DCHECK(error_details != NULL);
 353
 354   QuicErrorCode error = QUIC_NO_ERROR;
 355   if (error == QUIC_NO_ERROR) {
 356     error = congestion_control_.ProcessClientHello(client_hello, error_details);
 357   }
 358   if (error == QUIC_NO_ERROR) {
 359     error = idle_connection_state_lifetime_seconds_.ProcessClientHello(
 360         client_hello, error_details);
 361   }
 362   if (error == QUIC_NO_ERROR) {
 363     error = keepalive_timeout_seconds_.ProcessClientHello(
 364         client_hello, error_details);
 365   }
 366   if (error == QUIC_NO_ERROR) {
 367     error = max_streams_per_connection_.ProcessClientHello(
 368         client_hello, error_details);
 369   }
 370   if (error == QUIC_NO_ERROR) {
 371     error = server_initial_congestion_window_.ProcessClientHello(
 372         client_hello, error_details);
 373   }
 374   if (error == QUIC_NO_ERROR) {
 375     error = initial_round_trip_time_us_.ProcessClientHello(
 376         client_hello, error_details);
 377   }
 378   return error;
 379 }
 380
 381 QuicErrorCode QuicConfig::ProcessServerHello(
 382     const CryptoHandshakeMessage& server_hello,
 383     string* error_details) {
 384   DCHECK(error_details != NULL);
 385
 386   QuicErrorCode error = QUIC_NO_ERROR;
 387   if (error == QUIC_NO_ERROR) {
 388     error = congestion_control_.ProcessServerHello(server_hello, error_details);
 389   }
 390   if (error == QUIC_NO_ERROR) {
 391     error = idle_connection_state_lifetime_seconds_.ProcessServerHello(
 392         server_hello, error_details);
 393   }
 394   if (error == QUIC_NO_ERROR) {
 395     error = keepalive_timeout_seconds_.ProcessServerHello(
 396         server_hello, error_details);
 397   }
 398   if (error == QUIC_NO_ERROR) {
 399     error = max_streams_per_connection_.ProcessServerHello(
 400         server_hello, error_details);
 401   }
 402   if (error == QUIC_NO_ERROR) {
 403     error = server_initial_congestion_window_.ProcessServerHello(
 404         server_hello, error_details);
 405   }
 406   if (error == QUIC_NO_ERROR) {
 407     error = initial_round_trip_time_us_.ProcessServerHello(
 408         server_hello, error_details);
 409   }
 410   return error;
 411 }
 412
 413 }  // namespace net