internal/moq.h

Go to the documentation of this file.

 
#ifndef IMQUIC_MOQ_INTERNAL_H
#define IMQUIC_MOQ_INTERNAL_H
 
#include <stddef.h>
#include <stdint.h>
 
#include <glib.h>
 
#include "../imquic/imquic.h"
#include "../imquic/moq.h"
#include "utils.h"
#include "qlog.h"
#include "refcount.h"
 
#define IMQUIC_MOQ              7171953
 
void imquic_moq_init(void);
void imquic_moq_deinit(void);
 
typedef enum imquic_moq_message_type {
        IMQUIC_MOQ_SUBSCRIBE_UPDATE = 0x2,
        IMQUIC_MOQ_SUBSCRIBE = 0x3,
        IMQUIC_MOQ_SUBSCRIBE_OK = 0x4,
        IMQUIC_MOQ_SUBSCRIBE_ERROR = 0x5,
        IMQUIC_MOQ_PUBLISH_NAMESPACE = 0x6,
        IMQUIC_MOQ_PUBLISH_NAMESPACE_OK = 0x7,
        IMQUIC_MOQ_PUBLISH_NAMESPACE_ERROR = 0x8,
        IMQUIC_MOQ_PUBLISH_NAMESPACE_DONE = 0x9,
        IMQUIC_MOQ_UNSUBSCRIBE = 0xa,
        IMQUIC_MOQ_PUBLISH_DONE = 0xb,
        IMQUIC_MOQ_PUBLISH_NAMESPACE_CANCEL = 0xc,
        IMQUIC_MOQ_TRACK_STATUS = 0xd,
        IMQUIC_MOQ_TRACK_STATUS_OK = 0xe,
        IMQUIC_MOQ_TRACK_STATUS_ERROR = 0xf,
        IMQUIC_MOQ_GOAWAY = 0x10,
        IMQUIC_MOQ_SUBSCRIBE_NAMESPACE = 0x11,
        IMQUIC_MOQ_SUBSCRIBE_NAMESPACE_OK = 0x12,
        IMQUIC_MOQ_SUBSCRIBE_NAMESPACE_ERROR = 0x13,
        IMQUIC_MOQ_UNSUBSCRIBE_NAMESPACE = 0x14,
        IMQUIC_MOQ_MAX_REQUEST_ID = 0x15,
        IMQUIC_MOQ_REQUESTS_BLOCKED = 0x1A,
        IMQUIC_MOQ_FETCH = 0x16,
        IMQUIC_MOQ_FETCH_CANCEL = 0x17,
        IMQUIC_MOQ_FETCH_OK = 0x18,
        IMQUIC_MOQ_FETCH_ERROR = 0x19,
        IMQUIC_MOQ_CLIENT_SETUP = 0x20,
        IMQUIC_MOQ_SERVER_SETUP = 0x21,
        IMQUIC_MOQ_PUBLISH = 0x1D,
        IMQUIC_MOQ_PUBLISH_OK = 0x1E,
        IMQUIC_MOQ_PUBLISH_ERROR = 0x1F,
        IMQUIC_MOQ_CLIENT_SETUP_LEGACY = 0x40,
        IMQUIC_MOQ_SERVER_SETUP_LEGACY = 0x41,
} imquic_moq_message_type;
const char *imquic_moq_message_type_str(imquic_moq_message_type type);
 
typedef enum imquic_moq_datagram_message_type {
        /* OBJECT_DATAGRAM */
        IMQUIC_MOQ_OBJECT_DATAGRAM = 0x1,
                IMQUIC_MOQ_OBJECT_DATAGRAM_NOEXT = 0x0,
                IMQUIC_MOQ_OBJECT_DATAGRAM_EOG = 0x3,
                IMQUIC_MOQ_OBJECT_DATAGRAM_EOG_NOEXT = 0x2,
                IMQUIC_MOQ_OBJECT_DATAGRAM_NOOID = 0x5,
                IMQUIC_MOQ_OBJECT_DATAGRAM_NOEXT_NOOID = 0x4,
                IMQUIC_MOQ_OBJECT_DATAGRAM_EOG_NOOID = 0x7,
                IMQUIC_MOQ_OBJECT_DATAGRAM_EOG_NOEXT_NOOID = 0x6,
        /* OBJECT_DATAGRAM_STATUS */
        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS = 0x20,
                IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS_NOEXT = 0x21,
                        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS_v13 = 0x5,            /* Deprecated in v14 */
                        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS_NOEXT_v13 = 0x4,      /* Deprecated in v14 */
                        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS_v11 = 0x3,            /* Deprecated in v12 */
                        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS_NOEXT_v11 = 0x2,      /* Deprecated in v12 */
} imquic_moq_datagram_message_type;
imquic_moq_datagram_message_type imquic_moq_datagram_message_type_return(imquic_moq_version version, gboolean ext, gboolean eog, gboolean oid);
void imquic_moq_datagram_message_type_parse(imquic_moq_version version, imquic_moq_datagram_message_type type, gboolean *ext, gboolean *eog, gboolean *oid);
const char *imquic_moq_datagram_message_type_str(imquic_moq_datagram_message_type type, imquic_moq_version version);
 
