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_REQUEST_OK = 0x5,                                               /* Added in v15 */
        IMQUIC_MOQ_REQUEST_ERROR = 0x7,                                         /* Added in v15 */
        IMQUIC_MOQ_REQUEST_UPDATE = 0x2,
        IMQUIC_MOQ_SUBSCRIBE = 0x3,
        IMQUIC_MOQ_SUBSCRIBE_OK = 0x4,
                IMQUIC_MOQ_SUBSCRIBE_ERROR = 0x5,                             /* Deprecated in v15 */
        IMQUIC_MOQ_PUBLISH_NAMESPACE = 0x6,
                IMQUIC_MOQ_PUBLISH_NAMESPACE_OK = 0x7,                   /* Deprecated in v15 */
                IMQUIC_MOQ_PUBLISH_NAMESPACE_ERROR = 0x8,             /* Deprecated in v15 */
        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,                             /* Deprecated in v15 */
                IMQUIC_MOQ_TRACK_STATUS_ERROR = 0xf,                       /* Deprecated in v15 */
        IMQUIC_MOQ_GOAWAY = 0x10,
        IMQUIC_MOQ_SUBSCRIBE_NAMESPACE = 0x11,
                IMQUIC_MOQ_SUBSCRIBE_NAMESPACE_OK = 0x12,              /* Deprecated in v15 */
                IMQUIC_MOQ_SUBSCRIBE_NAMESPACE_ERROR = 0x13,        /* Deprecated in v15 */
        IMQUIC_MOQ_UNSUBSCRIBE_NAMESPACE = 0x14,                        /* Deprecated in v16 */
        IMQUIC_MOQ_NAMESPACE = 0x8,                                                 /* Added in v16 */
        IMQUIC_MOQ_NAMESPACE_DONE = 0xe,                                       /* Added in v16 */
        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,                                    /* Deprecated in v15 */
        IMQUIC_MOQ_CLIENT_SETUP = 0x20,
        IMQUIC_MOQ_SERVER_SETUP = 0x21,
        IMQUIC_MOQ_PUBLISH = 0x1D,
        IMQUIC_MOQ_PUBLISH_OK = 0x1E,
                IMQUIC_MOQ_PUBLISH_ERROR = 0x1F,                                /* Deprecated in v15 */
} 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_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 ext, gboolean eog, gboolean oid, gboolean priority);
void imquic_moq_datagram_message_type_parse(imquic_moq_version version, uint8_t type,
        gboolean *payload, gboolean *ext, gboolean *eog, gboolean *oid, gboolean *priority, gboolean *violation);
const char *imquic_moq_datagram_message_type_str(uint8_t type, imquic_moq_version version);

typedef enum imquic_moq_data_message_type {
        /* IMQUIC_MOQ_SUBGROUP_HEADER_XXX */
                /* 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 = 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_FETCH_HEADER */
        IMQUIC_MOQ_FETCH_HEADER = 0x5,
} imquic_moq_data_message_type;

gboolean imquic_moq_is_data_message_type_valid(imquic_moq_version version, uint8_t type);
uint8_t imquic_moq_data_message_type_from_subgroup_header(imquic_moq_version version,
        gboolean subgroup, gboolean sgid0, gboolean ext, gboolean eog, gboolean priority);
void imquic_moq_data_message_type_to_subgroup_header(imquic_moq_version version, uint8_t type,
        gboolean *subgroup, gboolean *sgid0, gboolean *ext, gboolean *eog, gboolean *priority, 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 ext,
        gboolean datagram, gboolean end_ne_range, gboolean end_uk_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 *ext,
        gboolean *datagram, gboolean *end_ne_range, gboolean *end_uk_range, gboolean *violation);

