Landing Recent QUIC changes until 01/26/2016 18:14 UTC

net/quic/crypto/quic_crypto_server_config.cc

 // Copyright 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.
 
 #include "net/quic/crypto/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 
@@ skipping 504 matching lines @@
         SelectNewPrimaryConfig(now);
         DCHECK(primary_config_.get());
         DCHECK_EQ(configs_.find(primary_config_->id)->second, primary_config_);
       }
 
       memcpy(primary_orbit, primary_config_->orbit, sizeof(primary_orbit));
     }
 
     requested_config = GetConfigWithScid(requested_scid);
     primary_config = primary_config_;
-    crypto_proof->primary_scid = primary_config->id;
+    if (FLAGS_quic_crypto_proof_use_ref) {
+      crypto_proof->config = primary_config_;
+    } else {
+      crypto_proof->primary_scid = primary_config->id;
+    }
   }
 
   if (result->error_code == QUIC_NO_ERROR) {
     EvaluateClientHello(server_ip, version, primary_orbit, requested_config,
                         primary_config, crypto_proof, result, done_cb);
   } else {
     done_cb->Run(result);
   }
 }
 
@@ skipping 39 matching lines @@
 
     if (!next_config_promotion_time_.IsZero() &&
         next_config_promotion_time_.IsAfter(now)) {
       SelectNewPrimaryConfig(now);
       DCHECK(primary_config_.get());
       DCHECK_EQ(configs_.find(primary_config_->id)->second, primary_config_);
     }
 
     // Use the config that the client requested in order to do key-agreement.
     // Otherwise give it a copy of |primary_config_| to use.
-    primary_config = GetConfigWithScid(crypto_proof->primary_scid);
+    if (FLAGS_quic_crypto_proof_use_ref) {
+      primary_config = crypto_proof->config;
+    } else {
+      primary_config = GetConfigWithScid(crypto_proof->primary_scid);
+    }
     if (!primary_config) {
       *error_details = "Configuration not found";
       QUIC_BUG << "Primary config not found";
       return QUIC_CRYPTO_INTERNAL_ERROR;
     }
 
     requested_config = GetConfigWithScid(requested_scid);
   }
 
   if (validate_chlo_result.error_code != QUIC_NO_ERROR) {
@@ skipping 141 matching lines @@
     }
 
     char plaintext[kMaxPacketSize];
     size_t plaintext_length = 0;
     const bool success = crypters.decrypter->DecryptPacket(
         kDefaultPathId, 0 /* packet number */,
         StringPiece() /* associated data */, cetv_ciphertext, plaintext,
         &plaintext_length, kMaxPacketSize);
     if (!success) {
       *error_details = "CETV decryption failure";
-      return QUIC_PACKET_TOO_LARGE;
+      return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
     scoped_ptr<CryptoHandshakeMessage> cetv(
         CryptoFramer::ParseMessage(StringPiece(plaintext, plaintext_length)));
     if (!cetv.get()) {
       *error_details = "CETV parse error";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     StringPiece key, signature;
     if (cetv->GetStringPiece(kCIDK, &key) &&
@@ skipping 1038 matching lines @@
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0),
       source_address_token_boxer(nullptr) {}
 
 QuicCryptoServerConfig::Config::~Config() {
   STLDeleteElements(&key_exchanges);
 }
 
+QuicCryptoProof::QuicCryptoProof() : certs(nullptr) {}
+QuicCryptoProof::~QuicCryptoProof() {}
 }  // namespace net