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 "buffer.h"
#include "qlog.h"
 
#define IMQUIC_MOQ              7171953

void imquic_moq_init(void);
void imquic_moq_deinit(void);

typedef enum imquic_moq_message_type {
        IMQUIC_MOQ_REQUEST_OK = 0x7,
        IMQUIC_MOQ_REQUEST_ERROR = 0x5,
        IMQUIC_MOQ_REQUEST_UPDATE = 0x2,
        IMQUIC_MOQ_SUBSCRIBE = 0x3,
        IMQUIC_MOQ_SUBSCRIBE_OK = 0x4,
        IMQUIC_MOQ_PUBLISH_NAMESPACE = 0x6,
                IMQUIC_MOQ_PUBLISH_NAMESPACE_DONE = 0x9,        /* Deprecated in v17 */
                IMQUIC_MOQ_UNSUBSCRIBE = 0xa,                           /* Deprecated in v17 */
        IMQUIC_MOQ_PUBLISH_DONE = 0xb,
                IMQUIC_MOQ_PUBLISH_NAMESPACE_CANCEL = 0xc,      /* Deprecated in v17 */
        IMQUIC_MOQ_TRACK_STATUS = 0xd,
        IMQUIC_MOQ_GOAWAY = 0x10,
        IMQUIC_MOQ_SUBSCRIBE_NAMESPACE = 0x50,                  /* Added in v18 */
                IMQUIC_MOQ_SUBSCRIBE_NAMESPACE_v17 = 0x11,      /* Deprecated in v18 */
        IMQUIC_MOQ_SUBSCRIBE_TRACKS = 0x51,                             /* Added in v18 */
        IMQUIC_MOQ_NAMESPACE = 0x8,
        IMQUIC_MOQ_NAMESPACE_DONE = 0xe,
        IMQUIC_MOQ_PUBLISH_SKIPPED = 0xf,
                IMQUIC_MOQ_MAX_REQUEST_ID = 0x15,                       /* Deprecated in v17 */
                IMQUIC_MOQ_REQUESTS_BLOCKED = 0x1A,                     /* Deprecated in v17 */
        IMQUIC_MOQ_FETCH = 0x16,
                IMQUIC_MOQ_FETCH_CANCEL = 0x17,                         /* Deprecated in v17 */
        IMQUIC_MOQ_FETCH_OK = 0x18,
        IMQUIC_MOQ_SETUP = 0x2F00,
                IMQUIC_MOQ_CLIENT_SETUP = 0x20,                         /* Deprecated in v17 */
                IMQUIC_MOQ_SERVER_SETUP = 0x21,                         /* Deprecated in v17 */
        IMQUIC_MOQ_PUBLISH = 0x1D,
                IMQUIC_MOQ_PUBLISH_OK = 0x1E,                           /* Deprecated in v18 */
        IMQUIC_MOQ_PUBLISH_STATE_NOTIFY = 0x22,                 /* Added in v20 */
        IMQUIC_MOQ_PSEUDO_REQUEST = 0x0,                                /* Pseudo request, only needed for FILL_PARAMETERS */
} imquic_moq_message_type;

const char *imquic_moq_message_type_str(imquic_moq_message_type type, imquic_moq_version version);

typedef enum imquic_moq_datagram_message_type {
        IMQUIC_MOQ_OBJECT_DATAGRAM = 0x01,
        IMQUIC_MOQ_OBJECT_DATAGRAM_STATUS = 0x20,
                IMQUIC_MOQ_OBJECT_DATAGRAM_RANGE_MIN = 0x00,
                IMQUIC_MOQ_OBJECT_DATAGRAM_RANGE_MAX = 0x2D,
        IMQUIC_MOQ_PADDING_DATAGRAM = 0x132B3E29,               /* Added in v18 */
} imquic_moq_datagram_message_type;

gboolean imquic_moq_is_datagram_message_type_valid(imquic_moq_version version, uint8_t type);
uint8_t imquic_moq_datagram_message_type_return(imquic_moq_version version,
        gboolean payload, gboolean prop, gboolean eog, gboolean oid, gboolean priority);
