Reject reasons from strike register when nonce validation fails.

net/quic/crypto/strike_register.cc

 // 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.
 
 #include "net/quic/crypto/strike_register.h"
 
 #include "base/logging.h"
 
 using std::make_pair;
 using std::max;
@@ skipping 110 matching lines @@
   // Also thread a free list through the external nodes.
   external_node_free_head_ = 0;
   for (unsigned i = 0; i < max_entries_ - 1; i++)
     external_node_next_ptr(i) = i + 1;
   external_node_next_ptr(max_entries_ - 1) = kNil;
 
   // This is the root of the tree.
   internal_node_head_ = kNil;
 }
 
-bool StrikeRegister::Insert(const uint8 nonce[32],
-                            uint32 current_time_external) {
+InsertStatus StrikeRegister::Insert(const uint8 nonce[32],
+                                    uint32 current_time_external) {
   // Make space for the insertion if the strike register is full.
   while (external_node_free_head_ == kNil ||
          internal_node_free_head_ == kNil) {
     DropOldestNode();
   }
 
   const uint32 current_time = ExternalTimeToInternal(current_time_external);
 
   // Check to see if the orbit is correct.
   if (memcmp(nonce + sizeof(current_time), orbit_, sizeof(orbit_))) {
-    return false;
+    return NONCE_INVALID_ORBIT_FAILURE;
   }
 
   const uint32 nonce_time = ExternalTimeToInternal(TimeFromBytes(nonce));
 
   // Check that the timestamp is in the valid range.
   pair<uint32, uint32> valid_range =
       StrikeRegister::GetValidRange(current_time);
   if (nonce_time < valid_range.first || nonce_time > valid_range.second) {
-    return false;
+    return NONCE_INVALID_TIME_FAILURE;
   }
 
   // We strip the orbit out of the nonce.
   uint8 value[24];
   memcpy(value, nonce, sizeof(nonce_time));
   memcpy(value + sizeof(nonce_time),
          nonce + sizeof(nonce_time) + sizeof(orbit_),
          sizeof(value) - sizeof(nonce_time));
 
   // Find the best match to |value| in the crit-bit tree. The best match is
   // simply the value which /could/ match |value|, if any does, so we still
   // need a memcmp to check.
   uint32 best_match_index = BestMatch(value);
   if (best_match_index == kNil) {
     // Empty tree. Just insert the new value at the root.
     uint32 index = GetFreeExternalNode();
     memcpy(external_node(index), value, sizeof(value));
     internal_node_head_ = (index | kExternalFlag) << 8;
     DCHECK_LE(horizon_, nonce_time);
-    return true;
+    return NONCE_OK;
   }
 
   const uint8* best_match = external_node(best_match_index);
   if (memcmp(best_match, value, sizeof(value)) == 0) {
     // We found the value in the tree.
-    return false;
+    return NONCE_NOT_UNIQUE_FAILURE;
   }
 
   // We are going to insert a new entry into the tree, so get the nodes now.
   uint32 internal_node_index = GetFreeInternalNode();
   uint32 external_node_index = GetFreeExternalNode();
 
   // If we just evicted the best match, then we have to try and match again.
   // We know that we didn't just empty the tree because we require that
   // max_entries_ >= 2. Also, we know that it doesn't match because, if it
   // did, it would have been returned previously.
@@ skipping 65 matching lines @@
     uint8 c = value[node->critbyte()];
     const int direction =
         (1 + static_cast<unsigned>(node->otherbits() | c)) >> 8;
     where_index = &node->data_[direction];
   }
 
   inode->SetChild(newdirection ^ 1, *where_index >> 8);
   *where_index = (*where_index & 0xff) | (internal_node_index << 8);
 
   DCHECK_LE(horizon_, nonce_time);
-  return true;
+  return NONCE_OK;
 }
 
 const uint8* StrikeRegister::orbit() const {
   return orbit_;
 }
 
 uint32 StrikeRegister::GetCurrentValidWindowSecs(
     uint32 current_time_external) const {
   uint32 current_time = ExternalTimeToInternal(current_time_external);
   pair<uint32, uint32> valid_range = StrikeRegister::GetValidRange(
@@ skipping 234 matching lines @@
       CHECK_EQ(free_internal_nodes.count(inter), 0u);
       CHECK_EQ(used_internal_nodes->count(inter), 0u);
       used_internal_nodes->insert(inter);
       ValidateTree(inter, bit, bits, free_internal_nodes, free_external_nodes,
                    used_internal_nodes, used_external_nodes);
     }
   }
 }
 
 }  // namespace net