Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/core/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/core/quic_utils.h"
 
 #include <ctype.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/ip_address.h"
 #include "net/quic/core/quic_flags.h"
-#include "net/quic/core/quic_write_blocked_list.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace {
 
 // We know that >= GCC 4.8 and Clang have a __uint128_t intrinsic. Other
 // compilers don't necessarily, notably MSVC.
 #if defined(__x86_64__) &&                                         \
@@ skipping 87 matching lines @@
                         UINT64_C(7113472399480571277));
 
   uint128 hash = IncrementalHash(kOffset, data1, len1);
   if (data2 == nullptr) {
     return hash;
   }
   return IncrementalHash(hash, data2, len2);
 }
 
 // static
-bool QuicUtils::FindMutualTag(const QuicTagVector& our_tags_vector,
-                              const QuicTag* their_tags,
-                              size_t num_their_tags,
-                              Priority priority,
-                              QuicTag* out_result,
-                              size_t* out_index) {
-  if (our_tags_vector.empty()) {
-    return false;
-  }
-  const size_t num_our_tags = our_tags_vector.size();
-  const QuicTag* our_tags = &our_tags_vector[0];
-
-  size_t num_priority_tags, num_inferior_tags;
-  const QuicTag* priority_tags;
-  const QuicTag* inferior_tags;
-  if (priority == LOCAL_PRIORITY) {
-    num_priority_tags = num_our_tags;
-    priority_tags = our_tags;
-    num_inferior_tags = num_their_tags;
-    inferior_tags = their_tags;
-  } else {
-    num_priority_tags = num_their_tags;
-    priority_tags = their_tags;
-    num_inferior_tags = num_our_tags;
-    inferior_tags = our_tags;
-  }
-
-  for (size_t i = 0; i < num_priority_tags; i++) {
-    for (size_t j = 0; j < num_inferior_tags; j++) {
-      if (priority_tags[i] == inferior_tags[j]) {
-        *out_result = priority_tags[i];
-        if (out_index) {
-          if (priority == LOCAL_PRIORITY) {
-            *out_index = j;
-          } else {
-            *out_index = i;
-          }
-        }
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-// static
 void QuicUtils::SerializeUint128Short(uint128 v, uint8_t* out) {
   const uint64_t lo = Uint128Low64(v);
   const uint64_t hi = Uint128High64(v);
   // This assumes that the system is little-endian.
   memcpy(out, &lo, sizeof(lo));
   memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2);
 }
 
 #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_ERROR_PROCESSING_STREAM);
-    RETURN_STRING_LITERAL(QUIC_MULTIPLE_TERMINATION_OFFSETS);
-    RETURN_STRING_LITERAL(QUIC_BAD_APPLICATION_PAYLOAD);
-    RETURN_STRING_LITERAL(QUIC_STREAM_PEER_GOING_AWAY);
-    RETURN_STRING_LITERAL(QUIC_STREAM_CANCELLED);
-    RETURN_STRING_LITERAL(QUIC_RST_ACKNOWLEDGEMENT);
-    RETURN_STRING_LITERAL(QUIC_REFUSED_STREAM);
-    RETURN_STRING_LITERAL(QUIC_STREAM_LAST_ERROR);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PROMISE_URL);
-    RETURN_STRING_LITERAL(QUIC_UNAUTHORIZED_PROMISE_URL);
-    RETURN_STRING_LITERAL(QUIC_DUPLICATE_PROMISE_URL);
-    RETURN_STRING_LITERAL(QUIC_PROMISE_VARY_MISMATCH);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PROMISE_METHOD);
-    RETURN_STRING_LITERAL(QUIC_PUSH_STREAM_TIMED_OUT);
-    RETURN_STRING_LITERAL(QUIC_HEADERS_TOO_LARGE);
-  }
-  // Return a default value so that we return this when |error| doesn't match
-  // any of the QuicRstStreamErrorCodes. This can happen when the RstStream
-  // frame sent by the peer (attacker) has invalid error code.
-  return "INVALID_RST_STREAM_ERROR_CODE";
-}
-
-// static
-const char* QuicUtils::ErrorToString(QuicErrorCode error) {
-  switch (error) {
-    RETURN_STRING_LITERAL(QUIC_NO_ERROR);
-    RETURN_STRING_LITERAL(QUIC_INTERNAL_ERROR);
-    RETURN_STRING_LITERAL(QUIC_STREAM_DATA_AFTER_TERMINATION);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PACKET_HEADER);
-    RETURN_STRING_LITERAL(QUIC_INVALID_FRAME_DATA);
-    RETURN_STRING_LITERAL(QUIC_MISSING_PAYLOAD);
-    RETURN_STRING_LITERAL(QUIC_INVALID_FEC_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_OVERLAPPING_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_UNENCRYPTED_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_RST_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_CONNECTION_CLOSE_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_GOAWAY_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_WINDOW_UPDATE_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_BLOCKED_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_STOP_WAITING_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PATH_CLOSE_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_ACK_DATA);
-    RETURN_STRING_LITERAL(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PUBLIC_RST_PACKET);
-    RETURN_STRING_LITERAL(QUIC_DECRYPTION_FAILURE);
-    RETURN_STRING_LITERAL(QUIC_ENCRYPTION_FAILURE);
-    RETURN_STRING_LITERAL(QUIC_PACKET_TOO_LARGE);
-    RETURN_STRING_LITERAL(QUIC_PEER_GOING_AWAY);
-    RETURN_STRING_LITERAL(QUIC_HANDSHAKE_FAILED);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_TAGS_OUT_OF_ORDER);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_TOO_MANY_ENTRIES);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_TOO_MANY_REJECTS);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_INVALID_VALUE_LENGTH)
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_INTERNAL_ERROR);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_VERSION_NOT_SUPPORTED);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT);
-    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_UNSUPPORTED_PROOF_DEMAND);
-    RETURN_STRING_LITERAL(QUIC_INVALID_STREAM_ID);
-    RETURN_STRING_LITERAL(QUIC_INVALID_PRIORITY);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_OPEN_STREAMS);
-    RETURN_STRING_LITERAL(QUIC_PUBLIC_RESET);
-    RETURN_STRING_LITERAL(QUIC_INVALID_VERSION);
-    RETURN_STRING_LITERAL(QUIC_INVALID_HEADER_ID);
-    RETURN_STRING_LITERAL(QUIC_INVALID_NEGOTIATED_VALUE);
-    RETURN_STRING_LITERAL(QUIC_DECOMPRESSION_FAILURE);
-    RETURN_STRING_LITERAL(QUIC_NETWORK_IDLE_TIMEOUT);
-    RETURN_STRING_LITERAL(QUIC_HANDSHAKE_TIMEOUT);
-    RETURN_STRING_LITERAL(QUIC_ERROR_MIGRATING_ADDRESS);
-    RETURN_STRING_LITERAL(QUIC_ERROR_MIGRATING_PORT);
-    RETURN_STRING_LITERAL(QUIC_PACKET_WRITE_ERROR);
-    RETURN_STRING_LITERAL(QUIC_PACKET_READ_ERROR);
-    RETURN_STRING_LITERAL(QUIC_EMPTY_STREAM_FRAME_NO_FIN);
-    RETURN_STRING_LITERAL(QUIC_INVALID_HEADERS_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA);
-    RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA);
-    RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_INVALID_WINDOW);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_IP_POOLED);
-    RETURN_STRING_LITERAL(QUIC_PROOF_INVALID);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_DUPLICATE_TAG);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_SERVER_CONFIG_EXPIRED);
-    RETURN_STRING_LITERAL(QUIC_INVALID_CHANNEL_ID_SIGNATURE);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE);
-    RETURN_STRING_LITERAL(QUIC_VERSION_NEGOTIATION_MISMATCH);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_CANCELLED);
-    RETURN_STRING_LITERAL(QUIC_BAD_PACKET_LOSS_RATE);
-    RETURN_STRING_LITERAL(QUIC_PUBLIC_RESETS_POST_HANDSHAKE);
-    RETURN_STRING_LITERAL(QUIC_TIMEOUTS_WITH_OPEN_STREAMS);
-    RETURN_STRING_LITERAL(QUIC_FAILED_TO_SERIALIZE_PACKET);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_AVAILABLE_STREAMS);
-    RETURN_STRING_LITERAL(QUIC_UNENCRYPTED_FEC_DATA);
-    RETURN_STRING_LITERAL(QUIC_BAD_MULTIPATH_FLAG);
-    RETURN_STRING_LITERAL(QUIC_IP_ADDRESS_CHANGED);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK);
-    RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_RTOS);
-    RETURN_STRING_LITERAL(QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA);
-    RETURN_STRING_LITERAL(QUIC_MAYBE_CORRUPTED_MEMORY);
-    RETURN_STRING_LITERAL(QUIC_CRYPTO_CHLO_TOO_LARGE);
-    RETURN_STRING_LITERAL(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST);
-    RETURN_STRING_LITERAL(QUIC_MULTIPATH_PATH_NOT_ACTIVE);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_FRAME_GAPS);
-    RETURN_STRING_LITERAL(QUIC_STREAM_SEQUENCER_INVALID_STATE);
-    RETURN_STRING_LITERAL(QUIC_TOO_MANY_SESSIONS_ON_SERVER);
-    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";
-}
-
-// static
 const char* QuicUtils::EncryptionLevelToString(EncryptionLevel level) {
   switch (level) {
     RETURN_STRING_LITERAL(ENCRYPTION_NONE);
     RETURN_STRING_LITERAL(ENCRYPTION_INITIAL);
     RETURN_STRING_LITERAL(ENCRYPTION_FORWARD_SECURE);
     RETURN_STRING_LITERAL(NUM_ENCRYPTION_LEVELS);
   }
   return "INVALID_ENCRYPTION_LEVEL";
 }
 
 // static
 const char* QuicUtils::TransmissionTypeToString(TransmissionType type) {
   switch (type) {
     RETURN_STRING_LITERAL(NOT_RETRANSMISSION);
     RETURN_STRING_LITERAL(HANDSHAKE_RETRANSMISSION);
     RETURN_STRING_LITERAL(LOSS_RETRANSMISSION);
     RETURN_STRING_LITERAL(ALL_UNACKED_RETRANSMISSION);
     RETURN_STRING_LITERAL(ALL_INITIAL_RETRANSMISSION);
     RETURN_STRING_LITERAL(RTO_RETRANSMISSION);
     RETURN_STRING_LITERAL(TLP_RETRANSMISSION);
   }
   return "INVALID_TRANSMISSION_TYPE";
 }
 
 // static
