Land Recent QUIC changes

net/quic/quic_utils.cc

 // Copyright (c) 2012 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/quic_utils.h"
 
 #include "base/logging.h"
 #include "base/port.h"
 
 namespace net {
 
 // static
+uint64 QuicUtils::FNV1a_64_Hash(const char* data, int len) {
+  static const uint64 kOffset = GG_UINT64_C(14695981039346656037);
+  static const uint64 kPrime = GG_UINT64_C(1099511628211);
+
+  const uint8* octets = reinterpret_cast<const uint8*>(data);
+
+  uint64 hash = kOffset;
+
+  for (int i = 0; i < len; ++i) {
+    hash = hash ^ octets[i];
+    hash = hash * kPrime;
+  }
+
+  return hash;
+}
+
+// static
 uint128 QuicUtils::FNV1a_128_Hash(const char* data, int len) {
   // The following two constants are defined as part of the hash algorithm.
   // see http://www.isthe.com/chongo/tech/comp/fnv/
   // 309485009821345068724781371
   const uint128 kPrime(16777216, 315);
   // 144066263297769815596495629667062367629
   const uint128 kOffset(GG_UINT64_C(7809847782465536322),
                         GG_UINT64_C(7113472399480571277));
 
   const uint8* octets = reinterpret_cast<const uint8*>(data);
 
   uint128 hash = kOffset;
 
   for (int i = 0; i < len; ++i) {
     hash  = hash ^ uint128(0, octets[i]);
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
+// static
+void QuicUtils::SerializeUint128(uint128 v, uint8* out) {
+  const uint64 lo = Uint128Low64(v);
+  const uint64 hi = Uint128High64(v);
+  // This assumes that the system is little-endian.
+  memcpy(out, &lo, sizeof(lo));
+  memcpy(out + sizeof(lo), &hi, sizeof(hi));
+}
+
+// static
+uint128 QuicUtils::ParseUint128(const uint8* in) {
+  uint64 lo, hi;
+  memcpy(&lo, in, sizeof(lo));
+  memcpy(&hi, in + sizeof(lo), sizeof(hi));
+  return uint128(hi, lo);
+}
+
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x;
 
 // static
 const char* QuicUtils::StreamErrorToString(QuicRstStreamErrorCode error) {
   switch (error) {
     RETURN_STRING_LITERAL(QUIC_STREAM_NO_ERROR);
     RETURN_STRING_LITERAL(QUIC_STREAM_CONNECTION_ERROR);
     RETURN_STRING_LITERAL(QUIC_SERVER_ERROR_PROCESSING_STREAM);
@@ skipping 37 matching lines @@
     RETURN_STRING_LITERAL(QUIC_CRYPTO_NO_SUPPORT);
     RETURN_STRING_LITERAL(QUIC_INVALID_CRYPTO_MESSAGE_TYPE);
     RETURN_STRING_LITERAL(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND);
     RETURN_STRING_LITERAL(QUIC_INVALID_STREAM_ID);
     RETURN_STRING_LITERAL(QUIC_TOO_MANY_OPEN_STREAMS);
     RETURN_STRING_LITERAL(QUIC_PUBLIC_RESET);
     RETURN_STRING_LITERAL(QUIC_INVALID_VERSION);
+    RETURN_STRING_LITERAL(QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED);
+    RETURN_STRING_LITERAL(QUIC_INVALID_HEADER_ID);
     RETURN_STRING_LITERAL(QUIC_CONNECTION_TIMED_OUT);
     RETURN_STRING_LITERAL(QUIC_PROOF_INVALID);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_DUPLICATE_TAG);
     RETURN_STRING_LITERAL(QUIC_LAST_ERROR);
     // Intentionally have no default case, so we'll break the build
     // if we add errors and don't put them here.
   }
   // Return a default value so that we return this when |error| doesn't match
   // any of the QuicErrorCodes. This can happen when the ConnectionClose
   // frame sent by the peer (attacker) has invalid error code.
   return "INVALID_ERROR_CODE";
 }
 
 }  // namespace net