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/crypto/crypto_handshake_message.h"
  11 #include "net/quic/crypto/crypto_protocol.h"
  12 #include "net/quic/quic_flags.h"
  13 #include "net/quic/quic_sent_packet_manager.h"
  14 #include "net/quic/quic_utils.h"
  15
  16 using std::min;
  17 using std::string;
  18
  19 namespace net {
  20
  21 // Reads the value corresponding to |name_| from |msg| into |out|. If the
  22 // |name_| is absent in |msg| and |presence| is set to OPTIONAL |out| is set
  23 // to |default_value|.
  24 QuicErrorCode ReadUint32(const CryptoHandshakeMessage& msg,
  25                          QuicTag tag,
  26                          QuicConfigPresence presence,
  27                          uint32 default_value,
  28                          uint32* out,
  29                          string* error_details) {
  30   DCHECK(error_details != NULL);
  31   QuicErrorCode error = msg.GetUint32(tag, out);
  32   switch (error) {
  33     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
  34       if (presence == PRESENCE_REQUIRED) {
  35         *error_details = "Missing " + QuicUtils::TagToString(tag);
  36         break;
  37       }
  38       error = QUIC_NO_ERROR;
  39       *out = default_value;
  40       break;
  41     case QUIC_NO_ERROR:
  42       break;
  43     default:
  44       *error_details = "Bad " + QuicUtils::TagToString(tag);
  45       break;
  46   }
  47   return error;
  48 }
  49
  50
  51 QuicConfigValue::QuicConfigValue(QuicTag tag,
  52                                  QuicConfigPresence presence)
  53     : tag_(tag),
  54       presence_(presence) {
  55 }
  56 QuicConfigValue::~QuicConfigValue() {}
  57
  58 QuicNegotiableValue::QuicNegotiableValue(QuicTag tag,
  59                                          QuicConfigPresence presence)
  60     : QuicConfigValue(tag, presence),
  61       negotiated_(false) {
  62 }
  63 QuicNegotiableValue::~QuicNegotiableValue() {}
  64
  65 QuicNegotiableUint32::QuicNegotiableUint32(QuicTag tag,
  66                                            QuicConfigPresence presence)
  67     : QuicNegotiableValue(tag, presence),
  68       max_value_(0),
  69       default_value_(0) {
  70 }
  71 QuicNegotiableUint32::~QuicNegotiableUint32() {}
  72
  73 void QuicNegotiableUint32::set(uint32 max, uint32 default_value) {
  74   DCHECK_LE(default_value, max);
  75   max_value_ = max;
  76   default_value_ = default_value;
  77 }
  78
  79 uint32 QuicNegotiableUint32::GetUint32() const {
  80   if (negotiated_) {
  81     return negotiated_value_;
  82   }
  83   return default_value_;
  84 }
  85
  86 void QuicNegotiableUint32::ToHandshakeMessage(
  87     CryptoHandshakeMessage* out) const {
  88   if (negotiated_) {
  89     out->SetValue(tag_, negotiated_value_);
  90   } else {
  91     out->SetValue(tag_, max_value_);
  92   }
  93 }
  94
  95 QuicErrorCode QuicNegotiableUint32::ProcessPeerHello(
  96     const CryptoHandshakeMessage& peer_hello,
  97     HelloType hello_type,
  98     string* error_details) {
  99   DCHECK(!negotiated_);
 100   DCHECK(error_details != NULL);
 101   uint32 value;
 102   QuicErrorCode error = ReadUint32(peer_hello,
 103                                    tag_,
 104                                    presence_,
 105                                    default_value_,
 106                                    &value,
 107                                    error_details);
 108   if (error != QUIC_NO_ERROR) {
 109     return error;
 110   }
 111   if (hello_type == SERVER && value > max_value_) {
 112     *error_details =
 113         "Invalid value received for " + QuicUtils::TagToString(tag_);
 114     return QUIC_INVALID_NEGOTIATED_VALUE;
 115   }
 116
 117   negotiated_ = true;
 118   negotiated_value_ = min(value, max_value_);
 119   return QUIC_NO_ERROR;
 120 }
 121
 122 QuicNegotiableTag::QuicNegotiableTag(QuicTag tag, QuicConfigPresence presence)
 123     : QuicNegotiableValue(tag, presence),
 124       negotiated_tag_(0),
 125       default_value_(0) {
 126 }
 127
 128 QuicNegotiableTag::~QuicNegotiableTag() {}
 129
 130 void QuicNegotiableTag::set(const QuicTagVector& possible,
 131                             QuicTag default_value) {
 132   DCHECK(ContainsQuicTag(possible, default_value));
 133   possible_values_ = possible;
 134   default_value_ = default_value;
 135 }
 136
 137 QuicTag QuicNegotiableTag::GetTag() const {
 138   if (negotiated_) {
 139     return negotiated_tag_;
 140   }
 141   return default_value_;
 142 }
 143
 144 void QuicNegotiableTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 145   if (negotiated_) {
 146     // Because of the way we serialize and parse handshake messages we can
 147     // serialize this as value and still parse it as a vector.
 148     out->SetValue(tag_, negotiated_tag_);
 149   } else {
 150     out->SetVector(tag_, possible_values_);
 151   }
 152 }
 153
 154 QuicErrorCode QuicNegotiableTag::ReadVector(
 155     const CryptoHandshakeMessage& msg,
 156     const QuicTag** out,
 157     size_t* out_length,
 158     string* error_details) const {
 159   DCHECK(error_details != NULL);
 160   QuicErrorCode error = msg.GetTaglist(tag_, out, out_length);
 161   switch (error) {
 162     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
 163       if (presence_ == PRESENCE_REQUIRED) {
 164         *error_details = "Missing " + QuicUtils::TagToString(tag_);
 165         break;
 166       }
 167       error = QUIC_NO_ERROR;
 168       *out_length = 1;
 169       *out = &default_value_;
 170
 171     case QUIC_NO_ERROR:
 172       break;
 173     default:
 174       *error_details = "Bad " + QuicUtils::TagToString(tag_);
 175       break;
 176   }
 177   return error;
 178 }
 179
 180 QuicErrorCode QuicNegotiableTag::ProcessPeerHello(
 181     const CryptoHandshakeMessage& peer_hello,
 182     HelloType hello_type,
 183     string* error_details) {
 184   DCHECK(!negotiated_);
 185   DCHECK(error_details != NULL);
 186   const QuicTag* received_tags;
 187   size_t received_tags_length;
 188   QuicErrorCode error = ReadVector(peer_hello, &received_tags,
 189                                    &received_tags_length, error_details);
 190   if (error != QUIC_NO_ERROR) {
 191     return error;
 192   }
 193
 194   if (hello_type == SERVER) {
 195     if (received_tags_length != 1 ||
 196         !ContainsQuicTag(possible_values_,  *received_tags)) {
 197       *error_details = "Invalid " + QuicUtils::TagToString(tag_);
 198       return QUIC_INVALID_NEGOTIATED_VALUE;
 199     }
 200     negotiated_tag_ = *received_tags;
 201   } else {
 202     QuicTag negotiated_tag;
 203     if (!QuicUtils::FindMutualTag(possible_values_,
 204                                   received_tags,
 205                                   received_tags_length,
 206                                   QuicUtils::LOCAL_PRIORITY,
 207                                   &negotiated_tag,
 208                                   NULL)) {
 209       *error_details = "Unsupported " + QuicUtils::TagToString(tag_);
 210       return QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP;
 211     }
 212     negotiated_tag_ = negotiated_tag;
 213   }
 214
 215   negotiated_ = true;
 216   return QUIC_NO_ERROR;
 217 }
 218
 219 QuicFixedUint32::QuicFixedUint32(QuicTag tag, QuicConfigPresence presence)
 220     : QuicConfigValue(tag, presence),
 221       has_send_value_(false),
 222       has_receive_value_(false) {
 223 }
 224 QuicFixedUint32::~QuicFixedUint32() {}
 225
 226 bool QuicFixedUint32::HasSendValue() const {
 227   return has_send_value_;
 228 }
 229
 230 uint32 QuicFixedUint32::GetSendValue() const {
 231   LOG_IF(DFATAL, !has_send_value_)
 232       << "No send value to get for tag:" << QuicUtils::TagToString(tag_);
 233   return send_value_;
 234 }
 235
 236 void QuicFixedUint32::SetSendValue(uint32 value) {
 237   has_send_value_ = true;
 238   send_value_ = value;
 239 }
 240
 241 bool QuicFixedUint32::HasReceivedValue() const {
 242   return has_receive_value_;
 243 }
 244
 245 uint32 QuicFixedUint32::GetReceivedValue() const {
 246   LOG_IF(DFATAL, !has_receive_value_)
 247       << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
 248   return receive_value_;
 249 }
 250
 251 void QuicFixedUint32::SetReceivedValue(uint32 value) {
 252   has_receive_value_ = true;
 253   receive_value_ = value;
 254 }
 255
 256 void QuicFixedUint32::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 257   if (has_send_value_) {
 258     out->SetValue(tag_, send_value_);
 259   }
 260 }
 261
 262 QuicErrorCode QuicFixedUint32::ProcessPeerHello(
 263     const CryptoHandshakeMessage& peer_hello,
 264     HelloType hello_type,
 265     string* error_details) {
 266   DCHECK(error_details != NULL);
 267   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
 268   switch (error) {
 269     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
 270       if (presence_ == PRESENCE_OPTIONAL) {
 271         return QUIC_NO_ERROR;
 272       }
 273       *error_details = "Missing " + QuicUtils::TagToString(tag_);
 274       break;
 275     case QUIC_NO_ERROR:
 276       has_receive_value_ = true;
 277       break;
 278     default:
 279       *error_details = "Bad " + QuicUtils::TagToString(tag_);
 280       break;
 281   }
 282   return error;
 283 }
 284
 285 QuicFixedTag::QuicFixedTag(QuicTag name,
 286                            QuicConfigPresence presence)
 287     : QuicConfigValue(name, presence),
 288       has_send_value_(false),
 289       has_receive_value_(false) {
 290 }
 291
 292 QuicFixedTag::~QuicFixedTag() {}
 293
 294 bool QuicFixedTag::HasSendValue() const {
 295   return has_send_value_;
 296 }
 297
 298 uint32 QuicFixedTag::GetSendValue() const {
 299   LOG_IF(DFATAL, !has_send_value_)
 300       << "No send value to get for tag:" << QuicUtils::TagToString(tag_);
 301   return send_value_;
 302 }
 303
 304 void QuicFixedTag::SetSendValue(uint32 value) {
 305   has_send_value_ = true;
 306   send_value_ = value;
 307 }
 308
 309 bool QuicFixedTag::HasReceivedValue() const {
 310   return has_receive_value_;
 311 }
 312
 313 uint32 QuicFixedTag::GetReceivedValue() const {
 314   LOG_IF(DFATAL, !has_receive_value_)
 315       << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
 316   return receive_value_;
 317 }
 318
 319 void QuicFixedTag::SetReceivedValue(uint32 value) {
 320   has_receive_value_ = true;
 321   receive_value_ = value;
 322 }
 323
 324 void QuicFixedTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 325   if (has_send_value_) {
 326     out->SetValue(tag_, send_value_);
 327   }
 328 }
 329
 330 QuicErrorCode QuicFixedTag::ProcessPeerHello(
 331     const CryptoHandshakeMessage& peer_hello,
 332     HelloType hello_type,
 333     string* error_details) {
 334   DCHECK(error_details != NULL);
 335   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
 336   switch (error) {
 337     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
 338       if (presence_ == PRESENCE_OPTIONAL) {
 339         return QUIC_NO_ERROR;
 340       }
 341       *error_details = "Missing " + QuicUtils::TagToString(tag_);
 342       break;
 343     case QUIC_NO_ERROR:
 344       has_receive_value_ = true;
 345       break;
 346     default:
 347       *error_details = "Bad " + QuicUtils::TagToString(tag_);
 348       break;
 349   }
 350   return error;
 351 }
 352
 353 QuicFixedTagVector::QuicFixedTagVector(QuicTag name,
 354                                        QuicConfigPresence presence)
 355     : QuicConfigValue(name, presence),
 356       has_send_values_(false),
 357       has_receive_values_(false) {
 358 }
 359
 360 QuicFixedTagVector::~QuicFixedTagVector() {}
 361
 362 bool QuicFixedTagVector::HasSendValues() const {
 363   return has_send_values_;
 364 }
 365
 366 QuicTagVector QuicFixedTagVector::GetSendValues() const {
 367   LOG_IF(DFATAL, !has_send_values_)
 368       << "No send values to get for tag:" << QuicUtils::TagToString(tag_);
 369   return send_values_;
 370 }
 371
 372 void QuicFixedTagVector::SetSendValues(const QuicTagVector& values) {
 373   has_send_values_ = true;
 374   send_values_ = values;
 375 }
 376
 377 bool QuicFixedTagVector::HasReceivedValues() const {
 378   return has_receive_values_;
 379 }
 380
 381 QuicTagVector QuicFixedTagVector::GetReceivedValues() const {
 382   LOG_IF(DFATAL, !has_receive_values_)
 383       << "No receive value to get for tag:" << QuicUtils::TagToString(tag_);
 384   return receive_values_;
 385 }
 386
 387 void QuicFixedTagVector::SetReceivedValues(const QuicTagVector& values) {
 388   has_receive_values_ = true;
 389   receive_values_ = values;
 390 }
 391
 392 void QuicFixedTagVector::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 393   if (has_send_values_) {
 394     out->SetVector(tag_, send_values_);
 395   }
 396 }
 397
 398 QuicErrorCode QuicFixedTagVector::ProcessPeerHello(
 399     const CryptoHandshakeMessage& peer_hello,
 400     HelloType hello_type,
 401     string* error_details) {
 402   DCHECK(error_details != NULL);
 403   const QuicTag* received_tags;
 404   size_t received_tags_length;
 405   QuicErrorCode error =
 406       peer_hello.GetTaglist(tag_, &received_tags, &received_tags_length);
 407   switch (error) {
 408     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
 409       if (presence_ == PRESENCE_OPTIONAL) {
 410         return QUIC_NO_ERROR;
 411       }
 412       *error_details = "Missing " + QuicUtils::TagToString(tag_);
 413       break;
 414     case QUIC_NO_ERROR:
 415       DVLOG(1) << "Received Connection Option tags from receiver.";
 416       has_receive_values_ = true;
 417       for (size_t i = 0; i < received_tags_length; ++i) {
 418         receive_values_.push_back(received_tags[i]);
 419       }
 420       break;
 421     default:
 422       *error_details = "Bad " + QuicUtils::TagToString(tag_);
 423       break;
 424   }
 425   return error;
 426 }
 427
 428 QuicConfig::QuicConfig()
 429     : congestion_feedback_(kCGST, PRESENCE_REQUIRED),
 430       connection_options_(kCOPT, PRESENCE_OPTIONAL),
 431       loss_detection_(kLOSS, PRESENCE_OPTIONAL),
 432       idle_connection_state_lifetime_seconds_(kICSL, PRESENCE_REQUIRED),
 433       keepalive_timeout_seconds_(kKATO, PRESENCE_OPTIONAL),
 434       max_streams_per_connection_(kMSPC, PRESENCE_REQUIRED),
 435       max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
 436       initial_congestion_window_(kSWND, PRESENCE_OPTIONAL),
 437       initial_round_trip_time_us_(kIRTT, PRESENCE_OPTIONAL),
 438       // TODO(rjshade): Make this PRESENCE_REQUIRED when QUIC_VERSION_16 is
 439       // retired.
 440       initial_flow_control_window_bytes_(kIFCW, PRESENCE_OPTIONAL),
 441       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
 442       // QUIC_VERSION_19.
 443       initial_stream_flow_control_window_bytes_(kSFCW, PRESENCE_OPTIONAL),
 444       // TODO(rjshade): Make this PRESENCE_REQUIRED when retiring
 445       // QUIC_VERSION_19.
 446       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
 447       socket_receive_buffer_(kSRBF, PRESENCE_OPTIONAL) {
 448 }
 449
 450 QuicConfig::~QuicConfig() {}
 451
 452 void QuicConfig::set_congestion_feedback(
 453     const QuicTagVector& congestion_feedback,
 454     QuicTag default_congestion_feedback) {
 455   congestion_feedback_.set(congestion_feedback, default_congestion_feedback);
 456 }
 457
 458 QuicTag QuicConfig::congestion_feedback() const {
 459   return congestion_feedback_.GetTag();
 460 }
 461
 462 void QuicConfig::SetConnectionOptionsToSend(
 463     const QuicTagVector& connection_options) {
 464   connection_options_.SetSendValues(connection_options);
 465 }
 466
 467 bool QuicConfig::HasReceivedConnectionOptions() const {
 468   return connection_options_.HasReceivedValues();
 469 }
 470
 471 QuicTagVector QuicConfig::ReceivedConnectionOptions() const {
 472   return connection_options_.GetReceivedValues();
 473 }
 474
 475 bool QuicConfig::HasSendConnectionOptions() const {
 476   return connection_options_.HasSendValues();
 477 }
 478
 479 QuicTagVector QuicConfig::SendConnectionOptions() const {
 480   return connection_options_.GetSendValues();
 481 }
 482
 483 void QuicConfig::SetLossDetectionToSend(QuicTag loss_detection) {
 484   loss_detection_.SetSendValue(loss_detection);
 485 }
 486
 487 bool QuicConfig::HasReceivedLossDetection() const {
 488   return loss_detection_.HasReceivedValue();
 489 }
 490
 491 QuicTag QuicConfig::ReceivedLossDetection() const {
 492   return loss_detection_.GetReceivedValue();
 493 }
 494
 495 void QuicConfig::set_idle_connection_state_lifetime(
 496     QuicTime::Delta max_idle_connection_state_lifetime,
 497     QuicTime::Delta default_idle_conection_state_lifetime) {
 498   idle_connection_state_lifetime_seconds_.set(
 499       max_idle_connection_state_lifetime.ToSeconds(),
 500       default_idle_conection_state_lifetime.ToSeconds());
 501 }
 502
 503 QuicTime::Delta QuicConfig::idle_connection_state_lifetime() const {
 504   return QuicTime::Delta::FromSeconds(
 505       idle_connection_state_lifetime_seconds_.GetUint32());
 506 }
 507
 508 QuicTime::Delta QuicConfig::keepalive_timeout() const {
 509   return QuicTime::Delta::FromSeconds(
 510       keepalive_timeout_seconds_.GetUint32());
 511 }
 512
 513 void QuicConfig::set_max_streams_per_connection(size_t max_streams,
 514                                                 size_t default_streams) {
 515   max_streams_per_connection_.set(max_streams, default_streams);
 516 }
 517
 518 uint32 QuicConfig::max_streams_per_connection() const {
 519   return max_streams_per_connection_.GetUint32();
 520 }
 521
 522 void QuicConfig::set_max_time_before_crypto_handshake(
 523     QuicTime::Delta max_time_before_crypto_handshake) {
 524   max_time_before_crypto_handshake_ = max_time_before_crypto_handshake;
 525 }
 526
 527 QuicTime::Delta QuicConfig::max_time_before_crypto_handshake() const {
 528   return max_time_before_crypto_handshake_;
 529 }
 530
 531 void QuicConfig::SetInitialCongestionWindowToSend(size_t initial_window) {
 532   initial_congestion_window_.SetSendValue(initial_window);
 533 }
 534
 535 bool QuicConfig::HasReceivedInitialCongestionWindow() const {
 536   return initial_congestion_window_.HasReceivedValue();
 537 }
 538
 539 uint32 QuicConfig::ReceivedInitialCongestionWindow() const {
 540   return initial_congestion_window_.GetReceivedValue();
 541 }
 542
 543 void QuicConfig::SetInitialRoundTripTimeUsToSend(size_t rtt) {
 544   initial_round_trip_time_us_.SetSendValue(rtt);
 545 }
 546
 547 bool QuicConfig::HasReceivedInitialRoundTripTimeUs() const {
 548   return initial_round_trip_time_us_.HasReceivedValue();
 549 }
 550
 551 uint32 QuicConfig::ReceivedInitialRoundTripTimeUs() const {
 552   return initial_round_trip_time_us_.GetReceivedValue();
 553 }
 554
 555 bool QuicConfig::HasInitialRoundTripTimeUsToSend() const {
 556   return initial_round_trip_time_us_.HasSendValue();
 557 }
 558
 559 uint32 QuicConfig::GetInitialRoundTripTimeUsToSend() const {
 560   return initial_round_trip_time_us_.GetSendValue();
 561 }
 562
 563 void QuicConfig::SetInitialFlowControlWindowToSend(uint32 window_bytes) {
 564   if (window_bytes < kDefaultFlowControlSendWindow) {
 565     LOG(DFATAL) << "Initial flow control receive window (" << window_bytes
 566                 << ") cannot be set lower than default ("
 567                 << kDefaultFlowControlSendWindow << ").";
 568     window_bytes = kDefaultFlowControlSendWindow;
 569   }
 570   initial_flow_control_window_bytes_.SetSendValue(window_bytes);
 571 }
 572
 573 uint32 QuicConfig::GetInitialFlowControlWindowToSend() const {
 574   return initial_flow_control_window_bytes_.GetSendValue();
 575 }
 576
 577 bool QuicConfig::HasReceivedInitialFlowControlWindowBytes() const {
 578   return initial_flow_control_window_bytes_.HasReceivedValue();
 579 }
 580
 581 uint32 QuicConfig::ReceivedInitialFlowControlWindowBytes() const {
 582   return initial_flow_control_window_bytes_.GetReceivedValue();
 583 }
 584
 585 void QuicConfig::SetInitialStreamFlowControlWindowToSend(uint32 window_bytes) {
 586   if (window_bytes < kDefaultFlowControlSendWindow) {
 587     LOG(DFATAL) << "Initial stream flow control receive window ("
 588                 << window_bytes << ") cannot be set lower than default ("
 589                 << kDefaultFlowControlSendWindow << ").";
 590     window_bytes = kDefaultFlowControlSendWindow;
 591   }
 592   initial_stream_flow_control_window_bytes_.SetSendValue(window_bytes);
 593 }
 594
 595 uint32 QuicConfig::GetInitialStreamFlowControlWindowToSend() const {
 596   return initial_stream_flow_control_window_bytes_.GetSendValue();
 597 }
 598
 599 bool QuicConfig::HasReceivedInitialStreamFlowControlWindowBytes() const {
 600   return initial_stream_flow_control_window_bytes_.HasReceivedValue();
 601 }
 602
 603 uint32 QuicConfig::ReceivedInitialStreamFlowControlWindowBytes() const {
 604   return initial_stream_flow_control_window_bytes_.GetReceivedValue();
 605 }
 606
 607 void QuicConfig::SetInitialSessionFlowControlWindowToSend(uint32 window_bytes) {
 608   if (window_bytes < kDefaultFlowControlSendWindow) {
 609     LOG(DFATAL) << "Initial session flow control receive window ("
 610                 << window_bytes << ") cannot be set lower than default ("
 611                 << kDefaultFlowControlSendWindow << ").";
 612     window_bytes = kDefaultFlowControlSendWindow;
 613   }
 614   initial_session_flow_control_window_bytes_.SetSendValue(window_bytes);
 615 }
 616
 617 uint32 QuicConfig::GetInitialSessionFlowControlWindowToSend() const {
 618   return initial_session_flow_control_window_bytes_.GetSendValue();
 619 }
 620
 621 bool QuicConfig::HasReceivedInitialSessionFlowControlWindowBytes() const {
 622   return initial_session_flow_control_window_bytes_.HasReceivedValue();
 623 }
 624
 625 uint32 QuicConfig::ReceivedInitialSessionFlowControlWindowBytes() const {
 626   return initial_session_flow_control_window_bytes_.GetReceivedValue();
 627 }
 628
 629 void QuicConfig::SetSocketReceiveBufferToSend(uint32 tcp_receive_window) {
 630   socket_receive_buffer_.SetSendValue(tcp_receive_window);
 631 }
 632
 633 uint32 QuicConfig::GetSocketReceiveBufferToSend() const {
 634   return socket_receive_buffer_.GetSendValue();
 635 }
 636
 637 bool QuicConfig::HasReceivedSocketReceiveBuffer() const {
 638   return socket_receive_buffer_.HasReceivedValue();
 639 }
 640
 641 uint32 QuicConfig::ReceivedSocketReceiveBuffer() const {
 642   return socket_receive_buffer_.GetReceivedValue();
 643 }
 644
 645 bool QuicConfig::negotiated() {
 646   // TODO(ianswett): Add the negotiated parameters once and iterate over all
 647   // of them in negotiated, ToHandshakeMessage, ProcessClientHello, and
 648   // ProcessServerHello.
 649   return congestion_feedback_.negotiated() &&
 650       idle_connection_state_lifetime_seconds_.negotiated() &&
 651       keepalive_timeout_seconds_.negotiated() &&
 652       max_streams_per_connection_.negotiated();
 653 }
 654
 655 void QuicConfig::SetDefaults() {
 656   QuicTagVector congestion_feedback;
 657   congestion_feedback.push_back(kQBIC);
 658   congestion_feedback_.set(congestion_feedback, kQBIC);
 659   idle_connection_state_lifetime_seconds_.set(kMaximumIdleTimeoutSecs,
 660                                               kDefaultInitialTimeoutSecs);
 661   // kKATO is optional. Return 0 if not negotiated.
 662   keepalive_timeout_seconds_.set(0, 0);
 663   set_max_streams_per_connection(kDefaultMaxStreamsPerConnection,
 664                                  kDefaultMaxStreamsPerConnection);
 665   max_time_before_crypto_handshake_ = QuicTime::Delta::FromSeconds(
 666       kDefaultMaxTimeForCryptoHandshakeSecs);
 667
 668   SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 669   SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 670   SetInitialSessionFlowControlWindowToSend(kDefaultFlowControlSendWindow);
 671 }
 672
 673 void QuicConfig::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
 674   congestion_feedback_.ToHandshakeMessage(out);
 675   idle_connection_state_lifetime_seconds_.ToHandshakeMessage(out);
 676   keepalive_timeout_seconds_.ToHandshakeMessage(out);
 677   max_streams_per_connection_.ToHandshakeMessage(out);
 678   initial_congestion_window_.ToHandshakeMessage(out);
 679   initial_round_trip_time_us_.ToHandshakeMessage(out);
 680   loss_detection_.ToHandshakeMessage(out);
 681   initial_flow_control_window_bytes_.ToHandshakeMessage(out);
 682   initial_stream_flow_control_window_bytes_.ToHandshakeMessage(out);
 683   initial_session_flow_control_window_bytes_.ToHandshakeMessage(out);
 684   socket_receive_buffer_.ToHandshakeMessage(out);
 685   connection_options_.ToHandshakeMessage(out);
 686 }
 687
 688 QuicErrorCode QuicConfig::ProcessPeerHello(
 689     const CryptoHandshakeMessage& peer_hello,
 690     HelloType hello_type,
 691     string* error_details) {
 692   DCHECK(error_details != NULL);
 693
 694   QuicErrorCode error = QUIC_NO_ERROR;
 695   if (error == QUIC_NO_ERROR) {
 696     error = congestion_feedback_.ProcessPeerHello(
 697         peer_hello,  hello_type, error_details);
 698   }
 699   if (error == QUIC_NO_ERROR) {
 700     error = idle_connection_state_lifetime_seconds_.ProcessPeerHello(
 701         peer_hello, hello_type, error_details);
 702   }
 703   if (error == QUIC_NO_ERROR) {
 704     error = keepalive_timeout_seconds_.ProcessPeerHello(
 705         peer_hello, hello_type, error_details);
 706   }
 707   if (error == QUIC_NO_ERROR) {
 708     error = max_streams_per_connection_.ProcessPeerHello(
 709         peer_hello, hello_type, error_details);
 710   }
 711   if (error == QUIC_NO_ERROR) {
 712     error = initial_congestion_window_.ProcessPeerHello(
 713         peer_hello, hello_type, error_details);
 714   }
 715   if (error == QUIC_NO_ERROR) {
 716     error = initial_round_trip_time_us_.ProcessPeerHello(
 717         peer_hello, hello_type, error_details);
 718   }
 719   if (error == QUIC_NO_ERROR) {
 720     error = initial_flow_control_window_bytes_.ProcessPeerHello(
 721         peer_hello, hello_type, error_details);
 722   }
 723   if (error == QUIC_NO_ERROR) {
 724     error = initial_stream_flow_control_window_bytes_.ProcessPeerHello(
 725         peer_hello, hello_type, error_details);
 726   }
 727   if (error == QUIC_NO_ERROR) {
 728     error = initial_session_flow_control_window_bytes_.ProcessPeerHello(
 729         peer_hello, hello_type, error_details);
 730   }
 731   if (error == QUIC_NO_ERROR) {
 732     error = socket_receive_buffer_.ProcessPeerHello(
 733         peer_hello, hello_type, error_details);
 734   }
 735   if (error == QUIC_NO_ERROR) {
 736     error = loss_detection_.ProcessPeerHello(
 737         peer_hello, hello_type, error_details);
 738   }
 739   if (error == QUIC_NO_ERROR) {
 740     error = connection_options_.ProcessPeerHello(
 741         peer_hello, hello_type, error_details);
 742   }
 743   return error;
 744 }
 745
 746 }  // namespace net