void imquic_moq_datagram_message_type_parse(imquic_moq_version version, uint8_t type,
        gboolean *payload, gboolean *prop, gboolean *eog, gboolean *oid, gboolean *priority, gboolean *violation);
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_SUBGROUP_HEADER_XXX */
        IMQUIC_MOQ_SUBGROUP_HEADER = 0x10,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE1_MIN = 0x10,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE1_MAX = 0x1D,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE2_MIN = 0x30,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE2_MAX = 0x3D,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE3_MIN = 0x50,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE3_MAX = 0x5D,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE4_MIN = 0x70,
                IMQUIC_MOQ_SUBGROUP_HEADER_RANGE4_MAX = 0x7D,
        /* IMQUIC_MOQ_FETCH_HEADER */
        IMQUIC_MOQ_FETCH_HEADER = 0x5,
        /* Padding */
        IMQUIC_MOQ_PADDING_STREAM = 0x132B3E28,                         /* Added in v18 */
} imquic_moq_data_message_type;

gboolean imquic_moq_is_data_message_type_valid(imquic_moq_version version, imquic_moq_data_message_type type);
uint8_t imquic_moq_data_message_type_from_subgroup_header(imquic_moq_version version,
        gboolean subgroup, gboolean sgid0, gboolean prop, gboolean eog, gboolean priority, gboolean first_object);
void imquic_moq_data_message_type_to_subgroup_header(imquic_moq_version version, uint8_t type,
        gboolean *subgroup, gboolean *sgid0, gboolean *prop, gboolean *eog, gboolean *priority, gboolean *first_object, gboolean *violation);
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_fetch_subgroup_type {
        IMQUIC_MOQ_FETCH_SUBGROUP_ZERO = 0x00,
        IMQUIC_MOQ_FETCH_SUBGROUP_PREVIOUS = 0x01,
        IMQUIC_MOQ_FETCH_SUBGROUP_PLUS_ONE = 0x02,
        IMQUIC_MOQ_FETCH_SUBGROUP_ID = 0x03,
} imquic_moq_fetch_subgroup_type;

gboolean imquic_moq_is_fetch_serialization_flags_valid(imquic_moq_version version, uint64_t flags);
uint64_t imquic_moq_generate_fetch_serialization_flags(imquic_moq_version version,
        imquic_moq_fetch_subgroup_type subgroup, gboolean oid, gboolean group, gboolean priority, gboolean prop,
        gboolean datagram, gboolean end_ne_range, gboolean end_uk_range, gboolean end_to_range);
void imquic_moq_parse_fetch_serialization_flags(imquic_moq_version version, uint64_t flags,
        imquic_moq_fetch_subgroup_type *subgroup, gboolean *oid, gboolean *group, gboolean *priority, gboolean *prop,
        gboolean *datagram, gboolean *end_ne_range, gboolean *end_uk_range, gboolean *end_to_range, gboolean *violation);

typedef enum imquic_moq_setup_option_type {
        IMQUIC_MOQ_SETUP_OPTION_PATH = 0x01,
        IMQUIC_MOQ_SETUP_OPTION_MAX_REQUEST_ID = 0x02,
        IMQUIC_MOQ_SETUP_OPTION_AUTHORIZATION_TOKEN = 0x03,
        IMQUIC_MOQ_SETUP_OPTION_MAX_AUTH_TOKEN_CACHE_SIZE = 0x04,
        IMQUIC_MOQ_SETUP_OPTION_AUTHORITY = 0x05,
        IMQUIC_MOQ_SETUP_OPTION_MAX_FILTER_RANGES = 0x06,
        IMQUIC_MOQ_SETUP_OPTION_MOQT_IMPLEMENTATION = 0x07,
        IMQUIC_MOQ_SETUP_OPTION_MAX_REQUEST_UPDATES = 0x08,
} imquic_moq_setup_option_type;

const char *imquic_moq_setup_option_type_str(imquic_moq_setup_option_type type);