typedef enum imquic_moq_setup_parameter_type {
        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_request_parameter_type {
        IMQUIC_MOQ_REQUEST_PARAM_AUTHORIZATION_TOKEN_v11 = 0x01,        /* Deprecated in v12 */
        IMQUIC_MOQ_REQUEST_PARAM_AUTHORIZATION_TOKEN = 0x03,
        IMQUIC_MOQ_REQUEST_PARAM_DELIVERY_TIMEOUT = 0x02,
        IMQUIC_MOQ_REQUEST_PARAM_MAX_CACHE_DURATION = 0x04,          /* Deprecated in v16 */
        IMQUIC_MOQ_REQUEST_PARAM_PUBLISHER_PRIORITY = 0x0E,          /* Deprecated in v16 */
        IMQUIC_MOQ_REQUEST_PARAM_SUBSCRIBER_PRIORITY = 0x20,
        IMQUIC_MOQ_REQUEST_PARAM_GROUP_ORDER = 0x22,
        IMQUIC_MOQ_REQUEST_PARAM_SUBSCRIPTION_FILTER = 0x21,
        IMQUIC_MOQ_REQUEST_PARAM_EXPIRES = 0x8,
        IMQUIC_MOQ_REQUEST_PARAM_LARGEST_OBJECT = 0x9,
        IMQUIC_MOQ_REQUEST_PARAM_FORWARD = 0x10,
        IMQUIC_MOQ_REQUEST_PARAM_DYNAMIC_GROUPS = 0x30,          /* Deprecated in v16 */
        IMQUIC_MOQ_REQUEST_PARAM_NEW_GROUP_REQUEST = 0x32,
} 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_parameters {
        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;

GList *imquic_moq_parse_object_extensions(imquic_moq_version version, uint8_t *extensions, size_t elen);
size_t imquic_moq_build_object_extensions(imquic_moq_version version, GList *extensions, uint8_t *bytes, size_t blen);

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 enum imquic_moq_legacy_error_code {
        IMQUIC_MOQ_OLDERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_OLDERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_OLDERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_OLDERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_OLDERR_UNINTERESTED = 0x4,
        IMQUIC_MOQ_OLDERR_TRACK_DOES_NOT_EXIST = 0x4,
        IMQUIC_MOQ_OLDERR_INVALID_RANGE = 0x5,
        IMQUIC_MOQ_OLDERR_INVALID_JOINING_REQUEST_ID = 0x7,
        IMQUIC_MOQ_OLDERR_UNKNOWN_STATUS_IN_RANGE = 0x8,
        IMQUIC_MOQ_OLDERR_MALFORMED_TRACK = 0x9,
        IMQUIC_MOQ_OLDERR_MALFORMED_AUTH_TOKEN = 0x10,
        IMQUIC_MOQ_OLDERR_EXPIRED_AUTH_TOKEN = 0x12,
} imquic_moq_legacy_error_code;

imquic_moq_legacy_error_code imquic_moq_request_error_code_to_legacy(imquic_moq_version version, imquic_moq_request_error_code code);
imquic_moq_request_error_code imquic_moq_request_error_code_from_legacy(imquic_moq_version version, imquic_moq_legacy_error_code code);

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;
        char *peer_implementation;
        uint8_t *auth;
        size_t authlen;
        gboolean auth_set;
        gboolean is_server;
        gboolean has_control_stream;
        uint64_t control_stream_id;
        GHashTable *streams;
        GHashTable *subscriptions;
        GHashTable *subscriptions_by_id;
        GHashTable *tns_subscriptions_by_id;
        GHashTable *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;
        imquic_moq_buffer *buffer;
        imquic_mutex mutex;
        volatile gint connected;
        volatile gint got_goaway;
        volatile gint destroyed;
        imquic_refcount ref;
} imquic_moq_context;

typedef struct imquic_moq_stream {
        uint64_t stream_id;
        /* Whether this STREAM is used for objects, or namespaces */
        gboolean subscribe_namespace, namespace_publisher;
        /* State of SUBSCRIBE_NAMESPACE */
        volatile gint subscribe_namespace_state;
        imquic_moq_namespace *namespace_prefix, *last_tuple;
        uint8_t namespace_prefix_size;
        imquic_moq_data_message_type type;
        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;
        imquic_moq_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_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, 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_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, 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_request_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, imquic_moq_stream *moq_stream, 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_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_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_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_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_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);
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);
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_request_parameters *parameters);
size_t imquic_moq_add_publish_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_publish_namespace_error(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_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_request_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,
        imquic_moq_request_parameters *parameters, GList *track_extensions);
size_t imquic_moq_add_publish_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_request_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_request_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, imquic_moq_request_parameters *parameters);
size_t imquic_moq_add_request_update(imquic_moq_context *moq, 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, uint8_t *bytes, size_t blen, uint64_t request_id,
        uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_extensions);
size_t imquic_moq_add_subscribe_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id,
        imquic_moq_request_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_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_namespace_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id);
size_t imquic_moq_add_subscribe_namespace_error(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_unsubscribe_namespace(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t request_id, imquic_moq_namespace *track_namespace);
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_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,
        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, 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_extensions);
size_t imquic_moq_add_fetch_error(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_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, imquic_moq_request_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, imquic_moq_request_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_request_error_code error, const char *reason);
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_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, 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_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, 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 flags, 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, uint8_t *extensions, size_t elen);
size_t imquic_moq_add_object_extensions(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        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, uint64_t *param_type, uint8_t *error);
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_parameter_add_int(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_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_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_request_parameters_serialize(imquic_moq_context *moq,
        imquic_moq_request_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, imquic_moq_request_parameters *parameters);
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, imquic_moq_namespace *tns, 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);
        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, imquic_moq_request_parameters *parameters, GList *track_extensions);
        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);
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias,
                imquic_moq_namespace *tns, imquic_moq_name *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_extensions);
        void (* subscribe_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code, const char *reason, uint64_t track_alias, uint64_t retry_interval);
        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);
        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);
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
        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_standalone_fetch)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_name *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_extensions);
        void (* fetch_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code, const char *reason, uint64_t retry_interval);
        void (* incoming_track_status)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_name *tn, imquic_moq_request_parameters *parameters);
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_request_parameters *parameters);
        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);
        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 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_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, const char *name);
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_request_parameters(json_t *message, imquic_moq_version version,
        imquic_moq_request_parameters *parameters, const char *name);
void imquic_qlog_moq_message_add_extensions(json_t *message, GList *extensions, 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_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
 
#endif