-string QuicUtils::TagToString(QuicTag tag) {
-  char chars[sizeof tag];
-  bool ascii = true;
-  const QuicTag orig_tag = tag;
-
-  for (size_t i = 0; i < arraysize(chars); i++) {
-    chars[i] = static_cast<char>(tag);
-    if ((chars[i] == 0 || chars[i] == '\xff') && i == arraysize(chars) - 1) {
-      chars[i] = ' ';
-    }
-    if (!isprint(static_cast<unsigned char>(chars[i]))) {
-      ascii = false;
-      break;
-    }
-    tag >>= 8;
-  }
-
-  if (ascii) {
-    return string(chars, sizeof(chars));
-  }
-
-  return base::UintToString(orig_tag);
-}
-
-// static
 QuicTagVector QuicUtils::ParseQuicConnectionOptions(
     const std::string& connection_options) {
   QuicTagVector options;
   // Tokens are expected to be no more than 4 characters long, but we
   // handle overflow gracefully.
   for (const base::StringPiece& token :
        base::SplitStringPiece(connection_options, ",", base::TRIM_WHITESPACE,
                               base::SPLIT_WANT_ALL)) {
     uint32_t option = 0;
     for (char token_char : base::Reversed(token)) {
@@ skipping 140 matching lines @@
 }
 
 string QuicUtils::HexEncode(const char* data, size_t length) {
   return HexEncode(StringPiece(data, length));
 }
 
 string QuicUtils::HexEncode(StringPiece data) {
   return ::base::HexEncode(data.data(), data.size());
 }
 
-string QuicUtils::HexDecode(const char* data, size_t length) {
-  return HexDecode(StringPiece(data, length));
-}
-
 string QuicUtils::HexDecode(StringPiece data) {
   if (data.empty())
     return "";
   std::vector<uint8_t> v;
   if (!base::HexStringToBytes(data.as_string(), &v))
     return "";
   string out;
   if (!v.empty())
     out.assign(reinterpret_cast<const char*>(&v[0]), v.size());
   return out;
@@ skipping 25 matching lines @@
 
     bytes_remaining -= line_bytes;
     offset += line_bytes;
     p += line_bytes;
     s += '\n';
   }
   return s;
 }
 
 }  // namespace net