blob: d55fe4d0ec07989715272fb78eb82d19231156b6 [file] [log] [blame] [edit]
// Copyright (c) 2023 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 "quiche/quic/moqt/moqt_framer.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/moqt/moqt_messages.h"
#include "quiche/quic/moqt/moqt_priority.h"
#include "quiche/quic/moqt/test_tools/moqt_test_message.h"
#include "quiche/quic/platform/api/quic_expect_bug.h"
#include "quiche/quic/platform/api/quic_test.h"
#include "quiche/common/quiche_buffer_allocator.h"
#include "quiche/common/simple_buffer_allocator.h"
#include "quiche/common/test_tools/quiche_test_utils.h"
namespace moqt::test {
struct MoqtFramerTestParams {
MoqtFramerTestParams(MoqtMessageType message_type, bool uses_web_transport)
: message_type(message_type), uses_web_transport(uses_web_transport) {}
MoqtMessageType message_type;
bool uses_web_transport;
};
std::vector<MoqtFramerTestParams> GetMoqtFramerTestParams() {
std::vector<MoqtFramerTestParams> params;
std::vector<MoqtMessageType> message_types = {
MoqtMessageType::kSubscribe,
MoqtMessageType::kSubscribeOk,
MoqtMessageType::kSubscribeError,
MoqtMessageType::kUnsubscribe,
MoqtMessageType::kSubscribeDone,
MoqtMessageType::kAnnounceCancel,
MoqtMessageType::kTrackStatusRequest,
MoqtMessageType::kTrackStatus,
MoqtMessageType::kAnnounce,
MoqtMessageType::kAnnounceOk,
MoqtMessageType::kAnnounceError,
MoqtMessageType::kUnannounce,
MoqtMessageType::kGoAway,
MoqtMessageType::kSubscribeAnnounces,
MoqtMessageType::kSubscribeAnnouncesOk,
MoqtMessageType::kSubscribeAnnouncesError,
MoqtMessageType::kUnsubscribeAnnounces,
MoqtMessageType::kMaxSubscribeId,
MoqtMessageType::kFetch,
MoqtMessageType::kFetchCancel,
MoqtMessageType::kFetchOk,
MoqtMessageType::kFetchError,
MoqtMessageType::kSubscribesBlocked,
MoqtMessageType::kObjectAck,
MoqtMessageType::kClientSetup,
MoqtMessageType::kServerSetup,
};
for (const MoqtMessageType message_type : message_types) {
if (message_type == MoqtMessageType::kClientSetup) {
for (const bool uses_web_transport : {false, true}) {
params.push_back(
MoqtFramerTestParams(message_type, uses_web_transport));
}
} else {
// All other types are processed the same for either perspective or
// transport.
params.push_back(MoqtFramerTestParams(message_type, true));
}
}
return params;
}
std::string ParamNameFormatter(
const testing::TestParamInfo<MoqtFramerTestParams>& info) {
return MoqtMessageTypeToString(info.param.message_type) + "_" +
(info.param.uses_web_transport ? "WebTransport" : "QUIC");
}
quiche::QuicheBuffer SerializeObject(MoqtFramer& framer,
const MoqtObject& message,
absl::string_view payload,
MoqtDataStreamType stream_type,
bool is_first_in_stream) {
MoqtObject adjusted_message = message;
adjusted_message.payload_length = payload.size();
quiche::QuicheBuffer header =
(stream_type == MoqtDataStreamType::kObjectDatagram)
? framer.SerializeObjectDatagram(adjusted_message, payload)
: framer.SerializeObjectHeader(adjusted_message, stream_type,
is_first_in_stream);
if (header.empty()) {
return quiche::QuicheBuffer();
}
return quiche::QuicheBuffer::Copy(
quiche::SimpleBufferAllocator::Get(),
absl::StrCat(header.AsStringView(), payload));
}
class MoqtFramerTest
: public quic::test::QuicTestWithParam<MoqtFramerTestParams> {
public:
MoqtFramerTest()
: message_type_(GetParam().message_type),
webtrans_(GetParam().uses_web_transport),
buffer_allocator_(quiche::SimpleBufferAllocator::Get()),
framer_(buffer_allocator_, GetParam().uses_web_transport) {}
std::unique_ptr<TestMessageBase> MakeMessage(MoqtMessageType message_type) {
return CreateTestMessage(message_type, webtrans_);
}
quiche::QuicheBuffer SerializeMessage(
TestMessageBase::MessageStructuredData& structured_data) {
switch (message_type_) {
case MoqtMessageType::kSubscribe: {
auto data = std::get<MoqtSubscribe>(structured_data);
return framer_.SerializeSubscribe(data);
}
case MoqtMessageType::kSubscribeOk: {
auto data = std::get<MoqtSubscribeOk>(structured_data);
return framer_.SerializeSubscribeOk(data);
}
case MoqtMessageType::kSubscribeError: {
auto data = std::get<MoqtSubscribeError>(structured_data);
return framer_.SerializeSubscribeError(data);
}
case MoqtMessageType::kUnsubscribe: {
auto data = std::get<MoqtUnsubscribe>(structured_data);
return framer_.SerializeUnsubscribe(data);
}
case MoqtMessageType::kSubscribeDone: {
auto data = std::get<MoqtSubscribeDone>(structured_data);
return framer_.SerializeSubscribeDone(data);
}
case MoqtMessageType::kAnnounce: {
auto data = std::get<MoqtAnnounce>(structured_data);
return framer_.SerializeAnnounce(data);
}
case moqt::MoqtMessageType::kAnnounceOk: {
auto data = std::get<MoqtAnnounceOk>(structured_data);
return framer_.SerializeAnnounceOk(data);
}
case moqt::MoqtMessageType::kAnnounceError: {
auto data = std::get<MoqtAnnounceError>(structured_data);
return framer_.SerializeAnnounceError(data);
}
case moqt::MoqtMessageType::kAnnounceCancel: {
auto data = std::get<MoqtAnnounceCancel>(structured_data);
return framer_.SerializeAnnounceCancel(data);
}
case moqt::MoqtMessageType::kTrackStatusRequest: {
auto data = std::get<MoqtTrackStatusRequest>(structured_data);
return framer_.SerializeTrackStatusRequest(data);
}
case MoqtMessageType::kUnannounce: {
auto data = std::get<MoqtUnannounce>(structured_data);
return framer_.SerializeUnannounce(data);
}
case moqt::MoqtMessageType::kTrackStatus: {
auto data = std::get<MoqtTrackStatus>(structured_data);
return framer_.SerializeTrackStatus(data);
}
case moqt::MoqtMessageType::kGoAway: {
auto data = std::get<MoqtGoAway>(structured_data);
return framer_.SerializeGoAway(data);
}
case moqt::MoqtMessageType::kSubscribeAnnounces: {
auto data = std::get<MoqtSubscribeAnnounces>(structured_data);
return framer_.SerializeSubscribeAnnounces(data);
}
case moqt::MoqtMessageType::kSubscribeAnnouncesOk: {
auto data = std::get<MoqtSubscribeAnnouncesOk>(structured_data);
return framer_.SerializeSubscribeAnnouncesOk(data);
}
case moqt::MoqtMessageType::kSubscribeAnnouncesError: {
auto data = std::get<MoqtSubscribeAnnouncesError>(structured_data);
return framer_.SerializeSubscribeAnnouncesError(data);
}
case moqt::MoqtMessageType::kUnsubscribeAnnounces: {
auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data);
return framer_.SerializeUnsubscribeAnnounces(data);
}
case moqt::MoqtMessageType::kMaxSubscribeId: {
auto data = std::get<MoqtMaxSubscribeId>(structured_data);
return framer_.SerializeMaxSubscribeId(data);
}
case moqt::MoqtMessageType::kFetch: {
auto data = std::get<MoqtFetch>(structured_data);
return framer_.SerializeFetch(data);
}
case moqt::MoqtMessageType::kFetchCancel: {
auto data = std::get<MoqtFetchCancel>(structured_data);
return framer_.SerializeFetchCancel(data);
}
case moqt::MoqtMessageType::kFetchOk: {
auto data = std::get<MoqtFetchOk>(structured_data);
return framer_.SerializeFetchOk(data);
}
case moqt::MoqtMessageType::kFetchError: {
auto data = std::get<MoqtFetchError>(structured_data);
return framer_.SerializeFetchError(data);
}
case moqt::MoqtMessageType::kSubscribesBlocked: {
auto data = std::get<MoqtSubscribesBlocked>(structured_data);
return framer_.SerializeSubscribesBlocked(data);
}
case moqt::MoqtMessageType::kObjectAck: {
auto data = std::get<MoqtObjectAck>(structured_data);
return framer_.SerializeObjectAck(data);
}
case MoqtMessageType::kClientSetup: {
auto data = std::get<MoqtClientSetup>(structured_data);
return framer_.SerializeClientSetup(data);
}
case MoqtMessageType::kServerSetup: {
auto data = std::get<MoqtServerSetup>(structured_data);
return framer_.SerializeServerSetup(data);
}
default:
// kObjectDatagram is a totally different code path.
return quiche::QuicheBuffer();
}
}
MoqtMessageType message_type_;
bool webtrans_;
quiche::SimpleBufferAllocator* buffer_allocator_;
MoqtFramer framer_;
};
INSTANTIATE_TEST_SUITE_P(MoqtFramerTests, MoqtFramerTest,
testing::ValuesIn(GetMoqtFramerTestParams()),
ParamNameFormatter);
TEST_P(MoqtFramerTest, OneMessage) {
auto message = MakeMessage(message_type_);
auto structured_data = message->structured_data();
auto buffer = SerializeMessage(structured_data);
EXPECT_EQ(buffer.size(), message->total_message_size());
quiche::test::CompareCharArraysWithHexError(
"frame encoding", buffer.data(), buffer.size(),
message->PacketSample().data(), message->PacketSample().size());
}
class MoqtFramerSimpleTest : public quic::test::QuicTest {
public:
MoqtFramerSimpleTest()
: buffer_allocator_(quiche::SimpleBufferAllocator::Get()),
framer_(buffer_allocator_, /*web_transport=*/true) {}
quiche::SimpleBufferAllocator* buffer_allocator_;
MoqtFramer framer_;
// Obtain a pointer to an arbitrary offset in a serialized buffer.
const uint8_t* BufferAtOffset(quiche::QuicheBuffer& buffer, size_t offset) {
const char* data = buffer.data();
return reinterpret_cast<const uint8_t*>(data + offset);
}
};
TEST_F(MoqtFramerSimpleTest, GroupMiddler) {
auto header = std::make_unique<StreamHeaderSubgroupMessage>();
auto buffer1 =
SerializeObject(framer_, std::get<MoqtObject>(header->structured_data()),
"foo", MoqtDataStreamType::kStreamHeaderSubgroup, true);
EXPECT_EQ(buffer1.size(), header->total_message_size());
EXPECT_EQ(buffer1.AsStringView(), header->PacketSample());
auto middler = std::make_unique<StreamMiddlerSubgroupMessage>();
auto buffer2 =
SerializeObject(framer_, std::get<MoqtObject>(middler->structured_data()),
"bar", MoqtDataStreamType::kStreamHeaderSubgroup, false);
EXPECT_EQ(buffer2.size(), middler->total_message_size());
EXPECT_EQ(buffer2.AsStringView(), middler->PacketSample());
}
TEST_F(MoqtFramerSimpleTest, FetchMiddler) {
auto header = std::make_unique<StreamHeaderFetchMessage>();
auto buffer1 =
SerializeObject(framer_, std::get<MoqtObject>(header->structured_data()),
"foo", MoqtDataStreamType::kStreamHeaderFetch, true);
EXPECT_EQ(buffer1.size(), header->total_message_size());
EXPECT_EQ(buffer1.AsStringView(), header->PacketSample());
auto middler = std::make_unique<StreamMiddlerFetchMessage>();
auto buffer2 =
SerializeObject(framer_, std::get<MoqtObject>(middler->structured_data()),
"bar", MoqtDataStreamType::kStreamHeaderFetch, false);
EXPECT_EQ(buffer2.size(), middler->total_message_size());
EXPECT_EQ(buffer2.AsStringView(), middler->PacketSample());
}
TEST_F(MoqtFramerSimpleTest, BadObjectInput) {
MoqtObject object = {
// This is a valid object.
/*track_alias=*/4,
/*group_id=*/5,
/*object_id=*/6,
/*publisher_priority=*/7,
/*object_status=*/MoqtObjectStatus::kNormal,
/*subgroup_id=*/8,
/*payload_length=*/3,
};
quiche::QuicheBuffer buffer;
// kSubgroup must have a subgroup_id.
object.subgroup_id = std::nullopt;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
object, MoqtDataStreamType::kStreamHeaderSubgroup, false),
"Object metadata is invalid");
EXPECT_TRUE(buffer.empty());
object.subgroup_id = 8;
// kFetch must have a subgroup_id.
object.subgroup_id = std::nullopt;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
object, MoqtDataStreamType::kStreamHeaderFetch, false),
"Object metadata is invalid");
EXPECT_TRUE(buffer.empty());
object.subgroup_id = 8;
// Non-normal status must have no payload.
object.object_status = MoqtObjectStatus::kEndOfGroup;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
object, MoqtDataStreamType::kStreamHeaderSubgroup, false),
"Object metadata is invalid");
EXPECT_TRUE(buffer.empty());
// object.object_status = MoqtObjectStatus::kNormal;
}
TEST_F(MoqtFramerSimpleTest, BadDatagramInput) {
MoqtObject object = {
// This is a valid datagram.
/*track_alias=*/4,
/*group_id=*/5,
/*object_id=*/6,
/*publisher_priority=*/7,
/*object_status=*/MoqtObjectStatus::kNormal,
/*subgroup_id=*/std::nullopt,
/*payload_length=*/3,
};
quiche::QuicheBuffer buffer;
// No datagrams to SerializeObjectHeader().
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
object, MoqtDataStreamType::kObjectDatagram, false),
"Datagrams use SerializeObjectDatagram()")
EXPECT_TRUE(buffer.empty());
object.object_status = MoqtObjectStatus::kEndOfGroup;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foo"),
"Object metadata is invalid");
EXPECT_TRUE(buffer.empty());
object.object_status = MoqtObjectStatus::kNormal;
object.subgroup_id = 8;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foo"),
"Object metadata is invalid");
EXPECT_TRUE(buffer.empty());
object.subgroup_id = std::nullopt;
EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foobar"),
"Payload length does not match payload");
EXPECT_TRUE(buffer.empty());
}
TEST_F(MoqtFramerSimpleTest, Datagram) {
auto datagram = std::make_unique<ObjectDatagramMessage>();
MoqtObject object = {
/*track_alias=*/4,
/*group_id=*/5,
/*object_id=*/6,
/*publisher_priority=*/7,
/*object_status=*/MoqtObjectStatus::kNormal,
/*subgroup_id=*/std::nullopt,
/*payload_length=*/3,
};
std::string payload = "foo";
quiche::QuicheBuffer buffer;
buffer = framer_.SerializeObjectDatagram(object, payload);
EXPECT_EQ(buffer.size(), datagram->total_message_size());
EXPECT_EQ(buffer.AsStringView(), datagram->PacketSample());
}
TEST_F(MoqtFramerSimpleTest, AllSubscribeInputs) {
for (std::optional<uint64_t> start_group :
{std::optional<uint64_t>(), std::optional<uint64_t>(4)}) {
for (std::optional<uint64_t> start_object :
{std::optional<uint64_t>(), std::optional<uint64_t>(0)}) {
for (std::optional<uint64_t> end_group :
{std::optional<uint64_t>(), std::optional<uint64_t>(7)}) {
for (std::optional<uint64_t> end_object :
{std::optional<uint64_t>(), std::optional<uint64_t>(3)}) {
MoqtSubscribe subscribe = {
/*subscribe_id=*/3,
/*track_alias=*/4,
/*full_track_name=*/FullTrackName({"foo", "abcd"}),
/*subscriber_priority=*/0x20,
/*group_order=*/std::nullopt,
start_group,
start_object,
end_group,
end_object,
MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt,
std::nullopt},
};
quiche::QuicheBuffer buffer;
MoqtFilterType expected_filter_type = MoqtFilterType::kNone;
if (!start_group.has_value() && !start_object.has_value() &&
!end_group.has_value() && !end_object.has_value()) {
expected_filter_type = MoqtFilterType::kLatestObject;
} else if (!start_group.has_value() && start_object.has_value() &&
*start_object == 0 && !end_group.has_value() &&
!end_object.has_value()) {
expected_filter_type = MoqtFilterType::kLatestGroup;
} else if (start_group.has_value() && start_object.has_value() &&
!end_group.has_value() && !end_object.has_value()) {
expected_filter_type = MoqtFilterType::kAbsoluteStart;
} else if (start_group.has_value() && start_object.has_value() &&
end_group.has_value()) {
expected_filter_type = MoqtFilterType::kAbsoluteRange;
}
if (expected_filter_type == MoqtFilterType::kNone) {
EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
"Invalid object range");
EXPECT_EQ(buffer.size(), 0);
continue;
}
buffer = framer_.SerializeSubscribe(subscribe);
// Go to the filter type.
const uint8_t* read = BufferAtOffset(buffer, 16);
EXPECT_EQ(static_cast<MoqtFilterType>(*read), expected_filter_type);
EXPECT_GT(buffer.size(), 0);
if (expected_filter_type == MoqtFilterType::kAbsoluteRange &&
end_object.has_value()) {
const uint8_t* object_id = read + 4;
EXPECT_EQ(*object_id, *end_object + 1);
}
}
}
}
}
}
TEST_F(MoqtFramerSimpleTest, SubscribeEndBeforeStart) {
MoqtSubscribe subscribe = {
/*subscribe_id=*/3,
/*track_alias=*/4,
/*full_track_name=*/FullTrackName({"foo", "abcd"}),
/*subscriber_priority=*/0x20,
/*group_order=*/std::nullopt,
/*start_group=*/std::optional<uint64_t>(4),
/*start_object=*/std::optional<uint64_t>(3),
/*end_group=*/std::optional<uint64_t>(3),
/*end_object=*/std::nullopt,
MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt, std::nullopt},
};
quiche::QuicheBuffer buffer;
EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
"Invalid object range");
EXPECT_EQ(buffer.size(), 0);
subscribe.end_group = 4;
subscribe.end_object = 1;
EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
"Invalid object range");
EXPECT_EQ(buffer.size(), 0);
}
TEST_F(MoqtFramerSimpleTest, FetchEndBeforeStart) {
MoqtFetch fetch = {
/*subscribe_id =*/1,
/*full_track_name=*/FullTrackName{"foo", "bar"},
/*subscriber_priority=*/2,
/*group_order=*/MoqtDeliveryOrder::kAscending,
/*start_object=*/FullSequence{1, 2},
/*end_group=*/1,
/*end_object=*/1,
/*parameters=*/
MoqtSubscribeParameters{"baz", std::nullopt, std::nullopt, std::nullopt},
};
quiche::QuicheBuffer buffer;
EXPECT_QUIC_BUG(buffer = framer_.SerializeFetch(fetch),
"Invalid FETCH object range");
EXPECT_EQ(buffer.size(), 0);
fetch.end_group = 0;
fetch.end_object = std::nullopt;
EXPECT_QUIC_BUG(buffer = framer_.SerializeFetch(fetch),
"Invalid FETCH object range");
EXPECT_EQ(buffer.size(), 0);
}
TEST_F(MoqtFramerSimpleTest, SubscribeLatestGroupNonzeroObject) {
MoqtSubscribe subscribe = {
/*subscribe_id=*/3,
/*track_alias=*/4,
/*full_track_name=*/FullTrackName({"foo", "abcd"}),
/*subscriber_priority=*/0x20,
/*group_order=*/std::nullopt,
/*start_group=*/std::nullopt,
/*start_object=*/std::optional<uint64_t>(3),
/*end_group=*/std::nullopt,
/*end_object=*/std::nullopt,
MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt, std::nullopt},
};
quiche::QuicheBuffer buffer;
EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
"Invalid object range");
EXPECT_EQ(buffer.size(), 0);
}
TEST_F(MoqtFramerSimpleTest, SubscribeUpdateEndGroupOnly) {
MoqtSubscribeUpdate subscribe_update = {
/*subscribe_id=*/3,
/*start_group=*/4,
/*start_object=*/3,
/*end_group=*/4,
/*end_object=*/std::nullopt,
/*subscriber_priority=*/0xaa,
MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
std::nullopt},
};
quiche::QuicheBuffer buffer;
buffer = framer_.SerializeSubscribeUpdate(subscribe_update);
EXPECT_GT(buffer.size(), 0);
const uint8_t* end_group = BufferAtOffset(buffer, 5);
EXPECT_EQ(*end_group, 5);
const uint8_t* end_object = end_group + 1;
EXPECT_EQ(*end_object, 0);
}
TEST_F(MoqtFramerSimpleTest, SubscribeUpdateIncrementsEnd) {
MoqtSubscribeUpdate subscribe_update = {
/*subscribe_id=*/3,
/*start_group=*/4,
/*start_object=*/3,
/*end_group=*/4,
/*end_object=*/6,
/*subscriber_priority=*/0xaa,
MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
std::nullopt},
};
quiche::QuicheBuffer buffer;
buffer = framer_.SerializeSubscribeUpdate(subscribe_update);
EXPECT_GT(buffer.size(), 0);
const uint8_t* end_group = BufferAtOffset(buffer, 5);
EXPECT_EQ(*end_group, 5);
const uint8_t* end_object = end_group + 1;
EXPECT_EQ(*end_object, 7);
}
TEST_F(MoqtFramerSimpleTest, SubscribeUpdateInvalidRange) {
MoqtSubscribeUpdate subscribe_update = {
/*subscribe_id=*/3,
/*start_group=*/4,
/*start_object=*/3,
/*end_group=*/std::nullopt,
/*end_object=*/6,
/*subscriber_priority=*/0xaa,
MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
std::nullopt},
};
quiche::QuicheBuffer buffer;
EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribeUpdate(subscribe_update),
"Invalid object range");
EXPECT_EQ(buffer.size(), 0);
}
} // namespace moqt::test