Implement a parser for MOQT track name format.

vasilvv · copybara-github · commit 949946d02310 · 2026-02-12T15:35:50.000-08:00
PiperOrigin-RevId: 869414824
diff --git a/quiche/quic/moqt/moqt_names.cc b/quiche/quic/moqt/moqt_names.cc
@@ -9,14 +9,18 @@
 #include <string>
 #include <utility>
 
+#include "absl/container/fixed_array.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_status_utils.h"
 
 namespace moqt {
 
@@ -53,6 +57,109 @@ void AppendEscapedTrackNameTuple(const MoqtStringTuple& tuple,
   }
 }
 
+[[nodiscard]] bool HexCharToLowerHalfOfByte(char c, char& output) {
+  if (c >= '0' && c <= '9') {
+    output |= c - '0';
+    return true;
+  }
+  if (c >= 'a' && c <= 'f') {
+    output |= (c - 'a') + 0xa;
+    return true;
+  }
+  return false;
+}
+
+// Custom hex-to-binary converter that disallows uppercase hex, as the
+// specification explicitly requires lowercase hex.
+[[nodiscard]] bool HexEncodedBitToByte(char c0, char c1, char& output) {
+  output = 0;
+  if (!HexCharToLowerHalfOfByte(c0, output)) {
+    return false;
+  }
+  output <<= 4;
+  if (!HexCharToLowerHalfOfByte(c1, output)) {
+    return false;
+  }
+  return true;
+}
+
+// The MOQT specification is currently ambiguous regarding how permissive the
+// parsing should be.  We are intentionally taking a "strict" approach, in which
+// any track name that this code parses successfully will result in a byte-exact
+// serialization from `ToString()`.  For the discussion of this issue, see
+// <https://github.com/moq-wg/moq-transport/issues/1501>.
+//
+// It is up to the caller to reserve the capacity in `output_tuple` in advance.
+absl::Status UnescapeTrackNameComponent(absl::string_view input,
+                                        MoqtStringTuple& output_tuple) {
+  // The unescaping algorithm always results in strings of the same or smaller
+  // size, so the fixed array of size `input.size()` will always fit the output.
+  absl::FixedArray<char> output_buffer(input.size());
+  absl::Span<char> output = absl::MakeSpan(output_buffer);
+  while (!input.empty()) {
+    if (IsTrackNameSafeCharacter(input[0])) {
+      output[0] = input[0];
+      input.remove_prefix(1);
+      output.remove_prefix(1);
+      continue;
+    }
+    if (input[0] == '.') {
+      if (input.size() < 3) {
+        return absl::InvalidArgumentError("Incomplete escape sequence");
+      }
+      if (!HexEncodedBitToByte(input[1], input[2], output[0])) {
+        return absl::InvalidArgumentError("Invalid hex in an escape sequence");
+      }
+      if (IsTrackNameSafeCharacter(output[0])) {
+        return absl::InvalidArgumentError("Hex-encoding a safe character");
+      }
+      input.remove_prefix(3);
+      output.remove_prefix(1);
+      continue;
+    }
+    return absl::InvalidArgumentError(
+        absl::StrFormat("Invalid character 0x%02x encountered", input[0]));
+  }
+  size_t output_size = output_buffer.size() - output.size();
+  if (!output_tuple.Add(absl::string_view(output_buffer.data(), output_size))) {
+    return absl::OutOfRangeError("Maximum tuple size exceeded");
+  }
+  return absl::OkStatus();
+}
+
+absl::StatusOr<MoqtStringTuple> ParseNameTuple(absl::string_view input) {
+  // Special-case empty namespace, to indicate it is {} and not {""}.
+  if (input.empty()) {
+    return MoqtStringTuple();
+  }
+
+  ssize_t bytes_to_reserve = input.size();
+  ssize_t elements_to_reserve = 1;
+  for (char c : input) {
+    if (c == '-') {
+      ++elements_to_reserve;
+      --bytes_to_reserve;
+    }
+    if (c == '.') {
+      bytes_to_reserve -= 2;
+    }
+  }
+
+  MoqtStringTuple tuple;
+  if (bytes_to_reserve > 0) {
+    // A malformed name such as `......` will result in `bytes_to_reserve` being
+    // negative.
+    tuple.ReserveDataBytes(bytes_to_reserve);
+  }
+  tuple.ReserveTupleElements(elements_to_reserve);
+  for (absl::string_view bit : absl::StrSplit(input, '-')) {
+    QUICHE_RETURN_IF_ERROR(UnescapeTrackNameComponent(bit, tuple));
+  }
+  QUICHE_DCHECK_EQ(tuple.TotalBytes(), bytes_to_reserve);
+  QUICHE_DCHECK_EQ(tuple.size(), elements_to_reserve);
+  return tuple;
+}
+
 }  // namespace
 
 absl::StatusOr<TrackNamespace> TrackNamespace::Create(MoqtStringTuple tuple) {
@@ -64,6 +171,12 @@ absl::StatusOr<TrackNamespace> TrackNamespace::Create(MoqtStringTuple tuple) {
   return TrackNamespace(std::move(tuple));
 }
 
+absl::StatusOr<TrackNamespace> TrackNamespace::Parse(absl::string_view input) {
+  absl::StatusOr<MoqtStringTuple> tuple = ParseNameTuple(input);
+  QUICHE_RETURN_IF_ERROR(tuple.status());
+  return Create(*std::move(tuple));
+}
+
 TrackNamespace::TrackNamespace(std::initializer_list<absl::string_view> tuple) {
   bool success = tuple_.Append(tuple);
   if (!success) {
@@ -111,6 +224,28 @@ absl::StatusOr<FullTrackName> FullTrackName::Create(TrackNamespace ns,
                        FullTrackNameIsValidTag());
 }
 
+absl::StatusOr<FullTrackName> FullTrackName::Parse(absl::string_view input) {
+  absl::StatusOr<MoqtStringTuple> tuple = ParseNameTuple(input);
+  QUICHE_RETURN_IF_ERROR(tuple.status());
+  if (tuple->size() < 3) {
+    return absl::InvalidArgumentError("Full track name is missing elements");
+  }
+  std::string name(tuple->back());
+  tuple->Pop();
+  if (!tuple->back().empty()) {
+    return absl::InvalidArgumentError(
+        "Full track name must use -- as a separator");
+  }
+  tuple->Pop();
+  if (tuple->size() == 1 && tuple->ValueAt(0) == "") {
+    // Special case handling for empty namespace.
+    tuple->Pop();
+  }
+  absl::StatusOr<TrackNamespace> ns = TrackNamespace::Create(*std::move(tuple));
+  QUICHE_RETURN_IF_ERROR(ns.status());
+  return Create(*std::move(ns), std::move(name));
+}
+
 FullTrackName::FullTrackName(TrackNamespace ns, absl::string_view name)
     : namespace_(std::move(ns)), name_(name) {
   if (namespace_.total_length() + name.size() > kMaxFullTrackNameSize) {
diff --git a/quiche/quic/moqt/moqt_names.h b/quiche/quic/moqt/moqt_names.h
@@ -36,6 +36,8 @@ class TrackNamespace {
  public:
   static absl::StatusOr<TrackNamespace> Create(MoqtStringTuple tuple);
 
+  static absl::StatusOr<TrackNamespace> Parse(absl::string_view input);
+
   TrackNamespace() = default;
 
   explicit TrackNamespace(std::initializer_list<absl::string_view> tuple);
@@ -110,6 +112,8 @@ class FullTrackName {
   static absl::StatusOr<FullTrackName> Create(TrackNamespace ns,
                                               std::string name);
 
+  static absl::StatusOr<FullTrackName> Parse(absl::string_view input);
+
   FullTrackName() = default;
 
   // Convenience constructor. QUICHE_BUGs if the resulting full track name is
diff --git a/quiche/quic/moqt/moqt_names_test.cc b/quiche/quic/moqt/moqt_names_test.cc
@@ -4,20 +4,26 @@
 
 #include "quiche/quic/moqt/moqt_names.h"
 
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/hash/hash.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "quiche/common/platform/api/quiche_expect_bug.h"
+#include "quiche/common/platform/api/quiche_fuzztest.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_status_utils.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
 namespace moqt::test {
 namespace {
 
+using ::quiche::test::IsOkAndHolds;
 using ::quiche::test::StatusIs;
+using ::testing::ElementsAre;
 using ::testing::HasSubstr;
 
 TEST(MoqtNamesTest, TrackNamespaceConstructors) {
@@ -129,5 +135,100 @@ TEST(MoqtNamesTest, FullTrackNameTooLong) {
                     "TrackNamspace constructor");
 }
 
+absl::StatusOr<MoqtStringTuple> ParseNamespace(absl::string_view input) {
+  absl::StatusOr<TrackNamespace> ns = TrackNamespace::Parse(input);
+  QUICHE_RETURN_IF_ERROR(ns.status());
+  return ns->tuple();
+}
+
+TEST(MoqtNamesTest, ParseNamespace) {
+  EXPECT_THAT(ParseNamespace(""), IsOkAndHolds(ElementsAre()));
+  EXPECT_THAT(ParseNamespace("foo"), IsOkAndHolds(ElementsAre("foo")));
+  EXPECT_THAT(ParseNamespace("foo-bar"),
+              IsOkAndHolds(ElementsAre("foo", "bar")));
+  EXPECT_THAT(ParseNamespace("foo-bar--test"),
+              IsOkAndHolds(ElementsAre("foo", "bar", "", "test")));
+  EXPECT_THAT(ParseNamespace("foo-.ff"),
+              IsOkAndHolds(ElementsAre("foo", "\xff")));
+  EXPECT_THAT(ParseNamespace("foo-.f"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "Incomplete escape sequence"));
+  EXPECT_THAT(
+      ParseNamespace("foo-.zz"),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("Invalid hex")));
+  EXPECT_THAT(
+      ParseNamespace("foo-.FF"),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("Invalid hex")));
+  EXPECT_THAT(
+      ParseNamespace("foo-.0z"),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("Invalid hex")));
+  EXPECT_THAT(ParseNamespace("foo-.61"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("Hex-encoding a safe character")));
+  EXPECT_THAT(
+      ParseNamespace("................"),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("Invalid hex")));
+  EXPECT_THAT(ParseNamespace("foo-\xff"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("Invalid character 0xff")));
+  std::string long_string(2 * kMaxFullTrackNameSize, 'a');
+  EXPECT_THAT(
+      ParseNamespace(long_string),
+      StatusIs(absl::StatusCode::kOutOfRange, "Maximum tuple size exceeded"));
+}
+
+TEST(MoqtNamesTest, ParseFullTrackName) {
+  EXPECT_THAT(FullTrackName::Parse("foo-bar--test"),
+              IsOkAndHolds(FullTrackName({"foo", "bar"}, "test")));
+  EXPECT_THAT(FullTrackName::Parse("foo--bar--test"),
+              IsOkAndHolds(FullTrackName({"foo", "", "bar"}, "test")));
+  EXPECT_THAT(FullTrackName::Parse("--test"),
+              IsOkAndHolds(FullTrackName({}, "test")));
+  EXPECT_THAT(
+      FullTrackName::Parse("a-b-c-d-e-f"),
+      StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("must use --")));
+  EXPECT_THAT(FullTrackName::Parse("foo-bar"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("missing elements")));
+}
+
+void FuzzParseNamespace(absl::string_view encoded_namespace) {
+  (void)TrackNamespace::Parse(encoded_namespace);
+}
+
+void FuzzParseFullTrackName(absl::string_view encoded_track_name) {
+  (void)FullTrackName::Parse(encoded_track_name);
+}
+
+void SerializeAndParseNamespace(const std::vector<std::string>& elements) {
+  if (elements.empty() || elements[0].empty()) {
+    return;
+  }
+
+  TrackNamespace ns;
+  for (const std::string& element : elements) {
+    if (!ns.AddElement(element)) {
+      return;
+    }
+  }
+  absl::StatusOr<TrackNamespace> round_trip_result =
+      TrackNamespace::Parse(ns.ToString());
+  QUICHE_ASSERT_OK(round_trip_result.status());
+  EXPECT_EQ(ns, *round_trip_result);
+}
+
+void ParseAndSerializeNamespace(absl::string_view encoded_namespace) {
+  absl::StatusOr<TrackNamespace> ns = TrackNamespace::Parse(encoded_namespace);
+  if (!ns.ok()) {
+    return;
+  }
+  EXPECT_EQ(ns->ToString(), encoded_namespace);
+}
+
+FUZZ_TEST(MoqtNamesTest, FuzzParseNamespace);
+FUZZ_TEST(MoqtNamesTest, FuzzParseFullTrackName);
+FUZZ_TEST(MoqtNamesTest, SerializeAndParseNamespace);
+FUZZ_TEST(MoqtNamesTest, ParseAndSerializeNamespace);
+
 }  // namespace
 }  // namespace moqt::test
