@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/build/test.bzl

@@ -0,0 +1,26 @@
+"""Tools for building QUICHE tests."""
+
+load("@bazel_skylib//lib:paths.bzl", "paths")
+
+def test_suite_from_source_list(name, srcs, **kwargs):
+    """
+    Generates a test target for every individual test source file specified.
+
+    Args:
+        name: the name of the resulting test_suite target.
+        srcs: the list of source files from which the test targets are generated.
+        **kwargs: other arguments that are passed to the cc_test rule directly.s
+    """
+
+    tests = []
+    for sourcefile in srcs:
+        if not sourcefile.endswith("_test.cc"):
+            fail("All source files passed to test_suite_from_source_list() must end with _test.cc")
+        test_name, _ = paths.split_extension(paths.basename(sourcefile))
+        native.cc_test(
+            name = test_name,
+            srcs = [sourcefile],
+            **kwargs
+        )
+        tests.append(test_name)
+    native.test_suite(name = name, tests = tests)

package/third_party/quiche/build/zlib.BUILD

@@ -0,0 +1,25 @@
+# Copyright 2022 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.
+
+licenses(["notice"])
+
+cc_library(
+    name = "zlib",
+    srcs = glob(
+        include = [
+            "*.c",
+            "*.h",
+        ],
+        exclude = [
+            "zlib.h",
+            "zconf.h",
+        ],
+    ),
+    hdrs = [
+        "zconf.h",
+        "zlib.h",
+    ],
+    copts = ["-Wno-implicit-function-declaration"],
+    visibility = ["//visibility:public"],
+)

package/third_party/quiche/quiche/BUILD.bazel

