QUIC - (no behavior change) s/NULL/nullptr/g in .../quic/...

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>
 
 #include "base/stl_util.h"
@@ skipping 94 matching lines @@
 };
 
 class ValidateClientHelloHelper {
  public:
   ValidateClientHelloHelper(ValidateClientHelloResultCallback::Result* result,
                             ValidateClientHelloResultCallback* done_cb)
       : result_(result), done_cb_(done_cb) {
   }
 
   ~ValidateClientHelloHelper() {
-    LOG_IF(DFATAL, done_cb_ != NULL)
+    LOG_IF(DFATAL, done_cb_ != nullptr)
         << "Deleting ValidateClientHelloHelper with a pending callback.";
   }
 
   void ValidationComplete(QuicErrorCode error_code, const char* error_details) {
     result_->error_code = error_code;
     result_->error_details = error_details;
     done_cb_->Run(result_);
     DetachCallback();
   }
 
   void StartedAsyncCallback() {
     DetachCallback();
   }
 
  private:
   void DetachCallback() {
-    LOG_IF(DFATAL, done_cb_ == NULL) << "Callback already detached.";
-    done_cb_ = NULL;
+    LOG_IF(DFATAL, done_cb_ == nullptr) << "Callback already detached.";
+    done_cb_ = nullptr;
   }
 
   ValidateClientHelloResultCallback::Result* result_;
   ValidateClientHelloResultCallback* done_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(ValidateClientHelloHelper);
 };
 
 class VerifyNonceIsValidAndUniqueCallback
     : public StrikeRegisterClient::ResultCallback {
@@ skipping 76 matching lines @@
 QuicCryptoServerConfig::ConfigOptions::ConfigOptions()
     : expiry_time(QuicWallTime::Zero()),
       channel_id_enabled(false),
       p256(false) {}
 
 QuicCryptoServerConfig::QuicCryptoServerConfig(
     StringPiece source_address_token_secret,
     QuicRandom* rand)
     : replay_protection_(true),
       configs_lock_(),
-      primary_config_(NULL),
+      primary_config_(nullptr),
       next_config_promotion_time_(QuicWallTime::Zero()),
       server_nonce_strike_register_lock_(),
       strike_register_no_startup_period_(false),
       strike_register_max_entries_(1 << 10),
       strike_register_window_secs_(600),
       source_address_token_future_secs_(3600),
       source_address_token_lifetime_secs_(86400),
       server_nonce_strike_register_max_entries_(1 << 10),
       server_nonce_strike_register_window_secs_(120) {
   default_source_address_token_boxer_.SetKey(
       DeriveSourceAddressTokenKey(source_address_token_secret));
 
   // Generate a random key and orbit for server nonces.
   rand->RandBytes(server_nonce_orbit_, sizeof(server_nonce_orbit_));
   const size_t key_size = server_nonce_boxer_.GetKeySize();
   scoped_ptr<uint8[]> key_bytes(new uint8[key_size]);
   rand->RandBytes(key_bytes.get(), key_size);
 
   server_nonce_boxer_.SetKey(
       StringPiece(reinterpret_cast<char*>(key_bytes.get()), key_size));
 }
 
 QuicCryptoServerConfig::~QuicCryptoServerConfig() {
-  primary_config_ = NULL;
+  primary_config_ = nullptr;
 }
 
 // static
 QuicServerConfigProtobuf* QuicCryptoServerConfig::GenerateConfig(
     QuicRandom* rand,
     const QuicClock* clock,
     const ConfigOptions& options) {
   CryptoHandshakeMessage msg;
 
   const string curve25519_private_key =
@@ skipping 95 matching lines @@
 }
 
 CryptoHandshakeMessage* QuicCryptoServerConfig::AddConfig(
     QuicServerConfigProtobuf* protobuf,
     const QuicWallTime now) {
   scoped_ptr<CryptoHandshakeMessage> msg(
       CryptoFramer::ParseMessage(protobuf->config()));
 
   if (!msg.get()) {
     LOG(WARNING) << "Failed to parse server config message";
-    return NULL;
+    return nullptr;
   }
 
   scoped_refptr<Config> config(ParseConfigProtobuf(protobuf));
   if (!config.get()) {
     LOG(WARNING) << "Failed to parse server config message";
-    return NULL;
+    return nullptr;
   }
 
   {
     base::AutoLock locked(configs_lock_);
     if (configs_.find(config->id) != configs_.end()) {
       LOG(WARNING) << "Failed to add config because another with the same "
                       "server config id already exists: "
                    << base::HexEncode(config->id.data(), config->id.size());
-      return NULL;
+      return nullptr;
     }
 
     configs_[config->id] = config;
     SelectNewPrimaryConfig(now);
     DCHECK(primary_config_.get());
     DCHECK_EQ(configs_.find(primary_config_->id)->second, primary_config_);
   }
 
   return msg.release();
 }
@@ skipping 221 matching lines @@
                               &num_their_key_exchanges) != QUIC_NO_ERROR ||
       num_their_aeads != 1 ||
       num_their_key_exchanges != 1) {
     *error_details = "Missing or invalid AEAD or KEXS";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
   size_t key_exchange_index;
   if (!QuicUtils::FindMutualTag(requested_config->aead, their_aeads,
                                 num_their_aeads, QuicUtils::LOCAL_PRIORITY,
-                                &params->aead, NULL) ||
+                                &params->aead, nullptr) ||
       !QuicUtils::FindMutualTag(
           requested_config->kexs, their_key_exchanges, num_their_key_exchanges,
           QuicUtils::LOCAL_PRIORITY, &params->key_exchange,
           &key_exchange_index)) {
     *error_details = "Unsupported AEAD or KEXS";
     return QUIC_CRYPTO_NO_SUPPORT;
   }
 
   StringPiece public_value;
   if (!client_hello.GetStringPiece(kPUBS, &public_value)) {
@@ skipping 40 matching lines @@
     hkdf_input.append(reinterpret_cast<char*>(&connection_id),
                       sizeof(connection_id));
     hkdf_input.append(client_hello_serialized.data(),
                       client_hello_serialized.length());
     hkdf_input.append(requested_config->serialized);
 
     CrypterPair crypters;
     if (!CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
                                  info.client_nonce, info.server_nonce,
                                  hkdf_input, CryptoUtils::SERVER, &crypters,
-                                 NULL /* subkey secret */)) {
+                                 nullptr /* subkey secret */)) {
       *error_details = "Symmetric key setup failed";
       return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
     }
 
     scoped_ptr<QuicData> cetv_plaintext(crypters.decrypter->DecryptPacket(
         0 /* sequence number */, StringPiece() /* associated data */,
         cetv_ciphertext));
     if (!cetv_plaintext.get()) {
       *error_details = "CETV decryption failure";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ skipping 21 matching lines @@
   string hkdf_input;
   size_t label_len = strlen(QuicCryptoConfig::kInitialLabel) + 1;
   hkdf_input.reserve(label_len + hkdf_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
   hkdf_input.append(hkdf_suffix);
 
   if (!CryptoUtils::DeriveKeys(params->initial_premaster_secret, params->aead,
                                info.client_nonce, info.server_nonce, hkdf_input,
                                CryptoUtils::SERVER,
                                &params->initial_crypters,
-                               NULL /* subkey secret */)) {
+                               nullptr /* subkey secret */)) {
     *error_details = "Symmetric key setup failed";
     return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
   }
 
   string forward_secure_public_value;
   if (ephemeral_key_source_.get()) {
     params->forward_secure_premaster_secret =
         ephemeral_key_source_->CalculateForwardSecureKey(
             key_exchange, rand, clock->ApproximateNow(), public_value,
             &forward_secure_public_value);
@@ skipping 27 matching lines @@
 
   out->set_tag(kSHLO);
   QuicTagVector supported_version_tags;
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     supported_version_tags.push_back
         (QuicVersionToQuicTag(supported_versions[i]));
   }
   out->SetVector(kVER, supported_version_tags);
   out->SetStringPiece(
       kSourceAddressTokenTag,
-      NewSourceAddressToken(
-          *requested_config.get(), client_address, rand, info.now, NULL));
+      NewSourceAddressToken(*requested_config.get(),
+                            client_address,
+                            rand,
+                            info.now,
+                            nullptr));
   QuicSocketAddressCoder address_coder(client_address);
   out->SetStringPiece(kCADR, address_coder.Encode());
   out->SetStringPiece(kPUBS, forward_secure_public_value);
 
   return QUIC_NO_ERROR;
 }
 
 scoped_refptr<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfig::GetConfigWithScid(StringPiece requested_scid) const {
   // In Chromium, we will dead lock if the lock is held by the current thread.
@@ skipping 81 matching lines @@
 
     if (primary_config_.get()) {
       primary_config_->is_primary = false;
     }
     primary_config_ = new_primary;
     new_primary->is_primary = true;
     DVLOG(1) << "New primary config.  orbit: "
              << base::HexEncode(
                  reinterpret_cast<const char*>(primary_config_->orbit),
                  kOrbitSize);
-    if (primary_config_changed_cb_.get() != NULL) {
+    if (primary_config_changed_cb_.get() != nullptr) {
       primary_config_changed_cb_->Run(primary_config_->id);
     }
 
     return;
   }
 
   // All config's primary times are in the past. We should make the most recent
   // and highest priority candidate primary.
   scoped_refptr<Config> new_primary(best_candidate);
   if (primary_config_.get()) {
     primary_config_->is_primary = false;
   }
   primary_config_ = new_primary;
   new_primary->is_primary = true;
   DVLOG(1) << "New primary config.  orbit: "
            << base::HexEncode(
                reinterpret_cast<const char*>(primary_config_->orbit),
                kOrbitSize)
            << " scid: " << base::HexEncode(primary_config_->id.data(),
                                            primary_config_->id.size());
   next_config_promotion_time_ = QuicWallTime::Zero();
-  if (primary_config_changed_cb_.get() != NULL) {
+  if (primary_config_changed_cb_.get() != nullptr) {
     primary_config_changed_cb_->Run(primary_config_->id);
   }
 }
 
 void QuicCryptoServerConfig::EvaluateClientHello(
     const uint8* primary_orbit,
     scoped_refptr<Config> requested_config,
     ValidateClientHelloResultCallback::Result* client_hello_state,
     ValidateClientHelloResultCallback* done_cb) const {
   ValidateClientHelloHelper helper(client_hello_state, done_cb);
@@ skipping 95 matching lines @@
   if (found_error) {
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
   // Use the client nonce to establish uniqueness.
   StrikeRegisterClient* strike_register_client;
   {
     base::AutoLock locked(strike_register_client_lock_);
 
-    if (strike_register_client_.get() == NULL) {
+    if (strike_register_client_.get() == nullptr) {
       strike_register_client_.reset(new LocalStrikeRegisterClient(
           strike_register_max_entries_,
           static_cast<uint32>(info->now.ToUNIXSeconds()),
           strike_register_window_secs_,
           primary_orbit,
           strike_register_no_startup_period_ ?
           StrikeRegister::NO_STARTUP_PERIOD_NEEDED :
           StrikeRegister::DENY_REQUESTS_AT_STARTUP));
     }
     strike_register_client = strike_register_client_.get();
@@ skipping 16 matching lines @@
   base::AutoLock locked(configs_lock_);
   out->set_tag(kSCUP);
   out->SetStringPiece(kSCFG, primary_config_->serialized);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(*primary_config_.get(),
                                             client_ip,
                                             rand,
                                             clock->WallNow(),
                                             cached_network_params));
 
-  if (proof_source_ == NULL) {
+  if (proof_source_ == nullptr) {
     // Insecure QUIC, can send SCFG without proof.
     return true;
   }
 
   const vector<string>* certs;
   string signature;
   if (!proof_source_->GetProof(params.sni, primary_config_->serialized,
                                params.x509_ecdsa_supported, &certs,
                                &signature)) {
     DVLOG(1) << "Server: failed to get proof.";
@@ skipping 17 matching lines @@
     QuicCryptoNegotiatedParameters *params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kREJ);
   out->SetStringPiece(kSCFG, config.serialized);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(
                           config,
                           info.client_ip,
                           rand,
                           info.now,
-                          NULL));
+                          nullptr));
   if (replay_protection_) {
     out->SetStringPiece(kServerNonceTag, NewServerNonce(rand, info.now));
   }
 
   if (FLAGS_send_quic_crypto_reject_reason) {
     // Send client the reject reason for debugging purposes.
     DCHECK_LT(0u, info.reject_reasons.size());
     out->SetVector(kRREJ, info.reject_reasons);
   }
 
   // The client may have requested a certificate chain.
   const QuicTag* their_proof_demands;
   size_t num_their_proof_demands;
 
-  if (proof_source_.get() == NULL ||
+  if (proof_source_.get() == nullptr ||
       client_hello.GetTaglist(kPDMD, &their_proof_demands,
                               &num_their_proof_demands) !=
           QUIC_NO_ERROR) {
     return;
   }
 
   bool x509_supported = false;
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     switch (their_proof_demands[i]) {
       case kX509:
@@ skipping 60 matching lines @@
 
 scoped_refptr<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfig::ParseConfigProtobuf(
     QuicServerConfigProtobuf* protobuf) {
   scoped_ptr<CryptoHandshakeMessage> msg(
       CryptoFramer::ParseMessage(protobuf->config()));
 
   if (msg->tag() != kSCFG) {
     LOG(WARNING) << "Server config message has tag " << msg->tag()
                  << " expected " << kSCFG;
-    return NULL;
+    return nullptr;
   }
 
   scoped_refptr<Config> config(new Config);
   config->serialized = protobuf->config();
 
   if (!protobuf->has_source_address_token_secret_override()) {
     // Use the default boxer.
     config->source_address_token_boxer = &default_source_address_token_boxer_;
   } else {
     // Create override boxer instance.
     CryptoSecretBoxer* boxer = new CryptoSecretBoxer;
     boxer->SetKey(DeriveSourceAddressTokenKey(
         protobuf->source_address_token_secret_override()));
     config->source_address_token_boxer_storage.reset(boxer);
     config->source_address_token_boxer = boxer;
   }
 
   if (protobuf->has_primary_time()) {
     config->primary_time =
         QuicWallTime::FromUNIXSeconds(protobuf->primary_time());
   }
 
   config->priority = protobuf->priority();
 
   StringPiece scid;
   if (!msg->GetStringPiece(kSCID, &scid)) {
     LOG(WARNING) << "Server config message is missing SCID";
-    return NULL;
+    return nullptr;
   }
   config->id = scid.as_string();
 
   const QuicTag* aead_tags;
   size_t aead_len;
   if (msg->GetTaglist(kAEAD, &aead_tags, &aead_len) != QUIC_NO_ERROR) {
     LOG(WARNING) << "Server config message is missing AEAD";
-    return NULL;
+    return nullptr;
   }
   config->aead = vector<QuicTag>(aead_tags, aead_tags + aead_len);
 
   const QuicTag* kexs_tags;
   size_t kexs_len;
   if (msg->GetTaglist(kKEXS, &kexs_tags, &kexs_len) != QUIC_NO_ERROR) {
     LOG(WARNING) << "Server config message is missing KEXS";
-    return NULL;
+    return nullptr;
   }
 
   StringPiece orbit;
   if (!msg->GetStringPiece(kORBT, &orbit)) {
     LOG(WARNING) << "Server config message is missing ORBT";
-    return NULL;
+    return nullptr;
   }
 
   if (orbit.size() != kOrbitSize) {
     LOG(WARNING) << "Orbit value in server config is the wrong length."
                     " Got " << orbit.size() << " want " << kOrbitSize;
-    return NULL;
+    return nullptr;
   }
   COMPILE_ASSERT(sizeof(config->orbit) == kOrbitSize, orbit_incorrect_size);
   memcpy(config->orbit, orbit.data(), sizeof(config->orbit));
 
   {
     StrikeRegisterClient* strike_register_client;
     {
       base::AutoLock locked(strike_register_client_lock_);
       strike_register_client = strike_register_client_.get();
     }
 
-    if (strike_register_client != NULL &&
+    if (strike_register_client != nullptr &&
         !strike_register_client->IsKnownOrbit(orbit)) {
       LOG(WARNING)
           << "Rejecting server config with orbit that the strike register "
           "client doesn't know about.";
-      return NULL;
+      return nullptr;
     }
   }
 
   if (kexs_len != protobuf->key_size()) {
     LOG(WARNING) << "Server config has " << kexs_len
                  << " key exchange methods configured, but "
                  << protobuf->key_size() << " private keys";
-    return NULL;
+    return nullptr;
   }
 
   const QuicTag* proof_demand_tags;
   size_t num_proof_demand_tags;
   if (msg->GetTaglist(kPDMD, &proof_demand_tags, &num_proof_demand_tags) ==
       QUIC_NO_ERROR) {
     for (size_t i = 0; i < num_proof_demand_tags; i++) {
       if (proof_demand_tags[i] == kCHID) {
         config->channel_id_enabled = true;
         break;
@@ skipping 11 matching lines @@
       const QuicServerConfigProtobuf::PrivateKey& key = protobuf->key(i);
       if (key.tag() == tag) {
         private_key = key.private_key();
         break;
       }
     }
 
     if (private_key.empty()) {
       LOG(WARNING) << "Server config contains key exchange method without "
                       "corresponding private key: " << tag;
-      return NULL;
+      return nullptr;
     }
 
     scoped_ptr<KeyExchange> ka;
     switch (tag) {
       case kC255:
         ka.reset(Curve25519KeyExchange::New(private_key));
         if (!ka.get()) {
           LOG(WARNING) << "Server config contained an invalid curve25519"
                           " private key.";
-          return NULL;
+          return nullptr;
         }
         break;
       case kP256:
         ka.reset(P256KeyExchange::New(private_key));
         if (!ka.get()) {
           LOG(WARNING) << "Server config contained an invalid P-256"
                           " private key.";
-          return NULL;
+          return nullptr;
         }
         break;
       default:
         LOG(WARNING) << "Server config message contains unknown key exchange "
                         "method: " << tag;
-        return NULL;
+        return nullptr;
     }
 
     for (vector<KeyExchange*>::const_iterator i = config->key_exchanges.begin();
          i != config->key_exchanges.end(); ++i) {
       if ((*i)->tag() == tag) {
         LOG(WARNING) << "Duplicate key exchange in config: " << tag;
-        return NULL;
+        return nullptr;
       }
     }
 
     config->key_exchanges.push_back(ka.release());
   }
 
   return config;
 }
 
 void QuicCryptoServerConfig::SetProofSource(ProofSource* proof_source) {
@@ skipping 70 matching lines @@
     QuicRandom* rand,
     QuicWallTime now,
     const CachedNetworkParameters* cached_network_params) const {
   IPAddressNumber ip_address = ip.address();
   if (ip.GetSockAddrFamily() == AF_INET) {
     ip_address = ConvertIPv4NumberToIPv6Number(ip_address);
   }
   SourceAddressToken source_address_token;
   source_address_token.set_ip(IPAddressToPackedString(ip_address));
   source_address_token.set_timestamp(now.ToUNIXSeconds());
-  if (cached_network_params != NULL) {
+  if (cached_network_params != nullptr) {
     source_address_token.set_cached_network_parameters(*cached_network_params);
   }
 
   return config.source_address_token_boxer->Box(
       rand, source_address_token.SerializeAsString());
 }
 
 HandshakeFailureReason QuicCryptoServerConfig::ValidateSourceAddressToken(
     const Config& config,
     StringPiece token,
@@ skipping 83 matching lines @@
   memcpy(server_nonce, plaintext.data(), 4);
   memcpy(server_nonce + 4, server_nonce_orbit_, sizeof(server_nonce_orbit_));
   memcpy(server_nonce + 4 + sizeof(server_nonce_orbit_), plaintext.data() + 4,
          20);
   COMPILE_ASSERT(4 + sizeof(server_nonce_orbit_) + 20 == sizeof(server_nonce),
                  bad_nonce_buffer_length);
 
   InsertStatus nonce_error;
   {
     base::AutoLock auto_lock(server_nonce_strike_register_lock_);
-    if (server_nonce_strike_register_.get() == NULL) {
+    if (server_nonce_strike_register_.get() == nullptr) {
       server_nonce_strike_register_.reset(new StrikeRegister(
           server_nonce_strike_register_max_entries_,
           static_cast<uint32>(now.ToUNIXSeconds()),
           server_nonce_strike_register_window_secs_, server_nonce_orbit_,
           StrikeRegister::NO_STARTUP_PERIOD_NEEDED));
     }
     nonce_error = server_nonce_strike_register_->Insert(
         server_nonce, static_cast<uint32>(now.ToUNIXSeconds()));
   }
 
@@ skipping 14 matching lines @@
       LOG(DFATAL) << "Unexpected server nonce error: " << nonce_error;
       return SERVER_NONCE_NOT_UNIQUE_FAILURE;
   }
 }
 
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0),
-      source_address_token_boxer(NULL) {}
+      source_address_token_boxer(nullptr) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net