typedef enum imquic_moq_data_message_type {
        IMQUIC_MOQ_STREAM_HEADER_TRACK = 0x2,   /* Deprecated in v07 */
        IMQUIC_MOQ_SUBGROUP_HEADER_LEGACY = 0x4,        /* Deprecated in v11 for the values below */
                /* v11 */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0_NOEXT_v11 = 0x8,     /* Deprecated in v12 */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0_v11 = 0x9,           /* Deprecated in v12 */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID_NOEXT_v11 = 0xA,      /* Deprecated in v12 */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID_v11 = 0xB,            /* Deprecated in v12 */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOEXT_v11 = 0xC,                     /* Deprecated in v12 */
                IMQUIC_MOQ_SUBGROUP_HEADER_v11 = 0xD,                           /* Deprecated in v12 */
                /* v12 and beyond */
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0_NOEXT = 0x10,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0 = 0x11,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID_NOEXT = 0x12,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID = 0x13,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOEXT = 0x14,
                IMQUIC_MOQ_SUBGROUP_HEADER = 0x15,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0_NOEXT_EOG = 0x18,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID0_EOG = 0x19,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID_NOEXT_EOG = 0x1A,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOSGID_EOG = 0x1B,
                IMQUIC_MOQ_SUBGROUP_HEADER_NOEXT_EOG = 0x1C,
                IMQUIC_MOQ_SUBGROUP_HEADER_EOG = 0x1D,
        IMQUIC_MOQ_FETCH_HEADER = 0x5,
} imquic_moq_data_message_type;
imquic_moq_data_message_type imquic_moq_data_message_type_from_subgroup_header(imquic_moq_version version, gboolean subgroup, gboolean sgid0, gboolean ext, gboolean eog);
void imquic_moq_data_message_type_to_subgroup_header(imquic_moq_version version, imquic_moq_data_message_type type, gboolean *subgroup, gboolean *sgid0, gboolean *ext, gboolean *eog);
const char *imquic_moq_data_message_type_str(imquic_moq_data_message_type type, imquic_moq_version version);
imquic_moq_delivery imquic_moq_data_message_type_to_delivery(imquic_moq_data_message_type type, imquic_moq_version version);
 
typedef enum imquic_moq_setup_parameter_type {
        IMQUIC_MOQ_SETUP_PARAM_ROLE = 0x00,     /* Deprecated since v08 */
        IMQUIC_MOQ_SETUP_PARAM_PATH = 0x01,
        IMQUIC_MOQ_SETUP_PARAM_MAX_REQUEST_ID = 0x02,
        IMQUIC_MOQ_SETUP_PARAM_AUTHORIZATION_TOKEN = 0x03,
        IMQUIC_MOQ_SETUP_PARAM_MAX_AUTH_TOKEN_CACHE_SIZE = 0x04,
        IMQUIC_MOQ_SETUP_PARAM_AUTHORITY = 0x05,
        IMQUIC_MOQ_SETUP_PARAM_MOQT_IMPLEMENTATION = 0x07,
} imquic_moq_setup_parameter_type;
const char *imquic_moq_setup_parameter_type_str(imquic_moq_setup_parameter_type type);
 
typedef enum imquic_moq_subscribe_parameter_type {
        IMQUIC_MOQ_SUB_PARAM_AUTHORIZATION_TOKEN_v11 = 0x01,    /* Deprecated in v12 */
                IMQUIC_MOQ_SUB_PARAM_AUTHORIZATION_INFO = 0x02, /* Deprecated in v11 for the value above */
        IMQUIC_MOQ_SUB_PARAM_DELIVERY_TIMEOUT = 0x02,
                IMQUIC_MOQ_SUB_PARAM_DELIVERY_TIMEOUT_LEGACY = 0x03,    /* Deprecated in v11 for the value above */
        IMQUIC_MOQ_SUB_PARAM_AUTHORIZATION_TOKEN = 0x03,
        IMQUIC_MOQ_SUB_PARAM_MAX_CACHE_DURATION = 0x04,
} imquic_moq_subscribe_parameter_type;
const char *imquic_moq_subscribe_parameter_type_str(imquic_moq_subscribe_parameter_type type, imquic_moq_version version);
 