typedef enum imquic_moq_request_parameter_type {
        IMQUIC_MOQ_REQUEST_PARAM_OBJECT_DELIVERY_TIMEOUT = 0x02,        /* Added in v18 */
                IMQUIC_MOQ_REQUEST_PARAM_DELIVERY_TIMEOUT = 0x02,       /* Deprecated in v18 */
        IMQUIC_MOQ_REQUEST_PARAM_AUTHORIZATION_TOKEN = 0x03,
        IMQUIC_MOQ_REQUEST_PARAM_RENDEZVOUS_TIMEOUT = 0x04,
        IMQUIC_MOQ_REQUEST_PARAM_SUBGROUP_DELIVERY_TIMEOUT = 0x06,      /* Added in v18 */
        IMQUIC_MOQ_REQUEST_PARAM_EXPIRES = 0x8,
        IMQUIC_MOQ_REQUEST_PARAM_LARGEST_OBJECT = 0x9,
        IMQUIC_MOQ_REQUEST_PARAM_FILL_TIMEOUT = 0x0A,   /* Added in v18 */
        IMQUIC_MOQ_REQUEST_PARAM_FORWARD = 0x10,
        IMQUIC_MOQ_REQUEST_PARAM_SUBSCRIBER_PRIORITY = 0x20,
        IMQUIC_MOQ_REQUEST_PARAM_LOCATION_FILTER = 0x21,
        IMQUIC_MOQ_REQUEST_PARAM_GROUP_ORDER = 0x22,
        IMQUIC_MOQ_REQUEST_PARAM_FILL_PARAMETERS = 0x23,
        IMQUIC_MOQ_REQUEST_PARAM_SUBGROUP_FILTER = 0x25,
        IMQUIC_MOQ_REQUEST_PARAM_OBJECT_FILTER = 0x26,
        IMQUIC_MOQ_REQUEST_PARAM_PRIORITY_FILTER = 0x27,
        IMQUIC_MOQ_REQUEST_PARAM_OBJECT_PROPERTY_FILTER = 0x28,
        IMQUIC_MOQ_REQUEST_PARAM_TRACK_PROPERTY_FILTER = 0x29,
        IMQUIC_MOQ_REQUEST_PARAM_NEW_GROUP_REQUEST = 0x32,
        IMQUIC_MOQ_REQUEST_PARAM_TRACK_NAMESPACE_PREFIX = 0x34, /* Added in v18 */
        IMQUIC_MOQ_REQUEST_PARAM_INCLUDE_PROPERTIES = 0x35,     /* Added in v20 */
} imquic_moq_request_parameter_type;

const char *imquic_moq_request_parameter_type_str(imquic_moq_request_parameter_type type, imquic_moq_version version);

typedef struct imquic_moq_setup_options {
        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 max_filter_ranges_set;
        uint64_t max_filter_ranges;
        gboolean moqt_implementation_set;
        char moqt_implementation[256];
        gboolean max_request_updates_set;
        uint64_t max_request_updates;
        gboolean unknown;
} imquic_moq_setup_options;

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_context {
        imquic_connection *conn;
        GList *supported_versions;
        imquic_moq_version version;
        gboolean do_grease;
        char *peer_implementation;
        uint8_t *auth;
        size_t authlen;
        gboolean auth_set;
        gboolean is_server;
        gboolean has_control_stream;
        uint64_t control_stream_id, remote_control_stream_id;
        gboolean sent_setup, recvd_setup;
        GHashTable *streams;
        GHashTable *streams_by_reqid;
        GHashTable *subscriptions;
        GHashTable *subscriptions_by_id;
        GHashTable *fill_fetches_by_id;
        GHashTable *requests;
        GHashTable *update_requests;
        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;
        uint64_t max_filter_ranges, local_max_filter_ranges;
        uint64_t max_request_updates, local_max_request_updates;
        imquic_buffer *buffer;
        imquic_mutex mutex;
        volatile gint connected;
        volatile gint check_pending;
        volatile gint got_goaway;
        volatile gint destroyed;
        imquic_refcount ref;
} imquic_moq_context;

typedef enum imquic_media_stream_request_state {
        IMQUIC_MOQ_REQUEST_STATE_NEW = 0,
        IMQUIC_MOQ_REQUEST_STATE_SENT,
        IMQUIC_MOQ_REQUEST_STATE_OK,
        IMQUIC_MOQ_REQUEST_STATE_ERROR,
        IMQUIC_MOQ_REQUEST_STATE_UPDATE_SENT,
        IMQUIC_MOQ_REQUEST_STATE_DONE,
} imquic_media_stream_request_state;

const char *imquic_media_stream_request_state_str(imquic_media_stream_request_state state);

typedef struct imquic_moq_stream {
        uint64_t stream_id;
        imquic_moq_message_type request_type;
        gboolean request_sender;
        imquic_media_stream_request_state request_state;
        imquic_moq_namespace *namespace_prefix, *last_tuple;
        uint8_t namespace_prefix_size;
        GHashTable *namespaces;
        imquic_moq_data_message_type type;
        uint64_t request_id, update_request_id;
        uint64_t track_alias;
        uint64_t group_id;
        uint64_t subgroup_id;
        uint64_t object_id;
        imquic_moq_object_status object_status;
        gboolean fill_fetch;
        gboolean ascending;
        gboolean priority_set;
        uint8_t priority;
        gboolean first_of_subgroup;
        imquic_buffer *buffer;
        gboolean got_objects;
        uint64_t last_group_id;
        uint64_t last_subgroup_id;
        uint64_t last_object_id;
        uint8_t last_priority;
        gboolean closed;
        imquic_mutex mutex;
        volatile gint destroyed;
        imquic_refcount ref;
} imquic_moq_stream;

