Serve subscriptions after namespace announce

Author: mondain

include/openmoq/publisher/transport/moqt_control_messages.h

@@ -40,18 +40,77 @@ struct TrackMessage {
     bool content_exists = false;
 };
 
+struct PublishNamespaceOk {
+    std::uint64_t request_id = 0;
+};
+
+struct SubscribeNamespaceMessage {
+    std::uint64_t request_id = 0;
+    std::vector<std::string> track_namespace_prefix;
+};
+
+struct SubscribeMessage {
+    std::uint64_t request_id = 0;
+    std::vector<std::string> track_namespace;
+    std::string track_name;
+    std::uint8_t subscriber_priority = 0;
+    std::uint8_t group_order = 0;
+    std::uint8_t forward = 0;
+    std::uint64_t filter_type = 0;
+    std::size_t start_group_id = 0;
+    std::size_t start_object_id = 0;
+    std::size_t end_group_id = 0;
+};
+
+struct PublishNamespaceError {
+    std::uint64_t request_id = 0;
+    std::uint64_t error_code = 0;
+    std::string reason;
+};
+
+struct PublishOk {
+    std::uint64_t request_id = 0;
+    std::uint8_t forward = 0;
+    std::uint8_t subscriber_priority = 0;
+    std::uint8_t group_order = 0;
+    std::uint64_t filter_type = 0;
+};
+
+struct PublishError {
+    std::uint64_t request_id = 0;
+    std::uint64_t error_code = 0;
+    std::string reason;
+};
+
 std::vector<std::uint8_t> encode_varint(std::uint64_t value);
 bool decode_varint(std::span<const std::uint8_t> bytes, std::size_t& offset, std::uint64_t& value);
 
 std::vector<std::uint8_t> encode_setup_message(const SetupMessage& message);
 bool decode_server_setup_message(std::span<const std::uint8_t> bytes, ServerSetupMessage& message);
 std::vector<std::uint8_t> encode_server_setup_message(const ServerSetupMessage& message);
+bool next_control_message(std::span<const std::uint8_t> bytes, std::size_t& message_size);
 std::vector<std::uint8_t> encode_namespace_message(const NamespaceMessage& message);
+bool decode_subscribe_namespace_message(std::span<const std::uint8_t> bytes, SubscribeNamespaceMessage& message);
+std::vector<std::uint8_t> encode_subscribe_namespace_ok_message(std::uint64_t request_id);
+bool decode_subscribe_message(std::span<const std::uint8_t> bytes, SubscribeMessage& message);
+std::vector<std::uint8_t> encode_subscribe_ok_message(std::uint64_t request_id,
+                                                      std::uint64_t track_alias,
+                                                      std::uint8_t subscriber_priority,
+                                                      std::size_t largest_group_id,
+                                                      std::size_t largest_object_id,
+                                                      bool content_exists);
+std::vector<std::uint8_t> encode_subscribe_error_message(std::uint64_t request_id,
+                                                         std::uint64_t error_code,
+                                                         std::string_view reason);
 std::vector<std::uint8_t> encode_track_message(const TrackMessage& message);
 std::vector<std::uint8_t> encode_publish_done_message(std::uint64_t request_id, std::uint64_t stream_count);
 std::vector<std::uint8_t> encode_publish_namespace_done_message(const NamespaceMessage& message);
 std::vector<std::uint8_t> encode_object_stream(std::uint64_t track_alias,
                                                const CmsfObject& object,
                                                std::span<const std::uint8_t> payload);
+bool decode_publish_namespace_ok(std::span<const std::uint8_t> bytes, PublishNamespaceOk& message);
+bool decode_publish_namespace_error(std::span<const std::uint8_t> bytes, PublishNamespaceError& message);
+bool decode_publish_ok(std::span<const std::uint8_t> bytes, PublishOk& message);
+bool decode_publish_error(std::span<const std::uint8_t> bytes, PublishError& message);
 
 }  // namespace openmoq::publisher::transport

include/openmoq/publisher/transport/picoquic_client.h

@@ -25,6 +25,7 @@ class PicoquicClient final : public PublisherTransport {
                                 std::vector<std::uint8_t>& bytes,
                                 bool& fin,
                                 std::chrono::milliseconds timeout) override;
+    std::string connection_id() const override;
     TransportStatus close(std::uint64_t application_error_code) override;
 
 private:

include/openmoq/publisher/transport/publisher_transport.h

@@ -60,6 +60,7 @@ class PublisherTransport {
                                         std::vector<std::uint8_t>& bytes,
                                         bool& fin,
                                         std::chrono::milliseconds timeout) = 0;
+    virtual std::string connection_id() const = 0;
     virtual TransportStatus close(std::uint64_t application_error_code) = 0;
 };