typedef enum imquic_moq_role_type {
        IMQUIC_MOQ_ROLE_ENDPOINT = 0x00,        /* Not a real role: since -08, there are no more roles */
        IMQUIC_MOQ_ROLE_PUBLISHER = 0x01,
        IMQUIC_MOQ_ROLE_SUBSCRIBER = 0x02,
        IMQUIC_MOQ_ROLE_PUBSUB = 0x03
} imquic_moq_role_type;
const char *imquic_moq_role_type_str(imquic_moq_role_type type);
 
typedef struct imquic_moq_setup_parameters {
        gboolean role_set;
        imquic_moq_role_type role;
        gboolean path_set;
        char path[256];
        gboolean max_request_id_set;
        uint64_t max_request_id;
        gboolean max_auth_token_cache_size_set;
        uint64_t max_auth_token_cache_size;
        gboolean auth_token_set;
        uint8_t auth_token[256];
        size_t auth_token_len;
        gboolean authority_set;
        char authority[256];
        gboolean moqt_implementation_set;
        char moqt_implementation[256];
        gboolean unknown;
} imquic_moq_setup_parameters;
 
typedef struct imquic_moq_subscribe_parameters {
        gboolean auth_token_set;
        uint8_t auth_token[256];
        size_t auth_token_len;
        gboolean delivery_timeout_set;
        uint64_t delivery_timeout;
        gboolean max_cache_duration_set;
        uint64_t max_cache_duration;
        gboolean unknown;
} imquic_moq_subscribe_parameters;
 
typedef enum imquic_moq_group_order {
        IMQUIC_MOQ_ORDERING_ORIGINAL = 0x0,
        IMQUIC_MOQ_ORDERING_ASCENDING = 0x1,
        IMQUIC_MOQ_ORDERING_DESCENDING = 0x2,
} imquic_moq_group_order;
const char *imquic_moq_group_order_str(imquic_moq_group_order type);
 
typedef enum imquic_moq_fetch_type {
        IMQUIC_MOQ_FETCH_STANDALONE = 0x01,
        IMQUIC_MOQ_FETCH_JOINING_RELATIVE = 0x02,
        IMQUIC_MOQ_FETCH_JOINING_ABSOLUTE = 0x03,
} imquic_moq_fetch_type;
const char *imquic_moq_fetch_type_str(imquic_moq_fetch_type type);
 
typedef struct imquic_moq_buffer {
        uint8_t *bytes;
        uint64_t length;
        uint64_t size;
} imquic_moq_buffer;
gboolean imquic_moq_buffer_resize(imquic_moq_buffer *buffer, uint64_t new_size);
void imquic_moq_buffer_append(imquic_moq_buffer *buffer, uint8_t *bytes, uint64_t length);
void imquic_moq_buffer_shift(imquic_moq_buffer *buffer, uint64_t length);
void imquic_moq_buffer_destroy(imquic_moq_buffer *buffer);
 
typedef struct imquic_moq_context {
        imquic_connection *conn;
        GList *supported_versions;
        imquic_moq_version version;
        gboolean version_set;
        imquic_moq_role_type type;
        gboolean role_set;
        uint8_t *auth;
        size_t authlen;
        gboolean auth_set;
        gboolean is_server;
        gboolean has_control_stream;
        uint64_t control_stream_id;
        uint64_t control_stream_offset;
        GHashTable *streams;
        GHashTable *subscriptions;
        GHashTable *subscriptions_by_id;
        uint64_t expected_request_id, next_request_id;
        uint64_t max_request_id, local_max_request_id;
        uint64_t max_auth_token_cache_size, local_max_auth_token_cache_size;
        imquic_moq_buffer *buffer;
        imquic_mutex mutex;
        volatile gint connected;
        volatile gint destroyed;
        imquic_refcount ref;
} imquic_moq_context;
 