imquic_moq_stream *imquic_moq_stream_create(void);
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;
        gboolean fill_fetch;
        gboolean ascending;
        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, uint8_t *error);
size_t imquic_moq_parse_server_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen, 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_request_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_request_error(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream, 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, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_request_update(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream, 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_state_notify(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_done(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_tracks(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_namespace_done(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_publish_skipped(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_fetch(imquic_moq_context *moq, imquic_moq_stream *moq_stream, 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, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_track_status(imquic_moq_context *moq, imquic_moq_stream *moq_stream, 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_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_padding_datagram(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
int imquic_moq_parse_padding_stream(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete, uint8_t *error);
size_t imquic_moq_parse_goaway(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);


size_t imquic_moq_add_client_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_setup_options *options);
size_t imquic_moq_add_server_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_setup_options *options);
size_t imquic_moq_add_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_setup_options *options);
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_request_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id, imquic_moq_request_parameters *parameters, GList *track_properties);
size_t imquic_moq_add_request_error(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id, uint64_t error, const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
size_t imquic_moq_add_publish_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_publish_namespace_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_publish_namespace_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_request_error_code error, const char *reason);
size_t imquic_moq_add_publish(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_track *track_name, uint64_t track_alias,
        imquic_moq_request_parameters *parameters, GList *track_properties);
size_t imquic_moq_add_publish_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_subscribe(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_track *track_name, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_request_update(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id, uint64_t sub_request_id, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_subscribe_ok(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
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_state_notify(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_publish_done(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_pub_done_code status, uint64_t streams_count, const char *reason);
size_t imquic_moq_add_subscribe_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_subscribe_namespace_options subscribe_options, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_subscribe_tracks(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_namespace(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace_suffix);
size_t imquic_moq_add_namespace_done(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace_suffix);
size_t imquic_moq_add_publish_skipped(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace_suffix, imquic_moq_track *track);
size_t imquic_moq_add_fetch(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        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_track *track_name,
        imquic_moq_location_range *range, imquic_moq_request_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, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        uint8_t end_of_track, imquic_moq_location *end_location, imquic_moq_request_parameters *parameters, GList *track_properties);
size_t imquic_moq_add_track_status(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_namespace *track_namespace, imquic_moq_track *track_name, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_goaway(imquic_moq_context *moq, imquic_moq_stream *moq_stream,
        uint8_t *bytes, size_t blen, uint64_t request_id, const char *new_session_uri, uint64_t timeout);
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, gboolean priority_set, uint8_t priority,
        uint8_t *payload_prefix, size_t pplen, uint8_t *payload, size_t plen, uint8_t *properties, size_t prlen);
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, gboolean priority_set, uint8_t priority,
        uint64_t object_status, uint8_t *properties, size_t prlen);
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, gboolean priority_set, 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_prefix, size_t pplen, uint8_t *payload, size_t plen, uint8_t *properties, size_t prlen);
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 flags, uint64_t group_id, uint64_t subgroup_id, uint64_t object_id, gboolean priority_set, uint8_t priority,
        uint8_t *payload_prefix, size_t pplen, uint8_t *payload, size_t plen, uint8_t *properties, size_t prlen);
size_t imquic_moq_add_padding(imquic_moq_context *moq, uint8_t *bytes, size_t blen, size_t padding, gboolean datagram);
size_t imquic_moq_add_properties(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint8_t *properties, size_t prlen, gboolean prefix);


size_t imquic_moq_setup_option_add_int(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t opt, uint64_t prev, uint64_t number);
size_t imquic_moq_setup_option_add_data(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t opt, uint64_t prev, uint8_t *buf, size_t buflen);
size_t imquic_moq_parse_setup_option(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_setup_options *params, uint64_t *param_type, uint8_t *error);
size_t imquic_moq_setup_options_serialize(imquic_moq_context *moq,
        imquic_moq_setup_options *options,
        uint8_t *bytes, size_t blen, uint8_t *params_num);


size_t imquic_moq_parameter_add_varint(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t param, uint64_t prev, uint64_t number);
size_t imquic_moq_parameter_add_uint8(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t param, uint64_t prev, uint8_t number);
size_t imquic_moq_parameter_add_location(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t param, uint64_t prev, imquic_moq_location *location);
size_t imquic_moq_parameter_add_location_filter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t param, uint64_t prev, imquic_moq_location_filter *location_filter);
size_t imquic_moq_parameter_add_data(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t param, uint64_t prev, uint8_t *buf, size_t buflen);
size_t imquic_moq_parse_request_parameter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_request_parameters *params, uint64_t *param_type, uint8_t *error);
size_t imquic_moq_request_parameters_serialize(imquic_moq_context *moq,
        imquic_moq_message_type request, imquic_moq_request_parameters *parameters,
        uint8_t *bytes, size_t blen, uint8_t *params_num);
size_t imquic_moq_parse_request_parameters(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_request_parameters *params, uint64_t *params_num, uint8_t *error);

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, imquic_moq_request_parameters *parameters);
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code, const char *reason);
        void (* publish_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* publish_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* publish_namespace_done)(imquic_connection *conn, uint64_t request_id);
        void (* incoming_publish)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn,
                uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
        void (* publish_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* publish_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
        void (* subscribe_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* request_updated)(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_request_parameters *parameters);
        void (* request_update_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* request_update_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* publish_state_notify)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* publish_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_pub_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, imquic_moq_subscribe_namespace_options subscribe_options, imquic_moq_request_parameters *parameters);
        void (* subscribe_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* subscribe_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, uint64_t request_id);
        void (* incoming_subscribe_tracks)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters);
        void (* subscribe_tracks_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
        void (* subscribe_tracks_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* incoming_unsubscribe_tracks)(imquic_connection *conn, uint64_t request_id);
        void (* incoming_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
        void (* incoming_namespace_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
        void (* incoming_publish_skipped)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn);
        void (* incoming_fetch)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_location_range *range, imquic_moq_request_parameters *parameters);
        void (* incoming_joining_fetch)(imquic_connection *conn, uint64_t request_id, uint64_t joining_request_id,
                gboolean absolute, uint64_t joining_start, imquic_moq_request_parameters *parameters);
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t request_id);
        void (* fetch_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_location *largest, imquic_moq_request_parameters *parameters, GList *track_properties);
        void (* fetch_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* incoming_track_status)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters, GList *track_properties);
        void (* track_status_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code,
                const char *reason, uint64_t retry_interval, imquic_moq_redirect *redirect);
        void (* incoming_object)(imquic_connection *conn, imquic_moq_object *object);
        void (* incoming_goaway)(imquic_connection *conn, const char *uri, uint64_t timeout);
        void (* incoming_request_goaway)(imquic_connection *conn, uint64_t request_id, const char *uri, uint64_t timeout);
        void (* connection_gone)(imquic_connection *conn, uint64_t error_code, const char *reason);
} 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 length, gboolean complete);
void imquic_moq_datagram_incoming(imquic_connection *conn, uint8_t *bytes, uint64_t length);
void imquic_moq_reset_stream_incoming(imquic_connection *conn, uint64_t stream_id, uint64_t error_code);
void imquic_moq_stop_sending_incoming(imquic_connection *conn, uint64_t stream_id, uint64_t error_code);
void imquic_moq_connection_gone(imquic_connection *conn, uint64_t error_code, const char *reason);


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, const char *name);
void imquic_qlog_moq_message_add_track(json_t *message, imquic_moq_track *track_name);
void imquic_qlog_moq_message_add_setup_options(json_t *message, imquic_moq_setup_options *options, const char *name);
void imquic_qlog_moq_message_add_request_parameters(json_t *message, imquic_moq_version version,
        imquic_moq_request_parameters *parameters, const char *name);
void imquic_qlog_moq_message_add_properties(json_t *message, GList *properties, const char *name);
void imquic_moq_qlog_control_message_created(imquic_qlog *qlog, uint64_t stream_id, uint8_t *bytes, size_t length, json_t *message);
void imquic_moq_qlog_control_message_parsed(imquic_qlog *qlog, uint64_t stream_id, uint8_t *bytes, 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_stream_closed(imquic_qlog *qlog, gboolean local, uint64_t stream_id, const char *cause, uint64_t error_code);
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, uint8_t *bytes, size_t length);
void imquic_moq_qlog_subgroup_header_parsed(imquic_qlog *qlog, imquic_moq_stream *stream, uint8_t *bytes, size_t length);
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, uint8_t *bytes, size_t length);
void imquic_moq_qlog_fetch_header_parsed(imquic_qlog *qlog, imquic_moq_stream *stream, uint8_t *bytes, size_t length);
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