@@ -0,0 +1,270 @@
+# Copyright 2022 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.
+
+load(
+    "//build:source_list.bzl",
+    "default_platform_impl_hdrs",
+    "default_platform_impl_srcs",
+    "default_platform_impl_test_support_hdrs",
+    "default_platform_impl_test_support_srcs",
+    "default_platform_impl_tool_support_hdrs",
+    "default_platform_impl_tool_support_srcs",
+    "quiche_core_hdrs",
+    "quiche_core_srcs",
+    "quiche_test_support_hdrs",
+    "quiche_test_support_srcs",
+    "quiche_tests_srcs",
+    "quiche_tool_support_hdrs",
+    "quiche_tool_support_srcs",
+)
+load("//build:test.bzl", "test_suite_from_source_list")
+
+licenses(["notice"])
+
+package(
+    default_visibility = ["//visibility:private"],
+    features = [
+        "parse_headers",
+        "layering_check",
+    ],
+)
+
+cc_library(
+    name = "quic_flags_list",
+    textual_hdrs = [
+        "quic/core/quic_flags_list.h",
+        "quic/core/quic_protocol_flags_list.h",
+    ],
+)
+
+# QUICHE_EXPORT is used by all platform definitions, and thus needs to be handled separately.
+cc_library(
+    name = "quiche_platform_default_quiche_export",
+    hdrs = [
+        "common/platform/default/quiche_platform_impl/quiche_export_impl.h",
+    ],
+    strip_include_prefix = "common/platform/default",
+)
+
+cc_library(
+    name = "quiche_platform_quiche_export",
+    hdrs = [
+        "common/platform/api/quiche_export.h",
+    ],
+    deps = [":quiche_platform_default_quiche_export"],
+)
+
+cc_library(
+    name = "quiche_platform_default",
+    srcs = default_platform_impl_srcs,
+    hdrs = default_platform_impl_hdrs,
+    strip_include_prefix = "common/platform/default",
+    deps = [
+        ":quic_flags_list",
+        ":quiche_platform_quiche_export",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/debugging:stacktrace",
+        "@com_google_absl//absl/debugging:symbolize",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/synchronization",
+        "@com_google_absl//absl/time",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_googleurl//url",
+    ],
+)
+
+cc_library(
+    name = "quiche_platform_default_tools",
+    srcs = default_platform_impl_tool_support_srcs,
+    hdrs = default_platform_impl_tool_support_hdrs,
+    strip_include_prefix = "common/platform/default",
+    deps = [
+        ":quiche_core",
+        "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/flags:parse",
+        "@com_google_absl//absl/flags:usage",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_googletest//:gtest",
+    ],
+)
+
+cc_library(
+    name = "quiche_platform_default_testonly",
+    testonly = 1,
+    srcs = default_platform_impl_test_support_srcs,
+    hdrs = default_platform_impl_test_support_hdrs,
+    strip_include_prefix = "common/platform/default",
+    deps = [
+        ":quiche_core",
+        "@com_google_absl//absl/flags:flag",
+        "@com_google_absl//absl/flags:parse",
+        "@com_google_absl//absl/flags:usage",
+        "@com_google_googletest//:gtest",
+    ],
+)
+
+proto_library(
+    name = "quiche_protobufs",
+    srcs = [
+        "quic/core/proto/cached_network_parameters.proto",
+        "quic/core/proto/crypto_server_config.proto",
+        "quic/core/proto/source_address_token.proto",
+    ],
+)
+
+cc_proto_library(
+    name = "quiche_protobufs_cc_proto",
+    deps = [":quiche_protobufs"],
+)
+
+proto_library(
+    name = "quiche_protobufs_testonly",
+    srcs = [
+        "quic/test_tools/send_algorithm_test_result.proto",
+    ],
+)
+
+cc_proto_library(
+    name = "quiche_protobufs_testonly_cc_proto",
+    deps = [":quiche_protobufs_testonly"],
+)
+
+cc_library(
+    name = "quiche_core",
+    srcs = quiche_core_srcs,
+    hdrs = quiche_core_hdrs,
+    textual_hdrs = ["http2/hpack/hpack_static_table_entries.inc"],
+    deps = [
+        ":quiche_platform_default",
+        ":quiche_protobufs_cc_proto",
+        "@boringssl//:crypto",
+        "@boringssl//:ssl",
+        "@com_google_absl//absl/algorithm:container",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:btree",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/container:inlined_vector",
+        "@com_google_absl//absl/container:node_hash_map",
+        "@com_google_absl//absl/hash",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/numeric:int128",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_absl//absl/types:span",
+        "@com_google_googleurl//url",
+        "@com_google_quic_trace//quic_trace:quic_trace_cc_proto",
+        "@zlib",
+    ],
+)
+
+cc_library(
+    name = "quiche_tool_support",
+    srcs = quiche_tool_support_srcs,
+    hdrs = quiche_tool_support_hdrs,
+    deps = [
+        ":quiche_core",
+        ":quiche_platform_default_tools",
+        "@boringssl//:crypto",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_googletest//:gtest",
+        "@com_google_googleurl//url",
+    ],
+)
+
+cc_library(
+    name = "quiche_test_support",
+    testonly = 1,
+    srcs = quiche_test_support_srcs,
+    hdrs = quiche_test_support_hdrs,
+    deps = [
+        ":quiche_core",
+        ":quiche_platform_default_testonly",
+        ":quiche_protobufs_testonly_cc_proto",
+        ":quiche_tool_support",
+        "@boringssl//:crypto",
+        "@boringssl//:ssl",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_googletest//:gtest",
+    ],
+)
+
+test_suite_from_source_list(
+    name = "quiche_tests",
+    srcs = quiche_tests_srcs,
+    data = glob([
+        "common/platform/api/testdir/**",
+        "quic/test_tools/quic_http_response_cache_data/**",
+    ]),
+    deps = [
+        ":quiche_core",
+        ":quiche_platform_default_testonly",
+        ":quiche_protobufs_testonly_cc_proto",
+        ":quiche_test_support",
+        ":quiche_tool_support",
+        "@boringssl//:crypto",
+        "@boringssl//:ssl",
+        "@com_google_absl//absl/algorithm:container",
+        "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/container:node_hash_map",
+        "@com_google_absl//absl/functional:bind_front",
+        "@com_google_absl//absl/hash",
+        "@com_google_absl//absl/memory",
+        "@com_google_absl//absl/numeric:int128",
+        "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:optional",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+# TODO(vasilvv): make a rule that generates cc_binary rules for all _bin targets.
+cc_binary(
+    name = "quic_packet_printer",
+    srcs = ["quic/tools/quic_packet_printer_bin.cc"],
+    deps = [
+        ":quiche_core",
+        ":quiche_tool_support",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+# Indicate that QUICHE APIs are explicitly unstable by providing only
+# appropriately named aliases as publicly visible targets.
+alias(
+    name = "quiche_unstable_api",
+    actual = ":quiche_core",
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "quiche_unstable_api_tool_support",
+    actual = ":quiche_tool_support",
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "quiche_unstable_api_test_support",
+    actual = ":quiche_test_support",
+    visibility = ["//visibility:public"],
+)

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_enums.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/common/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_enums.h"
 
 namespace quiche {
 
@@ -40,8 +40,8 @@ const char* BalsaFrameEnums::ParseStateToString(
 const char* BalsaFrameEnums::ErrorCodeToString(
     BalsaFrameEnums::ErrorCode error_code) {
   switch (error_code) {
-    case NO_ERROR:
-      return "NO_ERROR";
+    case BALSA_NO_ERROR:
+      return "BALSA_NO_ERROR";
     case NO_STATUS_LINE_IN_RESPONSE:
       return "NO_STATUS_LINE_IN_RESPONSE";
     case NO_REQUEST_LINE_IN_REQUEST:

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_enums.h

@@ -2,15 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_COMMON_BALSA_BALSA_ENUMS_H_
-#define QUICHE_COMMON_BALSA_BALSA_ENUMS_H_
+#ifndef QUICHE_BALSA_BALSA_ENUMS_H_
+#define QUICHE_BALSA_BALSA_ENUMS_H_
 
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace quiche {
 
 struct QUICHE_EXPORT_PRIVATE BalsaFrameEnums {
-  enum ParseState {
+  enum ParseState : int {
     ERROR,
     READING_HEADER_AND_FIRSTLINE,
     READING_CHUNK_LENGTH,
@@ -25,10 +25,10 @@ struct QUICHE_EXPORT_PRIVATE BalsaFrameEnums {
     NUM_STATES,
   };
 
-  enum ErrorCode {
+  enum ErrorCode : int {
     // A sentinel value for convenience, none of the callbacks should ever see
     // this error code.
-    NO_ERROR = 0,
+    BALSA_NO_ERROR = 0,
 
     // Header parsing errors
     // Note that adding one to many of the REQUEST errors yields the
@@ -113,7 +113,7 @@ struct QUICHE_EXPORT_PRIVATE BalsaFrameEnums {
 };
 
 struct QUICHE_EXPORT_PRIVATE BalsaHeadersEnums {
-  enum ContentLengthStatus {
+  enum ContentLengthStatus : int {
     INVALID_CONTENT_LENGTH,
     CONTENT_LENGTH_OVERFLOW,
     NO_CONTENT_LENGTH,
@@ -123,4 +123,4 @@ struct QUICHE_EXPORT_PRIVATE BalsaHeadersEnums {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_BALSA_ENUMS_H_
+#endif  // QUICHE_BALSA_BALSA_ENUMS_H_

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_frame.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/common/balsa/balsa_frame.h"
+#include "quiche/balsa/balsa_frame.h"
 
 #include <algorithm>
 #include <array>
@@ -17,12 +17,27 @@
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/balsa_headers.h"
-#include "quiche/common/balsa/balsa_visitor_interface.h"
-#include "quiche/common/balsa/header_properties.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_headers.h"
+#include "quiche/balsa/balsa_visitor_interface.h"
+#include "quiche/balsa/header_properties.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
+// When comparing characters (other than == and !=), cast to unsigned char
+// to make sure values above 127 rank as expected, even on platforms where char
+// is signed and thus such values are represented as negative numbers before the
+// cast.
+#define CHAR_LT(a, b) \
+  (static_cast<unsigned char>(a) < static_cast<unsigned char>(b))
+#define CHAR_LE(a, b) \
+  (static_cast<unsigned char>(a) <= static_cast<unsigned char>(b))
+#define CHAR_GT(a, b) \
+  (static_cast<unsigned char>(a) > static_cast<unsigned char>(b))
+#define CHAR_GE(a, b) \
+  (static_cast<unsigned char>(a) >= static_cast<unsigned char>(b))
+#define QUICHE_DCHECK_CHAR_GE(a, b) \
+  QUICHE_DCHECK_GE(static_cast<unsigned char>(a), static_cast<unsigned char>(b))
+
 namespace quiche {
 
 namespace {
@@ -53,7 +68,7 @@ void BalsaFrame::Reset() {
   last_slash_n_idx_ = 0;
   term_chars_ = 0;
   parse_state_ = BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE;
-  last_error_ = BalsaFrameEnums::NO_ERROR;
+  last_error_ = BalsaFrameEnums::BALSA_NO_ERROR;
   invalid_chars_.clear();
   lines_.clear();
   if (continue_headers_ != nullptr) {
@@ -88,11 +103,11 @@ inline const char* ParseOneIsland(const char* current, const char* begin,
                                   const char* end, size_t* first_whitespace,
                                   size_t* first_nonwhite) {
   *first_whitespace = current - begin;
-  while (current < end && *current <= ' ') {
+  while (current < end && CHAR_LE(*current, ' ')) {
     ++current;
   }
   *first_nonwhite = current - begin;
-  while (current<end&& * current> ' ') {
+  while (current < end && CHAR_GT(*current, ' ')) {
     ++current;
   }
   return current;
@@ -151,14 +166,14 @@ bool ParseHTTPFirstLine(const char* begin, const char* end, bool is_request,
 
   // Clean up any trailing whitespace that comes after the third island
   const char* last = end;
-  while (current <= last && *last <= ' ') {
+  while (current <= last && CHAR_LE(*last, ' ')) {
     --last;
   }
   headers->whitespace_4_idx_ = last - begin + 1;
 
   // Either the passed-in line is empty, or it starts with a non-whitespace
   // character.
-  QUICHE_DCHECK(begin == end || *begin > ' ');
+  QUICHE_DCHECK(begin == end || static_cast<unsigned char>(*begin) > ' ');
 
   QUICHE_DCHECK_EQ(0u, headers->whitespace_1_idx_);
   QUICHE_DCHECK_EQ(0u, headers->non_whitespace_1_idx_);
@@ -184,7 +199,7 @@ bool ParseHTTPFirstLine(const char* begin, const char* end, bool is_request,
     }
   }
   if (headers->whitespace_3_idx_ == headers->non_whitespace_3_idx_) {
-    if (*error_code == BalsaFrameEnums::NO_ERROR) {
+    if (*error_code == BalsaFrameEnums::BALSA_NO_ERROR) {
       // FAILED_TO_FIND_WS_AFTER_REQUEST_METHOD   for request
       // FAILED_TO_FIND_WS_AFTER_RESPONSE_VERSION for response
       *error_code = static_cast<BalsaFrameEnums::ErrorCode>(
@@ -268,13 +283,13 @@ void BalsaFrame::CleanUpKeyValueWhitespace(
   QUICHE_DCHECK_LT(colon_loc, line_end);
   QUICHE_DCHECK_EQ(':', *colon_loc);
   QUICHE_DCHECK_EQ(':', *current);
-  QUICHE_DCHECK_GE(' ', *line_end)
+  QUICHE_DCHECK_CHAR_GE(' ', *line_end)
       << "\"" << std::string(line_begin, line_end) << "\"";
 
   // TODO(fenix): Investigate whether or not the bounds tests in the
   // while loops here are redundant, and if so, remove them.
   --current;
-  while (current > line_begin && *current <= ' ') {
+  while (current > line_begin && CHAR_LE(*current, ' ')) {
     --current;
   }
   current += static_cast<int>(current != colon_loc);
@@ -283,7 +298,7 @@ void BalsaFrame::CleanUpKeyValueWhitespace(
   current = colon_loc;
   QUICHE_DCHECK_EQ(':', *current);
   ++current;
-  while (current < line_end && *current <= ' ') {
+  while (current < line_end && CHAR_LE(*current, ' ')) {
     ++current;
   }
   current_header_line->value_begin_idx = current - stream_begin;
@@ -323,7 +338,7 @@ bool BalsaFrame::FindColonsAndParseIntoKeyValue(const Lines& lines,
     // "\r\n", etc -within- the line (and not just at the end of it).
     for (++i; i < lines_size_m1; ++i) {
       const char c = *(stream_begin + lines[i].first);
-      if (c > ' ') {
+      if (CHAR_GT(c, ' ')) {
         // Not a continuation, so stop.  Note that if the 'original' i = 1,
         // and the next line is not a continuation, we'll end up with i = 2
         // when we break. This handles the incrementing of i for the outer
@@ -355,11 +370,11 @@ bool BalsaFrame::FindColonsAndParseIntoKeyValue(const Lines& lines,
     --line_end;
     QUICHE_DCHECK_EQ('\n', *line_end)
         << "\"" << std::string(line_begin, line_end) << "\"";
-    while (*line_end <= ' ' && line_end > line_begin) {
+    while (CHAR_LE(*line_end, ' ') && line_end > line_begin) {
       --line_end;
     }
     ++line_end;
-    QUICHE_DCHECK_GE(' ', *line_end);
+    QUICHE_DCHECK_CHAR_GE(' ', *line_end);
     QUICHE_DCHECK_LT(line_begin, line_end);
 
     // We use '0' for the block idx, because we're always writing to the first
@@ -731,7 +746,7 @@ size_t BalsaFrame::ProcessHeaders(const char* message_start,
       do {
         const char c = *message_current;
         if (c != '\r' && c != '\n') {
-          if (c <= ' ') {
+          if (CHAR_LE(c, ' ')) {
             HandleError(BalsaFrameEnums::NO_REQUEST_LINE_IN_REQUEST);
             return message_current - original_message_start;
           }
@@ -1294,3 +1309,9 @@ const int32_t BalsaFrame::kValidTerm2;
 const int32_t BalsaFrame::kValidTerm2Mask;
 
 }  // namespace quiche
+
+#undef CHAR_LT
+#undef CHAR_LE
+#undef CHAR_GT
+#undef CHAR_GE
+#undef QUICHE_DCHECK_CHAR_GE

package/third_party/quiche/quiche/{common/balsa → balsa}/balsa_frame.h

@@ -2,20 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_COMMON_BALSA_BALSA_FRAME_H_
-#define QUICHE_COMMON_BALSA_BALSA_FRAME_H_
+#ifndef QUICHE_BALSA_BALSA_FRAME_H_
+#define QUICHE_BALSA_BALSA_FRAME_H_
 
 #include <cstddef>
 #include <cstdint>
 #include <utility>
 #include <vector>
 
-#include "quiche/common/balsa/balsa_enums.h"
-#include "quiche/common/balsa/balsa_headers.h"
-#include "quiche/common/balsa/balsa_visitor_interface.h"
-#include "quiche/common/balsa/framer_interface.h"
-#include "quiche/common/balsa/http_validation_policy.h"
-#include "quiche/common/balsa/noop_balsa_visitor.h"
+#include "absl/container/flat_hash_map.h"
+#include "quiche/balsa/balsa_enums.h"
+#include "quiche/balsa/balsa_headers.h"
+#include "quiche/balsa/balsa_visitor_interface.h"
+#include "quiche/balsa/framer_interface.h"
+#include "quiche/balsa/http_validation_policy.h"
+#include "quiche/balsa/noop_balsa_visitor.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
@@ -60,7 +61,7 @@ class QUICHE_EXPORT_PRIVATE BalsaFrame : public FramerInterface {
         last_slash_n_idx_(0),
         term_chars_(0),
         parse_state_(BalsaFrameEnums::READING_HEADER_AND_FIRSTLINE),
-        last_error_(BalsaFrameEnums::NO_ERROR),
+        last_error_(BalsaFrameEnums::BALSA_NO_ERROR),
         continue_headers_(nullptr),
         headers_(nullptr),
         start_of_trailer_line_(0),
@@ -311,4 +312,4 @@ class QUICHE_EXPORT_PRIVATE BalsaFrame : public FramerInterface {
 
 }  // namespace quiche
 
-#endif  // QUICHE_COMMON_BALSA_BALSA_FRAME_H_
+#endif  // QUICHE_BALSA_BALSA_FRAME_H_