typedef struct imquic_moq_stream {
        imquic_moq_data_message_type type;
        uint64_t stream_id;
        uint64_t request_id;
        uint64_t track_alias;
        uint64_t group_id;
        uint64_t subgroup_id;
        uint64_t object_id;
        imquic_moq_object_status object_status;
        uint8_t priority;
        uint64_t stream_offset;
        imquic_moq_buffer *buffer;
        gboolean got_objects;
        uint64_t last_object_id;
        gboolean closed;
} imquic_moq_stream;
void imquic_moq_stream_destroy(imquic_moq_stream *moq_stream);
 
typedef struct imquic_moq_subscription {
        uint64_t request_id;
        uint64_t track_alias;
        gboolean fetch;
        imquic_moq_stream *stream;
        GHashTable *streams_by_subgroup;
        size_t streams_count;
} imquic_moq_subscription;
imquic_moq_subscription *imquic_moq_subscription_create(uint64_t request_id, uint64_t track_alias);
void imquic_moq_subscription_destroy(imquic_moq_subscription *moq_sub);
 
 
int imquic_moq_parse_message(imquic_moq_context *moq, uint64_t stream_id, uint8_t *bytes, size_t blen, gboolean complete, gboolean datagram);
size_t imquic_moq_parse_client_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen, gboolean legacy, uint8_t *error);
size_t imquic_moq_parse_server_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen, gboolean legacy, uint8_t *error);
size_t imquic_moq_parse_max_request_id(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_requests_blocked(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_update(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_unsubscribe(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_namespace_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_unsubscribe_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_fetch(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_fetch_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_fetch_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_fetch_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_track_status(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_track_status_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_track_status_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_object_datagram(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_datagram_message_type dtype, uint8_t *error);
size_t imquic_moq_parse_object_datagram_status(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_datagram_message_type dtype, uint8_t *error);
size_t imquic_moq_parse_stream_header_track(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
int imquic_moq_parse_stream_header_track_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete, uint8_t *error);
size_t imquic_moq_parse_subgroup_header(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, imquic_moq_data_message_type dtype, uint8_t *error);
int imquic_moq_parse_subgroup_header_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete, uint8_t *error);
size_t imquic_moq_parse_fetch_header(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
int imquic_moq_parse_fetch_header_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete, uint8_t *error);
size_t imquic_moq_parse_goaway(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
 
 
size_t imquic_moq_add_control_message(imquic_moq_context *moq, imquic_moq_message_type type,
        uint8_t *bytes, size_t blen, size_t poffset, size_t plen, size_t *start);
size_t imquic_moq_add_client_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        GList *supported_versions, imquic_moq_setup_parameters *parameters);
size_t imquic_moq_add_server_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint32_t version, imquic_moq_setup_parameters *parameters);
size_t imquic_moq_add_max_request_id(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t max_request_id);
size_t imquic_moq_add_requests_blocked(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t max_request_id);
size_t imquic_moq_add_publish_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_publish_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_publish_namespace_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace,
        imquic_moq_publish_namespace_error_code error, const char *reason);
size_t imquic_moq_add_publish_namespace_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_publish_namespace_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace,
        imquic_moq_publish_namespace_error_code error, const char *reason);
size_t imquic_moq_add_publish(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint64_t track_alias, uint8_t group_order,
        gboolean content_exists, uint64_t largest_group_id, uint64_t largest_object_id, gboolean forward, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_publish_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        gboolean forward, uint8_t priority, uint8_t group_order,
        imquic_moq_filter_type filter, uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object,
        imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_publish_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_pub_error_code error, const char *reason);
size_t imquic_moq_add_subscribe(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id, uint64_t track_alias,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint8_t priority, uint8_t group_order, gboolean forward,
        imquic_moq_filter_type filter, uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_subscribe_update(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, uint64_t sub_request_id,
        uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object, uint8_t priority,
        gboolean forward, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_subscribe_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        uint64_t track_alias, uint64_t expires, imquic_moq_group_order group_order, gboolean content_exists, uint64_t largest_group_id, uint64_t largest_object_id,
        imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_subscribe_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_sub_error_code error, const char *reason, uint64_t track_alias);
size_t imquic_moq_add_unsubscribe(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_publish_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_sub_done_code status, uint64_t streams_count, const char *reason, gboolean content_exists, uint64_t final_group, uint64_t final_object);
size_t imquic_moq_add_subscribe_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_subscribe_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_subscribe_namespace_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, imquic_moq_namespace *track_namespace,
        imquic_moq_subns_error_code error, const char *reason);
size_t imquic_moq_add_unsubscribe_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_fetch(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_fetch_type type,
        uint64_t request_id, uint64_t joining_request_id, uint64_t preceding_group_offset,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint8_t priority, imquic_moq_group_order group_order,
        imquic_moq_location_range *range, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_fetch_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_fetch_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        uint8_t group_order, uint8_t end_of_track, uint64_t largest_group_id, uint64_t largest_object_id,
        imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_fetch_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_fetch_error_code error, const char *reason);
size_t imquic_moq_add_track_status(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint8_t priority, uint8_t group_order, gboolean forward,
        imquic_moq_filter_type filter, uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object, imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_track_status_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        uint64_t track_alias, uint64_t expires, imquic_moq_group_order group_order, gboolean content_exists, uint64_t largest_group_id, uint64_t largest_object_id,
        imquic_moq_subscribe_parameters *parameters);
size_t imquic_moq_add_track_status_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_sub_error_code error, const char *reason);
size_t imquic_moq_add_object_datagram(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id, uint64_t track_alias,
        uint64_t group_id, uint64_t object_id, uint64_t object_status, uint8_t priority,
        uint8_t *payload, size_t plen, size_t extensions_count, uint8_t *extensions, size_t elen);
size_t imquic_moq_add_object_datagram_status(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t track_alias, uint64_t group_id, uint64_t object_id, uint8_t priority,
        uint64_t object_status, uint8_t *extensions, size_t elen);
size_t imquic_moq_add_stream_header_track(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t request_id, uint64_t track_alias, uint8_t priority);
size_t imquic_moq_add_stream_header_track_object(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t group_id, uint64_t object_id, uint64_t object_status, uint8_t *payload, size_t plen);
size_t imquic_moq_add_subgroup_header(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen,
        uint64_t request_id, uint64_t track_alias, uint64_t group_id, uint64_t subgroup_id, uint8_t priority);
size_t imquic_moq_add_subgroup_header_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t object_id, uint64_t object_status, uint8_t *payload, size_t plen,
        size_t extensions_count, uint8_t *extensions, size_t elen);
