From 02a86c7f29b3959a8a676932020cff976c2242c0 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 09:51:29 -0700
Subject: [PATCH 01/71] bring in encode/decode and support Announce via
 StreamBuffer

---
 include/quicr/moq_messages.h | 295 ++++++++++++++++
 src/CMakeLists.txt           |   1 +
 src/moq_messages.cpp         | 643 +++++++++++++++++++++++++++++++++++
 test/CMakeLists.txt          |   4 +-
 test/moq_messages.cpp        |  38 +++
 5 files changed, 980 insertions(+), 1 deletion(-)
 create mode 100644 include/quicr/moq_messages.h
 create mode 100644 src/moq_messages.cpp
 create mode 100644 test/moq_messages.cpp

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
new file mode 100644
index 00000000..1c33bebd
--- /dev/null
+++ b/include/quicr/moq_messages.h
@@ -0,0 +1,295 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <quicr/uvarint.h>
+#include <quicr/quicr_common.h>
+#include <quicr/message_buffer.h>
+#include <transport/stream_buffer.h>
+
+namespace quicr::messages {
+
+using Version = uintVar_t;
+using TrackNamespace = quicr::bytes;
+using TrackName = quicr::bytes;
+using ErrorCode = uintVar_t;
+using StatusCode = uintVar_t;
+using ReasonPhrase = quicr::bytes;
+using GroupId = uintVar_t;
+using ObjectId = uintVar_t;
+using ObjectPriority = uintVar_t;
+using SubscribeId = uintVar_t;
+using TrackAlias = uintVar_t;
+using ParamType = uintVar_t;
+
+// Ref: https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#name-messages
+constexpr uint8_t MESSAGE_TYPE_OBJECT_STREAM            = 0x0;
+constexpr uint8_t MESSAGE_TYPE_OBJECT_DATAGRAM          = 0x1;
+constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE                = 0x3;
+constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_OK             = 0x4;
+constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_ERROR          = 0x5;
+constexpr uint8_t MESSAGE_TYPE_ANNOUNCE                 = 0x6;
+constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_OK              = 0x7;
+constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_ERROR           = 0x8;
+constexpr uint8_t MESSAGE_TYPE_UNANNOUNCE               = 0x9;
+constexpr uint8_t MESSAGE_TYPE_UNSUBSCRIBE              = 0xA;
+constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_DONE           = 0xB;
+constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_CANCEL          = 0xC;
+constexpr uint8_t MESSAGE_TYPE_TRACK_STATUS_REQUEST     = 0xD;
+constexpr uint8_t MESSAGE_TYPE_TRACK_STATUS             = 0xE;
+constexpr uint8_t MESSAGE_TYPE_GOAWAY                   = 0x10;
+constexpr uint8_t MESSAGE_TYPE_CLIENT_SETUP             = 0x40;
+constexpr uint8_t MESSAGE_TYPE_SERVER_SETUP             = 0x41;
+constexpr uint8_t MESSAGE_TYPE_STREAM_HEADER_TRACK      = 0x50;
+constexpr uint8_t MESSAGE_TYPE_STREAM_HEADER_GROUP      = 0x51;
+
+// TODO (Suhas): rename it to StreamMapping
+enum ForwardingPreference : uint8_t {
+  StreamPerGroup = 0,
+  StreamPerObject,
+  StreamPerPriority,
+  StreamPerTrack,
+  Datagram
+};
+
+
+//
+// Parameters
+//
+
+enum struct ParameterType : uint8_t {
+  Role = 0x0,
+  Path = 0x1,
+  AuthorizationInfo = 0x2, // version specific, unused
+  Invalid = 0xFF, // used internally.
+};
+
+struct MoqParameter{
+  std::optional<ParamType> param_type;
+  uintVar_t param_length;
+  bytes param_value;
+};
+
+//
+// Setup
+//
+
+struct MoqClientSetup {
+  std::vector<Version> supported_versions;
+  MoqParameter role_parameter;
+  MoqParameter path_parameter;
+};
+
+struct MoqServerSetup {
+  Version supported_version;
+  MoqParameter role_parameter;
+  MoqParameter path_parameter;
+};
+
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqClientSetup &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqClientSetup &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqServerSetup &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqServerSetup &msg);
+
+//
+// Subscribe
+//
+enum struct LocationMode: uint8_t {
+  None = 0x0,
+  Absolute,
+  RelativePrevious,
+  RelativeNext
+};
+
+struct Location {
+  LocationMode mode;
+  std::optional<uintVar_t> value;
+};
+
+struct MoqSubscribe {
+  SubscribeId subscribe_id;
+  TrackAlias track_alias;
+  TrackNamespace track_namespace;
+  TrackName track_name;
+  Location start_group;
+  Location start_object;
+  Location end_group;
+  Location end_object;
+  std::vector<MoqParameter> track_params;
+};
+
+struct MoqSubscribeOk {
+  SubscribeId subscribe_id;
+  uintVar_t expires;
+  bool content_exists;
+  std::optional<GroupId> largest_group;
+  std::optional<ObjectId> largest_object;
+};
+
+
+struct MoqSubscribeError {
+  SubscribeId subscribe_id;
+  ErrorCode err_code;
+  ReasonPhrase reason_phrase;
+  TrackAlias  track_alias;
+};
+
+struct MoqUnsubscribe {
+  SubscribeId  subscribe_id;
+};
+
+struct MoqSubscribeDone
+{
+  SubscribeId  subscribe_id;
+  StatusCode status_code;
+  ReasonPhrase reason_phrase;
+  bool content_exists;
+  GroupId final_group_id;
+  ObjectId final_object_id;
+};
+
+MessageBuffer& operator<<(MessageBuffer &buffer, const Location &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, Location &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribe &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribe &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeOk &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeOk &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeError &msg);
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeDone &msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeDone &msg);
+
+
+
+//
+// Announce
+//
+
+struct MoqAnnounce {
+  TrackNamespace track_namespace;
+  std::vector<MoqParameter> params;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounce &msg);
+private:
+  uint64_t num_params {0};
+  MoqParameter current_param{};
+};
+
+struct MoqAnnounceOk {
+  TrackNamespace track_namespace;
+};
+
+struct MoqAnnounceError {
+  TrackNamespace track_namespace;
+  ErrorCode err_code;
+  ReasonPhrase reason_phrase;
+};
+
+struct MoqUnannounce {
+  TrackNamespace track_namespace;
+};
+
+struct MoqAnnounceCancel {
+  TrackNamespace track_namespace;
+};
+
+
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounce& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounce &msg);
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer, const MoqAnnounce& msg);
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounce &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceOk& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounceOk &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceError& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounceError &msg);
+MessageBuffer &operator<<(MessageBuffer &buffer, const MoqUnannounce &msg);
+MessageBuffer &operator>>(MessageBuffer &buffer, MoqUnannounce &msg);
+MessageBuffer &operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg);
+MessageBuffer &operator>>(MessageBuffer &buffer, MoqAnnounceCancel &msg);
+
+
+//
+// GoAway
+//
+struct MoqGoaway {
+  quicr::bytes new_session_uri;
+};
+
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqGoaway& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqGoaway &msg);
+
+
+//
+// Object
+//
+struct MoqObjectStream {
+  SubscribeId subscribe_id;
+  TrackAlias track_alias;
+  GroupId group_id;
+  ObjectId object_id;
+  ObjectPriority priority;
+  quicr::bytes payload;
+};
+
+struct MoqObjectDatagram {
+  SubscribeId subscribe_id;
+  TrackAlias track_alias;
+  GroupId group_id;
+  ObjectId object_id;
+  ObjectPriority priority;
+  quicr::bytes payload;
+};
+
+
+struct MoqStreamHeaderTrack {
+  SubscribeId subscribe_id;
+  TrackAlias track_alias;
+  ObjectPriority priority;
+};
+
+struct MoqStreamTrackObject {
+  GroupId  group_id;
+  ObjectId object_id;
+  quicr::bytes payload;
+};
+
+
+struct MoqStreamHeaderGroup {
+  SubscribeId subscribe_id;
+  TrackAlias track_alias;
+  GroupId group_id;
+  ObjectPriority priority;
+};
+
+struct MoqStreamGroupObject {
+  ObjectId object_id;
+  quicr::bytes payload;
+};
+
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqObjectStream& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqObjectStream &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqObjectDatagram& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqObjectDatagram &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamHeaderTrack& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamHeaderTrack &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamTrackObject& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamTrackObject &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamHeaderGroup& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamHeaderGroup &msg);
+MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamGroupObject& msg);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg);
+
+// utility
+std::tuple<Location, Location, Location, Location>  to_locations(const SubscribeIntent& intent);
+MessageBuffer& operator<<(MessageBuffer& buffer, const std::vector<uintVar_t>& val);
+MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
+MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
+
+template <typename T>
+MessageBuffer& operator<<(MessageBuffer& buffer, const std::optional<T>& val);
+template <typename T>
+MessageBuffer& operator>>(MessageBuffer& msg, std::optional<T>& val);
+}
\ No newline at end of file
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1f32b72c..7a383afc 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -4,6 +4,7 @@ add_library(quicr)
 target_sources(quicr PRIVATE
         message_buffer.cpp
         encode.cpp
+        moq_messages.cpp
         quicr_client.cpp
         quicr_client_raw_session.cpp
         quicr_server.cpp
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
new file mode 100644
index 00000000..a698abe2
--- /dev/null
+++ b/src/moq_messages.cpp
@@ -0,0 +1,643 @@
+#include "quicr/moq_messages.h"
+#include "quicr/message_buffer.h"
+#include "quicr/encode.h"
+
+namespace quicr::messages {
+
+//
+// Optional
+//
+
+template <typename T>
+MessageBuffer& operator<<(MessageBuffer& buffer, const std::optional<T>& val) {
+  if (val.has_value()) {
+    buffer << val.value();
+  }
+  return buffer;
+}
+
+template <typename T>
+MessageBuffer& operator>>(MessageBuffer& buffer, std::optional<T>& val) {
+  T val_in{};
+  buffer >> val_in;
+  val = val_in;
+  return buffer;
+}
+
+
+//
+// MoqParameter
+//
+
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &param) {
+  buffer << param.param_type;
+  buffer << param.param_length;
+  if (param.param_length) {
+    buffer << param.param_value;
+  }
+
+  return buffer;
+}
+
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
+  buffer >> param.param_type;
+  buffer >> param.param_length;
+  if (static_cast<uint64_t>(param.param_length) > 0) {
+    buffer >> param.param_value;
+  }
+  return buffer;
+}
+
+
+//
+// Subscribe
+//
+
+
+MessageBuffer& operator<<(MessageBuffer &buffer, const Location &msg) {
+  if (msg.mode == LocationMode::None) {
+    buffer << static_cast<uint8_t >(msg.mode);
+    return buffer;
+  }
+  buffer << static_cast<uint8_t >(msg.mode);
+  buffer << msg.value.value();
+  return buffer;
+}
+
+MessageBuffer& operator>>(MessageBuffer &buffer, Location &msg) {
+  uint8_t mode {0};
+  buffer >> mode;
+  msg.mode = static_cast<LocationMode>(mode);
+  if (static_cast<LocationMode>(mode) != LocationMode::None) {
+    uintVar_t loc_val{0};
+    buffer >> loc_val;
+    msg.value = loc_val;
+  }
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqSubscribe &msg) {
+  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_SUBSCRIBE);
+  buffer << msg.subscribe_id;
+  buffer << msg.track_alias;
+  buffer << msg.track_namespace;
+  buffer << msg.track_name;
+  buffer << msg.start_group;
+  buffer << msg.start_object;
+  buffer << msg.end_group;
+  buffer << msg.end_object;
+  buffer << static_cast<uintVar_t>(msg.track_params.size());
+  for (const auto& param: msg.track_params) {
+    buffer << param.param_type;
+    buffer << param.param_length;
+    buffer << param.param_value;
+  }
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqSubscribe &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.track_alias;
+  buffer >> msg.track_namespace;
+  buffer >> msg.track_name;
+  buffer >> msg.start_group;
+  buffer >> msg.start_object;
+  buffer >> msg.end_group;
+  buffer >> msg.end_object;
+  uintVar_t num_params {0};
+  buffer >> num_params;
+  auto track_params = std::vector<MoqParameter>{};
+  while(static_cast<uint64_t>(num_params) > 0) {
+    auto param = MoqParameter{};
+    buffer >> param.param_type;
+    buffer >> param.param_length;
+    buffer >> param.param_value;
+    track_params.push_back(std::move(param));
+    num_params = num_params - 1;
+  }
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_UNSUBSCRIBE);
+  buffer << msg.subscribe_id;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg) {
+  buffer >> msg.subscribe_id;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqSubscribeOk &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_OK);
+  buffer << msg.subscribe_id;
+  buffer << msg.expires;
+  buffer << static_cast<uint8_t>(msg.content_exists);
+  if (msg.content_exists) {
+    buffer << msg.largest_group;
+    buffer << msg.largest_object;
+    return buffer;
+  }
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqSubscribeOk &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.expires;
+  uint8_t content_exists {0};
+  buffer >> content_exists;
+  if(content_exists > 1) {
+    throw std::runtime_error("Invalid Context Exists Value");
+  }
+
+  if (content_exists == 1) {
+    msg.content_exists = true;
+    buffer >> msg.largest_group;
+    buffer >> msg.largest_object;
+    return buffer;
+  }
+
+  msg.content_exists = false;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR);
+  buffer << msg.subscribe_id;
+  buffer << msg.err_code;
+  buffer << msg.reason_phrase;
+  buffer << msg.track_alias;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqSubscribeError &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.err_code;
+  buffer >> msg.reason_phrase;
+  buffer >> msg.track_alias;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqSubscribeDone &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_DONE);
+  buffer << msg.subscribe_id;
+  buffer << msg.status_code;
+  buffer << msg.reason_phrase;
+  buffer << uint8_t(msg.content_exists);
+  if (msg.content_exists) {
+    buffer << msg.final_group_id;
+    buffer << msg.final_object_id;
+  }
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqSubscribeDone&msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.status_code;
+  buffer >> msg.reason_phrase;
+  uint8_t  context_exists {0};
+  buffer >> context_exists;
+  if (context_exists > 1) {
+    throw std::runtime_error("Incorrect Context Exists value");
+  }
+
+  if (context_exists == 1) {
+    msg.content_exists = true;
+    buffer >> msg.final_group_id;
+    buffer >> msg.final_object_id;
+    return buffer;
+  }
+
+  msg.content_exists = false;
+  return buffer;
+}
+
+
+//
+// Announce
+//
+
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqAnnounce& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE)));
+  buffer.push_lv(msg.track_namespace);
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(0)));
+  return buffer;
+}
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
+           MoqAnnounce &msg) {
+
+  // read namespace
+  if (msg.track_namespace.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = *val;
+  }
+
+  if (!msg.num_params) {
+    const auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+    msg.num_params = *val;
+  }
+
+  // parse each param
+  while (msg.num_params > 0) {
+    if (!msg.current_param.param_type) {
+      auto val = buffer.front();
+      if (!val) {
+        return false;
+      }
+      msg.current_param.param_type = *val;
+      buffer.pop();
+    }
+
+    // decode param_len:<bytes>
+    auto param = buffer.decode_bytes();
+    if (!param) {
+      return false;
+    }
+
+    msg.current_param.param_length = param->size();
+    msg.current_param.param_value = param.value();
+    msg.params.push_back(msg.current_param);
+    msg.current_param = {};
+    msg.num_params -= 1;
+  }
+
+  return true;
+}
+
+MessageBuffer&operator<<(MessageBuffer &buffer, const MoqAnnounce &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE);
+  buffer << msg.track_namespace;
+  // TODO(Suhas): Fix this once we have params
+  buffer << uintVar_t{0};
+  return buffer;
+}
+
+
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounce &msg) {
+  buffer >> msg.track_namespace;
+  uintVar_t num_params {0};
+  buffer >> num_params;
+  auto track_params = std::vector<MoqParameter>{};
+  while(static_cast<uint64_t>(num_params) > 0) {
+    auto param = MoqParameter{};
+    buffer >> param.param_type;
+    buffer >> param.param_length;
+    buffer >> param.param_value;
+    track_params.push_back(std::move(param));
+    num_params = num_params - 1;
+  }
+  return buffer;
+}
+
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqAnnounceOk &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_OK);
+  buffer << msg.track_namespace;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqAnnounceOk &msg) {
+  buffer >> msg.track_namespace;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqAnnounceError &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_ERROR);
+  buffer << msg.track_namespace;
+  buffer << msg.err_code;
+  buffer << msg.reason_phrase;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqAnnounceError &msg) {
+  buffer >> msg.track_namespace;
+  buffer >> msg.err_code;
+  buffer >> msg.reason_phrase;
+  return buffer;
+}
+
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqUnannounce &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_UNANNOUNCE);
+  buffer << msg.track_namespace;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqUnannounce &msg) {
+  buffer >> msg.track_namespace;
+  return buffer;
+}
+
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL);
+  buffer << msg.track_namespace;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqAnnounceCancel &msg) {
+  buffer >> msg.track_namespace;
+  return buffer;
+}
+
+
+//
+// Goaway
+//
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqGoaway &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_GOAWAY);
+  buffer << msg.new_session_uri;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqGoaway &msg) {
+  buffer >> msg.new_session_uri;
+  return buffer;
+}
+
+//
+// Object
+//
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqObjectStream &msg) {
+  buffer << static_cast<uint8_t>(MESSAGE_TYPE_OBJECT_STREAM);
+  buffer << msg.subscribe_id;
+  buffer << msg.track_alias;
+  buffer << msg.group_id;
+  buffer << msg.object_id;
+  buffer << msg.priority;
+  buffer << msg.payload;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqObjectStream &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.track_alias;
+  buffer >> msg.group_id;
+  buffer >> msg.object_id;
+  buffer >> msg.priority;
+  buffer >> msg.payload;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqObjectDatagram &msg) {
+  buffer << MESSAGE_TYPE_OBJECT_DATAGRAM;
+  buffer << msg.subscribe_id;
+  buffer << msg.track_alias;
+  buffer << msg.group_id;
+  buffer << msg.object_id;
+  buffer << msg.priority;
+  buffer << msg.payload;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqObjectDatagram &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.track_alias;
+  buffer >> msg.group_id;
+  buffer >> msg.object_id;
+  buffer >> msg.priority;
+  buffer >> msg.payload;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqStreamTrackObject &msg) {
+  buffer << msg.group_id;
+  buffer << msg.object_id;
+  buffer << msg.payload;
+  return buffer;
+}
+
+MessageBuffer&
+operator>>(MessageBuffer &buffer, MoqStreamTrackObject &msg) {
+  buffer >> msg.group_id;
+  buffer >> msg.object_id;
+  buffer >> msg.payload;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqStreamHeaderTrack &msg) {
+  buffer << MESSAGE_TYPE_STREAM_HEADER_TRACK;
+  buffer << msg.subscribe_id;
+  buffer << msg.track_alias;
+  buffer << msg.priority;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqStreamHeaderTrack &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.track_alias;
+  buffer >> msg.priority;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqStreamHeaderGroup &msg) {
+  buffer << MESSAGE_TYPE_STREAM_HEADER_GROUP;
+  buffer << msg.subscribe_id;
+  buffer << msg.track_alias;
+  buffer << msg.group_id;
+  buffer << msg.priority;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqStreamHeaderGroup &msg) {
+  buffer >> msg.subscribe_id;
+  buffer >> msg.track_alias;
+  buffer >> msg.group_id;
+  buffer >> msg.priority;
+  return buffer;
+}
+
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqStreamGroupObject &msg) {
+  buffer << msg.object_id;
+  buffer << msg.payload;
+  return buffer;
+}
+
+MessageBuffer&
+operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg) {
+  buffer >> msg.object_id;
+  buffer >> msg.payload;
+  return buffer;
+}
+
+std::tuple<Location, Location, Location, Location> to_locations(const SubscribeIntent& intent) {
+  auto none_location = Location {.mode = LocationMode::None, .value = std::nullopt};
+
+  /*
+   * Sequence:                0    1    2    3    4   [5]  [6] ...
+                                                ^
+                                           Largest Sequence
+   RelativePrevious Value:  4    3    2    1    0
+   RelativeNext Value:                               0    1  ...
+ */
+  switch (intent) {
+    case SubscribeIntent::immediate:
+      return std::make_tuple(Location{.mode=LocationMode::RelativePrevious, .value=0}, //StartGroup
+                             none_location, // EndGroup
+                             Location{.mode=LocationMode::RelativePrevious, .value=0}, //StartObject
+                             none_location); // EndObject
+    case SubscribeIntent::sync_up:
+      throw std::runtime_error("Intent Unsupported for Subscribe");
+    case SubscribeIntent::wait_up:
+      throw std::runtime_error("Intent Unsupported for Subscribe");
+    default:
+      throw std::runtime_error("Bad Intent  for Subscribe");
+  }
+
+}
+
+
+// Setup
+
+// vector<varint> encode/decode
+MessageBuffer&
+operator<<(MessageBuffer& buffer, const std::vector<uintVar_t>& val)
+{
+  buffer << static_cast<uintVar_t>(val.size());
+  for(uint64_t i = 0; i < val.size(); i++) {
+    buffer << val[i];
+  }
+
+  return buffer;
+}
+
+MessageBuffer&
+operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val)
+{
+  auto vec_size = uintVar_t(0);
+  msg >> vec_size;
+  auto version = std::vector<uintVar_t>();
+  version.resize((uint64_t) vec_size);
+  val.resize((uint64_t) vec_size);
+
+  // TODO (Suhas): This needs revisiting
+  for(uint64_t i = 0; i < version.size(); i++) {
+    msg >> version[i];
+  }
+  val = std::move(version);
+  return msg;
+}
+
+
+// Client Setup message
+MessageBuffer &
+operator<<(MessageBuffer &buffer, const MoqClientSetup &msg) {
+  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_CLIENT_SETUP);
+  // versions
+  buffer << static_cast<uintVar_t>(msg.supported_versions.size());
+  for (const auto& ver: msg.supported_versions) {
+    buffer << static_cast<uintVar_t>(ver);
+  }
+
+  // TODO (Suhas): Add support for PATH Param
+  // num params
+  buffer << uintVar_t{1};
+  // role param
+  buffer << static_cast<uint8_t>(msg.role_parameter.param_type.value());
+  buffer << uintVar_t(1);
+  buffer << msg.role_parameter.param_value;
+
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqClientSetup &msg) {
+  uintVar_t num_versions {0};
+  buffer >> num_versions;
+  msg.supported_versions.resize(num_versions);
+  for(size_t i = 0; i < num_versions; i++) {
+    uintVar_t version{0};
+    buffer >> version;
+    msg.supported_versions.push_back(version);
+  }
+
+  uintVar_t num_params {0};
+  buffer >> num_params;
+  if (static_cast<uint64_t> (num_params) == 0) {
+    return buffer;
+  }
+
+  while (static_cast<uint64_t>(num_params) > 0) {
+    uint8_t param_type {0};
+    buffer >> param_type;
+    auto param_type_enum = static_cast<ParameterType> (param_type);
+    switch(param_type_enum) {
+      case ParameterType::Role: {
+        msg.role_parameter.param_type = param_type;
+        buffer >> msg.role_parameter.param_length;
+        buffer >> msg.role_parameter.param_value;
+      }
+      break;
+      case ParameterType::Path: {
+        msg.path_parameter.param_type = param_type;
+        buffer >> msg.path_parameter.param_length;
+        buffer >> msg.path_parameter.param_value;
+      }
+      break;
+      default:
+        throw std::runtime_error("Unsupported Parameter Type for ClientSetup");
+    }
+    num_params = num_params - 1;
+  }
+
+
+  return buffer;
+}
+
+// Server Setup message
+MessageBuffer&
+operator<<(MessageBuffer &buffer, const MoqServerSetup &msg) {
+  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_SERVER_SETUP);
+  buffer << msg.supported_version;
+  return buffer;
+}
+
+MessageBuffer &
+operator>>(MessageBuffer &buffer, MoqServerSetup &msg) {
+  buffer >> msg.supported_version;
+  return buffer;
+}
+}
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index d0320ec9..57469693 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -5,7 +5,9 @@ add_executable(quicr_test
                 quicr_client.cpp
                 stream_buffer.cpp
                 quicr_server.cpp
-                encode.cpp)
+                moq_messages.cpp
+                encode.cpp
+        moq_messages.cpp)
 target_include_directories(quicr_test PRIVATE ${PROJECT_SOURCE_DIR}/src)
 
 target_link_libraries(quicr_test PRIVATE quicr doctest::doctest)
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
new file mode 100644
index 00000000..3be9e0d2
--- /dev/null
+++ b/test/moq_messages.cpp
@@ -0,0 +1,38 @@
+#include <doctest/doctest.h>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <iostream>
+#include <quicr/moq_messages.h>
+
+using namespace quicr;
+using namespace quicr::messages;
+
+static bytes from_ascii(const std::string& ascii)
+{
+  return std::vector<uint8_t>(ascii.begin(), ascii.end());
+}
+
+const quicr::bytes TRACK_NAMESPACE_CONF = from_ascii("moqt://conf.example.com/conf/1");
+const quicr::bytes TRACK_NAME_ALICE_VIDEO = from_ascii("alice/video");
+const uintVar_t TRACK_ALIAS_ALICE_VIDEO = 0xA11CE;
+
+TEST_CASE("Announce Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  std::vector<uint8_t> net_data;
+
+  auto announce  = MoqAnnounce {};
+  announce.track_namespace = TRACK_NAMESPACE_CONF;
+  announce.params = {};
+
+  buffer <<  announce;
+
+  auto message_type = buffer.decode_uintV();
+  CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE));
+
+  MoqAnnounce announce_out;
+  buffer >> announce_out;
+  CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
+  CHECK_EQ(0, announce_out.params.size());
+}
\ No newline at end of file

From 791acef9450050bb67b694c81169b71791d9e7e9 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 10:59:13 -0700
Subject: [PATCH 02/71] add announce_ok

---
 include/quicr/moq_messages.h |  9 ++++---
 src/moq_messages.cpp         | 47 ++++++++++++------------------------
 test/moq_messages.cpp        | 17 +++++++++++++
 3 files changed, 38 insertions(+), 35 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 1c33bebd..7e296166 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -173,6 +173,8 @@ struct MoqAnnounce {
   TrackNamespace track_namespace;
   std::vector<MoqParameter> params;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounce &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqAnnounce& msg);
 private:
   uint64_t num_params {0};
   MoqParameter current_param{};
@@ -180,6 +182,9 @@ struct MoqAnnounce {
 
 struct MoqAnnounceOk {
   TrackNamespace track_namespace;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceOk &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqAnnounceOk& msg);
 };
 
 struct MoqAnnounceError {
@@ -197,10 +202,6 @@ struct MoqAnnounceCancel {
 };
 
 
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounce& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounce &msg);
-qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer, const MoqAnnounce& msg);
-bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounce &msg);
 MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceOk& msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounceOk &msg);
 MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceError& msg);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index a698abe2..bcd17fbb 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -285,44 +285,29 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
   return true;
 }
 
-MessageBuffer&operator<<(MessageBuffer &buffer, const MoqAnnounce &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE);
-  buffer << msg.track_namespace;
-  // TODO(Suhas): Fix this once we have params
-  buffer << uintVar_t{0};
-  return buffer;
-}
 
-
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounce &msg) {
-  buffer >> msg.track_namespace;
-  uintVar_t num_params {0};
-  buffer >> num_params;
-  auto track_params = std::vector<MoqParameter>{};
-  while(static_cast<uint64_t>(num_params) > 0) {
-    auto param = MoqParameter{};
-    buffer >> param.param_type;
-    buffer >> param.param_length;
-    buffer >> param.param_value;
-    track_params.push_back(std::move(param));
-    num_params = num_params - 1;
-  }
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqAnnounceOk& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK)));
+  buffer.push_lv(msg.track_namespace);
   return buffer;
 }
 
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
+           MoqAnnounceOk &msg) {
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqAnnounceOk &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_OK);
-  buffer << msg.track_namespace;
-  return buffer;
+  // read namespace
+  if (msg.track_namespace.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = *val;
+  }
+  return true;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqAnnounceOk &msg) {
-  buffer >> msg.track_namespace;
-  return buffer;
-}
 
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqAnnounceError &msg) {
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 3be9e0d2..3052f347 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -17,6 +17,23 @@ const quicr::bytes TRACK_NAMESPACE_CONF = from_ascii("moqt://conf.example.com/co
 const quicr::bytes TRACK_NAME_ALICE_VIDEO = from_ascii("alice/video");
 const uintVar_t TRACK_ALIAS_ALICE_VIDEO = 0xA11CE;
 
+TEST_CASE("AnnounceOk Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto announce_ok  = MoqAnnounceOk {};
+  announce_ok.track_namespace = TRACK_NAMESPACE_CONF;
+
+  buffer <<  announce_ok;
+
+  auto message_type = buffer.decode_uintV();
+  CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK));
+
+  MoqAnnounceOk announce_ok_out;
+  buffer >> announce_ok_out;
+  CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
+}
+
 TEST_CASE("Announce Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;

From a80a07d1be2af443ea98a9660745211c5f0fc545 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 12:05:22 -0700
Subject: [PATCH 03/71] make decode test a streaming test

---
 include/quicr/moq_messages.h | 15 +++++------
 src/moq_messages.cpp         | 50 ++++++++++++++++++++++++++----------
 test/moq_messages.cpp        | 31 +++++++++++++++++-----
 3 files changed, 67 insertions(+), 29 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 7e296166..a0cbf8c6 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -12,7 +12,7 @@ namespace quicr::messages {
 using Version = uintVar_t;
 using TrackNamespace = quicr::bytes;
 using TrackName = quicr::bytes;
-using ErrorCode = uintVar_t;
+using ErrorCode = uint64_t;
 using StatusCode = uintVar_t;
 using ReasonPhrase = quicr::bytes;
 using GroupId = uintVar_t;
@@ -188,9 +188,12 @@ struct MoqAnnounceOk {
 };
 
 struct MoqAnnounceError {
-  TrackNamespace track_namespace;
-  ErrorCode err_code;
-  ReasonPhrase reason_phrase;
+  std::optional<TrackNamespace> track_namespace;
+  std::optional<ErrorCode> err_code;
+  std::optional<ReasonPhrase> reason_phrase;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceError &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqAnnounceError* msg);
 };
 
 struct MoqUnannounce {
@@ -202,10 +205,6 @@ struct MoqAnnounceCancel {
 };
 
 
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceOk& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounceOk &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqAnnounceError& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqAnnounceError &msg);
 MessageBuffer &operator<<(MessageBuffer &buffer, const MoqUnannounce &msg);
 MessageBuffer &operator>>(MessageBuffer &buffer, MoqUnannounce &msg);
 MessageBuffer &operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index bcd17fbb..4ae0ba96 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -293,8 +293,7 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   return buffer;
 }
 
-bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
-           MoqAnnounceOk &msg) {
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceOk &msg) {
 
   // read namespace
   if (msg.track_namespace.empty())
@@ -309,21 +308,44 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
 }
 
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqAnnounceError &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_ERROR);
-  buffer << msg.track_namespace;
-  buffer << msg.err_code;
-  buffer << msg.reason_phrase;
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqAnnounceError& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_ERROR)));
+  buffer.push_lv(msg.track_namespace.value());
+  buffer.push(qtransport::to_uintV(msg.err_code.value()));
+  buffer.push_lv(msg.reason_phrase.value());
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqAnnounceError &msg) {
-  buffer >> msg.track_namespace;
-  buffer >> msg.err_code;
-  buffer >> msg.reason_phrase;
-  return buffer;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceError &msg) {
+
+  // read namespace
+  if (!msg.track_namespace)
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = *val;
+  }
+
+  if (!msg.err_code) {
+    const auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+
+    msg.err_code = *val;
+  }
+  while (!msg.reason_phrase > 0) {
+    auto reason = buffer.decode_bytes();
+    if (!reason) {
+      return false;
+    }
+    msg.reason_phrase = reason;
+  }
+
+  return true;
 }
 
 
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 3052f347..2c13fa6d 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -24,7 +24,7 @@ TEST_CASE("AnnounceOk Message encode/decode")
   auto announce_ok  = MoqAnnounceOk {};
   announce_ok.track_namespace = TRACK_NAMESPACE_CONF;
 
-  buffer <<  announce_ok;
+  buffer << announce_ok;
 
   auto message_type = buffer.decode_uintV();
   CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK));
@@ -37,19 +37,36 @@ TEST_CASE("AnnounceOk Message encode/decode")
 TEST_CASE("Announce Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
-  std::vector<uint8_t> net_data;
 
   auto announce  = MoqAnnounce {};
   announce.track_namespace = TRACK_NAMESPACE_CONF;
   announce.params = {};
-
   buffer <<  announce;
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
-  auto message_type = buffer.decode_uintV();
-  CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE));
+  // ingress buffer
+  qtransport::StreamBuffer<uint8_t> in_buffer;
+  std::optional<uint64_t> message_type;
 
   MoqAnnounce announce_out;
-  buffer >> announce_out;
+  for (auto& v: net_data) {
+    in_buffer.push(v);
+    if (!message_type) {
+      message_type = in_buffer.decode_uintV();
+      if(!message_type) {
+        continue;
+      }
+      CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE));
+      continue;
+    }
+
+    bool got = in_buffer >> announce_out;
+    if (!got) {
+      continue;
+    }
+  }
+
+
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
   CHECK_EQ(0, announce_out.params.size());
-}
\ No newline at end of file
+}

From e0b13d9e2851b0f9b77176087aa0f9fac8a56489 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 12:11:49 -0700
Subject: [PATCH 04/71] make announce_ok a streaming test

---
 test/moq_messages.cpp | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 2c13fa6d..1295ae62 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -26,11 +26,29 @@ TEST_CASE("AnnounceOk Message encode/decode")
 
   buffer << announce_ok;
 
-  auto message_type = buffer.decode_uintV();
-  CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK));
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  // ingress buffer
+  qtransport::StreamBuffer<uint8_t> in_buffer;
+  std::optional<uint64_t> message_type;
 
   MoqAnnounceOk announce_ok_out;
-  buffer >> announce_ok_out;
+  for (auto& v: net_data) {
+    in_buffer.push(v);
+    if (!message_type) {
+      message_type = in_buffer.decode_uintV();
+      if (!message_type) {
+        continue;
+      }
+      CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK));
+      continue;
+    }
+    bool got = in_buffer >> announce_ok_out;
+    if (!got) {
+      continue;
+    }
+  }
+
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
 }
 
@@ -66,7 +84,6 @@ TEST_CASE("Announce Message encode/decode")
     }
   }
 
-
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
   CHECK_EQ(0, announce_out.params.size());
 }

From 8524f2b76df809e684932cb2caf8f971d475cd0b Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 31 May 2024 16:59:36 -0700
Subject: [PATCH 05/71] Stub out new MOQ delegates and instance

---
 cmd/really/reallyTest.cpp                    |  6 ++++-
 dependencies/transport                       |  2 +-
 include/quicr/moq_delegate_instance.h        | 24 ++++++++++++++++++++
 include/quicr/moq_delegate_track_publish.h   | 16 +++++++++++++
 include/quicr/moq_delegate_track_subscribe.h | 18 +++++++++++++++
 include/quicr/moq_instance.h                 | 18 +++++++++++++++
 src/CMakeLists.txt                           |  2 ++
 src/moq_instance.cpp                         | 11 +++++++++
 src/moq_session.cpp                          | 11 +++++++++
 src/moq_session.h                            | 18 +++++++++++++++
 10 files changed, 124 insertions(+), 2 deletions(-)
 create mode 100644 include/quicr/moq_delegate_instance.h
 create mode 100644 include/quicr/moq_delegate_track_publish.h
 create mode 100644 include/quicr/moq_delegate_track_subscribe.h
 create mode 100644 include/quicr/moq_instance.h
 create mode 100644 src/moq_instance.cpp
 create mode 100644 src/moq_session.cpp
 create mode 100644 src/moq_session.h

diff --git a/cmd/really/reallyTest.cpp b/cmd/really/reallyTest.cpp
index c199fa28..2996cf8e 100644
--- a/cmd/really/reallyTest.cpp
+++ b/cmd/really/reallyTest.cpp
@@ -113,7 +113,11 @@ int do_publisher(cantina::LoggerPointer logger,
       return -1;
     }
 
-    logger->info << "Received intent response. Type message and press ENTER to publish. Type exit to end program." << std::flush;
+    logger->info << "Received intent response." << std::flush;
+
+    std::cout << "-----------------------------------------------------------------------" << std::endl;
+    std::cout << " Type a message and press ENTER to publish. Type the word exit to end program." << std::flush;
+    std::cout << "-----------------------------------------------------------------------" << std::endl;
 
     while (true) {
       std::string msg;
diff --git a/dependencies/transport b/dependencies/transport
index 1d13a363..ebf29645 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 1d13a3631b20e3d1355f484d78132fc19ca174e4
+Subproject commit ebf29645ce4eadb057a09d6b641c765f487e400d
diff --git a/include/quicr/moq_delegate_instance.h b/include/quicr/moq_delegate_instance.h
new file mode 100644
index 00000000..183bc24a
--- /dev/null
+++ b/include/quicr/moq_delegate_instance.h
@@ -0,0 +1,24 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#pragma once
+
+namespace quicr {
+
+/**
+ * @brief Delegate for all MOQ/MOQT callbacks and interaction
+ *
+ * @details A new MOQ instance is created with this delegate as a shared pointer.
+ *   All interaction with the instance is handled via this delegate. This delegate
+ *   is a base class implementation and interface for callbacks.
+ */
+
+class MOQInstanceDelegate
+{
+
+};
+
+} // namespace quicr
diff --git a/include/quicr/moq_delegate_track_publish.h b/include/quicr/moq_delegate_track_publish.h
new file mode 100644
index 00000000..b9e0759d
--- /dev/null
+++ b/include/quicr/moq_delegate_track_publish.h
@@ -0,0 +1,16 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#pragma once
+
+namespace quicr {
+
+class MOQTrackPublishDelegate
+{
+
+};
+
+} // namespace quicr
diff --git a/include/quicr/moq_delegate_track_subscribe.h b/include/quicr/moq_delegate_track_subscribe.h
new file mode 100644
index 00000000..945df79c
--- /dev/null
+++ b/include/quicr/moq_delegate_track_subscribe.h
@@ -0,0 +1,18 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#pragma once
+
+
+namespace quicr {
+
+class MOQTrackSubscribeDelegate
+{
+
+};
+
+
+} // namespace quicr
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
new file mode 100644
index 00000000..94f281fb
--- /dev/null
+++ b/include/quicr/moq_instance.h
@@ -0,0 +1,18 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#pragma once
+
+#include <quicr/moq_delegate_instance.h>
+#include <quicr/moq_delegate_track_publish.h>
+#include <quicr/moq_delegate_track_subscribe.h>
+
+namespace quicr {
+
+class MOQInstance {
+};
+
+} // namespace quicr
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7a383afc..71e0adb3 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,6 +9,8 @@ target_sources(quicr PRIVATE
         quicr_client_raw_session.cpp
         quicr_server.cpp
         quicr_server_raw_session.cpp
+        moq_instance.cpp
+        moq_session.cpp
 )
 
 if(NOT LIBQUICR_WITHOUT_INFLUXDB)
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
new file mode 100644
index 00000000..e36196c4
--- /dev/null
+++ b/src/moq_instance.cpp
@@ -0,0 +1,11 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#include <quicr/moq_instance.h>
+
+namespace quicr {
+
+} // namespace quicr
diff --git a/src/moq_session.cpp b/src/moq_session.cpp
new file mode 100644
index 00000000..7f0d5102
--- /dev/null
+++ b/src/moq_session.cpp
@@ -0,0 +1,11 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#include "moq_session.h"
+
+namespace quicr {
+
+} // namespace quicr
diff --git a/src/moq_session.h b/src/moq_session.h
new file mode 100644
index 00000000..45efad6a
--- /dev/null
+++ b/src/moq_session.h
@@ -0,0 +1,18 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#pragma once
+
+#include "moq_session.h"
+
+namespace quicr {
+
+class MOQSession
+{
+
+};
+
+} // namespace quicr

From 0398433a581636551a364e5a2c66006129a4a5eb Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 18:21:36 -0700
Subject: [PATCH 06/71] refactor test

---
 include/quicr/moq_messages.h |  5 ++-
 src/moq_messages.cpp         | 27 ++++++++------
 test/moq_messages.cpp        | 71 ++++++++++++++----------------------
 3 files changed, 46 insertions(+), 57 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index a0cbf8c6..d39e62d0 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -198,6 +198,9 @@ struct MoqAnnounceError {
 
 struct MoqUnannounce {
   TrackNamespace track_namespace;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnannounce &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqUnannounce* msg);
 };
 
 struct MoqAnnounceCancel {
@@ -205,8 +208,6 @@ struct MoqAnnounceCancel {
 };
 
 
-MessageBuffer &operator<<(MessageBuffer &buffer, const MoqUnannounce &msg);
-MessageBuffer &operator>>(MessageBuffer &buffer, MoqUnannounce &msg);
 MessageBuffer &operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg);
 MessageBuffer &operator>>(MessageBuffer &buffer, MoqAnnounceCancel &msg);
 
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 4ae0ba96..f0b2a597 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -285,7 +285,6 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
   return true;
 }
 
-
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqAnnounceOk& msg){
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK)));
@@ -348,20 +347,26 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceError &msg
   return true;
 }
 
-
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqUnannounce &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_UNANNOUNCE);
-  buffer << msg.track_namespace;
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqUnannounce& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_UNANNOUNCE)));
+  buffer.push_lv(msg.track_namespace);
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqUnannounce &msg) {
-  buffer >> msg.track_namespace;
-  return buffer;
-}
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnannounce &msg) {
 
+  // read namespace
+  if (msg.track_namespace.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = *val;
+  }
+  return true;
+}
 
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg) {
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 1295ae62..8c10cda3 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -17,38 +17,42 @@ const quicr::bytes TRACK_NAMESPACE_CONF = from_ascii("moqt://conf.example.com/co
 const quicr::bytes TRACK_NAME_ALICE_VIDEO = from_ascii("alice/video");
 const uintVar_t TRACK_ALIAS_ALICE_VIDEO = 0xA11CE;
 
-TEST_CASE("AnnounceOk Message encode/decode")
-{
-  qtransport::StreamBuffer<uint8_t> buffer;
-
-  auto announce_ok  = MoqAnnounceOk {};
-  announce_ok.track_namespace = TRACK_NAMESPACE_CONF;
-
-  buffer << announce_ok;
-
-  std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
-  // ingress buffer
+template<typename T>
+bool verify(std::vector<uint8_t>& net_data, uint64_t message_type, T& message) {
   qtransport::StreamBuffer<uint8_t> in_buffer;
-  std::optional<uint64_t> message_type;
-
-  MoqAnnounceOk announce_ok_out;
+  std::optional<uint64_t> msg_type;
+  bool done = false;
   for (auto& v: net_data) {
     in_buffer.push(v);
-    if (!message_type) {
-      message_type = in_buffer.decode_uintV();
-      if (!message_type) {
+    if (!msg_type) {
+      msg_type = in_buffer.decode_uintV();
+      if (!msg_type) {
         continue;
       }
-      CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK));
+      CHECK_EQ(*msg_type, message_type);
       continue;
     }
-    bool got = in_buffer >> announce_ok_out;
-    if (!got) {
-      continue;
+
+    done = in_buffer >> message;
+    if (done) {
+      break;
     }
   }
 
+  return done;
+}
+
+TEST_CASE("AnnounceOk Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto announce_ok  = MoqAnnounceOk {};
+  announce_ok.track_namespace = TRACK_NAMESPACE_CONF;
+  buffer << announce_ok;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqAnnounceOk announce_ok_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK), announce_ok_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
 }
 
@@ -61,29 +65,8 @@ TEST_CASE("Announce Message encode/decode")
   announce.params = {};
   buffer <<  announce;
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
-  // ingress buffer
-  qtransport::StreamBuffer<uint8_t> in_buffer;
-  std::optional<uint64_t> message_type;
-
   MoqAnnounce announce_out;
-  for (auto& v: net_data) {
-    in_buffer.push(v);
-    if (!message_type) {
-      message_type = in_buffer.decode_uintV();
-      if(!message_type) {
-        continue;
-      }
-      CHECK_EQ(*message_type, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE));
-      continue;
-    }
-
-    bool got = in_buffer >> announce_out;
-    if (!got) {
-      continue;
-    }
-  }
-
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE), announce_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
   CHECK_EQ(0, announce_out.params.size());
 }

From 175f9888b8896646a24d30680939ba0919c01ead Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 18:30:35 -0700
Subject: [PATCH 07/71] add announce_err, unannounce

---
 include/quicr/moq_messages.h |  5 +++--
 test/moq_messages.cpp        | 35 ++++++++++++++++++++++++++++++++++-
 2 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index d39e62d0..5ccd5213 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -191,16 +191,17 @@ struct MoqAnnounceError {
   std::optional<TrackNamespace> track_namespace;
   std::optional<ErrorCode> err_code;
   std::optional<ReasonPhrase> reason_phrase;
+
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceError &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
-                                                       const MoqAnnounceError* msg);
+                                                       const MoqAnnounceError& msg);
 };
 
 struct MoqUnannounce {
   TrackNamespace track_namespace;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnannounce &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
-                                                       const MoqUnannounce* msg);
+                                                       const MoqUnannounce& msg);
 };
 
 struct MoqAnnounceCancel {
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 8c10cda3..9ac09aad 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -18,7 +18,8 @@ const quicr::bytes TRACK_NAME_ALICE_VIDEO = from_ascii("alice/video");
 const uintVar_t TRACK_ALIAS_ALICE_VIDEO = 0xA11CE;
 
 template<typename T>
-bool verify(std::vector<uint8_t>& net_data, uint64_t message_type, T& message) {
+bool verify(std::vector<uint8_t>& net_data, uint64_t message_type, T& message, size_t slice_depth=1) {
+  // TODO: support size_depth > 1, if needed
   qtransport::StreamBuffer<uint8_t> in_buffer;
   std::optional<uint64_t> msg_type;
   bool done = false;
@@ -70,3 +71,35 @@ TEST_CASE("Announce Message encode/decode")
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
   CHECK_EQ(0, announce_out.params.size());
 }
+
+TEST_CASE("Unannounce Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto unannounce  = MoqUnannounce {};
+  unannounce.track_namespace = TRACK_NAMESPACE_CONF;
+  buffer << unannounce;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqAnnounceOk announce_ok_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_UNANNOUNCE), announce_ok_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
+}
+
+TEST_CASE("AnnounceError Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto announce_err  = MoqAnnounceError {};
+  announce_err.track_namespace = TRACK_NAMESPACE_CONF;
+  announce_err.err_code = 0x1234;
+  announce_err.reason_phrase = quicr::bytes{0x1,0x2,0x3};
+  buffer << announce_err;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqAnnounceError announce_err_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_ERROR), announce_err_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, announce_err_out.track_namespace);
+  CHECK_EQ(announce_err.err_code, announce_err_out.err_code);
+  CHECK_EQ(announce_err.reason_phrase, announce_err_out.reason_phrase);
+}
\ No newline at end of file

From 2cc7171d05b23fcb85e7a4d6d1408994233ab448 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Fri, 31 May 2024 18:35:52 -0700
Subject: [PATCH 08/71] add announce_cancel

---
 include/quicr/moq_messages.h |  7 +++----
 src/moq_messages.cpp         | 25 ++++++++++++++++---------
 test/moq_messages.cpp        | 14 ++++++++++++++
 3 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 5ccd5213..0ffe1028 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -206,13 +206,12 @@ struct MoqUnannounce {
 
 struct MoqAnnounceCancel {
   TrackNamespace track_namespace;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceCancel &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqAnnounceCancel& msg);
 };
 
 
-MessageBuffer &operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg);
-MessageBuffer &operator>>(MessageBuffer &buffer, MoqAnnounceCancel &msg);
-
-
 //
 // GoAway
 //
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index f0b2a597..54937bad 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -368,19 +368,26 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnannounce &msg) {
   return true;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqAnnounceCancel &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL);
-  buffer << msg.track_namespace;
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqAnnounceCancel& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL)));
+  buffer.push_lv(msg.track_namespace);
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqAnnounceCancel &msg) {
-  buffer >> msg.track_namespace;
-  return buffer;
-}
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceCancel &msg) {
 
+  // read namespace
+  if (msg.track_namespace.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = *val;
+  }
+  return true;
+}
 
 //
 // Goaway
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 9ac09aad..f0094cff 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -102,4 +102,18 @@ TEST_CASE("AnnounceError Message encode/decode")
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_err_out.track_namespace);
   CHECK_EQ(announce_err.err_code, announce_err_out.err_code);
   CHECK_EQ(announce_err.reason_phrase, announce_err_out.reason_phrase);
+}
+
+TEST_CASE("AnnounceCancel Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto announce_cancel  = MoqAnnounceCancel {};
+  announce_cancel.track_namespace = TRACK_NAMESPACE_CONF;
+  buffer << announce_cancel;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqAnnounceCancel announce_cancel_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL), announce_cancel_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, announce_cancel_out.track_namespace);
 }
\ No newline at end of file

From 5648e920317c1f7cd64951e1f2aeabec3384af43 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Sat, 1 Jun 2024 04:20:49 -0700
Subject: [PATCH 09/71] add subscribe

---
 include/quicr/moq_messages.h |  39 +++---
 src/moq_messages.cpp         | 250 +++++++++++++++++++++++------------
 test/moq_messages.cpp        | 150 +++++++++++++++++++++
 3 files changed, 338 insertions(+), 101 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 0ffe1028..a81631a5 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -65,7 +65,7 @@ enum struct ParameterType : uint8_t {
 };
 
 struct MoqParameter{
-  std::optional<ParamType> param_type;
+  std::optional<uint64_t> param_type;
   uintVar_t param_length;
   bytes param_value;
 };
@@ -96,28 +96,31 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqServerSetup &msg);
 //
 // Subscribe
 //
-enum struct LocationMode: uint8_t {
+enum struct FilterType: uint64_t {
   None = 0x0,
-  Absolute,
-  RelativePrevious,
-  RelativeNext
-};
-
-struct Location {
-  LocationMode mode;
-  std::optional<uintVar_t> value;
+  LatestGroup,
+  LatestObject,
+  AbsoluteStart,
+  AbsoluteRange
 };
 
 struct MoqSubscribe {
-  SubscribeId subscribe_id;
-  TrackAlias track_alias;
+  std::optional<uint64_t> subscribe_id;
+  std::optional<uint64_t> track_alias;
   TrackNamespace track_namespace;
   TrackName track_name;
-  Location start_group;
-  Location start_object;
-  Location end_group;
-  Location end_object;
+  FilterType filter_type {FilterType::None};
+  std::optional<uintVar_t> start_group;
+  std::optional<uintVar_t> end_group;
+  std::optional<uintVar_t> start_object;
+  std::optional<uintVar_t> end_object;
+  uint64_t num_params {0};
   std::vector<MoqParameter> track_params;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqSubscribe& msg);
+private:
+  MoqParameter current_param{};
 };
 
 struct MoqSubscribeOk {
@@ -150,8 +153,6 @@ struct MoqSubscribeDone
   ObjectId final_object_id;
 };
 
-MessageBuffer& operator<<(MessageBuffer &buffer, const Location &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, Location &msg);
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribe &msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribe &msg);
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg);
@@ -283,8 +284,6 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamHeaderGroup &msg);
 MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamGroupObject& msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg);
 
-// utility
-std::tuple<Location, Location, Location, Location>  to_locations(const SubscribeIntent& intent);
 MessageBuffer& operator<<(MessageBuffer& buffer, const std::vector<uintVar_t>& val);
 MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
 MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 54937bad..952e5558 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -53,71 +53,185 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
 // Subscribe
 //
 
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqSubscribe& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id.value()));
+  buffer.push(qtransport::to_uintV(msg.track_alias.value()));
+  buffer.push_lv(msg.track_namespace);
+  buffer.push_lv(msg.track_name);
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.filter_type)));
 
-MessageBuffer& operator<<(MessageBuffer &buffer, const Location &msg) {
-  if (msg.mode == LocationMode::None) {
-    buffer << static_cast<uint8_t >(msg.mode);
-    return buffer;
+  switch (msg.filter_type) {
+    case FilterType::None:
+    case FilterType::LatestGroup:
+    case FilterType::LatestObject:
+      break;
+    case FilterType::AbsoluteStart: {
+      buffer.push(qtransport::to_uintV(msg.start_group.value()));
+      buffer.push(qtransport::to_uintV(msg.start_object.value()));
+    }
+      break;
+    case FilterType::AbsoluteRange:
+      buffer.push(qtransport::to_uintV(msg.start_group.value()));
+      buffer.push(qtransport::to_uintV(msg.start_object.value()));
+      buffer.push(qtransport::to_uintV(msg.end_group.value()));
+      buffer.push(qtransport::to_uintV(msg.end_object.value()));
+      break;
   }
-  buffer << static_cast<uint8_t >(msg.mode);
-  buffer << msg.value.value();
-  return buffer;
-}
 
-MessageBuffer& operator>>(MessageBuffer &buffer, Location &msg) {
-  uint8_t mode {0};
-  buffer >> mode;
-  msg.mode = static_cast<LocationMode>(mode);
-  if (static_cast<LocationMode>(mode) != LocationMode::None) {
-    uintVar_t loc_val{0};
-    buffer >> loc_val;
-    msg.value = loc_val;
+  buffer.push(qtransport::to_uintV(msg.num_params));
+  for (const auto& param: msg.track_params) {
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.param_type.value())));
+    buffer.push(qtransport::to_uintV(param.param_length));
+    buffer.push(param.param_value);
   }
+
   return buffer;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqSubscribe &msg) {
-  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_SUBSCRIBE);
-  buffer << msg.subscribe_id;
-  buffer << msg.track_alias;
-  buffer << msg.track_namespace;
-  buffer << msg.track_name;
-  buffer << msg.start_group;
-  buffer << msg.start_object;
-  buffer << msg.end_group;
-  buffer << msg.end_object;
-  buffer << static_cast<uintVar_t>(msg.track_params.size());
-  for (const auto& param: msg.track_params) {
-    buffer << param.param_type;
-    buffer << param.param_length;
-    buffer << param.param_value;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
+
+  if (!msg.subscribe_id.has_value()) {
+    auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+    msg.subscribe_id = val.value();
   }
-  return buffer;
-}
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqSubscribe &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.track_alias;
-  buffer >> msg.track_namespace;
-  buffer >> msg.track_name;
-  buffer >> msg.start_group;
-  buffer >> msg.start_object;
-  buffer >> msg.end_group;
-  buffer >> msg.end_object;
-  uintVar_t num_params {0};
-  buffer >> num_params;
-  auto track_params = std::vector<MoqParameter>{};
-  while(static_cast<uint64_t>(num_params) > 0) {
-    auto param = MoqParameter{};
-    buffer >> param.param_type;
-    buffer >> param.param_length;
-    buffer >> param.param_value;
-    track_params.push_back(std::move(param));
-    num_params = num_params - 1;
+  if (!msg.track_alias.has_value()) {
+    auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+    msg.track_alias = val.value();
   }
-  return buffer;
+
+  if (msg.track_namespace.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_namespace = val.value();
+  }
+
+  if (msg.track_name.empty())
+  {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    msg.track_name = val.value();
+  }
+
+  if (msg.filter_type == FilterType::None)
+  {
+    const auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+
+    auto filter = val.value();
+    msg.filter_type = static_cast<FilterType>(filter);
+  }
+
+  switch (msg.filter_type) {
+    case FilterType::None:
+    throw std::runtime_error("Malformed Filter Type");
+    case FilterType::LatestGroup:
+    case FilterType::LatestObject:
+      break;
+    case FilterType::AbsoluteStart:
+    {
+      if (!msg.start_group.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.start_group = val.value();
+      }
+
+      if (!msg.start_object.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.start_object = val.value();
+      }
+    }
+      break;
+    case FilterType::AbsoluteRange:
+    {
+      if (!msg.start_group.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.start_group = val.value();
+      }
+
+      if (!msg.start_object.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.start_object = val.value();
+      }
+
+      if (!msg.end_group.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.end_group = val.value();
+      }
+
+      if (!msg.end_object.has_value()) {
+        const auto val = buffer.decode_uintV();
+        if (!val) {
+          return false;
+        }
+        msg.end_object = val.value();
+      }
+    }
+      break;
+  }
+
+  if (!msg.num_params) {
+    const auto val = buffer.decode_uintV();
+    if (!val) {
+      return false;
+    }
+    msg.num_params = val.value();
+  }
+
+  // parse each param
+  while (msg.num_params > 0) {
+    if (!msg.current_param.param_type) {
+      auto val = buffer.front();
+      if (!val) {
+        return false;
+      }
+      msg.current_param.param_type = *val;
+      buffer.pop();
+    }
+
+    // decode param_len:<bytes>
+    auto param = buffer.decode_bytes();
+    if (!param) {
+      return false;
+    }
+
+    msg.current_param.param_length = param->size();
+    msg.current_param.param_value = param.value();
+    msg.track_params.push_back(msg.current_param);
+    msg.current_param = {};
+    msg.num_params -= 1;
+  }
+
+  return true;
 }
 
 MessageBuffer &
@@ -522,32 +636,6 @@ operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg) {
   return buffer;
 }
 
-std::tuple<Location, Location, Location, Location> to_locations(const SubscribeIntent& intent) {
-  auto none_location = Location {.mode = LocationMode::None, .value = std::nullopt};
-
-  /*
-   * Sequence:                0    1    2    3    4   [5]  [6] ...
-                                                ^
-                                           Largest Sequence
-   RelativePrevious Value:  4    3    2    1    0
-   RelativeNext Value:                               0    1  ...
- */
-  switch (intent) {
-    case SubscribeIntent::immediate:
-      return std::make_tuple(Location{.mode=LocationMode::RelativePrevious, .value=0}, //StartGroup
-                             none_location, // EndGroup
-                             Location{.mode=LocationMode::RelativePrevious, .value=0}, //StartObject
-                             none_location); // EndObject
-    case SubscribeIntent::sync_up:
-      throw std::runtime_error("Intent Unsupported for Subscribe");
-    case SubscribeIntent::wait_up:
-      throw std::runtime_error("Intent Unsupported for Subscribe");
-    default:
-      throw std::runtime_error("Bad Intent  for Subscribe");
-  }
-
-}
-
 
 // Setup
 
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index f0094cff..73422316 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -116,4 +116,154 @@ TEST_CASE("AnnounceCancel Message encode/decode")
   MoqAnnounceCancel announce_cancel_out;
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL), announce_cancel_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_cancel_out.track_namespace);
+}
+
+TEST_CASE("Subscribe (LatestObject) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::LatestObject;
+  subscribe.num_params = 0;
+
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
+  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+}
+
+TEST_CASE("Subscribe (LatestGroup) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::LatestGroup;
+  subscribe.num_params = 0;
+
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
+  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+}
+
+TEST_CASE("Subscribe (AbsoluteStart) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::AbsoluteStart;
+  subscribe.start_group = 0x1000;
+  subscribe.start_object = 0xFF;
+  subscribe.num_params = 0;
+
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
+  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+  CHECK_EQ(subscribe.start_group, subscribe_out.start_group);
+  CHECK_EQ(subscribe.start_object, subscribe_out.start_object);
+}
+
+TEST_CASE("Subscribe (AbsoluteRange) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::AbsoluteRange;
+  subscribe.start_group = 0x1000;
+  subscribe.start_object = 0x1;
+  subscribe.end_group = 0xFFF;
+  subscribe.end_object = 0xFF;
+
+  subscribe.num_params = 0;
+
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
+  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+  CHECK_EQ(subscribe.start_group, subscribe_out.start_group);
+  CHECK_EQ(subscribe.start_object, subscribe_out.start_object);
+  CHECK_EQ(subscribe.end_group, subscribe_out.end_group);
+  CHECK_EQ(subscribe.end_object, subscribe_out.end_object);
+}
+
+TEST_CASE("Subscribe (Params) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  MoqParameter param;
+  param.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
+  param.param_length = 0x2;
+  param.param_value = {0x1, 0x2};
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::LatestObject;
+  subscribe.num_params = 1;
+  subscribe.track_params.push_back(param);
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
+  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+  CHECK_EQ(subscribe.track_params.size(), subscribe_out.track_params.size());
+  CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
+  CHECK_EQ(subscribe.track_params[0].param_length, subscribe_out.track_params[0].param_length);
+  CHECK_EQ(subscribe.track_params[0].param_value, subscribe_out.track_params[0].param_value);
 }
\ No newline at end of file

From 6dfee82fd67f7fb90ee55d511ee0c0cf97b5fabe Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Sun, 2 Jun 2024 09:11:24 -0700
Subject: [PATCH 10/71] add subscribe_ok

---
 include/quicr/moq_messages.h |  19 +++----
 src/moq_messages.cpp         | 102 ++++++++++++++++++++++++++---------
 test/moq_messages.cpp        |  45 ++++++++++++++++
 3 files changed, 132 insertions(+), 34 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index a81631a5..326759df 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -18,7 +18,7 @@ using ReasonPhrase = quicr::bytes;
 using GroupId = uintVar_t;
 using ObjectId = uintVar_t;
 using ObjectPriority = uintVar_t;
-using SubscribeId = uintVar_t;
+using SubscribeId = uint64_t;
 using TrackAlias = uintVar_t;
 using ParamType = uintVar_t;
 
@@ -125,10 +125,16 @@ struct MoqSubscribe {
 
 struct MoqSubscribeOk {
   SubscribeId subscribe_id;
-  uintVar_t expires;
+  uint64_t expires;
   bool content_exists;
-  std::optional<GroupId> largest_group;
-  std::optional<ObjectId> largest_object;
+  uint64_t largest_group {0};
+  uint64_t largest_object {0};
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqSubscribeOk& msg);
+private:
+  size_t current_pos {0};
+  const size_t MAX_FIELDS = 5;
 };
 
 
@@ -153,19 +159,14 @@ struct MoqSubscribeDone
   ObjectId final_object_id;
 };
 
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribe &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribe &msg);
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg);
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeOk &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeOk &msg);
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeError &msg);
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeDone &msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeDone &msg);
 
 
-
 //
 // Announce
 //
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 952e5558..a5a7bf0a 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -247,39 +247,91 @@ operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg) {
   return buffer;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqSubscribeOk &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_OK);
-  buffer << msg.subscribe_id;
-  buffer << msg.expires;
-  buffer << static_cast<uint8_t>(msg.content_exists);
-  if (msg.content_exists) {
-    buffer << msg.largest_group;
-    buffer << msg.largest_object;
-    return buffer;
+
+/*
+ * SubscribeId subscribe_id;
+uintVar_t expires;
+bool content_exists;
+std::optional<GroupId> largest_group;
+std::optional<ObjectId> largest_object;
+
+ */
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqSubscribeOk& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.expires));
+  msg.content_exists ? buffer.push(static_cast<uint8_t>(1)) : buffer.push(static_cast<uint8_t>(0));
+  if(msg.content_exists) {
+    buffer.push(qtransport::to_uintV(msg.largest_group));
+    buffer.push(qtransport::to_uintV(msg.largest_object));
   }
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqSubscribeOk &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.expires;
-  uint8_t content_exists {0};
-  buffer >> content_exists;
-  if(content_exists > 1) {
-    throw std::runtime_error("Invalid Context Exists Value");
+bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& field) {
+  auto val = buffer.decode_uintV();
+  if (!val) {
+    return false;
   }
+  field = val.value();
+  return true;
+}
 
-  if (content_exists == 1) {
-    msg.content_exists = true;
-    buffer >> msg.largest_group;
-    buffer >> msg.largest_object;
-    return buffer;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg) {
+
+  switch (msg.current_pos) {
+    case 0:
+    {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.expires)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      const auto val = buffer.front();
+      if (!val) {
+        return false;
+      }
+      buffer.pop();
+      msg.content_exists = (val.value()) == 1;
+      msg.current_pos += 1;
+      if (!msg.content_exists) {
+        // nothing more to process.
+        return true;
+      }
+    }
+    break;
+    case 3: {
+      if(!parse_uintV_field(buffer, msg.largest_group)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 4: {
+      if(!parse_uintV_field(buffer, msg.largest_object)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    default:
+      throw std::runtime_error("Malformed Message (SubscribeOK)");
   }
 
-  msg.content_exists = false;
-  return buffer;
+  if (msg.current_pos < msg.MAX_FIELDS) {
+    return false;
+  }
+  return true;
 }
 
 MessageBuffer &
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 73422316..ebf07541 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -266,4 +266,49 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
   CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
   CHECK_EQ(subscribe.track_params[0].param_length, subscribe_out.track_params[0].param_length);
   CHECK_EQ(subscribe.track_params[0].param_value, subscribe_out.track_params[0].param_value);
+}
+
+
+TEST_CASE("SubscribeOk Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe_ok  = MoqSubscribeOk {};
+  subscribe_ok.subscribe_id = 0x1;
+  subscribe_ok.expires = 0x100;
+  subscribe_ok.content_exists = false;
+  buffer << subscribe_ok;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribeOk subscribe_ok_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK), subscribe_ok_out));
+  CHECK_EQ(subscribe_ok.subscribe_id, subscribe_ok_out.subscribe_id);
+  CHECK_EQ(subscribe_ok.expires, subscribe_ok_out.expires);
+  CHECK_EQ(subscribe_ok.content_exists, subscribe_ok_out.content_exists);
+}
+
+
+TEST_CASE("SubscribeOk (content-exists) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe_ok  = MoqSubscribeOk {};
+  subscribe_ok.subscribe_id = 0x1;
+  subscribe_ok.expires = 0x100;
+  subscribe_ok.content_exists = true;
+  subscribe_ok.largest_group = 0x1000;
+  subscribe_ok.largest_object = 0xff;
+  buffer << subscribe_ok;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribeOk subscribe_ok_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK), subscribe_ok_out));
+  CHECK_EQ(subscribe_ok.subscribe_id, subscribe_ok_out.subscribe_id);
+  CHECK_EQ(subscribe_ok.expires, subscribe_ok_out.expires);
+  CHECK_EQ(subscribe_ok.content_exists, subscribe_ok_out.content_exists);
+  CHECK_EQ(subscribe_ok.largest_group, subscribe_ok_out.largest_group);
+  CHECK_EQ(subscribe_ok.largest_object, subscribe_ok_out.largest_object);
+
 }
\ No newline at end of file

From 6fd6e534f149ad849eb575d5b1b47c06605e0ba8 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Sun, 2 Jun 2024 23:11:57 -0700
Subject: [PATCH 11/71] rewrite subscribe parsing

---
 include/quicr/moq_messages.h |  16 ++-
 src/moq_messages.cpp         | 260 +++++++++++++++++------------------
 test/moq_messages.cpp        |  66 +++++++--
 3 files changed, 191 insertions(+), 151 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 326759df..6d4e0021 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -105,22 +105,24 @@ enum struct FilterType: uint64_t {
 };
 
 struct MoqSubscribe {
-  std::optional<uint64_t> subscribe_id;
-  std::optional<uint64_t> track_alias;
+  uint64_t subscribe_id;
+  uint64_t track_alias;
   TrackNamespace track_namespace;
   TrackName track_name;
   FilterType filter_type {FilterType::None};
-  std::optional<uintVar_t> start_group;
-  std::optional<uintVar_t> end_group;
-  std::optional<uintVar_t> start_object;
-  std::optional<uintVar_t> end_object;
+  uint64_t start_group {0};
+  uint64_t end_group {0};
+  uint64_t start_object {0};
+  uint64_t end_object {0};
   uint64_t num_params {0};
   std::vector<MoqParameter> track_params;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
                                                        const MoqSubscribe& msg);
 private:
-  MoqParameter current_param{};
+  std::optional<MoqParameter> current_param{};
+  size_t current_pos {0};
+  bool parsing_completed { false };
 };
 
 struct MoqSubscribeOk {
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index a5a7bf0a..8226f9c2 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -4,6 +4,28 @@
 
 namespace quicr::messages {
 
+//
+// Utility
+//
+bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& field) {
+  auto val = buffer.decode_uintV();
+  if (!val) {
+    return false;
+  }
+  field = val.value();
+  return true;
+}
+
+
+bool parse_bytes_field(qtransport::StreamBuffer<uint8_t> &buffer, quicr::bytes& field) {
+  auto val = buffer.decode_bytes();
+  if (!val) {
+    return false;
+  }
+  field = std::move(val.value());
+  return true;
+}
+
 //
 // Optional
 //
@@ -56,8 +78,8 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribe& msg){
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE)));
-  buffer.push(qtransport::to_uintV(msg.subscribe_id.value()));
-  buffer.push(qtransport::to_uintV(msg.track_alias.value()));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push_lv(msg.track_namespace);
   buffer.push_lv(msg.track_name);
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.filter_type)));
@@ -68,15 +90,15 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
     case FilterType::LatestObject:
       break;
     case FilterType::AbsoluteStart: {
-      buffer.push(qtransport::to_uintV(msg.start_group.value()));
-      buffer.push(qtransport::to_uintV(msg.start_object.value()));
+      buffer.push(qtransport::to_uintV(msg.start_group));
+      buffer.push(qtransport::to_uintV(msg.start_object));
     }
       break;
     case FilterType::AbsoluteRange:
-      buffer.push(qtransport::to_uintV(msg.start_group.value()));
-      buffer.push(qtransport::to_uintV(msg.start_object.value()));
-      buffer.push(qtransport::to_uintV(msg.end_group.value()));
-      buffer.push(qtransport::to_uintV(msg.end_object.value()));
+      buffer.push(qtransport::to_uintV(msg.start_group));
+      buffer.push(qtransport::to_uintV(msg.start_object));
+      buffer.push(qtransport::to_uintV(msg.end_group));
+      buffer.push(qtransport::to_uintV(msg.end_object));
       break;
   }
 
@@ -92,143 +114,130 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
 
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
 
-  if (!msg.subscribe_id.has_value()) {
-    auto val = buffer.decode_uintV();
-    if (!val) {
-      return false;
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
     }
-    msg.subscribe_id = val.value();
-  }
-
-  if (!msg.track_alias.has_value()) {
-    auto val = buffer.decode_uintV();
-    if (!val) {
-      return false;
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
     }
-    msg.track_alias = val.value();
-  }
-
-  if (msg.track_namespace.empty())
-  {
-    const auto val = buffer.decode_bytes();
-    if (!val) {
-      return false;
+    break;
+    case 2: {
+      if(!parse_bytes_field(buffer, msg.track_namespace)) {
+        return false;
+      }
+      msg.current_pos += 1;
     }
-    msg.track_namespace = val.value();
-  }
-
-  if (msg.track_name.empty())
-  {
-    const auto val = buffer.decode_bytes();
-    if (!val) {
-      return false;
+    break;
+    case 3: {
+      if(!parse_bytes_field(buffer, msg.track_name)) {
+        return false;
+      }
+      msg.current_pos += 1;
     }
-    msg.track_name = val.value();
-  }
-
-  if (msg.filter_type == FilterType::None)
-  {
-    const auto val = buffer.decode_uintV();
-    if (!val) {
-      return false;
+    break;
+    case 4: {
+      const auto val = buffer.decode_uintV();
+      if (!val) {
+        return false;
+      }
+      auto filter = val.value();
+      msg.filter_type = static_cast<FilterType>(filter);
+      if (msg.filter_type == FilterType::LatestGroup
+          || msg.filter_type == FilterType::LatestObject) {
+        // we don't get further fields until parameters
+        msg.current_pos = 9;
+      } else {
+        msg.current_pos += 1;
+      }
     }
-
-    auto filter = val.value();
-    msg.filter_type = static_cast<FilterType>(filter);
-  }
-
-  switch (msg.filter_type) {
-    case FilterType::None:
-    throw std::runtime_error("Malformed Filter Type");
-    case FilterType::LatestGroup:
-    case FilterType::LatestObject:
-      break;
-    case FilterType::AbsoluteStart:
-    {
-      if (!msg.start_group.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+    break;
+    case 5: {
+      if (msg.filter_type == FilterType::AbsoluteStart
+          || msg.filter_type == FilterType::AbsoluteRange) {
+        if (!parse_uintV_field(buffer, msg.start_group)) {
           return false;
         }
-        msg.start_group = val.value();
+        msg.current_pos += 1;
       }
-
-      if (!msg.start_object.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+    }
+    break;
+    case 6: {
+      if (msg.filter_type == FilterType::AbsoluteStart
+          || msg.filter_type == FilterType::AbsoluteRange) {
+        if (!parse_uintV_field(buffer, msg.start_object)) {
           return false;
         }
-        msg.start_object = val.value();
+
+        if (msg.filter_type == FilterType::AbsoluteStart) {
+          msg.current_pos = 9;
+        } else {
+          msg.current_pos += 1;
+        }
       }
     }
-      break;
-    case FilterType::AbsoluteRange:
-    {
-      if (!msg.start_group.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+    break;
+    case 7: {
+      if (msg.filter_type == FilterType::AbsoluteRange) {
+        if (!parse_uintV_field(buffer, msg.end_group)) {
           return false;
         }
-        msg.start_group = val.value();
+        msg.current_pos += 1;
       }
-
-      if (!msg.start_object.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+    }
+    break;
+    case 8: {
+      if (msg.filter_type == FilterType::AbsoluteRange) {
+        if (!parse_uintV_field(buffer, msg.end_object)) {
           return false;
         }
-        msg.start_object = val.value();
+        msg.current_pos += 1;
       }
-
-      if (!msg.end_group.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+    }
+    break;
+    case 9: {
+      if (!msg.current_param.has_value()) {
+        if (!parse_uintV_field(buffer, msg.num_params)) {
           return false;
         }
-        msg.end_group = val.value();
+        msg.current_param = MoqParameter{};
       }
+      // parse each param
+      while (msg.num_params > 0) {
+        if (!msg.current_param.value().param_type) {
+          auto val = buffer.front();
+          if (!val) {
+            return false;
+          }
+          msg.current_param.value().param_type = *val;
+          buffer.pop();
+        }
 
-      if (!msg.end_object.has_value()) {
-        const auto val = buffer.decode_uintV();
-        if (!val) {
+        // decode param_len:<bytes>
+        auto param = buffer.decode_bytes();
+        if (!param) {
           return false;
         }
-        msg.end_object = val.value();
+        msg.current_param.value().param_length = param->size();
+        msg.current_param.value().param_value = param.value();
+        msg.track_params.push_back(msg.current_param.value());
+        msg.current_param = MoqParameter{};
+        msg.num_params -= 1;
       }
+      msg.parsing_completed = true;
     }
-      break;
-  }
-
-  if (!msg.num_params) {
-    const auto val = buffer.decode_uintV();
-    if (!val) {
-      return false;
-    }
-    msg.num_params = val.value();
+    break;
   }
 
-  // parse each param
-  while (msg.num_params > 0) {
-    if (!msg.current_param.param_type) {
-      auto val = buffer.front();
-      if (!val) {
-        return false;
-      }
-      msg.current_param.param_type = *val;
-      buffer.pop();
-    }
-
-    // decode param_len:<bytes>
-    auto param = buffer.decode_bytes();
-    if (!param) {
-      return false;
-    }
-
-    msg.current_param.param_length = param->size();
-    msg.current_param.param_value = param.value();
-    msg.track_params.push_back(msg.current_param);
-    msg.current_param = {};
-    msg.num_params -= 1;
+  if (!msg.parsing_completed ) {
+    return false;
   }
 
   return true;
@@ -247,15 +256,6 @@ operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg) {
   return buffer;
 }
 
-
-/*
- * SubscribeId subscribe_id;
-uintVar_t expires;
-bool content_exists;
-std::optional<GroupId> largest_group;
-std::optional<ObjectId> largest_object;
-
- */
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribeOk& msg){
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK)));
@@ -269,14 +269,6 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   return buffer;
 }
 
-bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& field) {
-  auto val = buffer.decode_uintV();
-  if (!val) {
-    return false;
-  }
-  field = val.value();
-  return true;
-}
 
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg) {
 
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index ebf07541..5d5f2a15 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -138,8 +138,8 @@ TEST_CASE("Subscribe (LatestObject) Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
-  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
-  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
 }
@@ -164,8 +164,8 @@ TEST_CASE("Subscribe (LatestGroup) Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
-  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
-  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
 }
@@ -192,8 +192,8 @@ TEST_CASE("Subscribe (AbsoluteStart) Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
-  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
-  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
   CHECK_EQ(subscribe.start_group, subscribe_out.start_group);
@@ -225,8 +225,8 @@ TEST_CASE("Subscribe (AbsoluteRange) Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
-  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
-  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.num_params, subscribe_out.num_params);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
   CHECK_EQ(subscribe.start_group, subscribe_out.start_group);
@@ -259,8 +259,8 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
-  CHECK_EQ(subscribe.subscribe_id.value(), subscribe_out.subscribe_id.value());
-  CHECK_EQ(subscribe.track_alias.value(), subscribe_out.track_alias.value());
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
   CHECK_EQ(subscribe.track_params.size(), subscribe_out.track_params.size());
   CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
@@ -269,6 +269,52 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
 }
 
 
+TEST_CASE("Subscribe (Params - 2) Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  MoqParameter param1 {
+    .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
+    .param_length = 0x2,
+    .param_value = {0x1, 0x2}
+  };
+
+  MoqParameter param2  {
+    .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
+    .param_length = 0x4,
+    .param_value = {0x1, 0x2, 0x3, 0x4}
+  };
+
+  auto subscribe  = MoqSubscribe {};
+  subscribe.subscribe_id = 0x1;
+  subscribe.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  subscribe.track_namespace = TRACK_NAMESPACE_CONF;
+  subscribe.track_name = TRACK_NAME_ALICE_VIDEO;
+  subscribe.filter_type = FilterType::LatestObject;
+  subscribe.num_params = 2;
+  subscribe.track_params.push_back(param1);
+  subscribe.track_params.push_back(param2);
+  buffer << subscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribe subscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+  CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+  CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
+  CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
+  CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
+  CHECK_EQ(subscribe.track_params.size(), subscribe_out.track_params.size());
+  CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
+  CHECK_EQ(subscribe.track_params[0].param_length, subscribe_out.track_params[0].param_length);
+  CHECK_EQ(subscribe.track_params[0].param_value, subscribe_out.track_params[0].param_value);
+
+  CHECK_EQ(subscribe.track_params[1].param_type, subscribe_out.track_params[1].param_type);
+  CHECK_EQ(subscribe.track_params[1].param_length, subscribe_out.track_params[1].param_length);
+  CHECK_EQ(subscribe.track_params[1].param_value, subscribe_out.track_params[1].param_value);
+}
+
+
 TEST_CASE("SubscribeOk Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;

From 27039e2dcc7e49066f7472e0310844761be58da0 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 01:51:19 -0700
Subject: [PATCH 12/71] add a combo test for subscribe

---
 test/moq_messages.cpp | 76 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 5d5f2a15..994204f3 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -315,6 +315,82 @@ TEST_CASE("Subscribe (Params - 2) Message encode/decode")
 }
 
 
+MoqSubscribe generate_subscribe(FilterType filter, size_t  num_params = 0, uint64_t sg = 0, uint64_t so=0,
+                   uint64_t eg=0, uint64_t eo=0) {
+  MoqSubscribe out;
+  out.subscribe_id = 0xABCD;
+  out.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  out.track_namespace = TRACK_NAMESPACE_CONF;
+  out.track_name = TRACK_NAME_ALICE_VIDEO;
+  out.filter_type = filter;
+  out.num_params = num_params;
+  switch (filter) {
+    case FilterType::LatestObject:
+    case FilterType::LatestGroup:
+      break;
+    case FilterType::AbsoluteStart:
+      out.start_group = sg;
+      out.start_object = so;
+      break;
+    case FilterType::AbsoluteRange:
+      out.start_group = sg;
+      out.start_object = so;
+      out.end_group = eg;
+      out.end_object = eo;
+      break;
+  }
+
+  while(num_params > 0) {
+    MoqParameter param1 {
+      .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
+      .param_length = 0x2,
+      .param_value = {0x1, 0x2}
+    };
+    out.track_params.push_back(param1);
+    num_params--;
+  }
+  return out;
+}
+
+TEST_CASE("Subscribe (Combo) Message encode/decode")
+{
+  auto subscribes = std::vector<MoqSubscribe> {
+    generate_subscribe(FilterType::LatestObject),
+    generate_subscribe(FilterType::LatestGroup),
+    generate_subscribe(FilterType::LatestObject, 1),
+    generate_subscribe(FilterType::LatestGroup, 2),
+    generate_subscribe(FilterType::AbsoluteStart, 0, 0x100, 0x2),
+    generate_subscribe(FilterType::AbsoluteStart, 2, 0x100, 0x2),
+    generate_subscribe(FilterType::AbsoluteRange, 0, 0x100, 0x2, 0x500, 0x2),
+    generate_subscribe(FilterType::AbsoluteRange, 2, 0x100, 0x2, 0x500, 0x2),
+  };
+
+  for (size_t i = 0; i < subscribes.size(); i++) {
+    qtransport::StreamBuffer<uint8_t> buffer;
+    buffer << subscribes[i];
+    std::vector<uint8_t> net_data = buffer.front(buffer.size());
+    MoqSubscribe subscribe_out;
+    CHECK(verify(
+      net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+    CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
+    CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
+    CHECK_EQ(subscribes[i].subscribe_id, subscribe_out.subscribe_id);
+    CHECK_EQ(subscribes[i].track_alias, subscribe_out.track_alias);
+    CHECK_EQ(subscribes[i].filter_type, subscribe_out.filter_type);
+    CHECK_EQ(subscribes[i].track_params.size(), subscribe_out.track_params.size());
+    for(size_t j = 0; j < subscribes[i].track_params.size(); j++) {
+      CHECK_EQ(subscribes[i].track_params[j].param_type,
+               subscribe_out.track_params[j].param_type);
+      CHECK_EQ(subscribes[i].track_params[j].param_length,
+               subscribe_out.track_params[j].param_length);
+      CHECK_EQ(subscribes[i].track_params[j].param_value,
+               subscribe_out.track_params[j].param_value);
+
+    }
+  }
+}
+
+
 TEST_CASE("SubscribeOk Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;

From 4bc13c3ca47a164fe304f82e669ea22c2920d299 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 02:04:26 -0700
Subject: [PATCH 13/71] add subscribe error encode/decode/test

---
 include/quicr/moq_messages.h | 12 ++++++--
 src/moq_messages.cpp         | 54 ++++++++++++++++++++++++++++++++++++
 test/moq_messages.cpp        | 20 +++++++++++++
 3 files changed, 83 insertions(+), 3 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 6d4e0021..c547c98a 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -136,15 +136,21 @@ struct MoqSubscribeOk {
                                                        const MoqSubscribeOk& msg);
 private:
   size_t current_pos {0};
-  const size_t MAX_FIELDS = 5;
+  const size_t MAX_FIELDS {5};
 };
 
 
 struct MoqSubscribeError {
-  SubscribeId subscribe_id;
+  uint64_t subscribe_id;
   ErrorCode err_code;
   ReasonPhrase reason_phrase;
-  TrackAlias  track_alias;
+  uint64_t track_alias;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqSubscribeError& msg);
+private:
+  size_t current_pos {0};
+  const size_t MAX_FIELDS {4};
 };
 
 struct MoqUnsubscribe {
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 8226f9c2..a2ede675 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -326,6 +326,60 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg)
   return true;
 }
 
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqSubscribeError& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.err_code));
+  buffer.push_lv(msg.reason_phrase);
+  buffer.push(qtransport::to_uintV(msg.track_alias));
+  return buffer;
+}
+
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &msg) {
+
+  switch (msg.current_pos) {
+    case 0:
+    {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.err_code)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      const auto val = buffer.decode_bytes();
+      if (!val) {
+        return false;
+      }
+      msg.reason_phrase = std::move(val.value());
+      msg.current_pos += 1;
+    }
+    break;
+    case 3: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+  }
+
+  if (msg.current_pos < msg.MAX_FIELDS) {
+    return false;
+  }
+  return true;
+}
+
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg) {
   buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR);
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 994204f3..48e03a56 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -432,5 +432,25 @@ TEST_CASE("SubscribeOk (content-exists) Message encode/decode")
   CHECK_EQ(subscribe_ok.content_exists, subscribe_ok_out.content_exists);
   CHECK_EQ(subscribe_ok.largest_group, subscribe_ok_out.largest_group);
   CHECK_EQ(subscribe_ok.largest_object, subscribe_ok_out.largest_object);
+}
+
+TEST_CASE("SubscribeError  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe_err  = MoqSubscribeError {};
+  subscribe_err.subscribe_id = 0x1;
+  subscribe_err.err_code = 0;
+  subscribe_err.reason_phrase = quicr::bytes {0x0, 0x1};
+  subscribe_err.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  buffer << subscribe_err;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
+  MoqSubscribeError subscribe_err_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR), subscribe_err_out));
+  CHECK_EQ(subscribe_err.subscribe_id, subscribe_err_out.subscribe_id);
+  CHECK_EQ(subscribe_err.err_code, subscribe_err_out.err_code);
+  CHECK_EQ(subscribe_err.reason_phrase, subscribe_err_out.reason_phrase);
+  CHECK_EQ(subscribe_err.track_alias, subscribe_err_out.track_alias);
 }
\ No newline at end of file

From 42a2d419fd3817ac556abe1b0d32984709c9cf81 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 03:53:17 -0700
Subject: [PATCH 14/71] add subscribedone and unsunbscribe encode/decode/test

---
 include/quicr/moq_messages.h |  17 +++-
 src/moq_messages.cpp         | 150 +++++++++++++++++++++--------------
 test/moq_messages.cpp        |  63 +++++++++++++++
 3 files changed, 165 insertions(+), 65 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index c547c98a..ec2f950c 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -155,16 +155,25 @@ struct MoqSubscribeError {
 
 struct MoqUnsubscribe {
   SubscribeId  subscribe_id;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnsubscribe &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqUnsubscribe& msg);
 };
 
 struct MoqSubscribeDone
 {
-  SubscribeId  subscribe_id;
-  StatusCode status_code;
+  uint64_t subscribe_id;
+  uint64_t status_code;
   ReasonPhrase reason_phrase;
   bool content_exists;
-  GroupId final_group_id;
-  ObjectId final_object_id;
+  uint64_t final_group_id;
+  uint64_t final_object_id;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqSubscribeDone& msg);
+private:
+  size_t current_pos {0};
+  const size_t MAX_FIELDS = {6};
 };
 
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index a2ede675..30a523bc 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -243,19 +243,101 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
   return true;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_UNSUBSCRIBE);
-  buffer << msg.subscribe_id;
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqUnsubscribe& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_UNSUBSCRIBE)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg) {
-  buffer >> msg.subscribe_id;
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnsubscribe &msg) {
+
+  if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+    return false;
+  }
+  return true;
+}
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqSubscribeDone& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.status_code));
+  buffer.push_lv(msg.reason_phrase);
+  msg.content_exists ? buffer.push(static_cast<uint8_t>(1)) : buffer.push(static_cast<uint8_t>(0));
+  if(msg.content_exists) {
+    buffer.push(qtransport::to_uintV(msg.final_group_id));
+    buffer.push(qtransport::to_uintV(msg.final_object_id));
+  }
+
   return buffer;
 }
 
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.status_code)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      const auto val = buffer.decode_bytes();
+      if (!val) {
+        return false;
+      }
+      msg.reason_phrase = std::move(val.value());
+      msg.current_pos += 1;
+    }
+    break;
+    case 3: {
+      const auto val = buffer.front();
+      if (!val) {
+        return false;
+      }
+      buffer.pop();
+      msg.content_exists = (val.value()) == 1;
+      msg.current_pos += 1;
+      if (!msg.content_exists) {
+        // nothing more to process.
+        return true;
+      }
+    }
+    break;
+    case 4: {
+      if(!parse_uintV_field(buffer, msg.final_group_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 5: {
+      if(!parse_uintV_field(buffer, msg.final_object_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+  }
+
+  if (msg.current_pos < msg.MAX_FIELDS) {
+    return false;
+  }
+  return true;
+}
+
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribeOk& msg){
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK)));
@@ -316,8 +398,6 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg)
       msg.current_pos += 1;
     }
     break;
-    default:
-      throw std::runtime_error("Malformed Message (SubscribeOK)");
   }
 
   if (msg.current_pos < msg.MAX_FIELDS) {
@@ -380,60 +460,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &ms
   return true;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR);
-  buffer << msg.subscribe_id;
-  buffer << msg.err_code;
-  buffer << msg.reason_phrase;
-  buffer << msg.track_alias;
-  return buffer;
-}
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqSubscribeError &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.err_code;
-  buffer >> msg.reason_phrase;
-  buffer >> msg.track_alias;
-  return buffer;
-}
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqSubscribeDone &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_SUBSCRIBE_DONE);
-  buffer << msg.subscribe_id;
-  buffer << msg.status_code;
-  buffer << msg.reason_phrase;
-  buffer << uint8_t(msg.content_exists);
-  if (msg.content_exists) {
-    buffer << msg.final_group_id;
-    buffer << msg.final_object_id;
-  }
-  return buffer;
-}
-
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqSubscribeDone&msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.status_code;
-  buffer >> msg.reason_phrase;
-  uint8_t  context_exists {0};
-  buffer >> context_exists;
-  if (context_exists > 1) {
-    throw std::runtime_error("Incorrect Context Exists value");
-  }
-
-  if (context_exists == 1) {
-    msg.content_exists = true;
-    buffer >> msg.final_group_id;
-    buffer >> msg.final_object_id;
-    return buffer;
-  }
-
-  msg.content_exists = false;
-  return buffer;
-}
 
 
 //
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 48e03a56..270ca23e 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -453,4 +453,67 @@ TEST_CASE("SubscribeError  Message encode/decode")
   CHECK_EQ(subscribe_err.err_code, subscribe_err_out.err_code);
   CHECK_EQ(subscribe_err.reason_phrase, subscribe_err_out.reason_phrase);
   CHECK_EQ(subscribe_err.track_alias, subscribe_err_out.track_alias);
+}
+
+TEST_CASE("Unsubscribe  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto unsubscribe  = MoqUnsubscribe {};
+  unsubscribe.subscribe_id = 0x1;
+  buffer << unsubscribe;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqUnsubscribe unsubscribe_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_UNSUBSCRIBE), unsubscribe_out));
+  CHECK_EQ(unsubscribe.subscribe_id, unsubscribe_out.subscribe_id);
+}
+
+TEST_CASE("SubscribeDone  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe_done  = MoqSubscribeDone {};
+  subscribe_done.subscribe_id = 0x1;
+  subscribe_done.status_code = 0x0;
+  subscribe_done.reason_phrase = quicr::bytes {0x0};
+  subscribe_done.content_exists = false;
+
+  buffer << subscribe_done;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribeDone subscribe_done_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE), subscribe_done_out));
+  CHECK_EQ(subscribe_done.subscribe_id, subscribe_done_out.subscribe_id);
+  CHECK_EQ(subscribe_done.status_code, subscribe_done_out.status_code);
+  CHECK_EQ(subscribe_done.reason_phrase, subscribe_done_out.reason_phrase);
+  CHECK_EQ(subscribe_done.content_exists, subscribe_done_out.content_exists);
+}
+
+TEST_CASE("SubscribeDone (content-exists)  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto subscribe_done  = MoqSubscribeDone {};
+  subscribe_done.subscribe_id = 0x1;
+  subscribe_done.status_code = 0x0;
+  subscribe_done.reason_phrase = quicr::bytes {0x0};
+  subscribe_done.content_exists = true;
+  subscribe_done.final_group_id = 0x1111;
+  subscribe_done.final_object_id = 0xff;
+
+  buffer << subscribe_done;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqSubscribeDone subscribe_done_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE), subscribe_done_out));
+  CHECK_EQ(subscribe_done.subscribe_id, subscribe_done_out.subscribe_id);
+  CHECK_EQ(subscribe_done.status_code, subscribe_done_out.status_code);
+  CHECK_EQ(subscribe_done.reason_phrase, subscribe_done_out.reason_phrase);
+  CHECK_EQ(subscribe_done.content_exists, subscribe_done_out.content_exists);
+  CHECK_EQ(subscribe_done.final_group_id, subscribe_done_out.final_group_id);
+  CHECK_EQ(subscribe_done.final_object_id, subscribe_done_out.final_object_id);
 }
\ No newline at end of file

From 6b8baa7f1e86a445b685cadad07c25400aa25480 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 11:55:46 -0700
Subject: [PATCH 15/71] wip client setup

---
 include/quicr/moq_messages.h |  33 +++++---
 src/moq_messages.cpp         | 141 +++++++++++++++++++++++++----------
 test/moq_messages.cpp        |  49 ++++++++----
 3 files changed, 156 insertions(+), 67 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index ec2f950c..794ea72e 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -9,7 +9,7 @@
 
 namespace quicr::messages {
 
-using Version = uintVar_t;
+using Version = uint64_t;
 using TrackNamespace = quicr::bytes;
 using TrackName = quicr::bytes;
 using ErrorCode = uint64_t;
@@ -64,10 +64,15 @@ enum struct ParameterType : uint8_t {
   Invalid = 0xFF, // used internally.
 };
 
-struct MoqParameter{
-  std::optional<uint64_t> param_type;
-  uintVar_t param_length;
+struct MoqParameter {
+  uint64_t param_type {0};
+  uint64_t param_length {0};
   bytes param_value;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqParameter& msg);
+private:
+  uint64_t current_pos {0};
 };
 
 //
@@ -75,15 +80,27 @@ struct MoqParameter{
 //
 
 struct MoqClientSetup {
+  uint64_t num_versions {0};
   std::vector<Version> supported_versions;
   MoqParameter role_parameter;
   MoqParameter path_parameter;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqClientSetup& msg);
+private:
+  size_t current_pos {0};
+  uint64_t num_params {0};
+  MoqParameter current_param {};
+  bool parse_completed { false };
 };
 
 struct MoqServerSetup {
   Version supported_version;
   MoqParameter role_parameter;
   MoqParameter path_parameter;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqServerSetup& msg);
 };
 
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &msg);
@@ -176,14 +193,6 @@ struct MoqSubscribeDone
   const size_t MAX_FIELDS = {6};
 };
 
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqUnsubscribe &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqUnsubscribe &msg);
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeError &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeError &msg);
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqSubscribeDone &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqSubscribeDone &msg);
-
-
 //
 // Announce
 //
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 30a523bc..52c389e3 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -51,6 +51,40 @@ MessageBuffer& operator>>(MessageBuffer& buffer, std::optional<T>& val) {
 // MoqParameter
 //
 
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqParameter& param){
+
+  buffer.push(qtransport::to_uintV(param.param_type));
+  buffer.push(qtransport::to_uintV(param.param_length));
+  if (param.param_length) {
+    buffer.push_lv(param.param_value);
+  }
+  return buffer;
+}
+
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &param) {
+
+  if(!parse_uintV_field(buffer, param.param_type)) {
+    return false;
+  }
+
+  if(!parse_uintV_field(buffer, param.param_length)) {
+    return false;
+  }
+
+  if(param.param_length) {
+    const auto val = buffer.decode_bytes();
+    if (!val) {
+      return false;
+    }
+    param.param_value = std::move(val.value());
+  }
+
+  return true;
+}
+
+
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &param) {
   buffer << param.param_type;
   buffer << param.param_length;
@@ -104,7 +138,7 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
 
   buffer.push(qtransport::to_uintV(msg.num_params));
   for (const auto& param: msg.track_params) {
-    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.param_type.value())));
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.param_type)));
     buffer.push(qtransport::to_uintV(param.param_length));
     buffer.push(param.param_value);
   }
@@ -763,59 +797,86 @@ operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg) {
 }
 
 
-// Setup
+// Client Setup message
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqClientSetup& msg){
 
-// vector<varint> encode/decode
-MessageBuffer&
-operator<<(MessageBuffer& buffer, const std::vector<uintVar_t>& val)
-{
-  buffer << static_cast<uintVar_t>(val.size());
-  for(uint64_t i = 0; i < val.size(); i++) {
-    buffer << val[i];
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_CLIENT_SETUP)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.supported_versions.size())));
+  // versions
+  for (const auto& ver: msg.supported_versions) {
+    buffer.push(qtransport::to_uintV(ver));
   }
 
+  /// num params
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
+  // role param
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
+  buffer.push_lv(msg.role_parameter.param_value);
   return buffer;
 }
 
-MessageBuffer&
-operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val)
-{
-  auto vec_size = uintVar_t(0);
-  msg >> vec_size;
-  auto version = std::vector<uintVar_t>();
-  version.resize((uint64_t) vec_size);
-  val.resize((uint64_t) vec_size);
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg) {
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.num_versions)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    case 1: {
+      while (msg.num_versions > 0) {
+        uint64_t version{ 0 };
+        if (!parse_uintV_field(buffer, version)) {
+          return false;
+        }
+        msg.supported_versions.push_back(version);
+        msg.num_versions -= 1;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      if(!parse_uintV_field(buffer, msg.num_params)) {
+        return false;
+      }
 
-  // TODO (Suhas): This needs revisiting
-  for(uint64_t i = 0; i < version.size(); i++) {
-    msg >> version[i];
-  }
-  val = std::move(version);
-  return msg;
-}
+      while (msg.num_params > 0) {
+        if (!msg.current_param.param_type) {
+          auto val = buffer.front();
+          if (!val) {
+            return false;
+          }
+          msg.current_param.param_type = *val;
+          buffer.pop();
+        }
 
+        auto param = buffer.decode_bytes();
+        if (!param) {
+          return false;
+        }
+        msg.current_param.param_length = param->size();
+        msg.current_param.param_value = param.value();
+        static_cast<ParameterType>(msg.current_param.param_type) == ParameterType::Role  ?
+          msg.role_parameter = std::move(msg.current_param) : msg.path_parameter = std::move(msg.current_param);
+        msg.current_param = MoqParameter{};
+        msg.num_params -= 1;
+      }
 
-// Client Setup message
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqClientSetup &msg) {
-  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_CLIENT_SETUP);
-  // versions
-  buffer << static_cast<uintVar_t>(msg.supported_versions.size());
-  for (const auto& ver: msg.supported_versions) {
-    buffer << static_cast<uintVar_t>(ver);
+      msg.parse_completed = true;
+    }
+    break;
   }
 
-  // TODO (Suhas): Add support for PATH Param
-  // num params
-  buffer << uintVar_t{1};
-  // role param
-  buffer << static_cast<uint8_t>(msg.role_parameter.param_type.value());
-  buffer << uintVar_t(1);
-  buffer << msg.role_parameter.param_value;
+  if (!msg.parse_completed) {
+    return false;
+  }
 
-  return buffer;
+  return true;
 }
 
+
 MessageBuffer &
 operator>>(MessageBuffer &buffer, MoqClientSetup &msg) {
   uintVar_t num_versions {0};
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 270ca23e..3ceb957e 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -272,17 +272,16 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
 TEST_CASE("Subscribe (Params - 2) Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
-  MoqParameter param1 {
-    .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
-    .param_length = 0x2,
-    .param_value = {0x1, 0x2}
-  };
+  MoqParameter param1;
+  param1.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+  param1.param_length = 0x2;
+  param1.param_value = {0x1, 0x2};
+
+  MoqParameter param2;
+  param2.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+  param2.param_length = 0x3;
+  param2.param_value = {0x1, 0x2, 0x3};
 
-  MoqParameter param2  {
-    .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
-    .param_length = 0x4,
-    .param_value = {0x1, 0x2, 0x3, 0x4}
-  };
 
   auto subscribe  = MoqSubscribe {};
   subscribe.subscribe_id = 0x1;
@@ -341,11 +340,10 @@ MoqSubscribe generate_subscribe(FilterType filter, size_t  num_params = 0, uint6
   }
 
   while(num_params > 0) {
-    MoqParameter param1 {
-      .param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
-      .param_length = 0x2,
-      .param_value = {0x1, 0x2}
-    };
+    MoqParameter param1;
+    param1.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+    param1.param_length = 0x2;
+    param1.param_value = {0x1, 0x2};
     out.track_params.push_back(param1);
     num_params--;
   }
@@ -516,4 +514,25 @@ TEST_CASE("SubscribeDone (content-exists)  Message encode/decode")
   CHECK_EQ(subscribe_done.content_exists, subscribe_done_out.content_exists);
   CHECK_EQ(subscribe_done.final_group_id, subscribe_done_out.final_group_id);
   CHECK_EQ(subscribe_done.final_object_id, subscribe_done_out.final_object_id);
+}
+
+
+TEST_CASE("ClientSetup  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto client_setup = MoqClientSetup {};
+  client_setup.num_versions = 2;
+  client_setup.supported_versions = {0x1000, 0x2000};
+  client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
+  client_setup.role_parameter.param_length = 0x1;
+  client_setup.role_parameter.param_value = {0xFF};
+
+  buffer << client_setup;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqClientSetup client_setup_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_CLIENT_SETUP), client_setup_out));
+  CHECK_EQ(client_setup.supported_versions, client_setup_out.supported_versions);
+  CHECK_EQ(client_setup.role_parameter.param_value, client_setup_out.role_parameter.param_value);
 }
\ No newline at end of file

From 2b58363b99ae009d6f9b6a9e7cded5d9f6ac326c Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 23:17:31 -0700
Subject: [PATCH 16/71] fix up client setup, hardcoded role

---
 include/quicr/moq_messages.h |  4 ++--
 src/moq_messages.cpp         | 25 ++++++++++++++-----------
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 794ea72e..1bb3a1d0 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -89,8 +89,8 @@ struct MoqClientSetup {
                                                        const MoqClientSetup& msg);
 private:
   size_t current_pos {0};
-  uint64_t num_params {0};
-  MoqParameter current_param {};
+  std::optional<uint64_t> num_params;
+  std::optional<MoqParameter> current_param {};
   bool parse_completed { false };
 };
 
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 52c389e3..f69dc9a5 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -812,7 +812,6 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
   // role param
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
   buffer.push_lv(msg.role_parameter.param_value);
   return buffer;
 }
@@ -838,17 +837,21 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
     }
     break;
     case 2: {
-      if(!parse_uintV_field(buffer, msg.num_params)) {
-        return false;
+      if(!msg.num_params.has_value()) {
+        auto params = uint64_t {0};
+        if (!parse_uintV_field(buffer, params)) {
+          return false;
+        }
+        msg.num_params = params;
       }
-
       while (msg.num_params > 0) {
-        if (!msg.current_param.param_type) {
+        if (!msg.current_param.has_value()) {
           auto val = buffer.front();
           if (!val) {
             return false;
           }
-          msg.current_param.param_type = *val;
+          msg.current_param = MoqParameter{};
+          msg.current_param->param_type = *val;
           buffer.pop();
         }
 
@@ -856,12 +859,12 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
         if (!param) {
           return false;
         }
-        msg.current_param.param_length = param->size();
-        msg.current_param.param_value = param.value();
-        static_cast<ParameterType>(msg.current_param.param_type) == ParameterType::Role  ?
-          msg.role_parameter = std::move(msg.current_param) : msg.path_parameter = std::move(msg.current_param);
+        msg.current_param->param_length = param->size();
+        msg.current_param->param_value = param.value();
+        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role  ?
+          msg.role_parameter = std::move(msg.current_param.value()) : msg.path_parameter = std::move(msg.current_param.value());
         msg.current_param = MoqParameter{};
-        msg.num_params -= 1;
+        msg.num_params.value() -= 1;
       }
 
       msg.parse_completed = true;

From 18f63b8314233e7df7808840b3d746d1ddfa5b6e Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 3 Jun 2024 23:52:36 -0700
Subject: [PATCH 17/71] add server setup

---
 include/quicr/moq_messages.h |  12 ++--
 src/moq_messages.cpp         | 108 +++++++++++++++++++----------------
 test/moq_messages.cpp        |  20 +++++++
 3 files changed, 86 insertions(+), 54 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 1bb3a1d0..6f5e8f94 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -95,20 +95,22 @@ struct MoqClientSetup {
 };
 
 struct MoqServerSetup {
-  Version supported_version;
+  Version selection_version;
   MoqParameter role_parameter;
   MoqParameter path_parameter;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
                                                        const MoqServerSetup& msg);
+private:
+  size_t current_pos {0};
+  std::optional<uint64_t> num_params;
+  bool parse_completed { false };
+  std::optional<MoqParameter> current_param {};
+
 };
 
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &msg);
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &msg);
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqClientSetup &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqClientSetup &msg);
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqServerSetup &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqServerSetup &msg);
 
 //
 // Subscribe
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index f69dc9a5..ac0163bf 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -880,61 +880,71 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
 }
 
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqClientSetup &msg) {
-  uintVar_t num_versions {0};
-  buffer >> num_versions;
-  msg.supported_versions.resize(num_versions);
-  for(size_t i = 0; i < num_versions; i++) {
-    uintVar_t version{0};
-    buffer >> version;
-    msg.supported_versions.push_back(version);
-  }
-
-  uintVar_t num_params {0};
-  buffer >> num_params;
-  if (static_cast<uint64_t> (num_params) == 0) {
-    return buffer;
-  }
-
-  while (static_cast<uint64_t>(num_params) > 0) {
-    uint8_t param_type {0};
-    buffer >> param_type;
-    auto param_type_enum = static_cast<ParameterType> (param_type);
-    switch(param_type_enum) {
-      case ParameterType::Role: {
-        msg.role_parameter.param_type = param_type;
-        buffer >> msg.role_parameter.param_length;
-        buffer >> msg.role_parameter.param_value;
+
+// Server Setup message
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqServerSetup& msg){
+
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SERVER_SETUP)));
+  buffer.push(qtransport::to_uintV(msg.selection_version));
+
+  /// num params
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
+  // role param
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
+  buffer.push_lv(msg.role_parameter.param_value);
+  return buffer;
+}
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg) {
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.selection_version)) {
+        return false;
       }
-      break;
-      case ParameterType::Path: {
-        msg.path_parameter.param_type = param_type;
-        buffer >> msg.path_parameter.param_length;
-        buffer >> msg.path_parameter.param_value;
+      msg.current_pos += 1;
+    }
+    case 1: {
+      if(!msg.num_params.has_value()) {
+        auto params = uint64_t {0};
+        if (!parse_uintV_field(buffer, params)) {
+          return false;
+        }
+        msg.num_params = params;
       }
-      break;
-      default:
-        throw std::runtime_error("Unsupported Parameter Type for ClientSetup");
+      while (msg.num_params > 0) {
+        if (!msg.current_param.has_value()) {
+          auto val = buffer.front();
+          if (!val) {
+            return false;
+          }
+          msg.current_param = MoqParameter{};
+          msg.current_param->param_type = *val;
+          buffer.pop();
+        }
+
+        auto param = buffer.decode_bytes();
+        if (!param) {
+          return false;
+        }
+        msg.current_param->param_length = param->size();
+        msg.current_param->param_value = param.value();
+        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role  ?
+                                                                                         msg.role_parameter = std::move(msg.current_param.value()) : msg.path_parameter = std::move(msg.current_param.value());
+        msg.current_param = MoqParameter{};
+        msg.num_params.value() -= 1;
+      }
+      msg.parse_completed = true;
     }
-    num_params = num_params - 1;
+    break;
   }
 
+  if (!msg.parse_completed) {
+    return false;
+  }
 
-  return buffer;
-}
-
-// Server Setup message
-MessageBuffer&
-operator<<(MessageBuffer &buffer, const MoqServerSetup &msg) {
-  buffer << static_cast<uintVar_t>(MESSAGE_TYPE_SERVER_SETUP);
-  buffer << msg.supported_version;
-  return buffer;
+  return true;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqServerSetup &msg) {
-  buffer >> msg.supported_version;
-  return buffer;
-}
 }
\ No newline at end of file
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 3ceb957e..49502e8e 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -535,4 +535,24 @@ TEST_CASE("ClientSetup  Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_CLIENT_SETUP), client_setup_out));
   CHECK_EQ(client_setup.supported_versions, client_setup_out.supported_versions);
   CHECK_EQ(client_setup.role_parameter.param_value, client_setup_out.role_parameter.param_value);
+}
+
+
+TEST_CASE("ServertSetup  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto server_setup = MoqServerSetup {};
+  server_setup.selection_version = {0x1000};
+  server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
+  server_setup.role_parameter.param_length = 0x1;
+  server_setup.role_parameter.param_value = {0xFF};
+
+  buffer << server_setup;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqServerSetup server_setup_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SERVER_SETUP), server_setup_out));
+  CHECK_EQ(server_setup.selection_version, server_setup_out.selection_version);
+  CHECK_EQ(server_setup.role_parameter.param_value, server_setup.role_parameter.param_value);
 }
\ No newline at end of file

From c7e0aea4b870d7112ead1f92745b70041b4177c9 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 09:48:13 -0700
Subject: [PATCH 18/71] add object stream encode/decode

---
 include/quicr/moq_messages.h | 18 ++++++----
 src/moq_messages.cpp         | 69 ++++++++++++++++++++++++++++++++++++
 test/moq_messages.cpp        | 27 +++++++++++++-
 3 files changed, 107 insertions(+), 7 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 6f5e8f94..d30a80f5 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -13,14 +13,14 @@ using Version = uint64_t;
 using TrackNamespace = quicr::bytes;
 using TrackName = quicr::bytes;
 using ErrorCode = uint64_t;
-using StatusCode = uintVar_t;
+using StatusCode = uint64_t;
 using ReasonPhrase = quicr::bytes;
-using GroupId = uintVar_t;
-using ObjectId = uintVar_t;
-using ObjectPriority = uintVar_t;
+using GroupId = uint64_t;
+using ObjectId = uint64_t;
+using ObjectPriority = uint64_t;
 using SubscribeId = uint64_t;
-using TrackAlias = uintVar_t;
-using ParamType = uintVar_t;
+using TrackAlias = uint64_t;
+using ParamType = uint64_t;
 
 // Ref: https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#name-messages
 constexpr uint8_t MESSAGE_TYPE_OBJECT_STREAM            = 0x0;
@@ -263,6 +263,12 @@ struct MoqObjectStream {
   ObjectId object_id;
   ObjectPriority priority;
   quicr::bytes payload;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqObjectStream& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 struct MoqObjectDatagram {
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index ac0163bf..df083dde 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -684,6 +684,75 @@ operator>>(MessageBuffer &buffer, MoqGoaway &msg) {
 // Object
 //
 
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqObjectStream& msg){
+
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_STREAM)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.track_alias));
+  buffer.push(qtransport::to_uintV(msg.group_id));
+  buffer.push(qtransport::to_uintV(msg.object_id));
+  buffer.push(qtransport::to_uintV(msg.priority));
+  buffer.push_lv(msg.payload);
+  return buffer;
+}
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      if(!parse_uintV_field(buffer, msg.group_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 3: {
+      if(!parse_uintV_field(buffer, msg.object_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 4: {
+      if(!parse_uintV_field(buffer, msg.priority)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 5: {
+      const auto val = buffer.decode_bytes();
+      if (!val) {
+        return false;
+      }
+      msg.payload = std::move(val.value());
+      msg.parse_completed = true;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+
+  return true;
+}
+
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqObjectStream &msg) {
   buffer << static_cast<uint8_t>(MESSAGE_TYPE_OBJECT_STREAM);
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 49502e8e..ec116dfd 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -538,7 +538,7 @@ TEST_CASE("ClientSetup  Message encode/decode")
 }
 
 
-TEST_CASE("ServertSetup  Message encode/decode")
+TEST_CASE("ServerSetup  Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
   auto server_setup = MoqServerSetup {};
@@ -555,4 +555,29 @@ TEST_CASE("ServertSetup  Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SERVER_SETUP), server_setup_out));
   CHECK_EQ(server_setup.selection_version, server_setup_out.selection_version);
   CHECK_EQ(server_setup.role_parameter.param_value, server_setup.role_parameter.param_value);
+}
+
+TEST_CASE("ObjectStream  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto object_stream = MoqObjectStream {};
+  object_stream.subscribe_id = 0x100;
+  object_stream.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  object_stream.group_id = 0x1000;
+  object_stream.object_id = 0xFF;
+  object_stream.priority =0xA;
+  object_stream.payload = {0x1, 0x2, 0x3, 0x5, 0x6};
+
+  buffer << object_stream;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqObjectStream object_stream_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_STREAM), object_stream_out));
+  CHECK_EQ(object_stream.subscribe_id, object_stream_out.subscribe_id);
+  CHECK_EQ(object_stream.track_alias, object_stream_out.track_alias);
+  CHECK_EQ(object_stream.group_id, object_stream_out.group_id);
+  CHECK_EQ(object_stream.object_id, object_stream_out.object_id);
+  CHECK_EQ(object_stream.priority, object_stream_out.priority);
+  CHECK_EQ(object_stream.payload, object_stream_out.payload);
 }
\ No newline at end of file

From d6905de5dad386779e0e5982a1272c3b789716c0 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 10:10:29 -0700
Subject: [PATCH 19/71] add encode/decode to object and friends

---
 include/quicr/moq_messages.h |  30 ++++
 src/moq_messages.cpp         | 305 +++++++++++++++++++++++++----------
 2 files changed, 249 insertions(+), 86 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index d30a80f5..7337b056 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -278,6 +278,12 @@ struct MoqObjectDatagram {
   ObjectId object_id;
   ObjectPriority priority;
   quicr::bytes payload;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqObjectDatagram& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 
@@ -285,12 +291,24 @@ struct MoqStreamHeaderTrack {
   SubscribeId subscribe_id;
   TrackAlias track_alias;
   ObjectPriority priority;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderTrack &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqStreamHeaderTrack& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 struct MoqStreamTrackObject {
   GroupId  group_id;
   ObjectId object_id;
   quicr::bytes payload;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqStreamTrackObject& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 
@@ -299,11 +317,23 @@ struct MoqStreamHeaderGroup {
   TrackAlias track_alias;
   GroupId group_id;
   ObjectPriority priority;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderGroup &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqStreamHeaderGroup& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 struct MoqStreamGroupObject {
   ObjectId object_id;
   quicr::bytes payload;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamGroupObject &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqStreamGroupObject& msg);
+private:
+  uint64_t current_pos {0};
+  bool parse_completed { false };
 };
 
 MessageBuffer& operator<<(MessageBuffer& buffer, const MoqObjectStream& msg);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index df083dde..9315a4c5 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -753,118 +753,251 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg)
   return true;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqObjectStream &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_OBJECT_STREAM);
-  buffer << msg.subscribe_id;
-  buffer << msg.track_alias;
-  buffer << msg.group_id;
-  buffer << msg.object_id;
-  buffer << msg.priority;
-  buffer << msg.payload;
-  return buffer;
-}
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqObjectStream &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.track_alias;
-  buffer >> msg.group_id;
-  buffer >> msg.object_id;
-  buffer >> msg.priority;
-  buffer >> msg.payload;
-  return buffer;
-}
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqObjectDatagram& msg){
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqObjectDatagram &msg) {
-  buffer << MESSAGE_TYPE_OBJECT_DATAGRAM;
-  buffer << msg.subscribe_id;
-  buffer << msg.track_alias;
-  buffer << msg.group_id;
-  buffer << msg.object_id;
-  buffer << msg.priority;
-  buffer << msg.payload;
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_DATAGRAM)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.track_alias));
+  buffer.push(qtransport::to_uintV(msg.group_id));
+  buffer.push(qtransport::to_uintV(msg.object_id));
+  buffer.push(qtransport::to_uintV(msg.priority));
+  buffer.push_lv(msg.payload);
   return buffer;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqObjectDatagram &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.track_alias;
-  buffer >> msg.group_id;
-  buffer >> msg.object_id;
-  buffer >> msg.priority;
-  buffer >> msg.payload;
-  return buffer;
-}
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &msg) {
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqStreamTrackObject &msg) {
-  buffer << msg.group_id;
-  buffer << msg.object_id;
-  buffer << msg.payload;
-  return buffer;
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      if(!parse_uintV_field(buffer, msg.group_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 3: {
+      if(!parse_uintV_field(buffer, msg.object_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 4: {
+      if(!parse_uintV_field(buffer, msg.priority)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 5: {
+      const auto val = buffer.decode_bytes();
+      if (!val) {
+        return false;
+      }
+      msg.payload = std::move(val.value());
+      msg.parse_completed = true;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+
+  return true;
 }
 
-MessageBuffer&
-operator>>(MessageBuffer &buffer, MoqStreamTrackObject &msg) {
-  buffer >> msg.group_id;
-  buffer >> msg.object_id;
-  buffer >> msg.payload;
+
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqStreamHeaderTrack& msg){
+
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_TRACK)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.track_alias));
+  buffer.push(qtransport::to_uintV(msg.priority));
   return buffer;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqStreamHeaderTrack &msg) {
-  buffer << MESSAGE_TYPE_STREAM_HEADER_TRACK;
-  buffer << msg.subscribe_id;
-  buffer << msg.track_alias;
-  buffer << msg.priority;
-  return buffer;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderTrack &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      if(!parse_uintV_field(buffer, msg.priority)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+  return true;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqStreamHeaderTrack &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.track_alias;
-  buffer >> msg.priority;
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqStreamTrackObject& msg){
+
+  buffer.push(qtransport::to_uintV(msg.group_id));
+  buffer.push(qtransport::to_uintV(msg.object_id));
+  buffer.push_lv(msg.payload);
   return buffer;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqStreamHeaderGroup &msg) {
-  buffer << MESSAGE_TYPE_STREAM_HEADER_GROUP;
-  buffer << msg.subscribe_id;
-  buffer << msg.track_alias;
-  buffer << msg.group_id;
-  buffer << msg.priority;
-  return buffer;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.group_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.object_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      const auto val = buffer.decode_bytes();
+      if(!val) {
+        return false;
+      }
+      msg.parse_completed = true;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+  return true;
 }
 
-MessageBuffer &
-operator>>(MessageBuffer &buffer, MoqStreamHeaderGroup &msg) {
-  buffer >> msg.subscribe_id;
-  buffer >> msg.track_alias;
-  buffer >> msg.group_id;
-  buffer >> msg.priority;
+
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqStreamHeaderGroup& msg){
+
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_GROUP)));
+  buffer.push(qtransport::to_uintV(msg.subscribe_id));
+  buffer.push(qtransport::to_uintV(msg.track_alias));
+  buffer.push(qtransport::to_uintV(msg.group_id));
+  buffer.push(qtransport::to_uintV(msg.priority));
   return buffer;
 }
 
-MessageBuffer &
-operator<<(MessageBuffer &buffer, const MoqStreamGroupObject &msg) {
-  buffer << msg.object_id;
-  buffer << msg.payload;
-  return buffer;
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderGroup &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.subscribe_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      if(!parse_uintV_field(buffer, msg.track_alias)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 2: {
+      if(!parse_uintV_field(buffer, msg.group_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 4: {
+      if(!parse_uintV_field(buffer, msg.priority)) {
+        return false;
+      }
+      msg.current_pos += 1;
+      msg.parse_completed = true;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+
+  return true;
 }
 
-MessageBuffer&
-operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg) {
-  buffer >> msg.object_id;
-  buffer >> msg.payload;
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqStreamGroupObject& msg){
+
+  buffer.push(qtransport::to_uintV(msg.object_id));
+  buffer.push_lv(msg.payload);
   return buffer;
 }
 
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamGroupObject &msg) {
+
+  switch (msg.current_pos) {
+    case 0: {
+      if(!parse_uintV_field(buffer, msg.object_id)) {
+        return false;
+      }
+      msg.current_pos += 1;
+    }
+    break;
+    case 1: {
+      const auto val = buffer.decode_bytes();
+      if (!val) {
+        return false;
+      }
+      msg.payload = std::move(val.value());
+      msg.parse_completed = true;
+    }
+    break;
+  }
+
+  if(!msg.parse_completed) {
+    return false;
+  }
+
+  return true;
+}
 
 // Client Setup message
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,

From 5d9129526156540f5dc7d3d003295d20dc431c09 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 11:40:11 -0700
Subject: [PATCH 20/71] object tests work in progress

---
 src/moq_messages.cpp  |  3 +-
 test/moq_messages.cpp | 73 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 2 deletions(-)

diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 9315a4c5..91149aec 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -923,7 +923,6 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
 }
 
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderGroup &msg) {
-
   switch (msg.current_pos) {
     case 0: {
       if(!parse_uintV_field(buffer, msg.subscribe_id)) {
@@ -946,7 +945,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderGroup
       msg.current_pos += 1;
     }
     break;
-    case 4: {
+    case 3: {
       if(!parse_uintV_field(buffer, msg.priority)) {
         return false;
       }
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index ec116dfd..917cca61 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -580,4 +580,77 @@ TEST_CASE("ObjectStream  Message encode/decode")
   CHECK_EQ(object_stream.object_id, object_stream_out.object_id);
   CHECK_EQ(object_stream.priority, object_stream_out.priority);
   CHECK_EQ(object_stream.payload, object_stream_out.payload);
+}
+
+TEST_CASE("ObjectDatagram  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto object_datagram = MoqObjectDatagram {};
+  object_datagram.subscribe_id = 0x100;
+  object_datagram.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  object_datagram.group_id = 0x1000;
+  object_datagram.object_id = 0xFF;
+  object_datagram.priority =0xA;
+  object_datagram.payload = {0x1, 0x2, 0x3, 0x5, 0x6};
+
+  buffer << object_datagram;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+  MoqObjectStream object_datagram_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_DATAGRAM), object_datagram_out));
+  CHECK_EQ(object_datagram.subscribe_id, object_datagram_out.subscribe_id);
+  CHECK_EQ(object_datagram.track_alias, object_datagram_out.track_alias);
+  CHECK_EQ(object_datagram.group_id, object_datagram_out.group_id);
+  CHECK_EQ(object_datagram.object_id, object_datagram_out.object_id);
+  CHECK_EQ(object_datagram.priority, object_datagram_out.priority);
+  CHECK_EQ(object_datagram.payload, object_datagram_out.payload);
+}
+
+TEST_CASE("StreamPerGroup Object  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto hdr_grp = MoqStreamHeaderGroup {};
+  hdr_grp.subscribe_id = 0x100;
+  hdr_grp.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  hdr_grp.group_id = 0x1000;
+  hdr_grp.priority = 0xA;
+
+  buffer << hdr_grp;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqStreamHeaderGroup hdr_group_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_GROUP), hdr_group_out));
+  CHECK_EQ(hdr_grp.subscribe_id, hdr_group_out.subscribe_id);
+  CHECK_EQ(hdr_grp.track_alias, hdr_group_out.track_alias);
+  CHECK_EQ(hdr_grp.group_id, hdr_group_out.group_id);
+
+  buffer.pop(buffer.size());
+  auto objects = std::vector<MoqStreamGroupObject>{};
+  // send 10 objects
+  for(size_t i = 0; i < 10; i++) {
+    auto obj = MoqStreamGroupObject{};
+    obj.object_id = i;
+    obj.payload = {0x1, 0x2, 0x3, 0x4, 0x5};
+    objects.push_back(obj);
+    buffer << obj;
+  }
+
+  net_data.clear();
+  net_data = buffer.front(buffer.size());
+  size_t object_count = 0;
+  for(const auto v: net_data) {
+    buffer.push(v);
+    bool done = false;
+    auto obj_out = MoqStreamGroupObject{};
+    done = buffer >> obj_out;
+    if (done) {
+      CHECK_EQ(obj_out.object_id, objects[object_count].object_id);
+      CHECK_EQ(obj_out.payload, objects[object_count].payload);
+      // got one object
+      object_count++;
+    }
+  }
+
+  CHECK_EQ(object_count, 10);
 }
\ No newline at end of file

From 7db2053745c9f86354912953fc73f2daeb2f633f Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 4 Jun 2024 16:26:01 -0700
Subject: [PATCH 21/71] instance and delegate updates

---
 include/quicr/moq_delegate_track_publish.h    |  16 --
 include/quicr/moq_delegate_track_subscribe.h  |  18 --
 include/quicr/moq_instance.h                  | 219 +++++++++++++++++-
 ...ate_instance.h => moq_instance_delegate.h} |   2 +-
 include/quicr/moq_track_delegate.h            | 189 +++++++++++++++
 5 files changed, 405 insertions(+), 39 deletions(-)
 delete mode 100644 include/quicr/moq_delegate_track_publish.h
 delete mode 100644 include/quicr/moq_delegate_track_subscribe.h
 rename include/quicr/{moq_delegate_instance.h => moq_instance_delegate.h} (94%)
 create mode 100644 include/quicr/moq_track_delegate.h

diff --git a/include/quicr/moq_delegate_track_publish.h b/include/quicr/moq_delegate_track_publish.h
deleted file mode 100644
index b9e0759d..00000000
--- a/include/quicr/moq_delegate_track_publish.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- *  Copyright (C) 2024
- *  Cisco Systems, Inc.
- *  All Rights Reserved
- */
-
-#pragma once
-
-namespace quicr {
-
-class MOQTrackPublishDelegate
-{
-
-};
-
-} // namespace quicr
diff --git a/include/quicr/moq_delegate_track_subscribe.h b/include/quicr/moq_delegate_track_subscribe.h
deleted file mode 100644
index 945df79c..00000000
--- a/include/quicr/moq_delegate_track_subscribe.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- *  Copyright (C) 2024
- *  Cisco Systems, Inc.
- *  All Rights Reserved
- */
-
-#pragma once
-
-
-namespace quicr {
-
-class MOQTrackSubscribeDelegate
-{
-
-};
-
-
-} // namespace quicr
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 94f281fb..b2174512 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -6,13 +6,224 @@
 
 #pragma once
 
-#include <quicr/moq_delegate_instance.h>
-#include <quicr/moq_delegate_track_publish.h>
-#include <quicr/moq_delegate_track_subscribe.h>
+#include <quicr/metrics_exporter.h>
+#include <quicr/quicr_common.h>
+#include <transport/transport.h>
+
+#include <quicr/moq_instance_delegate.h>
+#include <quicr/moq_track_delegate.h>
 
 namespace quicr {
+using namespace qtransport;
+
+class MoQInstanceConfig
+{
+  RelayInfo relay_info;
+
+  // TODO(tievens): Convert to use URL instead of Relay Info
+
+  std::string instance_id;                    /// Instance ID for the client or server, should be unique
+  TransportConfig transport_config;
+};
+
+class MoQInstance : public ITransport::TransportDelegate
+{
+
+public:
+  /**
+   *
+   * @param cfg     MoQ Instance Configuration
+   * @param logger  MoQ Log pointer to parent logger
+   */
+  MoQInstance(const MoQInstanceConfig& cfg,
+              const cantina::LoggerPointer& logger);
+
+  ~MoQInstance();
+
+  // -------------------------------------------------------------------------------------------------
+  // Public API MoQ Intance API methods
+  // -------------------------------------------------------------------------------------------------
+  /**
+   * @brief Subscribe to a track
+   *
+   * @param track_delegate    Track delegate to use for track related functions and callbacks
+   *
+   * @returns `track_alias` if no error and nullopt on error
+   */
+  std::optional<uint64_t> subscribeTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
+
+
+  /**
+   * @brief Publish to a track
+   *
+   * @param track_delegate    Track delegate to use for track related functions
+   *                          and callbacks
+   *
+   * @returns `track_alias` if no error and nullopt on error
+   */
+  std::optional<uint64_t> publishTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
+
+
+  // -------------------------------------------------------------------------------------------------
+
+  /*
+   * Transport Delegete/callback functions
+   */
+  void on_new_data_context(const TransportConnId& conn_id,
+                           const DataContextId& data_ctx_id) override
+  {
+  }
+  void on_connection_status(const TransportConnId& conn_id,
+                            const TransportStatus status) override;
+  void on_new_connection(const TransportConnId& conn_id,
+                         const TransportRemote& remote) override;
+  void on_recv_stream(const TransportConnId& conn_id,
+                      uint64_t stream_id,
+                      std::optional<DataContextId> data_ctx_id,
+                      const bool is_bidir = false) override;
+  void on_recv_dgram(const TransportConnId& conn_id,
+                     std::optional<DataContextId> data_ctx_id) override;
+
+private:
+  /**
+   * @brief Client thread to monitor client published messages
+   */
+  void PeerQueueThread();
+
+  /**
+   * @brief Watch Thread to perform reconnects and cleanup
+   * @details Thread will perform various tasks each interval
+   *
+   * @param interval_ms       Interval in milliseconds to sleep before running
+   * check
+   */
+  void watchThread(int interval_ms);
+
+  /**
+   * @brief Create a peering session/connection
+   *
+   * @param peer_config           Peer/relay configuration parameters
+   *
+   */
+  void createPeerSession(const TransportRemote& peer_config);
+
+  /**
+   * @brief Send subscribe to first/best publish intent peers
+   *
+   * @details There is a single best (first in list) publish intent peer to send
+   * matching subscribes to for a given origin. This method will iterate over
+   * each matching publish intent best origin peer and send a subscribe.
+   *
+   * @param ns                    Namespace to subscribe
+   * @param source_peer_id        Source peer that sent (or client manager) the
+   * intent
+   */
+  void subscribePeers(const Namespace& ns, const peer_id_t& source_peer_id);
+
+  /**
+   * @brief Send subscribe to specific peer
+   *
+   * @param ns                    Namespace to subscribe peers to
+   * @param peer_id               Peer ID to send to
+   */
+  void subscribePeer(const Namespace& ns, const peer_id_t& peer_id);
+
+  /**
+   * @brief Send unsubscribe to peers that had previous subscribes for given
+   * namespace
+   *
+   * @param ns                    Namespace to unsubscribe peers to
+   * @param source_peer_id        Source peer that sent (or client manager) the
+   * intent
+   */
+  void unSubscribePeers(const Namespace& ns, const peer_id_t& source_peer_id);
+
+  /**
+   * @brief Send unsubscribe to specific peer
+   *
+   * @param ns                    Namespace to unsubscribe peers to
+   * @param peer_id               Peer ID to send to
+   */
+  void unSubscribePeer(const Namespace& ns, const peer_id_t& peer_id);
+
+  /**
+   * @brief Send publish intent to all peers
+   *
+   * @details Currently publish intents are flooded to all peers
+   *
+   * @param ns                   Namespace for publish intent
+   * @param source_peer_id       Source peer that sent (or client manager) the
+   * intent
+   * @param origin_peer_id       Origin peer/relay that has the publisher
+   * directly connected
+   */
+  void publishIntentPeers(const Namespace& ns,
+                          const peer_id_t& source_peer_id,
+                          const peer_id_t& origin_peer_id);
+
+  /**
+   * @brief Send publish intent done
+   *
+   * @brief Currently publish intents are flooded to all peers, so the done
+   * needs to be flooded as well
+   *
+   * @param ns                    Namespace for publish intent done
+   * @param source_peer_id        Source peer that sent (or client manager) the
+   * intent
+   * @param origin_peer_id        Origin peer/relay that has the publisher
+   * directly connected
+   */
+  void publishIntentDonePeers(const Namespace& ns,
+                              const peer_id_t& source_peer_id,
+                              const peer_id_t& origin_peer_id);
+
+  /**
+   * @brief Get the pointer to the session by peer_id
+   *
+   * @param peer_id               Peer ID to get session
+   *
+   * @return Returns nullptr or peer session if found
+   */
+  PeerSession* getPeerSession(const peer_id_t& peer_id);
+
+  void addSubscribedPeer(const Namespace& ns, const peer_id_t& peer_id);
+
+private:
+  std::mutex _mutex;
+  std::atomic<bool> _stop{ false };
+  const Config& _config;
+
+  peerQueue& _peer_queue;
+  Cache& _cache;
+  ClientSubscriptions& _subscriptions;
+
+  std::shared_ptr<ITransport>
+    _server_transport; /// Server Transport for inbound connections
+
+  std::thread _client_rx_msg_thr; /// Client receive message thread
+  std::thread _watch_thr;         /// Watch/task thread, handles reconnects
+
+  /// Peer sessions that are accepted by the server
+  std::map<TransportConnId, PeerSession> _server_peer_sessions;
+
+  std::vector<PeerSession>
+    _client_peer_sessions; /// Peer sessions that are initiated by the peer
+                           /// manager
+
+  // TODO: Fix to use list for peer sessions subscribed
+  namespace_map<std::set<peer_id_t>>
+    _peer_sess_subscribe_sent; /// Peers that subscribes have been sent
+  namespace_map<std::set<peer_id_t>>
+    _peer_sess_subscribe_recv; /// Peers that subscribes have been received
+  namespace_map<std::map<peer_id_t, std::list<peer_id_t>>>
+    _pub_intent_namespaces; /// Publish intents received from peers
+
+  // Log handler to use
+  cantina::LoggerPointer logger;
 
-class MOQInstance {
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+  std::shared_ptr<MetricsExporter> _mexport;
+#endif
 };
 
 } // namespace quicr
diff --git a/include/quicr/moq_delegate_instance.h b/include/quicr/moq_instance_delegate.h
similarity index 94%
rename from include/quicr/moq_delegate_instance.h
rename to include/quicr/moq_instance_delegate.h
index 183bc24a..81bd45ba 100644
--- a/include/quicr/moq_delegate_instance.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -16,7 +16,7 @@ namespace quicr {
  *   is a base class implementation and interface for callbacks.
  */
 
-class MOQInstanceDelegate
+class MoQInstanceDelegate
 {
 
 };
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
new file mode 100644
index 00000000..21aef3ef
--- /dev/null
+++ b/include/quicr/moq_track_delegate.h
@@ -0,0 +1,189 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+#pragma once
+
+#include <quicr/quicr_common.h>
+
+namespace quicr {
+
+/**
+ * @brief MOQ track delegate for subscribe and publish
+ *
+ * @details MOQ track delegate defines all track related callbacks and
+ *  functions. Track delegate operates on a single track (namespace + name).
+ *  It can be used for subscribe, publish, or both subscribe and publish. The
+ *  only requirement is that the namespace and track alias be the same.
+ */
+class MoQTrackDelegate
+{
+public:
+  enum class ReadError : uint8_t
+  {
+    OK = 0,
+    NOT_AUTHORIZED,
+    NOT_SUBSCRIBED,
+    NO_DATA,
+  };
+
+  enum class SendError : uint8_t
+  {
+    OK = 0,
+    NOT_AUTHORIZED,
+    NOT_ANNOUNCED,
+    NO_SUBSCRIBERS,
+  };
+
+  enum class TrackReadStatus : uint8_t
+  {
+    NOT_AUTHORIZED = 0,
+    NOT_SUBSCRIBED,
+    PENDING_SUBSCRIBE_RESPONSE,
+    SUBSCRIBE_NOT_AUTHORIZED
+  };
+
+  enum class TrackSendStatus : uint8_t
+  {
+    NOT_ANNOUNCED = 0,
+    PENDING_ANNOUNCE_RESPONSE,
+    ANNOUNCE_NOT_AUTHORIZED,
+    NO_SUBSCRIBERS,
+  };
+
+
+  // --------------------------------------------------------------------------
+  // Public API methods that normally should not be overridden
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief Track delegate constructor
+   */
+  MoQTrackDelegate(const bytes& track_namespace,
+                   const bytes& track_name,
+                   uint8_t default_priority,
+                   uint32_t default_ttl);
+
+  /**
+   * @brief Send object to announced track
+   *
+   * @details Send object to announced track that was previously announced.
+   *   This will have an error if the track wasn't announced yet. Status will
+   *   indicate if there are no subscribers. In this case, the object will
+   *   not be sent.
+   *
+   * @param[in] object   Object to send to track
+   *
+   * @returns SendError status of the send
+   *
+   */
+  SendError sendObject(const std::span<const uint8_t>& object);
+  SendError sendObject(const std::span<const uint8_t>& object, uint32_t ttl);
+
+  /**
+   * @brief Read object from track
+   *
+   * @details Reads an object from the subscribed track
+   *
+   * @param[out] object   Refence to object to be updated. Will be cleared.
+   *
+   * @returns ReadError status of the read
+   */
+  ReadError readObject(std::vector<const uint8_t>& object);
+
+  /**
+   * @brief Current track read status
+   *
+   * @details Obtains the current track read status/state
+   *
+   * @returns current TrackReadStatus
+   */
+  TrackReadStatus statusRead();
+
+  /**
+   * @brief Current track send status
+   *
+   * @details Obtains the current track send status/state
+   *
+   * @returns current TrackSendStatus
+   */
+  TrackReadStatus statusSend();
+
+  /**
+   * @brief set/update the default priority for published objects
+   */
+  void setDefaultPriority(uint8_t);
+
+  /**
+   * @brief set/update the default TTL expirty for published objects
+   */
+  void setDefaultTTL(uint32_t);
+
+  // --------------------------------------------------------------------------
+  // Public Virtual API callback event methods to be overridden
+  // --------------------------------------------------------------------------
+
+  /**
+   * @brief Notificaiton that data is avaialble to be read.
+   *
+   * @details Event notification to inform the caller that data can be read. The caller
+   *   should read all data if possible.
+   *
+   * @param objects_available       Number of objects available to be read at time of notification
+   */
+  virtual void callback_objectsAvailable(uint64_t objects_available) = 0;
+  virtual void callback_objectReceived(std::vector<uint8_t>&& object) = 0;
+
+  /**
+   * @brief Notification that data can be sent
+   * @details Notification that an announcement has been successful and there is at least one
+   *   subscriber for the track. Data can now be succesfully sent.
+   */
+  virtual void callback_sendReady() = 0;
+
+  /**
+   * @brief Notification that data can not be sent
+   * @details Notification that data cannot be sent yet with a reason. This will
+   *   be called as it transitions through send states.
+   *
+   * @param status        Indicates the reason for why data cannot be sent [yet]
+   */
+  virtual void callback_sendNotReady(TrackSendStatus status) = 0;
+
+  /**
+   * @brief Notification that the send queue is congested
+   * @details Notification indicates that send queue is backlogged and sending more
+   *   will likely cause more congestion.
+   *
+   * @param cleared             Indicates if congestion has cleared
+   * @param objects_in_queue    Number of objects still pending to be sent at time of notification
+   */
+  virtual void callback_sendCongested(bool cleared, uint64_t objects_in_queue) = 0;
+
+  /**
+   * @brief Notification to indicate reading is ready
+   * @details Notification that an announcement has been successful and but
+   * there are no subscribers, so data cannot be sent yet.
+   */
+  virtual void callback_readReady() = 0;
+
+ /**
+  * @brief Notification that read is not available
+  *
+  * @param status        Indicates the reason for why data cannot be sent [yet]
+  */
+ virtual void callback_readNotReady(TrackReadStatus status) = 0;
+
+
+
+  // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
+
+private:
+  const bytes _track_namespace;
+  const bytes _track_name;
+  std::optional<uint64_t> _track_alias;
+};
+
+} // namespace quicr

From 8c5a17c79e870f11f9b9aa6b21e4b2b8f2b079f6 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 4 Jun 2024 16:27:41 -0700
Subject: [PATCH 22/71] Update transport

---
 dependencies/transport | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dependencies/transport b/dependencies/transport
index ebf29645..3edbbdab 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit ebf29645ce4eadb057a09d6b641c765f487e400d
+Subproject commit 3edbbdab718b30a6fdbe9a092caf4e1459bb92c6

From 169ab6beb4f3272a441fd7691f6f34c34074fc98 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 19:24:59 -0700
Subject: [PATCH 23/71] get objectstream, objectdatagram and object group tests
 working

---
 test/moq_messages.cpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 917cca61..f5416a23 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -625,6 +625,7 @@ TEST_CASE("StreamPerGroup Object  Message encode/decode")
   CHECK_EQ(hdr_grp.track_alias, hdr_group_out.track_alias);
   CHECK_EQ(hdr_grp.group_id, hdr_group_out.group_id);
 
+  // stream all the objects
   buffer.pop(buffer.size());
   auto objects = std::vector<MoqStreamGroupObject>{};
   // send 10 objects
@@ -638,17 +639,20 @@ TEST_CASE("StreamPerGroup Object  Message encode/decode")
 
   net_data.clear();
   net_data = buffer.front(buffer.size());
+  auto obj_out = MoqStreamGroupObject{};
   size_t object_count = 0;
-  for(const auto v: net_data) {
-    buffer.push(v);
-    bool done = false;
-    auto obj_out = MoqStreamGroupObject{};
-    done = buffer >> obj_out;
+  qtransport::StreamBuffer<uint8_t> in_buffer;
+  for(size_t i =0; i < net_data.size(); i++) {
+    in_buffer.push(net_data.at(i));
+    bool done;
+    done = in_buffer >> obj_out;
     if (done) {
       CHECK_EQ(obj_out.object_id, objects[object_count].object_id);
       CHECK_EQ(obj_out.payload, objects[object_count].payload);
       // got one object
       object_count++;
+      obj_out = MoqStreamGroupObject{};
+      in_buffer.pop(in_buffer.size());
     }
   }
 

From c76f78e30f766fc384e9b6da48da03196ec2aa54 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 23:22:06 -0700
Subject: [PATCH 24/71] add test for stream-per-track encode/decode

---
 src/CMakeLists.txt    |  4 +--
 src/moq_messages.cpp  |  2 ++
 test/moq_messages.cpp | 62 +++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 71e0adb3..ea8c28f6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,8 +9,8 @@ target_sources(quicr PRIVATE
         quicr_client_raw_session.cpp
         quicr_server.cpp
         quicr_server_raw_session.cpp
-        moq_instance.cpp
-        moq_session.cpp
+        #moq_instance.cpp
+        #moq_session.cpp
 )
 
 if(NOT LIBQUICR_WITHOUT_INFLUXDB)
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 91149aec..c0f5308a 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -857,6 +857,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderTrack
         return false;
       }
       msg.current_pos += 1;
+      msg.parse_completed = true;
     }
     break;
   }
@@ -898,6 +899,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject
       if(!val) {
         return false;
       }
+      msg.payload = std::move(val.value());
       msg.parse_completed = true;
     }
     break;
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index f5416a23..da4562e8 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -629,7 +629,7 @@ TEST_CASE("StreamPerGroup Object  Message encode/decode")
   buffer.pop(buffer.size());
   auto objects = std::vector<MoqStreamGroupObject>{};
   // send 10 objects
-  for(size_t i = 0; i < 10; i++) {
+  for(size_t i = 0; i < 1000; i++) {
     auto obj = MoqStreamGroupObject{};
     obj.object_id = i;
     obj.payload = {0x1, 0x2, 0x3, 0x4, 0x5};
@@ -656,5 +656,63 @@ TEST_CASE("StreamPerGroup Object  Message encode/decode")
     }
   }
 
-  CHECK_EQ(object_count, 10);
+  CHECK_EQ(object_count, 1000);
+}
+
+TEST_CASE("StreamPerTrack Object  Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+  auto hdr = MoqStreamHeaderTrack {};
+  hdr.subscribe_id = 0x100;
+  hdr.track_alias = TRACK_ALIAS_ALICE_VIDEO;
+  hdr.priority = 0xA;
+
+  buffer << hdr;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqStreamHeaderTrack hdr_out;
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_TRACK), hdr_out));
+  CHECK_EQ(hdr_out.subscribe_id, hdr_out.subscribe_id);
+  CHECK_EQ(hdr_out.track_alias, hdr_out.track_alias);
+  CHECK_EQ(hdr_out.priority, hdr_out.priority);
+
+  // stream all the objects
+  buffer.pop(buffer.size());
+  auto objects = std::vector<MoqStreamTrackObject>{};
+  // send 10 objects
+  for(size_t i = 0; i < 1000; i++) {
+    auto obj = MoqStreamTrackObject{};
+   if ( i % 10 == 0) {
+      obj.group_id = i;
+      obj.object_id = 0;
+    } else {
+      obj.object_id = i;
+    }
+
+    obj.payload = {0x1, 0x2, 0x3, 0x4, 0x5};
+    objects.push_back(obj);
+    buffer << obj;
+  }
+
+  net_data.clear();
+  net_data = buffer.front(buffer.size());
+  auto obj_out = MoqStreamTrackObject{};
+  size_t object_count = 0;
+  qtransport::StreamBuffer<uint8_t> in_buffer;
+  for(size_t i =0; i < net_data.size(); i++) {
+    in_buffer.push(net_data.at(i));
+    bool done;
+    done = in_buffer >> obj_out;
+    if (done) {
+      CHECK_EQ(obj_out.group_id, objects[object_count].group_id);
+      CHECK_EQ(obj_out.object_id, objects[object_count].object_id);
+      CHECK_EQ(obj_out.payload, objects[object_count].payload);
+      // got one object
+      object_count++;
+      obj_out = MoqStreamTrackObject{};
+      in_buffer.pop(in_buffer.size());
+    }
+  }
+
+  CHECK_EQ(object_count, 1000);
 }
\ No newline at end of file

From 3e81f6c60e955131ba0d37ccd24d0dadfd13fd4e Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Tue, 4 Jun 2024 23:27:16 -0700
Subject: [PATCH 25/71] add goaway encode/decode/test, cleanup old Apis

---
 include/quicr/moq_messages.h | 27 +++------------------------
 src/moq_messages.cpp         | 18 ++++++++++++++++++
 test/moq_messages.cpp        | 15 +++++++++++++++
 3 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 7337b056..eb32eeed 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -109,9 +109,6 @@ struct MoqServerSetup {
 
 };
 
-MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &msg);
-
 //
 // Subscribe
 //
@@ -247,6 +244,9 @@ struct MoqAnnounceCancel {
 //
 struct MoqGoaway {
   quicr::bytes new_session_uri;
+  friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqGoaway &msg);
+  friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                       const MoqGoaway& msg);
 };
 
 MessageBuffer& operator<<(MessageBuffer& buffer, const MoqGoaway& msg);
@@ -336,25 +336,4 @@ struct MoqStreamGroupObject {
   bool parse_completed { false };
 };
 
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqObjectStream& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqObjectStream &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqObjectDatagram& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqObjectDatagram &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamHeaderTrack& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamHeaderTrack &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamTrackObject& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamTrackObject &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamHeaderGroup& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamHeaderGroup &msg);
-MessageBuffer& operator<<(MessageBuffer& buffer, const MoqStreamGroupObject& msg);
-MessageBuffer& operator>>(MessageBuffer &buffer, MoqStreamGroupObject &msg);
-
-MessageBuffer& operator<<(MessageBuffer& buffer, const std::vector<uintVar_t>& val);
-MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
-MessageBuffer& operator>>(MessageBuffer& msg, std::vector<uintVar_t>& val);
-
-template <typename T>
-MessageBuffer& operator<<(MessageBuffer& buffer, const std::optional<T>& val);
-template <typename T>
-MessageBuffer& operator>>(MessageBuffer& msg, std::optional<T>& val);
 }
\ No newline at end of file
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index c0f5308a..6b4f06c2 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -667,6 +667,24 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceCancel &ms
 // Goaway
 //
 
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+           const MoqGoaway& msg){
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_GOAWAY)));
+  buffer.push_lv(msg.new_session_uri);
+  return buffer;
+}
+
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqGoaway &msg) {
+
+  const auto val = buffer.decode_bytes();
+  if (!val) {
+    return false;
+  }
+  msg.new_session_uri = std::move(val.value());
+  return true;
+}
+
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqGoaway &msg) {
   buffer << static_cast<uint8_t>(MESSAGE_TYPE_GOAWAY);
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index da4562e8..783699d2 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -715,4 +715,19 @@ TEST_CASE("StreamPerTrack Object  Message encode/decode")
   }
 
   CHECK_EQ(object_count, 1000);
+}
+
+
+TEST_CASE("MoqGoaway Message encode/decode")
+{
+  qtransport::StreamBuffer<uint8_t> buffer;
+
+  auto goaway  = MoqGoaway {};
+  goaway.new_session_uri = from_ascii("go.away.now.no.return");
+  buffer << goaway;
+
+  std::vector<uint8_t> net_data = buffer.front(buffer.size());
+  MoqGoaway goaway_out{};
+  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_GOAWAY), goaway_out));
+  CHECK_EQ(from_ascii("go.away.now.no.return"), goaway_out.new_session_uri);
 }
\ No newline at end of file

From 006a81b12ac339f77bc76513999cddcbb4ae2e27 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Wed, 5 Jun 2024 16:59:52 -0700
Subject: [PATCH 26/71] Update api methods and remove unused code

---
 .clang-format                         |   5 +
 include/quicr/moq_instance.h          | 362 +++++++++++-------------
 include/quicr/moq_instance_delegate.h |  20 +-
 include/quicr/moq_track_delegate.h    | 380 ++++++++++++++------------
 src/CMakeLists.txt                    |   4 +-
 src/moq_session.h                     |   1 +
 6 files changed, 375 insertions(+), 397 deletions(-)

diff --git a/.clang-format b/.clang-format
index 2e8f10e1..72fa895f 100644
--- a/.clang-format
+++ b/.clang-format
@@ -3,5 +3,10 @@ Language:      Cpp
 BasedOnStyle:  Mozilla
 
 BreakAfterAttributes: Leave
+ColumnLimit: 120
+IndentWidth: 4
+NamespaceIndentation: All
+BraceWrapping:
+  AfterFunction: false
 ...
 
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index b2174512..f8ef3056 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -14,216 +14,162 @@
 #include <quicr/moq_track_delegate.h>
 
 namespace quicr {
-using namespace qtransport;
-
-class MoQInstanceConfig
-{
-  RelayInfo relay_info;
-
-  // TODO(tievens): Convert to use URL instead of Relay Info
-
-  std::string instance_id;                    /// Instance ID for the client or server, should be unique
-  TransportConfig transport_config;
-};
-
-class MoQInstance : public ITransport::TransportDelegate
-{
-
-public:
-  /**
-   *
-   * @param cfg     MoQ Instance Configuration
-   * @param logger  MoQ Log pointer to parent logger
-   */
-  MoQInstance(const MoQInstanceConfig& cfg,
-              const cantina::LoggerPointer& logger);
-
-  ~MoQInstance();
-
-  // -------------------------------------------------------------------------------------------------
-  // Public API MoQ Intance API methods
-  // -------------------------------------------------------------------------------------------------
-  /**
-   * @brief Subscribe to a track
-   *
-   * @param track_delegate    Track delegate to use for track related functions and callbacks
-   *
-   * @returns `track_alias` if no error and nullopt on error
-   */
-  std::optional<uint64_t> subscribeTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
-
-
-  /**
-   * @brief Publish to a track
-   *
-   * @param track_delegate    Track delegate to use for track related functions
-   *                          and callbacks
-   *
-   * @returns `track_alias` if no error and nullopt on error
-   */
-  std::optional<uint64_t> publishTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
-
-
-  // -------------------------------------------------------------------------------------------------
-
-  /*
-   * Transport Delegete/callback functions
-   */
-  void on_new_data_context(const TransportConnId& conn_id,
-                           const DataContextId& data_ctx_id) override
-  {
-  }
-  void on_connection_status(const TransportConnId& conn_id,
-                            const TransportStatus status) override;
-  void on_new_connection(const TransportConnId& conn_id,
-                         const TransportRemote& remote) override;
-  void on_recv_stream(const TransportConnId& conn_id,
-                      uint64_t stream_id,
-                      std::optional<DataContextId> data_ctx_id,
-                      const bool is_bidir = false) override;
-  void on_recv_dgram(const TransportConnId& conn_id,
-                     std::optional<DataContextId> data_ctx_id) override;
-
-private:
-  /**
-   * @brief Client thread to monitor client published messages
-   */
-  void PeerQueueThread();
-
-  /**
-   * @brief Watch Thread to perform reconnects and cleanup
-   * @details Thread will perform various tasks each interval
-   *
-   * @param interval_ms       Interval in milliseconds to sleep before running
-   * check
-   */
-  void watchThread(int interval_ms);
-
-  /**
-   * @brief Create a peering session/connection
-   *
-   * @param peer_config           Peer/relay configuration parameters
-   *
-   */
-  void createPeerSession(const TransportRemote& peer_config);
-
-  /**
-   * @brief Send subscribe to first/best publish intent peers
-   *
-   * @details There is a single best (first in list) publish intent peer to send
-   * matching subscribes to for a given origin. This method will iterate over
-   * each matching publish intent best origin peer and send a subscribe.
-   *
-   * @param ns                    Namespace to subscribe
-   * @param source_peer_id        Source peer that sent (or client manager) the
-   * intent
-   */
-  void subscribePeers(const Namespace& ns, const peer_id_t& source_peer_id);
-
-  /**
-   * @brief Send subscribe to specific peer
-   *
-   * @param ns                    Namespace to subscribe peers to
-   * @param peer_id               Peer ID to send to
-   */
-  void subscribePeer(const Namespace& ns, const peer_id_t& peer_id);
-
-  /**
-   * @brief Send unsubscribe to peers that had previous subscribes for given
-   * namespace
-   *
-   * @param ns                    Namespace to unsubscribe peers to
-   * @param source_peer_id        Source peer that sent (or client manager) the
-   * intent
-   */
-  void unSubscribePeers(const Namespace& ns, const peer_id_t& source_peer_id);
-
-  /**
-   * @brief Send unsubscribe to specific peer
-   *
-   * @param ns                    Namespace to unsubscribe peers to
-   * @param peer_id               Peer ID to send to
-   */
-  void unSubscribePeer(const Namespace& ns, const peer_id_t& peer_id);
-
-  /**
-   * @brief Send publish intent to all peers
-   *
-   * @details Currently publish intents are flooded to all peers
-   *
-   * @param ns                   Namespace for publish intent
-   * @param source_peer_id       Source peer that sent (or client manager) the
-   * intent
-   * @param origin_peer_id       Origin peer/relay that has the publisher
-   * directly connected
-   */
-  void publishIntentPeers(const Namespace& ns,
-                          const peer_id_t& source_peer_id,
-                          const peer_id_t& origin_peer_id);
-
-  /**
-   * @brief Send publish intent done
-   *
-   * @brief Currently publish intents are flooded to all peers, so the done
-   * needs to be flooded as well
-   *
-   * @param ns                    Namespace for publish intent done
-   * @param source_peer_id        Source peer that sent (or client manager) the
-   * intent
-   * @param origin_peer_id        Origin peer/relay that has the publisher
-   * directly connected
-   */
-  void publishIntentDonePeers(const Namespace& ns,
-                              const peer_id_t& source_peer_id,
-                              const peer_id_t& origin_peer_id);
-
-  /**
-   * @brief Get the pointer to the session by peer_id
-   *
-   * @param peer_id               Peer ID to get session
-   *
-   * @return Returns nullptr or peer session if found
-   */
-  PeerSession* getPeerSession(const peer_id_t& peer_id);
-
-  void addSubscribedPeer(const Namespace& ns, const peer_id_t& peer_id);
-
-private:
-  std::mutex _mutex;
-  std::atomic<bool> _stop{ false };
-  const Config& _config;
-
-  peerQueue& _peer_queue;
-  Cache& _cache;
-  ClientSubscriptions& _subscriptions;
-
-  std::shared_ptr<ITransport>
-    _server_transport; /// Server Transport for inbound connections
-
-  std::thread _client_rx_msg_thr; /// Client receive message thread
-  std::thread _watch_thr;         /// Watch/task thread, handles reconnects
-
-  /// Peer sessions that are accepted by the server
-  std::map<TransportConnId, PeerSession> _server_peer_sessions;
-
-  std::vector<PeerSession>
-    _client_peer_sessions; /// Peer sessions that are initiated by the peer
-                           /// manager
-
-  // TODO: Fix to use list for peer sessions subscribed
-  namespace_map<std::set<peer_id_t>>
-    _peer_sess_subscribe_sent; /// Peers that subscribes have been sent
-  namespace_map<std::set<peer_id_t>>
-    _peer_sess_subscribe_recv; /// Peers that subscribes have been received
-  namespace_map<std::map<peer_id_t, std::list<peer_id_t>>>
-    _pub_intent_namespaces; /// Publish intents received from peers
-
-  // Log handler to use
-  cantina::LoggerPointer logger;
+    using namespace qtransport;
+
+
+
+    class MoQInstanceConfig
+    {
+        std::string instance_id; /// Instance ID for the client or server, should be unique
+        TransportConfig transport_config;
+    };
+
+    class MoQInstanceClientConfig : MoQInstanceConfig
+    {
+        std::string server_host_ip;     /// Relay hostname or IP to connect to
+        uint16_t server__port;          /// Relay port to connect to
+        TransportProtocol server_proto; /// Protocol to use when connecting to relay
+    };
+
+    class MoQInstanceServerConfig : MoQInstanceConfig
+    {
+        std::string server_bind_ip;     /// IP address to bind to, can be 0.0.0.0
+        uint16_t server_port;           /// Listening port for server
+        TransportProtocol server_proto; /// Protocol to use
+    };
+
+    /**
+     * @brief MOQ Instance
+     * @Details MoQ Instance is the handler for either a client or server. It can run
+     *   in only one mode, client or server.
+     */
+    class MoQInstance
+    {
+      public:
+        enum class Status : uint8_t
+        {
+            READY = 0,
+
+            ERROR_NOT_IN_CLIENT_MODE,
+            ERROR_NOT_IN_SERVER_MODE,
+
+            CLIENT_INVALID_PARAMS,
+            CLIENT_NOT_CONNECTED,
+            CLIENT_CONNECTING,
+        };
+
+        /**
+         * @brief Client mode Constructor to create the MOQ instance
+         *
+         * @param cfg     MoQ Instance Client Configuration
+         * @param logger  MoQ Log pointer to parent logger
+         */
+        MoQInstance(const MoQInstanceClientConfig& cfg, const cantina::LoggerPointer& logger);
+
+        /**
+         * @brief Server mode Constructor to create the MOQ instance
+         *
+         * @param cfg     MoQ Instance Server Configuration
+         * @param logger  MoQ Log pointer to parent logger
+         */
+        MoQInstance(const MoQInstanceServerConfig& cfg, const cantina::LoggerPointer& logger);
+
+        ~MoQInstance();
+
+        // -------------------------------------------------------------------------------------------------
+        // Public API MoQ Intance API methods
+        // -------------------------------------------------------------------------------------------------
+        /**
+         * @brief Subscribe to a track
+         *
+         * @param track_delegate    Track delegate to use for track related functions and callbacks
+         *
+         * @returns `track_alias` if no error and nullopt on error
+         */
+        std::optional<uint64_t> subscribeTrack(TransportConnId conn_id,
+                                               std::shared_ptr<MoQTrackDelegate> track_delegate);
+
+        /**
+         * @brief Publish to a track
+         *
+         * @param track_delegate    Track delegate to use for track related functions
+         *                          and callbacks
+         *
+         * @returns `track_alias` if no error and nullopt on error
+         */
+        std::optional<uint64_t> publishTrack(TransportConnId conn_id,
+                                             std::shared_ptr<MoQTrackDelegate> track_delegate);
+
+        /**
+         * @brief Make client connection
+         *
+         * @details Makes a client connection session if instance is in client mode
+         *
+         * @return Status indicating state or error. If succesful, status will be
+         *    CLIENT_CONNECTING.
+         */
+        Status client_connect();
+
+        /**
+         * @brief Get the instance status
+         *
+         * @return Status indicating the state/status of the instance
+         */
+        Status status();
+
+    private:
+        /**
+         * @brief Create a transport session/connection
+         *
+         * @param peer_config           Peer/relay configuration parameters
+         *
+         */
+        void createSession(const TransportRemote& peer_config);
+
+      private:
+        std::mutex _mutex;
+        const bool _client_mode;
+        std::atomic<bool> _stop{ false };
+        const MoQInstanceServerConfig& _server_config;
+        const MoQInstanceClientConfig& _client_config;
+
+
+        // Log handler to use
+        cantina::LoggerPointer logger;
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-  std::shared_ptr<MetricsExporter> _mexport;
+        std::shared_ptr<MetricsExporter> _mexport;
 #endif
-};
+    };
+
+    /**
+     * @brief MOQ Instance Transport Delegate
+     * @details MOQ implements the transport delegate, which is shared by all sessions
+     */
+    class MoQInstanceTransportDelegate : public ITransport::TransportDelegate
+    {
+      public:
+        MoQInstanceTransportDelegate(const MoQInstance& moq_instance, const cantina::LoggerPointer& logger) :
+           _moq_instance(moq_instance)
+           , _logger(std::make_shared<cantina::Logger>("MOQ_ITD", logger))
+        {}
+
+        // -------------------------------------------------------------------------------------------------
+        // Transprot Delegate/callback functions
+        // -------------------------------------------------------------------------------------------------
+
+        void on_new_data_context(const TransportConnId& conn_id, const DataContextId& data_ctx_id) override {}
+        void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) override;
+        void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) override;
+        void on_recv_stream(const TransportConnId& conn_id,
+                            uint64_t stream_id,
+                            std::optional<DataContextId> data_ctx_id,
+                            const bool is_bidir = false) override;
+        void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
+
+      private:
+        cantina::LoggerPointer _logger;
+        const MoQInstance& _moq_instance;
+    };
 
 } // namespace quicr
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 81bd45ba..f369bcac 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -8,17 +8,15 @@
 
 namespace quicr {
 
-/**
- * @brief Delegate for all MOQ/MOQT callbacks and interaction
- *
- * @details A new MOQ instance is created with this delegate as a shared pointer.
- *   All interaction with the instance is handled via this delegate. This delegate
- *   is a base class implementation and interface for callbacks.
- */
-
-class MoQInstanceDelegate
-{
+    /**
+     * @brief Delegate for all MOQ/MOQT callbacks and interaction
+     *
+     * @details A new MOQ instance is created with this delegate as a shared pointer.
+     *   All interaction with the instance is handled via this delegate. This delegate
+     *   is a base class implementation and interface for callbacks.
+     */
 
-};
+    class MoQInstanceDelegate
+    {};
 
 } // namespace quicr
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 21aef3ef..68bff007 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -5,185 +5,213 @@
  */
 #pragma once
 
+#include <quicr/moq_messages.h>
 #include <quicr/quicr_common.h>
 
 namespace quicr {
 
-/**
- * @brief MOQ track delegate for subscribe and publish
- *
- * @details MOQ track delegate defines all track related callbacks and
- *  functions. Track delegate operates on a single track (namespace + name).
- *  It can be used for subscribe, publish, or both subscribe and publish. The
- *  only requirement is that the namespace and track alias be the same.
- */
-class MoQTrackDelegate
-{
-public:
-  enum class ReadError : uint8_t
-  {
-    OK = 0,
-    NOT_AUTHORIZED,
-    NOT_SUBSCRIBED,
-    NO_DATA,
-  };
-
-  enum class SendError : uint8_t
-  {
-    OK = 0,
-    NOT_AUTHORIZED,
-    NOT_ANNOUNCED,
-    NO_SUBSCRIBERS,
-  };
-
-  enum class TrackReadStatus : uint8_t
-  {
-    NOT_AUTHORIZED = 0,
-    NOT_SUBSCRIBED,
-    PENDING_SUBSCRIBE_RESPONSE,
-    SUBSCRIBE_NOT_AUTHORIZED
-  };
-
-  enum class TrackSendStatus : uint8_t
-  {
-    NOT_ANNOUNCED = 0,
-    PENDING_ANNOUNCE_RESPONSE,
-    ANNOUNCE_NOT_AUTHORIZED,
-    NO_SUBSCRIBERS,
-  };
-
-
-  // --------------------------------------------------------------------------
-  // Public API methods that normally should not be overridden
-  // --------------------------------------------------------------------------
-
-  /**
-   * @brief Track delegate constructor
-   */
-  MoQTrackDelegate(const bytes& track_namespace,
-                   const bytes& track_name,
-                   uint8_t default_priority,
-                   uint32_t default_ttl);
-
-  /**
-   * @brief Send object to announced track
-   *
-   * @details Send object to announced track that was previously announced.
-   *   This will have an error if the track wasn't announced yet. Status will
-   *   indicate if there are no subscribers. In this case, the object will
-   *   not be sent.
-   *
-   * @param[in] object   Object to send to track
-   *
-   * @returns SendError status of the send
-   *
-   */
-  SendError sendObject(const std::span<const uint8_t>& object);
-  SendError sendObject(const std::span<const uint8_t>& object, uint32_t ttl);
-
-  /**
-   * @brief Read object from track
-   *
-   * @details Reads an object from the subscribed track
-   *
-   * @param[out] object   Refence to object to be updated. Will be cleared.
-   *
-   * @returns ReadError status of the read
-   */
-  ReadError readObject(std::vector<const uint8_t>& object);
-
-  /**
-   * @brief Current track read status
-   *
-   * @details Obtains the current track read status/state
-   *
-   * @returns current TrackReadStatus
-   */
-  TrackReadStatus statusRead();
-
-  /**
-   * @brief Current track send status
-   *
-   * @details Obtains the current track send status/state
-   *
-   * @returns current TrackSendStatus
-   */
-  TrackReadStatus statusSend();
-
-  /**
-   * @brief set/update the default priority for published objects
-   */
-  void setDefaultPriority(uint8_t);
-
-  /**
-   * @brief set/update the default TTL expirty for published objects
-   */
-  void setDefaultTTL(uint32_t);
-
-  // --------------------------------------------------------------------------
-  // Public Virtual API callback event methods to be overridden
-  // --------------------------------------------------------------------------
-
-  /**
-   * @brief Notificaiton that data is avaialble to be read.
-   *
-   * @details Event notification to inform the caller that data can be read. The caller
-   *   should read all data if possible.
-   *
-   * @param objects_available       Number of objects available to be read at time of notification
-   */
-  virtual void callback_objectsAvailable(uint64_t objects_available) = 0;
-  virtual void callback_objectReceived(std::vector<uint8_t>&& object) = 0;
-
-  /**
-   * @brief Notification that data can be sent
-   * @details Notification that an announcement has been successful and there is at least one
-   *   subscriber for the track. Data can now be succesfully sent.
-   */
-  virtual void callback_sendReady() = 0;
-
-  /**
-   * @brief Notification that data can not be sent
-   * @details Notification that data cannot be sent yet with a reason. This will
-   *   be called as it transitions through send states.
-   *
-   * @param status        Indicates the reason for why data cannot be sent [yet]
-   */
-  virtual void callback_sendNotReady(TrackSendStatus status) = 0;
-
-  /**
-   * @brief Notification that the send queue is congested
-   * @details Notification indicates that send queue is backlogged and sending more
-   *   will likely cause more congestion.
-   *
-   * @param cleared             Indicates if congestion has cleared
-   * @param objects_in_queue    Number of objects still pending to be sent at time of notification
-   */
-  virtual void callback_sendCongested(bool cleared, uint64_t objects_in_queue) = 0;
-
-  /**
-   * @brief Notification to indicate reading is ready
-   * @details Notification that an announcement has been successful and but
-   * there are no subscribers, so data cannot be sent yet.
-   */
-  virtual void callback_readReady() = 0;
-
- /**
-  * @brief Notification that read is not available
-  *
-  * @param status        Indicates the reason for why data cannot be sent [yet]
-  */
- virtual void callback_readNotReady(TrackReadStatus status) = 0;
-
-
-
-  // --------------------------------------------------------------------------
-  // --------------------------------------------------------------------------
-
-private:
-  const bytes _track_namespace;
-  const bytes _track_name;
-  std::optional<uint64_t> _track_alias;
-};
+    /**
+     * @brief MOQ track delegate for subscribe and publish
+     *
+     * @details MOQ track delegate defines all track related callbacks and
+     *  functions. Track delegate operates on a single track (namespace + name).
+     *  It can be used for subscribe, publish, or both subscribe and publish. The
+     *  only requirement is that the namespace and track alias be the same.
+     */
+    class MoQTrackDelegate
+    {
+      public:
+        enum class ReadError : uint8_t
+        {
+            OK = 0,
+            NOT_AUTHORIZED,
+            NOT_SUBSCRIBED,
+            NO_DATA,
+        };
+
+        enum class SendError : uint8_t
+        {
+            OK = 0,
+            NOT_AUTHORIZED,
+            NOT_ANNOUNCED,
+            NO_SUBSCRIBERS,
+        };
+
+        enum class TrackReadStatus : uint8_t
+        {
+            NOT_AUTHORIZED = 0,
+            NOT_SUBSCRIBED,
+            PENDING_SUBSCRIBE_RESPONSE,
+            SUBSCRIBE_NOT_AUTHORIZED
+        };
+
+        enum class TrackSendStatus : uint8_t
+        {
+            NOT_ANNOUNCED = 0,
+            PENDING_ANNOUNCE_RESPONSE,
+            ANNOUNCE_NOT_AUTHORIZED,
+            NO_SUBSCRIBERS,
+        };
+
+        enum class TrackMode : uint8_t
+        {
+            DATAGRAM,
+            STREAM_PER_OBJECT,
+            STREAM_PER_GROUP,
+            STREAM_PER_TRACK
+        };
+
+        // --------------------------------------------------------------------------
+        // Public API methods that normally should not be overridden
+        // --------------------------------------------------------------------------
+
+        /**
+         * @brief Track delegate constructor
+         */
+        MoQTrackDelegate(const bytes& track_namespace,
+                         const bytes& track_name,
+                         const TrackMode track_mode,
+                         uint8_t default_priority,
+                         uint32_t default_ttl);
+
+        /**
+         * @brief Send object to announced track
+         *
+         * @details Send object to announced track that was previously announced.
+         *   This will have an error if the track wasn't announced yet. Status will
+         *   indicate if there are no subscribers. In this case, the object will
+         *   not be sent.
+         *
+         * @param[in] object   Object to send to track
+         *
+         * @returns SendError status of the send
+         *
+         */
+        SendError sendObject(const std::span<const uint8_t>& object);
+        SendError sendObject(const std::span<const uint8_t>& object, uint32_t ttl);
+
+        /**
+         * @brief Read object from track
+         *
+         * @details Reads an object from the subscribed track
+         *
+         * @param[out] object   Refence to object to be updated. Will be cleared.
+         *
+         * @returns ReadError status of the read
+         */
+        ReadError readObject(std::vector<const uint8_t>& object);
+
+        /**
+         * @brief Current track read status
+         *
+         * @details Obtains the current track read status/state
+         *
+         * @returns current TrackReadStatus
+         */
+        TrackReadStatus statusRead();
+
+        /**
+         * @brief Current track send status
+         *
+         * @details Obtains the current track send status/state
+         *
+         * @returns current TrackSendStatus
+         */
+        TrackReadStatus statusSend();
+
+        /**
+         * @brief set/update the default priority for published objects
+         */
+        void setDefaultPriority(uint8_t);
+
+        /**
+         * @brief set/update the default TTL expirty for published objects
+         */
+        void setDefaultTTL(uint32_t);
+
+        // --------------------------------------------------------------------------
+        // Public Virtual API callback event methods to be overridden
+        // --------------------------------------------------------------------------
+
+        /**
+         * @brief Notificaiton that data is avaialble to be read.
+         *
+         * @details Event notification to inform the caller that data can be read. The caller
+         *   should read all data if possible.
+         *
+         * @param objects_available       Number of objects available to be read at time of notification
+         */
+        virtual void cb_objectsAvailable(uint64_t objects_available) = 0;
+        virtual void cb_objectReceived(std::vector<uint8_t>&& object) = 0;
+
+        /**
+         * @brief Notification that data can be sent
+         * @details Notification that an announcement has been successful and there is at least one
+         *   subscriber for the track. Data can now be succesfully sent.
+         */
+        virtual void cb_sendReady() = 0;
+
+        /**
+         * @brief Notification that data can not be sent
+         * @details Notification that data cannot be sent yet with a reason. This will
+         *   be called as it transitions through send states.
+         *
+         * @param status        Indicates the reason for why data cannot be sent [yet]
+         */
+        virtual void cb_sendNotReady(TrackSendStatus status) = 0;
+
+        /**
+         * @brief Notification that the send queue is congested
+         * @details Notification indicates that send queue is backlogged and sending more
+         *   will likely cause more congestion.
+         *
+         * @param cleared             Indicates if congestion has cleared
+         * @param objects_in_queue    Number of objects still pending to be sent at time of notification
+         */
+        virtual void cb_sendCongested(bool cleared, uint64_t objects_in_queue) = 0;
+
+        /**
+         * @brief Notification to indicate reading is ready
+         * @details Notification that an announcement has been successful and but
+         * there are no subscribers, so data cannot be sent yet.
+         */
+        virtual void cb_readReady() = 0;
+
+        /**
+         * @brief Notification that read is not available
+         *
+         * @param status        Indicates the reason for why data cannot be sent [yet]
+         */
+        virtual void cb_readNotReady(TrackReadStatus status) = 0;
+
+        // --------------------------------------------------------------------------
+        // Internal API methods used by MOQ instance and peering session
+        // --------------------------------------------------------------------------
+
+        /**
+         * @brief Set the track alias
+         * @details MOQ Instance session will set the track alias when the track has
+         *   been assigned.
+         *
+         * @param track_alias       MOQT track alias for track namespace+name that
+         *                          is relative to the sesssion
+         */
+        void setTrackAlias(uint64_t track_alias) { _track_alias = track_alias; }
+
+        /**
+         * @brief Get the track alias
+         * @returns Track alias as an optional. Track alias may not be set yet. If not
+         *   set, nullopt will be returned.
+         */
+        std::optional<uint64_t> getTrackAlias() { return _track_alias; }
+
+        // --------------------------------------------------------------------------
+        // --------------------------------------------------------------------------
+
+      private:
+        const bytes _track_namespace;
+        const bytes _track_name;
+        std::optional<uint64_t> _track_alias;
+    };
 
 } // namespace quicr
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ea8c28f6..71e0adb3 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,8 +9,8 @@ target_sources(quicr PRIVATE
         quicr_client_raw_session.cpp
         quicr_server.cpp
         quicr_server_raw_session.cpp
-        #moq_instance.cpp
-        #moq_session.cpp
+        moq_instance.cpp
+        moq_session.cpp
 )
 
 if(NOT LIBQUICR_WITHOUT_INFLUXDB)
diff --git a/src/moq_session.h b/src/moq_session.h
index 45efad6a..e3132321 100644
--- a/src/moq_session.h
+++ b/src/moq_session.h
@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <quicr/moq_instance.h>
 #include "moq_session.h"
 
 namespace quicr {

From fec7d89bbee2da1426c8074accb6d601570df75c Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 6 Jun 2024 17:07:40 -0700
Subject: [PATCH 27/71] Initial instance implementation

---
 cmd/CMakeLists.txt                    |   1 +
 include/quicr/moq_instance.h          | 134 +++++++++++++---------
 include/quicr/moq_instance_delegate.h |  53 ++++++++-
 include/quicr/moq_track_delegate.h    |   3 +-
 src/moq_instance.cpp                  | 159 ++++++++++++++++++++++++++
 5 files changed, 288 insertions(+), 62 deletions(-)

diff --git a/cmd/CMakeLists.txt b/cmd/CMakeLists.txt
index 56c72004..5d66703c 100644
--- a/cmd/CMakeLists.txt
+++ b/cmd/CMakeLists.txt
@@ -1,3 +1,4 @@
 #add_subdirectory(qcurl)
 add_subdirectory(really)
+add_subdirectory(moq-example)
 
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index f8ef3056..a012e411 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-#include <quicr/metrics_exporter.h>
 #include <quicr/quicr_common.h>
 #include <transport/transport.h>
+#include <quicr/metrics_exporter.h>
 
 #include <quicr/moq_instance_delegate.h>
 #include <quicr/moq_track_delegate.h>
@@ -16,28 +16,63 @@
 namespace quicr {
     using namespace qtransport;
 
-
-
-    class MoQInstanceConfig
+    struct MoQInstanceConfig
     {
         std::string instance_id; /// Instance ID for the client or server, should be unique
         TransportConfig transport_config;
     };
 
-    class MoQInstanceClientConfig : MoQInstanceConfig
+    struct MoQInstanceClientConfig : MoQInstanceConfig
     {
         std::string server_host_ip;     /// Relay hostname or IP to connect to
-        uint16_t server__port;          /// Relay port to connect to
+        uint16_t server_port;          /// Relay port to connect to
         TransportProtocol server_proto; /// Protocol to use when connecting to relay
     };
 
-    class MoQInstanceServerConfig : MoQInstanceConfig
+    struct MoQInstanceServerConfig : MoQInstanceConfig
     {
         std::string server_bind_ip;     /// IP address to bind to, can be 0.0.0.0
         uint16_t server_port;           /// Listening port for server
         TransportProtocol server_proto; /// Protocol to use
     };
 
+    class MoQInstance;
+    /**
+     * @brief MOQ Instance Transport Delegate
+     * @details MOQ implements the transport delegate, which is shared by all sessions
+     */
+    class MoQInstanceTransportDelegate : public ITransport::TransportDelegate
+    {
+      public:
+        MoQInstanceTransportDelegate(MoQInstance& moq_instance, const cantina::LoggerPointer& logger)
+          : _moq_instance(moq_instance)
+          , _logger(std::make_shared<cantina::Logger>("MOQ_ITD", logger))
+        {
+        }
+
+        // -------------------------------------------------------------------------------------------------
+        // Transprot Delegate/callback functions
+        // -------------------------------------------------------------------------------------------------
+
+        void on_new_data_context([[maybe_unused]] const TransportConnId& conn_id,
+                                 [[maybe_unused]] const DataContextId& data_ctx_id) override
+        {
+        }
+
+        void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) override;
+        void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) override;
+        void on_recv_stream(const TransportConnId& conn_id,
+                            uint64_t stream_id,
+                            std::optional<DataContextId> data_ctx_id,
+                            const bool is_bidir = false) override;
+        void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
+
+      private:
+        MoQInstance& _moq_instance;
+        cantina::LoggerPointer _logger;
+    };
+
+
     /**
      * @brief MOQ Instance
      * @Details MoQ Instance is the handler for either a client or server. It can run
@@ -49,6 +84,7 @@ namespace quicr {
         enum class Status : uint8_t
         {
             READY = 0,
+            NOT_READY,
 
             ERROR_NOT_IN_CLIENT_MODE,
             ERROR_NOT_IN_SERVER_MODE,
@@ -56,23 +92,30 @@ namespace quicr {
             CLIENT_INVALID_PARAMS,
             CLIENT_NOT_CONNECTED,
             CLIENT_CONNECTING,
+            CLIENT_FAILED_TO_CONNECT,
         };
 
         /**
          * @brief Client mode Constructor to create the MOQ instance
          *
          * @param cfg     MoQ Instance Client Configuration
+         * @param delegate   MoQ instance delegate of callbacks
          * @param logger  MoQ Log pointer to parent logger
          */
-        MoQInstance(const MoQInstanceClientConfig& cfg, const cantina::LoggerPointer& logger);
+        MoQInstance(const MoQInstanceClientConfig& cfg,
+                    std::shared_ptr<MoQInstanceDelegate> delegate,
+                    const cantina::LoggerPointer& logger);
 
         /**
          * @brief Server mode Constructor to create the MOQ instance
          *
-         * @param cfg     MoQ Instance Server Configuration
-         * @param logger  MoQ Log pointer to parent logger
+         * @param cfg        MoQ Instance Server Configuration
+         * @param delegate   MoQ instance delegate of callbacks
+         * @param logger     MoQ Log pointer to parent logger
          */
-        MoQInstance(const MoQInstanceServerConfig& cfg, const cantina::LoggerPointer& logger);
+        MoQInstance(const MoQInstanceServerConfig& cfg,
+                    std::shared_ptr<MoQInstanceDelegate> delegate,
+                    const cantina::LoggerPointer& logger);
 
         ~MoQInstance();
 
@@ -101,75 +144,56 @@ namespace quicr {
                                              std::shared_ptr<MoQTrackDelegate> track_delegate);
 
         /**
-         * @brief Make client connection
+         * @brief Make client connection and run
          *
-         * @details Makes a client connection session if instance is in client mode
+         * @details Makes a client connection session if instance is in client mode and runs as client
          *
          * @return Status indicating state or error. If succesful, status will be
          *    CLIENT_CONNECTING.
          */
-        Status client_connect();
+        Status run_client();
 
         /**
-         * @brief Get the instance status
+         * @brief Start Server Listening
          *
-         * @return Status indicating the state/status of the instance
+         * @details Creates transport and listens for new connections
+         *
+         * @return Status indicating state or error. If succesful, status will be
+         *    READY.
          */
-        Status status();
+        Status run_server();
+
 
-    private:
         /**
-         * @brief Create a transport session/connection
-         *
-         * @param peer_config           Peer/relay configuration parameters
+         * @brief Get the instance status
          *
+         * @return Status indicating the state/status of the instance
          */
-        void createSession(const TransportRemote& peer_config);
+        Status status();
+
+      private:
+        void init();
 
       private:
         std::mutex _mutex;
         const bool _client_mode;
         std::atomic<bool> _stop{ false };
-        const MoQInstanceServerConfig& _server_config;
-        const MoQInstanceClientConfig& _client_config;
-
+        const MoQInstanceServerConfig _server_config;
+        const MoQInstanceClientConfig _client_config;
+        std::shared_ptr<MoQInstanceDelegate> _delegate;
+        MoQInstanceTransportDelegate _transport_delegate;
 
         // Log handler to use
-        cantina::LoggerPointer logger;
+        cantina::LoggerPointer _logger;
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        std::shared_ptr<MetricsExporter> _mexport;
+        MetricsExporter _mexport;
 #endif
-    };
 
-    /**
-     * @brief MOQ Instance Transport Delegate
-     * @details MOQ implements the transport delegate, which is shared by all sessions
-     */
-    class MoQInstanceTransportDelegate : public ITransport::TransportDelegate
-    {
-      public:
-        MoQInstanceTransportDelegate(const MoQInstance& moq_instance, const cantina::LoggerPointer& logger) :
-           _moq_instance(moq_instance)
-           , _logger(std::make_shared<cantina::Logger>("MOQ_ITD", logger))
-        {}
+        std::shared_ptr<ITransport> _transport;
 
-        // -------------------------------------------------------------------------------------------------
-        // Transprot Delegate/callback functions
-        // -------------------------------------------------------------------------------------------------
-
-        void on_new_data_context(const TransportConnId& conn_id, const DataContextId& data_ctx_id) override {}
-        void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) override;
-        void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) override;
-        void on_recv_stream(const TransportConnId& conn_id,
-                            uint64_t stream_id,
-                            std::optional<DataContextId> data_ctx_id,
-                            const bool is_bidir = false) override;
-        void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
-
-      private:
-        cantina::LoggerPointer _logger;
-        const MoQInstance& _moq_instance;
+        std::vector<TransportConnId> _connections;
     };
 
+
 } // namespace quicr
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index f369bcac..5a4e2e3c 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -6,17 +6,58 @@
 
 #pragma once
 
+#include <quicr/moq_messages.h>
+
 namespace quicr {
 
     /**
-     * @brief Delegate for all MOQ/MOQT callbacks and interaction
+     * @brief MOQ/MOQT callbacks
      *
-     * @details A new MOQ instance is created with this delegate as a shared pointer.
-     *   All interaction with the instance is handled via this delegate. This delegate
-     *   is a base class implementation and interface for callbacks.
+     * @details MOQ instance is created and this delegate is passed to the instanct constructor.
+     *    MOQ instance callbacks are defined in this delegate
      */
-
     class MoQInstanceDelegate
-    {};
+    {
+        /**
+         * @brief Notification on new connection
+         * @details Notification that a new connection has been accepted
+         *
+         * @param conn_id          Transport connection ID
+         * @param endpoint_id      Endpoint ID of client connection
+         * @param remote           Transport remote connection information
+         */
+        virtual void cb_newConnection(TransportConnId conn_id,
+                                      const std::span<uint8_t>& endpoint_id,
+                                      const TransportRemote& remote) = 0;
+
+        /**
+         * @brief Notification for connection status/state change
+         * @details Notification indicates state change of connection, such as disconnected
+         *
+         * @param conn_id          Transport connection ID
+         * @param status           Transport status of connection id
+         */
+        virtual void cb_connectionStatus(TransportConnId conn_id,
+                                         TransportStatus status) = 0;
+
+        /**
+         * @brief callback on client setup message
+         * @detais In server mode, client will send a setup message on new connection.
+         *         Server responds with server setup.
+         *
+         * @param conn_id          Transport connection ID
+         * @param client_setup     Decoded client setup message
+         */
+        virtual void cb_clientSetup(TransportConnId conn_id, messages::MoqClientSetup client_setup) = 0;
+
+        /**
+         * @brief callback on server setup message
+         * @details In client mode, server will send sever setup in response to client setup message sent.
+         *
+         * @param conn_id          Transport connection ID
+         * @param server_setup     Decoded sever setup message
+         */
+        virtual void cb_serverSetup(TransportConnId conn_id, messages::MoqServerSetup server_setup) = 0;
+    };
 
 } // namespace quicr
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 68bff007..5b8f2538 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -70,7 +70,7 @@ namespace quicr {
          */
         MoQTrackDelegate(const bytes& track_namespace,
                          const bytes& track_name,
-                         const TrackMode track_mode,
+                         TrackMode track_mode,
                          uint8_t default_priority,
                          uint32_t default_ttl);
 
@@ -211,6 +211,7 @@ namespace quicr {
       private:
         const bytes _track_namespace;
         const bytes _track_name;
+        TrackMode _track_mode;
         std::optional<uint64_t> _track_alias;
     };
 
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index e36196c4..2055fd5f 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -8,4 +8,163 @@
 
 namespace quicr {
 
+    MoQInstance::MoQInstance(const MoQInstanceClientConfig& cfg,
+                            std::shared_ptr<MoQInstanceDelegate> delegate,
+                            const cantina::LoggerPointer& logger) :
+        _client_mode(true)
+        , _server_config({})
+        , _client_config(cfg)
+        , _delegate(std::move(delegate))
+        , _transport_delegate({*this, _logger})
+        , _logger(std::make_shared<cantina::Logger>("MOQ_IC", logger))
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        , _mexport(logger)
+#endif
+        , _transport({})
+    {
+        _logger->info << "Created MoQ instance in client mode connecting to "
+                      << cfg.server_host_ip << ":" << cfg.server_port
+                      << std::flush;
+
+        init();
+    }
+
+    MoQInstance::MoQInstance(const MoQInstanceServerConfig& cfg,
+                             std::shared_ptr<MoQInstanceDelegate> delegate,
+                             const cantina::LoggerPointer& logger)
+      : _client_mode(false)
+      , _server_config(cfg)
+      , _client_config({})
+      , _delegate(std::move(delegate))
+      , _transport_delegate({*this, _logger})
+      , _logger(std::make_shared<cantina::Logger>("MOQ_IS", logger))
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        , _mexport(logger)
+#endif
+      , _transport({})
+    {
+        _logger->info << "Created MoQ instance in server mode listening on "
+                      << cfg.server_bind_ip << ":" << cfg.server_port
+                      << std::flush;
+
+        init();
+    }
+
+    void MoQInstance::init()
+    {
+        _logger->info << "Starting metrics exporter" << std::flush;
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        if (_mexport.init("http://metrics.m10x.ctgpoc.com:8086",
+                         "Media10x",
+                         "cisco-cto-media10x") !=
+            MetricsExporter::MetricsExporterError::NoError) {
+            throw std::runtime_error("Failed to connect to InfluxDB");
+            }
+
+        _mexport.run();
+#endif
+    }
+
+    MoQInstance::Status MoQInstance::run_server()
+    {
+        TransportRemote server { .host_or_ip = _server_config.server_bind_ip,
+                                 .port = _server_config.server_port,
+                                 .proto =  _server_config.server_proto };
+
+        _transport = ITransport::make_server_transport(server, _server_config.transport_config,
+                                                       _transport_delegate, _logger);
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+#else
+        _transport->start(nullptr, nullptr);
+#endif
+
+        switch (_transport->status()) {
+            case TransportStatus::Ready:
+                return Status::READY;
+            default:
+                return Status::NOT_READY;
+        }
+    }
+
+    MoQInstance::Status MoQInstance::run_client()
+    {
+        TransportRemote relay { .host_or_ip = _client_config.server_host_ip,
+                                .port = _client_config.server_port,
+                                .proto =  _client_config.server_proto };
+
+        _transport = ITransport::make_client_transport(relay, _client_config.transport_config,
+                                                       _transport_delegate, _logger);
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+#else
+        _transport->start(nullptr, nullptr);
+#endif
+
+        _connections.push_back(_transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples));
+
+        LOGGER_INFO(_logger, "Connecting session conn_id: " << _connections.front() << "...");
+
+        while (!_stop && _transport->status() == TransportStatus::Connecting) {
+            LOGGER_DEBUG(_logger, "Connecting... " << int(_stop.load()));
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+
+        if (_stop || !_transport) {
+            LOGGER_INFO(_logger, "Cancelling connecting session " << _connections.front());
+            return Status::CLIENT_FAILED_TO_CONNECT;
+        }
+
+        if (_transport->status() != TransportStatus::Ready) {
+            _logger->error << "Failed to connect status: " << static_cast<int>(_transport->status()) << std::flush;
+
+            return Status::CLIENT_FAILED_TO_CONNECT;
+        }
+
+        return Status::READY;
+    }
+
+
+    void MoQInstanceTransportDelegate::on_connection_status(const TransportConnId& conn_id, const TransportStatus status)
+    {
+        _logger->info << "Connection status conn_id: " << conn_id
+                      << " status: " << static_cast<int>(status)
+                      << std::flush;
+
+        _moq_instance.status();
+    }
+
+    void MoQInstanceTransportDelegate::on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote)
+    {
+        _logger->info << "New connection conn_id: " << conn_id
+                      << " remote ip: " << remote.host_or_ip
+                      << " port: " << remote.port
+                      << std::flush;
+
+    }
+
+    void MoQInstanceTransportDelegate::on_recv_stream(const TransportConnId& conn_id,
+                        uint64_t stream_id,
+                        std::optional<DataContextId> data_ctx_id,
+                        const bool is_bidir)
+    {
+        _logger->info << "stream data conn_id: " << conn_id
+                      << " stream_id: " << stream_id
+                      << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
+                      << " is_bidir: " << is_bidir
+                      << std::flush;
+    }
+
+    void MoQInstanceTransportDelegate::on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id)
+    {
+        _logger->info << "datagram data conn_id: " << conn_id
+                      << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
+                      << std::flush;
+
+    }
+
+
 } // namespace quicr

From 4bb9a687854531ba9272ceb52ffa0cb0a026f6be Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 6 Jun 2024 21:14:11 -0700
Subject: [PATCH 28/71] moq-example

---
 cmd/moq-example/CMakeLists.txt   |  35 +++++
 cmd/moq-example/client.cpp       | 252 +++++++++++++++++++++++++++++++
 cmd/moq-example/server.cpp       | 178 ++++++++++++++++++++++
 cmd/moq-example/subscription.cpp |  63 ++++++++
 cmd/moq-example/subscription.h   |  44 ++++++
 5 files changed, 572 insertions(+)
 create mode 100644 cmd/moq-example/CMakeLists.txt
 create mode 100644 cmd/moq-example/client.cpp
 create mode 100644 cmd/moq-example/server.cpp
 create mode 100644 cmd/moq-example/subscription.cpp
 create mode 100644 cmd/moq-example/subscription.h

diff --git a/cmd/moq-example/CMakeLists.txt b/cmd/moq-example/CMakeLists.txt
new file mode 100644
index 00000000..d80a6112
--- /dev/null
+++ b/cmd/moq-example/CMakeLists.txt
@@ -0,0 +1,35 @@
+add_executable(qserver
+        server.cpp
+        subscription.cpp)
+target_link_libraries(qserver PRIVATE quicr)
+
+target_compile_options(qserver
+        PRIVATE
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>: -Wpedantic -Wextra -Wall>
+        $<$<CXX_COMPILER_ID:MSVC>: >)
+
+set_target_properties(qserver
+        PROPERTIES
+        CXX_STANDARD 20
+        CXX_STANDARD_REQUIRED YES
+        CXX_EXTENSIONS ON)
+
+if(CLANG_TIDY_EXE)
+  set_target_properties(quicr PROPERTIES CXX_CLANG_TIDY "${CLANG_TIDY_EXE}")
+endif()
+
+
+add_executable(qclient client.cpp )
+
+target_link_libraries(qclient LINK_PUBLIC quicr)
+
+target_compile_options(qclient
+        PRIVATE
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>: -Wpedantic -Wextra -Wall>
+        $<$<CXX_COMPILER_ID:MSVC>: >)
+
+set_target_properties(qclient
+        PROPERTIES
+        CXX_STANDARD 20
+        CXX_STANDARD_REQUIRED YES
+        CXX_EXTENSIONS OFF)
diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
new file mode 100644
index 00000000..1742d3f3
--- /dev/null
+++ b/cmd/moq-example/client.cpp
@@ -0,0 +1,252 @@
+#include <cantina/logger.h>
+#include <quicr/quicr_client.h>
+#include <quicr/quicr_common.h>
+#include <transport/transport.h>
+
+#include <chrono>
+#include <iostream>
+#include <sstream>
+#include <thread>
+
+class subDelegate : public quicr::SubscriberDelegate
+{
+public:
+  explicit subDelegate(cantina::LoggerPointer& logger)
+    : logger(std::make_shared<cantina::Logger>("SDEL", logger))
+  {
+  }
+
+  void onSubscribeResponse(
+    [[maybe_unused]] const quicr::Namespace& quicr_namespace,
+    [[maybe_unused]] const quicr::SubscribeResult& result) override
+  {
+    logger->info << "onSubscriptionResponse: name: " << quicr_namespace << "/"
+                 << int(quicr_namespace.length())
+                 << " status: " << static_cast<unsigned>(result.status)
+                 << std::flush;
+  }
+
+  void onSubscriptionEnded(
+    [[maybe_unused]] const quicr::Namespace& quicr_namespace,
+    [[maybe_unused]] const quicr::SubscribeResult::SubscribeStatus& reason)
+    override
+  {
+    logger->info << "onSubscriptionEnded: name: " << quicr_namespace << "/"
+                 << static_cast<unsigned>(quicr_namespace.length())
+                 << std::flush;
+  }
+
+  void onSubscribedObject([[maybe_unused]] const quicr::Name& quicr_name,
+                          [[maybe_unused]] uint8_t priority,
+                          [[maybe_unused]] quicr::bytes&& data) override
+  {
+    logger->info << "recv object: name: " << quicr_name
+                 << " data sz: " << data.size();
+
+    if (!data.empty()) {
+      logger->info << " data: " << data.data();
+    }
+
+    logger->info << std::flush;
+  }
+
+  void onSubscribedObjectFragment(
+    [[maybe_unused]] const quicr::Name& quicr_name,
+    [[maybe_unused]] uint8_t priority,
+    [[maybe_unused]] const uint64_t& offset,
+    [[maybe_unused]] bool is_last_fragment,
+    [[maybe_unused]] quicr::bytes&& data) override
+  {
+  }
+
+private:
+  cantina::LoggerPointer logger;
+};
+
+class pubDelegate : public quicr::PublisherDelegate
+{
+public:
+  std::atomic<bool> got_intent_response { false };
+
+  explicit pubDelegate(cantina::LoggerPointer& logger)
+    : logger(std::make_shared<cantina::Logger>("PDEL", logger))
+  {
+  }
+
+  void onPublishIntentResponse(
+    const quicr::Namespace& quicr_namespace,
+    const quicr::PublishIntentResult& result) override
+  {
+    LOGGER_INFO(logger,
+                "Received PublishIntentResponse for "
+                  << quicr_namespace << ": "
+                  << static_cast<int>(result.status));
+    got_intent_response = true;
+  }
+
+private:
+  cantina::LoggerPointer logger;
+};
+
+int do_publisher(cantina::LoggerPointer logger,
+                 quicr::Client& client,
+                 std::shared_ptr<pubDelegate> pd,
+                 quicr::Name name) {
+
+    auto nspace = quicr::Namespace(name, 96);
+    logger->info << "Publish Intent for name: " << name
+                 << " == namespace: " << nspace << std::flush;
+
+    client.publishIntent(pd, nspace, {}, {}, {}, quicr::TransportMode::ReliablePerGroup, 2);
+    logger->info << "Waiting for intent response, up to 2.5 seconds" << std::flush;
+
+    for (int c=0; c < 50; c++) {
+      if (pd->got_intent_response) {
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds (50));
+    }
+
+    if (!pd->got_intent_response) {
+      logger->info << "Did not receive publish intent, cannot proceed. Exit" << std::flush;
+      return -1;
+    }
+
+    logger->info << "Received intent response." << std::flush;
+
+    std::cout << "-----------------------------------------------------------------------" << std::endl;
+    std::cout << " Type a message and press ENTER to publish. Type the word exit to end program." << std::flush;
+    std::cout << "-----------------------------------------------------------------------" << std::endl;
+
+    while (true) {
+      std::string msg;
+      getline(std::cin, msg);
+      if (!msg.compare("exit")) {
+        logger->info << "Exit" << std::flush;
+        break;
+      }
+
+      logger->info << "Publish: " << msg << std::flush;
+      std::vector<uint8_t> m_data(msg.begin(), msg.end());
+
+      std::vector<qtransport::MethodTraceItem> trace;
+      const auto start_time = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
+
+      trace.push_back({"client:publish", start_time});
+
+      client.publishNamedObject(name++, 0, 1000, std::move(m_data), std::move(trace));
+    }
+
+    return 0;
+}
+
+int do_subscribe(cantina::LoggerPointer logger,
+                 quicr::Client& client,
+                 quicr::Name name) {
+
+    auto sd = std::make_shared<subDelegate>(logger);
+    auto nspace = quicr::Namespace(name, 96);
+
+    logger->info << "Subscribe to " << name << "/" << 96 << std::flush;
+
+    client.subscribe(sd,
+                     nspace,
+                     quicr::SubscribeIntent::immediate,
+                     quicr::TransportMode::ReliablePerGroup,
+                     "origin_url",
+                     "auth_token",
+                     quicr::bytes{});
+
+    logger->info << "Type exit to end program" << std::flush;
+    while (true) {
+      std::string msg;
+      getline(std::cin, msg);
+      if (!msg.compare("exit")) {
+        logger->info << "Exit" << std::flush;
+        break;
+      }
+    }
+
+
+    logger->Log("Now unsubscribing");
+    client.unsubscribe(nspace, {}, {});
+
+    logger->Log("Sleeping for 5 seconds before exiting");
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+
+    return 0;
+}
+
+int
+main(int argc, char* argv[])
+{
+  cantina::LoggerPointer logger =
+  std::make_shared<cantina::Logger>("reallyTest");
+
+  if ((argc != 2) && (argc != 3)) {
+    std::cerr
+      << "Relay address and port set in REALLY_RELAY and REALLY_PORT env "
+         "variables."
+      << std::endl;
+    std::cerr << std::endl;
+    std::cerr << "Usage PUB: reallyTest FF0001 pub" << std::endl;
+    std::cerr << "Usage SUB: reallyTest FF0000" << std::endl;
+    exit(-1); // NOLINT(concurrency-mt-unsafe)
+  }
+
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
+  const auto* relayName = getenv("REALLY_RELAY");
+  if (relayName == nullptr) {
+    relayName = "127.0.0.1";
+  }
+
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
+  const auto* portVar = getenv("REALLY_PORT");
+  int port = 1234;
+  if (portVar != nullptr) {
+    port = atoi(portVar); // NOLINT(cert-err34-c)
+  }
+
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  auto name = quicr::Name(std::string(argv[1]));
+
+  logger->info << "Name = " << name << std::flush;
+
+  auto data = std::vector<uint8_t>{};
+  if (argc == 3) {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    const auto data_str = std::string(argv[2]);
+    data.insert(data.end(), data_str.begin(), data_str.end());
+  }
+
+  logger->info << "Connecting to " << relayName << ":" << port << std::flush;
+
+  const auto relay =
+    quicr::RelayInfo{ .hostname = relayName,
+                      .port = uint16_t(port),
+                      .proto = quicr::RelayInfo::Protocol::QUIC };
+
+  const auto tcfg = qtransport::TransportConfig{
+    .tls_cert_filename = nullptr,
+    .tls_key_filename = nullptr,
+  };
+
+  quicr::Client client(relay, "a@cisco.com", 0, tcfg, logger);
+  auto pd = std::make_shared<pubDelegate>(logger);
+
+  if (!client.connect()) {
+    logger->Log(cantina::LogLevel::Critical, "Transport connect failed");
+    return 0;
+  }
+
+  if (!data.empty()) {
+    if (do_publisher(logger, client, pd, name))
+      return -1;
+
+  } else {
+    if (do_subscribe(logger, client, name))
+      return -1;
+  }
+
+  return 0;
+}
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
new file mode 100644
index 00000000..de2cd7f8
--- /dev/null
+++ b/cmd/moq-example/server.cpp
@@ -0,0 +1,178 @@
+
+#include <quicr/moq_instance.h>
+
+#include <cantina/logger.h>
+#include <condition_variable>
+#include <csignal>
+
+#include "subscription.h"
+
+
+// Module-level variables used to control program execution
+namespace moq_server {
+    static std::mutex main_mutex;                     // Main's mutex
+    static bool terminate{ false };                   // Termination flag
+    static std::condition_variable cv;                // Main thread waits on this
+    static const char* termination_reason{ nullptr }; // Termination reason
+}
+
+/*
+ *  signalHandler
+ *
+ *  Description:
+ *      This function will handle operating system signals related to
+ *      termination and then instruct the main thread to terminate.
+ *
+ *  Parameters:
+ *      signal_number [in]
+ *          The signal caught.
+ *
+ *  Returns:
+ *      Nothing.
+ *
+ *  Comments:
+ *      None.
+ */
+void
+signalHandler(int signal_number)
+{
+    const auto lock = std::lock_guard<std::mutex>(moq_server::main_mutex);
+
+    // If termination is in process, just return
+    if (moq_server::terminate) {
+        return;
+    }
+
+    // Indicate that the process should terminate
+    moq_server::terminate = true;
+
+    // Set the termination reason string
+    switch (signal_number) {
+        case SIGINT:
+            moq_server::termination_reason = "Interrupt signal received";
+            break;
+
+#ifndef _WIN32
+        case SIGHUP:
+            moq_server::termination_reason = "Hangup signal received";
+            break;
+
+        case SIGQUIT:
+            moq_server::termination_reason = "Quit signal received";
+            break;
+#endif
+
+        default:
+            moq_server::termination_reason = "Unknown signal received";
+            break;
+    }
+
+    // Notify the main execution thread to terminate
+    moq_server::cv.notify_one();
+}
+
+/*
+ *  installSignalHandlers
+ *
+ *  Description:
+ *      This function will install the signal handlers for SIGINT, SIGQUIT,
+ *      etc. so that the process can be terminated in a controlled fashion.
+ *
+ *  Parameters:
+ *      None.
+ *
+ *  Returns:
+ *      Nothing.
+ *
+ *  Comments:
+ *      None.
+ */
+void
+installSignalHandlers()
+{
+#ifdef _WIN32
+    if (signal(SIGINT, signalHandler) == SIG_ERR) {
+        std::cerr << "Failed to install SIGINT handler" << std::endl;
+    }
+#else
+    struct sigaction sa = {};
+
+    // Configure the sigaction struct
+    sa.sa_handler = signalHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+
+    // Catch SIGHUP (signal 1)
+    if (sigaction(SIGHUP, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGHUP handler" << std::endl;
+    }
+
+    // Catch SIGINT (signal 2)
+    if (sigaction(SIGINT, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGINT handler" << std::endl;
+    }
+
+    // Catch SIGQUIT (signal 3)
+    if (sigaction(SIGQUIT, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGQUIT handler" << std::endl;
+    }
+#endif
+}
+
+class serverDelegate : public quicr::MoQInstanceDelegate
+{
+    void cb_newConnection(qtransport::TransportConnId conn_id,
+                          const std::span<uint8_t>& endpoint_id,
+                          const qtransport::TransportRemote& remote) override {}
+    void cb_connectionStatus(qtransport::TransportConnId conn_id, qtransport::TransportStatus status) override {}
+    void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
+    void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
+};
+
+int
+main()
+{
+    int result_code = EXIT_SUCCESS;
+
+    // Install a signal handlers to catch operating system signals
+    installSignalHandlers();
+
+    // Lock the mutex so that main can then wait on it
+    std::unique_lock<std::mutex> lock(moq_server::main_mutex);
+
+    quicr::MoQInstanceServerConfig config;
+    config.instance_id = "moq_server";
+    config.server_bind_ip = "127.0.0.1";
+    config.server_port = 1234;
+    config.server_proto = qtransport::TransportProtocol::QUIC;
+    config.transport_config.debug = true;
+    config.transport_config.tls_cert_filename = "./server-cert.pem";
+    config.transport_config.tls_key_filename = "./server-key.pem";
+
+    auto logger = std::make_shared<cantina::Logger>("moq_server");
+
+    auto delegate = std::make_shared<serverDelegate>();
+
+    try {
+        auto moqInstance = quicr::MoQInstance{config, delegate, logger};
+
+        moqInstance.run_server();
+
+        // Wait until told to terminate
+        moq_server::cv.wait(lock, [&]() { return moq_server::terminate; });
+
+        // Unlock the mutex
+        lock.unlock();
+    } catch (const std::invalid_argument& e) {
+        std::cerr << "Invalid argument: " << e.what() << std::endl;
+        result_code = EXIT_FAILURE;
+    } catch (const std::exception& e) {
+        std::cerr << "Unexpected exception: " << e.what() << std::endl;
+        result_code = EXIT_FAILURE;
+    } catch (...) {
+        std::cerr << "Unexpected exception" << std::endl;
+        result_code = EXIT_FAILURE;
+    }
+
+    return result_code;
+}
diff --git a/cmd/moq-example/subscription.cpp b/cmd/moq-example/subscription.cpp
new file mode 100644
index 00000000..80b782ef
--- /dev/null
+++ b/cmd/moq-example/subscription.cpp
@@ -0,0 +1,63 @@
+#include "subscription.h"
+
+Subscriptions::Subscriptions()
+{
+  subscriptions.resize(129 /* 128 + 1 to handle zero and 128 */);
+}
+
+void
+Subscriptions::add(const quicr::Name& name, uint8_t len, const Remote& remote)
+{
+
+  const auto prefix = quicr::Namespace{ name, len };
+
+  auto mapPtr = subscriptions[len].find(prefix.name());
+  if (mapPtr == subscriptions[len].end()) {
+    std::set<Remote> list;
+    list.insert(remote);
+    std::pair<quicr::Name, std::set<Remote>> pair;
+    pair = make_pair(prefix.name(), list);
+    subscriptions[len].insert(pair);
+  } else {
+    auto& list = mapPtr->second;
+    if (list.find(remote) == list.end()) {
+      list.insert(
+        remote); // TODO(trigaux) - rethink if list is right thing here
+    }
+  }
+}
+
+void
+Subscriptions::remove(const quicr::Name& name,
+                      uint8_t len,
+                      const Remote& remote)
+{
+  const auto prefix = quicr::Namespace{ name, len };
+
+  auto mapPtr = subscriptions[len].find(prefix.name());
+  if (mapPtr != subscriptions[len].end()) {
+    auto& list = mapPtr->second;
+    if (list.find(remote) == list.end()) {
+      list.erase(remote);
+    }
+  }
+}
+
+std::list<Subscriptions::Remote>
+Subscriptions::find(const quicr::Name& name)
+{
+  std::list<Remote> all_remotes;
+
+  // TODO(trigaux): Fix this to not have to iterate for each mask bit
+  for (uint8_t len = 0; len <= 128; len++) {
+    const auto prefix = quicr::Namespace{ name, len };
+
+    auto mapPtr = subscriptions[len].find(prefix.name());
+    if (mapPtr != subscriptions[len].end()) {
+      const auto& list = mapPtr->second;
+      all_remotes.insert(all_remotes.end(), list.begin(), list.end());
+    }
+  }
+
+  return all_remotes;
+}
diff --git a/cmd/moq-example/subscription.h b/cmd/moq-example/subscription.h
new file mode 100644
index 00000000..a31e23a4
--- /dev/null
+++ b/cmd/moq-example/subscription.h
@@ -0,0 +1,44 @@
+#include <list>
+#include <map>
+#include <optional>
+#include <set>
+#include <vector>
+
+#include <qname>
+#include <transport/transport.h>
+
+class Subscriptions
+{
+public:
+  struct Remote
+  {
+    uint64_t subscribe_id {0};
+    uint64_t conn_id {0};           /// Connection ID is used only for detecting if subscription is to the same connection
+
+    bool operator==(const Remote& o) const
+    {
+      return subscribe_id == o.subscribe_id;
+    }
+
+    bool operator<(const Remote& o) const
+    {
+      return std::tie(subscribe_id) <
+             std::tie(o.subscribe_id);
+    }
+  };
+
+  Subscriptions();
+
+  void get_masked_quicRName(const quicr::Name& src,
+                            quicr::Name& dst,
+                            const int len);
+
+  void add(const quicr::Name& name, uint8_t len, const Remote& remote);
+
+  void remove(const quicr::Name& name, uint8_t len, const Remote& remote);
+
+  std::list<Remote> find(const quicr::Name& name);
+
+private:
+  std::vector<std::map<quicr::Name, std::set<Remote>>> subscriptions;
+};

From d5a08d13a31cd1d0920b9887177396d7212ba4b2 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 7 Jun 2024 16:51:58 -0700
Subject: [PATCH 29/71] Initial moq-example and instance implementation

---
 cmd/CMakeLists.txt                    |   1 -
 cmd/moq-example/CMakeLists.txt        |  17 +-
 cmd/moq-example/client.cpp            | 288 ++++++--------------------
 cmd/moq-example/server.cpp            | 123 +----------
 cmd/moq-example/subscription.h        |   2 +
 include/quicr/moq_instance.h          | 100 ++++-----
 include/quicr/moq_instance_delegate.h |   2 +
 include/quicr/moq_messages.h          |  47 +++--
 src/moq_instance.cpp                  | 128 ++++++++----
 src/moq_messages.cpp                  |  41 ++--
 test/moq_messages.cpp                 |  50 ++---
 11 files changed, 304 insertions(+), 495 deletions(-)

diff --git a/cmd/CMakeLists.txt b/cmd/CMakeLists.txt
index 5d66703c..d3d3a2b5 100644
--- a/cmd/CMakeLists.txt
+++ b/cmd/CMakeLists.txt
@@ -1,4 +1,3 @@
 #add_subdirectory(qcurl)
 add_subdirectory(really)
 add_subdirectory(moq-example)
-
diff --git a/cmd/moq-example/CMakeLists.txt b/cmd/moq-example/CMakeLists.txt
index d80a6112..7e3457b6 100644
--- a/cmd/moq-example/CMakeLists.txt
+++ b/cmd/moq-example/CMakeLists.txt
@@ -1,8 +1,15 @@
+
 add_executable(qserver
         server.cpp
         subscription.cpp)
 target_link_libraries(qserver PRIVATE quicr)
 
+if(NOT LIBQUICR_WITHOUT_INFLUXDB)
+  target_link_libraries(qserver
+          PRIVATE InfluxData::InfluxDB)
+endif()
+
+
 target_compile_options(qserver
         PRIVATE
         $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>: -Wpedantic -Wextra -Wall>
@@ -19,15 +26,21 @@ if(CLANG_TIDY_EXE)
 endif()
 
 
-add_executable(qclient client.cpp )
+add_executable(qclient client.cpp)
 
-target_link_libraries(qclient LINK_PUBLIC quicr)
+target_link_libraries(qclient PRIVATE quicr)
+
+if(NOT LIBQUICR_WITHOUT_INFLUXDB)
+  target_link_libraries(qclient
+          PRIVATE InfluxData::InfluxDB)
+endif()
 
 target_compile_options(qclient
         PRIVATE
         $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>: -Wpedantic -Wextra -Wall>
         $<$<CXX_COMPILER_ID:MSVC>: >)
 
+
 set_target_properties(qclient
         PROPERTIES
         CXX_STANDARD 20
diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 1742d3f3..623c0f14 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -1,252 +1,90 @@
-#include <cantina/logger.h>
-#include <quicr/quicr_client.h>
-#include <quicr/quicr_common.h>
-#include <transport/transport.h>
+
+#include <quicr/moq_instance.h>
+
+#include "signal_handler.h"
 
 #include <chrono>
 #include <iostream>
-#include <sstream>
 #include <thread>
 
-class subDelegate : public quicr::SubscriberDelegate
+class clientDelegate : public quicr::MoQInstanceDelegate
 {
-public:
-  explicit subDelegate(cantina::LoggerPointer& logger)
-    : logger(std::make_shared<cantina::Logger>("SDEL", logger))
-  {
-  }
-
-  void onSubscribeResponse(
-    [[maybe_unused]] const quicr::Namespace& quicr_namespace,
-    [[maybe_unused]] const quicr::SubscribeResult& result) override
-  {
-    logger->info << "onSubscriptionResponse: name: " << quicr_namespace << "/"
-                 << int(quicr_namespace.length())
-                 << " status: " << static_cast<unsigned>(result.status)
-                 << std::flush;
-  }
-
-  void onSubscriptionEnded(
-    [[maybe_unused]] const quicr::Namespace& quicr_namespace,
-    [[maybe_unused]] const quicr::SubscribeResult::SubscribeStatus& reason)
-    override
-  {
-    logger->info << "onSubscriptionEnded: name: " << quicr_namespace << "/"
-                 << static_cast<unsigned>(quicr_namespace.length())
-                 << std::flush;
-  }
-
-  void onSubscribedObject([[maybe_unused]] const quicr::Name& quicr_name,
-                          [[maybe_unused]] uint8_t priority,
-                          [[maybe_unused]] quicr::bytes&& data) override
-  {
-    logger->info << "recv object: name: " << quicr_name
-                 << " data sz: " << data.size();
-
-    if (!data.empty()) {
-      logger->info << " data: " << data.data();
-    }
-
-    logger->info << std::flush;
-  }
-
-  void onSubscribedObjectFragment(
-    [[maybe_unused]] const quicr::Name& quicr_name,
-    [[maybe_unused]] uint8_t priority,
-    [[maybe_unused]] const uint64_t& offset,
-    [[maybe_unused]] bool is_last_fragment,
-    [[maybe_unused]] quicr::bytes&& data) override
-  {
-  }
-
-private:
-  cantina::LoggerPointer logger;
+    void cb_newConnection(qtransport::TransportConnId conn_id,
+                          const std::span<uint8_t>& endpoint_id,
+                          const qtransport::TransportRemote& remote) override {}
+    void cb_connectionStatus(qtransport::TransportConnId conn_id, qtransport::TransportStatus status) override {}
+    void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
+    void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
 };
 
-class pubDelegate : public quicr::PublisherDelegate
+int
+main(int argc, char* argv[])
 {
-public:
-  std::atomic<bool> got_intent_response { false };
-
-  explicit pubDelegate(cantina::LoggerPointer& logger)
-    : logger(std::make_shared<cantina::Logger>("PDEL", logger))
-  {
-  }
-
-  void onPublishIntentResponse(
-    const quicr::Namespace& quicr_namespace,
-    const quicr::PublishIntentResult& result) override
-  {
-    LOGGER_INFO(logger,
-                "Received PublishIntentResponse for "
-                  << quicr_namespace << ": "
-                  << static_cast<int>(result.status));
-    got_intent_response = true;
-  }
-
-private:
-  cantina::LoggerPointer logger;
-};
+    int result_code = EXIT_SUCCESS;
 
-int do_publisher(cantina::LoggerPointer logger,
-                 quicr::Client& client,
-                 std::shared_ptr<pubDelegate> pd,
-                 quicr::Name name) {
+    cantina::LoggerPointer logger = std::make_shared<cantina::Logger>("qclient");
+    logger->SetLogLevel("DEBUG");
 
-    auto nspace = quicr::Namespace(name, 96);
-    logger->info << "Publish Intent for name: " << name
-                 << " == namespace: " << nspace << std::flush;
-
-    client.publishIntent(pd, nspace, {}, {}, {}, quicr::TransportMode::ReliablePerGroup, 2);
-    logger->info << "Waiting for intent response, up to 2.5 seconds" << std::flush;
+    if ((argc != 2) && (argc != 3)) {
+        std::cerr << "Relay address and port set in MOQ_RELAY and MOQ_PORT env variables." << std::endl;
+        std::cerr << std::endl;
+        std::cerr << "Usage publisher: qclient pub <track_namespace> <track_name>" << std::endl;
+        std::cerr << "Usage subscriber: qclient <track_namespace> <track_name>" << std::endl;
+        exit(-1); // NOLINT(concurrency-mt-unsafe)
+    }
 
-    for (int c=0; c < 50; c++) {
-      if (pd->got_intent_response) {
-        break;
-      }
-      std::this_thread::sleep_for(std::chrono::milliseconds (50));
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    const auto* relayName = getenv("MOQ_RELAY");
+    if (relayName == nullptr) {
+        relayName = "127.0.0.1";
     }
 
-    if (!pd->got_intent_response) {
-      logger->info << "Did not receive publish intent, cannot proceed. Exit" << std::flush;
-      return -1;
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    const auto* portVar = getenv("MOQ_PORT");
+    int port = 1234;
+    if (portVar != nullptr) {
+        port = atoi(portVar); // NOLINT(cert-err34-c)
     }
 
-    logger->info << "Received intent response." << std::flush;
+    // Install a signal handlers to catch operating system signals
+    installSignalHandlers();
 
-    std::cout << "-----------------------------------------------------------------------" << std::endl;
-    std::cout << " Type a message and press ENTER to publish. Type the word exit to end program." << std::flush;
-    std::cout << "-----------------------------------------------------------------------" << std::endl;
+    // Lock the mutex so that main can then wait on it
+    std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
-    while (true) {
-      std::string msg;
-      getline(std::cin, msg);
-      if (!msg.compare("exit")) {
-        logger->info << "Exit" << std::flush;
-        break;
-      }
+    quicr::MoQInstanceClientConfig config;
+    config.instance_id = "moq_client";
+    config.server_host_ip = "127.0.0.1";
+    config.server_port = 1234;
+    config.server_proto = qtransport::TransportProtocol::QUIC;
+    config.transport_config.debug = true;
+    config.transport_config.use_reset_wait_strategy = false;
+    config.transport_config.time_queue_max_duration = 5000;
 
-      logger->info << "Publish: " << msg << std::flush;
-      std::vector<uint8_t> m_data(msg.begin(), msg.end());
+    auto delegate = std::make_shared<clientDelegate>();
 
-      std::vector<qtransport::MethodTraceItem> trace;
-      const auto start_time = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
+    try {
+        auto moqInstance = quicr::MoQInstance{config, delegate, logger};
 
-      trace.push_back({"client:publish", start_time});
+        moqInstance.run_client();
 
-      client.publishNamedObject(name++, 0, 1000, std::move(m_data), std::move(trace));
-    }
+        // Wait until told to terminate
+        moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
 
-    return 0;
-}
+        logger->info << "Client done" << std::endl;
 
-int do_subscribe(cantina::LoggerPointer logger,
-                 quicr::Client& client,
-                 quicr::Name name) {
-
-    auto sd = std::make_shared<subDelegate>(logger);
-    auto nspace = quicr::Namespace(name, 96);
-
-    logger->info << "Subscribe to " << name << "/" << 96 << std::flush;
-
-    client.subscribe(sd,
-                     nspace,
-                     quicr::SubscribeIntent::immediate,
-                     quicr::TransportMode::ReliablePerGroup,
-                     "origin_url",
-                     "auth_token",
-                     quicr::bytes{});
-
-    logger->info << "Type exit to end program" << std::flush;
-    while (true) {
-      std::string msg;
-      getline(std::cin, msg);
-      if (!msg.compare("exit")) {
-        logger->info << "Exit" << std::flush;
-        break;
-      }
+        // Unlock the mutex
+        lock.unlock();
+    } catch (const std::invalid_argument& e) {
+        std::cerr << "Invalid argument: " << e.what() << std::endl;
+        result_code = EXIT_FAILURE;
+    } catch (const std::exception& e) {
+        std::cerr << "Unexpected exception: " << e.what() << std::endl;
+        result_code = EXIT_FAILURE;
+    } catch (...) {
+        std::cerr << "Unexpected exception" << std::endl;
+        result_code = EXIT_FAILURE;
     }
 
-
-    logger->Log("Now unsubscribing");
-    client.unsubscribe(nspace, {}, {});
-
-    logger->Log("Sleeping for 5 seconds before exiting");
-    std::this_thread::sleep_for(std::chrono::seconds(5));
-
-    return 0;
-}
-
-int
-main(int argc, char* argv[])
-{
-  cantina::LoggerPointer logger =
-  std::make_shared<cantina::Logger>("reallyTest");
-
-  if ((argc != 2) && (argc != 3)) {
-    std::cerr
-      << "Relay address and port set in REALLY_RELAY and REALLY_PORT env "
-         "variables."
-      << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "Usage PUB: reallyTest FF0001 pub" << std::endl;
-    std::cerr << "Usage SUB: reallyTest FF0000" << std::endl;
-    exit(-1); // NOLINT(concurrency-mt-unsafe)
-  }
-
-  // NOLINTNEXTLINE(concurrency-mt-unsafe)
-  const auto* relayName = getenv("REALLY_RELAY");
-  if (relayName == nullptr) {
-    relayName = "127.0.0.1";
-  }
-
-  // NOLINTNEXTLINE(concurrency-mt-unsafe)
-  const auto* portVar = getenv("REALLY_PORT");
-  int port = 1234;
-  if (portVar != nullptr) {
-    port = atoi(portVar); // NOLINT(cert-err34-c)
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-  auto name = quicr::Name(std::string(argv[1]));
-
-  logger->info << "Name = " << name << std::flush;
-
-  auto data = std::vector<uint8_t>{};
-  if (argc == 3) {
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-    const auto data_str = std::string(argv[2]);
-    data.insert(data.end(), data_str.begin(), data_str.end());
-  }
-
-  logger->info << "Connecting to " << relayName << ":" << port << std::flush;
-
-  const auto relay =
-    quicr::RelayInfo{ .hostname = relayName,
-                      .port = uint16_t(port),
-                      .proto = quicr::RelayInfo::Protocol::QUIC };
-
-  const auto tcfg = qtransport::TransportConfig{
-    .tls_cert_filename = nullptr,
-    .tls_key_filename = nullptr,
-  };
-
-  quicr::Client client(relay, "a@cisco.com", 0, tcfg, logger);
-  auto pd = std::make_shared<pubDelegate>(logger);
-
-  if (!client.connect()) {
-    logger->Log(cantina::LogLevel::Critical, "Transport connect failed");
-    return 0;
-  }
-
-  if (!data.empty()) {
-    if (do_publisher(logger, client, pd, name))
-      return -1;
-
-  } else {
-    if (do_subscribe(logger, client, name))
-      return -1;
-  }
-
-  return 0;
+    return result_code;
 }
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index de2cd7f8..ff5ec72a 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -5,119 +5,9 @@
 #include <condition_variable>
 #include <csignal>
 
-#include "subscription.h"
-
-
-// Module-level variables used to control program execution
-namespace moq_server {
-    static std::mutex main_mutex;                     // Main's mutex
-    static bool terminate{ false };                   // Termination flag
-    static std::condition_variable cv;                // Main thread waits on this
-    static const char* termination_reason{ nullptr }; // Termination reason
-}
-
-/*
- *  signalHandler
- *
- *  Description:
- *      This function will handle operating system signals related to
- *      termination and then instruct the main thread to terminate.
- *
- *  Parameters:
- *      signal_number [in]
- *          The signal caught.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *      None.
- */
-void
-signalHandler(int signal_number)
-{
-    const auto lock = std::lock_guard<std::mutex>(moq_server::main_mutex);
-
-    // If termination is in process, just return
-    if (moq_server::terminate) {
-        return;
-    }
+#include "signal_handler.h"
 
-    // Indicate that the process should terminate
-    moq_server::terminate = true;
-
-    // Set the termination reason string
-    switch (signal_number) {
-        case SIGINT:
-            moq_server::termination_reason = "Interrupt signal received";
-            break;
-
-#ifndef _WIN32
-        case SIGHUP:
-            moq_server::termination_reason = "Hangup signal received";
-            break;
-
-        case SIGQUIT:
-            moq_server::termination_reason = "Quit signal received";
-            break;
-#endif
-
-        default:
-            moq_server::termination_reason = "Unknown signal received";
-            break;
-    }
-
-    // Notify the main execution thread to terminate
-    moq_server::cv.notify_one();
-}
-
-/*
- *  installSignalHandlers
- *
- *  Description:
- *      This function will install the signal handlers for SIGINT, SIGQUIT,
- *      etc. so that the process can be terminated in a controlled fashion.
- *
- *  Parameters:
- *      None.
- *
- *  Returns:
- *      Nothing.
- *
- *  Comments:
- *      None.
- */
-void
-installSignalHandlers()
-{
-#ifdef _WIN32
-    if (signal(SIGINT, signalHandler) == SIG_ERR) {
-        std::cerr << "Failed to install SIGINT handler" << std::endl;
-    }
-#else
-    struct sigaction sa = {};
-
-    // Configure the sigaction struct
-    sa.sa_handler = signalHandler;
-    sigemptyset(&sa.sa_mask);
-    sa.sa_flags = 0;
-
-    // Catch SIGHUP (signal 1)
-    if (sigaction(SIGHUP, &sa, nullptr) == -1) {
-        std::cerr << "Failed to install SIGHUP handler" << std::endl;
-    }
-
-    // Catch SIGINT (signal 2)
-    if (sigaction(SIGINT, &sa, nullptr) == -1) {
-        std::cerr << "Failed to install SIGINT handler" << std::endl;
-    }
-
-    // Catch SIGQUIT (signal 3)
-    if (sigaction(SIGQUIT, &sa, nullptr) == -1) {
-        std::cerr << "Failed to install SIGQUIT handler" << std::endl;
-    }
-#endif
-}
+#include "subscription.h"
 
 class serverDelegate : public quicr::MoQInstanceDelegate
 {
@@ -134,11 +24,14 @@ main()
 {
     int result_code = EXIT_SUCCESS;
 
+    auto logger = std::make_shared<cantina::Logger>("qserver");
+    logger->SetLogLevel("DEBUG");
+
     // Install a signal handlers to catch operating system signals
     installSignalHandlers();
 
     // Lock the mutex so that main can then wait on it
-    std::unique_lock<std::mutex> lock(moq_server::main_mutex);
+    std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
     quicr::MoQInstanceServerConfig config;
     config.instance_id = "moq_server";
@@ -149,8 +42,6 @@ main()
     config.transport_config.tls_cert_filename = "./server-cert.pem";
     config.transport_config.tls_key_filename = "./server-key.pem";
 
-    auto logger = std::make_shared<cantina::Logger>("moq_server");
-
     auto delegate = std::make_shared<serverDelegate>();
 
     try {
@@ -159,7 +50,7 @@ main()
         moqInstance.run_server();
 
         // Wait until told to terminate
-        moq_server::cv.wait(lock, [&]() { return moq_server::terminate; });
+        moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
 
         // Unlock the mutex
         lock.unlock();
diff --git a/cmd/moq-example/subscription.h b/cmd/moq-example/subscription.h
index a31e23a4..7cc3dc32 100644
--- a/cmd/moq-example/subscription.h
+++ b/cmd/moq-example/subscription.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <list>
 #include <map>
 #include <optional>
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index a012e411..5c529105 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -6,14 +6,16 @@
 
 #pragma once
 
+#include <quicr/metrics_exporter.h>
 #include <quicr/quicr_common.h>
 #include <transport/transport.h>
-#include <quicr/metrics_exporter.h>
 
 #include <quicr/moq_instance_delegate.h>
 #include <quicr/moq_track_delegate.h>
 
 namespace quicr {
+    constexpr uint64_t MOQT_VERSION = 0xff000004; /// draft-ietf-moq-transport-04
+
     using namespace qtransport;
 
     struct MoQInstanceConfig
@@ -25,7 +27,7 @@ namespace quicr {
     struct MoQInstanceClientConfig : MoQInstanceConfig
     {
         std::string server_host_ip;     /// Relay hostname or IP to connect to
-        uint16_t server_port;          /// Relay port to connect to
+        uint16_t server_port;           /// Relay port to connect to
         TransportProtocol server_proto; /// Protocol to use when connecting to relay
     };
 
@@ -36,49 +38,12 @@ namespace quicr {
         TransportProtocol server_proto; /// Protocol to use
     };
 
-    class MoQInstance;
-    /**
-     * @brief MOQ Instance Transport Delegate
-     * @details MOQ implements the transport delegate, which is shared by all sessions
-     */
-    class MoQInstanceTransportDelegate : public ITransport::TransportDelegate
-    {
-      public:
-        MoQInstanceTransportDelegate(MoQInstance& moq_instance, const cantina::LoggerPointer& logger)
-          : _moq_instance(moq_instance)
-          , _logger(std::make_shared<cantina::Logger>("MOQ_ITD", logger))
-        {
-        }
-
-        // -------------------------------------------------------------------------------------------------
-        // Transprot Delegate/callback functions
-        // -------------------------------------------------------------------------------------------------
-
-        void on_new_data_context([[maybe_unused]] const TransportConnId& conn_id,
-                                 [[maybe_unused]] const DataContextId& data_ctx_id) override
-        {
-        }
-
-        void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) override;
-        void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) override;
-        void on_recv_stream(const TransportConnId& conn_id,
-                            uint64_t stream_id,
-                            std::optional<DataContextId> data_ctx_id,
-                            const bool is_bidir = false) override;
-        void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
-
-      private:
-        MoQInstance& _moq_instance;
-        cantina::LoggerPointer _logger;
-    };
-
-
     /**
      * @brief MOQ Instance
      * @Details MoQ Instance is the handler for either a client or server. It can run
      *   in only one mode, client or server.
      */
-    class MoQInstance
+    class MoQInstance : public ITransport::TransportDelegate
     {
       public:
         enum class Status : uint8_t
@@ -117,7 +82,7 @@ namespace quicr {
                     std::shared_ptr<MoQInstanceDelegate> delegate,
                     const cantina::LoggerPointer& logger);
 
-        ~MoQInstance();
+        ~MoQInstance() = default;
 
         // -------------------------------------------------------------------------------------------------
         // Public API MoQ Intance API methods
@@ -140,8 +105,7 @@ namespace quicr {
          *
          * @returns `track_alias` if no error and nullopt on error
          */
-        std::optional<uint64_t> publishTrack(TransportConnId conn_id,
-                                             std::shared_ptr<MoQTrackDelegate> track_delegate);
+        std::optional<uint64_t> publishTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
 
         /**
          * @brief Make client connection and run
@@ -163,7 +127,6 @@ namespace quicr {
          */
         Status run_server();
 
-
         /**
          * @brief Get the instance status
          *
@@ -171,17 +134,57 @@ namespace quicr {
          */
         Status status();
 
+        /**
+         * Stop Instance
+         */
+        void stop() { _stop = true; }
+
+        // -------------------------------------------------------------------------------------------------
+        // Transprot Delegate/callback functions
+        // -------------------------------------------------------------------------------------------------
+
+        void on_new_data_context([[maybe_unused]] const TransportConnId& conn_id,
+                                 [[maybe_unused]] const DataContextId& data_ctx_id) override
+        {
+        }
+
+        void on_connection_status(const TransportConnId& conn_id, const TransportStatus status) override;
+        void on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote) override;
+        void on_recv_stream(const TransportConnId& conn_id,
+                            uint64_t stream_id,
+                            std::optional<DataContextId> data_ctx_id,
+                            const bool is_bidir = false) override;
+        void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
+
       private:
+        struct ConnectionContext
+        {
+            TransportConnId conn_id;
+            uint64_t ctrl_data_ctx_id;
+            std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
+        };
+
+        // -------------------------------------------------------------------------------------------------
+        // Private methods
+        // -------------------------------------------------------------------------------------------------
         void init();
 
-      private:
+        void send_ctrl_msg(const ConnectionContext& conn_ctx, std::vector<uint8_t>&& data);
+        void send_client_setup();
+
+        // -------------------------------------------------------------------------------------------------
+        // Private member variables
+        // -------------------------------------------------------------------------------------------------
+
+
         std::mutex _mutex;
         const bool _client_mode;
-        std::atomic<bool> _stop{ false };
+        bool _stop { false };
         const MoQInstanceServerConfig _server_config;
         const MoQInstanceClientConfig _client_config;
         std::shared_ptr<MoQInstanceDelegate> _delegate;
-        MoQInstanceTransportDelegate _transport_delegate;
+
+        Status _status{ Status::NOT_READY };
 
         // Log handler to use
         cantina::LoggerPointer _logger;
@@ -192,8 +195,7 @@ namespace quicr {
 
         std::shared_ptr<ITransport> _transport;
 
-        std::vector<TransportConnId> _connections;
+        std::map<TransportConnId, ConnectionContext> _connections;
     };
 
-
 } // namespace quicr
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 5a4e2e3c..210c4723 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -6,9 +6,11 @@
 
 #pragma once
 
+#include <transport/transport.h>
 #include <quicr/moq_messages.h>
 
 namespace quicr {
+    using namespace qtransport;
 
     /**
      * @brief MOQ/MOQT callbacks
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index eb32eeed..02d3f1f2 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -23,25 +23,32 @@ using TrackAlias = uint64_t;
 using ParamType = uint64_t;
 
 // Ref: https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#name-messages
-constexpr uint8_t MESSAGE_TYPE_OBJECT_STREAM            = 0x0;
-constexpr uint8_t MESSAGE_TYPE_OBJECT_DATAGRAM          = 0x1;
-constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE                = 0x3;
-constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_OK             = 0x4;
-constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_ERROR          = 0x5;
-constexpr uint8_t MESSAGE_TYPE_ANNOUNCE                 = 0x6;
-constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_OK              = 0x7;
-constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_ERROR           = 0x8;
-constexpr uint8_t MESSAGE_TYPE_UNANNOUNCE               = 0x9;
-constexpr uint8_t MESSAGE_TYPE_UNSUBSCRIBE              = 0xA;
-constexpr uint8_t MESSAGE_TYPE_SUBSCRIBE_DONE           = 0xB;
-constexpr uint8_t MESSAGE_TYPE_ANNOUNCE_CANCEL          = 0xC;
-constexpr uint8_t MESSAGE_TYPE_TRACK_STATUS_REQUEST     = 0xD;
-constexpr uint8_t MESSAGE_TYPE_TRACK_STATUS             = 0xE;
-constexpr uint8_t MESSAGE_TYPE_GOAWAY                   = 0x10;
-constexpr uint8_t MESSAGE_TYPE_CLIENT_SETUP             = 0x40;
-constexpr uint8_t MESSAGE_TYPE_SERVER_SETUP             = 0x41;
-constexpr uint8_t MESSAGE_TYPE_STREAM_HEADER_TRACK      = 0x50;
-constexpr uint8_t MESSAGE_TYPE_STREAM_HEADER_GROUP      = 0x51;
+enum class MoQMessageType : uint64_t
+{
+    OBJECT_STREAM = 0x0,
+    OBJECT_DATAGRAM,
+
+    SUBSCRIBE = 0x03,
+    SUBSCRIBE_OK,
+    SUBSCRIBE_ERROR,
+    ANNOUNCE,
+    ANNOUNCE_OK,
+    ANNOUNCE_ERROR,
+    UNANNOUNCE,
+    UNSUBSCRIBE,
+    SUBSCRIBE_DONE,
+    ANNOUNCE_CANCEL,
+    TRACK_STATUS_REQUEST,
+    TRACK_STATUS,
+
+    GOWAY = 0x10,
+
+    CLIENT_SETUP = 0x40,
+    SERVER_SETUP,
+
+    STREAM_HEADER_TRACK = 0x50,
+    STREAM_HEADER_GROUP,
+};
 
 // TODO (Suhas): rename it to StreamMapping
 enum ForwardingPreference : uint8_t {
@@ -335,5 +342,5 @@ struct MoqStreamGroupObject {
   uint64_t current_pos {0};
   bool parse_completed { false };
 };
-
+  
 }
\ No newline at end of file
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 2055fd5f..6b58e9db 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -5,9 +5,12 @@
  */
 
 #include <quicr/moq_instance.h>
+#include <quicr/moq_messages.h>
 
 namespace quicr {
 
+    using namespace quicr::messages;
+
     MoQInstance::MoQInstance(const MoQInstanceClientConfig& cfg,
                             std::shared_ptr<MoQInstanceDelegate> delegate,
                             const cantina::LoggerPointer& logger) :
@@ -15,7 +18,6 @@ namespace quicr {
         , _server_config({})
         , _client_config(cfg)
         , _delegate(std::move(delegate))
-        , _transport_delegate({*this, _logger})
         , _logger(std::make_shared<cantina::Logger>("MOQ_IC", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
@@ -36,7 +38,6 @@ namespace quicr {
       , _server_config(cfg)
       , _client_config({})
       , _delegate(std::move(delegate))
-      , _transport_delegate({*this, _logger})
       , _logger(std::make_shared<cantina::Logger>("MOQ_IS", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
@@ -73,7 +74,7 @@ namespace quicr {
                                  .proto =  _server_config.server_proto };
 
         _transport = ITransport::make_server_transport(server, _server_config.transport_config,
-                                                       _transport_delegate, _logger);
+                                                       *this, _logger);
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
@@ -96,69 +97,122 @@ namespace quicr {
                                 .proto =  _client_config.server_proto };
 
         _transport = ITransport::make_client_transport(relay, _client_config.transport_config,
-                                                       _transport_delegate, _logger);
+                                                       *this, _logger);
+
+        _status = Status::CLIENT_CONNECTING;
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+        auto conn_id = _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
 #else
-        _transport->start(nullptr, nullptr);
+        auto conn_id = _transport->start(nullptr, nullptr);
 #endif
 
-        _connections.push_back(_transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples));
+        LOGGER_INFO(_logger, "Connecting session conn_id: " << conn_id << "...");
+        _connections.try_emplace(conn_id, ConnectionContext{ .conn_id =  conn_id });
 
-        LOGGER_INFO(_logger, "Connecting session conn_id: " << _connections.front() << "...");
+        return _status;
+    }
 
-        while (!_stop && _transport->status() == TransportStatus::Connecting) {
-            LOGGER_DEBUG(_logger, "Connecting... " << int(_stop.load()));
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
+    void MoQInstance::send_ctrl_msg(const ConnectionContext& conn_ctx, std::vector<uint8_t>&& data)
+    {
+        _transport->enqueue(conn_ctx.conn_id,
+                            conn_ctx.ctrl_data_ctx_id,
+                            std::move(data),
+                            { MethodTraceItem{} },
+                            0,
+                            2000,
+                            0,
+                            { true, false, false, false });
 
-        if (_stop || !_transport) {
-            LOGGER_INFO(_logger, "Cancelling connecting session " << _connections.front());
-            return Status::CLIENT_FAILED_TO_CONNECT;
-        }
+    }
 
-        if (_transport->status() != TransportStatus::Ready) {
-            _logger->error << "Failed to connect status: " << static_cast<int>(_transport->status()) << std::flush;
+    void MoQInstance::send_client_setup()
+    {
+        StreamBuffer<uint8_t> buffer;
+        auto client_setup = MoqClientSetup{};
 
-            return Status::CLIENT_FAILED_TO_CONNECT;
-        }
+        client_setup.num_versions = 1;
+        client_setup.supported_versions = { MOQT_VERSION };
+        client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
+        client_setup.role_parameter.param_length = 0x1; // length of 1 for role value
+        client_setup.role_parameter.param_value = { 0x03 };
+
+        buffer << client_setup;
+
+        auto &conn_ctx = _connections.begin()->second;
 
-        return Status::READY;
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
 
-    void MoQInstanceTransportDelegate::on_connection_status(const TransportConnId& conn_id, const TransportStatus status)
+    MoQInstance::Status MoQInstance::status()
     {
-        _logger->info << "Connection status conn_id: " << conn_id
-                      << " status: " << static_cast<int>(status)
-                      << std::flush;
+        return _status;
+    }
+
+
+    // ---------------------------------------------------------------------------------------
+    // Transport delegate callbacks
+    // ---------------------------------------------------------------------------------------
 
-        _moq_instance.status();
+    void MoQInstance::on_connection_status(const TransportConnId& conn_id, const TransportStatus status)
+    {
+        _logger->debug << "Connection status conn_id: " << conn_id
+                       << " status: " << static_cast<int>(status)
+                       << std::flush;
+
+        if (_client_mode) {
+            auto& conn_ctx = _connections[conn_id];
+            _logger->info << "Connection established, creating bi-dir stream and sending CLIENT_SETUP" << std::flush;
+
+            conn_ctx.ctrl_data_ctx_id = _transport->createDataContext(conn_id, true, 0, true);
+            send_client_setup();
+        }
+
+        _status = Status::READY;
     }
 
-    void MoQInstanceTransportDelegate::on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote)
+    void MoQInstance::on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote)
     {
         _logger->info << "New connection conn_id: " << conn_id
                       << " remote ip: " << remote.host_or_ip
                       << " port: " << remote.port
                       << std::flush;
-
     }
 
-    void MoQInstanceTransportDelegate::on_recv_stream(const TransportConnId& conn_id,
+    void MoQInstance::on_recv_stream(const TransportConnId& conn_id,
                         uint64_t stream_id,
-                        std::optional<DataContextId> data_ctx_id,
-                        const bool is_bidir)
+                        [[maybe_unused]] std::optional<DataContextId> data_ctx_id,
+                        [[maybe_unused]] const bool is_bidir)
     {
-        _logger->info << "stream data conn_id: " << conn_id
-                      << " stream_id: " << stream_id
-                      << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
-                      << " is_bidir: " << is_bidir
-                      << std::flush;
+        auto stream_buf = _transport->getStreamBuffer(conn_id, stream_id);
+        auto& conn_ctx = _connections[conn_id];
+
+        if (stream_buf == nullptr) {
+            return;
+        }
+
+        while (true) {
+            if (not conn_ctx.msg_type_received.has_value()) {
+                auto msg_type = stream_buf->decode_uintV();
+
+                if (msg_type) {
+                    conn_ctx.msg_type_received = static_cast<MoQMessageType>(*msg_type);
+                } else {
+                    break;
+                }
+            }
+
+            if (conn_ctx.msg_type_received) {
+
+                // type is known, process data based on the message type
+                _logger->debug << "processing incoming message type: "
+                               << static_cast<int>(*conn_ctx.msg_type_received) << std::flush;
+            }
+        }
     }
 
-    void MoQInstanceTransportDelegate::on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id)
+    void MoQInstance::on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id)
     {
         _logger->info << "datagram data conn_id: " << conn_id
                       << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 6b4f06c2..ca1968c2 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -111,7 +111,7 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribe& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::SUBSCRIBE)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push_lv(msg.track_namespace);
@@ -280,7 +280,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqUnsubscribe& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_UNSUBSCRIBE)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::UNSUBSCRIBE)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   return buffer;
 }
@@ -296,7 +296,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnsubscribe &msg)
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribeDone& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_DONE)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.status_code));
   buffer.push_lv(msg.reason_phrase);
@@ -374,7 +374,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribeOk& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_OK)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.expires));
   msg.content_exists ? buffer.push(static_cast<uint8_t>(1)) : buffer.push(static_cast<uint8_t>(0));
@@ -443,7 +443,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg)
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqSubscribeError& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_ERROR)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.err_code));
   buffer.push_lv(msg.reason_phrase);
@@ -505,7 +505,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &ms
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqAnnounce& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::ANNOUNCE)));
   buffer.push_lv(msg.track_namespace);
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(0)));
   return buffer;
@@ -561,7 +561,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqAnnounceOk& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::ANNOUNCE_OK)));
   buffer.push_lv(msg.track_namespace);
   return buffer;
 }
@@ -583,7 +583,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceOk &msg) {
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqAnnounceError& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_ERROR)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::ANNOUNCE_ERROR)));
   buffer.push_lv(msg.track_namespace.value());
   buffer.push(qtransport::to_uintV(msg.err_code.value()));
   buffer.push_lv(msg.reason_phrase.value());
@@ -623,7 +623,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceError &msg
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqUnannounce& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_UNANNOUNCE)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::UNANNOUNCE)));
   buffer.push_lv(msg.track_namespace);
   return buffer;
 }
@@ -644,7 +644,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnannounce &msg) {
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqAnnounceCancel& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::ANNOUNCE_CANCEL)));
   buffer.push_lv(msg.track_namespace);
   return buffer;
 }
@@ -669,7 +669,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceCancel &ms
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqGoaway& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_GOAWAY)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::GOWAY)));
   buffer.push_lv(msg.new_session_uri);
   return buffer;
 }
@@ -687,7 +687,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqGoaway &msg) {
 
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqGoaway &msg) {
-  buffer << static_cast<uint8_t>(MESSAGE_TYPE_GOAWAY);
+  buffer << static_cast<uint8_t>(MoQMessageType::GOWAY);
   buffer << msg.new_session_uri;
   return buffer;
 }
@@ -705,7 +705,7 @@ operator>>(MessageBuffer &buffer, MoqGoaway &msg) {
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqObjectStream& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_STREAM)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::OBJECT_STREAM)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push(qtransport::to_uintV(msg.group_id));
@@ -775,7 +775,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg)
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqObjectDatagram& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_DATAGRAM)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::OBJECT_DATAGRAM)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push(qtransport::to_uintV(msg.group_id));
@@ -846,7 +846,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &ms
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqStreamHeaderTrack& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_TRACK)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_TRACK)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push(qtransport::to_uintV(msg.priority));
@@ -934,7 +934,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqStreamHeaderGroup& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_GROUP)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_GROUP)));
   buffer.push(qtransport::to_uintV(msg.subscribe_id));
   buffer.push(qtransport::to_uintV(msg.track_alias));
   buffer.push(qtransport::to_uintV(msg.group_id));
@@ -1022,7 +1022,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamGroupObject
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqClientSetup& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_CLIENT_SETUP)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::CLIENT_SETUP)));
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.supported_versions.size())));
   // versions
   for (const auto& ver: msg.supported_versions) {
@@ -1107,7 +1107,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqServerSetup& msg){
 
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MESSAGE_TYPE_SERVER_SETUP)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::SERVER_SETUP)));
   buffer.push(qtransport::to_uintV(msg.selection_version));
 
   /// num params
@@ -1151,8 +1151,9 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
         }
         msg.current_param->param_length = param->size();
         msg.current_param->param_value = param.value();
-        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role  ?
-                                                                                         msg.role_parameter = std::move(msg.current_param.value()) : msg.path_parameter = std::move(msg.current_param.value());
+        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role
+          ? msg.role_parameter = std::move(msg.current_param.value())
+          : msg.path_parameter = std::move(msg.current_param.value());
         msg.current_param = MoqParameter{};
         msg.num_params.value() -= 1;
       }
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 783699d2..bcfffb08 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -53,7 +53,7 @@ TEST_CASE("AnnounceOk Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqAnnounceOk announce_ok_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_OK), announce_ok_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::ANNOUNCE_OK), announce_ok_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
 }
 
@@ -67,7 +67,7 @@ TEST_CASE("Announce Message encode/decode")
   buffer <<  announce;
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqAnnounce announce_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE), announce_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::ANNOUNCE), announce_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_out.track_namespace);
   CHECK_EQ(0, announce_out.params.size());
 }
@@ -82,7 +82,7 @@ TEST_CASE("Unannounce Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqAnnounceOk announce_ok_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_UNANNOUNCE), announce_ok_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::UNANNOUNCE), announce_ok_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_ok_out.track_namespace);
 }
 
@@ -98,7 +98,7 @@ TEST_CASE("AnnounceError Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqAnnounceError announce_err_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_ERROR), announce_err_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::ANNOUNCE_ERROR), announce_err_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_err_out.track_namespace);
   CHECK_EQ(announce_err.err_code, announce_err_out.err_code);
   CHECK_EQ(announce_err.reason_phrase, announce_err_out.reason_phrase);
@@ -114,7 +114,7 @@ TEST_CASE("AnnounceCancel Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqAnnounceCancel announce_cancel_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_ANNOUNCE_CANCEL), announce_cancel_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::ANNOUNCE_CANCEL), announce_cancel_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, announce_cancel_out.track_namespace);
 }
 
@@ -135,7 +135,7 @@ TEST_CASE("Subscribe (LatestObject) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -161,7 +161,7 @@ TEST_CASE("Subscribe (LatestGroup) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -189,7 +189,7 @@ TEST_CASE("Subscribe (AbsoluteStart) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -222,7 +222,7 @@ TEST_CASE("Subscribe (AbsoluteRange) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -256,7 +256,7 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -297,7 +297,7 @@ TEST_CASE("Subscribe (Params - 2) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribe subscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
   CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
   CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
   CHECK_EQ(subscribe.subscribe_id, subscribe_out.subscribe_id);
@@ -369,7 +369,7 @@ TEST_CASE("Subscribe (Combo) Message encode/decode")
     std::vector<uint8_t> net_data = buffer.front(buffer.size());
     MoqSubscribe subscribe_out;
     CHECK(verify(
-      net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE), subscribe_out));
+      net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE), subscribe_out));
     CHECK_EQ(TRACK_NAMESPACE_CONF, subscribe_out.track_namespace);
     CHECK_EQ(TRACK_NAME_ALICE_VIDEO, subscribe_out.track_name);
     CHECK_EQ(subscribes[i].subscribe_id, subscribe_out.subscribe_id);
@@ -402,7 +402,7 @@ TEST_CASE("SubscribeOk Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribeOk subscribe_ok_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK), subscribe_ok_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_OK), subscribe_ok_out));
   CHECK_EQ(subscribe_ok.subscribe_id, subscribe_ok_out.subscribe_id);
   CHECK_EQ(subscribe_ok.expires, subscribe_ok_out.expires);
   CHECK_EQ(subscribe_ok.content_exists, subscribe_ok_out.content_exists);
@@ -424,7 +424,7 @@ TEST_CASE("SubscribeOk (content-exists) Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribeOk subscribe_ok_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_OK), subscribe_ok_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_OK), subscribe_ok_out));
   CHECK_EQ(subscribe_ok.subscribe_id, subscribe_ok_out.subscribe_id);
   CHECK_EQ(subscribe_ok.expires, subscribe_ok_out.expires);
   CHECK_EQ(subscribe_ok.content_exists, subscribe_ok_out.content_exists);
@@ -446,7 +446,7 @@ TEST_CASE("SubscribeError  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribeError subscribe_err_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_ERROR), subscribe_err_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_ERROR), subscribe_err_out));
   CHECK_EQ(subscribe_err.subscribe_id, subscribe_err_out.subscribe_id);
   CHECK_EQ(subscribe_err.err_code, subscribe_err_out.err_code);
   CHECK_EQ(subscribe_err.reason_phrase, subscribe_err_out.reason_phrase);
@@ -464,7 +464,7 @@ TEST_CASE("Unsubscribe  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqUnsubscribe unsubscribe_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_UNSUBSCRIBE), unsubscribe_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::UNSUBSCRIBE), unsubscribe_out));
   CHECK_EQ(unsubscribe.subscribe_id, unsubscribe_out.subscribe_id);
 }
 
@@ -483,7 +483,7 @@ TEST_CASE("SubscribeDone  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribeDone subscribe_done_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE), subscribe_done_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_DONE), subscribe_done_out));
   CHECK_EQ(subscribe_done.subscribe_id, subscribe_done_out.subscribe_id);
   CHECK_EQ(subscribe_done.status_code, subscribe_done_out.status_code);
   CHECK_EQ(subscribe_done.reason_phrase, subscribe_done_out.reason_phrase);
@@ -507,7 +507,7 @@ TEST_CASE("SubscribeDone (content-exists)  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqSubscribeDone subscribe_done_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SUBSCRIBE_DONE), subscribe_done_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SUBSCRIBE_DONE), subscribe_done_out));
   CHECK_EQ(subscribe_done.subscribe_id, subscribe_done_out.subscribe_id);
   CHECK_EQ(subscribe_done.status_code, subscribe_done_out.status_code);
   CHECK_EQ(subscribe_done.reason_phrase, subscribe_done_out.reason_phrase);
@@ -532,7 +532,7 @@ TEST_CASE("ClientSetup  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqClientSetup client_setup_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_CLIENT_SETUP), client_setup_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::CLIENT_SETUP), client_setup_out));
   CHECK_EQ(client_setup.supported_versions, client_setup_out.supported_versions);
   CHECK_EQ(client_setup.role_parameter.param_value, client_setup_out.role_parameter.param_value);
 }
@@ -552,7 +552,7 @@ TEST_CASE("ServerSetup  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqServerSetup server_setup_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_SERVER_SETUP), server_setup_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SERVER_SETUP), server_setup_out));
   CHECK_EQ(server_setup.selection_version, server_setup_out.selection_version);
   CHECK_EQ(server_setup.role_parameter.param_value, server_setup.role_parameter.param_value);
 }
@@ -573,7 +573,7 @@ TEST_CASE("ObjectStream  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqObjectStream object_stream_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_STREAM), object_stream_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::OBJECT_STREAM), object_stream_out));
   CHECK_EQ(object_stream.subscribe_id, object_stream_out.subscribe_id);
   CHECK_EQ(object_stream.track_alias, object_stream_out.track_alias);
   CHECK_EQ(object_stream.group_id, object_stream_out.group_id);
@@ -598,7 +598,7 @@ TEST_CASE("ObjectDatagram  Message encode/decode")
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
 
   MoqObjectStream object_datagram_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_OBJECT_DATAGRAM), object_datagram_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::OBJECT_DATAGRAM), object_datagram_out));
   CHECK_EQ(object_datagram.subscribe_id, object_datagram_out.subscribe_id);
   CHECK_EQ(object_datagram.track_alias, object_datagram_out.track_alias);
   CHECK_EQ(object_datagram.group_id, object_datagram_out.group_id);
@@ -620,7 +620,7 @@ TEST_CASE("StreamPerGroup Object  Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqStreamHeaderGroup hdr_group_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_GROUP), hdr_group_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_GROUP), hdr_group_out));
   CHECK_EQ(hdr_grp.subscribe_id, hdr_group_out.subscribe_id);
   CHECK_EQ(hdr_grp.track_alias, hdr_group_out.track_alias);
   CHECK_EQ(hdr_grp.group_id, hdr_group_out.group_id);
@@ -671,7 +671,7 @@ TEST_CASE("StreamPerTrack Object  Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqStreamHeaderTrack hdr_out;
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_STREAM_HEADER_TRACK), hdr_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_TRACK), hdr_out));
   CHECK_EQ(hdr_out.subscribe_id, hdr_out.subscribe_id);
   CHECK_EQ(hdr_out.track_alias, hdr_out.track_alias);
   CHECK_EQ(hdr_out.priority, hdr_out.priority);
@@ -728,6 +728,6 @@ TEST_CASE("MoqGoaway Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqGoaway goaway_out{};
-  CHECK(verify(net_data, static_cast<uint64_t>(MESSAGE_TYPE_GOAWAY), goaway_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::GOWAY), goaway_out));
   CHECK_EQ(from_ascii("go.away.now.no.return"), goaway_out.new_session_uri);
 }
\ No newline at end of file

From d710f514c4f48d89439c6503817aac0be3b93f26 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 7 Jun 2024 21:59:55 -0700
Subject: [PATCH 30/71] break out signal handler

---
 cmd/moq-example/signal_handler.h | 116 +++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)
 create mode 100644 cmd/moq-example/signal_handler.h

diff --git a/cmd/moq-example/signal_handler.h b/cmd/moq-example/signal_handler.h
new file mode 100644
index 00000000..254465f0
--- /dev/null
+++ b/cmd/moq-example/signal_handler.h
@@ -0,0 +1,116 @@
+#pragma once
+
+#include <condition_variable>
+#include <csignal>
+#include <iostream>
+#include <mutex>
+
+namespace moq_example {
+    std::mutex main_mutex;                     // Main's mutex
+    bool terminate{ false };                   // Termination flag
+    std::condition_variable cv;                // Main thread waits on this
+    const char* termination_reason{ nullptr }; // Termination reason
+};
+
+/*
+ *  signalHandler
+ *
+ *  Description:
+ *      This function will handle operating system signals related to
+ *      termination and then instruct the main thread to terminate.
+ *
+ *  Parameters:
+ *      signal_number [in]
+ *          The signal caught.
+ *
+ *  Returns:
+ *      Nothing.
+ *
+ *  Comments:
+ *      None.
+ */
+void
+signalHandler(int signal_number)
+{
+    const auto lock = std::lock_guard<std::mutex>(moq_example::main_mutex);
+
+    // If termination is in process, just return
+    if (moq_example::terminate) {
+        return;
+    }
+
+    // Indicate that the process should terminate
+    moq_example::terminate = true;
+
+    // Set the termination reason string
+    switch (signal_number) {
+        case SIGINT:
+            moq_example::termination_reason = "Interrupt signal received";
+            break;
+
+#ifndef _WIN32
+        case SIGHUP:
+            moq_example::termination_reason = "Hangup signal received";
+            break;
+
+        case SIGQUIT:
+            moq_example::termination_reason = "Quit signal received";
+            break;
+#endif
+
+        default:
+            moq_example::termination_reason = "Unknown signal received";
+            break;
+    }
+
+    // Notify the main execution thread to terminate
+    moq_example::cv.notify_one();
+}
+
+/*
+ *  installSignalHandlers
+ *
+ *  Description:
+ *      This function will install the signal handlers for SIGINT, SIGQUIT,
+ *      etc. so that the process can be terminated in a controlled fashion.
+ *
+ *  Parameters:
+ *      None.
+ *
+ *  Returns:
+ *      Nothing.
+ *
+ *  Comments:
+ *      None.
+ */
+void
+installSignalHandlers()
+{
+#ifdef _WIN32
+    if (signal(SIGINT, signalHandler) == SIG_ERR) {
+        std::cerr << "Failed to install SIGINT handler" << std::endl;
+    }
+#else
+    struct sigaction sa = {};
+
+    // Configure the sigaction struct
+    sa.sa_handler = signalHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+
+    // Catch SIGHUP (signal 1)
+    if (sigaction(SIGHUP, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGHUP handler" << std::endl;
+    }
+
+    // Catch SIGINT (signal 2)
+    if (sigaction(SIGINT, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGINT handler" << std::endl;
+    }
+
+    // Catch SIGQUIT (signal 3)
+    if (sigaction(SIGQUIT, &sa, nullptr) == -1) {
+        std::cerr << "Failed to install SIGQUIT handler" << std::endl;
+    }
+#endif
+}

From b024e41b1c2c0c2b57e15917d5c11c7ea7bbc3ef Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 7 Jun 2024 22:00:45 -0700
Subject: [PATCH 31/71] update transport

---
 dependencies/transport | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dependencies/transport b/dependencies/transport
index 3edbbdab..08c3f0d0 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 3edbbdab718b30a6fdbe9a092caf4e1459bb92c6
+Subproject commit 08c3f0d0647158fbff0ca95f028f3a47e2fec9bb

From d21052b4b30fcf7ed0be4f34b003ac00ec8c671f Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 10 Jun 2024 21:55:27 -0700
Subject: [PATCH 32/71] MoQ updates...

* Updated transport with bug fixes and new any data object in stream buffer
* Implemented close with termination code/reason
* Implemented bidir handling as first bidir stream and to close connection in error
* Implemented CLIENT and SERVER SETUP state machine on new connections
* Added MoQTerminationReason enum class
* Resolved copy operator issues with moq structs
* Disabled metrics exporter till we have endpoint_id added
* Optimized moq message decode to continue to decode if stream buffer
  still has data.
* Updated moq test `verify()` to use any object in stream buffer
---
 cmd/moq-example/server.cpp   |   2 +
 dependencies/transport       |   2 +-
 include/quicr/moq_instance.h |   9 +-
 include/quicr/moq_messages.h |  18 ++-
 src/moq_instance.cpp         | 210 ++++++++++++++++++++++++++++++++---
 src/moq_messages.cpp         | 134 +++++++++++++---------
 test/moq_messages.cpp        |  14 ++-
 7 files changed, 315 insertions(+), 74 deletions(-)

diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index ff5ec72a..5e24878e 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -41,6 +41,8 @@ main()
     config.transport_config.debug = true;
     config.transport_config.tls_cert_filename = "./server-cert.pem";
     config.transport_config.tls_key_filename = "./server-key.pem";
+    config.transport_config.use_reset_wait_strategy = false;
+    config.transport_config.time_queue_max_duration = 5000;
 
     auto delegate = std::make_shared<serverDelegate>();
 
diff --git a/dependencies/transport b/dependencies/transport
index 08c3f0d0..4430d5fc 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 08c3f0d0647158fbff0ca95f028f3a47e2fec9bb
+Subproject commit 4430d5fc3125dec3e310772cd1cadbd8574e80ee
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 5c529105..7f425ae1 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -160,7 +160,9 @@ namespace quicr {
         struct ConnectionContext
         {
             TransportConnId conn_id;
-            uint64_t ctrl_data_ctx_id;
+            std::optional<uint64_t> ctrl_data_ctx_id;
+            bool setup_complete { false };   /// True if both client and server setup messages have completed
+            uint64_t client_version { 0 };
             std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
         };
 
@@ -171,6 +173,11 @@ namespace quicr {
 
         void send_ctrl_msg(const ConnectionContext& conn_ctx, std::vector<uint8_t>&& data);
         void send_client_setup();
+        void send_server_setup(ConnectionContext& conn_ctx);
+        void close_connection(TransportConnId conn_id, messages::MoQTerminationReason reason,
+                              const std::string& reason_str);
+        bool process_recv_message(ConnectionContext& conn_ctx,
+                                  std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
 
         // -------------------------------------------------------------------------------------------------
         // Private member variables
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 02d3f1f2..a4e045f4 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -22,6 +22,18 @@ using SubscribeId = uint64_t;
 using TrackAlias = uint64_t;
 using ParamType = uint64_t;
 
+enum class MoQTerminationReason : uint64_t
+{
+  NO_ERROR = 0x0,
+  INTERNAL_ERROR,
+  UNAUTHORIZED,
+  PROTOCOL_VIOLATION,
+  DUP_TRACK_ALIAS,
+  PARAM_LEN_MISMATCH,
+
+  GOAWAY_TIMEOUT = 0x10,
+};
+
 // Ref: https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#name-messages
 enum class MoQMessageType : uint64_t
 {
@@ -159,7 +171,7 @@ struct MoqSubscribeOk {
                                                        const MoqSubscribeOk& msg);
 private:
   size_t current_pos {0};
-  const size_t MAX_FIELDS {5};
+  size_t MAX_FIELDS {5};
 };
 
 
@@ -173,7 +185,7 @@ struct MoqSubscribeError {
                                                        const MoqSubscribeError& msg);
 private:
   size_t current_pos {0};
-  const size_t MAX_FIELDS {4};
+  size_t MAX_FIELDS {4};
 };
 
 struct MoqUnsubscribe {
@@ -196,7 +208,7 @@ struct MoqSubscribeDone
                                                        const MoqSubscribeDone& msg);
 private:
   size_t current_pos {0};
-  const size_t MAX_FIELDS = {6};
+  size_t MAX_FIELDS = {6};
 };
 
 //
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 6b58e9db..d96c277f 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -77,7 +77,9 @@ namespace quicr {
                                                        *this, _logger);
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+        // TODO(tievens) add back after endpoint_id is added
+        // _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+        _transport->start(nullptr, nullptr);
 #else
         _transport->start(nullptr, nullptr);
 #endif
@@ -102,7 +104,9 @@ namespace quicr {
         _status = Status::CLIENT_CONNECTING;
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        auto conn_id = _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+        // TODO(tievens): Add back after endpoint_id is added
+        //auto conn_id = _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
+        auto conn_id = _transport->start(nullptr, nullptr);
 #else
         auto conn_id = _transport->start(nullptr, nullptr);
 #endif
@@ -115,8 +119,15 @@ namespace quicr {
 
     void MoQInstance::send_ctrl_msg(const ConnectionContext& conn_ctx, std::vector<uint8_t>&& data)
     {
+        if (not conn_ctx.ctrl_data_ctx_id) {
+            close_connection(conn_ctx.conn_id,
+                             MoQTerminationReason::PROTOCOL_VIOLATION,
+                             "Control bidir stream not created");
+            return;
+        }
+
         _transport->enqueue(conn_ctx.conn_id,
-                            conn_ctx.ctrl_data_ctx_id,
+                            *conn_ctx.ctrl_data_ctx_id,
                             std::move(data),
                             { MethodTraceItem{} },
                             0,
@@ -131,10 +142,10 @@ namespace quicr {
         StreamBuffer<uint8_t> buffer;
         auto client_setup = MoqClientSetup{};
 
-        client_setup.num_versions = 1;
+        client_setup.num_versions = 1;      // NOTE: Not used for encode, verison vector size is used
         client_setup.supported_versions = { MOQT_VERSION };
         client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
-        client_setup.role_parameter.param_length = 0x1; // length of 1 for role value
+        client_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
         client_setup.role_parameter.param_value = { 0x03 };
 
         buffer << client_setup;
@@ -144,12 +155,134 @@ namespace quicr {
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
+    void MoQInstance::send_server_setup(ConnectionContext& conn_ctx)
+    {
+        StreamBuffer<uint8_t> buffer;
+        auto server_setup = MoqServerSetup{};
+
+        server_setup.selection_version = { conn_ctx.client_version };
+        server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
+        server_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
+        server_setup.role_parameter.param_value = { 0x03 };
+
+        buffer << server_setup;
+
+        _logger->info << "Sending SERVER_SETUP to conn_id: " << conn_ctx.conn_id << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
 
     MoQInstance::Status MoQInstance::status()
     {
         return _status;
     }
 
+    bool MoQInstance::process_recv_message(ConnectionContext& conn_ctx,
+                                           std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer)
+    {
+        if (stream_buffer->size() == 0) { // should never happen
+            close_connection(conn_ctx.conn_id,
+                             MoQTerminationReason::INTERNAL_ERROR,
+                             "Stream buffer cannot be zero when parsing message type");
+        }
+
+        if (not conn_ctx.msg_type_received) { // should never happen
+            close_connection(conn_ctx.conn_id,
+                             MoQTerminationReason::INTERNAL_ERROR,
+                             "Process recv message connection context is missing message type");
+        }
+
+        switch (*conn_ctx.msg_type_received) {
+            case MoQMessageType::OBJECT_STREAM:
+                break;
+            case MoQMessageType::OBJECT_DATAGRAM:
+                break;
+            case MoQMessageType::SUBSCRIBE:
+                break;
+            case MoQMessageType::SUBSCRIBE_OK:
+                break;
+            case MoQMessageType::SUBSCRIBE_ERROR:
+                break;
+            case MoQMessageType::ANNOUNCE:
+                break;
+            case MoQMessageType::ANNOUNCE_OK:
+                break;
+            case MoQMessageType::ANNOUNCE_ERROR:
+                break;
+            case MoQMessageType::UNANNOUNCE:
+                break;
+            case MoQMessageType::UNSUBSCRIBE:
+                break;
+            case MoQMessageType::SUBSCRIBE_DONE:
+                break;
+            case MoQMessageType::ANNOUNCE_CANCEL:
+                break;
+            case MoQMessageType::TRACK_STATUS_REQUEST:
+                break;
+            case MoQMessageType::TRACK_STATUS:
+                break;
+            case MoQMessageType::GOWAY:
+                break;
+            case MoQMessageType::CLIENT_SETUP: {
+                    if (not stream_buffer->anyHasValue()) {
+                        _logger->info << "init stream buffer client setup" << std::flush;
+                        stream_buffer->initAny<MoqClientSetup>();
+                    }
+
+                    auto& msg = stream_buffer->getAny<MoqClientSetup>();
+                    if (*stream_buffer >> msg) {
+                        if (!msg.supported_versions.size()) { // should never happen
+                            close_connection(conn_ctx.conn_id,
+                                             MoQTerminationReason::PROTOCOL_VIOLATION,
+                                             "Client setup contained zero versions");
+
+                        }
+
+                        _logger->info << "Client setup received, "
+                                      << " num_versions: " << msg.num_versions
+                                      << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
+                                      << " version: 0x" << std::hex << msg.supported_versions.front()
+                                      << std::dec << std::flush;
+
+                        conn_ctx.client_version = msg.supported_versions.front();
+                        stream_buffer->resetAny();
+
+                        send_server_setup(conn_ctx);
+                        conn_ctx.setup_complete = true;
+                        return true;
+                    }
+                    break;
+            }
+            case MoQMessageType::SERVER_SETUP: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->info << "init stream buffer server setup" << std::flush;
+                    stream_buffer->initAny<MoqServerSetup>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqServerSetup>();
+                if (*stream_buffer >> msg) {
+                    _logger->info << "Server setup received,"
+                                  << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
+                                  << " selected_version: 0x" << std::hex << msg.selection_version
+                                  << std::dec << std::flush;
+                    stream_buffer->resetAny();
+                    conn_ctx.setup_complete = true;
+                    return true;
+                }
+                break;
+            }
+            case MoQMessageType::STREAM_HEADER_TRACK:
+                break;
+            case MoQMessageType::STREAM_HEADER_GROUP:
+                break;
+        }
+
+        _logger->debug << " type: " << static_cast<int>(*conn_ctx.msg_type_received)
+                      << " sbuf_size: " << stream_buffer->size()
+                      << std::flush;
+        return false;
+    }
 
     // ---------------------------------------------------------------------------------------
     // Transport delegate callbacks
@@ -174,16 +307,20 @@ namespace quicr {
 
     void MoQInstance::on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote)
     {
+        auto [conn_ctx, is_new] = _connections.try_emplace(conn_id, ConnectionContext{});
+
         _logger->info << "New connection conn_id: " << conn_id
                       << " remote ip: " << remote.host_or_ip
                       << " port: " << remote.port
                       << std::flush;
+
+        conn_ctx->second.conn_id = conn_id;
     }
 
     void MoQInstance::on_recv_stream(const TransportConnId& conn_id,
                         uint64_t stream_id,
-                        [[maybe_unused]] std::optional<DataContextId> data_ctx_id,
-                        [[maybe_unused]] const bool is_bidir)
+                        std::optional<DataContextId> data_ctx_id,
+                        const bool is_bidir)
     {
         auto stream_buf = _transport->getStreamBuffer(conn_id, stream_id);
         auto& conn_ctx = _connections[conn_id];
@@ -192,8 +329,18 @@ namespace quicr {
             return;
         }
 
-        while (true) {
-            if (not conn_ctx.msg_type_received.has_value()) {
+        if (is_bidir && not conn_ctx.ctrl_data_ctx_id) {
+            if (not data_ctx_id) {
+                close_connection(conn_id,
+                                 MoQTerminationReason::INTERNAL_ERROR,
+                                 "Received bidir is missing data context");
+                return;
+            }
+            conn_ctx.ctrl_data_ctx_id = data_ctx_id;
+        }
+
+        while (stream_buf->size()) {
+            if (not conn_ctx.msg_type_received) {
                 auto msg_type = stream_buf->decode_uintV();
 
                 if (msg_type) {
@@ -204,10 +351,9 @@ namespace quicr {
             }
 
             if (conn_ctx.msg_type_received) {
-
-                // type is known, process data based on the message type
-                _logger->debug << "processing incoming message type: "
-                               << static_cast<int>(*conn_ctx.msg_type_received) << std::flush;
+                if (process_recv_message(conn_ctx, stream_buf)) {
+                    conn_ctx.msg_type_received = std::nullopt;
+                }
             }
         }
     }
@@ -220,5 +366,43 @@ namespace quicr {
 
     }
 
+    void MoQInstance::close_connection(TransportConnId conn_id, messages::MoQTerminationReason reason,
+                                       const std::string& reason_str)
+    {
+        _logger->info << "Closing conn_id: " << conn_id;
+        switch (reason) {
+            case MoQTerminationReason::NO_ERROR:
+                _logger->info << " no error";
+                break;
+            case MoQTerminationReason::INTERNAL_ERROR:
+                _logger->info << " internal error: " << reason_str;
+                break;
+            case MoQTerminationReason::UNAUTHORIZED:
+                _logger->info << " unauthorized: " << reason_str;
+                break;
+            case MoQTerminationReason::PROTOCOL_VIOLATION:
+                _logger->info << " protocol violation: " << reason_str;
+            break;
+            case MoQTerminationReason::DUP_TRACK_ALIAS:
+                _logger->info << " duplicate track alias: " << reason_str;
+                break;
+            case MoQTerminationReason::PARAM_LEN_MISMATCH:
+                _logger->info << " param length mismatch: " << reason_str;
+                break;
+            case MoQTerminationReason::GOAWAY_TIMEOUT:
+                _logger->info << " goaway timeout: " << reason_str;
+                break;
+        }
+        _logger->info << std::flush;
+
+        // TODO(tievens): update transport to allow passing the reason/error code value
+        _transport->close(conn_id);
+
+        if (_client_mode) {
+            _logger->info << "Client connection closed, stopping client" << std::flush;
+            _stop = true;
+        }
+    }
+
 
 } // namespace quicr
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index ca1968c2..bd681e97 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -154,29 +154,29 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!parse_bytes_field(buffer, msg.track_namespace)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_bytes_field(buffer, msg.track_name)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 4: {
       const auto val = buffer.decode_uintV();
       if (!val) {
@@ -191,8 +191,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
       } else {
         msg.current_pos += 1;
       }
+      [[fallthrough]];
     }
-    break;
     case 5: {
       if (msg.filter_type == FilterType::AbsoluteStart
           || msg.filter_type == FilterType::AbsoluteRange) {
@@ -201,8 +201,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         }
         msg.current_pos += 1;
       }
+      [[fallthrough]];
     }
-    break;
     case 6: {
       if (msg.filter_type == FilterType::AbsoluteStart
           || msg.filter_type == FilterType::AbsoluteRange) {
@@ -216,8 +216,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
           msg.current_pos += 1;
         }
       }
+      [[fallthrough]];
     }
-    break;
     case 7: {
       if (msg.filter_type == FilterType::AbsoluteRange) {
         if (!parse_uintV_field(buffer, msg.end_group)) {
@@ -225,8 +225,9 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         }
         msg.current_pos += 1;
       }
+
+      [[fallthrough]];
     }
-    break;
     case 8: {
       if (msg.filter_type == FilterType::AbsoluteRange) {
         if (!parse_uintV_field(buffer, msg.end_object)) {
@@ -234,8 +235,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         }
         msg.current_pos += 1;
       }
+      [[fallthrough]];
     }
-    break;
     case 9: {
       if (!msg.current_param.has_value()) {
         if (!parse_uintV_field(buffer, msg.num_params)) {
@@ -266,8 +267,11 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         msg.num_params -= 1;
       }
       msg.parsing_completed = true;
+      [[fallthrough]];
     }
-    break;
+
+    default:
+      break;
   }
 
   if (!msg.parsing_completed ) {
@@ -318,15 +322,15 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.status_code)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       const auto val = buffer.decode_bytes();
       if (!val) {
@@ -334,8 +338,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg
       }
       msg.reason_phrase = std::move(val.value());
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       const auto val = buffer.front();
       if (!val) {
@@ -348,22 +352,24 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeDone &msg
         // nothing more to process.
         return true;
       }
+      [[fallthrough]];
     }
-    break;
     case 4: {
       if(!parse_uintV_field(buffer, msg.final_group_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 5: {
       if(!parse_uintV_field(buffer, msg.final_object_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if (msg.current_pos < msg.MAX_FIELDS) {
@@ -395,15 +401,15 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg)
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.expires)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       const auto val = buffer.front();
       if (!val) {
@@ -416,22 +422,24 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeOk &msg)
         // nothing more to process.
         return true;
       }
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_uintV_field(buffer, msg.largest_group)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 4: {
       if(!parse_uintV_field(buffer, msg.largest_object)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if (msg.current_pos < msg.MAX_FIELDS) {
@@ -461,15 +469,15 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &ms
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.err_code)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       const auto val = buffer.decode_bytes();
       if (!val) {
@@ -477,15 +485,17 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribeError &ms
       }
       msg.reason_phrase = std::move(val.value());
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if (msg.current_pos < msg.MAX_FIELDS) {
@@ -723,36 +733,36 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg)
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!parse_uintV_field(buffer, msg.group_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_uintV_field(buffer, msg.object_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 4: {
       if(!parse_uintV_field(buffer, msg.priority)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 5: {
       const auto val = buffer.decode_bytes();
       if (!val) {
@@ -760,8 +770,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectStream &msg)
       }
       msg.payload = std::move(val.value());
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -793,36 +805,36 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &ms
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!parse_uintV_field(buffer, msg.group_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_uintV_field(buffer, msg.object_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 4: {
       if(!parse_uintV_field(buffer, msg.priority)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 5: {
       const auto val = buffer.decode_bytes();
       if (!val) {
@@ -830,8 +842,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &ms
       }
       msg.payload = std::move(val.value());
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -861,23 +875,25 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderTrack
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!parse_uintV_field(buffer, msg.priority)) {
         return false;
       }
       msg.current_pos += 1;
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -903,15 +919,15 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.object_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       const auto val = buffer.decode_bytes();
       if(!val) {
@@ -919,8 +935,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamTrackObject
       }
       msg.payload = std::move(val.value());
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -949,30 +967,32 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamHeaderGroup
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       if(!parse_uintV_field(buffer, msg.track_alias)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!parse_uintV_field(buffer, msg.group_id)) {
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 3: {
       if(!parse_uintV_field(buffer, msg.priority)) {
         return false;
       }
       msg.current_pos += 1;
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -998,8 +1018,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamGroupObject
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 1: {
       const auto val = buffer.decode_bytes();
       if (!val) {
@@ -1007,8 +1027,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqStreamGroupObject
       }
       msg.payload = std::move(val.value());
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if(!msg.parse_completed) {
@@ -1023,7 +1045,7 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
            const MoqClientSetup& msg){
 
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::CLIENT_SETUP)));
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.supported_versions.size())));
+  buffer.push(qtransport::to_uintV(msg.supported_versions.size()));
   // versions
   for (const auto& ver: msg.supported_versions) {
     buffer.push(qtransport::to_uintV(ver));
@@ -1044,6 +1066,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
     case 1: {
       while (msg.num_versions > 0) {
@@ -1055,8 +1078,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
         msg.num_versions -= 1;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
-    break;
     case 2: {
       if(!msg.num_params.has_value()) {
         auto params = uint64_t {0};
@@ -1089,8 +1112,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
       }
 
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if (!msg.parse_completed) {
@@ -1125,6 +1150,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
         return false;
       }
       msg.current_pos += 1;
+      [[fallthrough]];
     }
     case 1: {
       if(!msg.num_params.has_value()) {
@@ -1158,8 +1184,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
         msg.num_params.value() -= 1;
       }
       msg.parse_completed = true;
+      [[fallthrough]];
     }
-    break;
+    default:
+      break;
   }
 
   if (!msg.parse_completed) {
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index bcfffb08..85583f3d 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -1,9 +1,10 @@
+#include <any>
 #include <doctest/doctest.h>
+#include <iostream>
 #include <memory>
+#include <quicr/moq_messages.h>
 #include <sstream>
 #include <string>
-#include <iostream>
-#include <quicr/moq_messages.h>
 
 using namespace quicr;
 using namespace quicr::messages;
@@ -21,10 +22,15 @@ template<typename T>
 bool verify(std::vector<uint8_t>& net_data, uint64_t message_type, T& message, size_t slice_depth=1) {
   // TODO: support size_depth > 1, if needed
   qtransport::StreamBuffer<uint8_t> in_buffer;
+  in_buffer.initAny<T>();    // Set parsed data to be of this type using out param
+
   std::optional<uint64_t> msg_type;
   bool done = false;
+
   for (auto& v: net_data) {
+    auto &msg = in_buffer.getAny<T>();
     in_buffer.push(v);
+
     if (!msg_type) {
       msg_type = in_buffer.decode_uintV();
       if (!msg_type) {
@@ -34,8 +40,10 @@ bool verify(std::vector<uint8_t>& net_data, uint64_t message_type, T& message, s
       continue;
     }
 
-    done = in_buffer >> message;
+    done = in_buffer >> msg;
     if (done) {
+      // copy the working parsed data to out param.
+      message = msg;
       break;
     }
   }

From 186410923c0dd44f38bc744e4587020e9aac5d63 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 10 Jun 2024 22:08:36 -0700
Subject: [PATCH 33/71] Update track delegate to support updating priority on
 sendObject

---
 include/quicr/moq_track_delegate.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 5b8f2538..08ac0f35 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -89,6 +89,8 @@ namespace quicr {
          */
         SendError sendObject(const std::span<const uint8_t>& object);
         SendError sendObject(const std::span<const uint8_t>& object, uint32_t ttl);
+        SendError sendObject(const std::span<const uint8_t>& object, uint8_t priority);
+        SendError sendObject(const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl);
 
         /**
          * @brief Read object from track

From 97df872f54617766fb16c1cd58e33b7dae3f4428 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 10:51:23 -0700
Subject: [PATCH 34/71] Update close() to include app_reason_code

---
 dependencies/transport | 2 +-
 src/moq_instance.cpp   | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dependencies/transport b/dependencies/transport
index 4430d5fc..645e036f 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 4430d5fc3125dec3e310772cd1cadbd8574e80ee
+Subproject commit 645e036fc4a0ac506829899641c6b102a1211121
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index d96c277f..9997c5d7 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -268,6 +268,7 @@ namespace quicr {
                                   << std::dec << std::flush;
                     stream_buffer->resetAny();
                     conn_ctx.setup_complete = true;
+
                     return true;
                 }
                 break;
@@ -395,8 +396,7 @@ namespace quicr {
         }
         _logger->info << std::flush;
 
-        // TODO(tievens): update transport to allow passing the reason/error code value
-        _transport->close(conn_id);
+        _transport->close(conn_id, static_cast<uint64_t>(reason));
 
         if (_client_mode) {
             _logger->info << "Client connection closed, stopping client" << std::flush;

From 6d52a9cf67da84096408559a74cbf3f0bc9e5d39 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 17:27:02 -0700
Subject: [PATCH 35/71] MOQ update to add metrics and endpoint_id

* Fixes parameter parsing of type not being uintV
* Adds endpoint_id parameter type
* Implement metrics connection and data context info updates
  for control channel.
* Re-enabled metrics
---
 cmd/moq-example/client.cpp   |   2 +-
 cmd/moq-example/server.cpp   |   2 +-
 include/quicr/moq_instance.h |   2 +-
 include/quicr/moq_messages.h |   5 +-
 src/moq_instance.cpp         |  49 ++++++++++---
 src/moq_messages.cpp         | 132 ++++++++++++++++++++++-------------
 test/fake_transport.h        |   2 +-
 test/moq_messages.cpp        |   7 ++
 8 files changed, 141 insertions(+), 60 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 623c0f14..094d98ff 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -53,7 +53,7 @@ main(int argc, char* argv[])
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
     quicr::MoQInstanceClientConfig config;
-    config.instance_id = "moq_client";
+    config.endpoint_id = "moq_client";
     config.server_host_ip = "127.0.0.1";
     config.server_port = 1234;
     config.server_proto = qtransport::TransportProtocol::QUIC;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 5e24878e..ee189862 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -34,7 +34,7 @@ main()
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
     quicr::MoQInstanceServerConfig config;
-    config.instance_id = "moq_server";
+    config.endpoint_id = "moq_server";
     config.server_bind_ip = "127.0.0.1";
     config.server_port = 1234;
     config.server_proto = qtransport::TransportProtocol::QUIC;
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 7f425ae1..1ee2dfe8 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -20,7 +20,7 @@ namespace quicr {
 
     struct MoQInstanceConfig
     {
-        std::string instance_id; /// Instance ID for the client or server, should be unique
+        std::string endpoint_id; /// Endpoint ID for the client or server, should be unique
         TransportConfig transport_config;
     };
 
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index a4e045f4..f2028277 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -80,6 +80,7 @@ enum struct ParameterType : uint8_t {
   Role = 0x0,
   Path = 0x1,
   AuthorizationInfo = 0x2, // version specific, unused
+  EndpointId = 0xF0, // Endpoint ID, using temp value for now
   Invalid = 0xFF, // used internally.
 };
 
@@ -103,6 +104,7 @@ struct MoqClientSetup {
   std::vector<Version> supported_versions;
   MoqParameter role_parameter;
   MoqParameter path_parameter;
+  MoqParameter endpoint_id_parameter;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
                                                        const MoqClientSetup& msg);
@@ -117,6 +119,7 @@ struct MoqServerSetup {
   Version selection_version;
   MoqParameter role_parameter;
   MoqParameter path_parameter;
+  MoqParameter endpoint_id_parameter;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
                                                        const MoqServerSetup& msg);
@@ -149,7 +152,7 @@ struct MoqSubscribe {
   uint64_t end_group {0};
   uint64_t start_object {0};
   uint64_t end_object {0};
-  uint64_t num_params {0};
+  std::optional<uint64_t> num_params;
   std::vector<MoqParameter> track_params;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 9997c5d7..4f3c75a5 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -77,9 +77,7 @@ namespace quicr {
                                                        *this, _logger);
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        // TODO(tievens) add back after endpoint_id is added
-        // _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
-        _transport->start(nullptr, nullptr);
+        _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
 #else
         _transport->start(nullptr, nullptr);
 #endif
@@ -104,9 +102,7 @@ namespace quicr {
         _status = Status::CLIENT_CONNECTING;
 
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-        // TODO(tievens): Add back after endpoint_id is added
-        //auto conn_id = _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
-        auto conn_id = _transport->start(nullptr, nullptr);
+        auto conn_id = _transport->start(_mexport.metrics_conn_samples, _mexport.metrics_data_samples);
 #else
         auto conn_id = _transport->start(nullptr, nullptr);
 #endif
@@ -147,6 +143,8 @@ namespace quicr {
         client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
         client_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
         client_setup.role_parameter.param_value = { 0x03 };
+        client_setup.endpoint_id_parameter.param_value.assign(_client_config.endpoint_id.begin(),
+                                                              _client_config.endpoint_id.end());
 
         buffer << client_setup;
 
@@ -164,6 +162,9 @@ namespace quicr {
         server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
         server_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
         server_setup.role_parameter.param_value = { 0x03 };
+        server_setup.endpoint_id_parameter.param_value.assign(_server_config.endpoint_id.begin(),
+                                                              _server_config.endpoint_id.end());
+
 
         buffer << server_setup;
 
@@ -239,7 +240,9 @@ namespace quicr {
 
                         }
 
-                        _logger->info << "Client setup received, "
+                        std::string client_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
+                                                        msg.endpoint_id_parameter.param_value.end());
+                        _logger->info << "Client setup received from: " << client_endpoint_id
                                       << " num_versions: " << msg.num_versions
                                       << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
                                       << " version: 0x" << std::hex << msg.supported_versions.front()
@@ -248,6 +251,14 @@ namespace quicr {
                         conn_ctx.client_version = msg.supported_versions.front();
                         stream_buffer->resetAny();
 
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+                        _mexport.set_conn_ctx_info(conn_ctx.conn_id, {.endpoint_id = client_endpoint_id,
+                                                                            .relay_id = _server_config.endpoint_id,
+                                                                            .data_ctx_info = {}}, false);
+                        _mexport.set_data_ctx_info(conn_ctx.conn_id, *conn_ctx.ctrl_data_ctx_id,
+                                                   {.subscribe = false, .nspace = {}});
+#endif
+
                         send_server_setup(conn_ctx);
                         conn_ctx.setup_complete = true;
                         return true;
@@ -262,13 +273,30 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqServerSetup>();
                 if (*stream_buffer >> msg) {
-                    _logger->info << "Server setup received,"
+                    std::string server_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
+                                msg.endpoint_id_parameter.param_value.end());
+
+                    _logger->info << "Server setup received"
+                                  << " from: " << server_endpoint_id
+                                  << std::string(msg.endpoint_id_parameter.param_value.begin(),
+                                                 msg.endpoint_id_parameter.param_value.end())
                                   << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
                                   << " selected_version: 0x" << std::hex << msg.selection_version
                                   << std::dec << std::flush;
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+                    _mexport.set_conn_ctx_info(conn_ctx.conn_id, {.endpoint_id = server_endpoint_id,
+                                                                        .relay_id = _server_config.endpoint_id,
+                                                                        .data_ctx_info = {}}, false);
+
+                    _mexport.set_data_ctx_info(conn_ctx.conn_id, *conn_ctx.ctrl_data_ctx_id,
+                                               {.subscribe = false, .nspace = {}});
+#endif
+
                     stream_buffer->resetAny();
                     conn_ctx.setup_complete = true;
 
+
                     return true;
                 }
                 break;
@@ -300,6 +328,11 @@ namespace quicr {
             _logger->info << "Connection established, creating bi-dir stream and sending CLIENT_SETUP" << std::flush;
 
             conn_ctx.ctrl_data_ctx_id = _transport->createDataContext(conn_id, true, 0, true);
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+            _mexport.set_data_ctx_info(conn_ctx.conn_id, *conn_ctx.ctrl_data_ctx_id,
+                                       {.subscribe = false, .nspace = {}});
+#endif
+
             send_client_setup();
         }
 
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index bd681e97..e077008a 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -136,11 +136,10 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
       break;
   }
 
-  buffer.push(qtransport::to_uintV(msg.num_params));
+  buffer.push(qtransport::to_uintV(msg.track_params.size()));
   for (const auto& param: msg.track_params) {
     buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.param_type)));
-    buffer.push(qtransport::to_uintV(param.param_length));
-    buffer.push(param.param_value);
+    buffer.push_lv(param.param_value);
   }
 
   return buffer;
@@ -238,21 +237,24 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
       [[fallthrough]];
     }
     case 9: {
-      if (!msg.current_param.has_value()) {
-        if (!parse_uintV_field(buffer, msg.num_params)) {
+      if (!msg.num_params.has_value()) {
+        uint64_t num = 0;
+        if (!parse_uintV_field(buffer, num)) {
           return false;
         }
-        msg.current_param = MoqParameter{};
+
+        msg.num_params = num;
       }
       // parse each param
-      while (msg.num_params > 0) {
-        if (!msg.current_param.value().param_type) {
-          auto val = buffer.front();
-          if (!val) {
+      while (*msg.num_params > 0) {
+        if (!msg.current_param.has_value()) {
+          uint64_t type {0};
+          if (!parse_uintV_field(buffer, type)) {
             return false;
           }
-          msg.current_param.value().param_type = *val;
-          buffer.pop();
+
+          msg.current_param = MoqParameter{};
+          msg.current_param->param_type = type;
         }
 
         // decode param_len:<bytes>
@@ -263,9 +265,10 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         msg.current_param.value().param_length = param->size();
         msg.current_param.value().param_value = param.value();
         msg.track_params.push_back(msg.current_param.value());
-        msg.current_param = MoqParameter{};
-        msg.num_params -= 1;
+        msg.current_param = std::nullopt;
+        *msg.num_params -= 1;
       }
+
       msg.parsing_completed = true;
       [[fallthrough]];
     }
@@ -545,12 +548,13 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
   // parse each param
   while (msg.num_params > 0) {
     if (!msg.current_param.param_type) {
-      auto val = buffer.front();
-      if (!val) {
+      uint64_t type {0};
+      if (!parse_uintV_field(buffer, type)) {
         return false;
       }
-      msg.current_param.param_type = *val;
-      buffer.pop();
+
+      msg.current_param = {};
+      msg.current_param.param_type = type;
     }
 
     // decode param_len:<bytes>
@@ -1052,10 +1056,14 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   }
 
   /// num params
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(2)));
   // role param
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
   buffer.push_lv(msg.role_parameter.param_value);
+  // endpoint_id param
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(ParameterType::EndpointId)));
+  buffer.push_lv(msg.endpoint_id_parameter.param_value);
+
   return buffer;
 }
 
@@ -1089,26 +1097,39 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
         msg.num_params = params;
       }
       while (msg.num_params > 0) {
-        if (!msg.current_param.has_value()) {
-          auto val = buffer.front();
-          if (!val) {
-            return false;
+          if (!msg.current_param.has_value()) {
+              uint64_t type{ 0 };
+              if (!parse_uintV_field(buffer, type)) {
+                  return false;
+              }
+
+              msg.current_param = MoqParameter{};
+              msg.current_param->param_type = type;
           }
-          msg.current_param = MoqParameter{};
-          msg.current_param->param_type = *val;
-          buffer.pop();
-        }
 
-        auto param = buffer.decode_bytes();
-        if (!param) {
-          return false;
-        }
-        msg.current_param->param_length = param->size();
-        msg.current_param->param_value = param.value();
-        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role  ?
-          msg.role_parameter = std::move(msg.current_param.value()) : msg.path_parameter = std::move(msg.current_param.value());
-        msg.current_param = MoqParameter{};
-        msg.num_params.value() -= 1;
+          auto param = buffer.decode_bytes();
+          if (!param) {
+              return false;
+          }
+          msg.current_param->param_length = param->size();
+          msg.current_param->param_value = param.value();
+
+          switch (static_cast<ParameterType>(msg.current_param->param_type)) {
+              case ParameterType::Role:
+                  msg.role_parameter = std::move(msg.current_param.value());
+                  break;
+              case ParameterType::Path:
+                  msg.path_parameter = std::move(msg.current_param.value());
+                  break;
+              case ParameterType::EndpointId:
+                  msg.endpoint_id_parameter = std::move(msg.current_param.value());
+                  break;
+              default:
+                  break;
+          }
+
+          msg.current_param = std::nullopt;
+          msg.num_params.value() -= 1;
       }
 
       msg.parse_completed = true;
@@ -1136,10 +1157,15 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   buffer.push(qtransport::to_uintV(msg.selection_version));
 
   /// num params
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(1)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(2)));
   // role param
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
   buffer.push_lv(msg.role_parameter.param_value);
+
+  // endpoint_id param
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(ParameterType::EndpointId)));
+  buffer.push_lv(msg.endpoint_id_parameter.param_value);
+
   return buffer;
 }
 
@@ -1162,13 +1188,13 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
       }
       while (msg.num_params > 0) {
         if (!msg.current_param.has_value()) {
-          auto val = buffer.front();
-          if (!val) {
-            return false;
+          uint64_t type {0};
+          if (!parse_uintV_field(buffer, type)) {
+              return false;
           }
+
           msg.current_param = MoqParameter{};
-          msg.current_param->param_type = *val;
-          buffer.pop();
+          msg.current_param->param_type = type;
         }
 
         auto param = buffer.decode_bytes();
@@ -1177,10 +1203,22 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
         }
         msg.current_param->param_length = param->size();
         msg.current_param->param_value = param.value();
-        static_cast<ParameterType>(msg.current_param->param_type) == ParameterType::Role
-          ? msg.role_parameter = std::move(msg.current_param.value())
-          : msg.path_parameter = std::move(msg.current_param.value());
-        msg.current_param = MoqParameter{};
+
+        switch (static_cast<ParameterType>(msg.current_param->param_type)) {
+            case ParameterType::Role:
+                msg.role_parameter = std::move(msg.current_param.value());
+                break;
+            case ParameterType::Path:
+                msg.path_parameter = std::move(msg.current_param.value());
+                break;
+            case ParameterType::EndpointId:
+                msg.endpoint_id_parameter = std::move(msg.current_param.value());
+                break;
+            default:
+                break;
+        }
+
+        msg.current_param = std::nullopt;
         msg.num_params.value() -= 1;
       }
       msg.parse_completed = true;
diff --git a/test/fake_transport.h b/test/fake_transport.h
index 25347483..a9c7bf89 100644
--- a/test/fake_transport.h
+++ b/test/fake_transport.h
@@ -60,7 +60,7 @@ struct FakeTransport : public ITransport
                           [[maybe_unused]] uint8_t priority) override {}
 
   std::shared_ptr<StreamBuffer<uint8_t>> getStreamBuffer(TransportConnId, uint64_t) override { return nullptr;}
-  void close(const TransportConnId& /* conn_id */) override {};
+  void close(const TransportConnId& /* conn_id */, uint64_t) override {};
 
   void deleteDataContext([[maybe_unused]] const TransportConnId& conn_id,
                          [[maybe_unused]] DataContextId data_ctx_id) override
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 85583f3d..51bcc42f 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -5,6 +5,7 @@
 #include <quicr/moq_messages.h>
 #include <sstream>
 #include <string>
+#include <sys/socket.h>
 
 using namespace quicr;
 using namespace quicr::messages;
@@ -528,12 +529,14 @@ TEST_CASE("SubscribeDone (content-exists)  Message encode/decode")
 TEST_CASE("ClientSetup  Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
+  const std::string endpoint_id = "client test";
   auto client_setup = MoqClientSetup {};
   client_setup.num_versions = 2;
   client_setup.supported_versions = {0x1000, 0x2000};
   client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
   client_setup.role_parameter.param_length = 0x1;
   client_setup.role_parameter.param_value = {0xFF};
+  client_setup.endpoint_id_parameter.param_value.assign(endpoint_id.begin(), endpoint_id.end());
 
   buffer << client_setup;
 
@@ -543,17 +546,20 @@ TEST_CASE("ClientSetup  Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::CLIENT_SETUP), client_setup_out));
   CHECK_EQ(client_setup.supported_versions, client_setup_out.supported_versions);
   CHECK_EQ(client_setup.role_parameter.param_value, client_setup_out.role_parameter.param_value);
+  CHECK_EQ(client_setup.endpoint_id_parameter.param_value, client_setup_out.endpoint_id_parameter.param_value);
 }
 
 
 TEST_CASE("ServerSetup  Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
+  const std::string endpoint_id = "server_test";
   auto server_setup = MoqServerSetup {};
   server_setup.selection_version = {0x1000};
   server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
   server_setup.role_parameter.param_length = 0x1;
   server_setup.role_parameter.param_value = {0xFF};
+  server_setup.endpoint_id_parameter.param_value.assign(endpoint_id.begin(), endpoint_id.end());
 
   buffer << server_setup;
 
@@ -563,6 +569,7 @@ TEST_CASE("ServerSetup  Message encode/decode")
   CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SERVER_SETUP), server_setup_out));
   CHECK_EQ(server_setup.selection_version, server_setup_out.selection_version);
   CHECK_EQ(server_setup.role_parameter.param_value, server_setup.role_parameter.param_value);
+  CHECK_EQ(server_setup.endpoint_id_parameter.param_value, server_setup_out.endpoint_id_parameter.param_value);
 }
 
 TEST_CASE("ObjectStream  Message encode/decode")

From d133cf06f34aa8f8cdf0eb3d24a86bee21454b89 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 22:34:25 -0700
Subject: [PATCH 36/71] Add cxxopts for cli parsing

---
 cmd/moq-example/client.cpp |   69 +-
 cmd/moq-example/server.cpp |   46 +-
 include/oss/cxxopts.hpp    | 2908 ++++++++++++++++++++++++++++++++++++
 3 files changed, 2994 insertions(+), 29 deletions(-)
 create mode 100644 include/oss/cxxopts.hpp

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 094d98ff..189d05da 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -3,9 +3,9 @@
 
 #include "signal_handler.h"
 
-#include <chrono>
 #include <iostream>
-#include <thread>
+#include <oss/cxxopts.hpp>
+
 
 class clientDelegate : public quicr::MoQInstanceDelegate
 {
@@ -23,27 +23,47 @@ main(int argc, char* argv[])
     int result_code = EXIT_SUCCESS;
 
     cantina::LoggerPointer logger = std::make_shared<cantina::Logger>("qclient");
-    logger->SetLogLevel("DEBUG");
-
-    if ((argc != 2) && (argc != 3)) {
-        std::cerr << "Relay address and port set in MOQ_RELAY and MOQ_PORT env variables." << std::endl;
-        std::cerr << std::endl;
-        std::cerr << "Usage publisher: qclient pub <track_namespace> <track_name>" << std::endl;
-        std::cerr << "Usage subscriber: qclient <track_namespace> <track_name>" << std::endl;
-        exit(-1); // NOLINT(concurrency-mt-unsafe)
+
+    cxxopts::Options options("qclient", "MOQ Example Client");
+    options
+      .set_width(75)
+      .set_tab_expansion()
+      .allow_unrecognised_options()
+      .add_options()
+      ("h,help", "Print help")
+      ("d,debug", "Enable debugging") // a bool parameter
+      ("r,host", "Relay host/IP", cxxopts::value<std::string>()->default_value("localhost"))
+      ("p,port", "Relay port", cxxopts::value<uint16_t>()->default_value("1234"))
+      ("e,endpoint_id", "This client endpoint ID", cxxopts::value<std::string>()->default_value("moq-client"))
+      ("q,qlog", "Enable qlog using path", cxxopts::value<std::string>())
+    ; // end of options
+
+    options.add_options("Publisher")
+      ("pn,pub_namespace", "Track namespace", cxxopts::value<std::string>()->default_value("client1"))
+      ("pt,pub_name", "Track name", cxxopts::value<std::vector<std::string>>()->default_value("chat"))
+    ;
+
+    options.add_options("Subscriber")
+      ("sn,sub_namespace", "Track namespace", cxxopts::value<std::string>()->default_value("client1"))
+      ("st,sub_name", "Track name", cxxopts::value<std::vector<std::string>>()->default_value("chat"))
+    ;
+
+    auto result = options.parse(argc, argv);
+
+    if (result.count("help"))
+    {
+        std::cout << options.help({"", "Publisher", "Subscriber"}) << std::endl;
+        return true;
     }
 
-    // NOLINTNEXTLINE(concurrency-mt-unsafe)
-    const auto* relayName = getenv("MOQ_RELAY");
-    if (relayName == nullptr) {
-        relayName = "127.0.0.1";
+    std::string qlog_path;
+    if (result.count("qlog")) {
+        qlog_path = result["qlog"].as<std::string>();
     }
 
-    // NOLINTNEXTLINE(concurrency-mt-unsafe)
-    const auto* portVar = getenv("MOQ_PORT");
-    int port = 1234;
-    if (portVar != nullptr) {
-        port = atoi(portVar); // NOLINT(cert-err34-c)
+    if (result.count("debug") && result["debug"].as<bool>() == true) {
+        logger->info << "setting debug level" << std::flush;
+        logger->SetLogLevel("DEBUG");
     }
 
     // Install a signal handlers to catch operating system signals
@@ -53,13 +73,16 @@ main(int argc, char* argv[])
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
     quicr::MoQInstanceClientConfig config;
-    config.endpoint_id = "moq_client";
-    config.server_host_ip = "127.0.0.1";
-    config.server_port = 1234;
+    config.endpoint_id = result["endpoint_id"].as<std::string>();
+    config.server_host_ip = result["host"].as<std::string>();
+    config.server_port = result["port"].as<uint16_t>();
     config.server_proto = qtransport::TransportProtocol::QUIC;
-    config.transport_config.debug = true;
+    config.transport_config.debug = result["debug"].as<bool>();;
     config.transport_config.use_reset_wait_strategy = false;
     config.transport_config.time_queue_max_duration = 5000;
+    config.transport_config.tls_cert_filename = nullptr;
+    config.transport_config.tls_key_filename = nullptr;
+    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
 
     auto delegate = std::make_shared<clientDelegate>();
 
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index ee189862..6ebc1604 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -4,6 +4,8 @@
 #include <cantina/logger.h>
 #include <condition_variable>
 #include <csignal>
+#include <oss/cxxopts.hpp>
+
 
 #include "signal_handler.h"
 
@@ -20,12 +22,43 @@ class serverDelegate : public quicr::MoQInstanceDelegate
 };
 
 int
-main()
+main(int argc, char* argv[])
 {
     int result_code = EXIT_SUCCESS;
 
     auto logger = std::make_shared<cantina::Logger>("qserver");
-    logger->SetLogLevel("DEBUG");
+
+    cxxopts::Options options("qclient", "MOQ Example Client");
+    options
+      .set_width(75)
+      .set_tab_expansion()
+      .allow_unrecognised_options()
+      .add_options()
+      ("h,help", "Print help")
+      ("d,debug", "Enable debugging") // a bool parameter
+      ("b,bind_ip", "Bind IP", cxxopts::value<std::string>()->default_value("127.0.0.1"))
+      ("p,port", "Listening port", cxxopts::value<uint16_t>()->default_value("1234"))
+      ("e,endpoint_id", "This relay/server endpoint ID", cxxopts::value<std::string>()->default_value("moq-server"))
+      ("q,qlog", "Enable qlog using path", cxxopts::value<std::string>())
+    ; // end of options
+
+    auto result = options.parse(argc, argv);
+
+    if (result.count("help"))
+    {
+        std::cout << options.help({""}) << std::endl;
+        return true;
+    }
+
+    std::string qlog_path;
+    if (result.count("qlog")) {
+        qlog_path = result["qlog"].as<std::string>();
+    }
+
+    if (result.count("debug") && result["debug"].as<bool>() == true) {
+        logger->info << "setting debug level" << std::flush;
+        logger->SetLogLevel("DEBUG");
+    }
 
     // Install a signal handlers to catch operating system signals
     installSignalHandlers();
@@ -34,15 +67,16 @@ main()
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
     quicr::MoQInstanceServerConfig config;
-    config.endpoint_id = "moq_server";
-    config.server_bind_ip = "127.0.0.1";
-    config.server_port = 1234;
+    config.endpoint_id = result["endpoint_id"].as<std::string>();
+    config.server_bind_ip = result["bind_ip"].as<std::string>();
+    config.server_port = result["port"].as<uint16_t>();
     config.server_proto = qtransport::TransportProtocol::QUIC;
-    config.transport_config.debug = true;
+    config.transport_config.debug = result["debug"].as<bool>();
     config.transport_config.tls_cert_filename = "./server-cert.pem";
     config.transport_config.tls_key_filename = "./server-key.pem";
     config.transport_config.use_reset_wait_strategy = false;
     config.transport_config.time_queue_max_duration = 5000;
+    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
 
     auto delegate = std::make_shared<serverDelegate>();
 
diff --git a/include/oss/cxxopts.hpp b/include/oss/cxxopts.hpp
new file mode 100644
index 00000000..ff163e54
--- /dev/null
+++ b/include/oss/cxxopts.hpp
@@ -0,0 +1,2908 @@
+/*
+
+Copyright (c) 2014-2022 Jarryd Beck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+// vim: ts=2:sw=2:expandtab
+
+#ifndef CXXOPTS_HPP_INCLUDED
+#define CXXOPTS_HPP_INCLUDED
+
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+#include <limits>
+#include <initializer_list>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+#include <algorithm>
+#include <locale>
+
+#ifdef CXXOPTS_NO_EXCEPTIONS
+#include <iostream>
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#  if (__GNUC__ * 10 + __GNUC_MINOR__) < 49
+#    define CXXOPTS_NO_REGEX true
+#  endif
+#endif
+#if defined(_MSC_VER) && !defined(__clang__)
+#define CXXOPTS_LINKONCE_CONST	__declspec(selectany) extern
+#define CXXOPTS_LINKONCE		__declspec(selectany) extern
+#else
+#define CXXOPTS_LINKONCE_CONST
+#define CXXOPTS_LINKONCE
+#endif
+
+#ifndef CXXOPTS_NO_REGEX
+#  include <regex>
+#endif  // CXXOPTS_NO_REGEX
+
+// Nonstandard before C++17, which is coincidentally what we also need for <optional>
+#ifdef __has_include
+#  if __has_include(<optional>)
+#    include <optional>
+#    ifdef __cpp_lib_optional
+#      define CXXOPTS_HAS_OPTIONAL
+#    endif
+#  endif
+#endif
+
+#define CXXOPTS_FALLTHROUGH
+#ifdef __has_cpp_attribute
+  #if __has_cpp_attribute(fallthrough)
+    #undef CXXOPTS_FALLTHROUGH
+    #define CXXOPTS_FALLTHROUGH [[fallthrough]]
+  #endif
+#endif
+
+#if __cplusplus >= 201603L
+#define CXXOPTS_NODISCARD [[nodiscard]]
+#else
+#define CXXOPTS_NODISCARD
+#endif
+
+#ifndef CXXOPTS_VECTOR_DELIMITER
+#define CXXOPTS_VECTOR_DELIMITER ','
+#endif
+
+#define CXXOPTS__VERSION_MAJOR 3
+#define CXXOPTS__VERSION_MINOR 2
+#define CXXOPTS__VERSION_PATCH 1
+
+#if (__GNUC__ < 10 || (__GNUC__ == 10 && __GNUC_MINOR__ < 1)) && __GNUC__ >= 6
+  #define CXXOPTS_NULL_DEREF_IGNORE
+#endif
+
+#if defined(__GNUC__)
+#define DO_PRAGMA(x) _Pragma(#x)
+#define CXXOPTS_DIAGNOSTIC_PUSH DO_PRAGMA(GCC diagnostic push)
+#define CXXOPTS_DIAGNOSTIC_POP DO_PRAGMA(GCC diagnostic pop)
+#define CXXOPTS_IGNORE_WARNING(x) DO_PRAGMA(GCC diagnostic ignored x)
+#else
+// define other compilers here if needed
+#define CXXOPTS_DIAGNOSTIC_PUSH
+#define CXXOPTS_DIAGNOSTIC_POP
+#define CXXOPTS_IGNORE_WARNING(x)
+#endif
+
+#ifdef CXXOPTS_NO_RTTI
+#define CXXOPTS_RTTI_CAST static_cast
+#else
+#define CXXOPTS_RTTI_CAST dynamic_cast
+#endif
+
+namespace cxxopts {
+static constexpr struct {
+  uint8_t major, minor, patch;
+} version = {
+  CXXOPTS__VERSION_MAJOR,
+  CXXOPTS__VERSION_MINOR,
+  CXXOPTS__VERSION_PATCH
+};
+} // namespace cxxopts
+
+//when we ask cxxopts to use Unicode, help strings are processed using ICU,
+//which results in the correct lengths being computed for strings when they
+//are formatted for the help output
+//it is necessary to make sure that <unicode/unistr.h> can be found by the
+//compiler, and that icu-uc is linked in to the binary.
+
+#ifdef CXXOPTS_USE_UNICODE
+#include <unicode/unistr.h>
+
+namespace cxxopts {
+
+using String = icu::UnicodeString;
+
+inline
+String
+toLocalString(std::string s)
+{
+  return icu::UnicodeString::fromUTF8(std::move(s));
+}
+
+// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it:
+// warning: base class 'class std::enable_shared_from_this<cxxopts::Value>' has accessible non-virtual destructor
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor")
+// This will be ignored under other compilers like LLVM clang.
+class UnicodeStringIterator
+{
+  public:
+
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = int32_t;
+  using difference_type = std::ptrdiff_t;
+  using pointer = value_type*;
+  using reference = value_type&;
+
+  UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos)
+  : s(string)
+  , i(pos)
+  {
+  }
+
+  value_type
+  operator*() const
+  {
+    return s->char32At(i);
+  }
+
+  bool
+  operator==(const UnicodeStringIterator& rhs) const
+  {
+    return s == rhs.s && i == rhs.i;
+  }
+
+  bool
+  operator!=(const UnicodeStringIterator& rhs) const
+  {
+    return !(*this == rhs);
+  }
+
+  UnicodeStringIterator&
+  operator++()
+  {
+    ++i;
+    return *this;
+  }
+
+  UnicodeStringIterator
+  operator+(int32_t v)
+  {
+    return UnicodeStringIterator(s, i + v);
+  }
+
+  private:
+  const icu::UnicodeString* s;
+  int32_t i;
+};
+CXXOPTS_DIAGNOSTIC_POP
+
+inline
+String&
+stringAppend(String&s, String a)
+{
+  return s.append(std::move(a));
+}
+
+inline
+String&
+stringAppend(String& s, std::size_t n, UChar32 c)
+{
+  for (std::size_t i = 0; i != n; ++i)
+  {
+    s.append(c);
+  }
+
+  return s;
+}
+
+template <typename Iterator>
+String&
+stringAppend(String& s, Iterator begin, Iterator end)
+{
+  while (begin != end)
+  {
+    s.append(*begin);
+    ++begin;
+  }
+
+  return s;
+}
+
+inline
+size_t
+stringLength(const String& s)
+{
+  return static_cast<size_t>(s.length());
+}
+
+inline
+std::string
+toUTF8String(const String& s)
+{
+  std::string result;
+  s.toUTF8String(result);
+
+  return result;
+}
+
+inline
+bool
+empty(const String& s)
+{
+  return s.isEmpty();
+}
+
+} // namespace cxxopts
+
+namespace std {
+
+inline
+cxxopts::UnicodeStringIterator
+begin(const icu::UnicodeString& s)
+{
+  return cxxopts::UnicodeStringIterator(&s, 0);
+}
+
+inline
+cxxopts::UnicodeStringIterator
+end(const icu::UnicodeString& s)
+{
+  return cxxopts::UnicodeStringIterator(&s, s.length());
+}
+
+} // namespace std
+
+//ifdef CXXOPTS_USE_UNICODE
+#else
+
+namespace cxxopts {
+
+using String = std::string;
+
+template <typename T>
+T
+toLocalString(T&& t)
+{
+  return std::forward<T>(t);
+}
+
+inline
+std::size_t
+stringLength(const String& s)
+{
+  return s.length();
+}
+
+inline
+String&
+stringAppend(String&s, const String& a)
+{
+  return s.append(a);
+}
+
+inline
+String&
+stringAppend(String& s, std::size_t n, char c)
+{
+  return s.append(n, c);
+}
+
+template <typename Iterator>
+String&
+stringAppend(String& s, Iterator begin, Iterator end)
+{
+  return s.append(begin, end);
+}
+
+template <typename T>
+std::string
+toUTF8String(T&& t)
+{
+  return std::forward<T>(t);
+}
+
+inline
+bool
+empty(const std::string& s)
+{
+  return s.empty();
+}
+
+} // namespace cxxopts
+
+//ifdef CXXOPTS_USE_UNICODE
+#endif
+
+namespace cxxopts {
+
+namespace {
+CXXOPTS_LINKONCE_CONST std::string LQUOTE("\'");
+CXXOPTS_LINKONCE_CONST std::string RQUOTE("\'");
+} // namespace
+
+// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we
+// want to silence it: warning: base class 'class
+// std::enable_shared_from_this<cxxopts::Value>' has accessible non-virtual
+// destructor This will be ignored under other compilers like LLVM clang.
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor")
+
+// some older versions of GCC warn under this warning
+CXXOPTS_IGNORE_WARNING("-Weffc++")
+class Value : public std::enable_shared_from_this<Value>
+{
+  public:
+
+  virtual ~Value() = default;
+
+  virtual
+  std::shared_ptr<Value>
+  clone() const = 0;
+
+  virtual void
+  add(const std::string& text) const = 0;
+
+  virtual void
+  parse(const std::string& text) const = 0;
+
+  virtual void
+  parse() const = 0;
+
+  virtual bool
+  has_default() const = 0;
+
+  virtual bool
+  is_container() const = 0;
+
+  virtual bool
+  has_implicit() const = 0;
+
+  virtual std::string
+  get_default_value() const = 0;
+
+  virtual std::string
+  get_implicit_value() const = 0;
+
+  virtual std::shared_ptr<Value>
+  default_value(const std::string& value) = 0;
+
+  virtual std::shared_ptr<Value>
+  implicit_value(const std::string& value) = 0;
+
+  virtual std::shared_ptr<Value>
+  no_implicit_value() = 0;
+
+  virtual bool
+  is_boolean() const = 0;
+};
+
+CXXOPTS_DIAGNOSTIC_POP
+
+namespace exceptions {
+
+class exception : public std::exception
+{
+  public:
+  explicit exception(std::string  message)
+  : m_message(std::move(message))
+  {
+  }
+
+  CXXOPTS_NODISCARD
+  const char*
+  what() const noexcept override
+  {
+    return m_message.c_str();
+  }
+
+  private:
+  std::string m_message;
+};
+
+class specification : public exception
+{
+  public:
+
+  explicit specification(const std::string& message)
+  : exception(message)
+  {
+  }
+};
+
+class parsing : public exception
+{
+  public:
+  explicit parsing(const std::string& message)
+  : exception(message)
+  {
+  }
+};
+
+class option_already_exists : public specification
+{
+  public:
+  explicit option_already_exists(const std::string& option)
+  : specification("Option " + LQUOTE + option + RQUOTE + " already exists")
+  {
+  }
+};
+
+class invalid_option_format : public specification
+{
+  public:
+  explicit invalid_option_format(const std::string& format)
+  : specification("Invalid option format " + LQUOTE + format + RQUOTE)
+  {
+  }
+};
+
+class invalid_option_syntax : public parsing {
+  public:
+  explicit invalid_option_syntax(const std::string& text)
+  : parsing("Argument " + LQUOTE + text + RQUOTE +
+            " starts with a - but has incorrect syntax")
+  {
+  }
+};
+
+class no_such_option : public parsing
+{
+  public:
+  explicit no_such_option(const std::string& option)
+  : parsing("Option " + LQUOTE + option + RQUOTE + " does not exist")
+  {
+  }
+};
+
+class missing_argument : public parsing
+{
+  public:
+  explicit missing_argument(const std::string& option)
+  : parsing(
+      "Option " + LQUOTE + option + RQUOTE + " is missing an argument"
+    )
+  {
+  }
+};
+
+class option_requires_argument : public parsing
+{
+  public:
+  explicit option_requires_argument(const std::string& option)
+  : parsing(
+      "Option " + LQUOTE + option + RQUOTE + " requires an argument"
+    )
+  {
+  }
+};
+
+class gratuitous_argument_for_option : public parsing
+{
+  public:
+  gratuitous_argument_for_option
+  (
+    const std::string& option,
+    const std::string& arg
+  )
+  : parsing(
+      "Option " + LQUOTE + option + RQUOTE +
+      " does not take an argument, but argument " +
+      LQUOTE + arg + RQUOTE + " given"
+    )
+  {
+  }
+};
+
+class requested_option_not_present : public parsing
+{
+  public:
+  explicit requested_option_not_present(const std::string& option)
+  : parsing("Option " + LQUOTE + option + RQUOTE + " not present")
+  {
+  }
+};
+
+class option_has_no_value : public exception
+{
+  public:
+  explicit option_has_no_value(const std::string& option)
+  : exception(
+      !option.empty() ?
+      ("Option " + LQUOTE + option + RQUOTE + " has no value") :
+      "Option has no value")
+  {
+  }
+};
+
+class incorrect_argument_type : public parsing
+{
+  public:
+  explicit incorrect_argument_type
+  (
+    const std::string& arg
+  )
+  : parsing(
+      "Argument " + LQUOTE + arg + RQUOTE + " failed to parse"
+    )
+  {
+  }
+};
+
+} // namespace exceptions
+
+
+template <typename T>
+void throw_or_mimic(const std::string& text)
+{
+  static_assert(std::is_base_of<std::exception, T>::value,
+                "throw_or_mimic only works on std::exception and "
+                "deriving classes");
+
+#ifndef CXXOPTS_NO_EXCEPTIONS
+  // If CXXOPTS_NO_EXCEPTIONS is not defined, just throw
+  throw T{text};
+#else
+  // Otherwise manually instantiate the exception, print what() to stderr,
+  // and exit
+  T exception{text};
+  std::cerr << exception.what() << std::endl;
+  std::exit(EXIT_FAILURE);
+#endif
+}
+
+using OptionNames = std::vector<std::string>;
+
+namespace values {
+
+namespace parser_tool {
+
+struct IntegerDesc
+{
+  std::string negative = "";
+  std::string base     = "";
+  std::string value    = "";
+};
+struct ArguDesc {
+  std::string arg_name  = "";
+  bool        grouping  = false;
+  bool        set_value = false;
+  std::string value     = "";
+};
+
+#ifdef CXXOPTS_NO_REGEX
+inline IntegerDesc SplitInteger(const std::string &text)
+{
+  if (text.empty())
+  {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+  IntegerDesc desc;
+  const char *pdata = text.c_str();
+  if (*pdata == '-')
+  {
+    pdata += 1;
+    desc.negative = "-";
+  }
+  if (strncmp(pdata, "0x", 2) == 0)
+  {
+    pdata += 2;
+    desc.base = "0x";
+  }
+  if (*pdata != '\0')
+  {
+    desc.value = std::string(pdata);
+  }
+  else
+  {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+  return desc;
+}
+
+inline bool IsTrueText(const std::string &text)
+{
+  const char *pdata = text.c_str();
+  if (*pdata == 't' || *pdata == 'T')
+  {
+    pdata += 1;
+    if (strncmp(pdata, "rue\0", 4) == 0)
+    {
+      return true;
+    }
+  }
+  else if (strncmp(pdata, "1\0", 2) == 0)
+  {
+    return true;
+  }
+  return false;
+}
+
+inline bool IsFalseText(const std::string &text)
+{
+  const char *pdata = text.c_str();
+  if (*pdata == 'f' || *pdata == 'F')
+  {
+    pdata += 1;
+    if (strncmp(pdata, "alse\0", 5) == 0)
+    {
+      return true;
+    }
+  }
+  else if (strncmp(pdata, "0\0", 2) == 0)
+  {
+    return true;
+  }
+  return false;
+}
+
+inline OptionNames split_option_names(const std::string &text)
+{
+  OptionNames split_names;
+
+  std::string::size_type token_start_pos = 0;
+  auto length = text.length();
+
+  if (length == 0)
+  {
+    throw_or_mimic<exceptions::invalid_option_format>(text);
+  }
+
+  while (token_start_pos < length) {
+    const auto &npos = std::string::npos;
+    auto next_non_space_pos = text.find_first_not_of(' ', token_start_pos);
+    if (next_non_space_pos == npos) {
+      throw_or_mimic<exceptions::invalid_option_format>(text);
+    }
+    token_start_pos = next_non_space_pos;
+    auto next_delimiter_pos = text.find(',', token_start_pos);
+    if (next_delimiter_pos == token_start_pos) {
+      throw_or_mimic<exceptions::invalid_option_format>(text);
+    }
+    if (next_delimiter_pos == npos) {
+      next_delimiter_pos = length;
+    }
+    auto token_length = next_delimiter_pos - token_start_pos;
+    // validate the token itself matches the regex /([:alnum:][-_[:alnum:]]*/
+    {
+      const char* option_name_valid_chars =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz"
+        "0123456789"
+        "_-.?";
+
+      if (!std::isalnum(text[token_start_pos], std::locale::classic()) ||
+          text.find_first_not_of(option_name_valid_chars, token_start_pos) < next_delimiter_pos) {
+        throw_or_mimic<exceptions::invalid_option_format>(text);
+      }
+    }
+    split_names.emplace_back(text.substr(token_start_pos, token_length));
+    token_start_pos = next_delimiter_pos + 1;
+  }
+  return split_names;
+}
+
+inline ArguDesc ParseArgument(const char *arg, bool &matched)
+{
+  ArguDesc argu_desc;
+  const char *pdata = arg;
+  matched = false;
+  if (strncmp(pdata, "--", 2) == 0)
+  {
+    pdata += 2;
+    if (isalnum(*pdata, std::locale::classic()))
+    {
+      argu_desc.arg_name.push_back(*pdata);
+      pdata += 1;
+      while (isalnum(*pdata, std::locale::classic()) || *pdata == '-' || *pdata == '_')
+      {
+        argu_desc.arg_name.push_back(*pdata);
+        pdata += 1;
+      }
+      if (argu_desc.arg_name.length() > 1)
+      {
+        if (*pdata == '=')
+        {
+          argu_desc.set_value = true;
+          pdata += 1;
+          if (*pdata != '\0')
+          {
+            argu_desc.value = std::string(pdata);
+          }
+          matched = true;
+        }
+        else if (*pdata == '\0')
+        {
+          matched = true;
+        }
+      }
+    }
+  }
+  else if (strncmp(pdata, "-", 1) == 0)
+  {
+    pdata += 1;
+    argu_desc.grouping = true;
+    while (isalnum(*pdata, std::locale::classic()))
+    {
+      argu_desc.arg_name.push_back(*pdata);
+      pdata += 1;
+    }
+    matched = !argu_desc.arg_name.empty() && *pdata == '\0';
+  }
+  return argu_desc;
+}
+
+#else  // CXXOPTS_NO_REGEX
+
+namespace {
+CXXOPTS_LINKONCE
+const char* const integer_pattern =
+  "(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)";
+CXXOPTS_LINKONCE
+const char* const truthy_pattern =
+  "(t|T)(rue)?|1";
+CXXOPTS_LINKONCE
+const char* const falsy_pattern =
+  "(f|F)(alse)?|0";
+CXXOPTS_LINKONCE
+const char* const option_pattern =
+  "--([[:alnum:]][-_[:alnum:]\\.]+)(=(.*))?|-([[:alnum:]].*)";
+CXXOPTS_LINKONCE
+const char* const option_specifier_pattern =
+  "([[:alnum:]][-_[:alnum:]\\.]*)(,[ ]*[[:alnum:]][-_[:alnum:]]*)*";
+CXXOPTS_LINKONCE
+const char* const option_specifier_separator_pattern = ", *";
+
+} // namespace
+
+inline IntegerDesc SplitInteger(const std::string &text)
+{
+  static const std::basic_regex<char> integer_matcher(integer_pattern);
+
+  std::smatch match;
+  std::regex_match(text, match, integer_matcher);
+
+  if (match.length() == 0)
+  {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+
+  IntegerDesc desc;
+  desc.negative = match[1];
+  desc.base = match[2];
+  desc.value = match[3];
+
+  if (match.length(4) > 0)
+  {
+    desc.base = match[5];
+    desc.value = "0";
+    return desc;
+  }
+
+  return desc;
+}
+
+inline bool IsTrueText(const std::string &text)
+{
+  static const std::basic_regex<char> truthy_matcher(truthy_pattern);
+  std::smatch result;
+  std::regex_match(text, result, truthy_matcher);
+  return !result.empty();
+}
+
+inline bool IsFalseText(const std::string &text)
+{
+  static const std::basic_regex<char> falsy_matcher(falsy_pattern);
+  std::smatch result;
+  std::regex_match(text, result, falsy_matcher);
+  return !result.empty();
+}
+
+// Gets the option names specified via a single, comma-separated string,
+// and returns the separate, space-discarded, non-empty names
+// (without considering which or how many are single-character)
+inline OptionNames split_option_names(const std::string &text)
+{
+  static const std::basic_regex<char> option_specifier_matcher(option_specifier_pattern);
+  if (!std::regex_match(text.c_str(), option_specifier_matcher))
+  {
+    throw_or_mimic<exceptions::invalid_option_format>(text);
+  }
+
+  OptionNames split_names;
+
+  static const std::basic_regex<char> option_specifier_separator_matcher(option_specifier_separator_pattern);
+  constexpr int use_non_matches { -1 };
+  auto token_iterator = std::sregex_token_iterator(
+    text.begin(), text.end(), option_specifier_separator_matcher, use_non_matches);
+  std::copy(token_iterator, std::sregex_token_iterator(), std::back_inserter(split_names));
+  return split_names;
+}
+
+inline ArguDesc ParseArgument(const char *arg, bool &matched)
+{
+  static const std::basic_regex<char> option_matcher(option_pattern);
+  std::match_results<const char*> result;
+  std::regex_match(arg, result, option_matcher);
+  matched = !result.empty();
+
+  ArguDesc argu_desc;
+  if (matched) {
+    argu_desc.arg_name = result[1].str();
+    argu_desc.set_value = result[2].length() > 0;
+    argu_desc.value = result[3].str();
+    if (result[4].length() > 0)
+    {
+      argu_desc.grouping = true;
+      argu_desc.arg_name = result[4].str();
+    }
+  }
+
+  return argu_desc;
+}
+
+#endif  // CXXOPTS_NO_REGEX
+#undef CXXOPTS_NO_REGEX
+} // namespace parser_tool
+
+namespace detail {
+
+template <typename T, bool B>
+struct SignedCheck;
+
+template <typename T>
+struct SignedCheck<T, true>
+{
+  template <typename U>
+  void
+  operator()(bool negative, U u, const std::string& text)
+  {
+    if (negative)
+    {
+      if (u > static_cast<U>((std::numeric_limits<T>::min)()))
+      {
+        throw_or_mimic<exceptions::incorrect_argument_type>(text);
+      }
+    }
+    else
+    {
+      if (u > static_cast<U>((std::numeric_limits<T>::max)()))
+      {
+        throw_or_mimic<exceptions::incorrect_argument_type>(text);
+      }
+    }
+  }
+};
+
+template <typename T>
+struct SignedCheck<T, false>
+{
+  template <typename U>
+  void
+  operator()(bool, U, const std::string&) const {}
+};
+
+template <typename T, typename U>
+void
+check_signed_range(bool negative, U value, const std::string& text)
+{
+  SignedCheck<T, std::numeric_limits<T>::is_signed>()(negative, value, text);
+}
+
+} // namespace detail
+
+template <typename R, typename T>
+void
+checked_negate(R& r, T&& t, const std::string&, std::true_type)
+{
+  // if we got to here, then `t` is a positive number that fits into
+  // `R`. So to avoid MSVC C4146, we first cast it to `R`.
+  // See https://github.com/jarro2783/cxxopts/issues/62 for more details.
+  r = static_cast<R>(-static_cast<R>(t-1)-1);
+}
+
+template <typename R, typename T>
+void
+checked_negate(R&, T&&, const std::string& text, std::false_type)
+{
+  throw_or_mimic<exceptions::incorrect_argument_type>(text);
+}
+
+template <typename T>
+void
+integer_parser(const std::string& text, T& value)
+{
+  parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text);
+
+  using US = typename std::make_unsigned<T>::type;
+  constexpr bool is_signed = std::numeric_limits<T>::is_signed;
+
+  const bool          negative    = int_desc.negative.length() > 0;
+  const uint8_t       base        = int_desc.base.length() > 0 ? 16 : 10;
+  const std::string & value_match = int_desc.value;
+
+  US result = 0;
+
+  for (char ch : value_match)
+  {
+    US digit = 0;
+
+    if (ch >= '0' && ch <= '9')
+    {
+      digit = static_cast<US>(ch - '0');
+    }
+    else if (base == 16 && ch >= 'a' && ch <= 'f')
+    {
+      digit = static_cast<US>(ch - 'a' + 10);
+    }
+    else if (base == 16 && ch >= 'A' && ch <= 'F')
+    {
+      digit = static_cast<US>(ch - 'A' + 10);
+    }
+    else
+    {
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
+    }
+
+    US limit = 0;
+    if (negative)
+    {
+      limit = static_cast<US>(std::abs(static_cast<intmax_t>((std::numeric_limits<T>::min)())));
+    }
+    else
+    {
+      limit = (std::numeric_limits<T>::max)();
+    }
+
+    if (base != 0 && result > limit / base)
+    {
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
+    }
+    if (result * base > limit - digit)
+    {
+      throw_or_mimic<exceptions::incorrect_argument_type>(text);
+    }
+
+    result = static_cast<US>(result * base + digit);
+  }
+
+  detail::check_signed_range<T>(negative, result, text);
+
+  if (negative)
+  {
+    checked_negate<T>(value, result, text, std::integral_constant<bool, is_signed>());
+  }
+  else
+  {
+    value = static_cast<T>(result);
+  }
+}
+
+template <typename T>
+void stringstream_parser(const std::string& text, T& value)
+{
+  std::stringstream in(text);
+  in >> value;
+  if (!in) {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+}
+
+template <typename T,
+         typename std::enable_if<std::is_integral<T>::value>::type* = nullptr
+         >
+void parse_value(const std::string& text, T& value)
+{
+    integer_parser(text, value);
+}
+
+inline
+void
+parse_value(const std::string& text, bool& value)
+{
+  if (parser_tool::IsTrueText(text))
+  {
+    value = true;
+    return;
+  }
+
+  if (parser_tool::IsFalseText(text))
+  {
+    value = false;
+    return;
+  }
+
+  throw_or_mimic<exceptions::incorrect_argument_type>(text);
+}
+
+inline
+void
+parse_value(const std::string& text, std::string& value)
+{
+  value = text;
+}
+
+// The fallback parser. It uses the stringstream parser to parse all types
+// that have not been overloaded explicitly.  It has to be placed in the
+// source code before all other more specialized templates.
+template <typename T,
+         typename std::enable_if<!std::is_integral<T>::value>::type* = nullptr
+         >
+void
+parse_value(const std::string& text, T& value) {
+  stringstream_parser(text, value);
+}
+
+#ifdef CXXOPTS_HAS_OPTIONAL
+template <typename T>
+void
+parse_value(const std::string& text, std::optional<T>& value)
+{
+  T result;
+  parse_value(text, result);
+  value = std::move(result);
+}
+#endif
+
+inline
+void parse_value(const std::string& text, char& c)
+{
+  if (text.length() != 1)
+  {
+    throw_or_mimic<exceptions::incorrect_argument_type>(text);
+  }
+
+  c = text[0];
+}
+
+template <typename T>
+void
+parse_value(const std::string& text, std::vector<T>& value)
+{
+  if (text.empty()) {
+    T v;
+    parse_value(text, v);
+    value.emplace_back(std::move(v));
+    return;
+  }
+  std::stringstream in(text);
+  std::string token;
+  while(!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) {
+    T v;
+    parse_value(token, v);
+    value.emplace_back(std::move(v));
+  }
+}
+
+template <typename T>
+void
+add_value(const std::string& text, T& value)
+{
+  parse_value(text, value);
+}
+
+template <typename T>
+void
+add_value(const std::string& text, std::vector<T>& value)
+{
+  T v;
+  add_value(text, v);
+  value.emplace_back(std::move(v));
+}
+
+template <typename T>
+struct type_is_container
+{
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct type_is_container<std::vector<T>>
+{
+  static constexpr bool value = true;
+};
+
+template <typename T>
+class abstract_value : public Value
+{
+  using Self = abstract_value<T>;
+
+  public:
+  abstract_value()
+  : m_result(std::make_shared<T>())
+  , m_store(m_result.get())
+  {
+  }
+
+  explicit abstract_value(T* t)
+  : m_store(t)
+  {
+  }
+
+  ~abstract_value() override = default;
+
+  abstract_value& operator=(const abstract_value&) = default;
+
+  abstract_value(const abstract_value& rhs)
+  {
+    if (rhs.m_result)
+    {
+      m_result = std::make_shared<T>();
+      m_store = m_result.get();
+    }
+    else
+    {
+      m_store = rhs.m_store;
+    }
+
+    m_default = rhs.m_default;
+    m_implicit = rhs.m_implicit;
+    m_default_value = rhs.m_default_value;
+    m_implicit_value = rhs.m_implicit_value;
+  }
+
+  void
+  add(const std::string& text) const override
+  {
+    add_value(text, *m_store);
+  }
+
+  void
+  parse(const std::string& text) const override
+  {
+    parse_value(text, *m_store);
+  }
+
+  bool
+  is_container() const override
+  {
+    return type_is_container<T>::value;
+  }
+
+  void
+  parse() const override
+  {
+    parse_value(m_default_value, *m_store);
+  }
+
+  bool
+  has_default() const override
+  {
+    return m_default;
+  }
+
+  bool
+  has_implicit() const override
+  {
+    return m_implicit;
+  }
+
+  std::shared_ptr<Value>
+  default_value(const std::string& value) override
+  {
+    m_default = true;
+    m_default_value = value;
+    return shared_from_this();
+  }
+
+  std::shared_ptr<Value>
+  implicit_value(const std::string& value) override
+  {
+    m_implicit = true;
+    m_implicit_value = value;
+    return shared_from_this();
+  }
+
+  std::shared_ptr<Value>
+  no_implicit_value() override
+  {
+    m_implicit = false;
+    return shared_from_this();
+  }
+
+  std::string
+  get_default_value() const override
+  {
+    return m_default_value;
+  }
+
+  std::string
+  get_implicit_value() const override
+  {
+    return m_implicit_value;
+  }
+
+  bool
+  is_boolean() const override
+  {
+    return std::is_same<T, bool>::value;
+  }
+
+  const T&
+  get() const
+  {
+    if (m_store == nullptr)
+    {
+      return *m_result;
+    }
+    return *m_store;
+  }
+
+  protected:
+  std::shared_ptr<T> m_result{};
+  T* m_store{};
+
+  bool m_default = false;
+  bool m_implicit = false;
+
+  std::string m_default_value{};
+  std::string m_implicit_value{};
+};
+
+template <typename T>
+class standard_value : public abstract_value<T>
+{
+  public:
+  using abstract_value<T>::abstract_value;
+
+  CXXOPTS_NODISCARD
+  std::shared_ptr<Value>
+  clone() const override
+  {
+    return std::make_shared<standard_value<T>>(*this);
+  }
+};
+
+template <>
+class standard_value<bool> : public abstract_value<bool>
+{
+  public:
+  ~standard_value() override = default;
+
+  standard_value()
+  {
+    set_default_and_implicit();
+  }
+
+  explicit standard_value(bool* b)
+  : abstract_value(b)
+  {
+    m_implicit = true;
+    m_implicit_value = "true";
+  }
+
+  std::shared_ptr<Value>
+  clone() const override
+  {
+    return std::make_shared<standard_value<bool>>(*this);
+  }
+
+  private:
+
+  void
+  set_default_and_implicit()
+  {
+    m_default = true;
+    m_default_value = "false";
+    m_implicit = true;
+    m_implicit_value = "true";
+  }
+};
+
+} // namespace values
+
+template <typename T>
+std::shared_ptr<Value>
+value()
+{
+  return std::make_shared<values::standard_value<T>>();
+}
+
+template <typename T>
+std::shared_ptr<Value>
+value(T& t)
+{
+  return std::make_shared<values::standard_value<T>>(&t);
+}
+
+class OptionAdder;
+
+CXXOPTS_NODISCARD
+inline
+const std::string&
+first_or_empty(const OptionNames& long_names)
+{
+  static const std::string empty{""};
+  return long_names.empty() ? empty : long_names.front();
+}
+
+class OptionDetails
+{
+  public:
+  OptionDetails
+  (
+    std::string short_,
+    OptionNames long_,
+    String desc,
+    std::shared_ptr<const Value> val
+  )
+  : m_short(std::move(short_))
+  , m_long(std::move(long_))
+  , m_desc(std::move(desc))
+  , m_value(std::move(val))
+  , m_count(0)
+  {
+    m_hash = std::hash<std::string>{}(first_long_name() + m_short);
+  }
+
+  OptionDetails(const OptionDetails& rhs)
+  : m_desc(rhs.m_desc)
+  , m_value(rhs.m_value->clone())
+  , m_count(rhs.m_count)
+  {
+  }
+
+  OptionDetails(OptionDetails&& rhs) = default;
+
+  CXXOPTS_NODISCARD
+  const String&
+  description() const
+  {
+    return m_desc;
+  }
+
+  CXXOPTS_NODISCARD
+  const Value&
+  value() const {
+      return *m_value;
+  }
+
+  CXXOPTS_NODISCARD
+  std::shared_ptr<Value>
+  make_storage() const
+  {
+    return m_value->clone();
+  }
+
+  CXXOPTS_NODISCARD
+  const std::string&
+  short_name() const
+  {
+    return m_short;
+  }
+
+  CXXOPTS_NODISCARD
+  const std::string&
+  first_long_name() const
+  {
+    return first_or_empty(m_long);
+  }
+
+  CXXOPTS_NODISCARD
+  const std::string&
+  essential_name() const
+  {
+    return m_long.empty() ? m_short : m_long.front();
+  }
+
+  CXXOPTS_NODISCARD
+  const OptionNames &
+  long_names() const
+  {
+    return m_long;
+  }
+
+  std::size_t
+  hash() const
+  {
+    return m_hash;
+  }
+
+  private:
+  std::string m_short{};
+  OptionNames m_long{};
+  String m_desc{};
+  std::shared_ptr<const Value> m_value{};
+  int m_count;
+
+  std::size_t m_hash{};
+};
+
+struct HelpOptionDetails
+{
+  std::string s;
+  OptionNames l;
+  String desc;
+  bool has_default;
+  std::string default_value;
+  bool has_implicit;
+  std::string implicit_value;
+  std::string arg_help;
+  bool is_container;
+  bool is_boolean;
+};
+
+struct HelpGroupDetails
+{
+  std::string name{};
+  std::string description{};
+  std::vector<HelpOptionDetails> options{};
+};
+
+class OptionValue
+{
+  public:
+  void
+  add
+  (
+    const std::shared_ptr<const OptionDetails>& details,
+    const std::string& text
+  )
+  {
+    ensure_value(details);
+    ++m_count;
+    m_value->add(text);
+    m_long_names = &details->long_names();
+  }
+
+  void
+  parse
+  (
+    const std::shared_ptr<const OptionDetails>& details,
+    const std::string& text
+  )
+  {
+    ensure_value(details);
+    ++m_count;
+    m_value->parse(text);
+    m_long_names = &details->long_names();
+  }
+
+  void
+  parse_default(const std::shared_ptr<const OptionDetails>& details)
+  {
+    ensure_value(details);
+    m_default = true;
+    m_long_names = &details->long_names();
+    m_value->parse();
+  }
+
+  void
+  parse_no_value(const std::shared_ptr<const OptionDetails>& details)
+  {
+    m_long_names = &details->long_names();
+  }
+
+#if defined(CXXOPTS_NULL_DEREF_IGNORE)
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Wnull-dereference")
+#endif
+
+  CXXOPTS_NODISCARD
+  std::size_t
+  count() const noexcept
+  {
+    return m_count;
+  }
+
+#if defined(CXXOPTS_NULL_DEREF_IGNORE)
+CXXOPTS_DIAGNOSTIC_POP
+#endif
+
+  // TODO: maybe default options should count towards the number of arguments
+  CXXOPTS_NODISCARD
+  bool
+  has_default() const noexcept
+  {
+    return m_default;
+  }
+
+  template <typename T>
+  const T&
+  as() const
+  {
+    if (m_value == nullptr) {
+        throw_or_mimic<exceptions::option_has_no_value>(
+            m_long_names == nullptr ? "" : first_or_empty(*m_long_names));
+    }
+
+    return CXXOPTS_RTTI_CAST<const values::standard_value<T>&>(*m_value).get();
+  }
+
+#ifdef CXXOPTS_HAS_OPTIONAL
+  template <typename T>
+  std::optional<T>
+  as_optional() const
+  {
+    if (m_value == nullptr) {
+      return std::nullopt;
+    }
+    return as<T>();
+  }
+#endif
+
+  private:
+  void
+  ensure_value(const std::shared_ptr<const OptionDetails>& details)
+  {
+    if (m_value == nullptr)
+    {
+      m_value = details->make_storage();
+    }
+  }
+
+
+  const OptionNames * m_long_names = nullptr;
+  // Holding this pointer is safe, since OptionValue's only exist in key-value pairs,
+  // where the key has the string we point to.
+  std::shared_ptr<Value> m_value{};
+  std::size_t m_count = 0;
+  bool m_default = false;
+};
+
+class KeyValue
+{
+  public:
+  KeyValue(std::string key_, std::string value_) noexcept
+  : m_key(std::move(key_))
+  , m_value(std::move(value_))
+  {
+  }
+
+  CXXOPTS_NODISCARD
+  const std::string&
+  key() const
+  {
+    return m_key;
+  }
+
+  CXXOPTS_NODISCARD
+  const std::string&
+  value() const
+  {
+    return m_value;
+  }
+
+  template <typename T>
+  T
+  as() const
+  {
+    T result;
+    values::parse_value(m_value, result);
+    return result;
+  }
+
+  private:
+  std::string m_key;
+  std::string m_value;
+};
+
+using ParsedHashMap = std::unordered_map<std::size_t, OptionValue>;
+using NameHashMap = std::unordered_map<std::string, std::size_t>;
+
+class ParseResult
+{
+  public:
+  class Iterator
+  {
+    public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = KeyValue;
+    using difference_type = void;
+    using pointer = const KeyValue*;
+    using reference = const KeyValue&;
+
+    Iterator() = default;
+    Iterator(const Iterator&) = default;
+
+// GCC complains about m_iter not being initialised in the member
+// initializer list
+CXXOPTS_DIAGNOSTIC_PUSH
+CXXOPTS_IGNORE_WARNING("-Weffc++")
+    Iterator(const ParseResult *pr, bool end=false)
+    : m_pr(pr)
+    {
+      if (end)
+      {
+        m_sequential = false;
+        m_iter = m_pr->m_defaults.end();
+      }
+      else
+      {
+        m_sequential = true;
+        m_iter = m_pr->m_sequential.begin();
+
+        if (m_iter == m_pr->m_sequential.end())
+        {
+          m_sequential = false;
+          m_iter = m_pr->m_defaults.begin();
+        }
+      }
+    }
+CXXOPTS_DIAGNOSTIC_POP
+
+    Iterator& operator++()
+    {
+      ++m_iter;
+      if(m_sequential && m_iter == m_pr->m_sequential.end())
+      {
+        m_sequential = false;
+        m_iter = m_pr->m_defaults.begin();
+        return *this;
+      }
+      return *this;
+    }
+
+    Iterator operator++(int)
+    {
+      Iterator retval = *this;
+      ++(*this);
+      return retval;
+    }
+
+    bool operator==(const Iterator& other) const
+    {
+      return (m_sequential == other.m_sequential) && (m_iter == other.m_iter);
+    }
+
+    bool operator!=(const Iterator& other) const
+    {
+      return !(*this == other);
+    }
+
+    const KeyValue& operator*()
+    {
+      return *m_iter;
+    }
+
+    const KeyValue* operator->()
+    {
+      return m_iter.operator->();
+    }
+
+    private:
+    const ParseResult* m_pr;
+    std::vector<KeyValue>::const_iterator m_iter;
+    bool m_sequential = true;
+  };
+
+  ParseResult() = default;
+  ParseResult(const ParseResult&) = default;
+
+  ParseResult(NameHashMap&& keys, ParsedHashMap&& values, std::vector<KeyValue> sequential,
+          std::vector<KeyValue> default_opts, std::vector<std::string>&& unmatched_args)
+  : m_keys(std::move(keys))
+  , m_values(std::move(values))
+  , m_sequential(std::move(sequential))
+  , m_defaults(std::move(default_opts))
+  , m_unmatched(std::move(unmatched_args))
+  {
+  }
+
+  ParseResult& operator=(ParseResult&&) = default;
+  ParseResult& operator=(const ParseResult&) = default;
+
+  Iterator
+  begin() const
+  {
+    return Iterator(this);
+  }
+
+  Iterator
+  end() const
+  {
+    return Iterator(this, true);
+  }
+
+  std::size_t
+  count(const std::string& o) const
+  {
+    auto iter = m_keys.find(o);
+    if (iter == m_keys.end())
+    {
+      return 0;
+    }
+
+    auto viter = m_values.find(iter->second);
+
+    if (viter == m_values.end())
+    {
+      return 0;
+    }
+
+    return viter->second.count();
+  }
+
+  const OptionValue&
+  operator[](const std::string& option) const
+  {
+    auto iter = m_keys.find(option);
+
+    if (iter == m_keys.end())
+    {
+      throw_or_mimic<exceptions::requested_option_not_present>(option);
+    }
+
+    auto viter = m_values.find(iter->second);
+
+    if (viter == m_values.end())
+    {
+      throw_or_mimic<exceptions::requested_option_not_present>(option);
+    }
+
+    return viter->second;
+  }
+
+#ifdef CXXOPTS_HAS_OPTIONAL
+  template <typename T>
+  std::optional<T>
+  as_optional(const std::string& option) const
+  {
+    auto iter = m_keys.find(option);
+    if (iter != m_keys.end())
+    {
+      auto viter = m_values.find(iter->second);
+      if (viter != m_values.end())
+      {
+        return viter->second.as_optional<T>();
+      }
+    }
+    return std::nullopt;
+  }
+#endif
+
+  const std::vector<KeyValue>&
+  arguments() const
+  {
+    return m_sequential;
+  }
+
+  const std::vector<std::string>&
+  unmatched() const
+  {
+    return m_unmatched;
+  }
+
+  const std::vector<KeyValue>&
+  defaults() const
+  {
+    return m_defaults;
+  }
+
+  const std::string
+  arguments_string() const
+  {
+    std::string result;
+    for(const auto& kv: m_sequential)
+    {
+      result += kv.key() + " = " + kv.value() + "\n";
+    }
+    for(const auto& kv: m_defaults)
+    {
+      result += kv.key() + " = " + kv.value() + " " + "(default)" + "\n";
+    }
+    return result;
+  }
+
+  private:
+  NameHashMap m_keys{};
+  ParsedHashMap m_values{};
+  std::vector<KeyValue> m_sequential{};
+  std::vector<KeyValue> m_defaults{};
+  std::vector<std::string> m_unmatched{};
+};
+
+struct Option
+{
+  Option
+  (
+    std::string opts,
+    std::string desc,
+    std::shared_ptr<const Value>  value = ::cxxopts::value<bool>(),
+    std::string arg_help = ""
+  )
+  : opts_(std::move(opts))
+  , desc_(std::move(desc))
+  , value_(std::move(value))
+  , arg_help_(std::move(arg_help))
+  {
+  }
+
+  std::string opts_;
+  std::string desc_;
+  std::shared_ptr<const Value> value_;
+  std::string arg_help_;
+};
+
+using OptionMap = std::unordered_map<std::string, std::shared_ptr<OptionDetails>>;
+using PositionalList = std::vector<std::string>;
+using PositionalListIterator = PositionalList::const_iterator;
+
+class OptionParser
+{
+  public:
+  OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised)
+  : m_options(options)
+  , m_positional(positional)
+  , m_allow_unrecognised(allow_unrecognised)
+  {
+  }
+
+  ParseResult
+  parse(int argc, const char* const* argv);
+
+  bool
+  consume_positional(const std::string& a, PositionalListIterator& next);
+
+  void
+  checked_parse_arg
+  (
+    int argc,
+    const char* const* argv,
+    int& current,
+    const std::shared_ptr<OptionDetails>& value,
+    const std::string& name
+  );
+
+  void
+  add_to_option(const std::shared_ptr<OptionDetails>& value, const std::string& arg);
+
+  void
+  parse_option
+  (
+    const std::shared_ptr<OptionDetails>& value,
+    const std::string& name,
+    const std::string& arg = ""
+  );
+
+  void
+  parse_default(const std::shared_ptr<OptionDetails>& details);
+
+  void
+  parse_no_value(const std::shared_ptr<OptionDetails>& details);
+
+  private:
+
+  void finalise_aliases();
+
+  const OptionMap& m_options;
+  const PositionalList& m_positional;
+
+  std::vector<KeyValue> m_sequential{};
+  std::vector<KeyValue> m_defaults{};
+  bool m_allow_unrecognised;
+
+  ParsedHashMap m_parsed{};
+  NameHashMap m_keys{};
+};
+
+class Options
+{
+  public:
+
+  explicit Options(std::string program_name, std::string help_string = "")
+  : m_program(std::move(program_name))
+  , m_help_string(toLocalString(std::move(help_string)))
+  , m_custom_help("[OPTION...]")
+  , m_positional_help("positional parameters")
+  , m_show_positional(false)
+  , m_allow_unrecognised(false)
+  , m_width(76)
+  , m_tab_expansion(false)
+  , m_options(std::make_shared<OptionMap>())
+  {
+  }
+
+  Options&
+  positional_help(std::string help_text)
+  {
+    m_positional_help = std::move(help_text);
+    return *this;
+  }
+
+  Options&
+  custom_help(std::string help_text)
+  {
+    m_custom_help = std::move(help_text);
+    return *this;
+  }
+
+  Options&
+  show_positional_help()
+  {
+    m_show_positional = true;
+    return *this;
+  }
+
+  Options&
+  allow_unrecognised_options()
+  {
+    m_allow_unrecognised = true;
+    return *this;
+  }
+
+  Options&
+  set_width(std::size_t width)
+  {
+    m_width = width;
+    return *this;
+  }
+
+  Options&
+  set_tab_expansion(bool expansion=true)
+  {
+    m_tab_expansion = expansion;
+    return *this;
+  }
+
+  ParseResult
+  parse(int argc, const char* const* argv);
+
+  OptionAdder
+  add_options(std::string group = "");
+
+  void
+  add_options
+  (
+    const std::string& group,
+    std::initializer_list<Option> options
+  );
+
+  void
+  add_option
+  (
+    const std::string& group,
+    const Option& option
+  );
+
+  void
+  add_option
+  (
+    const std::string& group,
+    const std::string& s,
+    const OptionNames& l,
+    std::string desc,
+    const std::shared_ptr<const Value>& value,
+    std::string arg_help
+  );
+
+  void
+  add_option
+  (
+    const std::string& group,
+    const std::string& short_name,
+    const std::string& single_long_name,
+    std::string desc,
+    const std::shared_ptr<const Value>& value,
+    std::string arg_help
+  )
+  {
+    OptionNames long_names;
+    long_names.emplace_back(single_long_name);
+    add_option(group, short_name, long_names, desc, value, arg_help);
+  }
+
+  //parse positional arguments into the given option
+  void
+  parse_positional(std::string option);
+
+  void
+  parse_positional(std::vector<std::string> options);
+
+  void
+  parse_positional(std::initializer_list<std::string> options);
+
+  template <typename Iterator>
+  void
+  parse_positional(Iterator begin, Iterator end) {
+    parse_positional(std::vector<std::string>{begin, end});
+  }
+
+  std::string
+  help(const std::vector<std::string>& groups = {}, bool print_usage=true) const;
+
+  std::vector<std::string>
+  groups() const;
+
+  const HelpGroupDetails&
+  group_help(const std::string& group) const;
+
+  const std::string& program() const
+  {
+    return m_program;
+  }
+
+  private:
+
+  void
+  add_one_option
+  (
+    const std::string& option,
+    const std::shared_ptr<OptionDetails>& details
+  );
+
+  String
+  help_one_group(const std::string& group) const;
+
+  void
+  generate_group_help
+  (
+    String& result,
+    const std::vector<std::string>& groups
+  ) const;
+
+  void
+  generate_all_groups_help(String& result) const;
+
+  std::string m_program{};
+  String m_help_string{};
+  std::string m_custom_help{};
+  std::string m_positional_help{};
+  bool m_show_positional;
+  bool m_allow_unrecognised;
+  std::size_t m_width;
+  bool m_tab_expansion;
+
+  std::shared_ptr<OptionMap> m_options;
+  std::vector<std::string> m_positional{};
+  std::unordered_set<std::string> m_positional_set{};
+
+  //mapping from groups to help options
+  std::vector<std::string> m_group{};
+  std::map<std::string, HelpGroupDetails> m_help{};
+};
+
+class OptionAdder
+{
+  public:
+
+  OptionAdder(Options& options, std::string group)
+  : m_options(options), m_group(std::move(group))
+  {
+  }
+
+  OptionAdder&
+  operator()
+  (
+    const std::string& opts,
+    const std::string& desc,
+    const std::shared_ptr<const Value>& value
+      = ::cxxopts::value<bool>(),
+    std::string arg_help = ""
+  );
+
+  private:
+  Options& m_options;
+  std::string m_group;
+};
+
+namespace {
+constexpr std::size_t OPTION_LONGEST = 30;
+constexpr std::size_t OPTION_DESC_GAP = 2;
+
+String
+format_option
+(
+  const HelpOptionDetails& o
+)
+{
+  const auto& s = o.s;
+  const auto& l = first_or_empty(o.l);
+
+  String result = "  ";
+
+  if (!s.empty())
+  {
+    result += "-" + toLocalString(s);
+    if (!l.empty())
+    {
+      result += ",";
+    }
+  }
+  else
+  {
+    result += "   ";
+  }
+
+  if (!l.empty())
+  {
+    result += " --" + toLocalString(l);
+  }
+
+  auto arg = !o.arg_help.empty() ? toLocalString(o.arg_help) : "arg";
+
+  if (!o.is_boolean)
+  {
+    if (o.has_implicit)
+    {
+      result += " [=" + arg + "(=" + toLocalString(o.implicit_value) + ")]";
+    }
+    else
+    {
+      result += " " + arg;
+    }
+  }
+
+  return result;
+}
+
+String
+format_description
+(
+  const HelpOptionDetails& o,
+  std::size_t start,
+  std::size_t allowed,
+  bool tab_expansion
+)
+{
+  auto desc = o.desc;
+
+  if (o.has_default && (!o.is_boolean || o.default_value != "false"))
+  {
+    if(!o.default_value.empty())
+    {
+      desc += toLocalString(" (default: " + o.default_value + ")");
+    }
+    else
+    {
+      desc += toLocalString(" (default: \"\")");
+    }
+  }
+
+  String result;
+
+  if (tab_expansion)
+  {
+    String desc2;
+    auto size = std::size_t{ 0 };
+    for (auto c = std::begin(desc); c != std::end(desc); ++c)
+    {
+      if (*c == '\n')
+      {
+        desc2 += *c;
+        size = 0;
+      }
+      else if (*c == '\t')
+      {
+        auto skip = 8 - size % 8;
+        stringAppend(desc2, skip, ' ');
+        size += skip;
+      }
+      else
+      {
+        desc2 += *c;
+        ++size;
+      }
+    }
+    desc = desc2;
+  }
+
+  desc += " ";
+
+  auto current = std::begin(desc);
+  auto previous = current;
+  auto startLine = current;
+  auto lastSpace = current;
+
+  auto size = std::size_t{};
+
+  bool appendNewLine;
+  bool onlyWhiteSpace = true;
+
+  while (current != std::end(desc))
+  {
+    appendNewLine = false;
+    if (*previous == ' ' || *previous == '\t')
+    {
+      lastSpace = current;
+    }
+    if (*current != ' ' && *current != '\t')
+    {
+      onlyWhiteSpace = false;
+    }
+
+    while (*current == '\n')
+    {
+      previous = current;
+      ++current;
+      appendNewLine = true;
+    }
+
+    if (!appendNewLine && size >= allowed)
+    {
+      if (lastSpace != startLine)
+      {
+        current = lastSpace;
+        previous = current;
+      }
+      appendNewLine = true;
+    }
+
+    if (appendNewLine)
+    {
+      stringAppend(result, startLine, current);
+      startLine = current;
+      lastSpace = current;
+
+      if (*previous != '\n')
+      {
+        stringAppend(result, "\n");
+      }
+
+      stringAppend(result, start, ' ');
+
+      if (*previous != '\n')
+      {
+        stringAppend(result, lastSpace, current);
+      }
+
+      onlyWhiteSpace = true;
+      size = 0;
+    }
+
+    previous = current;
+    ++current;
+    ++size;
+  }
+
+  //append whatever is left but ignore whitespace
+  if (!onlyWhiteSpace)
+  {
+    stringAppend(result, startLine, previous);
+  }
+
+  return result;
+}
+
+} // namespace
+
+inline
+void
+Options::add_options
+(
+  const std::string &group,
+  std::initializer_list<Option> options
+)
+{
+ OptionAdder option_adder(*this, group);
+ for (const auto &option: options)
+ {
+   option_adder(option.opts_, option.desc_, option.value_, option.arg_help_);
+ }
+}
+
+inline
+OptionAdder
+Options::add_options(std::string group)
+{
+  return OptionAdder(*this, std::move(group));
+}
+
+inline
+OptionAdder&
+OptionAdder::operator()
+(
+  const std::string& opts,
+  const std::string& desc,
+  const std::shared_ptr<const Value>& value,
+  std::string arg_help
+)
+{
+  OptionNames option_names = values::parser_tool::split_option_names(opts);
+    // Note: All names will be non-empty; but we must separate the short
+    // (length-1) and longer names
+  std::string short_name {""};
+  auto first_short_name_iter =
+    std::partition(option_names.begin(), option_names.end(),
+      [&](const std::string& name) { return name.length() > 1; }
+    );
+  auto num_length_1_names = (option_names.end() - first_short_name_iter);
+  switch(num_length_1_names) {
+  case 1:
+    short_name = *first_short_name_iter;
+    option_names.erase(first_short_name_iter);
+    CXXOPTS_FALLTHROUGH;
+  case 0:
+    break;
+  default:
+    throw_or_mimic<exceptions::invalid_option_format>(opts);
+  };
+
+  m_options.add_option
+  (
+    m_group,
+    short_name,
+    option_names,
+    desc,
+    value,
+    std::move(arg_help)
+  );
+
+  return *this;
+}
+
+inline
+void
+OptionParser::parse_default(const std::shared_ptr<OptionDetails>& details)
+{
+  // TODO: remove the duplicate code here
+  auto& store = m_parsed[details->hash()];
+  store.parse_default(details);
+  m_defaults.emplace_back(details->essential_name(), details->value().get_default_value());
+}
+
+inline
+void
+OptionParser::parse_no_value(const std::shared_ptr<OptionDetails>& details)
+{
+  auto& store = m_parsed[details->hash()];
+  store.parse_no_value(details);
+}
+
+inline
+void
+OptionParser::parse_option
+(
+  const std::shared_ptr<OptionDetails>& value,
+  const std::string& /*name*/,
+  const std::string& arg
+)
+{
+  auto hash = value->hash();
+  auto& result = m_parsed[hash];
+  result.parse(value, arg);
+
+  m_sequential.emplace_back(value->essential_name(), arg);
+}
+
+inline
+void
+OptionParser::checked_parse_arg
+(
+  int argc,
+  const char* const* argv,
+  int& current,
+  const std::shared_ptr<OptionDetails>& value,
+  const std::string& name
+)
+{
+  if (current + 1 >= argc)
+  {
+    if (value->value().has_implicit())
+    {
+      parse_option(value, name, value->value().get_implicit_value());
+    }
+    else
+    {
+      throw_or_mimic<exceptions::missing_argument>(name);
+    }
+  }
+  else
+  {
+    if (value->value().has_implicit())
+    {
+      parse_option(value, name, value->value().get_implicit_value());
+    }
+    else
+    {
+      parse_option(value, name, argv[current + 1]);
+      ++current;
+    }
+  }
+}
+
+inline
+void
+OptionParser::add_to_option(const std::shared_ptr<OptionDetails>& value, const std::string& arg)
+{
+  auto hash = value->hash();
+  auto& result = m_parsed[hash];
+  result.add(value, arg);
+
+  m_sequential.emplace_back(value->essential_name(), arg);
+}
+
+inline
+bool
+OptionParser::consume_positional(const std::string& a, PositionalListIterator& next)
+{
+  while (next != m_positional.end())
+  {
+    auto iter = m_options.find(*next);
+    if (iter != m_options.end())
+    {
+      if (!iter->second->value().is_container())
+      {
+        auto& result = m_parsed[iter->second->hash()];
+        if (result.count() == 0)
+        {
+          add_to_option(iter->second, a);
+          ++next;
+          return true;
+        }
+        ++next;
+        continue;
+      }
+      add_to_option(iter->second, a);
+      return true;
+    }
+    throw_or_mimic<exceptions::no_such_option>(*next);
+  }
+
+  return false;
+}
+
+inline
+void
+Options::parse_positional(std::string option)
+{
+  parse_positional(std::vector<std::string>{std::move(option)});
+}
+
+inline
+void
+Options::parse_positional(std::vector<std::string> options)
+{
+  m_positional = std::move(options);
+
+  m_positional_set.insert(m_positional.begin(), m_positional.end());
+}
+
+inline
+void
+Options::parse_positional(std::initializer_list<std::string> options)
+{
+  parse_positional(std::vector<std::string>(options));
+}
+
+inline
+ParseResult
+Options::parse(int argc, const char* const* argv)
+{
+  OptionParser parser(*m_options, m_positional, m_allow_unrecognised);
+
+  return parser.parse(argc, argv);
+}
+
+inline ParseResult
+OptionParser::parse(int argc, const char* const* argv)
+{
+  int current = 1;
+  bool consume_remaining = false;
+  auto next_positional = m_positional.begin();
+
+  std::vector<std::string> unmatched;
+
+  while (current != argc)
+  {
+    if (strcmp(argv[current], "--") == 0)
+    {
+      consume_remaining = true;
+      ++current;
+      break;
+    }
+    bool matched = false;
+    values::parser_tool::ArguDesc argu_desc =
+        values::parser_tool::ParseArgument(argv[current], matched);
+
+    if (!matched)
+    {
+      //not a flag
+
+      // but if it starts with a `-`, then it's an error
+      if (argv[current][0] == '-' && argv[current][1] != '\0') {
+        if (!m_allow_unrecognised) {
+          throw_or_mimic<exceptions::invalid_option_syntax>(argv[current]);
+        }
+      }
+
+      //if true is returned here then it was consumed, otherwise it is
+      //ignored
+      if (consume_positional(argv[current], next_positional))
+      {
+      }
+      else
+      {
+        unmatched.emplace_back(argv[current]);
+      }
+      //if we return from here then it was parsed successfully, so continue
+    }
+    else
+    {
+      //short or long option?
+      if (argu_desc.grouping)
+      {
+        const std::string& s = argu_desc.arg_name;
+
+        for (std::size_t i = 0; i != s.size(); ++i)
+        {
+          std::string name(1, s[i]);
+          auto iter = m_options.find(name);
+
+          if (iter == m_options.end())
+          {
+            if (m_allow_unrecognised)
+            {
+              unmatched.push_back(std::string("-") + s[i]);
+              continue;
+            }
+            //error
+            throw_or_mimic<exceptions::no_such_option>(name);
+          }
+
+          auto value = iter->second;
+
+          if (i + 1 == s.size())
+          {
+            //it must be the last argument
+            checked_parse_arg(argc, argv, current, value, name);
+          }
+          else if (value->value().has_implicit())
+          {
+            parse_option(value, name, value->value().get_implicit_value());
+          }
+          else if (i + 1 < s.size())
+          {
+            std::string arg_value = s.substr(i + 1);
+            parse_option(value, name, arg_value);
+            break;
+          }
+          else
+          {
+            //error
+            throw_or_mimic<exceptions::option_requires_argument>(name);
+          }
+        }
+      }
+      else if (argu_desc.arg_name.length() != 0)
+      {
+        const std::string& name = argu_desc.arg_name;
+
+        auto iter = m_options.find(name);
+
+        if (iter == m_options.end())
+        {
+          if (m_allow_unrecognised)
+          {
+            // keep unrecognised options in argument list, skip to next argument
+            unmatched.emplace_back(argv[current]);
+            ++current;
+            continue;
+          }
+          //error
+          throw_or_mimic<exceptions::no_such_option>(name);
+        }
+
+        auto opt = iter->second;
+
+        //equals provided for long option?
+        if (argu_desc.set_value)
+        {
+          //parse the option given
+
+          parse_option(opt, name, argu_desc.value);
+        }
+        else
+        {
+          //parse the next argument
+          checked_parse_arg(argc, argv, current, opt, name);
+        }
+      }
+
+    }
+
+    ++current;
+  }
+
+  for (auto& opt : m_options)
+  {
+    auto& detail = opt.second;
+    const auto& value = detail->value();
+
+    auto& store = m_parsed[detail->hash()];
+
+    if (value.has_default()) {
+      if (!store.count() && !store.has_default()) {
+        parse_default(detail);
+      }
+    }
+    else {
+      parse_no_value(detail);
+    }
+  }
+
+  if (consume_remaining)
+  {
+    while (current < argc)
+    {
+      if (!consume_positional(argv[current], next_positional)) {
+        break;
+      }
+      ++current;
+    }
+
+    //adjust argv for any that couldn't be swallowed
+    while (current != argc) {
+      unmatched.emplace_back(argv[current]);
+      ++current;
+    }
+  }
+
+  finalise_aliases();
+
+  ParseResult parsed(std::move(m_keys), std::move(m_parsed), std::move(m_sequential), std::move(m_defaults), std::move(unmatched));
+  return parsed;
+}
+
+inline
+void
+OptionParser::finalise_aliases()
+{
+  for (auto& option: m_options)
+  {
+    auto& detail = *option.second;
+    auto hash = detail.hash();
+    m_keys[detail.short_name()] = hash;
+    for(const auto& long_name : detail.long_names()) {
+      m_keys[long_name] = hash;
+    }
+
+    m_parsed.emplace(hash, OptionValue());
+  }
+}
+
+inline
+void
+Options::add_option
+(
+  const std::string& group,
+  const Option& option
+)
+{
+    add_options(group, {option});
+}
+
+inline
+void
+Options::add_option
+(
+  const std::string& group,
+  const std::string& s,
+  const OptionNames& l,
+  std::string desc,
+  const std::shared_ptr<const Value>& value,
+  std::string arg_help
+)
+{
+  auto stringDesc = toLocalString(std::move(desc));
+  auto option = std::make_shared<OptionDetails>(s, l, stringDesc, value);
+
+  if (!s.empty())
+  {
+    add_one_option(s, option);
+  }
+
+  for(const auto& long_name : l) {
+    add_one_option(long_name, option);
+  }
+
+  //add the help details
+
+  if (m_help.find(group) == m_help.end())
+  {
+    m_group.push_back(group);
+  }
+
+  auto& options = m_help[group];
+
+  options.options.emplace_back(HelpOptionDetails{s, l, stringDesc,
+      value->has_default(), value->get_default_value(),
+      value->has_implicit(), value->get_implicit_value(),
+      std::move(arg_help),
+      value->is_container(),
+      value->is_boolean()});
+}
+
+inline
+void
+Options::add_one_option
+(
+  const std::string& option,
+  const std::shared_ptr<OptionDetails>& details
+)
+{
+  auto in = m_options->emplace(option, details);
+
+  if (!in.second)
+  {
+    throw_or_mimic<exceptions::option_already_exists>(option);
+  }
+}
+
+inline
+String
+Options::help_one_group(const std::string& g) const
+{
+  using OptionHelp = std::vector<std::pair<String, String>>;
+
+  auto group = m_help.find(g);
+  if (group == m_help.end())
+  {
+    return "";
+  }
+
+  OptionHelp format;
+
+  std::size_t longest = 0;
+
+  String result;
+
+  if (!g.empty())
+  {
+    result += toLocalString(" " + g + " options:\n");
+  }
+
+  for (const auto& o : group->second.options)
+  {
+    if (o.l.size() &&
+        m_positional_set.find(o.l.front()) != m_positional_set.end() &&
+        !m_show_positional)
+    {
+      continue;
+    }
+
+    auto s = format_option(o);
+    longest = (std::max)(longest, stringLength(s));
+    format.push_back(std::make_pair(s, String()));
+  }
+  longest = (std::min)(longest, OPTION_LONGEST);
+
+  //widest allowed description -- min 10 chars for helptext/line
+  std::size_t allowed = 10;
+  if (m_width > allowed + longest + OPTION_DESC_GAP)
+  {
+    allowed = m_width - longest - OPTION_DESC_GAP;
+  }
+
+  auto fiter = format.begin();
+  for (const auto& o : group->second.options)
+  {
+    if (o.l.size() &&
+        m_positional_set.find(o.l.front()) != m_positional_set.end() &&
+        !m_show_positional)
+    {
+      continue;
+    }
+
+    auto d = format_description(o, longest + OPTION_DESC_GAP, allowed, m_tab_expansion);
+
+    result += fiter->first;
+    if (stringLength(fiter->first) > longest)
+    {
+      result += '\n';
+      result += toLocalString(std::string(longest + OPTION_DESC_GAP, ' '));
+    }
+    else
+    {
+      result += toLocalString(std::string(longest + OPTION_DESC_GAP -
+        stringLength(fiter->first),
+        ' '));
+    }
+    result += d;
+    result += '\n';
+
+    ++fiter;
+  }
+
+  return result;
+}
+
+inline
+void
+Options::generate_group_help
+(
+  String& result,
+  const std::vector<std::string>& print_groups
+) const
+{
+  for (std::size_t i = 0; i != print_groups.size(); ++i)
+  {
+    const String& group_help_text = help_one_group(print_groups[i]);
+    if (empty(group_help_text))
+    {
+      continue;
+    }
+    result += group_help_text;
+    if (i < print_groups.size() - 1)
+    {
+      result += '\n';
+    }
+  }
+}
+
+inline
+void
+Options::generate_all_groups_help(String& result) const
+{
+  generate_group_help(result, m_group);
+}
+
+inline
+std::string
+Options::help(const std::vector<std::string>& help_groups, bool print_usage) const
+{
+  String result = m_help_string;
+  if(print_usage)
+  {
+    result+= "\nUsage:\n  " + toLocalString(m_program);
+  }
+
+  if (!m_custom_help.empty())
+  {
+    result += " " + toLocalString(m_custom_help);
+  }
+
+  if (!m_positional.empty() && !m_positional_help.empty()) {
+    result += " " + toLocalString(m_positional_help);
+  }
+
+  result += "\n\n";
+
+  if (help_groups.empty())
+  {
+    generate_all_groups_help(result);
+  }
+  else
+  {
+    generate_group_help(result, help_groups);
+  }
+
+  return toUTF8String(result);
+}
+
+inline
+std::vector<std::string>
+Options::groups() const
+{
+  return m_group;
+}
+
+inline
+const HelpGroupDetails&
+Options::group_help(const std::string& group) const
+{
+  return m_help.at(group);
+}
+
+} // namespace cxxopts
+
+#endif //CXXOPTS_HPP_INCLUDED
\ No newline at end of file

From 9e273cce07af76b9cefd6a4470250800c28b6b93 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 22:39:52 -0700
Subject: [PATCH 37/71] Add cli option for qserver cert/key files

---
 cmd/moq-example/server.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 6ebc1604..92bcdfd6 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -39,6 +39,8 @@ main(int argc, char* argv[])
       ("b,bind_ip", "Bind IP", cxxopts::value<std::string>()->default_value("127.0.0.1"))
       ("p,port", "Listening port", cxxopts::value<uint16_t>()->default_value("1234"))
       ("e,endpoint_id", "This relay/server endpoint ID", cxxopts::value<std::string>()->default_value("moq-server"))
+      ("c,cert", "Certificate file", cxxopts::value<std::string>()->default_value("./server-cert.pem"))
+      ("k,key", "Certificate key file", cxxopts::value<std::string>()->default_value("./server-key.pem"))
       ("q,qlog", "Enable qlog using path", cxxopts::value<std::string>())
     ; // end of options
 
@@ -72,8 +74,8 @@ main(int argc, char* argv[])
     config.server_port = result["port"].as<uint16_t>();
     config.server_proto = qtransport::TransportProtocol::QUIC;
     config.transport_config.debug = result["debug"].as<bool>();
-    config.transport_config.tls_cert_filename = "./server-cert.pem";
-    config.transport_config.tls_key_filename = "./server-key.pem";
+    config.transport_config.tls_cert_filename = const_cast<char *>(result["cert"].as<std::string>().c_str());
+    config.transport_config.tls_key_filename = const_cast<char *>(result["key"].as<std::string>().c_str());
     config.transport_config.use_reset_wait_strategy = false;
     config.transport_config.time_queue_max_duration = 5000;
     config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;

From 9d515d49c7c6f6b26047ce6bc8084f85edcb4646 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 22:52:59 -0700
Subject: [PATCH 38/71] update qclient cli publisher and subscriber options

---
 cmd/moq-example/client.cpp | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 189d05da..f911f219 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -39,13 +39,13 @@ main(int argc, char* argv[])
     ; // end of options
 
     options.add_options("Publisher")
-      ("pn,pub_namespace", "Track namespace", cxxopts::value<std::string>()->default_value("client1"))
-      ("pt,pub_name", "Track name", cxxopts::value<std::vector<std::string>>()->default_value("chat"))
+      ("pub_namespace", "Track namespace", cxxopts::value<std::string>())
+      ("pub_name", "Track name", cxxopts::value<std::string>())
     ;
 
     options.add_options("Subscriber")
-      ("sn,sub_namespace", "Track namespace", cxxopts::value<std::string>()->default_value("client1"))
-      ("st,sub_name", "Track name", cxxopts::value<std::vector<std::string>>()->default_value("chat"))
+      ("sub_namespace", "Track namespace", cxxopts::value<std::string>())
+      ("sub_name", "Track name", cxxopts::value<std::string>())
     ;
 
     auto result = options.parse(argc, argv);
@@ -56,6 +56,24 @@ main(int argc, char* argv[])
         return true;
     }
 
+    bool enable_pub { false };
+    if (result.count("pub_namespace") && result.count("pub_name")) {
+        enable_pub = true;
+        logger->info << "Publisher enabled using track"
+                     << " namespace: " << result["pub_namespace"].as<std::string>()
+                     << " name: " << result["pub_name"].as<std::string>()
+                     << std::flush;
+    }
+
+    bool enable_sub { false };
+    if (result.count("sub_namespace") && result.count("sub_name")) {
+        enable_pub = true;
+        logger->info << "Subscriber enabled using track"
+                     << " namespace: " << result["sub_namespace"].as<std::string>()
+                     << " name: " << result["sub_name"].as<std::string>()
+                     << std::flush;
+    }
+
     std::string qlog_path;
     if (result.count("qlog")) {
         qlog_path = result["qlog"].as<std::string>();

From bc780b110959002ee3b4b67b3039fcf863cde4b1 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 11 Jun 2024 22:53:50 -0700
Subject: [PATCH 39/71] ...

---
 cmd/moq-example/client.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index f911f219..5226739b 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -67,7 +67,7 @@ main(int argc, char* argv[])
 
     bool enable_sub { false };
     if (result.count("sub_namespace") && result.count("sub_name")) {
-        enable_pub = true;
+        enable_sub = true;
         logger->info << "Subscriber enabled using track"
                      << " namespace: " << result["sub_namespace"].as<std::string>()
                      << " name: " << result["sub_name"].as<std::string>()

From ba732a5cee5daddc285e2b7af0e2e84ce7edcac3 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 14 Jun 2024 09:18:04 -0700
Subject: [PATCH 40/71] Start on adding announce/publish track and responses

---
 cmd/moq-example/client.cpp            | 143 ++++++++++++++++++++++----
 cmd/moq-example/server.cpp            |   4 +-
 include/quicr/moq_instance_delegate.h |   3 +
 include/quicr/moq_track_delegate.h    |  36 ++++---
 src/CMakeLists.txt                    |   1 +
 src/moq_instance.cpp                  |  11 +-
 src/moq_track_delegate_base.cpp       |  52 ++++++++++
 7 files changed, 215 insertions(+), 35 deletions(-)
 create mode 100644 src/moq_track_delegate_base.cpp

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 5226739b..6e5ac65e 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -6,17 +6,116 @@
 #include <iostream>
 #include <oss/cxxopts.hpp>
 
+namespace qclient_vars {
+    std::optional<qtransport::TransportConnId> conn_id;
+}
+
+
+class trackDelegate : public quicr::MoQTrackDelegate
+{
+public:
+    trackDelegate(const std::string& t_namespace,
+                  const std::string& t_name,
+                  uint8_t priority,
+                  uint32_t ttl,
+                  const cantina::LoggerPointer& logger)
+      : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
+                         { t_name.begin(), t_name.end() },
+                         TrackMode::STREAM_PER_GROUP,
+                         priority,
+                         ttl,
+                         logger)
+    {
+    }
+
+    void cb_objectReceived(std::vector<uint8_t>&& object) override {}
+    void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
+    void cb_sendReady() override {}
+    void cb_sendNotReady(TrackSendStatus status) override {}
+    void cb_readReady() override {}
+    void cb_readNotReady(TrackReadStatus status) override {}
+};
 
 class clientDelegate : public quicr::MoQInstanceDelegate
 {
+public:
+    clientDelegate(const cantina::LoggerPointer& logger) :
+        _logger(std::make_shared<cantina::Logger>("MID", logger)) {}
+
     void cb_newConnection(qtransport::TransportConnId conn_id,
                           const std::span<uint8_t>& endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
-    void cb_connectionStatus(qtransport::TransportConnId conn_id, qtransport::TransportStatus status) override {}
+
+    void cb_connectionStatus(qtransport::TransportConnId conn_id,
+                             const std::span<uint8_t>& endpoint_id,
+                             qtransport::TransportStatus status) override
+    {
+        auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
+
+        if (status == qtransport::TransportStatus::Ready) {
+            _logger->info << "Connection ready conn_id: " << conn_id
+                          << " endpoint_id: " << ep_id
+                          << std::flush;
+
+            qclient_vars::conn_id = conn_id;
+        }
+    }
     void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
     void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
+
+private:
+    cantina::LoggerPointer _logger;
 };
 
+void do_publisher(const std::string t_namespace,
+                  const std::string t_name,
+                  const std::shared_ptr<quicr::MoQInstance>& moqInstance,
+                  const cantina::LoggerPointer& logger,
+                  const bool& stop)
+{
+    cantina::LoggerPointer _logger = std::make_shared<cantina::Logger>("PUB", logger);
+
+    auto mi = moqInstance;
+
+    auto track_delegate = std::make_shared<trackDelegate>(t_namespace, t_name, 2, 3000, logger);
+
+    _logger->info << "Started publisher track: " << t_namespace << "/" << t_name << std::flush;
+
+    bool published_track { false };
+    while (not stop) {
+        if (!published_track && qclient_vars::conn_id) {
+            _logger->info << "Create publish track: " << t_namespace << "/" << t_name << std::flush;
+            //mi->publishTrack(*qclient_vars::conn_id, track_delegate);
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    }
+
+    _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
+}
+
+quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts)
+{
+    quicr::MoQInstanceClientConfig config;
+
+    std::string qlog_path;
+    if (cli_opts.count("qlog")) {
+        qlog_path = cli_opts["qlog"].as<std::string>();
+    }
+
+    config.endpoint_id = cli_opts["endpoint_id"].as<std::string>();
+    config.server_host_ip = cli_opts["host"].as<std::string>();
+    config.server_port = cli_opts["port"].as<uint16_t>();
+    config.server_proto = qtransport::TransportProtocol::QUIC;
+    config.transport_config.debug = cli_opts["debug"].as<bool>();;
+    config.transport_config.use_reset_wait_strategy = false;
+    config.transport_config.time_queue_max_duration = 5000;
+    config.transport_config.tls_cert_filename = nullptr;
+    config.transport_config.tls_key_filename = nullptr;
+    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
+
+    return config;
+}
+
 int
 main(int argc, char* argv[])
 {
@@ -74,11 +173,6 @@ main(int argc, char* argv[])
                      << std::flush;
     }
 
-    std::string qlog_path;
-    if (result.count("qlog")) {
-        qlog_path = result["qlog"].as<std::string>();
-    }
-
     if (result.count("debug") && result["debug"].as<bool>() == true) {
         logger->info << "setting debug level" << std::flush;
         logger->SetLogLevel("DEBUG");
@@ -90,28 +184,37 @@ main(int argc, char* argv[])
     // Lock the mutex so that main can then wait on it
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
-    quicr::MoQInstanceClientConfig config;
-    config.endpoint_id = result["endpoint_id"].as<std::string>();
-    config.server_host_ip = result["host"].as<std::string>();
-    config.server_port = result["port"].as<uint16_t>();
-    config.server_proto = qtransport::TransportProtocol::QUIC;
-    config.transport_config.debug = result["debug"].as<bool>();;
-    config.transport_config.use_reset_wait_strategy = false;
-    config.transport_config.time_queue_max_duration = 5000;
-    config.transport_config.tls_cert_filename = nullptr;
-    config.transport_config.tls_key_filename = nullptr;
-    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
+    quicr::MoQInstanceClientConfig config = init_config(result);
 
-    auto delegate = std::make_shared<clientDelegate>();
+    auto delegate = std::make_shared<clientDelegate>(logger);
 
     try {
-        auto moqInstance = quicr::MoQInstance{config, delegate, logger};
+        //auto moqInstance = quicr::MoQInstance{config, delegate, logger};
+        auto moqInstance = std::make_shared<quicr::MoQInstance>(config, delegate, logger);
+
+        moqInstance->run_client();
 
-        moqInstance.run_client();
+        bool stop_threads { false };
+        std::thread pub_thread;
+        if (enable_pub) {
+            logger->info << "run publisher thread" << std::flush;
+            pub_thread = std::thread (do_publisher,
+                                     result["pub_namespace"].as<std::string>(),
+                                     result["pub_name"].as<std::string>(),
+                                     moqInstance, logger, stop_threads);
+        }
 
         // Wait until told to terminate
         moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
 
+        stop_threads = true;
+
+        if (pub_thread.joinable()) {
+            pub_thread.join();
+        }
+
+        moqInstance->stop();
+
         logger->info << "Client done" << std::endl;
 
         // Unlock the mutex
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 92bcdfd6..73e8f7e9 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -16,7 +16,9 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     void cb_newConnection(qtransport::TransportConnId conn_id,
                           const std::span<uint8_t>& endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
-    void cb_connectionStatus(qtransport::TransportConnId conn_id, qtransport::TransportStatus status) override {}
+    void cb_connectionStatus(qtransport::TransportConnId conn_id,
+                             const std::span<uint8_t>& endpoint_id,
+                             qtransport::TransportStatus status) override {}
     void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
     void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
 };
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 210c4723..8b92a6de 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -20,6 +20,7 @@ namespace quicr {
      */
     class MoQInstanceDelegate
     {
+    public:
         /**
          * @brief Notification on new connection
          * @details Notification that a new connection has been accepted
@@ -37,9 +38,11 @@ namespace quicr {
          * @details Notification indicates state change of connection, such as disconnected
          *
          * @param conn_id          Transport connection ID
+         * @param endpoint_id      Endpoint ID of remote side
          * @param status           Transport status of connection id
          */
         virtual void cb_connectionStatus(TransportConnId conn_id,
+                                         const std::span<uint8_t>& endpoint_id,
                                          TransportStatus status) = 0;
 
         /**
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 08ac0f35..c0e13b15 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -39,7 +39,8 @@ namespace quicr {
 
         enum class TrackReadStatus : uint8_t
         {
-            NOT_AUTHORIZED = 0,
+            OK = 0,
+            NOT_AUTHORIZED,
             NOT_SUBSCRIBED,
             PENDING_SUBSCRIBE_RESPONSE,
             SUBSCRIBE_NOT_AUTHORIZED
@@ -47,7 +48,8 @@ namespace quicr {
 
         enum class TrackSendStatus : uint8_t
         {
-            NOT_ANNOUNCED = 0,
+            OK = 0,
+            NOT_ANNOUNCED,
             PENDING_ANNOUNCE_RESPONSE,
             ANNOUNCE_NOT_AUTHORIZED,
             NO_SUBSCRIBERS,
@@ -72,7 +74,16 @@ namespace quicr {
                          const bytes& track_name,
                          TrackMode track_mode,
                          uint8_t default_priority,
-                         uint32_t default_ttl);
+                         uint32_t default_ttl,
+                         const cantina::LoggerPointer& logger) :
+              _track_namespace(track_namespace)
+             , _track_name(track_name)
+             , _track_mode(track_mode)
+             , _logger(std::make_shared<cantina::Logger>("MTD", logger))
+        {
+          this->setDefaultPriority(default_priority);
+          this->setDefaultTTL(default_ttl);
+        }
 
         /**
          * @brief Send object to announced track
@@ -119,31 +130,29 @@ namespace quicr {
          *
          * @returns current TrackSendStatus
          */
-        TrackReadStatus statusSend();
+        TrackSendStatus statusSend();
 
         /**
          * @brief set/update the default priority for published objects
          */
-        void setDefaultPriority(uint8_t);
+        void setDefaultPriority(uint8_t priority) { _def_priority = priority; }
 
         /**
          * @brief set/update the default TTL expirty for published objects
          */
-        void setDefaultTTL(uint32_t);
+        void setDefaultTTL(uint32_t ttl) { _def_ttl = ttl; }
 
         // --------------------------------------------------------------------------
         // Public Virtual API callback event methods to be overridden
         // --------------------------------------------------------------------------
 
         /**
-         * @brief Notificaiton that data is avaialble to be read.
+         * @brief Notificaiton of received data object
          *
-         * @details Event notification to inform the caller that data can be read. The caller
-         *   should read all data if possible.
+         * @details Event notification to provide the caller the received data object
          *
-         * @param objects_available       Number of objects available to be read at time of notification
+         * @param object    Data object received
          */
-        virtual void cb_objectsAvailable(uint64_t objects_available) = 0;
         virtual void cb_objectReceived(std::vector<uint8_t>&& object) = 0;
 
         /**
@@ -213,8 +222,11 @@ namespace quicr {
       private:
         const bytes _track_namespace;
         const bytes _track_name;
-        TrackMode _track_mode;
+        [[maybe_unused]] TrackMode _track_mode;
+        uint8_t _def_priority;
+        uint32_t _def_ttl;
         std::optional<uint64_t> _track_alias;
+        cantina::LoggerPointer _logger;
     };
 
 } // namespace quicr
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 71e0adb3..1e0ee927 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -10,6 +10,7 @@ target_sources(quicr PRIVATE
         quicr_server.cpp
         quicr_server_raw_session.cpp
         moq_instance.cpp
+        moq_track_delegate_base.cpp
         moq_session.cpp
 )
 
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 4f3c75a5..ffa6a295 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -242,6 +242,11 @@ namespace quicr {
 
                         std::string client_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
                                                         msg.endpoint_id_parameter.param_value.end());
+
+                        _delegate->cb_connectionStatus(conn_ctx.conn_id,
+                                                       msg.endpoint_id_parameter.param_value,
+                                                       TransportStatus::Ready);
+
                         _logger->info << "Client setup received from: " << client_endpoint_id
                                       << " num_versions: " << msg.num_versions
                                       << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
@@ -276,10 +281,12 @@ namespace quicr {
                     std::string server_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
                                 msg.endpoint_id_parameter.param_value.end());
 
+                    _delegate->cb_connectionStatus(conn_ctx.conn_id,
+                               msg.endpoint_id_parameter.param_value,
+                               TransportStatus::Ready);
+
                     _logger->info << "Server setup received"
                                   << " from: " << server_endpoint_id
-                                  << std::string(msg.endpoint_id_parameter.param_value.begin(),
-                                                 msg.endpoint_id_parameter.param_value.end())
                                   << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
                                   << " selected_version: 0x" << std::hex << msg.selection_version
                                   << std::dec << std::flush;
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
new file mode 100644
index 00000000..5dde2529
--- /dev/null
+++ b/src/moq_track_delegate_base.cpp
@@ -0,0 +1,52 @@
+/*
+ *  Copyright (C) 2024
+ *  Cisco Systems, Inc.
+ *  All Rights Reserved
+ */
+
+#include <quicr/moq_instance.h>
+#include <quicr/moq_track_delegate.h>
+
+namespace quicr {
+
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object)
+    {
+        return MoQTrackDelegate::SendError::OK;
+    }
+
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] uint32_t ttl)
+    {
+        return MoQTrackDelegate::SendError::OK;
+    }
+
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
+                                           [[maybe_unused]] uint8_t priority)
+    {
+        return MoQTrackDelegate::SendError::OK;
+    }
+
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
+                                           [[maybe_unused]] uint8_t priority,
+                                           [[maybe_unused]] uint32_t ttl)
+    {
+        return MoQTrackDelegate::SendError::OK;
+    }
+
+    MoQTrackDelegate::ReadError MoQTrackDelegate::readObject([[maybe_unused]] std::vector<const uint8_t>& object)
+    {
+        return MoQTrackDelegate::ReadError::NO_DATA;
+    }
+
+    MoQTrackDelegate::TrackReadStatus MoQTrackDelegate::statusRead()
+    {
+        return MoQTrackDelegate::TrackReadStatus::OK;
+    }
+
+    MoQTrackDelegate::TrackSendStatus MoQTrackDelegate::statusSend()
+    {
+        return MoQTrackDelegate::TrackSendStatus::OK;
+    }
+
+
+} // namespace quicr

From 4c89cdafc2324cc89bf0bdcec40750c3b57b407b Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 14 Jun 2024 16:25:11 -0700
Subject: [PATCH 41/71] CLI cleanup and implement announce/announce ok flow

---
 cmd/moq-example/client.cpp            |  65 ++++++++------
 cmd/moq-example/server.cpp            |  82 ++++++++++++-----
 include/quicr/moq_instance.h          |  43 ++++++++-
 include/quicr/moq_instance_delegate.h |  31 +++++--
 include/quicr/moq_track_delegate.h    |  49 ++++++++--
 src/moq_instance.cpp                  | 124 ++++++++++++++++++++++++--
 src/moq_track_delegate_base.cpp       |  10 ---
 test/CMakeLists.txt                   |   6 ++
 test/moq_instance.cpp                 |  29 ++++++
 9 files changed, 355 insertions(+), 84 deletions(-)
 create mode 100644 test/moq_instance.cpp

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 6e5ac65e..2fea2d48 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -30,7 +30,11 @@ class trackDelegate : public quicr::MoQTrackDelegate
 
     void cb_objectReceived(std::vector<uint8_t>&& object) override {}
     void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
-    void cb_sendReady() override {}
+
+    void cb_sendReady() override {
+        _logger->info << "Track alias: " << _track_alias.value() << " is ready to send" << std::flush;
+    }
+
     void cb_sendNotReady(TrackSendStatus status) override {}
     void cb_readReady() override {}
     void cb_readNotReady(TrackReadStatus status) override {}
@@ -84,8 +88,9 @@ void do_publisher(const std::string t_namespace,
     bool published_track { false };
     while (not stop) {
         if (!published_track && qclient_vars::conn_id) {
-            _logger->info << "Create publish track: " << t_namespace << "/" << t_name << std::flush;
-            //mi->publishTrack(*qclient_vars::conn_id, track_delegate);
+            _logger->info << "Publish track: " << t_namespace << "/" << t_name << std::flush;
+            mi->publishTrack(*qclient_vars::conn_id, track_delegate);
+            published_track = true;
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
     }
@@ -93,7 +98,10 @@ void do_publisher(const std::string t_namespace,
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
 }
 
-quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts)
+quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts,
+                                           bool& enable_pub,
+                                           bool& enable_sub,
+                                           const cantina::LoggerPointer& logger)
 {
     quicr::MoQInstanceClientConfig config;
 
@@ -102,6 +110,27 @@ quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts)
         qlog_path = cli_opts["qlog"].as<std::string>();
     }
 
+    if (cli_opts.count("debug") && cli_opts["debug"].as<bool>() == true) {
+        logger->info << "setting debug level" << std::flush;
+        logger->SetLogLevel("DEBUG");
+    }
+
+    if (cli_opts.count("pub_namespace") && cli_opts.count("pub_name")) {
+        enable_pub = true;
+        logger->info << "Publisher enabled using track"
+                     << " namespace: " << cli_opts["pub_namespace"].as<std::string>()
+                     << " name: " << cli_opts["pub_name"].as<std::string>()
+                     << std::flush;
+    }
+
+    if (cli_opts.count("sub_namespace") && cli_opts.count("sub_name")) {
+        enable_sub = true;
+        logger->info << "Subscriber enabled using track"
+                     << " namespace: " << cli_opts["sub_namespace"].as<std::string>()
+                     << " name: " << cli_opts["sub_name"].as<std::string>()
+                     << std::flush;
+    }
+
     config.endpoint_id = cli_opts["endpoint_id"].as<std::string>();
     config.server_host_ip = cli_opts["host"].as<std::string>();
     config.server_port = cli_opts["port"].as<uint16_t>();
@@ -155,36 +184,15 @@ main(int argc, char* argv[])
         return true;
     }
 
-    bool enable_pub { false };
-    if (result.count("pub_namespace") && result.count("pub_name")) {
-        enable_pub = true;
-        logger->info << "Publisher enabled using track"
-                     << " namespace: " << result["pub_namespace"].as<std::string>()
-                     << " name: " << result["pub_name"].as<std::string>()
-                     << std::flush;
-    }
-
-    bool enable_sub { false };
-    if (result.count("sub_namespace") && result.count("sub_name")) {
-        enable_sub = true;
-        logger->info << "Subscriber enabled using track"
-                     << " namespace: " << result["sub_namespace"].as<std::string>()
-                     << " name: " << result["sub_name"].as<std::string>()
-                     << std::flush;
-    }
-
-    if (result.count("debug") && result["debug"].as<bool>() == true) {
-        logger->info << "setting debug level" << std::flush;
-        logger->SetLogLevel("DEBUG");
-    }
-
     // Install a signal handlers to catch operating system signals
     installSignalHandlers();
 
     // Lock the mutex so that main can then wait on it
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
-    quicr::MoQInstanceClientConfig config = init_config(result);
+    bool enable_pub { false };
+    bool enable_sub { false };
+    quicr::MoQInstanceClientConfig config = init_config(result, enable_pub, enable_sub, logger);
 
     auto delegate = std::make_shared<clientDelegate>(logger);
 
@@ -197,7 +205,6 @@ main(int argc, char* argv[])
         bool stop_threads { false };
         std::thread pub_thread;
         if (enable_pub) {
-            logger->info << "run publisher thread" << std::flush;
             pub_thread = std::thread (do_publisher,
                                      result["pub_namespace"].as<std::string>(),
                                      result["pub_name"].as<std::string>(),
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 73e8f7e9..e7ad7958 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -13,16 +13,72 @@
 
 class serverDelegate : public quicr::MoQInstanceDelegate
 {
+  public:
+    serverDelegate(const cantina::LoggerPointer& logger) :
+      _logger(std::make_shared<cantina::Logger>("MID", logger)) {}
+
     void cb_newConnection(qtransport::TransportConnId conn_id,
                           const std::span<uint8_t>& endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
+
+    bool cb_announce(qtransport::TransportConnId conn_id,
+                     uint64_t track_namespace_hash) override {
+
+        _logger->debug << "Received announce from conn_id: " << conn_id
+                       << "  for namespace_hash: " << track_namespace_hash
+                       << std::flush;
+
+        // Send announce OK
+        return true;
+    }
+
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
                              const std::span<uint8_t>& endpoint_id,
-                             qtransport::TransportStatus status) override {}
+                             qtransport::TransportStatus status) override {
+        auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
+
+        if (status == qtransport::TransportStatus::Ready) {
+            _logger->debug << "Connection ready conn_id: " << conn_id
+                           << " endpoint_id: " << ep_id
+                           << std::flush;
+
+        }
+    }
     void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
     void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
+
+  private:
+    cantina::LoggerPointer _logger;
 };
 
+quicr::MoQInstanceServerConfig init_config(cxxopts::ParseResult& cli_opts, const cantina::LoggerPointer& logger)
+{
+    quicr::MoQInstanceServerConfig config;
+
+    std::string qlog_path;
+    if (cli_opts.count("qlog")) {
+        qlog_path = cli_opts["qlog"].as<std::string>();
+    }
+
+    if (cli_opts.count("debug") && cli_opts["debug"].as<bool>() == true) {
+        logger->info << "setting debug level" << std::flush;
+        logger->SetLogLevel("DEBUG");
+    }
+
+    config.endpoint_id = cli_opts["endpoint_id"].as<std::string>();
+    config.server_bind_ip = cli_opts["bind_ip"].as<std::string>();
+    config.server_port = cli_opts["port"].as<uint16_t>();
+    config.server_proto = qtransport::TransportProtocol::QUIC;
+    config.transport_config.debug = cli_opts["debug"].as<bool>();
+    config.transport_config.tls_cert_filename = const_cast<char *>(cli_opts["cert"].as<std::string>().c_str());
+    config.transport_config.tls_key_filename = const_cast<char *>(cli_opts["key"].as<std::string>().c_str());
+    config.transport_config.use_reset_wait_strategy = false;
+    config.transport_config.time_queue_max_duration = 5000;
+    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
+
+    return config;
+}
+
 int
 main(int argc, char* argv[])
 {
@@ -54,35 +110,15 @@ main(int argc, char* argv[])
         return true;
     }
 
-    std::string qlog_path;
-    if (result.count("qlog")) {
-        qlog_path = result["qlog"].as<std::string>();
-    }
-
-    if (result.count("debug") && result["debug"].as<bool>() == true) {
-        logger->info << "setting debug level" << std::flush;
-        logger->SetLogLevel("DEBUG");
-    }
-
     // Install a signal handlers to catch operating system signals
     installSignalHandlers();
 
     // Lock the mutex so that main can then wait on it
     std::unique_lock<std::mutex> lock(moq_example::main_mutex);
 
-    quicr::MoQInstanceServerConfig config;
-    config.endpoint_id = result["endpoint_id"].as<std::string>();
-    config.server_bind_ip = result["bind_ip"].as<std::string>();
-    config.server_port = result["port"].as<uint16_t>();
-    config.server_proto = qtransport::TransportProtocol::QUIC;
-    config.transport_config.debug = result["debug"].as<bool>();
-    config.transport_config.tls_cert_filename = const_cast<char *>(result["cert"].as<std::string>().c_str());
-    config.transport_config.tls_key_filename = const_cast<char *>(result["key"].as<std::string>().c_str());
-    config.transport_config.use_reset_wait_strategy = false;
-    config.transport_config.time_queue_max_duration = 5000;
-    config.transport_config.quic_qlog_path = qlog_path.size() ? const_cast<char *>(qlog_path.c_str()) : nullptr;
+    quicr::MoQInstanceServerConfig config = init_config(result, logger);
 
-    auto delegate = std::make_shared<serverDelegate>();
+    auto delegate = std::make_shared<serverDelegate>(logger);
 
     try {
         auto moqInstance = quicr::MoQInstance{config, delegate, logger};
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 1ee2dfe8..352ebd27 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -13,6 +13,11 @@
 #include <quicr/moq_instance_delegate.h>
 #include <quicr/moq_track_delegate.h>
 
+#include <unordered_map>
+#include <map>
+#include <string>
+#include <string_view>
+
 namespace quicr {
     constexpr uint64_t MOQT_VERSION = 0xff000004; /// draft-ietf-moq-transport-04
 
@@ -60,6 +65,29 @@ namespace quicr {
             CLIENT_FAILED_TO_CONNECT,
         };
 
+        struct TrackFullName {
+            std::span<uint8_t const> name_space;
+            std::span<uint8_t const> name;
+        };
+
+        struct TrackHash
+        {
+            uint64_t track_namespace_hash;                      // 64bit hash of namespace
+            uint64_t track_name_hash;                           // 64bit hash of name
+
+            uint64_t track_fullname_hash;                       // 62bit of namespace+name
+
+            TrackHash(const TrackFullName& tfn) noexcept
+            {
+                track_namespace_hash = std::hash<std::string_view>{}(
+                  {reinterpret_cast<const char*>(tfn.name_space.data()), tfn.name_space.size()});
+                track_name_hash = std::hash<std::string_view>{}(
+                  {reinterpret_cast<const char*>(tfn.name.data()), tfn.name.size()});
+
+                track_fullname_hash = (track_namespace_hash ^ (track_name_hash << 1)) << 1 >> 2; // combine and convert to 62 bits for uintVar
+            }
+        };
+
         /**
          * @brief Client mode Constructor to create the MOQ instance
          *
@@ -140,7 +168,7 @@ namespace quicr {
         void stop() { _stop = true; }
 
         // -------------------------------------------------------------------------------------------------
-        // Transprot Delegate/callback functions
+        // Transport Delegate/callback functions
         // -------------------------------------------------------------------------------------------------
 
         void on_new_data_context([[maybe_unused]] const TransportConnId& conn_id,
@@ -157,6 +185,7 @@ namespace quicr {
         void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
 
       private:
+
         struct ConnectionContext
         {
             TransportConnId conn_id;
@@ -164,6 +193,16 @@ namespace quicr {
             bool setup_complete { false };   /// True if both client and server setup messages have completed
             uint64_t client_version { 0 };
             std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
+
+            // Tracks by track alias
+            std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>> tracks_by_alias;
+
+            // Publish tracks by namespace and name. map[track namespace][track name] = track delegate
+            std::map<uint64_t, std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>>> pub_tracks_by_name;
+
+            // Subscribes by subscribe_id
+            std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>> sub_tracks;
+
         };
 
         // -------------------------------------------------------------------------------------------------
@@ -174,6 +213,8 @@ namespace quicr {
         void send_ctrl_msg(const ConnectionContext& conn_ctx, std::vector<uint8_t>&& data);
         void send_client_setup();
         void send_server_setup(ConnectionContext& conn_ctx);
+        void send_announce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
+        void send_announce_ok(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
         void close_connection(TransportConnId conn_id, messages::MoQTerminationReason reason,
                               const std::string& reason_str);
         bool process_recv_message(ConnectionContext& conn_ctx,
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 8b92a6de..20304423 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -22,16 +22,16 @@ namespace quicr {
     {
     public:
         /**
-         * @brief Notification on new connection
+         * @brief Server Mode; Notification on new connection
          * @details Notification that a new connection has been accepted
          *
          * @param conn_id          Transport connection ID
          * @param endpoint_id      Endpoint ID of client connection
          * @param remote           Transport remote connection information
          */
-        virtual void cb_newConnection(TransportConnId conn_id,
-                                      const std::span<uint8_t>& endpoint_id,
-                                      const TransportRemote& remote) = 0;
+        virtual void cb_newConnection([[maybe_unused]] TransportConnId conn_id,
+                                      [[maybe_unused]] const std::span<uint8_t>& endpoint_id,
+                                      [[maybe_unused]] const TransportRemote& remote) {};
 
         /**
          * @brief Notification for connection status/state change
@@ -46,23 +46,38 @@ namespace quicr {
                                          TransportStatus status) = 0;
 
         /**
-         * @brief callback on client setup message
+         * @brief Server Mode; callback on client setup message
          * @detais In server mode, client will send a setup message on new connection.
          *         Server responds with server setup.
          *
          * @param conn_id          Transport connection ID
          * @param client_setup     Decoded client setup message
          */
-        virtual void cb_clientSetup(TransportConnId conn_id, messages::MoqClientSetup client_setup) = 0;
+        virtual void cb_clientSetup([[maybe_unused]] TransportConnId conn_id,
+                                    [[maybe_unused]] messages::MoqClientSetup client_setup) {}
 
         /**
-         * @brief callback on server setup message
+         * @brief Client Mode; callback on server setup message
          * @details In client mode, server will send sever setup in response to client setup message sent.
          *
          * @param conn_id          Transport connection ID
          * @param server_setup     Decoded sever setup message
          */
-        virtual void cb_serverSetup(TransportConnId conn_id, messages::MoqServerSetup server_setup) = 0;
+        virtual void cb_serverSetup([[maybe_unused]] TransportConnId conn_id,
+                                    [[maybe_unused]] messages::MoqServerSetup server_setup) {}
+
+        /**
+         * @brief Server Mode; Callback notification for new announce received
+         *
+         * @param conn_id                   Source connection ID
+         * @param track_namespace_hash      Track namespace hash
+         *
+         * @return True if send announce should be sent, false if not
+         */
+        virtual bool cb_announce([[maybe_unused]] TransportConnId conn_id,
+                                 [[maybe_unused]] uint64_t track_namespace_hash) { return true; }
+
+
     };
 
 } // namespace quicr
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index c0e13b15..ea75a160 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -76,10 +76,10 @@ namespace quicr {
                          uint8_t default_priority,
                          uint32_t default_ttl,
                          const cantina::LoggerPointer& logger) :
-              _track_namespace(track_namespace)
+              _logger(std::make_shared<cantina::Logger>("MTD", logger))
+             , _track_namespace(track_namespace)
              , _track_name(track_name)
              , _track_mode(track_mode)
-             , _logger(std::make_shared<cantina::Logger>("MTD", logger))
         {
           this->setDefaultPriority(default_priority);
           this->setDefaultTTL(default_ttl);
@@ -121,7 +121,7 @@ namespace quicr {
          *
          * @returns current TrackReadStatus
          */
-        TrackReadStatus statusRead();
+        TrackReadStatus statusRead() { return _read_status; }
 
         /**
          * @brief Current track send status
@@ -130,7 +130,7 @@ namespace quicr {
          *
          * @returns current TrackSendStatus
          */
-        TrackSendStatus statusSend();
+        TrackSendStatus statusSend() { return _send_status; }
 
         /**
          * @brief set/update the default priority for published objects
@@ -216,17 +216,54 @@ namespace quicr {
          */
         std::optional<uint64_t> getTrackAlias() { return _track_alias; }
 
+        /**
+         * @brief Sets the subscribe ID
+         * @details MoQ instance sets the subscribe id based on subscribe track method call. Subscribe
+         *      id is specific to the connection, so it must be set by the moq instance/connection.
+         *
+         * @param subscribe_id          62bit subscribe ID
+         */
+        void setSubscribeId(uint64_t subscribe_id) { _subscribe_id = subscribe_id; }
+
+        /**
+         * @brief Get the subscribe ID
+         *
+         * @return nullopt if not subscribed, otherwise the subscribe ID
+         */
+        std::optional<uint64_t> getSubscribeId() { return _subscribe_id; }
+
+        /**
+         * @brief Get the track namespace
+         * @return span of track namespace
+         */
+        std::span<uint8_t const> getTrackNamespace() { return std::span(_track_namespace); }
+
+        /**
+         * @brief Get the track name
+         * @return span of track name
+         */
+        std::span<uint8_t const> getTrackName() { return std::span(_track_name); }
+
+        /**
+         * @brief Set the send status
+         * @param status                Status of sending (aka publish objects)
+         */
+        void setSendStatus(TrackSendStatus status) { _send_status = status; }
+
         // --------------------------------------------------------------------------
         // --------------------------------------------------------------------------
 
-      private:
+      protected:
+        cantina::LoggerPointer _logger;
         const bytes _track_namespace;
         const bytes _track_name;
         [[maybe_unused]] TrackMode _track_mode;
         uint8_t _def_priority;
         uint32_t _def_ttl;
         std::optional<uint64_t> _track_alias;
-        cantina::LoggerPointer _logger;
+        std::optional<uint64_t> _subscribe_id;
+        TrackSendStatus _send_status { TrackSendStatus::NOT_ANNOUNCED };
+        TrackReadStatus _read_status { TrackReadStatus::NOT_SUBSCRIBED };
     };
 
 } // namespace quicr
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index ffa6a295..372abad0 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -18,7 +18,7 @@ namespace quicr {
         , _server_config({})
         , _client_config(cfg)
         , _delegate(std::move(delegate))
-        , _logger(std::make_shared<cantina::Logger>("MOQ_IC", logger))
+        , _logger(std::make_shared<cantina::Logger>("MIC", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
 #endif
@@ -38,7 +38,7 @@ namespace quicr {
       , _server_config(cfg)
       , _client_config({})
       , _delegate(std::move(delegate))
-      , _logger(std::make_shared<cantina::Logger>("MOQ_IS", logger))
+      , _logger(std::make_shared<cantina::Logger>("MIS", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
 #endif
@@ -168,7 +168,38 @@ namespace quicr {
 
         buffer << server_setup;
 
-        _logger->info << "Sending SERVER_SETUP to conn_id: " << conn_ctx.conn_id << std::flush;
+        _logger->debug << "Sending SERVER_SETUP to conn_id: " << conn_ctx.conn_id << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+    void MoQInstance::send_announce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace)
+    {
+        StreamBuffer<uint8_t> buffer;
+        auto announce = MoqAnnounce{};
+
+        announce.track_namespace.assign(track_namespace.begin(), track_namespace.end());
+        announce.params = {};
+        buffer <<  announce;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending ANNOUNCE to conn_id: " << conn_ctx.conn_id << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+    void MoQInstance::send_announce_ok(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace)
+    {
+        StreamBuffer<uint8_t> buffer;
+        auto announce_ok = MoqAnnounceOk{};
+
+        announce_ok.track_namespace.assign(track_namespace.begin(), track_namespace.end());
+        buffer <<  announce_ok;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending ANNOUNCE OK to conn_id: " << conn_ctx.conn_id << std::flush;
 
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
@@ -205,10 +236,48 @@ namespace quicr {
                 break;
             case MoQMessageType::SUBSCRIBE_ERROR:
                 break;
-            case MoQMessageType::ANNOUNCE:
+            case MoQMessageType::ANNOUNCE: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received announce, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqAnnounce>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqAnnounce>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, { } };
+                    auto th = TrackHash(tfn);
+
+                    if (_delegate->cb_announce(conn_ctx.conn_id, th.track_namespace_hash)) {
+                        send_announce_ok(conn_ctx, msg.track_namespace);
+                    }
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
-            case MoQMessageType::ANNOUNCE_OK:
+            }
+            case MoQMessageType::ANNOUNCE_OK: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received announce ok, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqAnnounceOk>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqAnnounceOk>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, { } };
+                    auto th = TrackHash(tfn);
+                    _logger->debug << "Received announce ok, namespace_hash: " << th.track_namespace_hash << std::flush;
+
+                    // Update each track to indicate status is okay to publish
+                    auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
+                    for (const auto& td: pub_it->second) {
+                        td.second.lock().get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
+                        td.second.lock().get()->cb_sendReady();
+                    }
+
+                }
                 break;
+            }
             case MoQMessageType::ANNOUNCE_ERROR:
                 break;
             case MoQMessageType::UNANNOUNCE:
@@ -227,7 +296,7 @@ namespace quicr {
                 break;
             case MoQMessageType::CLIENT_SETUP: {
                     if (not stream_buffer->anyHasValue()) {
-                        _logger->info << "init stream buffer client setup" << std::flush;
+                        _logger->debug << "Received client setup, init stream buffer" << std::flush;
                         stream_buffer->initAny<MoqClientSetup>();
                     }
 
@@ -272,7 +341,7 @@ namespace quicr {
             }
             case MoQMessageType::SERVER_SETUP: {
                 if (not stream_buffer->anyHasValue()) {
-                    _logger->info << "init stream buffer server setup" << std::flush;
+                    _logger->debug << "Received server setup, init stream buffer" << std::flush;
                     stream_buffer->initAny<MoqServerSetup>();
                 }
 
@@ -320,6 +389,47 @@ namespace quicr {
         return false;
     }
 
+    std::optional<uint64_t> MoQInstance::publishTrack(TransportConnId conn_id,
+                                         std::shared_ptr<MoQTrackDelegate> track_delegate) {
+
+        // Generate track alias
+        auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
+
+        // Track hash is the track alias for now.
+        // TODO(tievens): Evaluate; change hash to be more than 62 bits to avoid collisions
+        auto th = TrackHash(tfn);
+
+        track_delegate->setTrackAlias(th.track_fullname_hash);
+
+        _logger->info << "Publish track conn_id: " << conn_id
+                      << " hash: " << th.track_fullname_hash << std::flush;
+
+        auto conn_it = _connections.find(conn_id);
+        if (conn_it == _connections.end()) {
+            _logger->error << "Publish track conn_id: " << conn_id << " does not exist." << std::flush;
+            return std::nullopt;
+        }
+
+
+        // Set the track alias delegate
+        conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
+
+        // Check if this published track is a new namespace or existing.
+        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash);
+
+        if (ns_is_new) {
+            _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash
+                          << " sending ANNOUNCE message" << std::flush;
+
+            send_announce(conn_it->second, track_delegate->getTrackNamespace());
+        }
+
+        // Add/update the track name delegate
+        pub_ns_it->second[th.track_name_hash] = track_delegate;
+
+        return th.track_fullname_hash;
+    }
+
     // ---------------------------------------------------------------------------------------
     // Transport delegate callbacks
     // ---------------------------------------------------------------------------------------
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
index 5dde2529..274568e7 100644
--- a/src/moq_track_delegate_base.cpp
+++ b/src/moq_track_delegate_base.cpp
@@ -38,15 +38,5 @@ namespace quicr {
         return MoQTrackDelegate::ReadError::NO_DATA;
     }
 
-    MoQTrackDelegate::TrackReadStatus MoQTrackDelegate::statusRead()
-    {
-        return MoQTrackDelegate::TrackReadStatus::OK;
-    }
-
-    MoQTrackDelegate::TrackSendStatus MoQTrackDelegate::statusSend()
-    {
-        return MoQTrackDelegate::TrackSendStatus::OK;
-    }
-
 
 } // namespace quicr
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 57469693..2f40be78 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -6,12 +6,18 @@ add_executable(quicr_test
                 stream_buffer.cpp
                 quicr_server.cpp
                 moq_messages.cpp
+                moq_instance.cpp
                 encode.cpp
         moq_messages.cpp)
 target_include_directories(quicr_test PRIVATE ${PROJECT_SOURCE_DIR}/src)
 
 target_link_libraries(quicr_test PRIVATE quicr doctest::doctest)
 
+if(NOT LIBQUICR_WITHOUT_INFLUXDB)
+    target_link_libraries(quicr_test
+            PRIVATE InfluxData::InfluxDB)
+endif()
+
 target_compile_options(quicr_test
     PRIVATE
         $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>: -Wpedantic -Wextra -Wall>
diff --git a/test/moq_instance.cpp b/test/moq_instance.cpp
new file mode 100644
index 00000000..9dcc3852
--- /dev/null
+++ b/test/moq_instance.cpp
@@ -0,0 +1,29 @@
+#include <doctest/doctest.h>
+
+#include <quicr/moq_instance.h>
+
+using namespace quicr;
+
+TEST_CASE("Track Hash")
+{
+    std::string n1 = "namespace using some very long name";
+    std::string tn1 = "track name can also be long. This track name is long.";
+    std::vector<uint8_t> n1_v { n1.begin(), n1.end()};
+    std::vector<uint8_t> tn1_v { tn1.begin(), tn1.end()};
+
+    std::string n2 = "2 namespace using some very long name";
+    std::string tn2 = "track name can also be long This track name is long. 2";
+    std::vector<uint8_t> n2_v { n2.begin(), n2.end()};
+    std::vector<uint8_t> tn2_v { tn2.begin(), tn2.end()};
+
+    auto tfn_1 = MoQInstance::TrackFullName{ n1_v, tn1_v };
+    auto th_1 = MoQInstance::TrackHash(tfn_1);
+    auto th_1_b = MoQInstance::TrackHash(tfn_1);
+    CHECK_EQ(th_1.track_fullname_hash, th_1_b.track_fullname_hash);
+
+    auto tfn_2 = MoQInstance::TrackFullName{ n2_v, tn2_v };
+    auto th_2 = MoQInstance::TrackHash(tfn_2);
+
+    CHECK_NE(th_1.track_fullname_hash, th_2.track_fullname_hash);
+}
+

From daf0b336d203196e667043ab142554123d19970f Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Sun, 16 Jun 2024 15:30:42 -0700
Subject: [PATCH 42/71] start on subscribe and change to shared ptr

---
 include/quicr/moq_instance.h |  2 +-
 src/moq_instance.cpp         | 49 +++++++++++++++++++++++++++++++++---
 2 files changed, 46 insertions(+), 5 deletions(-)

diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 352ebd27..6947fe8c 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -195,7 +195,7 @@ namespace quicr {
             std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
 
             // Tracks by track alias
-            std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>> tracks_by_alias;
+            std::map<uint64_t, std::shared_ptr<MoQTrackDelegate>> tracks_by_alias;
 
             // Publish tracks by namespace and name. map[track namespace][track name] = track delegate
             std::map<uint64_t, std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>>> pub_tracks_by_name;
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 372abad0..55f68e46 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -106,9 +106,10 @@ namespace quicr {
 #else
         auto conn_id = _transport->start(nullptr, nullptr);
 #endif
-
         LOGGER_INFO(_logger, "Connecting session conn_id: " << conn_id << "...");
-        _connections.try_emplace(conn_id, ConnectionContext{ .conn_id =  conn_id });
+        auto conn_ctx = ConnectionContext();
+        conn_ctx.conn_id = conn_id;
+        _connections.try_emplace(conn_id, conn_ctx);
 
         return _status;
     }
@@ -389,6 +390,47 @@ namespace quicr {
         return false;
     }
 
+    std::optional<uint64_t> MoQInstance::subscribeTrack(TransportConnId conn_id,
+                                                        std::shared_ptr<MoQTrackDelegate> track_delegate) {
+        // Generate track alias
+        auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
+
+        // Track hash is the track alias for now.
+        // TODO(tievens): Evaluate; change hash to be more than 62 bits to avoid collisions
+        auto th = TrackHash(tfn);
+
+        track_delegate->setTrackAlias(th.track_fullname_hash);
+
+        _logger->info << "Subscribe track conn_id: " << conn_id
+                      << " hash: " << th.track_fullname_hash << std::flush;
+
+        auto conn_it = _connections.find(conn_id);
+        if (conn_it == _connections.end()) {
+            _logger->error << "Subscribe track conn_id: " << conn_id << " does not exist." << std::flush;
+            return std::nullopt;
+        }
+
+---
+        // Set the track alias delegate
+        conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
+
+        // Check if this published track is a new namespace or existing.
+        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash);
+
+        if (ns_is_new) {
+            _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash
+                          << " sending ANNOUNCE message" << std::flush;
+
+            send_announce(conn_it->second, track_delegate->getTrackNamespace());
+        }
+
+        // Add/update the track name delegate
+        pub_ns_it->second[th.track_name_hash] = track_delegate;
+
+
+        return th.track_fullname_hash;
+    }
+
     std::optional<uint64_t> MoQInstance::publishTrack(TransportConnId conn_id,
                                          std::shared_ptr<MoQTrackDelegate> track_delegate) {
 
@@ -410,12 +452,11 @@ namespace quicr {
             return std::nullopt;
         }
 
-
         // Set the track alias delegate
         conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
 
         // Check if this published track is a new namespace or existing.
-        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash);
+        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash, track_delegate);
 
         if (ns_is_new) {
             _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash

From 252543a879a3470cf777b5d58743823d7ed16bfb Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 17 Jun 2024 08:41:24 -0700
Subject: [PATCH 43/71] Remove unused moq session and fix weak pointer map

---
 src/CMakeLists.txt   |  1 -
 src/moq_instance.cpp | 37 +++++++++++++++----------------------
 src/moq_session.cpp  | 11 -----------
 src/moq_session.h    | 19 -------------------
 4 files changed, 15 insertions(+), 53 deletions(-)
 delete mode 100644 src/moq_session.cpp
 delete mode 100644 src/moq_session.h

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1e0ee927..2a2cf539 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,7 +11,6 @@ target_sources(quicr PRIVATE
         quicr_server_raw_session.cpp
         moq_instance.cpp
         moq_track_delegate_base.cpp
-        moq_session.cpp
 )
 
 if(NOT LIBQUICR_WITHOUT_INFLUXDB)
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 55f68e46..e49797ee 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -107,9 +107,8 @@ namespace quicr {
         auto conn_id = _transport->start(nullptr, nullptr);
 #endif
         LOGGER_INFO(_logger, "Connecting session conn_id: " << conn_id << "...");
-        auto conn_ctx = ConnectionContext();
-        conn_ctx.conn_id = conn_id;
-        _connections.try_emplace(conn_id, conn_ctx);
+        auto [conn_ctx, _] = _connections.try_emplace(conn_id, ConnectionContext{});
+        conn_ctx->second.conn_id = conn_id;
 
         return _status;
     }
@@ -392,6 +391,7 @@ namespace quicr {
 
     std::optional<uint64_t> MoQInstance::subscribeTrack(TransportConnId conn_id,
                                                         std::shared_ptr<MoQTrackDelegate> track_delegate) {
+
         // Generate track alias
         auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
 
@@ -410,24 +410,9 @@ namespace quicr {
             return std::nullopt;
         }
 
----
         // Set the track alias delegate
         conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
 
-        // Check if this published track is a new namespace or existing.
-        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash);
-
-        if (ns_is_new) {
-            _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash
-                          << " sending ANNOUNCE message" << std::flush;
-
-            send_announce(conn_it->second, track_delegate->getTrackNamespace());
-        }
-
-        // Add/update the track name delegate
-        pub_ns_it->second[th.track_name_hash] = track_delegate;
-
-
         return th.track_fullname_hash;
     }
 
@@ -456,17 +441,25 @@ namespace quicr {
         conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
 
         // Check if this published track is a new namespace or existing.
-        auto [pub_ns_it, ns_is_new] = conn_it->second.pub_tracks_by_name.try_emplace(th.track_namespace_hash, track_delegate);
-
-        if (ns_is_new) {
+        auto pub_ns_it = conn_it->second.pub_tracks_by_name.find(th.track_namespace_hash);
+        if (pub_ns_it == conn_it->second.pub_tracks_by_name.end()) {
             _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash
                           << " sending ANNOUNCE message" << std::flush;
 
             send_announce(conn_it->second, track_delegate->getTrackNamespace());
+
+        } else {
+            auto pub_n_it = pub_ns_it->second.find(th.track_name_hash);
+            if (pub_n_it == pub_ns_it->second.end()) {
+                _logger->info << "Publish track has new track "
+                              << " namespace hash: " << th.track_namespace_hash
+                              << " name hash: " << th.track_name_hash
+                              << std::flush;
+            }
         }
 
         // Add/update the track name delegate
-        pub_ns_it->second[th.track_name_hash] = track_delegate;
+        conn_it->second.pub_tracks_by_name[th.track_namespace_hash][th.track_name_hash] = track_delegate;
 
         return th.track_fullname_hash;
     }
diff --git a/src/moq_session.cpp b/src/moq_session.cpp
deleted file mode 100644
index 7f0d5102..00000000
--- a/src/moq_session.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- *  Copyright (C) 2024
- *  Cisco Systems, Inc.
- *  All Rights Reserved
- */
-
-#include "moq_session.h"
-
-namespace quicr {
-
-} // namespace quicr
diff --git a/src/moq_session.h b/src/moq_session.h
deleted file mode 100644
index e3132321..00000000
--- a/src/moq_session.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- *  Copyright (C) 2024
- *  Cisco Systems, Inc.
- *  All Rights Reserved
- */
-
-#pragma once
-
-#include <quicr/moq_instance.h>
-#include "moq_session.h"
-
-namespace quicr {
-
-class MOQSession
-{
-
-};
-
-} // namespace quicr

From 3150bba72a87ed822df999733c94d26816a61919 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 17 Jun 2024 14:12:24 -0700
Subject: [PATCH 44/71] Implement subscribe flow and refactor memory

Adapts to received subscribe ID, which supports server/relay mode better.
---
 cmd/moq-example/client.cpp            |  49 ++++-
 cmd/moq-example/server.cpp            |  16 ++
 include/quicr/moq_instance.h          |  43 ++++-
 include/quicr/moq_instance_delegate.h |  19 +-
 include/quicr/moq_messages.h          |   9 +
 include/quicr/moq_track_delegate.h    |   8 +
 src/moq_instance.cpp                  | 249 ++++++++++++++++++++++++--
 7 files changed, 367 insertions(+), 26 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 2fea2d48..9a9352e9 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -36,7 +36,10 @@ class trackDelegate : public quicr::MoQTrackDelegate
     }
 
     void cb_sendNotReady(TrackSendStatus status) override {}
-    void cb_readReady() override {}
+    void cb_readReady() override
+    {
+        _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
+    }
     void cb_readNotReady(TrackReadStatus status) override {}
 };
 
@@ -98,6 +101,33 @@ void do_publisher(const std::string t_namespace,
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
 }
 
+void do_subscriber(const std::string t_namespace,
+                   const std::string t_name,
+                   const std::shared_ptr<quicr::MoQInstance>& moqInstance,
+                   const cantina::LoggerPointer& logger,
+                   const bool& stop)
+{
+    cantina::LoggerPointer _logger = std::make_shared<cantina::Logger>("SUB", logger);
+
+    auto mi = moqInstance;
+
+    auto track_delegate = std::make_shared<trackDelegate>(t_namespace, t_name, 2, 3000, logger);
+
+    _logger->info << "Started subscriber track: " << t_namespace << "/" << t_name << std::flush;
+
+    bool subscribe_track { false };
+    while (not stop) {
+        if (!subscribe_track && qclient_vars::conn_id) {
+            _logger->info << "Subscribe track: " << t_namespace << "/" << t_name << std::flush;
+            mi->subscribeTrack(*qclient_vars::conn_id, track_delegate);
+            subscribe_track = true;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    }
+
+    _logger->info << "Subscriber done track: " << t_namespace << "/" << t_name << std::flush;
+}
+
 quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts,
                                            bool& enable_pub,
                                            bool& enable_sub,
@@ -156,7 +186,7 @@ main(int argc, char* argv[])
     options
       .set_width(75)
       .set_tab_expansion()
-      .allow_unrecognised_options()
+      //.allow_unrecognised_options()
       .add_options()
       ("h,help", "Print help")
       ("d,debug", "Enable debugging") // a bool parameter
@@ -188,7 +218,7 @@ main(int argc, char* argv[])
     installSignalHandlers();
 
     // Lock the mutex so that main can then wait on it
-    std::unique_lock<std::mutex> lock(moq_example::main_mutex);
+    std::unique_lock lock(moq_example::main_mutex);
 
     bool enable_pub { false };
     bool enable_sub { false };
@@ -203,7 +233,7 @@ main(int argc, char* argv[])
         moqInstance->run_client();
 
         bool stop_threads { false };
-        std::thread pub_thread;
+        std::thread pub_thread, sub_thread;
         if (enable_pub) {
             pub_thread = std::thread (do_publisher,
                                      result["pub_namespace"].as<std::string>(),
@@ -211,6 +241,13 @@ main(int argc, char* argv[])
                                      moqInstance, logger, stop_threads);
         }
 
+        if (enable_sub) {
+            sub_thread = std::thread (do_subscriber,
+                                      result["sub_namespace"].as<std::string>(),
+                                      result["sub_name"].as<std::string>(),
+                                      moqInstance, logger, stop_threads);
+        }
+
         // Wait until told to terminate
         moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
 
@@ -220,6 +257,10 @@ main(int argc, char* argv[])
             pub_thread.join();
         }
 
+        if (sub_thread.joinable()) {
+            sub_thread.join();
+        }
+
         moqInstance->stop();
 
         logger->info << "Client done" << std::endl;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index e7ad7958..1e27eaa2 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -47,6 +47,22 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
     void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
 
+    bool cb_subscribe(qtransport::TransportConnId conn_id,
+                      uint64_t subscribe_id,
+                      std::span<uint8_t const> name_space,
+                      std::span<uint8_t const> name) override
+    {
+        std::string t_namespace(name_space.begin(), name_space.end());
+        std::string t_name(name.begin(), name.end());
+
+        _logger->info << "New subscribe conn_id: " << conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << " track: " << t_namespace << "/" << t_name
+                       << std::flush;
+
+        return true;
+    }
+
   private:
     cantina::LoggerPointer _logger;
 };
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 6947fe8c..1da3ccea 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -20,6 +20,7 @@
 
 namespace quicr {
     constexpr uint64_t MOQT_VERSION = 0xff000004; /// draft-ietf-moq-transport-04
+    constexpr uint64_t MOQT_SUBSCRIBE_EXPIRES = 0;      /// Never expires
 
     using namespace qtransport;
 
@@ -118,6 +119,7 @@ namespace quicr {
         /**
          * @brief Subscribe to a track
          *
+         * @param conn_id           Connection ID to send subscribe
          * @param track_delegate    Track delegate to use for track related functions and callbacks
          *
          * @returns `track_alias` if no error and nullopt on error
@@ -125,6 +127,21 @@ namespace quicr {
         std::optional<uint64_t> subscribeTrack(TransportConnId conn_id,
                                                std::shared_ptr<MoQTrackDelegate> track_delegate);
 
+        /**
+         * @brief Bind Subscribe track delegate
+         *
+         * @details This method is used to bind a received subscribe to a track delegate
+         *
+         * @param conn_id               Connection ID to send subscribe
+         * @param subscribe_id          Local subscribe ID to use
+         * @param track_delegate        Track delegate to use for track related functions and callbacks
+         *
+         * @returns `track_alias` if no error and nullopt on error
+         */
+        std::optional<uint64_t> bindSubscribeTrack(TransportConnId conn_id,
+                                                   uint64_t subscribe_id,
+                                                   std::shared_ptr<MoQTrackDelegate> track_delegate);
+
         /**
          * @brief Publish to a track
          *
@@ -194,15 +211,13 @@ namespace quicr {
             uint64_t client_version { 0 };
             std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
 
-            // Tracks by track alias
-            std::map<uint64_t, std::shared_ptr<MoQTrackDelegate>> tracks_by_alias;
+            uint64_t _sub_id {0};      /// Connection specific ID for subscribe messages
 
-            // Publish tracks by namespace and name. map[track namespace][track name] = track delegate
-            std::map<uint64_t, std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>>> pub_tracks_by_name;
-
-            // Subscribes by subscribe_id
-            std::map<uint64_t, std::weak_ptr<MoQTrackDelegate>> sub_tracks;
+            // Tracks by subscribe ID
+            std::map<uint64_t, std::shared_ptr<MoQTrackDelegate>> tracks_by_sub_id;
 
+            // Publish tracks by namespace and name. map[track namespace][track name] = track delegate
+            std::map<uint64_t, std::map<uint64_t, std::shared_ptr<MoQTrackDelegate>>> pub_tracks_by_name;
         };
 
         // -------------------------------------------------------------------------------------------------
@@ -215,17 +230,29 @@ namespace quicr {
         void send_server_setup(ConnectionContext& conn_ctx);
         void send_announce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
         void send_announce_ok(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
+        void send_subscribe(ConnectionContext& conn_ctx, uint64_t subscribe_id, TrackFullName& tfn, TrackHash th);
+        void send_subscribe_ok(ConnectionContext& conn_ctx,
+                               uint64_t subscribe_id,
+                               uint64_t expires,
+                               bool content_exists);
+        void send_subscribe_error(ConnectionContext& conn_ctx,
+                                  uint64_t subscribe_id,
+                                  uint64_t track_alias,
+                                  messages::MoQSubscribeError error,
+                                  const std::string& reason);
         void close_connection(TransportConnId conn_id, messages::MoQTerminationReason reason,
                               const std::string& reason_str);
         bool process_recv_message(ConnectionContext& conn_ctx,
                                   std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
+        std::optional<std::weak_ptr<MoQTrackDelegate>> getPubTrackDelegate(ConnectionContext& conn_ctx,
+                                                                           TrackHash& th);
 
         // -------------------------------------------------------------------------------------------------
         // Private member variables
         // -------------------------------------------------------------------------------------------------
 
 
-        std::mutex _mutex;
+        std::mutex _state_mutex;
         const bool _client_mode;
         bool _stop { false };
         const MoQInstanceServerConfig _server_config;
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 20304423..0b44e94f 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <transport/transport.h>
 #include <quicr/moq_messages.h>
+#include <transport/transport.h>
 
 namespace quicr {
     using namespace qtransport;
@@ -77,6 +77,23 @@ namespace quicr {
         virtual bool cb_announce([[maybe_unused]] TransportConnId conn_id,
                                  [[maybe_unused]] uint64_t track_namespace_hash) { return true; }
 
+        /**
+         * @brief Callback notification for new subscribe received
+         *
+         * @param conn_id             Source connection ID
+         * @param subscribe_id        Subscribe ID received
+         * @param name_space          Track Namespace from subscription
+         * @param name                Track name from subscription
+         *
+         * @return True if send announce should be sent, false if not
+         */
+        virtual bool cb_subscribe([[maybe_unused]] TransportConnId conn_id,
+                                  [[maybe_unused]] uint64_t subscribe_id,
+                                  [[maybe_unused]] std::span<uint8_t const> name_space,
+                                  [[maybe_unused]] std::span<uint8_t const> name)
+        {
+            return true;
+        }
 
     };
 
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index f2028277..00ba650a 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -62,6 +62,15 @@ enum class MoQMessageType : uint64_t
     STREAM_HEADER_GROUP,
 };
 
+enum class MoQSubscribeError : uint8_t
+{
+  INTERNAL_ERROR=0x0,
+  INVALID_RANGE,
+  RETRY_TRACK_ALIAS,
+
+  TRACK_NOT_EXIST=0xF0 // Missing in draft
+};
+
 // TODO (Suhas): rename it to StreamMapping
 enum ForwardingPreference : uint8_t {
   StreamPerGroup = 0,
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index ea75a160..63493d26 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -261,7 +261,15 @@ namespace quicr {
         uint8_t _def_priority;
         uint32_t _def_ttl;
         std::optional<uint64_t> _track_alias;
+
+        /**
+         * _subscribe_id is the primary index/key for subscribe subscribe context/delegate storage.
+         *   It is use as the subscribe_id in MOQT related subscribes.  Subscribe ID will adapt
+         *   to received subscribe IDs, so the value will reflect either the received subscribe ID
+         *   or the next one that increments from last received ID.
+         */
         std::optional<uint64_t> _subscribe_id;
+
         TrackSendStatus _send_status { TrackSendStatus::NOT_ANNOUNCED };
         TrackReadStatus _read_status { TrackReadStatus::NOT_SUBSCRIBED };
     };
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index e49797ee..50f01554 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -204,6 +204,82 @@ namespace quicr {
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
+    void MoQInstance::send_subscribe(ConnectionContext& conn_ctx,
+                                     uint64_t subscribe_id,
+                                     TrackFullName& tfn,
+                                     TrackHash th)
+    {
+        StreamBuffer<uint8_t> buffer;
+
+        auto subscribe  = MoqSubscribe {};
+        subscribe.subscribe_id = subscribe_id;
+        subscribe.track_alias = th.track_fullname_hash;
+        subscribe.track_namespace.assign(tfn.name_space.begin(), tfn.name_space.end());
+        subscribe.track_name.assign(tfn.name.begin(), tfn.name.end());
+        subscribe.filter_type = FilterType::LatestGroup;
+        subscribe.num_params = 0;
+
+        buffer << subscribe;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending SUBSCRIBE to conn_id: " << conn_ctx.conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << " track namespace hash: " << th.track_namespace_hash
+                       << " name hash: " << th.track_name_hash
+                       << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+    void MoQInstance::send_subscribe_ok(ConnectionContext& conn_ctx,
+                                        uint64_t subscribe_id,
+                                        uint64_t expires,
+                                        bool content_exists)
+    {
+        StreamBuffer<uint8_t> buffer;
+
+        auto subscribe_ok  = MoqSubscribeOk {};
+        subscribe_ok.subscribe_id = subscribe_id;
+        subscribe_ok.expires = expires;
+        subscribe_ok.content_exists = content_exists;
+        buffer << subscribe_ok;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending SUBSCRIBE OK to conn_id: " << conn_ctx.conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+    void MoQInstance::send_subscribe_error(ConnectionContext& conn_ctx,
+                                           uint64_t subscribe_id,
+                                           uint64_t track_alias,
+                                           MoQSubscribeError error,
+                                           const std::string& reason)
+    {
+        qtransport::StreamBuffer<uint8_t> buffer;
+
+        auto subscribe_err  = MoqSubscribeError {};
+        subscribe_err.subscribe_id = 0x1;
+        subscribe_err.err_code = static_cast<uint64_t>(error);
+        subscribe_err.track_alias = track_alias;
+        subscribe_err.reason_phrase.assign(reason.begin(), reason.end());
+
+        buffer << subscribe_err;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending SUBSCRIBE ERROR to conn_id: " << conn_ctx.conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << " error code: " << static_cast<int>(error)
+                       << " reason: " << reason
+                       << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
 
     MoQInstance::Status MoQInstance::status()
     {
@@ -230,12 +306,103 @@ namespace quicr {
                 break;
             case MoQMessageType::OBJECT_DATAGRAM:
                 break;
-            case MoQMessageType::SUBSCRIBE:
+            case MoQMessageType::SUBSCRIBE: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received subscribe, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqSubscribe>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqSubscribe>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, msg.track_name };
+                    auto th = TrackHash(tfn);
+
+                    // For client/publisher, notify track that there is a subscriber
+                    if (_client_mode) {
+                        auto ptd = getPubTrackDelegate(conn_ctx, th);
+                        if (not ptd.has_value()) {
+                            _logger->info << "Received subscribe unknown publish track"
+                                          << " namespace hash: " << th.track_namespace_hash
+                                          << " name hash: " << th.track_name_hash
+                                          << std::flush;
+
+                            send_subscribe_error(conn_ctx,
+                                                 msg.subscribe_id,
+                                                 msg.track_alias,
+                                                 MoQSubscribeError::TRACK_NOT_EXIST,
+                                                 "Published track not found");
+                            return true;
+                        }
+
+                        // TODO(tievens): Set content exists
+                        send_subscribe_ok(conn_ctx, msg.subscribe_id, MOQT_SUBSCRIBE_EXPIRES, false);
+
+                        // Indicate send is ready upon subscribe
+                        // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
+                        ptd->lock().get()->cb_sendReady();
+
+                    } else { // Server mode
+                        if (msg.subscribe_id > conn_ctx._sub_id) {
+                            conn_ctx._sub_id = msg.subscribe_id+1;
+                        }
+
+                        // TODO(tievens): add filter type when caching supports it
+                        if (_delegate->cb_subscribe(conn_ctx.conn_id,
+                                                    msg.subscribe_id,
+                                                    tfn.name_space,
+                                                    tfn.name)) {
+                            send_subscribe_ok(conn_ctx, msg.subscribe_id, MOQT_SUBSCRIBE_EXPIRES, false);
+                        }
+                    }
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
-            case MoQMessageType::SUBSCRIBE_OK:
+            }
+            case MoQMessageType::SUBSCRIBE_OK: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received subscribe ok, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqSubscribeOk>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqSubscribeOk>();
+                if (*stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->info << "Received subsribe ok to unknown subscribe track"
+                                      << " subscribe_id: " << msg.subscribe_id
+                                      << " , ignored"
+                                      << std::flush;
+
+                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        stream_buffer->resetAny();
+                        return true;
+                    }
+
+                    sub_it->second.get()->cb_readReady();
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
-            case MoQMessageType::SUBSCRIBE_ERROR:
+            }
+            case MoQMessageType::SUBSCRIBE_ERROR: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received subscribe error, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqSubscribeError>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqSubscribeError>();
+                if (*stream_buffer >> msg) {
+
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
+            }
             case MoQMessageType::ANNOUNCE: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received announce, init stream buffer" << std::flush;
@@ -271,10 +438,12 @@ namespace quicr {
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
                     for (const auto& td: pub_it->second) {
-                        td.second.lock().get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
-                        td.second.lock().get()->cb_sendReady();
+                        td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
+                        td.second.get()->cb_sendReady();
                     }
 
+                    stream_buffer->resetAny();
+                    return true;
                 }
                 break;
             }
@@ -390,8 +559,8 @@ namespace quicr {
     }
 
     std::optional<uint64_t> MoQInstance::subscribeTrack(TransportConnId conn_id,
-                                                        std::shared_ptr<MoQTrackDelegate> track_delegate) {
-
+                                                        std::shared_ptr<MoQTrackDelegate> track_delegate)
+    {
         // Generate track alias
         auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
 
@@ -404,14 +573,53 @@ namespace quicr {
         _logger->info << "Subscribe track conn_id: " << conn_id
                       << " hash: " << th.track_fullname_hash << std::flush;
 
+        std::lock_guard<std::mutex> _(_state_mutex);
         auto conn_it = _connections.find(conn_id);
         if (conn_it == _connections.end()) {
             _logger->error << "Subscribe track conn_id: " << conn_id << " does not exist." << std::flush;
             return std::nullopt;
         }
 
-        // Set the track alias delegate
-        conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
+        auto sid = conn_it->second._sub_id++;
+
+        _logger->debug << "subscribe id to add to memory: " << sid << std::flush;
+
+        // Set the track delegate for pub/sub using _sub_pub_id, which is the subscribe Id in MOQT
+        conn_it->second.tracks_by_sub_id[sid] = track_delegate;
+
+        track_delegate->setSubscribeId(sid);
+
+        send_subscribe(conn_it->second, sid, tfn, th);
+
+        return th.track_fullname_hash;
+    }
+
+    std::optional<uint64_t> MoQInstance::bindSubscribeTrack(TransportConnId conn_id,
+                                                            uint64_t subscribe_id,
+                                                            std::shared_ptr<MoQTrackDelegate> track_delegate) {
+
+        // Generate track alias
+        auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
+
+        // Track hash is the track alias for now.
+        auto th = TrackHash(tfn);
+
+        track_delegate->setTrackAlias(th.track_fullname_hash);
+
+        _logger->info << "Bind subscribe track delegate conn_id: " << conn_id
+                      << " hash: " << th.track_fullname_hash << std::flush;
+
+        std::lock_guard<std::mutex> _(_state_mutex);
+        auto conn_it = _connections.find(conn_id);
+        if (conn_it == _connections.end()) {
+            _logger->error << "Subscribe track conn_id: " << conn_id << " does not exist." << std::flush;
+            return std::nullopt;
+        }
+
+        // Set the track delegate for pub/sub using _sub_pub_id, which is the subscribe Id in MOQT
+        conn_it->second.tracks_by_sub_id[subscribe_id] = track_delegate;
+
+        track_delegate->setSubscribeId(subscribe_id);
 
         return th.track_fullname_hash;
     }
@@ -431,15 +639,14 @@ namespace quicr {
         _logger->info << "Publish track conn_id: " << conn_id
                       << " hash: " << th.track_fullname_hash << std::flush;
 
+        std::lock_guard<std::mutex> _(_state_mutex);
+
         auto conn_it = _connections.find(conn_id);
         if (conn_it == _connections.end()) {
             _logger->error << "Publish track conn_id: " << conn_id << " does not exist." << std::flush;
             return std::nullopt;
         }
 
-        // Set the track alias delegate
-        conn_it->second.tracks_by_alias[th.track_fullname_hash] = track_delegate;
-
         // Check if this published track is a new namespace or existing.
         auto pub_ns_it = conn_it->second.pub_tracks_by_name.find(th.track_namespace_hash);
         if (pub_ns_it == conn_it->second.pub_tracks_by_name.end()) {
@@ -458,12 +665,28 @@ namespace quicr {
             }
         }
 
-        // Add/update the track name delegate
+        // Set the track delegate for pub/sub
         conn_it->second.pub_tracks_by_name[th.track_namespace_hash][th.track_name_hash] = track_delegate;
 
         return th.track_fullname_hash;
     }
 
+    std::optional<std::weak_ptr<MoQTrackDelegate>> MoQInstance::getPubTrackDelegate(ConnectionContext& conn_ctx,
+                                                                                    TrackHash& th)
+    {
+        auto pub_ns_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
+        if (pub_ns_it == conn_ctx.pub_tracks_by_name.end()) {
+            return std::nullopt;
+        } else {
+            auto pub_n_it = pub_ns_it->second.find(th.track_name_hash);
+            if (pub_n_it == pub_ns_it->second.end()) {
+                return std::nullopt;
+            }
+
+            return pub_n_it->second;
+        }
+    }
+
     // ---------------------------------------------------------------------------------------
     // Transport delegate callbacks
     // ---------------------------------------------------------------------------------------

From 4ebe164050bf662c168ba6eb8af19b74c2ba31a3 Mon Sep 17 00:00:00 2001
From: suhasHere <snandaku@cisco.com>
Date: Mon, 17 Jun 2024 22:03:26 -0700
Subject: [PATCH 45/71] add stream-per-group reception, api updates

---
 cmd/moq-example/client.cpp            | 14 +++++++-
 cmd/moq-example/server.cpp            | 34 +++++++++++++++---
 include/quicr/moq_instance_delegate.h | 11 ++++++
 include/quicr/moq_track_delegate.h    | 12 ++++---
 src/moq_instance.cpp                  | 50 +++++++++++++++++++++++++--
 src/moq_track_delegate_base.cpp       | 22 ++++++++----
 6 files changed, 123 insertions(+), 20 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 9a9352e9..1855dee0 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -28,7 +28,7 @@ class trackDelegate : public quicr::MoQTrackDelegate
     {
     }
 
-    void cb_objectReceived(std::vector<uint8_t>&& object) override {}
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {}
     void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
 
     void cb_sendReady() override {
@@ -41,6 +41,11 @@ class trackDelegate : public quicr::MoQTrackDelegate
         _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
     }
     void cb_readNotReady(TrackReadStatus status) override {}
+
+    SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl) {
+        //TODO: check send status before sending
+
+    }
 };
 
 class clientDelegate : public quicr::MoQInstanceDelegate
@@ -96,6 +101,13 @@ void do_publisher(const std::string t_namespace,
             published_track = true;
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+        //TODO: Hardcoded publish, remove and make it interactive sends
+        constexpr auto NUM_MESSAGES = 10;
+        auto data = std::vector<uint8_t> {0, 1, 2, 3, 4, 5};
+        for (int i = 0; i < NUM_MESSAGES; i++) {
+            track_delegate->sendObject(100, i, data, 3, 500);
+        }
     }
 
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 1e27eaa2..8f78bc2b 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -52,19 +52,43 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                       std::span<uint8_t const> name_space,
                       std::span<uint8_t const> name) override
     {
-        std::string t_namespace(name_space.begin(), name_space.end());
-        std::string t_name(name.begin(), name.end());
+        std::string const t_namespace(name_space.begin(), name_space.end());
+        std::string const t_name(name.begin(), name.end());
 
         _logger->info << "New subscribe conn_id: " << conn_id
                        << " subscribe_id: " << subscribe_id
                        << " track: " << t_namespace << "/" << t_name
                        << std::flush;
 
+        active_subscriptions[subscribe_id] = conn_id;
         return true;
     }
 
+    bool cb_object_received([[maybe_unused]] qtransport::TransportConnId conn_id,
+                            [[maybe_unused]] uint64_t subscribe_id,
+                            [[maybe_unused]] uint64_t track_alias,
+                            [[maybe_unused]] uint64_t group_id,
+                            [[maybe_unused]] uint64_t object_id,
+                            [[maybe_unused]] std::vector<uint8_t>&& data)
+    {
+        if (!active_subscriptions.contains(subscribe_id)) {
+            _logger->info << "no active subscription conn_id: " << conn_id
+                          << " subscribe_id: " << subscribe_id
+                          << std::flush;
+            return true;
+        }
+
+        active_subscriptions.at(subscribe_id);
+    }
+
+    void set_moq_instance(std::shared_ptr<quicr::MoQInstance> mi) {
+        moq_instance_ptr = mi;
+    }
   private:
     cantina::LoggerPointer _logger;
+    std::weak_ptr<quicr::MoQInstance> moq_instance_ptr;
+    // map of subscription to its connections.
+    std::map<uint64_t , qtransport::TransportConnId> active_subscriptions {};
 };
 
 quicr::MoQInstanceServerConfig init_config(cxxopts::ParseResult& cli_opts, const cantina::LoggerPointer& logger)
@@ -137,9 +161,9 @@ main(int argc, char* argv[])
     auto delegate = std::make_shared<serverDelegate>(logger);
 
     try {
-        auto moqInstance = quicr::MoQInstance{config, delegate, logger};
-
-        moqInstance.run_server();
+        auto moqInstance = std::make_shared<quicr::MoQInstance>(config, delegate, logger);
+        delegate->set_moq_instance(moqInstance);
+        moqInstance->run_server();
 
         // Wait until told to terminate
         moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 0b44e94f..8789c338 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -95,6 +95,17 @@ namespace quicr {
             return true;
         }
 
+        virtual bool cb_object_received([[maybe_unused]] TransportConnId conn_id,
+                                        [[maybe_unused]] uint64_t subscribe_id,
+                                        [[maybe_unused]] uint64_t track_alias,
+                                        [[maybe_unused]] uint64_t group_id,
+                                        [[maybe_unused]] uint64_t object_id,
+                                        [[maybe_unused]] std::vector<uint8_t>&& data)
+        {
+            return true;
+        }
+
+
     };
 
 } // namespace quicr
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 63493d26..45d03acb 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -98,10 +98,10 @@ namespace quicr {
          * @returns SendError status of the send
          *
          */
-        SendError sendObject(const std::span<const uint8_t>& object);
-        SendError sendObject(const std::span<const uint8_t>& object, uint32_t ttl);
-        SendError sendObject(const std::span<const uint8_t>& object, uint8_t priority);
-        SendError sendObject(const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl);
+        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object);
+        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint32_t ttl);
+        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority);
+        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl);
 
         /**
          * @brief Read object from track
@@ -153,7 +153,9 @@ namespace quicr {
          *
          * @param object    Data object received
          */
-        virtual void cb_objectReceived(std::vector<uint8_t>&& object) = 0;
+        virtual void cb_objectReceived(uint64_t group_id,
+                                       uint64_t object_id,
+                                       std::vector<uint8_t>&& object) = 0;
 
         /**
          * @brief Notification that data can be sent
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 50f01554..4ce5a08f 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -540,8 +540,6 @@ namespace quicr {
 
                     stream_buffer->resetAny();
                     conn_ctx.setup_complete = true;
-
-
                     return true;
                 }
                 break;
@@ -549,6 +547,54 @@ namespace quicr {
             case MoQMessageType::STREAM_HEADER_TRACK:
                 break;
             case MoQMessageType::STREAM_HEADER_GROUP:
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received stream header group, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqStreamHeaderGroup>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqStreamHeaderGroup>();
+                if (*stream_buffer >> msg) {
+                    if (_client_mode) {
+                            auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                            if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                                _logger->info << "Received stream_header_group to unknown subscribe track"
+                                          << " subscribe_id: " << msg.subscribe_id
+                                          << " , ignored"
+                                          << std::flush;
+
+                                stream_buffer->resetAny();
+                                return true;
+                            }
+
+                            stream_buffer->resetAny();
+                            // let's get the full object payload
+                            stream_buffer->initAny<MoqStreamGroupObject>();
+                            auto& obj = stream_buffer->getAny<MoqStreamGroupObject>();
+                            if (*stream_buffer >> obj) {
+                                sub_it->second->cb_objectReceived(msg.group_id, obj.object_id, std::move(obj.payload));
+                            }
+                            stream_buffer->resetAny();
+                            return true;
+                    } else {
+                            //TODO: refactor this into its own function
+                            stream_buffer->resetAny();
+                            // let's get the full object payload
+                            stream_buffer->initAny<MoqStreamGroupObject>();
+                            auto& obj = stream_buffer->getAny<MoqStreamGroupObject>();
+                            if (*stream_buffer >> obj) {
+                                _delegate->cb_object_received(conn_ctx.conn_id,
+                                                              msg.subscribe_id,
+                                                              msg.track_alias,
+                                                              msg.group_id,
+                                                              obj.object_id,
+                                                              std::move(obj.payload));
+                            }
+                            stream_buffer->resetAny();
+                            return true;
+                    }
+
+                }
+
                 break;
         }
 
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
index 274568e7..16eade62 100644
--- a/src/moq_track_delegate_base.cpp
+++ b/src/moq_track_delegate_base.cpp
@@ -9,26 +9,34 @@
 
 namespace quicr {
 
-    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object)
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
+                                                             [[maybe_unused]] const uint64_t object_id,
+                                                             [[maybe_unused]] const std::span<const uint8_t>& object)
     {
         return MoQTrackDelegate::SendError::OK;
     }
 
-    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
+                                                             [[maybe_unused]] const uint64_t object_id,
+                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
                                                              [[maybe_unused]] uint32_t ttl)
     {
         return MoQTrackDelegate::SendError::OK;
     }
 
-    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
-                                           [[maybe_unused]] uint8_t priority)
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
+                                                             [[maybe_unused]] const uint64_t object_id,
+                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] uint8_t priority)
     {
         return MoQTrackDelegate::SendError::OK;
     }
 
-    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const std::span<const uint8_t>& object,
-                                           [[maybe_unused]] uint8_t priority,
-                                           [[maybe_unused]] uint32_t ttl)
+    MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
+                                                             [[maybe_unused]] const uint64_t object_id,
+                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] uint8_t priority,
+                                                             [[maybe_unused]] uint32_t ttl)
     {
         return MoQTrackDelegate::SendError::OK;
     }

From 653a3d589791d63b36a4b4b4033ac7b6ff5c1417 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 18 Jun 2024 17:08:39 -0700
Subject: [PATCH 46/71] Add sendObject and start on receive object handling. 
 Still in progress

---
 cmd/moq-example/client.cpp            |  38 ++-
 cmd/moq-example/server.cpp            | 100 ++++++--
 include/quicr/moq_instance.h          |  16 +-
 include/quicr/moq_instance_delegate.h |  26 +-
 include/quicr/moq_track_delegate.h    |  85 +++++--
 src/moq_instance.cpp                  | 349 +++++++++++++++++++++-----
 src/moq_track_delegate_base.cpp       |  36 ++-
 7 files changed, 513 insertions(+), 137 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 1855dee0..082a6bb0 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -41,11 +41,6 @@ class trackDelegate : public quicr::MoQTrackDelegate
         _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
     }
     void cb_readNotReady(TrackReadStatus status) override {}
-
-    SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl) {
-        //TODO: check send status before sending
-
-    }
 };
 
 class clientDelegate : public quicr::MoQInstanceDelegate
@@ -94,20 +89,41 @@ void do_publisher(const std::string t_namespace,
     _logger->info << "Started publisher track: " << t_namespace << "/" << t_name << std::flush;
 
     bool published_track { false };
+    bool sending { false };
+    uint64_t group_id { 0 };
+    uint64_t object_id { 0 };
+
     while (not stop) {
         if (!published_track && qclient_vars::conn_id) {
             _logger->info << "Publish track: " << t_namespace << "/" << t_name << std::flush;
             mi->publishTrack(*qclient_vars::conn_id, track_delegate);
             published_track = true;
         }
-        std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
-        //TODO: Hardcoded publish, remove and make it interactive sends
-        constexpr auto NUM_MESSAGES = 10;
-        auto data = std::vector<uint8_t> {0, 1, 2, 3, 4, 5};
-        for (int i = 0; i < NUM_MESSAGES; i++) {
-            track_delegate->sendObject(100, i, data, 3, 500);
+        if (track_delegate->statusSend() != quicr::MoQTrackDelegate::TrackSendStatus::OK) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            continue;
         }
+
+        if (!sending) {
+            _logger->info << "--------------------------------------------------------------------------" << std::flush;
+            _logger->info << " Type message and press enter to send" << std::flush;
+            _logger->info << "--------------------------------------------------------------------------" << std::flush;
+            sending = true;
+        }
+
+        std::string msg;
+        getline(std::cin, msg);
+        _logger->info << "Send mesage: " << msg << std::flush;
+
+        if (object_id % 5 == 0) {       // Set new group
+            object_id = 0;
+            group_id++;
+        }
+
+        std::vector<uint8_t> msg_v(msg.begin(), msg.end());
+        auto result = track_delegate->sendObject(group_id, object_id++, std::move(msg_v));
+        _logger->info << "send error: " << static_cast<int>(result) << std::flush;
     }
 
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 8f78bc2b..adac2288 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -2,14 +2,57 @@
 #include <quicr/moq_instance.h>
 
 #include <cantina/logger.h>
+#include <unordered_map>
 #include <condition_variable>
 #include <csignal>
 #include <oss/cxxopts.hpp>
+#include "signal_handler.h"
+#include "subscription.h"
 
+namespace qserver_vars {
+    /*
+     * Active subscribes for a given track, indexed (keyed) by track_alias,conn_id
+     *     NOTE: This indexing intentionally prohibits per connection having more
+     *           than one subscribe to a full track name.
+     *
+     *     Example: track_delegate = subscribes[track_alias][conn_id]
+     */
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> subscribes;
 
-#include "signal_handler.h"
+}
+
+class subTrackDelegate : public quicr::MoQTrackDelegate
+{
+public:
+    subTrackDelegate(const std::string& t_namespace,
+                     const std::string& t_name,
+                     uint8_t priority,
+                     uint32_t ttl,
+                     const cantina::LoggerPointer& logger)
+      : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
+                         { t_name.begin(), t_name.end() },
+                         TrackMode::STREAM_PER_GROUP,
+                         priority,
+                         ttl,
+                         logger)
+    {
+    }
+
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {}
+    void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
+
+    void cb_sendReady() override {
+        _logger->info << "Track alias: " << _track_alias.value() << " is ready to send" << std::flush;
+    }
+
+    void cb_sendNotReady(TrackSendStatus status) override {}
+    void cb_readReady() override
+    {
+        _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
+    }
+    void cb_readNotReady(TrackReadStatus status) override {}
+};
 
-#include "subscription.h"
 
 class serverDelegate : public quicr::MoQInstanceDelegate
 {
@@ -17,6 +60,11 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     serverDelegate(const cantina::LoggerPointer& logger) :
       _logger(std::make_shared<cantina::Logger>("MID", logger)) {}
 
+    void set_moq_instance(std::weak_ptr<quicr::MoQInstance> moq_instance)
+    {
+        _moq_instance = moq_instance;
+    }
+
     void cb_newConnection(qtransport::TransportConnId conn_id,
                           const std::span<uint8_t>& endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
@@ -60,35 +108,45 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                        << " track: " << t_namespace << "/" << t_name
                        << std::flush;
 
-        active_subscriptions[subscribe_id] = conn_id;
+        auto track_delegate = std::make_shared<subTrackDelegate>(t_namespace, t_name, 2, 3000, _logger);
+        auto tfn = quicr::MoQInstance::TrackFullName{ name_space, name };
+        auto th = quicr::MoQInstance::TrackHash(tfn);
+        qserver_vars::subscribes[th.track_fullname_hash][conn_id] = track_delegate;
+
+        // Create a subscribe track that will be used by the relay to send to subscriber for matching objects
+        _moq_instance.lock()->bindSubscribeTrack(conn_id, subscribe_id, track_delegate);
+
         return true;
     }
 
-    bool cb_object_received([[maybe_unused]] qtransport::TransportConnId conn_id,
-                            [[maybe_unused]] uint64_t subscribe_id,
-                            [[maybe_unused]] uint64_t track_alias,
-                            [[maybe_unused]] uint64_t group_id,
-                            [[maybe_unused]] uint64_t object_id,
-                            [[maybe_unused]] std::vector<uint8_t>&& data)
+    void cb_objectReceived(qtransport::TransportConnId conn_id,
+                           uint64_t subscribe_id,
+                           uint64_t track_alias,
+                           uint64_t group_id,
+                           uint64_t object_id,
+                           std::vector<uint8_t>&& data)
     {
-        if (!active_subscriptions.contains(subscribe_id)) {
-            _logger->info << "no active subscription conn_id: " << conn_id
-                          << " subscribe_id: " << subscribe_id
+        _logger->info << "Recieved object conn_id: " << conn_id
+                      << " subscribe_id: " << subscribe_id
+                      << " track_alias: " << track_alias
+                      << " group_id: " << group_id
+                      << " object_id: " << object_id
+                      << " data size: " << data.size()
+                      << std::flush;
+
+        // Relay to all subscribes
+        auto sub_it = qserver_vars::subscribes.find(track_alias);
+        for (auto& [conn_id, track_delegate]: sub_it->second) {
+            _logger->info << "Sending to conn_id: " << conn_id
+                          << " subscribe_id: " << *track_delegate->getSubscribeId()
                           << std::flush;
-            return true;
+            track_delegate->sendObject(group_id, object_id, data);
         }
-
-        active_subscriptions.at(subscribe_id);
     }
 
-    void set_moq_instance(std::shared_ptr<quicr::MoQInstance> mi) {
-        moq_instance_ptr = mi;
-    }
   private:
     cantina::LoggerPointer _logger;
-    std::weak_ptr<quicr::MoQInstance> moq_instance_ptr;
-    // map of subscription to its connections.
-    std::map<uint64_t , qtransport::TransportConnId> active_subscriptions {};
+    std::weak_ptr<quicr::MoQInstance> _moq_instance;
 };
 
 quicr::MoQInstanceServerConfig init_config(cxxopts::ParseResult& cli_opts, const cantina::LoggerPointer& logger)
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 1da3ccea..3b456445 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -201,6 +201,14 @@ namespace quicr {
                             const bool is_bidir = false) override;
         void on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id) override;
 
+        MoQTrackDelegate::SendError send_object(std::weak_ptr<MoQTrackDelegate> track_delegate,
+                                                uint8_t priority,
+                                                uint32_t ttl,
+                                                bool stream_header_needed,
+                                                uint64_t group_id,
+                                                uint64_t object_id,
+                                                bytes&& data);
+
       private:
 
         struct ConnectionContext
@@ -209,7 +217,7 @@ namespace quicr {
             std::optional<uint64_t> ctrl_data_ctx_id;
             bool setup_complete { false };   /// True if both client and server setup messages have completed
             uint64_t client_version { 0 };
-            std::optional<messages::MoQMessageType> msg_type_received;  /// Indicates the current message type being read
+            std::optional<messages::MoQMessageType> ctrl_msg_type_received;  /// Indicates the current message type being read
 
             uint64_t _sub_id {0};      /// Connection specific ID for subscribe messages
 
@@ -242,8 +250,10 @@ namespace quicr {
                                   const std::string& reason);
         void close_connection(TransportConnId conn_id, messages::MoQTerminationReason reason,
                               const std::string& reason_str);
-        bool process_recv_message(ConnectionContext& conn_ctx,
-                                  std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
+        bool process_recv_ctrl_message(ConnectionContext& conn_ctx,
+                                       std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
+        bool process_recv_data_message(ConnectionContext& conn_ctx,
+                                       std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
         std::optional<std::weak_ptr<MoQTrackDelegate>> getPubTrackDelegate(ConnectionContext& conn_ctx,
                                                                            TrackHash& th);
 
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 8789c338..08cbef4c 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -95,16 +95,22 @@ namespace quicr {
             return true;
         }
 
-        virtual bool cb_object_received([[maybe_unused]] TransportConnId conn_id,
-                                        [[maybe_unused]] uint64_t subscribe_id,
-                                        [[maybe_unused]] uint64_t track_alias,
-                                        [[maybe_unused]] uint64_t group_id,
-                                        [[maybe_unused]] uint64_t object_id,
-                                        [[maybe_unused]] std::vector<uint8_t>&& data)
-        {
-            return true;
-        }
-
+        /**
+         * @brief Server Mode; Callback notification on new object received to be relayed
+         *
+         * @param conn_id              Source connection Id
+         * @param subscribe_id         Subscribe ID received
+         * @param track_alias          Track alias received
+         * @param group_id             Group ID received
+         * @param object_id            Object ID received
+         * @param data                 Data received
+         */
+        virtual void cb_objectReceived([[maybe_unused]] TransportConnId conn_id,
+                                       [[maybe_unused]] uint64_t subscribe_id,
+                                       [[maybe_unused]] uint64_t track_alias,
+                                       [[maybe_unused]] uint64_t group_id,
+                                       [[maybe_unused]] uint64_t object_id,
+                                       [[maybe_unused]] std::vector<uint8_t>&& data) {}
 
     };
 
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 45d03acb..6f30dc54 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -5,7 +5,6 @@
  */
 #pragma once
 
-#include <quicr/moq_messages.h>
 #include <quicr/quicr_common.h>
 
 namespace quicr {
@@ -32,6 +31,7 @@ namespace quicr {
         enum class SendError : uint8_t
         {
             OK = 0,
+            INTERNAL_ERROR,
             NOT_AUTHORIZED,
             NOT_ANNOUNCED,
             NO_SUBSCRIBERS,
@@ -76,10 +76,10 @@ namespace quicr {
                          uint8_t default_priority,
                          uint32_t default_ttl,
                          const cantina::LoggerPointer& logger) :
-              _logger(std::make_shared<cantina::Logger>("MTD", logger))
+              _mi_track_mode(track_mode)
+             , _logger(std::make_shared<cantina::Logger>("MTD", logger))
              , _track_namespace(track_namespace)
              , _track_name(track_name)
-             , _track_mode(track_mode)
         {
           this->setDefaultPriority(default_priority);
           this->setDefaultTTL(default_ttl);
@@ -93,26 +93,29 @@ namespace quicr {
          *   indicate if there are no subscribers. In this case, the object will
          *   not be sent.
          *
-         * @param[in] object   Object to send to track
+         * @param[in] group_id     Group ID of object
+         * @param[in] object_id    Object ID of the object
+         * @param[in] object       Object to send to track
+         * @param[in] ttl          Expire TTL for object
+         * @param[in] priority     Priority for object; will be set upon next qualifing stream object
          *
          * @returns SendError status of the send
          *
          */
-        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object);
-        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint32_t ttl);
-        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority);
-        SendError sendObject(const uint64_t  group_id, const uint64_t object_id, const std::span<const uint8_t>& object, uint8_t priority, uint32_t ttl);
-
-        /**
-         * @brief Read object from track
-         *
-         * @details Reads an object from the subscribed track
-         *
-         * @param[out] object   Refence to object to be updated. Will be cleared.
-         *
-         * @returns ReadError status of the read
-         */
-        ReadError readObject(std::vector<const uint8_t>& object);
+        SendError sendObject(const uint64_t group_id, const uint64_t object_id, const std::span<const uint8_t>& object);
+        SendError sendObject(const uint64_t group_id,
+                             const uint64_t object_id,
+                             const std::span<const uint8_t>& object,
+                             uint32_t ttl);
+        SendError sendObject(const uint64_t group_id,
+                             const uint64_t object_id,
+                             const std::span<const uint8_t>& object,
+                             uint8_t priority);
+        SendError sendObject(const uint64_t group_id,
+                             const uint64_t object_id,
+                             const std::span<const uint8_t>& object,
+                             uint8_t priority,
+                             uint32_t ttl);
 
         /**
          * @brief Current track read status
@@ -142,6 +145,11 @@ namespace quicr {
          */
         void setDefaultTTL(uint32_t ttl) { _def_ttl = ttl; }
 
+        /**
+         * @brief set/update the track mode for sending
+         */
+        void setTrackMode(TrackMode track_mode) { _mi_track_mode = track_mode; }
+
         // --------------------------------------------------------------------------
         // Public Virtual API callback event methods to be overridden
         // --------------------------------------------------------------------------
@@ -252,6 +260,38 @@ namespace quicr {
          */
         void setSendStatus(TrackSendStatus status) { _send_status = status; }
 
+
+        // --------------------------------------------------------------------------
+        // MOQ Instance specific public variables/methods - Caller should not use these
+        // --------------------------------------------------------------------------
+
+        /**
+         * @brief Send Object function via the MoQ instance
+         *
+         * @details This is set by the MoQInstance.
+         *   Send object function provides direct access to the MoQInstance that will send
+         *   the object based on the track mode.
+         *
+         * @param priority              Priority to use for object; set on next track change
+         * @param ttl                   Expire time to live in milliseconds
+         * @param stream_header_needed  Indicates if group or track header is needed before this data object
+         * @param data                  Raw data/object that should be transmitted - MoQInstance serializes the data
+         */
+        std::function<SendError(uint8_t priority,
+                                uint32_t ttl,
+                                bool stream_header_needed,
+                                uint64_t group_id,
+                                uint64_t object_id,
+                                bytes&& data)> _mi_sendObjFunc;
+
+        uint64_t _mi_send_data_ctx_id;    // Set by moq instance
+        uint64_t _mi_conn_id;             // Set by moq instance
+        TrackMode _mi_track_mode;         // Set by moq instance
+        bool _mi_stream_header_received { false }; // True if stream header is complete, false if pending
+
+        uint8_t _def_priority;            // Set by caller and is used when priority is not specified
+        uint32_t _def_ttl;                // Set by caller and is used when TTL is not specified
+
         // --------------------------------------------------------------------------
         // --------------------------------------------------------------------------
 
@@ -259,9 +299,6 @@ namespace quicr {
         cantina::LoggerPointer _logger;
         const bytes _track_namespace;
         const bytes _track_name;
-        [[maybe_unused]] TrackMode _track_mode;
-        uint8_t _def_priority;
-        uint32_t _def_ttl;
         std::optional<uint64_t> _track_alias;
 
         /**
@@ -274,6 +311,10 @@ namespace quicr {
 
         TrackSendStatus _send_status { TrackSendStatus::NOT_ANNOUNCED };
         TrackReadStatus _read_status { TrackReadStatus::NOT_SUBSCRIBED };
+
+      private:
+        uint64_t _prev_group_id {0};
+        bool _sent_track_header { false };  // Used only in stream per tarck mode
     };
 
 } // namespace quicr
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 4ce5a08f..b002bce5 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -286,7 +286,7 @@ namespace quicr {
         return _status;
     }
 
-    bool MoQInstance::process_recv_message(ConnectionContext& conn_ctx,
+    bool MoQInstance::process_recv_ctrl_message(ConnectionContext& conn_ctx,
                                            std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer)
     {
         if (stream_buffer->size() == 0) { // should never happen
@@ -295,17 +295,13 @@ namespace quicr {
                              "Stream buffer cannot be zero when parsing message type");
         }
 
-        if (not conn_ctx.msg_type_received) { // should never happen
+        if (not conn_ctx.ctrl_msg_type_received) { // should never happen
             close_connection(conn_ctx.conn_id,
                              MoQTerminationReason::INTERNAL_ERROR,
                              "Process recv message connection context is missing message type");
         }
 
-        switch (*conn_ctx.msg_type_received) {
-            case MoQMessageType::OBJECT_STREAM:
-                break;
-            case MoQMessageType::OBJECT_DATAGRAM:
-                break;
+        switch (*conn_ctx.ctrl_msg_type_received) {
             case MoQMessageType::SUBSCRIBE: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received subscribe, init stream buffer" << std::flush;
@@ -321,7 +317,7 @@ namespace quicr {
                     if (_client_mode) {
                         auto ptd = getPubTrackDelegate(conn_ctx, th);
                         if (not ptd.has_value()) {
-                            _logger->info << "Received subscribe unknown publish track"
+                            _logger->warning << "Received subscribe unknown publish track"
                                           << " namespace hash: " << th.track_namespace_hash
                                           << " name hash: " << th.track_name_hash
                                           << std::flush;
@@ -339,7 +335,8 @@ namespace quicr {
 
                         // Indicate send is ready upon subscribe
                         // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
-                        ptd->lock().get()->cb_sendReady();
+                        ptd->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
+                        ptd->lock()->cb_sendReady();
 
                     } else { // Server mode
                         if (msg.subscribe_id > conn_ctx._sub_id) {
@@ -371,7 +368,7 @@ namespace quicr {
                     auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
-                        _logger->info << "Received subsribe ok to unknown subscribe track"
+                        _logger->warning << "Received subsribe ok to unknown subscribe track"
                                       << " subscribe_id: " << msg.subscribe_id
                                       << " , ignored"
                                       << std::flush;
@@ -383,6 +380,22 @@ namespace quicr {
 
                     sub_it->second.get()->cb_readReady();
 
+                    // For mirroring, update self publish track for same namespace/track that it can send
+                    auto tfn = TrackFullName{ sub_it->second->getTrackNamespace(), sub_it->second->getTrackName() };
+                    auto th = TrackHash(tfn);
+
+                    auto pub_track = getPubTrackDelegate(conn_ctx, th);
+                    if (pub_track.has_value()) {
+                        if (conn_ctx._sub_id <= msg.subscribe_id) {
+                            conn_ctx._sub_id = msg.subscribe_id  + 1;
+                        }
+
+                        pub_track->lock()->setSubscribeId(msg.subscribe_id);
+                        pub_track->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
+                        pub_track->lock()->cb_sendReady();
+                    }
+
+
                     stream_buffer->resetAny();
                     return true;
                 }
@@ -438,8 +451,7 @@ namespace quicr {
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
                     for (const auto& td: pub_it->second) {
-                        td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
-                        td.second.get()->cb_sendReady();
+                        td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
                     }
 
                     stream_buffer->resetAny();
@@ -544,9 +556,52 @@ namespace quicr {
                 }
                 break;
             }
+
+            default:
+                _logger->error << "Unsupported MOQT message "
+                               << "type: " << static_cast<uint64_t>(*conn_ctx.ctrl_msg_type_received)
+                               << std::flush;
+                close_connection(conn_ctx.conn_id,
+                                 MoQTerminationReason::PROTOCOL_VIOLATION,
+                                 "Unsupported MOQT message type");
+                return true;
+
+        } // End of switch(msg type)
+
+        _logger->debug << " type: " << static_cast<int>(*conn_ctx.ctrl_msg_type_received)
+                      << " sbuf_size: " << stream_buffer->size()
+                      << std::flush;
+        return false;
+    }
+
+    bool MoQInstance::process_recv_data_message(ConnectionContext& conn_ctx,
+                                                std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer)
+    {
+        if (stream_buffer->size() == 0) { // should never happen
+            close_connection(conn_ctx.conn_id,
+                             MoQTerminationReason::INTERNAL_ERROR,
+                             "Stream buffer cannot be zero when parsing message type");
+        }
+
+        // Header not set, get the header type
+        MoQMessageType data_type;
+        if (!stream_buffer->anyHasValue()) {
+            auto val = stream_buffer->decode_uintV();
+            if (val) {
+                data_type = static_cast<MoQMessageType>(*val);
+            } else {
+                return false;
+            }
+        }
+
+        switch (data_type) {
+            case MoQMessageType::OBJECT_DATAGRAM:
+                break;
+            case MoQMessageType::OBJECT_STREAM:
+                break;
             case MoQMessageType::STREAM_HEADER_TRACK:
                 break;
-            case MoQMessageType::STREAM_HEADER_GROUP:
+            case MoQMessageType::STREAM_HEADER_GROUP: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received stream header group, init stream buffer" << std::flush;
                     stream_buffer->initAny<MoqStreamHeaderGroup>();
@@ -554,51 +609,45 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqStreamHeaderGroup>();
                 if (*stream_buffer >> msg) {
-                    if (_client_mode) {
-                            auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
-                            if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
-                                _logger->info << "Received stream_header_group to unknown subscribe track"
-                                          << " subscribe_id: " << msg.subscribe_id
-                                          << " , ignored"
-                                          << std::flush;
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received stream_header_group to unknown subscribe track"
+                                  << " subscribe_id: " << msg.subscribe_id
+                                  << " , ignored"
+                                  << std::flush;
 
-                                stream_buffer->resetAny();
-                                return true;
-                            }
-
-                            stream_buffer->resetAny();
-                            // let's get the full object payload
-                            stream_buffer->initAny<MoqStreamGroupObject>();
-                            auto& obj = stream_buffer->getAny<MoqStreamGroupObject>();
-                            if (*stream_buffer >> obj) {
-                                sub_it->second->cb_objectReceived(msg.group_id, obj.object_id, std::move(obj.payload));
-                            }
-                            stream_buffer->resetAny();
-                            return true;
-                    } else {
-                            //TODO: refactor this into its own function
-                            stream_buffer->resetAny();
-                            // let's get the full object payload
-                            stream_buffer->initAny<MoqStreamGroupObject>();
-                            auto& obj = stream_buffer->getAny<MoqStreamGroupObject>();
-                            if (*stream_buffer >> obj) {
-                                _delegate->cb_object_received(conn_ctx.conn_id,
-                                                              msg.subscribe_id,
-                                                              msg.track_alias,
-                                                              msg.group_id,
-                                                              obj.object_id,
-                                                              std::move(obj.payload));
-                            }
-                            stream_buffer->resetAny();
-                            return true;
+                        // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                        stream_buffer->resetAny();
+                        return true;
                     }
 
-                }
+                    sub_it->second->_mi_stream_header_received = true;
+                    _logger->warning << "Received stream_header_group "
+                              << " subscribe_id: " << msg.subscribe_id
+                              << " priority: " << msg.priority
+                              << " track_alais: " << msg.track_alias
+                              << " group_id: " << msg.group_id
+                              << std::flush;
 
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
-        }
+            }
 
-        _logger->debug << " type: " << static_cast<int>(*conn_ctx.msg_type_received)
+            default:
+                _logger->error << "Unsupported MOQT data message "
+                               << "type: " << static_cast<uint64_t>(*conn_ctx.ctrl_msg_type_received)
+                               << std::flush;
+                close_connection(conn_ctx.conn_id,
+                                 MoQTerminationReason::PROTOCOL_VIOLATION,
+                                 "Unsupported MOQT data message type");
+                return true;
+
+        } // End of switch(msg type)
+
+        _logger->debug << " type: " << static_cast<int>(*conn_ctx.ctrl_msg_type_received)
                       << " sbuf_size: " << stream_buffer->size()
                       << std::flush;
         return false;
@@ -644,6 +693,7 @@ namespace quicr {
                                                             uint64_t subscribe_id,
                                                             std::shared_ptr<MoQTrackDelegate> track_delegate) {
 
+
         // Generate track alias
         auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
 
@@ -667,6 +717,22 @@ namespace quicr {
 
         track_delegate->setSubscribeId(subscribe_id);
 
+        track_delegate->_mi_conn_id = conn_id;
+
+        track_delegate->_mi_send_data_ctx_id = _transport->createDataContext(
+          conn_id,
+          track_delegate->_mi_track_mode == MoQTrackDelegate::TrackMode::DATAGRAM ? false : true,
+          track_delegate->_def_priority,
+          false);
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        Name n;
+        n += th.track_fullname_hash;
+
+        _mexport.set_data_ctx_info(conn_id, track_delegate->_mi_send_data_ctx_id,
+                                   {.subscribe = false, .nspace = {n, 64} } );
+#endif
+
         return th.track_fullname_hash;
     }
 
@@ -714,9 +780,152 @@ namespace quicr {
         // Set the track delegate for pub/sub
         conn_it->second.pub_tracks_by_name[th.track_namespace_hash][th.track_name_hash] = track_delegate;
 
+        track_delegate->_mi_conn_id = conn_id;
+        track_delegate->_mi_send_data_ctx_id = _transport->createDataContext(
+          conn_id,
+          track_delegate->_mi_track_mode == MoQTrackDelegate::TrackMode::DATAGRAM ? false : true,
+          track_delegate->_def_priority,
+          false);
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+        Name n;
+        n += th.track_fullname_hash;
+
+        _mexport.set_data_ctx_info(conn_id, track_delegate->_mi_send_data_ctx_id,
+                                   {.subscribe = false, .nspace = {n, 64} } );
+#endif
+
+
+        // Setup the function for the track delegate to use to send objects with thread safety
+        track_delegate->_mi_sendObjFunc =
+          [&,
+           track_delegate = track_delegate,
+           subscribe_id = track_delegate->getSubscribeId()](uint8_t priority,
+                                                            uint32_t ttl,
+                                                            bool stream_header_needed,
+                                                            uint64_t group_id,
+                                                            uint64_t object_id,
+                                                            bytes&& data) -> MoQTrackDelegate::SendError {
+            return send_object(track_delegate,
+                               priority,
+                               ttl,
+                               stream_header_needed,
+                               group_id,
+                               object_id,
+                               std::move(data));
+        };
+
         return th.track_fullname_hash;
     }
 
+    MoQTrackDelegate::SendError MoQInstance::send_object(std::weak_ptr<MoQTrackDelegate> track_delegate,
+                                                         uint8_t priority,
+                                                         uint32_t ttl,
+                                                         bool stream_header_needed,
+                                                         uint64_t group_id,
+                                                         uint64_t object_id,
+                                                         bytes&& data)
+    {
+
+        auto td = track_delegate.lock();
+
+        if (!td->getTrackAlias().has_value()) {
+            return MoQTrackDelegate::SendError::NOT_ANNOUNCED;
+        }
+
+        if (!td->getSubscribeId().has_value()) {
+            return MoQTrackDelegate::SendError::NO_SUBSCRIBERS;
+        }
+
+        ITransport::EnqueueFlags eflags;
+
+        StreamBuffer<uint8_t> buffer;
+
+        switch(td->_mi_track_mode) {
+            case MoQTrackDelegate::TrackMode::DATAGRAM: {
+                MoqObjectDatagram object;
+                object.group_id = group_id;
+                object.object_id = object_id;
+                object.priority = priority;
+                object.subscribe_id = *td->getSubscribeId();
+                object.track_alias = *td->getTrackAlias();
+                object.payload = std::move(data);
+                buffer << object;
+                break;
+            }
+            case MoQTrackDelegate::TrackMode::STREAM_PER_OBJECT: {
+                eflags.use_reliable = true;
+                eflags.new_stream = true;
+
+                MoqObjectStream object;
+                object.group_id = group_id;
+                object.object_id = object_id;
+                object.priority = priority;
+                object.subscribe_id = *td->getSubscribeId();
+                object.track_alias = *td->getTrackAlias();
+                object.payload = std::move(data);
+                buffer << object;
+
+                break;
+            }
+
+            case MoQTrackDelegate::TrackMode::STREAM_PER_GROUP: {
+                eflags.use_reliable = true;
+
+                if (stream_header_needed) {
+                    eflags.new_stream = true;
+                    eflags.clear_tx_queue = true;
+                    eflags.use_reset = true;
+
+                    MoqStreamHeaderGroup group_hdr;
+                    group_hdr.group_id = group_id;
+                    group_hdr.priority = priority;
+                    group_hdr.subscribe_id = *td->getSubscribeId();
+                    group_hdr.track_alias = *td->getTrackAlias();
+                    buffer << group_hdr;
+                }
+
+                MoqStreamGroupObject object;
+                object.object_id = object_id;
+                object.payload = std::move(data);
+                buffer << object;
+
+                break;
+            }
+            case MoQTrackDelegate::TrackMode::STREAM_PER_TRACK: {
+                eflags.use_reliable = true;
+
+                if (stream_header_needed) {
+                    eflags.new_stream = true;
+
+                    MoqStreamHeaderTrack track_hdr;
+                    track_hdr.priority = priority;
+                    track_hdr.subscribe_id = *td->getSubscribeId();
+                    track_hdr.track_alias = *td->getTrackAlias();
+                    buffer << track_hdr;
+                }
+
+                MoqStreamTrackObject object;
+                object.group_id = group_id;
+                object.object_id = object_id;
+                object.payload = std::move(data);
+                buffer << object;
+
+                break;
+            }
+        }
+
+        // TODO(tievens): Add M10x specific chunking... lacking in the draft
+        std::vector<uint8_t> serialized_data = buffer.front(buffer.size());
+
+        _transport->enqueue(td->_mi_conn_id, td->_mi_send_data_ctx_id, std::move(serialized_data),
+                    { MethodTraceItem{} }, priority,
+                    ttl, 0, eflags);
+
+        return MoQTrackDelegate::SendError::OK;
+    }
+
+
     std::optional<std::weak_ptr<MoQTrackDelegate>> MoQInstance::getPubTrackDelegate(ConnectionContext& conn_ctx,
                                                                                     TrackHash& th)
     {
@@ -793,22 +1002,38 @@ namespace quicr {
             conn_ctx.ctrl_data_ctx_id = data_ctx_id;
         }
 
-        while (stream_buf->size()) {
-            if (not conn_ctx.msg_type_received) {
-                auto msg_type = stream_buf->decode_uintV();
+        for (int i=0; i < 60; i++) { // don't loop forever, especially on bad stream
+            // bidir is Control stream, data streams are unidirectional
+            if (is_bidir) {
+                if (not conn_ctx.ctrl_msg_type_received) {
+                    auto msg_type = stream_buf->decode_uintV();
 
-                if (msg_type) {
-                    conn_ctx.msg_type_received = static_cast<MoQMessageType>(*msg_type);
-                } else {
-                    break;
+                    if (msg_type) {
+                        conn_ctx.ctrl_msg_type_received = static_cast<MoQMessageType>(*msg_type);
+                    } else {
+                        break;
+                    }
+                }
+
+                if (conn_ctx.ctrl_msg_type_received) {
+                    if (process_recv_ctrl_message(conn_ctx, stream_buf)) {
+                        conn_ctx.ctrl_msg_type_received = std::nullopt;
+                        break;
+                    }
                 }
             }
 
-            if (conn_ctx.msg_type_received) {
-                if (process_recv_message(conn_ctx, stream_buf)) {
-                    conn_ctx.msg_type_received = std::nullopt;
+            // Data stream, unidirectional
+            else {
+                if (process_recv_data_message(conn_ctx, stream_buf)) {
+                    break;
                 }
             }
+
+
+            if (!stream_buf->size()) { // done
+                break;
+            }
         }
     }
 
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
index 16eade62..ac1d4f49 100644
--- a/src/moq_track_delegate_base.cpp
+++ b/src/moq_track_delegate_base.cpp
@@ -9,11 +9,12 @@
 
 namespace quicr {
 
+
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
                                                              [[maybe_unused]] const uint64_t object_id,
                                                              [[maybe_unused]] const std::span<const uint8_t>& object)
     {
-        return MoQTrackDelegate::SendError::OK;
+        return sendObject(group_id, object_id, std::move(object), _def_priority, _def_ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -21,7 +22,7 @@ namespace quicr {
                                                              [[maybe_unused]] const std::span<const uint8_t>& object,
                                                              [[maybe_unused]] uint32_t ttl)
     {
-        return MoQTrackDelegate::SendError::OK;
+        return sendObject(group_id, object_id, std::move(object), _def_priority, ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -29,7 +30,8 @@ namespace quicr {
                                                              [[maybe_unused]] const std::span<const uint8_t>& object,
                                                              [[maybe_unused]] uint8_t priority)
     {
-        return MoQTrackDelegate::SendError::OK;
+
+        return sendObject(group_id, object_id, std::move(object), priority, _def_ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -38,12 +40,30 @@ namespace quicr {
                                                              [[maybe_unused]] uint8_t priority,
                                                              [[maybe_unused]] uint32_t ttl)
     {
-        return MoQTrackDelegate::SendError::OK;
-    }
+        std::vector<uint8_t> data_copy(object.begin(), object.end());
 
-    MoQTrackDelegate::ReadError MoQTrackDelegate::readObject([[maybe_unused]] std::vector<const uint8_t>& object)
-    {
-        return MoQTrackDelegate::ReadError::NO_DATA;
+        bool is_stream_header_needed { false };
+        switch (_mi_track_mode) {
+            case TrackMode::DATAGRAM:
+                break;
+            case TrackMode::STREAM_PER_GROUP:
+                is_stream_header_needed = _prev_group_id != group_id;
+            break;
+            case TrackMode::STREAM_PER_OBJECT:
+                is_stream_header_needed = true;
+            break;
+            case TrackMode::STREAM_PER_TRACK:
+                if (not _sent_track_header) {
+                    is_stream_header_needed = true;
+                    _sent_track_header = true;
+                }
+            break;
+        }
+
+        _prev_group_id = group_id;
+
+        return _mi_sendObjFunc(
+          priority, ttl, is_stream_header_needed, group_id, object_id, std::move(data_copy));
     }
 
 

From c80254f1791a83a69cf8ab81bfacf364bef04a4c Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 20 Jun 2024 08:30:00 -0700
Subject: [PATCH 47/71] MOQT fixes and add object processing

* Fixes subscribe flow to announcer
* Initial add of object flow handling
---
 cmd/moq-example/server.cpp         | 43 ++++++++++++++-
 dependencies/transport             |  2 +-
 include/quicr/moq_track_delegate.h |  2 +-
 src/moq_instance.cpp               | 84 ++++++++++++++++++++++--------
 4 files changed, 105 insertions(+), 26 deletions(-)

diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index adac2288..729cf615 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -3,6 +3,7 @@
 
 #include <cantina/logger.h>
 #include <unordered_map>
+#include <set>
 #include <condition_variable>
 #include <csignal>
 #include <oss/cxxopts.hpp>
@@ -10,6 +11,13 @@
 #include "subscription.h"
 
 namespace qserver_vars {
+
+    /*
+     * Map/state of announcements
+     *      track_alias_set = announce_state[track_namespace][conn_id]
+     */
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::set<uint64_t>>> announce_state;
+
     /*
      * Active subscribes for a given track, indexed (keyed) by track_alias,conn_id
      *     NOTE: This indexing intentionally prohibits per connection having more
@@ -19,6 +27,13 @@ namespace qserver_vars {
      */
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> subscribes;
 
+    /*
+     * Active publisher/announce subscribes that this relay has made to receive objects from publisher.
+     *
+     * track_delegate = pub_subscribes[track_alias][conn_id]
+     */
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> pub_subscribes;
+
 }
 
 class subTrackDelegate : public quicr::MoQTrackDelegate
@@ -76,7 +91,10 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                        << "  for namespace_hash: " << track_namespace_hash
                        << std::flush;
 
-        // Send announce OK
+        // Add to state if not exist
+        qserver_vars::announce_state[track_namespace_hash].try_emplace(conn_id);
+
+        // true results in Send announce OK
         return true;
     }
 
@@ -116,6 +134,29 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         // Create a subscribe track that will be used by the relay to send to subscriber for matching objects
         _moq_instance.lock()->bindSubscribeTrack(conn_id, subscribe_id, track_delegate);
 
+        //TODO: Create subscribe to announcer if new track
+        auto anno_ns_it = qserver_vars::announce_state.find(th.track_namespace_hash);
+        if (anno_ns_it == qserver_vars::announce_state.end()) {
+            _logger->info << "Subscribe to track namespace: " << t_namespace
+                          <<  ", does not have any announcements." << std::flush;
+            // TODO(tievens): Handle creating subscribe to announcer when subscribe is present
+            return true;
+        }
+
+        for (auto& [conn_id, tracks]: anno_ns_it->second) {
+            if (!tracks.contains(th.track_name_hash)) {
+                _logger->info << "Sending subscribe to announcer conn_id: " << conn_id
+                              << " subscribe track_alias: " << th.track_name_hash
+                              << std::flush;
+
+                tracks.insert(th.track_name_hash); // Add track alais to state
+
+                auto pub_track_delegate = std::make_shared<subTrackDelegate>(t_namespace, t_name, 2, 3000, _logger);
+                _moq_instance.lock()->subscribeTrack(conn_id, pub_track_delegate);
+                qserver_vars::pub_subscribes[th.track_fullname_hash][conn_id] = pub_track_delegate;
+            }
+        }
+
         return true;
     }
 
diff --git a/dependencies/transport b/dependencies/transport
index 645e036f..eac92244 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 645e036fc4a0ac506829899641c6b102a1211121
+Subproject commit eac922445d692305c689d376f0fb2f17103a14d1
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 6f30dc54..8b97ddf2 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -287,7 +287,7 @@ namespace quicr {
         uint64_t _mi_send_data_ctx_id;    // Set by moq instance
         uint64_t _mi_conn_id;             // Set by moq instance
         TrackMode _mi_track_mode;         // Set by moq instance
-        bool _mi_stream_header_received { false }; // True if stream header is complete, false if pending
+
 
         uint8_t _def_priority;            // Set by caller and is used when priority is not specified
         uint32_t _def_ttl;                // Set by caller and is used when TTL is not specified
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index b002bce5..f3c56b22 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -313,6 +313,10 @@ namespace quicr {
                     auto tfn = TrackFullName{ msg.track_namespace, msg.track_name };
                     auto th = TrackHash(tfn);
 
+                    if (msg.subscribe_id > conn_ctx._sub_id) {
+                        conn_ctx._sub_id = msg.subscribe_id+1;
+                    }
+
                     // For client/publisher, notify track that there is a subscriber
                     if (_client_mode) {
                         auto ptd = getPubTrackDelegate(conn_ctx, th);
@@ -330,19 +334,18 @@ namespace quicr {
                             return true;
                         }
 
-                        // TODO(tievens): Set content exists
                         send_subscribe_ok(conn_ctx, msg.subscribe_id, MOQT_SUBSCRIBE_EXPIRES, false);
 
+                        _logger->debug << "Received subscribe to announced track alias: " << msg.track_alias
+                                       << ", setting send state to ready" << std::flush;
+
                         // Indicate send is ready upon subscribe
                         // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
+                        ptd->lock()->setSubscribeId(msg.subscribe_id);
                         ptd->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
                         ptd->lock()->cb_sendReady();
 
                     } else { // Server mode
-                        if (msg.subscribe_id > conn_ctx._sub_id) {
-                            conn_ctx._sub_id = msg.subscribe_id+1;
-                        }
-
                         // TODO(tievens): add filter type when caching supports it
                         if (_delegate->cb_subscribe(conn_ctx.conn_id,
                                                     msg.subscribe_id,
@@ -380,6 +383,7 @@ namespace quicr {
 
                     sub_it->second.get()->cb_readReady();
 
+                    /*
                     // For mirroring, update self publish track for same namespace/track that it can send
                     auto tfn = TrackFullName{ sub_it->second->getTrackNamespace(), sub_it->second->getTrackName() };
                     auto th = TrackHash(tfn);
@@ -394,7 +398,7 @@ namespace quicr {
                         pub_track->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
                         pub_track->lock()->cb_sendReady();
                     }
-
+                    */
 
                     stream_buffer->resetAny();
                     return true;
@@ -583,7 +587,7 @@ namespace quicr {
                              "Stream buffer cannot be zero when parsing message type");
         }
 
-        // Header not set, get the header type
+        // Header not set, get the header for this stream or datagram
         MoQMessageType data_type;
         if (!stream_buffer->anyHasValue()) {
             auto val = stream_buffer->decode_uintV();
@@ -592,6 +596,15 @@ namespace quicr {
             } else {
                 return false;
             }
+        } else {
+            auto dt = stream_buffer->getAnyType();
+            if (dt.has_value()) {
+                data_type = static_cast<MoQMessageType>(*dt);
+            }
+            else {
+                _logger->warning << "Unknown data type for data stream" << std::flush;
+                return true;
+            }
         }
 
         switch (data_type) {
@@ -604,11 +617,11 @@ namespace quicr {
             case MoQMessageType::STREAM_HEADER_GROUP: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received stream header group, init stream buffer" << std::flush;
-                    stream_buffer->initAny<MoqStreamHeaderGroup>();
+                    stream_buffer->initAny<MoqStreamHeaderGroup>(static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_GROUP));
                 }
 
                 auto& msg = stream_buffer->getAny<MoqStreamHeaderGroup>();
-                if (*stream_buffer >> msg) {
+                if (!stream_buffer->anyHasValueB() && *stream_buffer >> msg) {
                     auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
                         _logger->warning << "Received stream_header_group to unknown subscribe track"
@@ -618,25 +631,53 @@ namespace quicr {
 
                         // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
 
-                        stream_buffer->resetAny();
                         return true;
                     }
 
-                    sub_it->second->_mi_stream_header_received = true;
-                    _logger->warning << "Received stream_header_group "
-                              << " subscribe_id: " << msg.subscribe_id
-                              << " priority: " << msg.priority
-                              << " track_alais: " << msg.track_alias
-                              << " group_id: " << msg.group_id
-                              << std::flush;
+                    // Init second working buffer to read data object
+                    stream_buffer->initAnyB<MoqStreamGroupObject>();
 
-                    stream_buffer->resetAny();
-                    return true;
+                    _logger->debug << "Received stream_header_group "
+                                   << " subscribe_id: " << msg.subscribe_id
+                                   << " priority: " << msg.priority
+                                   << " track_alais: " << msg.track_alias
+                                   << " group_id: " << msg.group_id
+                                   << std::flush;
+                }
+
+                if (stream_buffer->anyHasValueB()) {
+                    MoqStreamGroupObject obj;
+                    if (*stream_buffer >> obj) {
+                        auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                        if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                            _logger->warning << "Received stream_header_group to unknown subscribe track"
+                                      << " subscribe_id: " << msg.subscribe_id
+                                      << " , ignored"
+                                      << std::flush;
+
+                            // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                            return true;
+                        }
+
+                        _logger->debug << "Received stream_group_object "
+                                       << " subscribe_id: " << msg.subscribe_id
+                                       << " priority: " << msg.priority
+                                       << " track_alais: " << msg.track_alias
+                                       << " group_id: " << msg.group_id
+                                       << " object_id: " << obj.object_id
+                                       << " data size: " << obj.payload.size()
+                                       << std::flush;
+                        stream_buffer->resetAnyB();
+                    }
                 }
+
                 break;
             }
 
             default:
+                // Process the stream object type
+
                 _logger->error << "Unsupported MOQT data message "
                                << "type: " << static_cast<uint64_t>(*conn_ctx.ctrl_msg_type_received)
                                << std::flush;
@@ -645,11 +686,8 @@ namespace quicr {
                                  "Unsupported MOQT data message type");
                 return true;
 
-        } // End of switch(msg type)
+        }
 
-        _logger->debug << " type: " << static_cast<int>(*conn_ctx.ctrl_msg_type_received)
-                      << " sbuf_size: " << stream_buffer->size()
-                      << std::flush;
         return false;
     }
 

From a18457a8dba5681186ae0f430757125b2b1e0048 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 20 Jun 2024 09:36:12 -0700
Subject: [PATCH 48/71] Relay objects received to subscribes and print/log
 received

---
 cmd/moq-example/client.cpp            |  6 ++++-
 cmd/moq-example/server.cpp            | 37 ++++++++-------------------
 include/quicr/moq_instance_delegate.h | 17 ------------
 src/moq_instance.cpp                  | 22 ++++++++++++++++
 src/moq_track_delegate_base.cpp       | 21 ++++++++-------
 5 files changed, 50 insertions(+), 53 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 082a6bb0..c5aae160 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -28,7 +28,11 @@ class trackDelegate : public quicr::MoQTrackDelegate
     {
     }
 
-    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {}
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {
+        std::string msg(object.begin(), object.end());
+
+        _logger->info << "Received message: " << msg << std::flush;
+    }
     void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
 
     void cb_sendReady() override {
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 729cf615..617d6c3b 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -53,7 +53,17 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
     {
     }
 
-    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {}
+    // TODO: Add prioirty and TTL
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {
+
+        for (const auto& [conn_id, td]: qserver_vars::subscribes.find(*_track_alias)->second) {
+            _logger->debug << "Relaying track_alias: " << *_track_alias
+                           << ", object to subscribe conn_id: " << conn_id
+                           << " data size: " << object.size() << std::flush;
+
+            td->sendObject(group_id, object_id, object);
+        }
+    }
     void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
 
     void cb_sendReady() override {
@@ -160,31 +170,6 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         return true;
     }
 
-    void cb_objectReceived(qtransport::TransportConnId conn_id,
-                           uint64_t subscribe_id,
-                           uint64_t track_alias,
-                           uint64_t group_id,
-                           uint64_t object_id,
-                           std::vector<uint8_t>&& data)
-    {
-        _logger->info << "Recieved object conn_id: " << conn_id
-                      << " subscribe_id: " << subscribe_id
-                      << " track_alias: " << track_alias
-                      << " group_id: " << group_id
-                      << " object_id: " << object_id
-                      << " data size: " << data.size()
-                      << std::flush;
-
-        // Relay to all subscribes
-        auto sub_it = qserver_vars::subscribes.find(track_alias);
-        for (auto& [conn_id, track_delegate]: sub_it->second) {
-            _logger->info << "Sending to conn_id: " << conn_id
-                          << " subscribe_id: " << *track_delegate->getSubscribeId()
-                          << std::flush;
-            track_delegate->sendObject(group_id, object_id, data);
-        }
-    }
-
   private:
     cantina::LoggerPointer _logger;
     std::weak_ptr<quicr::MoQInstance> _moq_instance;
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 08cbef4c..0b44e94f 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -95,23 +95,6 @@ namespace quicr {
             return true;
         }
 
-        /**
-         * @brief Server Mode; Callback notification on new object received to be relayed
-         *
-         * @param conn_id              Source connection Id
-         * @param subscribe_id         Subscribe ID received
-         * @param track_alias          Track alias received
-         * @param group_id             Group ID received
-         * @param object_id            Object ID received
-         * @param data                 Data received
-         */
-        virtual void cb_objectReceived([[maybe_unused]] TransportConnId conn_id,
-                                       [[maybe_unused]] uint64_t subscribe_id,
-                                       [[maybe_unused]] uint64_t track_alias,
-                                       [[maybe_unused]] uint64_t group_id,
-                                       [[maybe_unused]] uint64_t object_id,
-                                       [[maybe_unused]] std::vector<uint8_t>&& data) {}
-
     };
 
 } // namespace quicr
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index f3c56b22..9a2423ee 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -669,6 +669,8 @@ namespace quicr {
                                        << " data size: " << obj.payload.size()
                                        << std::flush;
                         stream_buffer->resetAnyB();
+
+                        sub_it->second->cb_objectReceived(msg.group_id, obj.object_id, std::move(obj.payload));
                     }
                 }
 
@@ -771,6 +773,26 @@ namespace quicr {
                                    {.subscribe = false, .nspace = {n, 64} } );
 #endif
 
+        // Setup the function for the track delegate to use to send objects with thread safety
+        track_delegate->_mi_sendObjFunc =
+          [&,
+           track_delegate = track_delegate,
+           subscribe_id = track_delegate->getSubscribeId()](uint8_t priority,
+                                                                        uint32_t ttl,
+                                                                        bool stream_header_needed,
+                                                                        uint64_t group_id,
+                                                                        uint64_t object_id,
+                                                                        bytes&& data) -> MoQTrackDelegate::SendError {
+            return send_object(track_delegate,
+                               priority,
+                               ttl,
+                               stream_header_needed,
+                               group_id,
+                               object_id,
+                               std::move(data));
+        };
+
+
         return th.track_fullname_hash;
     }
 
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
index ac1d4f49..285bd21b 100644
--- a/src/moq_track_delegate_base.cpp
+++ b/src/moq_track_delegate_base.cpp
@@ -14,7 +14,7 @@ namespace quicr {
                                                              [[maybe_unused]] const uint64_t object_id,
                                                              [[maybe_unused]] const std::span<const uint8_t>& object)
     {
-        return sendObject(group_id, object_id, std::move(object), _def_priority, _def_ttl);
+        return sendObject(group_id, object_id, object, _def_priority, _def_ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -22,7 +22,7 @@ namespace quicr {
                                                              [[maybe_unused]] const std::span<const uint8_t>& object,
                                                              [[maybe_unused]] uint32_t ttl)
     {
-        return sendObject(group_id, object_id, std::move(object), _def_priority, ttl);
+        return sendObject(group_id, object_id, object, _def_priority, ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -31,7 +31,7 @@ namespace quicr {
                                                              [[maybe_unused]] uint8_t priority)
     {
 
-        return sendObject(group_id, object_id, std::move(object), priority, _def_ttl);
+        return sendObject(group_id, object_id, object, priority, _def_ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
@@ -42,28 +42,31 @@ namespace quicr {
     {
         std::vector<uint8_t> data_copy(object.begin(), object.end());
 
-        bool is_stream_header_needed { false };
+        bool is_stream_header_needed{ false };
         switch (_mi_track_mode) {
             case TrackMode::DATAGRAM:
                 break;
             case TrackMode::STREAM_PER_GROUP:
                 is_stream_header_needed = _prev_group_id != group_id;
-            break;
+                break;
             case TrackMode::STREAM_PER_OBJECT:
                 is_stream_header_needed = true;
-            break;
+                break;
             case TrackMode::STREAM_PER_TRACK:
                 if (not _sent_track_header) {
                     is_stream_header_needed = true;
                     _sent_track_header = true;
                 }
-            break;
+                break;
         }
 
         _prev_group_id = group_id;
 
-        return _mi_sendObjFunc(
-          priority, ttl, is_stream_header_needed, group_id, object_id, std::move(data_copy));
+        if (_mi_sendObjFunc != nullptr) {
+            return _mi_sendObjFunc(priority, ttl, is_stream_header_needed, group_id, object_id, std::move(data_copy));
+        } else {
+            return SendError::INTERNAL_ERROR;
+        }
     }
 
 

From 7b1957bd41cc59e52495f2bf8817aed23ea12ffc Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 20 Jun 2024 14:51:21 -0700
Subject: [PATCH 49/71] add clock

---
 cmd/moq-example/CMakeLists.txt   |  2 +-
 cmd/moq-example/client.cpp       | 43 +++++++++++++++++++---
 cmd/moq-example/server.cpp       |  2 -
 cmd/moq-example/subscription.cpp | 63 --------------------------------
 cmd/moq-example/subscription.h   | 46 -----------------------
 src/moq_instance.cpp             |  2 +-
 6 files changed, 39 insertions(+), 119 deletions(-)
 delete mode 100644 cmd/moq-example/subscription.cpp
 delete mode 100644 cmd/moq-example/subscription.h

diff --git a/cmd/moq-example/CMakeLists.txt b/cmd/moq-example/CMakeLists.txt
index 7e3457b6..006e1ea6 100644
--- a/cmd/moq-example/CMakeLists.txt
+++ b/cmd/moq-example/CMakeLists.txt
@@ -1,7 +1,7 @@
 
 add_executable(qserver
         server.cpp
-        subscription.cpp)
+)
 target_link_libraries(qserver PRIVATE quicr)
 
 if(NOT LIBQUICR_WITHOUT_INFLUXDB)
diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index c5aae160..6b505784 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -4,10 +4,14 @@
 #include "signal_handler.h"
 
 #include <iostream>
+#include <chrono>
+#include <format>
 #include <oss/cxxopts.hpp>
 
 namespace qclient_vars {
     std::optional<qtransport::TransportConnId> conn_id;
+
+    bool publish_clock {false};
 }
 
 
@@ -111,14 +115,29 @@ void do_publisher(const std::string t_namespace,
 
         if (!sending) {
             _logger->info << "--------------------------------------------------------------------------" << std::flush;
-            _logger->info << " Type message and press enter to send" << std::flush;
+
+            if (qclient_vars::publish_clock) {
+                _logger->info << " Publishing clock timestamp every second" << std::flush;
+            } else {
+                _logger->info << " Type message and press enter to send" << std::flush;
+            }
+
             _logger->info << "--------------------------------------------------------------------------" << std::flush;
             sending = true;
         }
 
         std::string msg;
-        getline(std::cin, msg);
-        _logger->info << "Send mesage: " << msg << std::flush;
+        if (qclient_vars::publish_clock) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(999));
+            std::stringstream ss;
+            auto tp = std::chrono::system_clock::now();
+            ss << "Time: " << std::format("{:%a %b %e %T %Y}",  std::chrono::time_point_cast<std::chrono::microseconds>(tp));
+            msg = ss.str();
+            _logger->info << msg << std::flush;
+        } else { // stdin
+            getline(std::cin, msg);
+            _logger->info << "Send message: " << msg << std::flush;
+        }
 
         if (object_id % 5 == 0) {       // Set new group
             object_id = 0;
@@ -127,7 +146,7 @@ void do_publisher(const std::string t_namespace,
 
         std::vector<uint8_t> msg_v(msg.begin(), msg.end());
         auto result = track_delegate->sendObject(group_id, object_id++, std::move(msg_v));
-        _logger->info << "send error: " << static_cast<int>(result) << std::flush;
+        _logger->debug << "send error: " << static_cast<int>(result) << std::flush;
     }
 
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
@@ -185,6 +204,12 @@ quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts,
                      << std::flush;
     }
 
+    if (cli_opts.count("clock") && cli_opts["clock"].as<bool>() == true) {
+        logger->info << "Running in clock publish mode" << std::flush;
+        qclient_vars::publish_clock = true;
+    }
+
+
     if (cli_opts.count("sub_namespace") && cli_opts.count("sub_name")) {
         enable_sub = true;
         logger->info << "Subscriber enabled using track"
@@ -193,6 +218,8 @@ quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts,
                      << std::flush;
     }
 
+
+
     config.endpoint_id = cli_opts["endpoint_id"].as<std::string>();
     config.server_host_ip = cli_opts["host"].as<std::string>();
     config.server_port = cli_opts["port"].as<uint16_t>();
@@ -231,6 +258,7 @@ main(int argc, char* argv[])
     options.add_options("Publisher")
       ("pub_namespace", "Track namespace", cxxopts::value<std::string>())
       ("pub_name", "Track name", cxxopts::value<std::string>())
+      ("clock", "Publish clock timestamp every second instead of using STDIN chat")
     ;
 
     options.add_options("Subscriber")
@@ -270,20 +298,21 @@ main(int argc, char* argv[])
             pub_thread = std::thread (do_publisher,
                                      result["pub_namespace"].as<std::string>(),
                                      result["pub_name"].as<std::string>(),
-                                     moqInstance, logger, stop_threads);
+                                     moqInstance, logger, std::ref(stop_threads));
         }
 
         if (enable_sub) {
             sub_thread = std::thread (do_subscriber,
                                       result["sub_namespace"].as<std::string>(),
                                       result["sub_name"].as<std::string>(),
-                                      moqInstance, logger, stop_threads);
+                                      moqInstance, logger, std::ref(stop_threads));
         }
 
         // Wait until told to terminate
         moq_example::cv.wait(lock, [&]() { return moq_example::terminate; });
 
         stop_threads = true;
+        logger->info << "Stopping threads..." << std::flush;
 
         if (pub_thread.joinable()) {
             pub_thread.join();
@@ -310,5 +339,7 @@ main(int argc, char* argv[])
         result_code = EXIT_FAILURE;
     }
 
+    logger->info << "Exit" << std::flush;
+
     return result_code;
 }
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 617d6c3b..ff4e3a4f 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -5,10 +5,8 @@
 #include <unordered_map>
 #include <set>
 #include <condition_variable>
-#include <csignal>
 #include <oss/cxxopts.hpp>
 #include "signal_handler.h"
-#include "subscription.h"
 
 namespace qserver_vars {
 
diff --git a/cmd/moq-example/subscription.cpp b/cmd/moq-example/subscription.cpp
deleted file mode 100644
index 80b782ef..00000000
--- a/cmd/moq-example/subscription.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "subscription.h"
-
-Subscriptions::Subscriptions()
-{
-  subscriptions.resize(129 /* 128 + 1 to handle zero and 128 */);
-}
-
-void
-Subscriptions::add(const quicr::Name& name, uint8_t len, const Remote& remote)
-{
-
-  const auto prefix = quicr::Namespace{ name, len };
-
-  auto mapPtr = subscriptions[len].find(prefix.name());
-  if (mapPtr == subscriptions[len].end()) {
-    std::set<Remote> list;
-    list.insert(remote);
-    std::pair<quicr::Name, std::set<Remote>> pair;
-    pair = make_pair(prefix.name(), list);
-    subscriptions[len].insert(pair);
-  } else {
-    auto& list = mapPtr->second;
-    if (list.find(remote) == list.end()) {
-      list.insert(
-        remote); // TODO(trigaux) - rethink if list is right thing here
-    }
-  }
-}
-
-void
-Subscriptions::remove(const quicr::Name& name,
-                      uint8_t len,
-                      const Remote& remote)
-{
-  const auto prefix = quicr::Namespace{ name, len };
-
-  auto mapPtr = subscriptions[len].find(prefix.name());
-  if (mapPtr != subscriptions[len].end()) {
-    auto& list = mapPtr->second;
-    if (list.find(remote) == list.end()) {
-      list.erase(remote);
-    }
-  }
-}
-
-std::list<Subscriptions::Remote>
-Subscriptions::find(const quicr::Name& name)
-{
-  std::list<Remote> all_remotes;
-
-  // TODO(trigaux): Fix this to not have to iterate for each mask bit
-  for (uint8_t len = 0; len <= 128; len++) {
-    const auto prefix = quicr::Namespace{ name, len };
-
-    auto mapPtr = subscriptions[len].find(prefix.name());
-    if (mapPtr != subscriptions[len].end()) {
-      const auto& list = mapPtr->second;
-      all_remotes.insert(all_remotes.end(), list.begin(), list.end());
-    }
-  }
-
-  return all_remotes;
-}
diff --git a/cmd/moq-example/subscription.h b/cmd/moq-example/subscription.h
deleted file mode 100644
index 7cc3dc32..00000000
--- a/cmd/moq-example/subscription.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <list>
-#include <map>
-#include <optional>
-#include <set>
-#include <vector>
-
-#include <qname>
-#include <transport/transport.h>
-
-class Subscriptions
-{
-public:
-  struct Remote
-  {
-    uint64_t subscribe_id {0};
-    uint64_t conn_id {0};           /// Connection ID is used only for detecting if subscription is to the same connection
-
-    bool operator==(const Remote& o) const
-    {
-      return subscribe_id == o.subscribe_id;
-    }
-
-    bool operator<(const Remote& o) const
-    {
-      return std::tie(subscribe_id) <
-             std::tie(o.subscribe_id);
-    }
-  };
-
-  Subscriptions();
-
-  void get_masked_quicRName(const quicr::Name& src,
-                            quicr::Name& dst,
-                            const int len);
-
-  void add(const quicr::Name& name, uint8_t len, const Remote& remote);
-
-  void remove(const quicr::Name& name, uint8_t len, const Remote& remote);
-
-  std::list<Remote> find(const quicr::Name& name);
-
-private:
-  std::vector<std::map<quicr::Name, std::set<Remote>>> subscriptions;
-};
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 9a2423ee..039ac1a2 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -1012,7 +1012,7 @@ namespace quicr {
                        << " status: " << static_cast<int>(status)
                        << std::flush;
 
-        if (_client_mode) {
+        if (_client_mode && status == TransportStatus::Ready) {
             auto& conn_ctx = _connections[conn_id];
             _logger->info << "Connection established, creating bi-dir stream and sending CLIENT_SETUP" << std::flush;
 

From 0c32ca4ed983e7f760314758805271ef41c14931 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 20 Jun 2024 15:52:58 -0700
Subject: [PATCH 50/71] Update transport

---
 dependencies/transport | 2 +-
 src/moq_instance.cpp   | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/dependencies/transport b/dependencies/transport
index eac92244..49385712 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit eac922445d692305c689d376f0fb2f17103a14d1
+Subproject commit 4938571264c4e07d796f552ceb5580e3fa7aee82
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 039ac1a2..9204255e 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -679,13 +679,14 @@ namespace quicr {
 
             default:
                 // Process the stream object type
-
+                /*
                 _logger->error << "Unsupported MOQT data message "
                                << "type: " << static_cast<uint64_t>(*conn_ctx.ctrl_msg_type_received)
                                << std::flush;
                 close_connection(conn_ctx.conn_id,
                                  MoQTerminationReason::PROTOCOL_VIOLATION,
                                  "Unsupported MOQT data message type");
+                 */
                 return true;
 
         }

From 8885e908fa184a12edd8c41f2f8495c54e6651f2 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 10:15:45 -0700
Subject: [PATCH 51/71] Fix build error

---
 include/quicr/moq_messages.h | 4 +++-
 src/moq_messages.cpp         | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 00ba650a..82ff3183 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -80,7 +80,6 @@ enum ForwardingPreference : uint8_t {
   Datagram
 };
 
-
 //
 // Parameters
 //
@@ -104,6 +103,9 @@ struct MoqParameter {
   uint64_t current_pos {0};
 };
 
+MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &param);
+MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param);
+
 //
 // Setup
 //
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index e077008a..ee4080e0 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -7,7 +7,7 @@ namespace quicr::messages {
 //
 // Utility
 //
-bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& field) {
+static bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& field) {
   auto val = buffer.decode_uintV();
   if (!val) {
     return false;
@@ -17,7 +17,7 @@ bool parse_uintV_field(qtransport::StreamBuffer<uint8_t> &buffer, uint64_t& fiel
 }
 
 
-bool parse_bytes_field(qtransport::StreamBuffer<uint8_t> &buffer, quicr::bytes& field) {
+static bool parse_bytes_field(qtransport::StreamBuffer<uint8_t> &buffer, quicr::bytes& field) {
   auto val = buffer.decode_bytes();
   if (!val) {
     return false;

From 829918f88266342065d89c8b39f714932987f343 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 10:50:31 -0700
Subject: [PATCH 52/71] Remove std::format

---
 cmd/moq-example/client.cpp | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 6b505784..6f9a7f21 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -5,7 +5,6 @@
 
 #include <iostream>
 #include <chrono>
-#include <format>
 #include <oss/cxxopts.hpp>
 
 namespace qclient_vars {
@@ -14,6 +13,23 @@ namespace qclient_vars {
     bool publish_clock {false};
 }
 
+std::string get_time_str()
+{
+    std::ostringstream oss;
+
+    auto now = std::chrono::system_clock::now();
+    auto now_us = std::chrono::time_point_cast<std::chrono::microseconds>(now);
+    std::time_t t = std::chrono::system_clock::to_time_t(now);
+    struct tm tm_result{};
+    localtime_r(&t, &tm_result);
+    oss << std::put_time(&tm_result, "%F %T")
+        << "."
+        << std::setfill('0')
+        << std::setw(6)
+        << (now_us.time_since_epoch().count()) % 1'000'000;
+
+    return oss.str();
+}
 
 class trackDelegate : public quicr::MoQTrackDelegate
 {
@@ -129,10 +145,7 @@ void do_publisher(const std::string t_namespace,
         std::string msg;
         if (qclient_vars::publish_clock) {
             std::this_thread::sleep_for(std::chrono::milliseconds(999));
-            std::stringstream ss;
-            auto tp = std::chrono::system_clock::now();
-            ss << "Time: " << std::format("{:%a %b %e %T %Y}",  std::chrono::time_point_cast<std::chrono::microseconds>(tp));
-            msg = ss.str();
+            msg = get_time_str();
             _logger->info << msg << std::flush;
         } else { // stdin
             getline(std::cin, msg);

From 57d9b5cd6f7b15ff260136fd91390bf1b0347e71 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 10:55:51 -0700
Subject: [PATCH 53/71] add missing header

---
 cmd/moq-example/client.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 6f9a7f21..edbba9b7 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -5,6 +5,7 @@
 
 #include <iostream>
 #include <chrono>
+#include <iomanip>
 #include <oss/cxxopts.hpp>
 
 namespace qclient_vars {

From 9cd60dfcee7ad984a2c98e7f923affca0157b229 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 13:26:15 -0700
Subject: [PATCH 54/71] Add handling for object datagram, object per stream and
 per track

---
 cmd/moq-example/client.cpp   |   3 +-
 cmd/moq-example/server.cpp   |   2 +-
 include/quicr/moq_instance.h |   2 +-
 src/moq_instance.cpp         | 151 ++++++++++++++++++++++++++++++++---
 4 files changed, 143 insertions(+), 15 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index edbba9b7..5861506f 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -42,7 +42,7 @@ class trackDelegate : public quicr::MoQTrackDelegate
                   const cantina::LoggerPointer& logger)
       : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
                          { t_name.begin(), t_name.end() },
-                         TrackMode::STREAM_PER_GROUP,
+                         TrackMode::DATAGRAM,
                          priority,
                          ttl,
                          logger)
@@ -160,7 +160,6 @@ void do_publisher(const std::string t_namespace,
 
         std::vector<uint8_t> msg_v(msg.begin(), msg.end());
         auto result = track_delegate->sendObject(group_id, object_id++, std::move(msg_v));
-        _logger->debug << "send error: " << static_cast<int>(result) << std::flush;
     }
 
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index ff4e3a4f..1149924d 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -44,7 +44,7 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
                      const cantina::LoggerPointer& logger)
       : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
                          { t_name.begin(), t_name.end() },
-                         TrackMode::STREAM_PER_GROUP,
+                         TrackMode::DATAGRAM,
                          priority,
                          ttl,
                          logger)
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 3b456445..c35fa631 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -252,7 +252,7 @@ namespace quicr {
                               const std::string& reason_str);
         bool process_recv_ctrl_message(ConnectionContext& conn_ctx,
                                        std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
-        bool process_recv_data_message(ConnectionContext& conn_ctx,
+        bool process_recv_stream_data_message(ConnectionContext& conn_ctx,
                                        std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
         std::optional<std::weak_ptr<MoQTrackDelegate>> getPubTrackDelegate(ConnectionContext& conn_ctx,
                                                                            TrackHash& th);
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 9204255e..dc2a57d4 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -337,7 +337,10 @@ namespace quicr {
                         send_subscribe_ok(conn_ctx, msg.subscribe_id, MOQT_SUBSCRIBE_EXPIRES, false);
 
                         _logger->debug << "Received subscribe to announced track alias: " << msg.track_alias
-                                       << ", setting send state to ready" << std::flush;
+                                       << " recv subscribe_id: " << msg.subscribe_id
+                                       << ", setting send"
+                                          ""
+                                          " state to ready" << std::flush;
 
                         // Indicate send is ready upon subscribe
                         // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
@@ -578,8 +581,8 @@ namespace quicr {
         return false;
     }
 
-    bool MoQInstance::process_recv_data_message(ConnectionContext& conn_ctx,
-                                                std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer)
+    bool MoQInstance::process_recv_stream_data_message(ConnectionContext& conn_ctx,
+                                                       std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer)
     {
         if (stream_buffer->size() == 0) { // should never happen
             close_connection(conn_ctx.conn_id,
@@ -608,12 +611,89 @@ namespace quicr {
         }
 
         switch (data_type) {
-            case MoQMessageType::OBJECT_DATAGRAM:
-                break;
-            case MoQMessageType::OBJECT_STREAM:
+            case MoQMessageType::OBJECT_STREAM: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received stream header object, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqObjectStream>(
+                      static_cast<uint64_t>(MoQMessageType::OBJECT_STREAM));
+                }
+
+                auto& msg = stream_buffer->getAny<MoqObjectStream>();
+                if (*stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received stream_object to unknown subscribe track"
+                                         << " subscribe_id: " << msg.subscribe_id << " , ignored" << std::flush;
+
+                        // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                        return true;
+                    }
+
+                    _logger->debug << "Received stream_object " << " subscribe_id: " << msg.subscribe_id
+                                   << " priority: " << msg.priority << " track_alias: " << msg.track_alias
+                                   << " group_id: " << msg.group_id << " object_id: " << msg.object_id
+                                   << " data size: " << msg.payload.size() << std::flush;
+                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, std::move(msg.payload));
+                    stream_buffer->resetAny();
+                }
                 break;
-            case MoQMessageType::STREAM_HEADER_TRACK:
+            }
+
+            case MoQMessageType::STREAM_HEADER_TRACK: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received stream header track, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqStreamHeaderTrack>(
+                      static_cast<uint64_t>(MoQMessageType::STREAM_HEADER_TRACK));
+                }
+
+                auto& msg = stream_buffer->getAny<MoqStreamHeaderTrack>();
+                if (!stream_buffer->anyHasValueB() && *stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received stream_header_track to unknown subscribe track"
+                                         << " subscribe_id: " << msg.subscribe_id << " , ignored" << std::flush;
+
+                        // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                        return true;
+                    }
+
+                    // Init second working buffer to read data object
+                    stream_buffer->initAnyB<MoqStreamTrackObject>();
+
+                    _logger->debug << "Received stream_header_track " << " subscribe_id: " << msg.subscribe_id
+                                   << " priority: " << msg.priority << " track_alias: " << msg.track_alias
+                                   << std::flush;
+                }
+
+                if (stream_buffer->anyHasValueB()) {
+                    MoqStreamTrackObject obj;
+                    if (*stream_buffer >> obj) {
+                        auto sub_it
+
+
+                          = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                        if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                            _logger->warning << "Received stream_header_group to unknown subscribe track"
+                                             << " subscribe_id: " << msg.subscribe_id << " , ignored" << std::flush;
+
+                            // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                            return true;
+                        }
+
+                        _logger->debug << "Received stream_track_object " << " subscribe_id: " << msg.subscribe_id
+                                       << " priority: " << msg.priority << " track_alias: " << msg.track_alias
+                                       << " group_id: " << obj.group_id << " object_id: " << obj.object_id
+                                       << " data size: " << obj.payload.size() << std::flush;
+                        stream_buffer->resetAnyB();
+
+                        sub_it->second->cb_objectReceived(obj.group_id, obj.object_id, std::move(obj.payload));
+                    }
+                }
                 break;
+            }
             case MoQMessageType::STREAM_HEADER_GROUP: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received stream header group, init stream buffer" << std::flush;
@@ -1047,6 +1127,9 @@ namespace quicr {
                         const bool is_bidir)
     {
         auto stream_buf = _transport->getStreamBuffer(conn_id, stream_id);
+
+        //std::lock_guard<std::mutex> _(_state_mutex);
+
         auto& conn_ctx = _connections[conn_id];
 
         if (stream_buf == nullptr) {
@@ -1086,7 +1169,7 @@ namespace quicr {
 
             // Data stream, unidirectional
             else {
-                if (process_recv_data_message(conn_ctx, stream_buf)) {
+                if (process_recv_stream_data_message(conn_ctx, stream_buf)) {
                     break;
                 }
             }
@@ -1100,9 +1183,55 @@ namespace quicr {
 
     void MoQInstance::on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id)
     {
-        _logger->info << "datagram data conn_id: " << conn_id
-                      << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
-                      << std::flush;
+        MoqObjectStream object_datagram_out;
+        for (int i=0; i < 70; i++) {
+            auto data = _transport->dequeue(conn_id, data_ctx_id);
+            if (data && !data->empty()) {
+                StreamBuffer<uint8_t> buffer;
+                buffer.push(*data);
+
+                auto msg_type = buffer.decode_uintV();
+                if (!msg_type || static_cast<MoQMessageType>(*msg_type) != MoQMessageType::OBJECT_DATAGRAM) {
+                    _logger->warning << "Received datagram that is not message type OBJECT_DATAGRAM, dropping" << std::flush;
+                    continue;
+                }
+
+                MoqObjectDatagram msg;
+                if (buffer >> msg) {
+
+                    //std::lock_guard<std::mutex> _(_state_mutex);
+
+                    auto& conn_ctx = _connections[conn_id];
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received datagram to unknown subscribe track"
+                                         << " subscribe_id: " << msg.subscribe_id << ", ignored" << std::flush;
+
+                        // TODO(tievens): Should close/reset stream in this case but draft leaves this case hanging
+
+                        continue;
+                    }
+
+
+                    _logger->debug << "Received object datagram conn_id: " << conn_id
+                                   << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
+                                   << " subscriber_id: " << msg.subscribe_id
+                                   << " track_alias: " << msg.track_alias
+                                   << " group_id: " << msg.group_id
+                                   << " object_id: " << msg.object_id
+                                   << " data size: " << msg.payload.size()
+                                   << std::flush;
+
+                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, std::move(msg.payload));
+
+                } else {
+                    _logger->warning << "Failed to decode datagram conn_id: " << conn_id
+                                     << " data_ctx_id: " << (data_ctx_id ? *data_ctx_id : 0)
+                                     << std::flush;
+                }
+
+            }
+        }
 
     }
 

From 7fbbaa2c5a45d2a287c02eae43779f9f63b75af0 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 13:38:20 -0700
Subject: [PATCH 55/71] Default qclient/qserver to use stream per group

---
 cmd/moq-example/client.cpp |  2 +-
 cmd/moq-example/server.cpp |  2 +-
 src/moq_instance.cpp       | 25 ++++++++-----------------
 3 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 5861506f..bdad51f9 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -42,7 +42,7 @@ class trackDelegate : public quicr::MoQTrackDelegate
                   const cantina::LoggerPointer& logger)
       : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
                          { t_name.begin(), t_name.end() },
-                         TrackMode::DATAGRAM,
+                         TrackMode::STREAM_PER_GROUP,
                          priority,
                          ttl,
                          logger)
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 1149924d..ff4e3a4f 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -44,7 +44,7 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
                      const cantina::LoggerPointer& logger)
       : MoQTrackDelegate({ t_namespace.begin(), t_namespace.end() },
                          { t_name.begin(), t_name.end() },
-                         TrackMode::DATAGRAM,
+                         TrackMode::STREAM_PER_GROUP,
                          priority,
                          ttl,
                          logger)
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index dc2a57d4..9b52a2d5 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -386,23 +386,6 @@ namespace quicr {
 
                     sub_it->second.get()->cb_readReady();
 
-                    /*
-                    // For mirroring, update self publish track for same namespace/track that it can send
-                    auto tfn = TrackFullName{ sub_it->second->getTrackNamespace(), sub_it->second->getTrackName() };
-                    auto th = TrackHash(tfn);
-
-                    auto pub_track = getPubTrackDelegate(conn_ctx, th);
-                    if (pub_track.has_value()) {
-                        if (conn_ctx._sub_id <= msg.subscribe_id) {
-                            conn_ctx._sub_id = msg.subscribe_id  + 1;
-                        }
-
-                        pub_track->lock()->setSubscribeId(msg.subscribe_id);
-                        pub_track->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
-                        pub_track->lock()->cb_sendReady();
-                    }
-                    */
-
                     stream_buffer->resetAny();
                     return true;
                 }
@@ -467,20 +450,28 @@ namespace quicr {
                 break;
             }
             case MoQMessageType::ANNOUNCE_ERROR:
+                _logger->debug << "Received announce error " << std::flush;
                 break;
             case MoQMessageType::UNANNOUNCE:
+                _logger->debug << "Received unannounce" << std::flush;
                 break;
             case MoQMessageType::UNSUBSCRIBE:
+                _logger->debug << "Received unsubscribe" << std::flush;
                 break;
             case MoQMessageType::SUBSCRIBE_DONE:
+                _logger->debug << "Received subscribe done" << std::flush;
                 break;
             case MoQMessageType::ANNOUNCE_CANCEL:
+                _logger->debug << "Received announce cancel" << std::flush;
                 break;
             case MoQMessageType::TRACK_STATUS_REQUEST:
+                _logger->debug << "Received track status request" << std::flush;
                 break;
             case MoQMessageType::TRACK_STATUS:
+                _logger->debug << "Received track status" << std::flush;
                 break;
             case MoQMessageType::GOWAY:
+                _logger->debug << "Received goaway" << std::flush;
                 break;
             case MoQMessageType::CLIENT_SETUP: {
                     if (not stream_buffer->anyHasValue()) {

From 62041578c9edbd29bedf3b9746463fc7ba89eefb Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 21 Jun 2024 15:44:13 -0700
Subject: [PATCH 56/71] Propagate and use publisher delivery mode

---
 cmd/moq-example/client.cpp         |  5 ++++-
 cmd/moq-example/server.cpp         |  8 ++++++--
 include/quicr/moq_track_delegate.h | 10 ++++++++--
 src/moq_instance.cpp               | 16 ++++++++++++----
 4 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index bdad51f9..b0096367 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -49,7 +49,10 @@ class trackDelegate : public quicr::MoQTrackDelegate
     {
     }
 
-    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id,
+                           [[maybe_unused]] uint8_t priority,
+                           std::vector<uint8_t>&& object,
+                           [[maybe_unused]] TrackMode track_mode) override {
         std::string msg(object.begin(), object.end());
 
         _logger->info << "Received message: " << msg << std::flush;
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index ff4e3a4f..d15d72d5 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -52,14 +52,18 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
     }
 
     // TODO: Add prioirty and TTL
-    void cb_objectReceived(uint64_t group_id, uint64_t object_id, std::vector<uint8_t>&& object) override {
+    void cb_objectReceived(uint64_t group_id, uint64_t object_id,
+                           uint8_t priority,
+                           std::vector<uint8_t>&& object,
+                           TrackMode track_mode) override {
 
         for (const auto& [conn_id, td]: qserver_vars::subscribes.find(*_track_alias)->second) {
             _logger->debug << "Relaying track_alias: " << *_track_alias
                            << ", object to subscribe conn_id: " << conn_id
                            << " data size: " << object.size() << std::flush;
 
-            td->sendObject(group_id, object_id, object);
+            td->setTrackMode(track_mode);
+            td->sendObject(group_id, object_id, object, priority);
         }
     }
     void cb_sendCongested(bool cleared, uint64_t objects_in_queue) override {}
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 8b97ddf2..e4cb635b 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -159,11 +159,17 @@ namespace quicr {
          *
          * @details Event notification to provide the caller the received data object
          *
-         * @param object    Data object received
+         * @param group_id          Group ID of the object received
+         * @param object_id         Object ID of the object received
+         * @parma priority          Priority of the object received
+         * @param object            Data object received
+         * @param track_mode        Track mode the object was received
          */
         virtual void cb_objectReceived(uint64_t group_id,
                                        uint64_t object_id,
-                                       std::vector<uint8_t>&& object) = 0;
+                                       uint8_t priority,
+                                       std::vector<uint8_t>&& object,
+                                       TrackMode track_mode) = 0;
 
         /**
          * @brief Notification that data can be sent
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 9b52a2d5..81e49255 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -625,7 +625,9 @@ namespace quicr {
                                    << " priority: " << msg.priority << " track_alias: " << msg.track_alias
                                    << " group_id: " << msg.group_id << " object_id: " << msg.object_id
                                    << " data size: " << msg.payload.size() << std::flush;
-                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, std::move(msg.payload));
+                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, msg.priority,
+                                                      std::move(msg.payload),
+                                                      MoQTrackDelegate::TrackMode::STREAM_PER_OBJECT);
                     stream_buffer->resetAny();
                 }
                 break;
@@ -680,7 +682,9 @@ namespace quicr {
                                        << " data size: " << obj.payload.size() << std::flush;
                         stream_buffer->resetAnyB();
 
-                        sub_it->second->cb_objectReceived(obj.group_id, obj.object_id, std::move(obj.payload));
+                        sub_it->second->cb_objectReceived(obj.group_id, obj.object_id, msg.priority,
+                                                          std::move(obj.payload),
+                                                          MoQTrackDelegate::TrackMode::STREAM_PER_TRACK);
                     }
                 }
                 break;
@@ -741,7 +745,9 @@ namespace quicr {
                                        << std::flush;
                         stream_buffer->resetAnyB();
 
-                        sub_it->second->cb_objectReceived(msg.group_id, obj.object_id, std::move(obj.payload));
+                        sub_it->second->cb_objectReceived(msg.group_id, obj.object_id, msg.priority,
+                                                          std::move(obj.payload),
+                                                          MoQTrackDelegate::TrackMode::STREAM_PER_GROUP);
                     }
                 }
 
@@ -1213,7 +1219,9 @@ namespace quicr {
                                    << " data size: " << msg.payload.size()
                                    << std::flush;
 
-                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, std::move(msg.payload));
+                    sub_it->second->cb_objectReceived(msg.group_id, msg.object_id, msg.priority,
+                                                      std::move(msg.payload),
+                                                      MoQTrackDelegate::TrackMode::DATAGRAM);
 
                 } else {
                     _logger->warning << "Failed to decode datagram conn_id: " << conn_id

From 1234ff1cfd8ce99218b4de796ae5683c62f43e20 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 24 Jun 2024 13:25:18 -0700
Subject: [PATCH 57/71] Resolve flow where subscriber comes first before
 announcement

---
 cmd/moq-example/server.cpp            | 90 ++++++++++++++++++++++++---
 include/quicr/moq_instance_delegate.h | 15 ++++-
 src/moq_instance.cpp                  |  5 +-
 3 files changed, 98 insertions(+), 12 deletions(-)

diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index d15d72d5..a9c98e2f 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -11,10 +11,10 @@
 namespace qserver_vars {
 
     /*
-     * Map/state of announcements
-     *      track_alias_set = announce_state[track_namespace][conn_id]
+     * Map of announcements
+     *      track_alias_set = announce_active[track_namespace][conn_id]
      */
-    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::set<uint64_t>>> announce_state;
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::set<uint64_t>>> announce_active;
 
     /*
      * Active subscribes for a given track, indexed (keyed) by track_alias,conn_id
@@ -25,13 +25,34 @@ namespace qserver_vars {
      */
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> subscribes;
 
+
+    /*
+     * Map of subscribes set by namespace and track name hash
+     *      Set<subscribe_who> = subscribe_active[track_namespace][track_name_hash]
+     */
+    struct SubscribeWho {
+        uint64_t conn_id;
+        uint64_t subscribe_id;
+        uint64_t track_alias;
+
+        bool operator<(const SubscribeWho& other) const {
+            return conn_id < other.conn_id && subscribe_id << other.subscribe_id;
+        }
+        bool operator==(const SubscribeWho& other) const {
+            return conn_id == other.conn_id && subscribe_id == other.subscribe_id;
+        }
+        bool operator>(const SubscribeWho& other) const {
+            return conn_id > other.conn_id && subscribe_id > other.subscribe_id;
+        }
+    };
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::set<SubscribeWho>>> subscribe_active;
+
     /*
      * Active publisher/announce subscribes that this relay has made to receive objects from publisher.
      *
      * track_delegate = pub_subscribes[track_alias][conn_id]
      */
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> pub_subscribes;
-
 }
 
 class subTrackDelegate : public quicr::MoQTrackDelegate
@@ -104,12 +125,56 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                        << std::flush;
 
         // Add to state if not exist
-        qserver_vars::announce_state[track_namespace_hash].try_emplace(conn_id);
+        auto [anno_conn_it, is_new] = qserver_vars::announce_active[track_namespace_hash].try_emplace(conn_id);
+
+        if (!is_new) {
+            _logger->info << "Received announce from conn_id: " << conn_id
+                          << " for namespace_hash: " << track_namespace_hash
+                          << " is duplicate, ignoring" << std::flush;
+            return true;
+        }
 
         // true results in Send announce OK
         return true;
     }
 
+    void cb_announce_post(qtransport::TransportConnId conn_id,
+                          uint64_t track_namespace_hash) override {
+
+        auto anno_conn_it = qserver_vars::announce_active[track_namespace_hash].find(conn_id);
+
+        // Check if there are any subscribes. If so, send subscribe to announce for all tracks matching namespace
+        const auto sub_active_it = qserver_vars::subscribe_active.find(track_namespace_hash);
+        if (sub_active_it != qserver_vars::subscribe_active.end()) {
+            for (const auto& [track_name, who]: sub_active_it->second) {
+                if (who.size()) { // Have subscribes
+                    auto& a_who = *who.begin();
+                    if (!anno_conn_it->second.contains(track_name)) {
+                        _logger->info << "Sending subscribe to announcer conn_id: " << conn_id
+                                      << " subscribe track_alias: " << a_who.track_alias
+                                      << std::flush;
+
+                        anno_conn_it->second.insert(track_name); // Add track to state
+
+                        const auto sub_track_delegate = qserver_vars::subscribes[a_who.track_alias][a_who.conn_id];
+                        std::string t_namespace {sub_track_delegate->getTrackNamespace().begin(), sub_track_delegate->getTrackNamespace().end()};
+                        std::string t_name { sub_track_delegate->getTrackName().begin(), sub_track_delegate->getTrackName().end()};
+
+                        auto pub_track_delegate =
+                          std::make_shared<subTrackDelegate>(t_namespace,
+                                                             t_name,
+                                                             2,
+                                                             3000,
+                                                             _logger);
+
+                        _moq_instance.lock()->subscribeTrack(conn_id, pub_track_delegate);
+                        qserver_vars::pub_subscribes[a_who.track_alias][conn_id] = pub_track_delegate;
+                    }
+                }
+            }
+        }
+    }
+
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
                              const std::span<uint8_t>& endpoint_id,
                              qtransport::TransportStatus status) override {
@@ -143,15 +208,20 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         auto th = quicr::MoQInstance::TrackHash(tfn);
         qserver_vars::subscribes[th.track_fullname_hash][conn_id] = track_delegate;
 
+        // record subscribe as active from this subscriber
+        qserver_vars::subscribe_active[th.track_namespace_hash][th.track_name_hash].emplace(
+          qserver_vars::SubscribeWho{ .conn_id = conn_id,
+                                      .subscribe_id = subscribe_id,
+                                      .track_alias = th.track_fullname_hash});
+
         // Create a subscribe track that will be used by the relay to send to subscriber for matching objects
         _moq_instance.lock()->bindSubscribeTrack(conn_id, subscribe_id, track_delegate);
 
-        //TODO: Create subscribe to announcer if new track
-        auto anno_ns_it = qserver_vars::announce_state.find(th.track_namespace_hash);
-        if (anno_ns_it == qserver_vars::announce_state.end()) {
+        // Subscribe to announcer if announcer is active
+        auto anno_ns_it = qserver_vars::announce_active.find(th.track_namespace_hash);
+        if (anno_ns_it == qserver_vars::announce_active.end()) {
             _logger->info << "Subscribe to track namespace: " << t_namespace
                           <<  ", does not have any announcements." << std::flush;
-            // TODO(tievens): Handle creating subscribe to announcer when subscribe is present
             return true;
         }
 
@@ -161,7 +231,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                               << " subscribe track_alias: " << th.track_name_hash
                               << std::flush;
 
-                tracks.insert(th.track_name_hash); // Add track alais to state
+                tracks.insert(th.track_name_hash); // Add track alias to state
 
                 auto pub_track_delegate = std::make_shared<subTrackDelegate>(t_namespace, t_name, 2, 3000, _logger);
                 _moq_instance.lock()->subscribeTrack(conn_id, pub_track_delegate);
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 0b44e94f..bda1808e 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -67,7 +67,7 @@ namespace quicr {
                                     [[maybe_unused]] messages::MoqServerSetup server_setup) {}
 
         /**
-         * @brief Server Mode; Callback notification for new announce received
+         * @brief Server Mode; Callback notification for new announce received (need to authorize)
          *
          * @param conn_id                   Source connection ID
          * @param track_namespace_hash      Track namespace hash
@@ -77,6 +77,19 @@ namespace quicr {
         virtual bool cb_announce([[maybe_unused]] TransportConnId conn_id,
                                  [[maybe_unused]] uint64_t track_namespace_hash) { return true; }
 
+        /**
+         * @brief Server Mode; Callback notification for new announce received post OK being sent
+         *
+         * @details After announce an OK is sent providing the announce was authorized and accepted. This
+         *      callback is called after `cb_announce()` to allow the server to subscribe or followup
+         *      with actions based on the announce.
+         *
+         * @param conn_id                   Source connection ID
+         * @param track_namespace_hash      Track namespace hash
+         */
+        virtual void cb_announce_post([[maybe_unused]] TransportConnId conn_id,
+                                      [[maybe_unused]] uint64_t track_namespace_hash) { }
+
         /**
          * @brief Callback notification for new subscribe received
          *
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 81e49255..ce7eab72 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -419,6 +419,7 @@ namespace quicr {
 
                     if (_delegate->cb_announce(conn_ctx.conn_id, th.track_namespace_hash)) {
                         send_announce_ok(conn_ctx, msg.track_namespace);
+                        _delegate->cb_announce_post(conn_ctx.conn_id, th.track_namespace_hash);
                     }
 
                     stream_buffer->resetAny();
@@ -441,7 +442,8 @@ namespace quicr {
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
                     for (const auto& td: pub_it->second) {
-                        td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
+                        if (td.second.get()->statusSend() != MoQTrackDelegate::TrackSendStatus::OK)
+                            td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
                     }
 
                     stream_buffer->resetAny();
@@ -903,6 +905,7 @@ namespace quicr {
             _logger->info << "Publish track has new namespace hash: " << th.track_namespace_hash
                           << " sending ANNOUNCE message" << std::flush;
 
+            track_delegate->setSendStatus(MoQTrackDelegate::TrackSendStatus::PENDING_ANNOUNCE_RESPONSE);
             send_announce(conn_it->second, track_delegate->getTrackNamespace());
 
         } else {

From 8a9ded8b41714fd59f94e455ac5aed47ccda922c Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Mon, 24 Jun 2024 17:21:31 -0700
Subject: [PATCH 58/71] Initial unsubscribe handling

---
 include/quicr/moq_instance.h          | 13 +++++
 include/quicr/moq_instance_delegate.h | 16 ++++++
 include/quicr/moq_messages.h          |  1 +
 include/quicr/moq_track_delegate.h    |  9 +++-
 src/moq_instance.cpp                  | 70 ++++++++++++++++++++++++++-
 5 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index c35fa631..d95f650c 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -127,6 +127,15 @@ namespace quicr {
         std::optional<uint64_t> subscribeTrack(TransportConnId conn_id,
                                                std::shared_ptr<MoQTrackDelegate> track_delegate);
 
+        /**
+         * @brief Unsubscribe track
+         *
+         * @param conn_id           Connection ID to send subscribe
+         * @param track_delegate    Track delegate to use for track related functions and callbacks
+         */
+        void unsubscribeTrack(TransportConnId conn_id,
+                              std::shared_ptr<MoQTrackDelegate> track_delegate);
+
         /**
          * @brief Bind Subscribe track delegate
          *
@@ -254,6 +263,10 @@ namespace quicr {
                                        std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
         bool process_recv_stream_data_message(ConnectionContext& conn_ctx,
                                        std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
+
+        void remove_subscribeTrack(ConnectionContext& conn_ctx,
+                                   MoQTrackDelegate& delegate);
+
         std::optional<std::weak_ptr<MoQTrackDelegate>> getPubTrackDelegate(ConnectionContext& conn_ctx,
                                                                            TrackHash& th);
 
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index bda1808e..e8093847 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -108,6 +108,22 @@ namespace quicr {
             return true;
         }
 
+        /**
+         * @brief Callback notification on unsubscribe received
+         *
+         * @param conn_id             Source connection ID
+         * @param subscribe_id        Subscribe ID received
+         * @param name_space          Track Namespace from subscription
+         * @param name                Track name from subscription
+         *
+         * @return True if send announce should be sent, false if not
+         */
+        virtual bool cb_unsubscribe([[maybe_unused]] TransportConnId conn_id,
+                                  [[maybe_unused]] uint64_t subscribe_id)
+        {
+            return true;
+        }
+
     };
 
 } // namespace quicr
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 82ff3183..4c665ca0 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -22,6 +22,7 @@ using SubscribeId = uint64_t;
 using TrackAlias = uint64_t;
 using ParamType = uint64_t;
 
+
 enum class MoQTerminationReason : uint64_t
 {
   NO_ERROR = 0x0,
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index e4cb635b..278a6d47 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -5,6 +5,7 @@
  */
 #pragma once
 
+#include "cantina/logger.h"
 #include <quicr/quicr_common.h>
 
 namespace quicr {
@@ -40,6 +41,7 @@ namespace quicr {
         enum class TrackReadStatus : uint8_t
         {
             OK = 0,
+            SUBSCRIBE_ERROR,
             NOT_AUTHORIZED,
             NOT_SUBSCRIBED,
             PENDING_SUBSCRIBE_RESPONSE,
@@ -239,7 +241,7 @@ namespace quicr {
          *
          * @param subscribe_id          62bit subscribe ID
          */
-        void setSubscribeId(uint64_t subscribe_id) { _subscribe_id = subscribe_id; }
+        void setSubscribeId(std::optional<uint64_t> subscribe_id) { _subscribe_id = subscribe_id; }
 
         /**
          * @brief Get the subscribe ID
@@ -266,6 +268,11 @@ namespace quicr {
          */
         void setSendStatus(TrackSendStatus status) { _send_status = status; }
 
+        /**
+         * @brief Set the read status
+         * @param status                Status of reading (aka subscribe)
+         */
+        void setReadStatus(TrackReadStatus status) { _read_status = status; }
 
         // --------------------------------------------------------------------------
         // MOQ Instance specific public variables/methods - Caller should not use these
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index ce7eab72..594722be 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -374,7 +374,7 @@ namespace quicr {
                     auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
-                        _logger->warning << "Received subsribe ok to unknown subscribe track"
+                        _logger->warning << "Received subscribe ok to unknown subscribe track"
                                       << " subscribe_id: " << msg.subscribe_id
                                       << " , ignored"
                                       << std::flush;
@@ -399,7 +399,21 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqSubscribeError>();
                 if (*stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received subscribe error to unknown subscribe_id"
+                                         << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored"
+                                         << std::flush;
+
+                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        stream_buffer->resetAny();
+                        return true;
+                    }
 
+                    sub_it->second.get()->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::SUBSCRIBE_ERROR);
+                    remove_subscribeTrack(conn_ctx, *sub_it->second);
 
                     stream_buffer->resetAny();
                     return true;
@@ -458,8 +472,37 @@ namespace quicr {
                 _logger->debug << "Received unannounce" << std::flush;
                 break;
             case MoQMessageType::UNSUBSCRIBE:
-                _logger->debug << "Received unsubscribe" << std::flush;
+            {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received unsubscribe, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqUnsubscribe>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqUnsubscribe>();
+                if (*stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received unsubscribe to unknown subscribe_id"
+                                         << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored"
+                                         << std::flush;
+
+                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        stream_buffer->resetAny();
+                        return true;
+                    }
+
+                    sub_it->second.get()->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
+                    remove_subscribeTrack(conn_ctx, *sub_it->second);
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
+
                 break;
+            }
             case MoQMessageType::SUBSCRIBE_DONE:
                 _logger->debug << "Received subscribe done" << std::flush;
                 break;
@@ -876,6 +919,28 @@ namespace quicr {
         return th.track_fullname_hash;
     }
 
+    void MoQInstance::unsubscribeTrack(qtransport::TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate)
+    {
+        auto& conn_ctx = _connections[conn_id];
+        remove_subscribeTrack(conn_ctx,*track_delegate);
+    }
+
+    void MoQInstance::remove_subscribeTrack(ConnectionContext& conn_ctx,
+                                          MoQTrackDelegate& delegate)
+    {
+        delegate.setReadStatus(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
+        delegate.setSubscribeId(std::nullopt);
+
+        auto subscribe_id = delegate.getSubscribeId();
+        if (subscribe_id.has_value()) {
+
+            std::lock_guard<std::mutex> _(_state_mutex);
+            _logger->debug << "remove subscribe id: " << *subscribe_id << std::flush;
+
+            conn_ctx.tracks_by_sub_id.erase(*subscribe_id);
+        }
+    }
+
     std::optional<uint64_t> MoQInstance::publishTrack(TransportConnId conn_id,
                                          std::shared_ptr<MoQTrackDelegate> track_delegate) {
 
@@ -1083,6 +1148,7 @@ namespace quicr {
         }
     }
 
+
     // ---------------------------------------------------------------------------------------
     // Transport delegate callbacks
     // ---------------------------------------------------------------------------------------

From 66549ea97e3089c355cf39bc2fe2f0f8f270678b Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Tue, 25 Jun 2024 16:19:33 -0700
Subject: [PATCH 59/71] Complete unsubscribe handling and update to use spans

---
 cmd/moq-example/client.cpp            |  35 ++++-
 cmd/moq-example/server.cpp            | 153 ++++++++++++++++++++-
 include/quicr/moq_instance.h          |  22 +++-
 include/quicr/moq_instance_delegate.h |  11 +-
 include/quicr/moq_track_delegate.h    |  15 ++-
 src/moq_instance.cpp                  | 183 ++++++++++++++++++++------
 src/moq_messages.cpp                  |   1 -
 src/moq_track_delegate_base.cpp       |  12 +-
 8 files changed, 352 insertions(+), 80 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index b0096367..20448d2a 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -32,6 +32,11 @@ std::string get_time_str()
     return oss.str();
 }
 
+/* -------------------------------------------------------------------------------------------------
+ * Track delegate is used for either publish or subscribe. All handling for the track is via the
+ *      delegate.
+ * -------------------------------------------------------------------------------------------------
+ */
 class trackDelegate : public quicr::MoQTrackDelegate
 {
 public:
@@ -63,7 +68,13 @@ class trackDelegate : public quicr::MoQTrackDelegate
         _logger->info << "Track alias: " << _track_alias.value() << " is ready to send" << std::flush;
     }
 
-    void cb_sendNotReady(TrackSendStatus status) override {}
+    void cb_sendNotReady(TrackSendStatus status) override {
+        _logger->info << "Track alias: " << _track_alias.value()
+                      << " is NOT ready to send"
+                      << " status: " << static_cast<int>(status)
+                      << std::flush;
+    }
+
     void cb_readReady() override
     {
         _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
@@ -71,6 +82,10 @@ class trackDelegate : public quicr::MoQTrackDelegate
     void cb_readNotReady(TrackReadStatus status) override {}
 };
 
+/* -------------------------------------------------------------------------------------------------
+ * Client MOQ instance delegate is used to control and interact with the connection.
+ * -------------------------------------------------------------------------------------------------
+ */
 class clientDelegate : public quicr::MoQInstanceDelegate
 {
 public:
@@ -102,6 +117,10 @@ class clientDelegate : public quicr::MoQInstanceDelegate
     cantina::LoggerPointer _logger;
 };
 
+/* -------------------------------------------------------------------------------------------------
+ * Publisher Thread to perform publishing
+ * -------------------------------------------------------------------------------------------------
+ */
 void do_publisher(const std::string t_namespace,
                   const std::string t_name,
                   const std::shared_ptr<quicr::MoQInstance>& moqInstance,
@@ -162,12 +181,16 @@ void do_publisher(const std::string t_namespace,
         }
 
         std::vector<uint8_t> msg_v(msg.begin(), msg.end());
-        auto result = track_delegate->sendObject(group_id, object_id++, std::move(msg_v));
+        auto result = track_delegate->sendObject(group_id, object_id++, msg_v);
     }
 
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
 }
 
+/* -------------------------------------------------------------------------------------------------
+ * Subscriber thread to perform subscribe
+ * -------------------------------------------------------------------------------------------------
+ */
 void do_subscriber(const std::string t_namespace,
                    const std::string t_name,
                    const std::shared_ptr<quicr::MoQInstance>& moqInstance,
@@ -192,9 +215,17 @@ void do_subscriber(const std::string t_namespace,
         std::this_thread::sleep_for(std::chrono::milliseconds(500));
     }
 
+    mi->unsubscribeTrack(*qclient_vars::conn_id, track_delegate);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
     _logger->info << "Subscriber done track: " << t_namespace << "/" << t_name << std::flush;
 }
 
+/* -------------------------------------------------------------------------------------------------
+ * Main program
+ * -------------------------------------------------------------------------------------------------
+ */
 quicr::MoQInstanceClientConfig init_config(cxxopts::ParseResult& cli_opts,
                                            bool& enable_pub,
                                            bool& enable_sub,
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index a9c98e2f..35fbbb16 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -9,9 +9,10 @@
 #include "signal_handler.h"
 
 namespace qserver_vars {
+    std::mutex _state_mutex;
 
     /*
-     * Map of announcements
+     * Map of subscribes (e.g., track alias) sent to announcements
      *      track_alias_set = announce_active[track_namespace][conn_id]
      */
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::set<uint64_t>>> announce_active;
@@ -25,10 +26,17 @@ namespace qserver_vars {
      */
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> subscribes;
 
+    /*
+     * Subscribe ID to alias mapping
+     *      Used to lookup the track alias for a given subscribe ID
+     *
+     *      track_alias = subscribe_alias_sub_id[conn_id][subscribe_id]
+     */
+    std::unordered_map<uint64_t, std::unordered_map<uint64_t, uint64_t>> subscribe_alias_sub_id;
 
     /*
      * Map of subscribes set by namespace and track name hash
-     *      Set<subscribe_who> = subscribe_active[track_namespace][track_name_hash]
+     *      Set<subscribe_who> = subscribe_active[track_namespace_hash][track_name_hash]
      */
     struct SubscribeWho {
         uint64_t conn_id;
@@ -55,6 +63,11 @@ namespace qserver_vars {
     std::unordered_map<uint64_t, std::unordered_map<uint64_t, std::shared_ptr<quicr::MoQTrackDelegate>>> pub_subscribes;
 }
 
+/* -------------------------------------------------------------------------------------------------
+ * Subscribe Track Delegate - Relay runs on subscribes and uses subscribe delegate to send data
+ *      to subscriber
+ * -------------------------------------------------------------------------------------------------
+ */
 class subTrackDelegate : public quicr::MoQTrackDelegate
 {
 public:
@@ -78,7 +91,18 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
                            std::vector<uint8_t>&& object,
                            TrackMode track_mode) override {
 
-        for (const auto& [conn_id, td]: qserver_vars::subscribes.find(*_track_alias)->second) {
+        std::lock_guard<std::mutex> _(qserver_vars::_state_mutex);
+
+        auto sub_it = qserver_vars::subscribes.find(*_track_alias);
+
+        if (sub_it == qserver_vars::subscribes.end()) {
+            _logger->debug << "No subscribes, not relaying track_alias: " << *_track_alias
+                           << " data size: " << object.size() << std::flush;
+
+            return;
+        }
+
+        for (const auto& [conn_id, td]: sub_it->second) {
             _logger->debug << "Relaying track_alias: " << *_track_alias
                            << ", object to subscribe conn_id: " << conn_id
                            << " data size: " << object.size() << std::flush;
@@ -98,10 +122,37 @@ class subTrackDelegate : public quicr::MoQTrackDelegate
     {
         _logger->info << "Track alias: " << _track_alias.value() << " is ready to read" << std::flush;
     }
-    void cb_readNotReady(TrackReadStatus status) override {}
-};
+    void cb_readNotReady(TrackReadStatus status) override {
+
+        std::string reason = "";
+        switch (status) {
+            case TrackReadStatus::NOT_CONNECTED:
+                reason = "not connected";
+                break;
+            case TrackReadStatus::SUBSCRIBE_ERROR:
+                reason = "subscribe error";
+                break;
+            case TrackReadStatus::NOT_AUTHORIZED:
+                reason = "not authorized";
+                break;
+            case TrackReadStatus::NOT_SUBSCRIBED:
+                reason = "not subscribed";
+                break;
+            case TrackReadStatus::PENDING_SUBSCRIBE_RESPONSE:
+                reason = "pending subscribe response";
+                break;
+            default:
+                break;
+        }
 
+        _logger->info << "Track alias: " << _track_alias.value() << " is NOT ready, status: " << reason << std::flush;
+    }
+};
 
+/* -------------------------------------------------------------------------------------------------
+ * Server delegate is the instance delegate for connection handling
+ * -------------------------------------------------------------------------------------------------
+ */
 class serverDelegate : public quicr::MoQInstanceDelegate
 {
   public:
@@ -190,6 +241,92 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     void cb_clientSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqClientSetup client_setup) override {}
     void cb_serverSetup(qtransport::TransportConnId conn_id, quicr::messages::MoqServerSetup server_setup) override {}
 
+    void cb_unsubscribe(qtransport::TransportConnId conn_id,
+                        uint64_t subscribe_id) {
+        _logger->info << "Unsubscribe conn_id: " << conn_id
+                      << " subscribe_id: " << subscribe_id
+                      << std::flush;
+
+        auto ta_conn_it = qserver_vars::subscribe_alias_sub_id.find(conn_id);
+        if (ta_conn_it == qserver_vars::subscribe_alias_sub_id.end()) {
+            _logger->warning << "Unable to find track alias connection for conn_id: " << conn_id
+                             << " subscribe_id: " << subscribe_id
+                             << std::flush;
+            return;
+        }
+
+        auto ta_it = ta_conn_it->second.find(subscribe_id);
+        if (ta_it == ta_conn_it->second.end()) {
+            _logger->warning << "Unable to find track alias for conn_id: " << conn_id
+                              << " subscribe_id: " << subscribe_id
+                              << std::flush;
+            return;
+        }
+
+        std::lock_guard<std::mutex> _(qserver_vars::_state_mutex);
+
+        auto track_alias = ta_it->second;
+
+        ta_conn_it->second.erase(ta_it);
+        if (!ta_conn_it->second.size()) {
+            qserver_vars::subscribe_alias_sub_id.erase(ta_conn_it);
+        }
+
+
+        auto& track_delegate = qserver_vars::subscribes[track_alias][conn_id];
+
+        if (track_delegate == nullptr) {
+            _logger->warning << "Unsubscribe unable to find track delegate for conn_id: " << conn_id
+                             << " subscribe_id: " << subscribe_id << std::flush;
+            return;
+        }
+
+
+        auto tfn = quicr::MoQInstance::TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
+        auto th = quicr::MoQInstance::TrackHash(tfn);
+
+        qserver_vars::subscribes[track_alias].erase(conn_id);
+        bool unsub_pub { false };
+        if (!qserver_vars::subscribes[track_alias].size()) {
+            unsub_pub = true;
+            qserver_vars::subscribes.erase(track_alias);
+        }
+
+        qserver_vars::subscribe_active[th.track_namespace_hash][th.track_name_hash].erase(qserver_vars::SubscribeWho{
+          .conn_id = conn_id, .subscribe_id = subscribe_id, .track_alias = th.track_fullname_hash });
+
+        if (!qserver_vars::subscribe_active[th.track_namespace_hash][th.track_name_hash].size()) {
+            qserver_vars::subscribe_active[th.track_namespace_hash].erase(th.track_name_hash);
+        }
+
+        if (!qserver_vars::subscribe_active[th.track_namespace_hash].size()) {
+            qserver_vars::subscribe_active.erase(th.track_namespace_hash);
+        }
+
+        if (unsub_pub) {
+            _logger->info << "No subscribers left, unsub publisher track_alias: " << track_alias << std::flush;
+
+            auto anno_ns_it = qserver_vars::announce_active.find(th.track_namespace_hash);
+            if (anno_ns_it == qserver_vars::announce_active.end()) {
+                return;
+            }
+
+            for (auto& [conn_id, tracks]: anno_ns_it->second) {
+                if (tracks.contains(th.track_name_hash)) {
+                    _logger->info << "Unsubscribe to announcer conn_id: " << conn_id
+                                  << " subscribe track_alias: " << th.track_name_hash << std::flush;
+
+                    tracks.erase(th.track_name_hash); // Add track alias to state
+
+                    auto pub_delegate = qserver_vars::pub_subscribes[th.track_fullname_hash][conn_id];
+                    if (pub_delegate != nullptr) {
+                        _moq_instance.lock()->unsubscribeTrack(conn_id, pub_delegate);
+                    }
+                }
+            }
+        }
+    }
+
     bool cb_subscribe(qtransport::TransportConnId conn_id,
                       uint64_t subscribe_id,
                       std::span<uint8_t const> name_space,
@@ -207,6 +344,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         auto tfn = quicr::MoQInstance::TrackFullName{ name_space, name };
         auto th = quicr::MoQInstance::TrackHash(tfn);
         qserver_vars::subscribes[th.track_fullname_hash][conn_id] = track_delegate;
+        qserver_vars::subscribe_alias_sub_id[conn_id][subscribe_id] = th.track_fullname_hash;
 
         // record subscribe as active from this subscriber
         qserver_vars::subscribe_active[th.track_namespace_hash][th.track_name_hash].emplace(
@@ -247,6 +385,10 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     std::weak_ptr<quicr::MoQInstance> _moq_instance;
 };
 
+/* -------------------------------------------------------------------------------------------------
+ * Main program
+ * -------------------------------------------------------------------------------------------------
+ */
 quicr::MoQInstanceServerConfig init_config(cxxopts::ParseResult& cli_opts, const cantina::LoggerPointer& logger)
 {
     quicr::MoQInstanceServerConfig config;
@@ -275,6 +417,7 @@ quicr::MoQInstanceServerConfig init_config(cxxopts::ParseResult& cli_opts, const
     return config;
 }
 
+
 int
 main(int argc, char* argv[])
 {
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index d95f650c..51414edf 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -78,6 +78,11 @@ namespace quicr {
 
             uint64_t track_fullname_hash;                       // 62bit of namespace+name
 
+            TrackHash(const uint64_t name_space, const uint64_t name) {
+                track_namespace_hash = name_space;
+                track_name_hash = name;
+            }
+
             TrackHash(const TrackFullName& tfn) noexcept
             {
                 track_namespace_hash = std::hash<std::string_view>{}(
@@ -216,7 +221,7 @@ namespace quicr {
                                                 bool stream_header_needed,
                                                 uint64_t group_id,
                                                 uint64_t object_id,
-                                                bytes&& data);
+                                                std::span<const uint8_t> data);
 
       private:
 
@@ -230,6 +235,9 @@ namespace quicr {
 
             uint64_t _sub_id {0};      /// Connection specific ID for subscribe messages
 
+            // Track namespace/name by received subscribe IDs - Used to map published tracks to subscribes in client mode
+            std::map<uint64_t, std::pair<uint64_t, uint64_t>> recv_sub_id;
+
             // Tracks by subscribe ID
             std::map<uint64_t, std::shared_ptr<MoQTrackDelegate>> tracks_by_sub_id;
 
@@ -252,6 +260,7 @@ namespace quicr {
                                uint64_t subscribe_id,
                                uint64_t expires,
                                bool content_exists);
+        void send_unsubscribe(ConnectionContext& conn_ctx, uint64_t subscribe_id);
         void send_subscribe_error(ConnectionContext& conn_ctx,
                                   uint64_t subscribe_id,
                                   uint64_t track_alias,
@@ -265,7 +274,8 @@ namespace quicr {
                                        std::shared_ptr<StreamBuffer<uint8_t>>& stream_buffer);
 
         void remove_subscribeTrack(ConnectionContext& conn_ctx,
-                                   MoQTrackDelegate& delegate);
+                                   MoQTrackDelegate& delegate,
+                                   bool remove_delegate=true);
 
         std::optional<std::weak_ptr<MoQTrackDelegate>> getPubTrackDelegate(ConnectionContext& conn_ctx,
                                                                            TrackHash& th);
@@ -280,7 +290,8 @@ namespace quicr {
         bool _stop { false };
         const MoQInstanceServerConfig _server_config;
         const MoQInstanceClientConfig _client_config;
-        std::shared_ptr<MoQInstanceDelegate> _delegate;
+
+        std::map<TransportConnId, ConnectionContext> _connections;
 
         Status _status{ Status::NOT_READY };
 
@@ -291,9 +302,8 @@ namespace quicr {
         MetricsExporter _mexport;
 #endif
 
-        std::shared_ptr<ITransport> _transport;
-
-        std::map<TransportConnId, ConnectionContext> _connections;
+        std::shared_ptr<MoQInstanceDelegate> _delegate;
+        std::shared_ptr<ITransport> _transport; // **MUST** be last for proper order of destruction
     };
 
 } // namespace quicr
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index e8093847..1f31b868 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -113,16 +113,9 @@ namespace quicr {
          *
          * @param conn_id             Source connection ID
          * @param subscribe_id        Subscribe ID received
-         * @param name_space          Track Namespace from subscription
-         * @param name                Track name from subscription
-         *
-         * @return True if send announce should be sent, false if not
          */
-        virtual bool cb_unsubscribe([[maybe_unused]] TransportConnId conn_id,
-                                  [[maybe_unused]] uint64_t subscribe_id)
-        {
-            return true;
-        }
+        virtual void cb_unsubscribe([[maybe_unused]] TransportConnId conn_id,
+                                    [[maybe_unused]] uint64_t subscribe_id) {}
 
     };
 
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 278a6d47..14a4d09a 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -41,16 +41,17 @@ namespace quicr {
         enum class TrackReadStatus : uint8_t
         {
             OK = 0,
+            NOT_CONNECTED,
             SUBSCRIBE_ERROR,
             NOT_AUTHORIZED,
             NOT_SUBSCRIBED,
-            PENDING_SUBSCRIBE_RESPONSE,
-            SUBSCRIBE_NOT_AUTHORIZED
+            PENDING_SUBSCRIBE_RESPONSE
         };
 
         enum class TrackSendStatus : uint8_t
         {
             OK = 0,
+            NOT_CONNECTED,
             NOT_ANNOUNCED,
             PENDING_ANNOUNCE_RESPONSE,
             ANNOUNCE_NOT_AUTHORIZED,
@@ -104,18 +105,18 @@ namespace quicr {
          * @returns SendError status of the send
          *
          */
-        SendError sendObject(const uint64_t group_id, const uint64_t object_id, const std::span<const uint8_t>& object);
+        SendError sendObject(const uint64_t group_id, const uint64_t object_id, std::span<const uint8_t> object);
         SendError sendObject(const uint64_t group_id,
                              const uint64_t object_id,
-                             const std::span<const uint8_t>& object,
+                             std::span<const uint8_t> object,
                              uint32_t ttl);
         SendError sendObject(const uint64_t group_id,
                              const uint64_t object_id,
-                             const std::span<const uint8_t>& object,
+                             std::span<const uint8_t> object,
                              uint8_t priority);
         SendError sendObject(const uint64_t group_id,
                              const uint64_t object_id,
-                             const std::span<const uint8_t>& object,
+                             std::span<const uint8_t> object,
                              uint8_t priority,
                              uint32_t ttl);
 
@@ -295,7 +296,7 @@ namespace quicr {
                                 bool stream_header_needed,
                                 uint64_t group_id,
                                 uint64_t object_id,
-                                bytes&& data)> _mi_sendObjFunc;
+                                std::span<const uint8_t> data)> _mi_sendObjFunc;
 
         uint64_t _mi_send_data_ctx_id;    // Set by moq instance
         uint64_t _mi_conn_id;             // Set by moq instance
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 594722be..8e4b764e 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -17,11 +17,11 @@ namespace quicr {
         _client_mode(true)
         , _server_config({})
         , _client_config(cfg)
-        , _delegate(std::move(delegate))
         , _logger(std::make_shared<cantina::Logger>("MIC", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
 #endif
+        , _delegate(std::move(delegate))
         , _transport({})
     {
         _logger->info << "Created MoQ instance in client mode connecting to "
@@ -37,11 +37,11 @@ namespace quicr {
       : _client_mode(false)
       , _server_config(cfg)
       , _client_config({})
-      , _delegate(std::move(delegate))
       , _logger(std::make_shared<cantina::Logger>("MIS", logger))
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
         , _mexport(logger)
 #endif
+      , _delegate(std::move(delegate))
       , _transport({})
     {
         _logger->info << "Created MoQ instance in server mode listening on "
@@ -254,6 +254,25 @@ namespace quicr {
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
+    void MoQInstance::send_unsubscribe(ConnectionContext& conn_ctx,
+                                       uint64_t subscribe_id)
+    {
+        StreamBuffer<uint8_t> buffer;
+
+        auto unsubscribe  = MoqUnsubscribe {};
+        unsubscribe.subscribe_id = subscribe_id;
+        buffer << unsubscribe;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending UNSUBSCRIBE to conn_id: " << conn_ctx.conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+
     void MoQInstance::send_subscribe_error(ConnectionContext& conn_ctx,
                                            uint64_t subscribe_id,
                                            uint64_t track_alias,
@@ -322,9 +341,10 @@ namespace quicr {
                         auto ptd = getPubTrackDelegate(conn_ctx, th);
                         if (not ptd.has_value()) {
                             _logger->warning << "Received subscribe unknown publish track"
-                                          << " namespace hash: " << th.track_namespace_hash
-                                          << " name hash: " << th.track_name_hash
-                                          << std::flush;
+                                             << " conn_id:" << conn_ctx.conn_id
+                                             << " namespace hash: " << th.track_namespace_hash
+                                             << " name hash: " << th.track_name_hash
+                                             << std::flush;
 
                             send_subscribe_error(conn_ctx,
                                                  msg.subscribe_id,
@@ -348,6 +368,8 @@ namespace quicr {
                         ptd->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
                         ptd->lock()->cb_sendReady();
 
+                        conn_ctx.recv_sub_id[msg.subscribe_id] = { th.track_namespace_hash, th.track_name_hash };
+
                     } else { // Server mode
                         // TODO(tievens): add filter type when caching supports it
                         if (_delegate->cb_subscribe(conn_ctx.conn_id,
@@ -375,9 +397,10 @@ namespace quicr {
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
                         _logger->warning << "Received subscribe ok to unknown subscribe track"
-                                      << " subscribe_id: " << msg.subscribe_id
-                                      << " , ignored"
-                                      << std::flush;
+                                         << " conn_id:" << conn_ctx.conn_id
+                                         << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored"
+                                         << std::flush;
 
                         //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
                         stream_buffer->resetAny();
@@ -403,6 +426,7 @@ namespace quicr {
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
                         _logger->warning << "Received subscribe error to unknown subscribe_id"
+                                         << " conn_id:" << conn_ctx.conn_id
                                          << " subscribe_id: " << msg.subscribe_id
                                          << " , ignored"
                                          << std::flush;
@@ -451,7 +475,9 @@ namespace quicr {
                 if (*stream_buffer >> msg) {
                     auto tfn = TrackFullName{ msg.track_namespace, { } };
                     auto th = TrackHash(tfn);
-                    _logger->debug << "Received announce ok, namespace_hash: " << th.track_namespace_hash << std::flush;
+                    _logger->debug << "Received announce ok, "
+                                   << " conn_id:" << conn_ctx.conn_id
+                                   << " namespace_hash: " << th.track_namespace_hash << std::flush;
 
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
@@ -480,21 +506,35 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqUnsubscribe>();
                 if (*stream_buffer >> msg) {
-                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (!_client_mode) {
+                        auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                        if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                            _logger->warning << "Received unsubscribe to unknown subscribe_id"
+                                             << " conn_id:" << conn_ctx.conn_id << " subscribe_id: " << msg.subscribe_id
+                                             << " , ignored" << std::flush;
 
-                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
-                        _logger->warning << "Received unsubscribe to unknown subscribe_id"
-                                         << " subscribe_id: " << msg.subscribe_id
-                                         << " , ignored"
-                                         << std::flush;
+                            // TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                            stream_buffer->resetAny();
+                            return true;
+                        }
 
-                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
-                        stream_buffer->resetAny();
-                        return true;
-                    }
+                        _logger->debug << "Received unsubscribe conn_id: " << conn_ctx.conn_id
+                                       << " subscribe_id: " << msg.subscribe_id << std::flush;
+                        sub_it->second.get()->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
 
-                    sub_it->second.get()->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
-                    remove_subscribeTrack(conn_ctx, *sub_it->second);
+                        _delegate->cb_unsubscribe(conn_ctx.conn_id, msg.subscribe_id);
+
+                        remove_subscribeTrack(conn_ctx, *sub_it->second);
+                    } else {
+                        const auto& [name_space, name] = conn_ctx.recv_sub_id[msg.subscribe_id];
+                        TrackHash th(name_space, name);
+                        if (auto pdt = getPubTrackDelegate(conn_ctx, th)) {
+                            pdt->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
+                            pdt->lock()->cb_sendNotReady(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
+                        }
+
+                        conn_ctx.recv_sub_id.erase(msg.subscribe_id);
+                    }
 
                     stream_buffer->resetAny();
                     return true;
@@ -540,7 +580,9 @@ namespace quicr {
                                                        msg.endpoint_id_parameter.param_value,
                                                        TransportStatus::Ready);
 
-                        _logger->info << "Client setup received from: " << client_endpoint_id
+                        _logger->info << "Client setup received "
+                                      << " conn_id:" << conn_ctx.conn_id
+                                      << " from: " << client_endpoint_id
                                       << " num_versions: " << msg.num_versions
                                       << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
                                       << " version: 0x" << std::hex << msg.supported_versions.front()
@@ -579,6 +621,7 @@ namespace quicr {
                                TransportStatus::Ready);
 
                     _logger->info << "Server setup received"
+                                  << " conn_id:" << conn_ctx.conn_id
                                   << " from: " << server_endpoint_id
                                   << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
                                   << " selected_version: 0x" << std::hex << msg.selection_version
@@ -905,14 +948,14 @@ namespace quicr {
                                                                         bool stream_header_needed,
                                                                         uint64_t group_id,
                                                                         uint64_t object_id,
-                                                                        bytes&& data) -> MoQTrackDelegate::SendError {
+                                                                        std::span<uint8_t const> data) -> MoQTrackDelegate::SendError {
             return send_object(track_delegate,
                                priority,
                                ttl,
                                stream_header_needed,
                                group_id,
                                object_id,
-                               std::move(data));
+                               data);
         };
 
 
@@ -922,11 +965,14 @@ namespace quicr {
     void MoQInstance::unsubscribeTrack(qtransport::TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate)
     {
         auto& conn_ctx = _connections[conn_id];
+        if (track_delegate->getSubscribeId().has_value()) {
+            send_unsubscribe(conn_ctx, *track_delegate->getSubscribeId());
+        }
         remove_subscribeTrack(conn_ctx,*track_delegate);
     }
 
     void MoQInstance::remove_subscribeTrack(ConnectionContext& conn_ctx,
-                                          MoQTrackDelegate& delegate)
+                                          MoQTrackDelegate& delegate, bool remove_delegate)
     {
         delegate.setReadStatus(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
         delegate.setSubscribeId(std::nullopt);
@@ -934,10 +980,14 @@ namespace quicr {
         auto subscribe_id = delegate.getSubscribeId();
         if (subscribe_id.has_value()) {
 
-            std::lock_guard<std::mutex> _(_state_mutex);
+            send_unsubscribe(conn_ctx, *subscribe_id);
+
             _logger->debug << "remove subscribe id: " << *subscribe_id << std::flush;
 
-            conn_ctx.tracks_by_sub_id.erase(*subscribe_id);
+            if (remove_delegate) {
+                std::lock_guard<std::mutex> _(_state_mutex);
+                conn_ctx.tracks_by_sub_id.erase(*subscribe_id);
+            }
         }
     }
 
@@ -1011,14 +1061,14 @@ namespace quicr {
                                                             bool stream_header_needed,
                                                             uint64_t group_id,
                                                             uint64_t object_id,
-                                                            bytes&& data) -> MoQTrackDelegate::SendError {
+                                                            std::span<const uint8_t> data) -> MoQTrackDelegate::SendError {
             return send_object(track_delegate,
                                priority,
                                ttl,
                                stream_header_needed,
                                group_id,
                                object_id,
-                               std::move(data));
+                               data);
         };
 
         return th.track_fullname_hash;
@@ -1030,7 +1080,7 @@ namespace quicr {
                                                          bool stream_header_needed,
                                                          uint64_t group_id,
                                                          uint64_t object_id,
-                                                         bytes&& data)
+                                                         std::span<const uint8_t> data)
     {
 
         auto td = track_delegate.lock();
@@ -1055,7 +1105,7 @@ namespace quicr {
                 object.priority = priority;
                 object.subscribe_id = *td->getSubscribeId();
                 object.track_alias = *td->getTrackAlias();
-                object.payload = std::move(data);
+                object.payload.assign(data.begin(), data.end());
                 buffer << object;
                 break;
             }
@@ -1069,7 +1119,7 @@ namespace quicr {
                 object.priority = priority;
                 object.subscribe_id = *td->getSubscribeId();
                 object.track_alias = *td->getTrackAlias();
-                object.payload = std::move(data);
+                object.payload.assign(data.begin(), data.end());
                 buffer << object;
 
                 break;
@@ -1093,7 +1143,7 @@ namespace quicr {
 
                 MoqStreamGroupObject object;
                 object.object_id = object_id;
-                object.payload = std::move(data);
+                object.payload.assign(data.begin(), data.end());
                 buffer << object;
 
                 break;
@@ -1114,7 +1164,7 @@ namespace quicr {
                 MoqStreamTrackObject object;
                 object.group_id = group_id;
                 object.object_id = object_id;
-                object.payload = std::move(data);
+                object.payload.assign(data.begin(), data.end());
                 buffer << object;
 
                 break;
@@ -1159,20 +1209,67 @@ namespace quicr {
                        << " status: " << static_cast<int>(status)
                        << std::flush;
 
-        if (_client_mode && status == TransportStatus::Ready) {
-            auto& conn_ctx = _connections[conn_id];
-            _logger->info << "Connection established, creating bi-dir stream and sending CLIENT_SETUP" << std::flush;
+        switch (status) {
+            case TransportStatus::Ready: {
+                if (_client_mode) {
+                    auto& conn_ctx = _connections[conn_id];
+                    _logger->info << "Connection established, creating bi-dir stream and sending CLIENT_SETUP"
+                                  << std::flush;
 
-            conn_ctx.ctrl_data_ctx_id = _transport->createDataContext(conn_id, true, 0, true);
+                    conn_ctx.ctrl_data_ctx_id = _transport->createDataContext(conn_id, true, 0, true);
 #ifndef LIBQUICR_WITHOUT_INFLUXDB
-            _mexport.set_data_ctx_info(conn_ctx.conn_id, *conn_ctx.ctrl_data_ctx_id,
-                                       {.subscribe = false, .nspace = {}});
+                    _mexport.set_data_ctx_info(
+                      conn_ctx.conn_id, *conn_ctx.ctrl_data_ctx_id, { .subscribe = false, .nspace = {} });
 #endif
 
-            send_client_setup();
-        }
+                    send_client_setup();
+                    _status = Status::READY;
+                }
+            }
+
+            case TransportStatus::Connecting:
+                _status = Status::CLIENT_CONNECTING;
+                break;
+            case TransportStatus::RemoteRequestClose:
+                [[fallthrough]];
+
+            case TransportStatus::Disconnected: {
+
+                // Clean up publish and subscribe tracks
+                std::lock_guard<std::mutex> _(_state_mutex);
+                auto conn_it = _connections.find(conn_id);
+
+                if (conn_it == _connections.end()) {
+                    return;
+                }
 
-        _status = Status::READY;
+                for (const auto& [sub_id, delegate] : conn_it->second.tracks_by_sub_id) {
+                    delegate->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
+                    _delegate->cb_unsubscribe(conn_id, sub_id);
+                    remove_subscribeTrack(conn_it->second, *delegate);
+                }
+
+                for (const auto& [name_space, track] : conn_it->second.recv_sub_id) {
+                    TrackHash th(track.first, track.second);
+                    if (auto pdt = getPubTrackDelegate(conn_it->second, th)) {
+                        pdt->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
+                        pdt->lock()->cb_sendNotReady(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
+                    }
+                }
+
+                conn_it->second.recv_sub_id.clear();
+                conn_it->second.tracks_by_sub_id.clear();
+
+                // TODO(tievens): Clean up publish tracks
+
+                _connections.erase(conn_it);
+
+                break;
+            }
+            case TransportStatus::Shutdown:
+                _status = Status::NOT_READY;
+                break;
+        }
     }
 
     void MoQInstance::on_new_connection(const TransportConnId& conn_id, const TransportRemote& remote)
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index ee4080e0..9f44ed34 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -860,7 +860,6 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqObjectDatagram &ms
 }
 
 
-
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqStreamHeaderTrack& msg){
 
diff --git a/src/moq_track_delegate_base.cpp b/src/moq_track_delegate_base.cpp
index 285bd21b..5a98371e 100644
--- a/src/moq_track_delegate_base.cpp
+++ b/src/moq_track_delegate_base.cpp
@@ -12,14 +12,14 @@ namespace quicr {
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
                                                              [[maybe_unused]] const uint64_t object_id,
-                                                             [[maybe_unused]] const std::span<const uint8_t>& object)
+                                                             [[maybe_unused]] std::span<const uint8_t> object)
     {
         return sendObject(group_id, object_id, object, _def_priority, _def_ttl);
     }
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
                                                              [[maybe_unused]] const uint64_t object_id,
-                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] std::span<const uint8_t> object,
                                                              [[maybe_unused]] uint32_t ttl)
     {
         return sendObject(group_id, object_id, object, _def_priority, ttl);
@@ -27,7 +27,7 @@ namespace quicr {
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
                                                              [[maybe_unused]] const uint64_t object_id,
-                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] std::span<const uint8_t> object,
                                                              [[maybe_unused]] uint8_t priority)
     {
 
@@ -36,12 +36,10 @@ namespace quicr {
 
     MoQTrackDelegate::SendError MoQTrackDelegate::sendObject([[maybe_unused]] const uint64_t  group_id,
                                                              [[maybe_unused]] const uint64_t object_id,
-                                                             [[maybe_unused]] const std::span<const uint8_t>& object,
+                                                             [[maybe_unused]] std::span<const uint8_t> object,
                                                              [[maybe_unused]] uint8_t priority,
                                                              [[maybe_unused]] uint32_t ttl)
     {
-        std::vector<uint8_t> data_copy(object.begin(), object.end());
-
         bool is_stream_header_needed{ false };
         switch (_mi_track_mode) {
             case TrackMode::DATAGRAM:
@@ -63,7 +61,7 @@ namespace quicr {
         _prev_group_id = group_id;
 
         if (_mi_sendObjFunc != nullptr) {
-            return _mi_sendObjFunc(priority, ttl, is_stream_header_needed, group_id, object_id, std::move(data_copy));
+            return _mi_sendObjFunc(priority, ttl, is_stream_header_needed, group_id, object_id, object);
         } else {
             return SendError::INTERNAL_ERROR;
         }

From c2a18bdf51eaa99e0913cd28b6eb3149d40c3ea1 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 12:02:38 -0700
Subject: [PATCH 60/71] Complete MOQT implementation, implemented...

* Unannounce
* Unsubscribe
* Subscribe done
* Announce Cancel
* Subscribe Error
* Announce Error
* Track Status
* Track Status Request
* Goaway
---
 cmd/moq-example/client.cpp            |   4 +
 cmd/moq-example/server.cpp            |  51 ++++-
 include/quicr/moq_instance.h          |  12 +
 include/quicr/moq_instance_delegate.h |  11 +
 include/quicr/moq_messages.h          |  36 +++
 include/quicr/moq_track_delegate.h    |   2 +
 src/moq_instance.cpp                  | 303 ++++++++++++++++++++++----
 src/moq_messages.cpp                  | 108 +++++++++
 8 files changed, 480 insertions(+), 47 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 20448d2a..a6ce58bd 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -184,6 +184,9 @@ void do_publisher(const std::string t_namespace,
         auto result = track_delegate->sendObject(group_id, object_id++, msg_v);
     }
 
+    mi->unpublishTrack(*qclient_vars::conn_id, track_delegate);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
     _logger->info << "Publisher done track: " << t_namespace << "/" << t_name << std::flush;
 }
 
@@ -372,6 +375,7 @@ main(int argc, char* argv[])
         moqInstance->stop();
 
         logger->info << "Client done" << std::endl;
+        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
 
         // Unlock the mutex
         lock.unlock();
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 35fbbb16..6f28a783 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -168,6 +168,45 @@ class serverDelegate : public quicr::MoQInstanceDelegate
                           const std::span<uint8_t>& endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
 
+    void cb_unannounce(qtransport::TransportConnId conn_id,
+                       uint64_t track_namespace_hash,
+                       std::optional<uint64_t> track_name_hash) {
+
+        if (track_name_hash.has_value()) { // subscribe done received
+            _logger->info << "Received subscribe done from conn_id: " << conn_id
+                           << "  for namespace hash: " << track_namespace_hash
+                           << " name hash: " << *track_name_hash
+                           << ", informational update only"
+                           << std::flush;
+        } else {
+            _logger->debug << "Received unannounce from conn_id: " << conn_id
+                           << "  for namespace hash: " << track_namespace_hash
+                           << ", removing all tracks associated with namespace"
+                           << std::flush;
+
+            for (auto track_alias: qserver_vars::announce_active[track_namespace_hash][conn_id]) {
+                auto ptd = qserver_vars::pub_subscribes[track_alias][conn_id];
+                if (ptd != nullptr) {
+                    _logger->info << "Received unannounce from conn_id: " << conn_id
+                                  << "  for namespace hash: " << track_namespace_hash
+                                  << ", removing track alias: " << track_alias
+                                  << std::flush;
+
+                    _moq_instance.lock()->unsubscribeTrack(conn_id, ptd);
+                }
+                qserver_vars::pub_subscribes[track_alias].erase(conn_id);
+                if (qserver_vars::pub_subscribes[track_alias].empty()) {
+                    qserver_vars::pub_subscribes.erase(track_alias);
+                }
+            }
+
+            qserver_vars::announce_active[track_namespace_hash].erase(conn_id);
+            if (qserver_vars::announce_active[track_namespace_hash].empty()) {
+                qserver_vars::announce_active.erase(track_namespace_hash);
+            }
+        }
+    }
+
     bool cb_announce(qtransport::TransportConnId conn_id,
                      uint64_t track_namespace_hash) override {
 
@@ -192,7 +231,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     void cb_announce_post(qtransport::TransportConnId conn_id,
                           uint64_t track_namespace_hash) override {
 
-        auto anno_conn_it = qserver_vars::announce_active[track_namespace_hash].find(conn_id);
+         auto& anno_tracks = qserver_vars::announce_active[track_namespace_hash][conn_id];
 
         // Check if there are any subscribes. If so, send subscribe to announce for all tracks matching namespace
         const auto sub_active_it = qserver_vars::subscribe_active.find(track_namespace_hash);
@@ -200,12 +239,12 @@ class serverDelegate : public quicr::MoQInstanceDelegate
             for (const auto& [track_name, who]: sub_active_it->second) {
                 if (who.size()) { // Have subscribes
                     auto& a_who = *who.begin();
-                    if (!anno_conn_it->second.contains(track_name)) {
+                    if (!anno_tracks.contains(a_who.track_alias)) {
                         _logger->info << "Sending subscribe to announcer conn_id: " << conn_id
                                       << " subscribe track_alias: " << a_who.track_alias
                                       << std::flush;
 
-                        anno_conn_it->second.insert(track_name); // Add track to state
+                        anno_tracks.insert(a_who.track_alias); // Add track to state
 
                         const auto sub_track_delegate = qserver_vars::subscribes[a_who.track_alias][a_who.conn_id];
                         std::string t_namespace {sub_track_delegate->getTrackNamespace().begin(), sub_track_delegate->getTrackNamespace().end()};
@@ -364,12 +403,12 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         }
 
         for (auto& [conn_id, tracks]: anno_ns_it->second) {
-            if (!tracks.contains(th.track_name_hash)) {
+            if (!tracks.contains(th.track_fullname_hash)) {
                 _logger->info << "Sending subscribe to announcer conn_id: " << conn_id
-                              << " subscribe track_alias: " << th.track_name_hash
+                              << " subscribe track_alias: " << th.track_fullname_hash
                               << std::flush;
 
-                tracks.insert(th.track_name_hash); // Add track alias to state
+                tracks.insert(th.track_fullname_hash); // Add track alias to state
 
                 auto pub_track_delegate = std::make_shared<subTrackDelegate>(t_namespace, t_name, 2, 3000, _logger);
                 _moq_instance.lock()->subscribeTrack(conn_id, pub_track_delegate);
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 51414edf..49250074 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -166,6 +166,14 @@ namespace quicr {
          */
         std::optional<uint64_t> publishTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
 
+        /**
+         * @brief Unpublish track
+         *
+         * @param track_delegate    Track delegate used when published track
+         */
+        void unpublishTrack(TransportConnId conn_id, std::shared_ptr<MoQTrackDelegate> track_delegate);
+
+
         /**
          * @brief Make client connection and run
          *
@@ -255,12 +263,16 @@ namespace quicr {
         void send_server_setup(ConnectionContext& conn_ctx);
         void send_announce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
         void send_announce_ok(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
+        void send_unannounce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace);
         void send_subscribe(ConnectionContext& conn_ctx, uint64_t subscribe_id, TrackFullName& tfn, TrackHash th);
         void send_subscribe_ok(ConnectionContext& conn_ctx,
                                uint64_t subscribe_id,
                                uint64_t expires,
                                bool content_exists);
         void send_unsubscribe(ConnectionContext& conn_ctx, uint64_t subscribe_id);
+        void send_subscribe_done(ConnectionContext& conn_ctx,
+                                 uint64_t subscribe_id,
+                                 const std::string& reason);
         void send_subscribe_error(ConnectionContext& conn_ctx,
                                   uint64_t subscribe_id,
                                   uint64_t track_alias,
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 1f31b868..d1c55e5e 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -90,6 +90,17 @@ namespace quicr {
         virtual void cb_announce_post([[maybe_unused]] TransportConnId conn_id,
                                       [[maybe_unused]] uint64_t track_namespace_hash) { }
 
+        /**
+         * @brief Server Mode; Callback notification for unannounce received
+         *
+         * @param conn_id                   Source connection ID
+         * @param track_namespace_hash      Track namespace hash
+         * @param track_name_hash           Track name is present if subscribe DONE was received
+         *                                  Otherwise, it will be nullopt for received UNANNOUNCE
+         */
+        virtual void cb_unannounce([[maybe_unused]] TransportConnId conn_id,
+                                   [[maybe_unused]] uint64_t track_namespace_hash,
+                                   [[maybe_unused]] std::optional<uint64_t> track_name_hash) { }
         /**
          * @brief Callback notification for new subscribe received
          *
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 4c665ca0..2b41ed00 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -226,6 +226,42 @@ struct MoqSubscribeDone
   size_t MAX_FIELDS = {6};
 };
 
+//
+// Track Status
+//
+struct MoqTrackStatusRequest {
+    TrackNamespace track_namespace;
+    TrackName track_name;
+    friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqTrackStatusRequest &msg);
+    friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                         const MoqTrackStatusRequest& msg);
+  private:
+    size_t current_pos {0};
+    bool parsing_completed { false };
+};
+
+enum class TrackStatus : uint64_t {
+    IN_PROGRESS=0x00,
+    DOES_NOT_EXIST,
+    NOT_STARTED,
+    FINISHED,
+    UNKNOWN
+};
+struct MoqTrackStatus {
+    TrackNamespace track_namespace;
+    TrackName track_name;
+    TrackStatus status_code;
+    uint64_t last_group_id {0};
+    uint64_t last_object_id {0};
+    friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqTrackStatus &msg);
+    friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                                         const MoqTrackStatus& msg);
+  private:
+    size_t current_pos {0};
+    bool parsing_completed { false };
+};
+
+
 //
 // Announce
 //
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 14a4d09a..ca46ac5d 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -268,12 +268,14 @@ namespace quicr {
          * @param status                Status of sending (aka publish objects)
          */
         void setSendStatus(TrackSendStatus status) { _send_status = status; }
+        TrackSendStatus getSendStatus() { return _send_status; }
 
         /**
          * @brief Set the read status
          * @param status                Status of reading (aka subscribe)
          */
         void setReadStatus(TrackReadStatus status) { _read_status = status; }
+        TrackReadStatus getReadStatus() { return _read_status; }
 
         // --------------------------------------------------------------------------
         // MOQ Instance specific public variables/methods - Caller should not use these
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 8e4b764e..3e402a44 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -204,6 +204,21 @@ namespace quicr {
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
+    void MoQInstance::send_unannounce(ConnectionContext& conn_ctx, std::span<uint8_t const> track_namespace)
+    {
+        StreamBuffer<uint8_t> buffer;
+        auto unannounce = MoqUnannounce{};
+
+        unannounce.track_namespace.assign(track_namespace.begin(), track_namespace.end());
+        buffer <<  unannounce;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending UNANNOUNCE to conn_id: " << conn_ctx.conn_id << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
     void MoQInstance::send_subscribe(ConnectionContext& conn_ctx,
                                      uint64_t subscribe_id,
                                      TrackFullName& tfn,
@@ -254,6 +269,28 @@ namespace quicr {
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
     }
 
+    void MoQInstance::send_subscribe_done(ConnectionContext& conn_ctx,
+                                          uint64_t subscribe_id,
+                                          const std::string& reason)
+    {
+        StreamBuffer<uint8_t> buffer;
+
+        auto subscribe_done  = MoqSubscribeDone {};
+        subscribe_done.subscribe_id = subscribe_id;
+        subscribe_done.reason_phrase.assign(reason.begin(), reason.end());
+        subscribe_done.content_exists = false;
+        buffer << subscribe_done;
+
+        std::vector<uint8_t> net_data = buffer.front(buffer.size());
+
+        _logger->debug << "Sending SUBSCRIBE DONE to conn_id: " << conn_ctx.conn_id
+                       << " subscribe_id: " << subscribe_id
+                       << std::flush;
+
+        send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
+    }
+
+
     void MoQInstance::send_unsubscribe(ConnectionContext& conn_ctx,
                                        uint64_t subscribe_id)
     {
@@ -333,18 +370,17 @@ namespace quicr {
                     auto th = TrackHash(tfn);
 
                     if (msg.subscribe_id > conn_ctx._sub_id) {
-                        conn_ctx._sub_id = msg.subscribe_id+1;
+                        conn_ctx._sub_id = msg.subscribe_id + 1;
                     }
 
                     // For client/publisher, notify track that there is a subscriber
                     if (_client_mode) {
                         auto ptd = getPubTrackDelegate(conn_ctx, th);
                         if (not ptd.has_value()) {
-                            _logger->warning << "Received subscribe unknown publish track"
-                                             << " conn_id:" << conn_ctx.conn_id
-                                             << " namespace hash: " << th.track_namespace_hash
-                                             << " name hash: " << th.track_name_hash
-                                             << std::flush;
+                            _logger->warning
+                              << "Received subscribe unknown publish track" << " conn_id:" << conn_ctx.conn_id
+                              << " namespace hash: " << th.track_namespace_hash << " name hash: " << th.track_name_hash
+                              << std::flush;
 
                             send_subscribe_error(conn_ctx,
                                                  msg.subscribe_id,
@@ -360,7 +396,8 @@ namespace quicr {
                                        << " recv subscribe_id: " << msg.subscribe_id
                                        << ", setting send"
                                           ""
-                                          " state to ready" << std::flush;
+                                          " state to ready"
+                                       << std::flush;
 
                         // Indicate send is ready upon subscribe
                         // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
@@ -372,10 +409,7 @@ namespace quicr {
 
                     } else { // Server mode
                         // TODO(tievens): add filter type when caching supports it
-                        if (_delegate->cb_subscribe(conn_ctx.conn_id,
-                                                    msg.subscribe_id,
-                                                    tfn.name_space,
-                                                    tfn.name)) {
+                        if (_delegate->cb_subscribe(conn_ctx.conn_id, msg.subscribe_id, tfn.name_space, tfn.name)) {
                             send_subscribe_ok(conn_ctx, msg.subscribe_id, MOQT_SUBSCRIBE_EXPIRES, false);
                         }
                     }
@@ -397,12 +431,10 @@ namespace quicr {
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
                         _logger->warning << "Received subscribe ok to unknown subscribe track"
-                                         << " conn_id:" << conn_ctx.conn_id
-                                         << " subscribe_id: " << msg.subscribe_id
-                                         << " , ignored"
-                                         << std::flush;
+                                         << " conn_id:" << conn_ctx.conn_id << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored" << std::flush;
 
-                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        // TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
                         stream_buffer->resetAny();
                         return true;
                     }
@@ -426,12 +458,10 @@ namespace quicr {
 
                     if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
                         _logger->warning << "Received subscribe error to unknown subscribe_id"
-                                         << " conn_id:" << conn_ctx.conn_id
-                                         << " subscribe_id: " << msg.subscribe_id
-                                         << " , ignored"
-                                         << std::flush;
+                                         << " conn_id:" << conn_ctx.conn_id << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored" << std::flush;
 
-                        //TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        // TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
                         stream_buffer->resetAny();
                         return true;
                     }
@@ -452,7 +482,7 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqAnnounce>();
                 if (*stream_buffer >> msg) {
-                    auto tfn = TrackFullName{ msg.track_namespace, { } };
+                    auto tfn = TrackFullName{ msg.track_namespace, {} };
                     auto th = TrackHash(tfn);
 
                     if (_delegate->cb_announce(conn_ctx.conn_id, th.track_namespace_hash)) {
@@ -473,15 +503,14 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqAnnounceOk>();
                 if (*stream_buffer >> msg) {
-                    auto tfn = TrackFullName{ msg.track_namespace, { } };
+                    auto tfn = TrackFullName{ msg.track_namespace, {} };
                     auto th = TrackHash(tfn);
-                    _logger->debug << "Received announce ok, "
-                                   << " conn_id:" << conn_ctx.conn_id
+                    _logger->debug << "Received announce ok, " << " conn_id:" << conn_ctx.conn_id
                                    << " namespace_hash: " << th.track_namespace_hash << std::flush;
 
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
-                    for (const auto& td: pub_it->second) {
+                    for (const auto& td : pub_it->second) {
                         if (td.second.get()->statusSend() != MoQTrackDelegate::TrackSendStatus::OK)
                             td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
                     }
@@ -494,11 +523,30 @@ namespace quicr {
             case MoQMessageType::ANNOUNCE_ERROR:
                 _logger->debug << "Received announce error " << std::flush;
                 break;
-            case MoQMessageType::UNANNOUNCE:
-                _logger->debug << "Received unannounce" << std::flush;
+
+            case MoQMessageType::UNANNOUNCE: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received unannounce, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqUnannounce>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqUnannounce>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, {} };
+                    auto th = TrackHash(tfn);
+
+                    _logger->info << "Received unannounce for namespace_hash: " << th.track_namespace_hash
+                                  << std::flush;
+
+                    _delegate->cb_unannounce(conn_ctx.conn_id, th.track_namespace_hash, std::nullopt);
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
                 break;
-            case MoQMessageType::UNSUBSCRIBE:
-            {
+            }
+            case MoQMessageType::UNSUBSCRIBE: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received unsubscribe, init stream buffer" << std::flush;
                     stream_buffer->initAny<MoqUnsubscribe>();
@@ -540,24 +588,127 @@ namespace quicr {
                     return true;
                 }
 
-
                 break;
             }
-            case MoQMessageType::SUBSCRIBE_DONE:
-                _logger->debug << "Received subscribe done" << std::flush;
+            case MoQMessageType::SUBSCRIBE_DONE: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received subscribe done, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqSubscribeDone>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqSubscribeDone>();
+                if (*stream_buffer >> msg) {
+                    auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
+                    if (sub_it == conn_ctx.tracks_by_sub_id.end()) {
+                        _logger->warning << "Received subscribe done to unknown subscribe_id"
+                                         << " conn_id:" << conn_ctx.conn_id << " subscribe_id: " << msg.subscribe_id
+                                         << " , ignored" << std::flush;
+
+                        // TODO(tievens): Draft doesn't indicate what to do in this case, which can happen due to race condition
+                        stream_buffer->resetAny();
+                        return true;
+                    }
+                    auto tfn = TrackFullName{ sub_it->second->getTrackNamespace(), sub_it->second->getTrackNamespace() };
+                    auto th = TrackHash(tfn);
+
+                    _logger->debug << "Received subscribe done conn_id: " << conn_ctx.conn_id
+                                   << " subscribe_id: " << msg.subscribe_id
+                                   << " track namespace hash: " << th.track_namespace_hash
+                                   << " name hash: " << th.track_name_hash
+                                   << " track alias: " << th.track_fullname_hash
+                                   << std::flush;
+
+                    sub_it->second.get()->cb_readNotReady(MoQTrackDelegate::TrackReadStatus::NOT_SUBSCRIBED);
+                    _delegate->cb_unannounce(conn_ctx.conn_id, th.track_namespace_hash, th.track_name_hash);
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
                 break;
-            case MoQMessageType::ANNOUNCE_CANCEL:
-                _logger->debug << "Received announce cancel" << std::flush;
+            }
+            case MoQMessageType::ANNOUNCE_CANCEL: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received announce cancel, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqAnnounceCancel>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqAnnounceCancel>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, {} };
+                    auto th = TrackHash(tfn);
+
+                    _logger->info << "Received announce cancel for namespace_hash: " << th.track_namespace_hash
+                                  << std::flush;
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
                 break;
-            case MoQMessageType::TRACK_STATUS_REQUEST:
-                _logger->debug << "Received track status request" << std::flush;
+            }
+            case MoQMessageType::TRACK_STATUS_REQUEST: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received track status request, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqTrackStatusRequest>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqTrackStatusRequest>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, msg.track_name };
+                    auto th = TrackHash(tfn);
+
+                    _logger->info << "Received track status request for "
+                                  << " namespace_hash: " << th.track_namespace_hash
+                                  << " name_hash: " << th.track_name_hash
+                                  << std::flush;
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
                 break;
-            case MoQMessageType::TRACK_STATUS:
-                _logger->debug << "Received track status" << std::flush;
+            }
+            case MoQMessageType::TRACK_STATUS: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received track status, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqTrackStatus>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqTrackStatus>();
+                if (*stream_buffer >> msg) {
+                    auto tfn = TrackFullName{ msg.track_namespace, msg.track_name };
+                    auto th = TrackHash(tfn);
+
+                    _logger->info << "Received track status for "
+                                  << " namespace_hash: " << th.track_namespace_hash
+                                  << " name_hash: " << th.track_name_hash
+                                  << std::flush;
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
                 break;
-            case MoQMessageType::GOWAY:
-                _logger->debug << "Received goaway" << std::flush;
+            }
+            case MoQMessageType::GOWAY: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received goaway, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqGoaway>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqGoaway>();
+                if (*stream_buffer >> msg) {
+                    std::string new_sess_uri(msg.new_session_uri.begin(), msg.new_session_uri.end());
+                    _logger->info << "Received goaway "
+                                  << " new session uri: " << new_sess_uri
+                                  << std::flush;
+
+                    stream_buffer->resetAny();
+                    return true;
+                }
+
                 break;
+            }
             case MoQMessageType::CLIENT_SETUP: {
                     if (not stream_buffer->anyHasValue()) {
                         _logger->debug << "Received client setup, init stream buffer" << std::flush;
@@ -984,6 +1135,14 @@ namespace quicr {
 
             _logger->debug << "remove subscribe id: " << *subscribe_id << std::flush;
 
+            _transport->deleteDataContext(conn_ctx.conn_id, delegate._mi_send_data_ctx_id);
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+            _mexport.del_data_ctx_info(conn_ctx.conn_id, delegate._mi_send_data_ctx_id);
+#endif
+            delegate._mi_send_data_ctx_id = 0;
+
+
             if (remove_delegate) {
                 std::lock_guard<std::mutex> _(_state_mutex);
                 conn_ctx.tracks_by_sub_id.erase(*subscribe_id);
@@ -991,6 +1150,65 @@ namespace quicr {
         }
     }
 
+    void MoQInstance::unpublishTrack(TransportConnId conn_id,
+                                     std::shared_ptr<MoQTrackDelegate> track_delegate) {
+
+        // Generate track alias
+        auto tfn = TrackFullName{ track_delegate->getTrackNamespace(), track_delegate->getTrackName() };
+        auto th = TrackHash(tfn);
+
+        _logger->info << "Unpublish track conn_id: " << conn_id
+                      << " hash: " << th.track_fullname_hash << std::flush;
+
+        std::lock_guard<std::mutex> _(_state_mutex);
+
+        auto conn_it = _connections.find(conn_id);
+        if (conn_it == _connections.end()) {
+            _logger->error << "Unpublish track conn_id: " << conn_id << " does not exist." << std::flush;
+            return;
+        }
+
+        // Check if this published track is a new namespace or existing.
+        auto pub_ns_it = conn_it->second.pub_tracks_by_name.find(th.track_namespace_hash);
+        if (pub_ns_it != conn_it->second.pub_tracks_by_name.end()) {
+            auto pub_n_it = pub_ns_it->second.find(th.track_name_hash);
+            if (pub_n_it != pub_ns_it->second.end()) {
+
+                // Send subscribe done if track has subscriber and is sending
+                if (pub_n_it->second->getSendStatus() == MoQTrackDelegate::TrackSendStatus::OK
+                    && pub_n_it->second->getSubscribeId().has_value()) {
+                    _logger->info << "Unpublish track namespace hash: " << th.track_namespace_hash
+                                  << " track_name_hash: " << th.track_name_hash
+                                  << " track_alias: " << th.track_fullname_hash
+                                  << ", sending subscribe_done"
+                                  << std::flush;
+                    send_subscribe_done(conn_it->second, *pub_n_it->second->getSubscribeId(), "Unpublish track");
+                } else {
+                    _logger->info << "Unpublish track namespace hash: " << th.track_namespace_hash
+                                  << " track_name_hash: " << th.track_name_hash
+                                  << " track_alias: " << th.track_fullname_hash
+                                  << std::flush;
+                }
+
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+                _mexport.del_data_ctx_info(conn_id, track_delegate->_mi_send_data_ctx_id);
+#endif
+                pub_n_it->second->_mi_send_data_ctx_id = 0;
+
+                pub_n_it->second->setSendStatus(MoQTrackDelegate::TrackSendStatus::NOT_ANNOUNCED);
+                pub_ns_it->second.erase(pub_n_it);
+            }
+
+            if (!pub_ns_it->second.size()) {
+                _logger->info << "Unpublish namespace hash: " << th.track_namespace_hash
+                              << ", has no tracks, sending unannounce" << std::flush;
+                send_unannounce(conn_it->second, track_delegate->getTrackNamespace());
+                conn_it->second.pub_tracks_by_name.erase(pub_ns_it);
+            }
+        }
+    }
+
+
     std::optional<uint64_t> MoQInstance::publishTrack(TransportConnId conn_id,
                                          std::shared_ptr<MoQTrackDelegate> track_delegate) {
 
@@ -1262,6 +1480,9 @@ namespace quicr {
 
                 // TODO(tievens): Clean up publish tracks
 
+#ifndef LIBQUICR_WITHOUT_INFLUXDB
+                _mexport.del_conn_ctx_info(conn_id);
+#endif
                 _connections.erase(conn_it);
 
                 break;
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 9f44ed34..11fb2bbc 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -104,6 +104,114 @@ MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
   return buffer;
 }
 
+//
+// Track Status
+//
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                              const MoqTrackStatus& msg) {
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::TRACK_STATUS)));
+    buffer.push_lv(msg.track_namespace);
+    buffer.push_lv(msg.track_name);
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.status_code)));
+    buffer.push(qtransport::to_uintV(msg.last_group_id));
+    buffer.push(qtransport::to_uintV(msg.last_object_id));
+
+    return buffer;
+}
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqTrackStatus &msg) {
+
+    switch (msg.current_pos) {
+        case 0: {
+            if(!parse_bytes_field(buffer, msg.track_namespace)) {
+                return false;
+            }
+            msg.current_pos += 1;
+            [[fallthrough]];
+        }
+        case 1: {
+            if(!parse_bytes_field(buffer, msg.track_name)) {
+                return false;
+            }
+            msg.current_pos += 1;
+            [[fallthrough]];
+        }
+        case 2: {
+            const auto val = buffer.decode_uintV();
+            if (!val) {
+                return false;
+            }
+            msg.status_code = static_cast<TrackStatus>(*val);
+            msg.current_pos += 1;
+            [[fallthrough]];
+        }
+        case 3: {
+            if (!parse_uintV_field(buffer, msg.last_group_id)) {
+                return false;
+            }
+            msg.current_pos += 1;
+
+            [[fallthrough]];
+        }
+        case 4: {
+            if (!parse_uintV_field(buffer, msg.last_object_id)) {
+                return false;
+            }
+            msg.current_pos += 1;
+
+            msg.parsing_completed = true;
+
+            [[fallthrough]];
+        }
+        default:
+            break;
+    }
+
+    if (!msg.parsing_completed ) {
+        return false;
+    }
+
+    return true;
+}
+
+qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
+                                              const MoqTrackStatusRequest& msg){
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::TRACK_STATUS_REQUEST)));
+    buffer.push_lv(msg.track_namespace);
+    buffer.push_lv(msg.track_name);
+
+    return buffer;
+}
+
+bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqTrackStatusRequest &msg) {
+
+    switch (msg.current_pos) {
+        case 0: {
+            if (!parse_bytes_field(buffer, msg.track_namespace)) {
+                return false;
+            }
+            msg.current_pos += 1;
+            [[fallthrough]];
+        }
+        case 1: {
+            if (!parse_bytes_field(buffer, msg.track_name)) {
+                return false;
+            }
+            msg.current_pos += 1;
+            msg.parsing_completed = true;
+            [[fallthrough]];
+        }
+        default:
+            break;
+    }
+
+    if (!msg.parsing_completed ) {
+        return false;
+    }
+
+    return true;
+}
+
 
 //
 // Subscribe

From 1e327b56e1494d6dd7fa890a6e1b9ce00fa65068 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 12:10:51 -0700
Subject: [PATCH 61/71] Implement announce error

---
 src/moq_instance.cpp | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index 3e402a44..e0e5a4ad 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -520,10 +520,34 @@ namespace quicr {
                 }
                 break;
             }
-            case MoQMessageType::ANNOUNCE_ERROR:
-                _logger->debug << "Received announce error " << std::flush;
-                break;
+            case MoQMessageType::ANNOUNCE_ERROR: {
+                if (not stream_buffer->anyHasValue()) {
+                    _logger->debug << "Received announce error, init stream buffer" << std::flush;
+                    stream_buffer->initAny<MoqAnnounceError>();
+                }
+
+                auto& msg = stream_buffer->getAny<MoqAnnounceError>();
+                if (*stream_buffer >> msg) {
+                    if (msg.track_namespace) {
+                        std::string reason = "unknown";
+                        auto tfn = TrackFullName{ *msg.track_namespace, {} };
+                        auto th = TrackHash(tfn);
+
+                        if (msg.reason_phrase) {
+                            reason.assign(msg.reason_phrase->begin(), msg.reason_phrase->end());
+                        }
+
+                        _logger->info << "Received announce error for namespace_hash: " << th.track_namespace_hash
+                                      << " error code: " << (msg.err_code.has_value() ? *msg.err_code : 0)
+                                      << " reason: " << reason << std::flush;
 
+                        stream_buffer->resetAny();
+                        return true;
+                    }
+                }
+
+                break;
+            }
             case MoQMessageType::UNANNOUNCE: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received unannounce, init stream buffer" << std::flush;

From 61e0d7a8fb1a95f2e3f321a420eb79d7d87e87a5 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 12:16:12 -0700
Subject: [PATCH 62/71] add missing break in case

---
 src/moq_instance.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index e0e5a4ad..effa11f4 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -1467,6 +1467,7 @@ namespace quicr {
                     send_client_setup();
                     _status = Status::READY;
                 }
+                break;
             }
 
             case TransportStatus::Connecting:

From 587b9f85589b5b7cee20259eebfb0da39913cfdf Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 14:59:03 -0700
Subject: [PATCH 63/71] updates based on PR review

---
 cmd/moq-example/client.cpp            | 10 +++++-----
 cmd/moq-example/server.cpp            | 12 ++++++------
 include/quicr/moq_instance_delegate.h |  4 ++--
 include/quicr/moq_track_delegate.h    | 18 ------------------
 src/moq_instance.cpp                  | 25 +++++--------------------
 5 files changed, 18 insertions(+), 51 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index a6ce58bd..25603f78 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -93,11 +93,11 @@ class clientDelegate : public quicr::MoQInstanceDelegate
         _logger(std::make_shared<cantina::Logger>("MID", logger)) {}
 
     void cb_newConnection(qtransport::TransportConnId conn_id,
-                          const std::span<uint8_t>& endpoint_id,
+                          const std::span<uint8_t> endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
 
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
-                             const std::span<uint8_t>& endpoint_id,
+                             const std::span<uint8_t> endpoint_id,
                              qtransport::TransportStatus status) override
     {
         auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
@@ -147,7 +147,7 @@ void do_publisher(const std::string t_namespace,
             published_track = true;
         }
 
-        if (track_delegate->statusSend() != quicr::MoQTrackDelegate::TrackSendStatus::OK) {
+        if (track_delegate->getSendStatus() != quicr::MoQTrackDelegate::TrackSendStatus::OK) {
             std::this_thread::sleep_for(std::chrono::milliseconds(100));
             continue;
         }
@@ -180,8 +180,8 @@ void do_publisher(const std::string t_namespace,
             group_id++;
         }
 
-        std::vector<uint8_t> msg_v(msg.begin(), msg.end());
-        auto result = track_delegate->sendObject(group_id, object_id++, msg_v);
+        track_delegate->sendObject(
+          group_id, object_id++, std::span{ std::bit_cast<uint8_t*>(msg.data()), msg.size() });
     }
 
     mi->unpublishTrack(*qclient_vars::conn_id, track_delegate);
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index 6f28a783..e3c4df2f 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -165,7 +165,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     }
 
     void cb_newConnection(qtransport::TransportConnId conn_id,
-                          const std::span<uint8_t>& endpoint_id,
+                          const std::span<uint8_t> endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
 
     void cb_unannounce(qtransport::TransportConnId conn_id,
@@ -266,7 +266,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     }
 
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
-                             const std::span<uint8_t>& endpoint_id,
+                             const std::span<uint8_t> endpoint_id,
                              qtransport::TransportStatus status) override {
         auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
 
@@ -343,7 +343,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
         }
 
         if (unsub_pub) {
-            _logger->info << "No subscribers left, unsub publisher track_alias: " << track_alias << std::flush;
+            _logger->info << "No subscribers left, unsubscribe publisher track_alias: " << track_alias << std::flush;
 
             auto anno_ns_it = qserver_vars::announce_active.find(th.track_namespace_hash);
             if (anno_ns_it == qserver_vars::announce_active.end()) {
@@ -351,11 +351,11 @@ class serverDelegate : public quicr::MoQInstanceDelegate
             }
 
             for (auto& [conn_id, tracks]: anno_ns_it->second) {
-                if (tracks.contains(th.track_name_hash)) {
+                if (tracks.contains(th.track_fullname_hash)) {
                     _logger->info << "Unsubscribe to announcer conn_id: " << conn_id
-                                  << " subscribe track_alias: " << th.track_name_hash << std::flush;
+                                  << " subscribe track_alias: " << th.track_fullname_hash << std::flush;
 
-                    tracks.erase(th.track_name_hash); // Add track alias to state
+                    tracks.erase(th.track_fullname_hash); // Add track alias to state
 
                     auto pub_delegate = qserver_vars::pub_subscribes[th.track_fullname_hash][conn_id];
                     if (pub_delegate != nullptr) {
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index d1c55e5e..57e78930 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -30,7 +30,7 @@ namespace quicr {
          * @param remote           Transport remote connection information
          */
         virtual void cb_newConnection([[maybe_unused]] TransportConnId conn_id,
-                                      [[maybe_unused]] const std::span<uint8_t>& endpoint_id,
+                                      [[maybe_unused]] const std::span<uint8_t> endpoint_id,
                                       [[maybe_unused]] const TransportRemote& remote) {};
 
         /**
@@ -42,7 +42,7 @@ namespace quicr {
          * @param status           Transport status of connection id
          */
         virtual void cb_connectionStatus(TransportConnId conn_id,
-                                         const std::span<uint8_t>& endpoint_id,
+                                         const std::span<uint8_t> endpoint_id,
                                          TransportStatus status) = 0;
 
         /**
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index ca46ac5d..26d53623 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -120,24 +120,6 @@ namespace quicr {
                              uint8_t priority,
                              uint32_t ttl);
 
-        /**
-         * @brief Current track read status
-         *
-         * @details Obtains the current track read status/state
-         *
-         * @returns current TrackReadStatus
-         */
-        TrackReadStatus statusRead() { return _read_status; }
-
-        /**
-         * @brief Current track send status
-         *
-         * @details Obtains the current track send status/state
-         *
-         * @returns current TrackSendStatus
-         */
-        TrackSendStatus statusSend() { return _send_status; }
-
         /**
          * @brief set/update the default priority for published objects
          */
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index effa11f4..c585b6f7 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -182,8 +182,6 @@ namespace quicr {
         announce.params = {};
         buffer <<  announce;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending ANNOUNCE to conn_id: " << conn_ctx.conn_id << std::flush;
 
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
@@ -197,8 +195,6 @@ namespace quicr {
         announce_ok.track_namespace.assign(track_namespace.begin(), track_namespace.end());
         buffer <<  announce_ok;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending ANNOUNCE OK to conn_id: " << conn_ctx.conn_id << std::flush;
 
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
@@ -212,8 +208,6 @@ namespace quicr {
         unannounce.track_namespace.assign(track_namespace.begin(), track_namespace.end());
         buffer <<  unannounce;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending UNANNOUNCE to conn_id: " << conn_ctx.conn_id << std::flush;
 
         send_ctrl_msg(conn_ctx, buffer.front(buffer.size()));
@@ -236,8 +230,6 @@ namespace quicr {
 
         buffer << subscribe;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending SUBSCRIBE to conn_id: " << conn_ctx.conn_id
                        << " subscribe_id: " << subscribe_id
                        << " track namespace hash: " << th.track_namespace_hash
@@ -260,8 +252,6 @@ namespace quicr {
         subscribe_ok.content_exists = content_exists;
         buffer << subscribe_ok;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending SUBSCRIBE OK to conn_id: " << conn_ctx.conn_id
                        << " subscribe_id: " << subscribe_id
                        << std::flush;
@@ -281,8 +271,6 @@ namespace quicr {
         subscribe_done.content_exists = false;
         buffer << subscribe_done;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending SUBSCRIBE DONE to conn_id: " << conn_ctx.conn_id
                        << " subscribe_id: " << subscribe_id
                        << std::flush;
@@ -300,8 +288,6 @@ namespace quicr {
         unsubscribe.subscribe_id = subscribe_id;
         buffer << unsubscribe;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending UNSUBSCRIBE to conn_id: " << conn_ctx.conn_id
                        << " subscribe_id: " << subscribe_id
                        << std::flush;
@@ -326,8 +312,6 @@ namespace quicr {
 
         buffer << subscribe_err;
 
-        std::vector<uint8_t> net_data = buffer.front(buffer.size());
-
         _logger->debug << "Sending SUBSCRIBE ERROR to conn_id: " << conn_ctx.conn_id
                        << " subscribe_id: " << subscribe_id
                        << " error code: " << static_cast<int>(error)
@@ -401,9 +385,10 @@ namespace quicr {
 
                         // Indicate send is ready upon subscribe
                         // TODO(tievens): Maybe needs a delay as subscriber may have not received ok before data is sent
-                        ptd->lock()->setSubscribeId(msg.subscribe_id);
-                        ptd->lock()->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
-                        ptd->lock()->cb_sendReady();
+                        auto ptd_l = ptd->lock();
+                        ptd_l->setSubscribeId(msg.subscribe_id);
+                        ptd_l->setSendStatus(MoQTrackDelegate::TrackSendStatus::OK);
+                        ptd_l->cb_sendReady();
 
                         conn_ctx.recv_sub_id[msg.subscribe_id] = { th.track_namespace_hash, th.track_name_hash };
 
@@ -511,7 +496,7 @@ namespace quicr {
                     // Update each track to indicate status is okay to publish
                     auto pub_it = conn_ctx.pub_tracks_by_name.find(th.track_namespace_hash);
                     for (const auto& td : pub_it->second) {
-                        if (td.second.get()->statusSend() != MoQTrackDelegate::TrackSendStatus::OK)
+                        if (td.second.get()->getSendStatus() != MoQTrackDelegate::TrackSendStatus::OK)
                             td.second.get()->setSendStatus(MoQTrackDelegate::TrackSendStatus::NO_SUBSCRIBERS);
                     }
 

From ab8a986f3d2752f9e03251adc99e936604e2be21 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 17:12:19 -0700
Subject: [PATCH 64/71] Update docs

---
 README.md                  | 101 +++++--------------------
 docs/moq-implementation.md | 151 +++++++++++++++++++++++++++++++++++++
 docs/unsubscribe-flows.md  |  47 ------------
 3 files changed, 168 insertions(+), 131 deletions(-)
 create mode 100644 docs/moq-implementation.md
 delete mode 100644 docs/unsubscribe-flows.md

diff --git a/README.md b/README.md
index 6e2b1328..21bc136b 100644
--- a/README.md
+++ b/README.md
@@ -1,113 +1,46 @@
 libquicr
 ========
 
-[![CMake](https://github.com/Quicr/libquicr/actions/workflows/cmake.yml/badge.svg?branch=main)](https://github.com/Quicr/libquicr/actions/workflows/cmake.yml)
+[![Build](https://github.com/Quicr/libquicr/actions/workflows/cmake.yml/badge.svg?branch=main)](https://github.com/Quicr/libquicr/actions/workflows/cmake.yml)
 
-Implementation of transport layer api based on QuicR.
-Please see for further details
-[QuicR Protocol](https://www.ietf.org/id/draft-jennings-moq-quicr-proto-01.html)
-
-The actual protocol implementation is covered [here](https://github.com/Quicr/quicrq).
-
-Quickstart
-----------
+An API library that implements publish/subscribe protocol [draft-ietf-moq-transport-04](https://datatracker.ietf.org/doc/html/draft-ietf-moq-transport-04). 
+The API supports both client and server. Server is intended to be implemented as a relay.
 
 ### Build
 Use `make` to build libquicr.
 
+Use `make test` to run tests. 
 
-### Build without InfluxDB
-
-To build without InfluxDB, run `cmake` with `-DLIBQUICR_WITHOUT_INFLUXDB=ON` 
-
-### Cmake FetchContent
-
-All the dependecies are now fetched via cmake and below steps should
-build libquicr.a
-
-```
-brew install openssl
-export PKG_CONFIG_PATH="/opt/homebrew/opt/openssl@3/lib/pkgconfig"
-git clone git@github.com:Quicr/libquicr.git
-cd libquicr
-git submodule update --init --recursive
-mkdir build
-cd build
-cmake ..
-make all
-```
-
-### Build Docker Dev Image
-If building docker image is the preferred option, please follow the below steps
-
-The developer image contains ```picotls```, ```picoquic``` and ```quicrq```, which are required
-for many other builds.  The container works by running it with a volume mount ```/ws/src```
-to the source to be compiled. The above libraries are in the ```/ws/``` directory, which is expected for builds.
-
-While ```quicrq``` is included under ```/ws/quicrq```, the container can be used to develop and compile
-it by mounting ```quicrq``` directory to ```/ws/src```.
-
-The docker container has been tested to work for both ARM (M1/Apple Silicon) and x86.
+Use `make cclean` to clean build files.
 
-```
-git clone git@github.com:Quicr/libquicr.git
-cd libquicr
-
-tar -c -C ../ ./quicrq ./libquicr  \
-    | docker buildx build --progress=plain \
-        --output type=docker \
-        -f libquicr/build.Dockerfile -t quicr/libquicr:latest -
-```
-
-```
-cd <libquicr directory>
-
-rm -rf $(pwd)/build
-docker run --rm \
-    -v $(pwd):/ws/src \
-    quicr/libquicr:latest make all
-```
 
-For now, it's best to run the binaries in interactive shell.  The images have been built for linux.  Run
-the image in interactive mode to access the shell prompt.  From there you can access the binaries.
-```quicrq``` and others are located under ```/ws/```.   For example, you can run ```/ws/quircq/quicrq_app``` binary.
-
-```
-docker run --rm -it \
-    -v $(pwd):/ws/src \
-    quicr/libquicr:latest bash
-```
+### Build without InfluxDB
 
-Running Examples
---------------
+To build without InfluxDB, run `cmake` with `-DLIBQUICR_WITHOUT_INFLUXDB=ON`
 
-### Running Relays/Etc.
+### Self-signed Certificate
 
-In order to test QUIC, the server/```really``` needs to have a certificate. The program expects
-the
+Server requires a TLS certificate and key file. For development and testing, use a self-signed certificate. Below
+are the steps to create a self-signed certificate and private ey. 
 
-Generate self-signed certificate for really server to test with.
+#### OpenSSL/BorningSSL
 
 ```
-cd build/cmd/really
+cd build/cmd/moq-example
 openssl req -nodes -x509 -newkey rsa:2048 -days 365 \
-    -subj "/C=US/ST=CA/L=San Jose/O=Cisco/CN=test.quicr.ctgpoc.com" \
+    -subj "/C=US/ST=CA/L=San Jose/O=Cisco/CN=test.m10x.org" \
     -keyout server-key.pem -out server-cert.pem
 ```
 
-#### MbedTLS cert
+#### MbedTLS
 
 ```
 openssl req -nodes -x509 -newkey ec:<(openssl ecparam -name secp256r1) -days 365 \
-    -subj "/C=US/ST=CA/L=San Jose/O=Cisco/CN=test.quicr.ctgpoc.com" \
+    -subj "/C=US/ST=CA/L=San Jose/O=Cisco/CN=test.m10x.org" \
     -keyout server-key.pem -out server-cert.pem
 ```
 
-Run:
-
-```
-cd build/cmd/really
-./really
 
-./reallyTest
+### MOQ Implementation Documentation
 
+See [docs/moq-implementation.md]
diff --git a/docs/moq-implementation.md b/docs/moq-implementation.md
new file mode 100644
index 00000000..8ecdebde
--- /dev/null
+++ b/docs/moq-implementation.md
@@ -0,0 +1,151 @@
+MOQT Implementation
+===================
+
+Supported implementation uses [MOQT draft-ietf-moq-transport-04](https://datatracker.ietf.org/doc/html/draft-ietf-moq-transport-04)
+
+MOQT is a publish/subscribe protocol that defines control flows to establish, maintain and teardown tracks. MOQT 
+defines **tracks** as a flow of data from a publisher to one or more subscribers. Track is synonymous with channel and
+data flow.  
+
+Objects are a set of data that as a whole is published and received by subscribes as a complete object. For example,
+sending data array of 2500 bytes (aka object) is published to a track and delivered to all subscribers as a complete
+object. The subscriber will receive the complete 2500 bytes as an object. 
+
+## Datagram vs Stream
+
+Objects can be of any size, but when using datagram they are restricted to MTU size in MOQT. **Libquicr** implements
+value added feature to optionally **slice** objects into smaller slices to be transmitted via datagram and stream objects. 
+For datagram, object sizes greater than transport MTU will automatically but sliced at the current MTU size. Subscribers
+will reassemble the slices to generate the complete object that was published. In this sense, the application on
+both sides are unaware that the object needed to be slice in order to efficiently transmit it. 
+
+## Object Slicing
+TODO - Add details
+
+## Track Fullname
+Publishing objects are sent using a track fullname that subscribers subscribe to. Relay (aka server) will forward received
+objects matching the track fullname to one or more subscribers. 
+
+There can be a bit of confusion when discussing track name as the component name is also identified as name. For this reason,
+when referring to a track name that publishers and subscribers use, the name **track fullname** is used.
+
+A track fullname is broken into two components:
+
+### (1) Track Namespace
+Unbounded size of binary bytes that the application defines. The namespace normally identifies the source client
+endpoint entity. It needs to identify the source endpoint because MOQT defines that all subscribes to track fullnames are
+sent to the namespace, regardless of the name portion. 
+
+### (2) Track Name
+Unbounded size of binary bytes that the application defines. Considering that MOQT defines that all subscribes will
+be routed to the publisher based only on the namespace component of the track fullname, it makes sense that the
+name component be used more of a filter of content from a publisher.  For example, high bandwidth video feed vs
+low bandwidth video feed. 
+
+### Track Alias
+Track alias is a generated hash value of `namespace` and `name` in this implementation. It's a consistent hash that
+is globally unique.  The track alias is a `uint64_t` value (*62 bits max due to QUIC variable length integer*)
+that represents the track fullname. Track alias is used when encoding object and other MOQT messages instead of
+having to duplicate the large binary array of bytes for namespace and name.
+
+## API
+### MOQ Track Delegate
+Publish and subscribe use the same delegate interface and base implementation. The track delegate can be subscribe only,
+publish only, or both publish and subscribe. The caller creates the delegate and ownes the lifecycle of it. 
+The `MoQInstance` holds a reference to the delegate so that callbacks can be used concurrently/thread-safe. 
+
+The track delegate is the primary handler for sending and receiving data to/from a track. Callbacks are implemented
+in the delegate to notify the caller of various events. 
+
+### MOQ Instance Delegate
+
+The caller implements and ownes the `MoQInstance` delegate. The instance delegate is passed to the `MoQInstance` 
+constructor. The `MoQInstance` creates a thread-safe reference to the delegate. Callbacks are implemented by 
+the caller to be notified on various MOQT control flow events. Various control flow events include status of the
+instance, connection status, new connections, announces, subscribes, etc.
+
+### MOQ Instance
+
+The `MoQInstance` is a QUIC connection instance, which is either a client or server. In client mode, it represents
+a single QUIC connection to a server. In serer mode, it represents a listening socket that accepts many QUIC connections.
+
+## Control Message Flows
+
+### Create Publish Track Flow
+
+API call to `publishTrack(connection_id, track_delegate)` will establish a new publish track fullname. If the track
+**namespace** is new and has not been processed before, a **MOQT announce** flow will be implemented. Below shows
+the flow. 
+
+```mermaid
+sequenceDiagram
+    actor P as Publisher
+    participant PI as PUB_MoQInstance
+    
+    participant R as Relay
+    
+    P->>PI: publishTrack('conf/100/tim/video', '1080p')
+    Note right of PI: Namespace is New
+    PI->>R: ANNOUNCE (namespace)
+    Note right of R: Authorize
+    R-->>PI: ANNOUNCE OK
+    PI-->>P: callback['conf/100/tim/video', '1080p'] send is authorized
+    
+    P->>PI: publishTrack('conf/100/tim/audio', 'opus')
+    Note right of PI: Namespace is already announced
+    PI-->>P: callback[''conf/100/tim/audio', 'opus'] send is authorized
+```
+
+In the above diagram, it shows the flow of creating new publishing tracks. In this state it will not be able to
+send any objecs yet. 
+
+>[!NOTE]
+> Notice that the result is only
+> that **"send is authorized"**. If the caller published objects in this state, the objects would be dropped
+> because per MOQT design, send cannot send anything till it has a matching track fullname subscribe. The reason
+> we cannot send is due to a restriction in MOQT that requires a **subscribe_id** to be encoded on sent objects. The
+> publisher cannot send objects till MOQT subscribe happens first, which provides a **subscribe_id** that is then used
+> by the publish track to send objects. 
+
+
+### Create Subscribe Track Flow
+
+API call to 'subscribeTrack(connection_id, track_delegate)' will establish a new subscribe track fullname. A MOQT
+subscribe will be sent when calling this method. 
+
+Below shows the flow of what happens with an initial subscribe. 
+
+
+```mermaid
+sequenceDiagram
+    actor S as Subscriber
+    participant SI as SUB_MoQInstance
+    participant R as Relay
+    participant PI as PUB_MoQInstance
+    actor P as Publisher
+    
+    S->>SI: subscribeTrack('conf/100/tim/video', '1080p')
+    SI->>R: SUBSCRIBE (namespace, track_name)
+    Note right of R: Authorize
+    R-->>SI: SUBSCRIBE OK
+    
+    SI-->>S: callback['conf/100/tim/video', '1080p'] read is ready
+```
+
+>[!NOTE]
+> Notice in the above diagram, the subscribe is successful and data could be read, but it does not
+> yet result in objects being received.  
+
+### Subscribe to Publish Announce Flow
+
+Before data can be sent to the subscribe, the relay **MUST** associate publish announcements by issuing a subscribe
+to the publisher. The publisher will then acknowledge the track fullname and will start to send data using the
+`subscribe_id` for the track fullname (track alias). 
+
+#### Subscribe association when publisher announcement comes before subscribe
+Below illustrates the flow of when a subscribe arrives after announcer is already known. 
+
+#### Subscribe association when publisher announcement comes after subscribe
+Below illustrates the flow of when a subscribe arrives after announcer is already known. 
+
+
diff --git a/docs/unsubscribe-flows.md b/docs/unsubscribe-flows.md
deleted file mode 100644
index 64c33bf2..00000000
--- a/docs/unsubscribe-flows.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# QuicR Unsubscribe flows
-
-> **1)** Client initiates ```unsubscribe()```
-
-1. Client runs ```QuicRClient::unsubscribe()```
-2. QuicRClient API sends QuicR **unsubscribe** message to server
-3. packet is received by QuicR server
-4. QuicR **server** API runs ```ServerDelegate::onUnsubscribe()``` to notify the server application
-5. Server application (e.g., LAPS) implements ```ServerDelegate::onUnsubscribe()```  and does the following:
-  * Frees any state for tracking the subscription
-  * Runs ```ServerDelegate::subscriptionEnded()```
-5. QuicR **server** API frees internal state of the subscription
-6. QuicR server API sends **subscriptionEnded** message to client
-7. packet is received by QuicR **client**
-8. QuicR **client** API does the following:
-  * runs ```SubscriberDelegate::onSubscriptionEnded()``` to notify the client APP
-  * Frees any internal state, includes removing the subscriber delegate. **The client provided delegate will no longer be called at this point.**
-9. Client implements ```SubscriberDelegate::onSubscriptionEnded()``` and closes out any state it has, including if it should free/delete the subscriber delegate
-
-
-> **2)** Server APP initiates the unsubscribe
-
-1. Server application runs ```QuicRServer::subscriptionEnded()```
-2. QuicR server API sends **subscriptionEnded** message to client
-3. Server application frees any subscription resources
-4. packet is received by QuicR **client**
-5. QuicR **client** API does the following:
-  * runs ```SubscriberDelegate::onSubscriptionEnded()``` to notify the client
-  * Frees any internal state, includes removing the subscriber delegate. **The client provided delegate will no longer be called at this point.**
-6. Client implements ```SubscriberDelegate::onSubscriptionEnded()``` and closes out any state it has, including if it should free/delete the subscriber delegate
-
-> **3)** QuicR Server API initiates the unsubscribe
-
-This is the same flow as **(2)** with the below step added first.
-
-0. QuicR Server API runs ```ServerDelegate::onUnsubscribe()```. This triggers the same flow as **(2)**
-
-
-> **4)** QuicR Client API initiates the unsubscribe
-
-Currently, the client API only initiates an unsubscribe locally. It will not send anything to the server side because the use-case for client API to close a subscription is when the connection to a server has been lost.  There might be other use-cases added in the future as we come across them. 
-
-1. QuicR **client** API does the following:
-  * runs ```SubscriberDelegate::onSubscriptionEnded()``` to notify the client
-  * Frees any internal state, includes removing the subscriber delegate. **The client provided delegate will no longer be called at this point.**
-2. Client implements ```SubscriberDelegate::onSubscriptionEnded()``` and closes out any state it has, including if it should free/delete the subscriber delegate
-

From 2772c777eb10e413ca1500e38fdeb3caccd1c7f5 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 17:13:11 -0700
Subject: [PATCH 65/71] ...

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 21bc136b..0249496b 100644
--- a/README.md
+++ b/README.md
@@ -43,4 +43,4 @@ openssl req -nodes -x509 -newkey ec:<(openssl ecparam -name secp256r1) -days 365
 
 ### MOQ Implementation Documentation
 
-See [docs/moq-implementation.md]
+See [MOQ Implementation](docs/moq-implementation.md)

From 5674a22bea499476850b6f09844370dae83f60a3 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Thu, 27 Jun 2024 17:15:05 -0700
Subject: [PATCH 66/71] ...

---
 docs/moq-implementation.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/moq-implementation.md b/docs/moq-implementation.md
index 8ecdebde..e5fb0f15 100644
--- a/docs/moq-implementation.md
+++ b/docs/moq-implementation.md
@@ -121,8 +121,6 @@ sequenceDiagram
     actor S as Subscriber
     participant SI as SUB_MoQInstance
     participant R as Relay
-    participant PI as PUB_MoQInstance
-    actor P as Publisher
     
     S->>SI: subscribeTrack('conf/100/tim/video', '1080p')
     SI->>R: SUBSCRIBE (namespace, track_name)

From cf71d876df7318cf3a1487916a2fad2ebc2bb0e2 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 28 Jun 2024 12:59:03 -0700
Subject: [PATCH 67/71] PR comment updates

---
 cmd/moq-example/client.cpp            |  4 ++--
 cmd/moq-example/server.cpp            |  4 ++--
 include/quicr/moq_instance.h          |  5 +++--
 include/quicr/moq_instance_delegate.h |  4 ++--
 include/quicr/moq_messages.h          |  2 +-
 include/quicr/moq_track_delegate.h    |  2 +-
 src/moq_instance.cpp                  | 10 +++++-----
 src/moq_messages.cpp                  | 11 +++--------
 test/moq_messages.cpp                 |  2 +-
 9 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/cmd/moq-example/client.cpp b/cmd/moq-example/client.cpp
index 25603f78..959f01bf 100644
--- a/cmd/moq-example/client.cpp
+++ b/cmd/moq-example/client.cpp
@@ -93,11 +93,11 @@ class clientDelegate : public quicr::MoQInstanceDelegate
         _logger(std::make_shared<cantina::Logger>("MID", logger)) {}
 
     void cb_newConnection(qtransport::TransportConnId conn_id,
-                          const std::span<uint8_t> endpoint_id,
+                          std::span<uint8_t const> endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
 
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
-                             const std::span<uint8_t> endpoint_id,
+                             std::span<uint8_t const> endpoint_id,
                              qtransport::TransportStatus status) override
     {
         auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
diff --git a/cmd/moq-example/server.cpp b/cmd/moq-example/server.cpp
index e3c4df2f..205810aa 100644
--- a/cmd/moq-example/server.cpp
+++ b/cmd/moq-example/server.cpp
@@ -165,7 +165,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     }
 
     void cb_newConnection(qtransport::TransportConnId conn_id,
-                          const std::span<uint8_t> endpoint_id,
+                          std::span<uint8_t const> endpoint_id,
                           const qtransport::TransportRemote& remote) override {}
 
     void cb_unannounce(qtransport::TransportConnId conn_id,
@@ -266,7 +266,7 @@ class serverDelegate : public quicr::MoQInstanceDelegate
     }
 
     void cb_connectionStatus(qtransport::TransportConnId conn_id,
-                             const std::span<uint8_t> endpoint_id,
+                             std::span<uint8_t const> endpoint_id,
                              qtransport::TransportStatus status) override {
         auto ep_id = std::string(endpoint_id.begin(), endpoint_id.end());
 
diff --git a/include/quicr/moq_instance.h b/include/quicr/moq_instance.h
index 49250074..5b572990 100644
--- a/include/quicr/moq_instance.h
+++ b/include/quicr/moq_instance.h
@@ -19,8 +19,9 @@
 #include <string_view>
 
 namespace quicr {
-    constexpr uint64_t MOQT_VERSION = 0xff000004; /// draft-ietf-moq-transport-04
-    constexpr uint64_t MOQT_SUBSCRIBE_EXPIRES = 0;      /// Never expires
+    constexpr uint64_t MOQT_VERSION = 0xff000004;             /// draft-ietf-moq-transport-04
+    constexpr uint64_t MOQT_SUBSCRIBE_EXPIRES = 0;            /// Never expires
+    constexpr int MOQT_READ_LOOP_MAX_PER_STREAM = 60;         /// Support packet/frame bursts, but do not allow starving other streams
 
     using namespace qtransport;
 
diff --git a/include/quicr/moq_instance_delegate.h b/include/quicr/moq_instance_delegate.h
index 57e78930..211c7c44 100644
--- a/include/quicr/moq_instance_delegate.h
+++ b/include/quicr/moq_instance_delegate.h
@@ -30,7 +30,7 @@ namespace quicr {
          * @param remote           Transport remote connection information
          */
         virtual void cb_newConnection([[maybe_unused]] TransportConnId conn_id,
-                                      [[maybe_unused]] const std::span<uint8_t> endpoint_id,
+                                      [[maybe_unused]] std::span<uint8_t const> endpoint_id,
                                       [[maybe_unused]] const TransportRemote& remote) {};
 
         /**
@@ -42,7 +42,7 @@ namespace quicr {
          * @param status           Transport status of connection id
          */
         virtual void cb_connectionStatus(TransportConnId conn_id,
-                                         const std::span<uint8_t> endpoint_id,
+                                         std::span<uint8_t const> endpoint_id,
                                          TransportStatus status) = 0;
 
         /**
diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 2b41ed00..3b3f22cf 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -54,7 +54,7 @@ enum class MoQMessageType : uint64_t
     TRACK_STATUS_REQUEST,
     TRACK_STATUS,
 
-    GOWAY = 0x10,
+    GOAWAY = 0x10,
 
     CLIENT_SETUP = 0x40,
     SERVER_SETUP,
diff --git a/include/quicr/moq_track_delegate.h b/include/quicr/moq_track_delegate.h
index 26d53623..13ee141c 100644
--- a/include/quicr/moq_track_delegate.h
+++ b/include/quicr/moq_track_delegate.h
@@ -140,7 +140,7 @@ namespace quicr {
         // --------------------------------------------------------------------------
 
         /**
-         * @brief Notificaiton of received data object
+         * @brief Notification of received data object
          *
          * @details Event notification to provide the caller the received data object
          *
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index c585b6f7..f4ab8774 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -699,7 +699,7 @@ namespace quicr {
 
                 break;
             }
-            case MoQMessageType::GOWAY: {
+            case MoQMessageType::GOAWAY: {
                 if (not stream_buffer->anyHasValue()) {
                     _logger->debug << "Received goaway, init stream buffer" << std::flush;
                     stream_buffer->initAny<MoqGoaway>();
@@ -1522,7 +1522,7 @@ namespace quicr {
     {
         auto stream_buf = _transport->getStreamBuffer(conn_id, stream_id);
 
-        //std::lock_guard<std::mutex> _(_state_mutex);
+        //TODO(tievens): Considering moving lock to here... std::lock_guard<std::mutex> _(_state_mutex);
 
         auto& conn_ctx = _connections[conn_id];
 
@@ -1540,7 +1540,7 @@ namespace quicr {
             conn_ctx.ctrl_data_ctx_id = data_ctx_id;
         }
 
-        for (int i=0; i < 60; i++) { // don't loop forever, especially on bad stream
+        for (int i=0; i < MOQT_READ_LOOP_MAX_PER_STREAM; i++) { // don't loop forever, especially on bad stream
             // bidir is Control stream, data streams are unidirectional
             if (is_bidir) {
                 if (not conn_ctx.ctrl_msg_type_received) {
@@ -1578,7 +1578,7 @@ namespace quicr {
     void MoQInstance::on_recv_dgram(const TransportConnId& conn_id, std::optional<DataContextId> data_ctx_id)
     {
         MoqObjectStream object_datagram_out;
-        for (int i=0; i < 70; i++) {
+        for (int i=0; i < MOQT_READ_LOOP_MAX_PER_STREAM; i++) {
             auto data = _transport->dequeue(conn_id, data_ctx_id);
             if (data && !data->empty()) {
                 StreamBuffer<uint8_t> buffer;
@@ -1593,7 +1593,7 @@ namespace quicr {
                 MoqObjectDatagram msg;
                 if (buffer >> msg) {
 
-                    //std::lock_guard<std::mutex> _(_state_mutex);
+                    ////TODO(tievens): Considering moving lock to here... std::lock_guard<std::mutex> _(_state_mutex);
 
                     auto& conn_ctx = _connections[conn_id];
                     auto sub_it = conn_ctx.tracks_by_sub_id.find(msg.subscribe_id);
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index 11fb2bbc..d45aaf7f 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -62,7 +62,6 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   return buffer;
 }
 
-
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &param) {
 
   if(!parse_uintV_field(buffer, param.param_type)) {
@@ -402,11 +401,7 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
 
 
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqUnsubscribe &msg) {
-
-  if(!parse_uintV_field(buffer, msg.subscribe_id)) {
-    return false;
-  }
-  return true;
+  return parse_uintV_field(buffer, msg.subscribe_id);
 }
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
@@ -791,7 +786,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqAnnounceCancel &ms
 
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqGoaway& msg){
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::GOWAY)));
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(MoQMessageType::GOAWAY)));
   buffer.push_lv(msg.new_session_uri);
   return buffer;
 }
@@ -809,7 +804,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqGoaway &msg) {
 
 MessageBuffer &
 operator<<(MessageBuffer &buffer, const MoqGoaway &msg) {
-  buffer << static_cast<uint8_t>(MoQMessageType::GOWAY);
+  buffer << static_cast<uint8_t>(MoQMessageType::GOAWAY);
   buffer << msg.new_session_uri;
   return buffer;
 }
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 51bcc42f..0452a602 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -743,6 +743,6 @@ TEST_CASE("MoqGoaway Message encode/decode")
 
   std::vector<uint8_t> net_data = buffer.front(buffer.size());
   MoqGoaway goaway_out{};
-  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::GOWAY), goaway_out));
+  CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::GOAWAY), goaway_out));
   CHECK_EQ(from_ascii("go.away.now.no.return"), goaway_out.new_session_uri);
 }
\ No newline at end of file

From 9a83935c4cead663dfb4e902fa862dcf83ebabdb Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 28 Jun 2024 13:02:42 -0700
Subject: [PATCH 68/71] ...

---
 include/quicr/moq_messages.h |  6 +--
 src/moq_instance.cpp         | 32 +++++++--------
 src/moq_messages.cpp         | 78 ++++++++++++++++++------------------
 test/moq_messages.cpp        | 78 ++++++++++++++++++------------------
 4 files changed, 97 insertions(+), 97 deletions(-)

diff --git a/include/quicr/moq_messages.h b/include/quicr/moq_messages.h
index 3b3f22cf..4f005d0c 100644
--- a/include/quicr/moq_messages.h
+++ b/include/quicr/moq_messages.h
@@ -94,9 +94,9 @@ enum struct ParameterType : uint8_t {
 };
 
 struct MoqParameter {
-  uint64_t param_type {0};
-  uint64_t param_length {0};
-  bytes param_value;
+  uint64_t type{0};
+  uint64_t length{0};
+  bytes value;
   friend bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &msg);
   friend qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
                                                        const MoqParameter& msg);
diff --git a/src/moq_instance.cpp b/src/moq_instance.cpp
index f4ab8774..974c0912 100644
--- a/src/moq_instance.cpp
+++ b/src/moq_instance.cpp
@@ -140,10 +140,10 @@ namespace quicr {
 
         client_setup.num_versions = 1;      // NOTE: Not used for encode, verison vector size is used
         client_setup.supported_versions = { MOQT_VERSION };
-        client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
-        client_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
-        client_setup.role_parameter.param_value = { 0x03 };
-        client_setup.endpoint_id_parameter.param_value.assign(_client_config.endpoint_id.begin(),
+        client_setup.role_parameter.type = static_cast<uint64_t>(ParameterType::Role);
+        client_setup.role_parameter.length = 0x1; // NOTE: not used for encode, size of value is used
+        client_setup.role_parameter.value = { 0x03 };
+        client_setup.endpoint_id_parameter.value.assign(_client_config.endpoint_id.begin(),
                                                               _client_config.endpoint_id.end());
 
         buffer << client_setup;
@@ -159,10 +159,10 @@ namespace quicr {
         auto server_setup = MoqServerSetup{};
 
         server_setup.selection_version = { conn_ctx.client_version };
-        server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
-        server_setup.role_parameter.param_length = 0x1; // NOTE: not used for encode, size of value is used
-        server_setup.role_parameter.param_value = { 0x03 };
-        server_setup.endpoint_id_parameter.param_value.assign(_server_config.endpoint_id.begin(),
+        server_setup.role_parameter.type = static_cast<uint64_t>(ParameterType::Role);
+        server_setup.role_parameter.length = 0x1; // NOTE: not used for encode, size of value is used
+        server_setup.role_parameter.value = { 0x03 };
+        server_setup.endpoint_id_parameter.value.assign(_server_config.endpoint_id.begin(),
                                                               _server_config.endpoint_id.end());
 
 
@@ -733,18 +733,18 @@ namespace quicr {
 
                         }
 
-                        std::string client_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
-                                                        msg.endpoint_id_parameter.param_value.end());
+                        std::string client_endpoint_id(msg.endpoint_id_parameter.value.begin(),
+                                                        msg.endpoint_id_parameter.value.end());
 
                         _delegate->cb_connectionStatus(conn_ctx.conn_id,
-                                                       msg.endpoint_id_parameter.param_value,
+                                                       msg.endpoint_id_parameter.value,
                                                        TransportStatus::Ready);
 
                         _logger->info << "Client setup received "
                                       << " conn_id:" << conn_ctx.conn_id
                                       << " from: " << client_endpoint_id
                                       << " num_versions: " << msg.num_versions
-                                      << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
+                                      << " role: " << static_cast<int>(msg.role_parameter.value.front())
                                       << " version: 0x" << std::hex << msg.supported_versions.front()
                                       << std::dec << std::flush;
 
@@ -773,17 +773,17 @@ namespace quicr {
 
                 auto& msg = stream_buffer->getAny<MoqServerSetup>();
                 if (*stream_buffer >> msg) {
-                    std::string server_endpoint_id(msg.endpoint_id_parameter.param_value.begin(),
-                                msg.endpoint_id_parameter.param_value.end());
+                    std::string server_endpoint_id(msg.endpoint_id_parameter.value.begin(),
+                                msg.endpoint_id_parameter.value.end());
 
                     _delegate->cb_connectionStatus(conn_ctx.conn_id,
-                               msg.endpoint_id_parameter.param_value,
+                               msg.endpoint_id_parameter.value,
                                TransportStatus::Ready);
 
                     _logger->info << "Server setup received"
                                   << " conn_id:" << conn_ctx.conn_id
                                   << " from: " << server_endpoint_id
-                                  << " role: " << static_cast<int>(msg.role_parameter.param_value.front())
+                                  << " role: " << static_cast<int>(msg.role_parameter.value.front())
                                   << " selected_version: 0x" << std::hex << msg.selection_version
                                   << std::dec << std::flush;
 
diff --git a/src/moq_messages.cpp b/src/moq_messages.cpp
index d45aaf7f..3d3460a9 100644
--- a/src/moq_messages.cpp
+++ b/src/moq_messages.cpp
@@ -54,30 +54,30 @@ MessageBuffer& operator>>(MessageBuffer& buffer, std::optional<T>& val) {
 qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>& buffer,
            const MoqParameter& param){
 
-  buffer.push(qtransport::to_uintV(param.param_type));
-  buffer.push(qtransport::to_uintV(param.param_length));
-  if (param.param_length) {
-    buffer.push_lv(param.param_value);
+  buffer.push(qtransport::to_uintV(param.type));
+  buffer.push(qtransport::to_uintV(param.length));
+  if (param.length) {
+    buffer.push_lv(param.value);
   }
   return buffer;
 }
 
 bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &param) {
 
-  if(!parse_uintV_field(buffer, param.param_type)) {
+  if(!parse_uintV_field(buffer, param.type)) {
     return false;
   }
 
-  if(!parse_uintV_field(buffer, param.param_length)) {
+  if(!parse_uintV_field(buffer, param.length)) {
     return false;
   }
 
-  if(param.param_length) {
+  if(param.length) {
     const auto val = buffer.decode_bytes();
     if (!val) {
       return false;
     }
-    param.param_value = std::move(val.value());
+    param.value = std::move(val.value());
   }
 
   return true;
@@ -85,20 +85,20 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqParameter &param)
 
 
 MessageBuffer& operator<<(MessageBuffer &buffer, const MoqParameter &param) {
-  buffer << param.param_type;
-  buffer << param.param_length;
-  if (param.param_length) {
-    buffer << param.param_value;
+  buffer << param.type;
+  buffer << param.length;
+  if (param.length) {
+    buffer << param.value;
   }
 
   return buffer;
 }
 
 MessageBuffer& operator>>(MessageBuffer &buffer, MoqParameter &param) {
-  buffer >> param.param_type;
-  buffer >> param.param_length;
-  if (static_cast<uint64_t>(param.param_length) > 0) {
-    buffer >> param.param_value;
+  buffer >> param.type;
+  buffer >> param.length;
+  if (static_cast<uint64_t>(param.length) > 0) {
+    buffer >> param.value;
   }
   return buffer;
 }
@@ -245,8 +245,8 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
 
   buffer.push(qtransport::to_uintV(msg.track_params.size()));
   for (const auto& param: msg.track_params) {
-    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.param_type)));
-    buffer.push_lv(param.param_value);
+    buffer.push(qtransport::to_uintV(static_cast<uint64_t>(param.type)));
+    buffer.push_lv(param.value);
   }
 
   return buffer;
@@ -361,7 +361,7 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
           }
 
           msg.current_param = MoqParameter{};
-          msg.current_param->param_type = type;
+          msg.current_param->type = type;
         }
 
         // decode param_len:<bytes>
@@ -369,8 +369,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqSubscribe &msg) {
         if (!param) {
           return false;
         }
-        msg.current_param.value().param_length = param->size();
-        msg.current_param.value().param_value = param.value();
+        msg.current_param.value().length = param->size();
+        msg.current_param.value().value = param.value();
         msg.track_params.push_back(msg.current_param.value());
         msg.current_param = std::nullopt;
         *msg.num_params -= 1;
@@ -650,14 +650,14 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
 
   // parse each param
   while (msg.num_params > 0) {
-    if (!msg.current_param.param_type) {
+    if (!msg.current_param.type) {
       uint64_t type {0};
       if (!parse_uintV_field(buffer, type)) {
         return false;
       }
 
       msg.current_param = {};
-      msg.current_param.param_type = type;
+      msg.current_param.type = type;
     }
 
     // decode param_len:<bytes>
@@ -666,8 +666,8 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer,
       return false;
     }
 
-    msg.current_param.param_length = param->size();
-    msg.current_param.param_value = param.value();
+    msg.current_param.length = param->size();
+    msg.current_param.value = param.value();
     msg.params.push_back(msg.current_param);
     msg.current_param = {};
     msg.num_params -= 1;
@@ -1160,11 +1160,11 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   /// num params
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(2)));
   // role param
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
-  buffer.push_lv(msg.role_parameter.param_value);
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.type)));
+  buffer.push_lv(msg.role_parameter.value);
   // endpoint_id param
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(ParameterType::EndpointId)));
-  buffer.push_lv(msg.endpoint_id_parameter.param_value);
+  buffer.push_lv(msg.endpoint_id_parameter.value);
 
   return buffer;
 }
@@ -1206,17 +1206,17 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqClientSetup &msg)
               }
 
               msg.current_param = MoqParameter{};
-              msg.current_param->param_type = type;
+              msg.current_param->type = type;
           }
 
           auto param = buffer.decode_bytes();
           if (!param) {
               return false;
           }
-          msg.current_param->param_length = param->size();
-          msg.current_param->param_value = param.value();
+          msg.current_param->length = param->size();
+          msg.current_param->value = param.value();
 
-          switch (static_cast<ParameterType>(msg.current_param->param_type)) {
+          switch (static_cast<ParameterType>(msg.current_param->type)) {
               case ParameterType::Role:
                   msg.role_parameter = std::move(msg.current_param.value());
                   break;
@@ -1261,12 +1261,12 @@ qtransport::StreamBuffer<uint8_t>& operator<<(qtransport::StreamBuffer<uint8_t>&
   /// num params
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(2)));
   // role param
-  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.param_type)));
-  buffer.push_lv(msg.role_parameter.param_value);
+  buffer.push(qtransport::to_uintV(static_cast<uint64_t>(msg.role_parameter.type)));
+  buffer.push_lv(msg.role_parameter.value);
 
   // endpoint_id param
   buffer.push(qtransport::to_uintV(static_cast<uint64_t>(ParameterType::EndpointId)));
-  buffer.push_lv(msg.endpoint_id_parameter.param_value);
+  buffer.push_lv(msg.endpoint_id_parameter.value);
 
   return buffer;
 }
@@ -1296,17 +1296,17 @@ bool operator>>(qtransport::StreamBuffer<uint8_t> &buffer, MoqServerSetup &msg)
           }
 
           msg.current_param = MoqParameter{};
-          msg.current_param->param_type = type;
+          msg.current_param->type = type;
         }
 
         auto param = buffer.decode_bytes();
         if (!param) {
           return false;
         }
-        msg.current_param->param_length = param->size();
-        msg.current_param->param_value = param.value();
+        msg.current_param->length = param->size();
+        msg.current_param->value = param.value();
 
-        switch (static_cast<ParameterType>(msg.current_param->param_type)) {
+        switch (static_cast<ParameterType>(msg.current_param->type)) {
             case ParameterType::Role:
                 msg.role_parameter = std::move(msg.current_param.value());
                 break;
diff --git a/test/moq_messages.cpp b/test/moq_messages.cpp
index 0452a602..4ecef9c7 100644
--- a/test/moq_messages.cpp
+++ b/test/moq_messages.cpp
@@ -248,9 +248,9 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
   MoqParameter param;
-  param.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
-  param.param_length = 0x2;
-  param.param_value = {0x1, 0x2};
+  param.type = static_cast<uint64_t>(ParameterType::AuthorizationInfo),
+  param.length = 0x2;
+  param.value = {0x1, 0x2};
 
   auto subscribe  = MoqSubscribe {};
   subscribe.subscribe_id = 0x1;
@@ -272,9 +272,9 @@ TEST_CASE("Subscribe (Params) Message encode/decode")
   CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
   CHECK_EQ(subscribe.track_params.size(), subscribe_out.track_params.size());
-  CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
-  CHECK_EQ(subscribe.track_params[0].param_length, subscribe_out.track_params[0].param_length);
-  CHECK_EQ(subscribe.track_params[0].param_value, subscribe_out.track_params[0].param_value);
+  CHECK_EQ(subscribe.track_params[0].type, subscribe_out.track_params[0].type);
+  CHECK_EQ(subscribe.track_params[0].length, subscribe_out.track_params[0].length);
+  CHECK_EQ(subscribe.track_params[0].value, subscribe_out.track_params[0].value);
 }
 
 
@@ -282,14 +282,14 @@ TEST_CASE("Subscribe (Params - 2) Message encode/decode")
 {
   qtransport::StreamBuffer<uint8_t> buffer;
   MoqParameter param1;
-  param1.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
-  param1.param_length = 0x2;
-  param1.param_value = {0x1, 0x2};
+  param1.type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+  param1.length = 0x2;
+  param1.value = {0x1, 0x2};
 
   MoqParameter param2;
-  param2.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
-  param2.param_length = 0x3;
-  param2.param_value = {0x1, 0x2, 0x3};
+  param2.type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+  param2.length = 0x3;
+  param2.value = {0x1, 0x2, 0x3};
 
 
   auto subscribe  = MoqSubscribe {};
@@ -313,13 +313,13 @@ TEST_CASE("Subscribe (Params - 2) Message encode/decode")
   CHECK_EQ(subscribe.track_alias, subscribe_out.track_alias);
   CHECK_EQ(subscribe.filter_type, subscribe_out.filter_type);
   CHECK_EQ(subscribe.track_params.size(), subscribe_out.track_params.size());
-  CHECK_EQ(subscribe.track_params[0].param_type, subscribe_out.track_params[0].param_type);
-  CHECK_EQ(subscribe.track_params[0].param_length, subscribe_out.track_params[0].param_length);
-  CHECK_EQ(subscribe.track_params[0].param_value, subscribe_out.track_params[0].param_value);
+  CHECK_EQ(subscribe.track_params[0].type, subscribe_out.track_params[0].type);
+  CHECK_EQ(subscribe.track_params[0].length, subscribe_out.track_params[0].length);
+  CHECK_EQ(subscribe.track_params[0].value, subscribe_out.track_params[0].value);
 
-  CHECK_EQ(subscribe.track_params[1].param_type, subscribe_out.track_params[1].param_type);
-  CHECK_EQ(subscribe.track_params[1].param_length, subscribe_out.track_params[1].param_length);
-  CHECK_EQ(subscribe.track_params[1].param_value, subscribe_out.track_params[1].param_value);
+  CHECK_EQ(subscribe.track_params[1].type, subscribe_out.track_params[1].type);
+  CHECK_EQ(subscribe.track_params[1].length, subscribe_out.track_params[1].length);
+  CHECK_EQ(subscribe.track_params[1].value, subscribe_out.track_params[1].value);
 }
 
 
@@ -350,9 +350,9 @@ MoqSubscribe generate_subscribe(FilterType filter, size_t  num_params = 0, uint6
 
   while(num_params > 0) {
     MoqParameter param1;
-    param1.param_type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
-    param1.param_length = 0x2;
-    param1.param_value = {0x1, 0x2};
+    param1.type = static_cast<uint64_t>(ParameterType::AuthorizationInfo);
+    param1.length = 0x2;
+    param1.value = {0x1, 0x2};
     out.track_params.push_back(param1);
     num_params--;
   }
@@ -386,12 +386,12 @@ TEST_CASE("Subscribe (Combo) Message encode/decode")
     CHECK_EQ(subscribes[i].filter_type, subscribe_out.filter_type);
     CHECK_EQ(subscribes[i].track_params.size(), subscribe_out.track_params.size());
     for(size_t j = 0; j < subscribes[i].track_params.size(); j++) {
-      CHECK_EQ(subscribes[i].track_params[j].param_type,
-               subscribe_out.track_params[j].param_type);
-      CHECK_EQ(subscribes[i].track_params[j].param_length,
-               subscribe_out.track_params[j].param_length);
-      CHECK_EQ(subscribes[i].track_params[j].param_value,
-               subscribe_out.track_params[j].param_value);
+      CHECK_EQ(subscribes[i].track_params[j].type,
+               subscribe_out.track_params[j].type);
+      CHECK_EQ(subscribes[i].track_params[j].length,
+               subscribe_out.track_params[j].length);
+      CHECK_EQ(subscribes[i].track_params[j].value,
+               subscribe_out.track_params[j].value);
 
     }
   }
@@ -533,10 +533,10 @@ TEST_CASE("ClientSetup  Message encode/decode")
   auto client_setup = MoqClientSetup {};
   client_setup.num_versions = 2;
   client_setup.supported_versions = {0x1000, 0x2000};
-  client_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
-  client_setup.role_parameter.param_length = 0x1;
-  client_setup.role_parameter.param_value = {0xFF};
-  client_setup.endpoint_id_parameter.param_value.assign(endpoint_id.begin(), endpoint_id.end());
+  client_setup.role_parameter.type = static_cast<uint64_t>(ParameterType::Role);
+  client_setup.role_parameter.length = 0x1;
+  client_setup.role_parameter.value = {0xFF};
+  client_setup.endpoint_id_parameter.value.assign(endpoint_id.begin(), endpoint_id.end());
 
   buffer << client_setup;
 
@@ -545,8 +545,8 @@ TEST_CASE("ClientSetup  Message encode/decode")
   MoqClientSetup client_setup_out;
   CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::CLIENT_SETUP), client_setup_out));
   CHECK_EQ(client_setup.supported_versions, client_setup_out.supported_versions);
-  CHECK_EQ(client_setup.role_parameter.param_value, client_setup_out.role_parameter.param_value);
-  CHECK_EQ(client_setup.endpoint_id_parameter.param_value, client_setup_out.endpoint_id_parameter.param_value);
+  CHECK_EQ(client_setup.role_parameter.value, client_setup_out.role_parameter.value);
+  CHECK_EQ(client_setup.endpoint_id_parameter.value, client_setup_out.endpoint_id_parameter.value);
 }
 
 
@@ -556,10 +556,10 @@ TEST_CASE("ServerSetup  Message encode/decode")
   const std::string endpoint_id = "server_test";
   auto server_setup = MoqServerSetup {};
   server_setup.selection_version = {0x1000};
-  server_setup.role_parameter.param_type = static_cast<uint64_t>(ParameterType::Role);
-  server_setup.role_parameter.param_length = 0x1;
-  server_setup.role_parameter.param_value = {0xFF};
-  server_setup.endpoint_id_parameter.param_value.assign(endpoint_id.begin(), endpoint_id.end());
+  server_setup.role_parameter.type = static_cast<uint64_t>(ParameterType::Role);
+  server_setup.role_parameter.length = 0x1;
+  server_setup.role_parameter.value = {0xFF};
+  server_setup.endpoint_id_parameter.value.assign(endpoint_id.begin(), endpoint_id.end());
 
   buffer << server_setup;
 
@@ -568,8 +568,8 @@ TEST_CASE("ServerSetup  Message encode/decode")
   MoqServerSetup server_setup_out;
   CHECK(verify(net_data, static_cast<uint64_t>(MoQMessageType::SERVER_SETUP), server_setup_out));
   CHECK_EQ(server_setup.selection_version, server_setup_out.selection_version);
-  CHECK_EQ(server_setup.role_parameter.param_value, server_setup.role_parameter.param_value);
-  CHECK_EQ(server_setup.endpoint_id_parameter.param_value, server_setup_out.endpoint_id_parameter.param_value);
+  CHECK_EQ(server_setup.role_parameter.value, server_setup.role_parameter.value);
+  CHECK_EQ(server_setup.endpoint_id_parameter.value, server_setup_out.endpoint_id_parameter.value);
 }
 
 TEST_CASE("ObjectStream  Message encode/decode")

From 39a3ae55c8010af0dce53260e6a1c2ad2faefac4 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 28 Jun 2024 16:35:46 -0700
Subject: [PATCH 69/71] Update docs

---
 docs/moq-implementation.md | 85 +++++++++++++++++++++++++++++++++++---
 1 file changed, 80 insertions(+), 5 deletions(-)

diff --git a/docs/moq-implementation.md b/docs/moq-implementation.md
index e5fb0f15..0b939741 100644
--- a/docs/moq-implementation.md
+++ b/docs/moq-implementation.md
@@ -134,16 +134,91 @@ sequenceDiagram
 > Notice in the above diagram, the subscribe is successful and data could be read, but it does not
 > yet result in objects being received.  
 
-### Subscribe to Publish Announce Flow
+### Subscribe and Publish Announce Flows
 
 Before data can be sent to the subscribe, the relay **MUST** associate publish announcements by issuing a subscribe
 to the publisher. The publisher will then acknowledge the track fullname and will start to send data using the
 `subscribe_id` for the track fullname (track alias). 
 
-#### Subscribe association when publisher announcement comes before subscribe
-Below illustrates the flow of when a subscribe arrives after announcer is already known. 
+Depending on if subscribe or announce comes first, the flow is different.
 
-#### Subscribe association when publisher announcement comes after subscribe
-Below illustrates the flow of when a subscribe arrives after announcer is already known. 
+#### Subscribe handling when publisher announcement comes before subscribe
+
+Below illustrates the flow of when subscribe arrives after announcer is already known.
+
+```mermaid
+flowchart LR
+    D((Done))
+    aS[[Append subscribe to forwarding state]]
+    
+    
+    S>"Subscribe [ns,n]"] --> asQ{"ns == announce ns?"}
+    asQ -- Yes --> asQy(("iterate"))
+    subgraph "forEach connection of announce == [n]" 
+        asQy --> sQ{Have existing\nsubscribes?}
+        sQ -- No --> sQn["Send subscribe to announcer [ns,n]"]
+        sQn --> aS
+        sQ -- Yes --> aS
+    end
+    aS --> D
+    asQ -- No --> D
+```
+
+> [!NOTE]
+> In the multiple publisher use-case, the connection ID is taken into account when processing the above flow. Forwarding
+> state is updated for each matching namespace publisher. What is not shown, but is pretty complicated, is that
+> not all publishers will subscribe OK to [ns,n], resulting in some being added to the forwarding state and others not.
+
+#### Subscribe handling when publisher announcement comes after subscribe
+Below illustrates the flow of when subscribe arrives before announcer.
+
+```mermaid
+flowchart LR
+    D((Done))
+    
+    A>"Announce [n]"] --> aC{"Is [n] new?"}
+    aC -- Yes --> aCy[Create state for new announce]
+    aCy --> sQ{"Have subscribes\nmatching [n]?"}
+    sQ -- Yes --> sQy(("`iterate`"))
+    subgraph "forEach subscribe[ns,n]"
+    sQy --> sQy_a[[Get Track full name]]
+    sQy_a --> sQy_b[Send subscribe]
+    sQy_b --> sQy
+    end
+    sQy --> D
+    aC -- No --> D
+    
+    
+```
+
+Noticed that the above flow is not so complicated with having to update each announcer, but it is more complicated
+in identifying each distinct subscribe [ns,n].
+
+### Unsubscribe Flow
+Unsubscribe flow gets pretty complicated as the state requires notifying the publisher (announcer) using an unsubscribe
+to indicate there are no subscribers. If there is at lest one subscriber, then the announcer is not unsubscribed.
+If there are zero subscribers left, then an unsubscribe is sent to each of the announcer that
+matchs `[ns,n] = track_alias = track fullname`
+
+TODO: add flow diagram
+
+### Unannounce Flow
+Unannounce flow is complicated in that SUBSCRIBE_DONE should be sent first to indicate that publishing is over. 
+When the relay receives a SUBSCRIBE_DONE, it updates the state of the subscription to the publisher to indicate it's over.
+The relay could propagate the SUBSCRIBE_DONE, but then that would cause excessive churn over thousands of subscribers,
+especially when considering that in MOQT the only way to come back from SUBSCRIBE_DONE is to unsubscribe and subscribe again...
+more churn. 
+
+For this reason, the relay does not propagate this right now. 
+
+For the same reasoning as mentioned above, the relay will process an UNANNOUNCE locally and remove the announcer
+and associated forwarding table entries, but will not cause excessive churn with subscribers to notify them yet that
+the publisher is gone. The existing subscribes will linger until the clients decided to unsubscribe. 
+
+The MOQT draft-04 includes TRACK_STATUS, which should be used to convey per subscriber and publisher on 
+status if there are any subscribers and/or publishers. 
+
+Excessive churn can be seen more often with race conditions, which would benefit from some level of dampening. 
+The current example/relay implementations takes this into account. 
 
 

From c57d7136292ed228fc164be516b4408b968a1bda Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 28 Jun 2024 16:37:32 -0700
Subject: [PATCH 70/71] Update transport to main branch

---
 dependencies/transport | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dependencies/transport b/dependencies/transport
index 49385712..508ca941 160000
--- a/dependencies/transport
+++ b/dependencies/transport
@@ -1 +1 @@
-Subproject commit 4938571264c4e07d796f552ceb5580e3fa7aee82
+Subproject commit 508ca941b67976cc58314ff18cbb66163d8a4cc4

From bed1bb58d8d67190de16e89ee134c653e4224634 Mon Sep 17 00:00:00 2001
From: Tim Evens <tievens@cisco.com>
Date: Fri, 28 Jun 2024 16:46:25 -0700
Subject: [PATCH 71/71] ...

---
 docs/moq-implementation.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/docs/moq-implementation.md b/docs/moq-implementation.md
index 0b939741..0dc866db 100644
--- a/docs/moq-implementation.md
+++ b/docs/moq-implementation.md
@@ -110,7 +110,7 @@ send any objecs yet.
 
 ### Create Subscribe Track Flow
 
-API call to 'subscribeTrack(connection_id, track_delegate)' will establish a new subscribe track fullname. A MOQT
+API call to `subscribeTrack(connection_id, track_delegate)` will establish a new subscribe track fullname. A MOQT
 subscribe will be sent when calling this method. 
 
 Below shows the flow of what happens with an initial subscribe. 
@@ -167,7 +167,7 @@ flowchart LR
 > [!NOTE]
 > In the multiple publisher use-case, the connection ID is taken into account when processing the above flow. Forwarding
 > state is updated for each matching namespace publisher. What is not shown, but is pretty complicated, is that
-> not all publishers will subscribe OK to [ns,n], resulting in some being added to the forwarding state and others not.
+> not all publishers will subscribe OK to `[ns,n]`, resulting in some being added to the forwarding state and others not.
 
 #### Subscribe handling when publisher announcement comes after subscribe
 Below illustrates the flow of when subscribe arrives before announcer.
@@ -186,19 +186,21 @@ flowchart LR
     sQy_b --> sQy
     end
     sQy --> D
+    sQ -- No --> D
     aC -- No --> D
     
     
 ```
 
-Noticed that the above flow is not so complicated with having to update each announcer, but it is more complicated
-in identifying each distinct subscribe [ns,n].
+> [!NOTE]
+> Noticed that the above flow is not so complicated with having to update each announcer, but it is more complicated
+> in identifying each distinct subscribe `[ns,n]`.
 
 ### Unsubscribe Flow
 Unsubscribe flow gets pretty complicated as the state requires notifying the publisher (announcer) using an unsubscribe
 to indicate there are no subscribers. If there is at lest one subscriber, then the announcer is not unsubscribed.
-If there are zero subscribers left, then an unsubscribe is sent to each of the announcer that
-matchs `[ns,n] = track_alias = track fullname`
+If there are zero subscribers left, then an unsubscribe is sent to each of the announcers that
+matches `[ns,n] = track_alias = track fullname`
 
 TODO: add flow diagram
 
@@ -211,11 +213,11 @@ more churn.
 
 For this reason, the relay does not propagate this right now. 
 
-For the same reasoning as mentioned above, the relay will process an UNANNOUNCE locally and remove the announcer
+For the same reasoning as mentioned above, the relay will process an UNANNOUNCE and remove the announcer
 and associated forwarding table entries, but will not cause excessive churn with subscribers to notify them yet that
-the publisher is gone. The existing subscribes will linger until the clients decided to unsubscribe. 
+the publisher is gone. The existing subscribes will linger until the clients decide to unsubscribe. 
 
-The MOQT draft-04 includes TRACK_STATUS, which should be used to convey per subscriber and publisher on 
+The MOQT draft-04 has TRACK_STATUS, which should be used to convey per subscriber and publisher on 
 status if there are any subscribers and/or publishers. 
 
 Excessive churn can be seen more often with race conditions, which would benefit from some level of dampening.