size_t imquic_moq_add_fetch_header(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_fetch_header_object(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t group_id, uint64_t subgroup_id, uint64_t object_id, uint8_t priority,
        uint64_t object_status, uint8_t *payload, size_t plen,
        size_t extensions_count, uint8_t *extensions, size_t elen);
size_t imquic_moq_add_goaway(imquic_moq_context *moq, uint8_t *bytes, size_t blen, const char *new_session_uri);
size_t imquic_moq_add_object_extensions(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        size_t extensions_count, uint8_t *extensions, size_t elen);
 
 
size_t imquic_moq_parse_setup_parameter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_setup_parameters *params, uint8_t *error);
size_t imquic_moq_parse_subscribe_parameter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_subscribe_parameters *params, uint8_t *error);
size_t imquic_moq_parameter_add_int(imquic_moq_context *moq, uint8_t *bytes, size_t blen, int param, uint64_t number);
size_t imquic_moq_parameter_add_data(imquic_moq_context *moq, uint8_t *bytes, size_t blen, int param, uint8_t *buf, size_t buflen);
size_t imquic_moq_setup_parameters_serialize(imquic_moq_context *moq,
        imquic_moq_setup_parameters *parameters,
        uint8_t *bytes, size_t blen, uint8_t *params_num);
 
size_t imquic_moq_subscribe_parameters_serialize(imquic_moq_context *moq,
        imquic_moq_subscribe_parameters *parameters,
        uint8_t *bytes, size_t blen, uint8_t *params_num);
 
typedef struct imquic_moq_callbacks {
        void (* new_connection)(imquic_connection *conn, void *user_data);
        uint64_t (* incoming_moq_connection)(imquic_connection *conn, uint8_t *auth, size_t authlen);
        void (* moq_ready)(imquic_connection *conn);
        void (* incoming_publish_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, uint8_t *auth, size_t authlen);
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, imquic_moq_namespace *tns, imquic_moq_publish_namespace_error_code error_code, const char *reason);
        void (* publish_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
        void (* publish_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_publish_namespace_error_code error_code, const char *reason);
        void (* publish_namespace_done)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* incoming_publish)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_name *tn, uint64_t track_alias,
                gboolean descending, imquic_moq_location *largest, gboolean forward, uint8_t *auth, size_t authlen);
        void (* publish_accepted)(imquic_connection *conn, uint64_t request_id, gboolean forward, uint8_t priority, gboolean descending,
                imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen);
        void (* publish_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_pub_error_code error_code, const char *reason);
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_namespace *tns, imquic_moq_name *tn,
                uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen);
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest);
        void (* subscribe_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason, uint64_t track_alias);
        void (* subscribe_updated)(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_location *start_location, uint64_t end_group, uint8_t priority, gboolean forward);
        void (* publish_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_done_code status_code, uint64_t streams_count, const char *reason);
        void (* incoming_unsubscribe)(imquic_connection *conn, uint64_t request_id);
        void (* requests_blocked)(imquic_connection *conn, uint64_t max_request_id);
        void (* incoming_subscribe_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, uint8_t *auth, size_t authlen);
        void (* subscribe_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
        void (* subscribe_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_subns_error_code error_code, const char *reason);
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* incoming_standalone_fetch)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_name *tn, gboolean descending, imquic_moq_location_range *range, uint8_t *auth, size_t authlen);
        void (* incoming_joining_fetch)(imquic_connection *conn, uint64_t request_id, uint64_t joining_request_id,
                gboolean absolute, uint64_t joining_start, gboolean descending, uint8_t *auth, size_t authlen);
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t request_id);
        void (* fetch_accepted)(imquic_connection *conn, uint64_t request_id, gboolean descending, imquic_moq_location *largest);
        void (* fetch_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_fetch_error_code error_code, const char *reason);
        void (* incoming_track_status)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_name *tn,
                uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen);
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest);
        void (* track_status_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason);
        void (* incoming_object)(imquic_connection *conn, imquic_moq_object *object);
        void (* incoming_goaway)(imquic_connection *conn, const char *uri);
        void (* connection_gone)(imquic_connection *conn);
} imquic_moq_callbacks;
 
 
void imquic_moq_new_connection(imquic_connection *conn, void *user_data);
void imquic_moq_stream_incoming(imquic_connection *conn, uint64_t stream_id,
        uint8_t *bytes, uint64_t offset, uint64_t length, gboolean complete);
void imquic_moq_datagram_incoming(imquic_connection *conn, uint8_t *bytes, uint64_t length);
void imquic_moq_connection_gone(imquic_connection *conn);
 
#ifdef HAVE_QLOG
 
json_t *imquic_qlog_moq_message_prepare(const char *type);
void imquic_qlog_moq_message_add_namespace(json_t *message, imquic_moq_namespace *track_namespace);
void imquic_qlog_moq_message_add_track(json_t *message, imquic_moq_name *track_name);
void imquic_qlog_moq_message_add_setup_parameters(json_t *message, imquic_moq_setup_parameters *parameters, const char *name);
void imquic_qlog_moq_message_add_subscribe_parameters(json_t *message, imquic_moq_subscribe_parameters *parameters, const char *name);
void imquic_moq_qlog_control_message_created(imquic_qlog *qlog, uint64_t stream_id, size_t length, json_t *message);
void imquic_moq_qlog_control_message_parsed(imquic_qlog *qlog, uint64_t stream_id, size_t length, json_t *message);
void imquic_moq_qlog_stream_type_set(imquic_qlog *qlog, gboolean local, uint64_t stream_id, const char *type);
void imquic_moq_qlog_object_datagram_created(imquic_qlog *qlog, imquic_moq_object *object);
void imquic_moq_qlog_object_datagram_parsed(imquic_qlog *qlog, imquic_moq_object *object);
void imquic_moq_qlog_object_datagram_status_created(imquic_qlog *qlog, imquic_moq_object *object);
void imquic_moq_qlog_object_datagram_status_parsed(imquic_qlog *qlog, imquic_moq_object *object);
void imquic_moq_qlog_subgroup_header_created(imquic_qlog *qlog, imquic_moq_stream *stream);
void imquic_moq_qlog_subgroup_header_parsed(imquic_qlog *qlog, imquic_moq_stream *stream);
void imquic_moq_qlog_subgroup_object_created(imquic_qlog *qlog, uint64_t stream_id, imquic_moq_object *object);
void imquic_moq_qlog_subgroup_object_parsed(imquic_qlog *qlog, uint64_t stream_id, imquic_moq_object *object);
void imquic_moq_qlog_fetch_header_created(imquic_qlog *qlog, imquic_moq_stream *stream);
void imquic_moq_qlog_fetch_header_parsed(imquic_qlog *qlog, imquic_moq_stream *stream);
void imquic_moq_qlog_fetch_object_created(imquic_qlog *qlog, uint64_t stream_id, imquic_moq_object *object);
void imquic_moq_qlog_fetch_object_parsed(imquic_qlog *qlog, uint64_t stream_id, imquic_moq_object *object);
#endif
 
#endif