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 "refcount.h"
 
#define IMQUIC_MOQ              7171953
 
void imquic_moq_init(void);
void imquic_moq_deinit(void);
 
typedef enum imquic_moq_error_code {
        IMQUIC_MOQ_NO_ERROR = 0x0,
        IMQUIC_MOQ_INTERNAL_ERROR = 0x1,
        IMQUIC_MOQ_UNAUTHORIZED = 0x2,
        IMQUIC_MOQ_PROTOCOL_VIOLATION = 0x3,
        IMQUIC_MOQ_DUPLICATE_TRACK_ALIAS = 0x4,
        IMQUIC_MOQ_PARAMETER_LENGTH_MISMATCH = 0x5,
        IMQUIC_MOQ_TOO_MANY_SUBSCRIBES = 0x6,
        IMQUIC_MOQ_GOAWAY_TIMEOUT = 0x10
} imquic_moq_error_code;
const char *imquic_moq_error_code_str(imquic_moq_error_code code);
 
typedef enum imquic_moq_sub_error_code {
        IMQUIC_MOQ_SUBERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_SUBERR_INVALID_RANGE = 0x1,
        IMQUIC_MOQ_SUBERR_RETRY_TRACK_ALIAS = 0x2,
        IMQUIC_MOQ_SUBERR_TRACK_DOES_NOT_EXIST = 0x3,
        IMQUIC_MOQ_SUBERR_UNAUTHORIZED = 0x4,
        IMQUIC_MOQ_SUBERR_TIMEOUT = 0x5,
} imquic_moq_sub_error_code;
const char *imquic_moq_sub_error_code_str(imquic_moq_sub_error_code code);
 
typedef enum imquic_moq_sub_done_code {
        IMQUIC_MOQ_SUBDONE_UNSUBSCRIBED = 0x0,
        IMQUIC_MOQ_SUBDONE_INTERNAL_ERROR = 0x1,
        IMQUIC_MOQ_SUBDONE_UNAUTHORIZED = 0x2,
        IMQUIC_MOQ_SUBDONE_TRACK_ENDED = 0x3,
        IMQUIC_MOQ_SUBDONE_SUBSCRIPTION_ENDED = 0x4,
        IMQUIC_MOQ_SUBDONE_GOING_AWAY = 0x5,
        IMQUIC_MOQ_SUBDONE_EXPIRED = 0x6
} imquic_moq_sub_done_code;
const char *imquic_moq_sub_done_code_str(imquic_moq_sub_done_code code);
 
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_ANNOUNCE = 0x6,
        IMQUIC_MOQ_ANNOUNCE_OK = 0x7,
        IMQUIC_MOQ_ANNOUNCE_ERROR = 0x8,
        IMQUIC_MOQ_UNANNOUNCE = 0x9,
        IMQUIC_MOQ_UNSUBSCRIBE = 0xa,
        IMQUIC_MOQ_SUBSCRIBE_DONE = 0xb,
        IMQUIC_MOQ_ANNOUNCE_CANCEL = 0xc,
        IMQUIC_MOQ_TRACK_STATUS_REQUEST = 0xd,
        IMQUIC_MOQ_TRACK_STATUS = 0xe,
        IMQUIC_MOQ_GOAWAY = 0x10,
        IMQUIC_MOQ_SUBSCRIBE_ANNOUNCES = 0x11,
        IMQUIC_MOQ_SUBSCRIBE_ANNOUNCES_OK = 0x12,
        IMQUIC_MOQ_SUBSCRIBE_ANNOUNCES_ERROR = 0x13,
        IMQUIC_MOQ_UNSUBSCRIBE_ANNOUNCES = 0x14,
        IMQUIC_MOQ_MAX_SUBSCRIBE_ID = 0x15,
        IMQUIC_MOQ_FETCH = 0x16,
        IMQUIC_MOQ_FETCH_CANCEL = 0x17,
        IMQUIC_MOQ_FETCH_OK = 0x18,
        IMQUIC_MOQ_FETCH_ERROR = 0x19,
        IMQUIC_MOQ_CLIENT_SETUP = 0x40,
        IMQUIC_MOQ_SERVER_SETUP = 0x41,
} imquic_moq_message_type;
const char *imquic_moq_message_type_str(imquic_moq_message_type type);
 
typedef enum imquic_moq_data_message_type {
        IMQUIC_MOQ_OBJECT_STREAM = 0x0,
        IMQUIC_MOQ_OBJECT_DATAGRAM = 0x1,
        IMQUIC_MOQ_STREAM_HEADER_TRACK = 0x50,
                IMQUIC_MOQ_STREAM_HEADER_TRACK_V06 = 0x2,
        IMQUIC_MOQ_STREAM_HEADER_GROUP = 0x51,
        IMQUIC_MOQ_STREAM_HEADER_SUBGROUP = 0x4,
        IMQUIC_MOQ_FETCH_HEADER = 0x5,
} imquic_moq_data_message_type;
const char *imquic_moq_data_message_type_str(imquic_moq_data_message_type type);
imquic_moq_delivery imquic_moq_data_message_type_to_delivery(imquic_moq_data_message_type type);
 
typedef enum imquic_moq_setup_parameter_type {
        IMQUIC_MOQ_PARAM_ROLE = 0x00,
        IMQUIC_MOQ_PARAM_PATH = 0x01,
        IMQUIC_MOQ_PARAM_MAX_SUBSCRIBE_ID = 0x02,
} 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_PARAM_AUTHORIZATION_INFO = 0x02,
        IMQUIC_MOQ_PARAM_DELIVERY_TIMEOUT = 0x03,
        IMQUIC_MOQ_PARAM_MAX_CACHE_DURATION = 0x04,
} imquic_moq_subscribe_parameter_type;
const char *imquic_moq_subscribe_parameter_type_str(imquic_moq_subscribe_parameter_type type);
 
typedef enum imquic_moq_role_type {
        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_parsed_setup_parameter {
        imquic_moq_setup_parameter_type type;
        union {
                imquic_moq_role_type role;
                char *path;
                uint64_t max_subscribe_id;
        } value;
} imquic_moq_parsed_setup_parameter;
 
typedef struct imquic_moq_parsed_subscribe_parameter {
        imquic_moq_subscribe_parameter_type type;
        union {
                imquic_moq_auth_info auth_info;
                uint64_t delivery_timeout;
                uint64_t max_cache_duration;
        } value;
} imquic_moq_parsed_subscribe_parameter;
 
 
typedef enum imquic_moq_location_mode {
        IMQUIC_MOQ_LOCATION_NONE = 0x0,
        IMQUIC_MOQ_LOCATION_ABSOLUTE = 0x1,
        IMQUIC_MOQ_LOCATION_RELATIVEPREVIOUS = 0x2,
        IMQUIC_MOQ_LOCATION_RELATIVENEXT = 0x3
} imquic_moq_location_mode;
const char *imquic_moq_location_mode_str(imquic_moq_location_mode mode);
 
typedef struct imquic_moq_location {
        imquic_moq_location_mode mode;
        uint64_t value;
} imquic_moq_location;
 
typedef enum imquic_moq_filter_type {
        IMQUIC_MOQ_FILTER_LATEST_GROUP = 0x1,
        IMQUIC_MOQ_FILTER_LATEST_OBJECT = 0x2,
        IMQUIC_MOQ_FILTER_ABSOLUTE_START = 0x3,
        IMQUIC_MOQ_FILTER_ABSOLUTE_RANGE = 0x4,
} imquic_moq_filter_type;
const char *imquic_moq_filter_type_str(imquic_moq_filter_type type);
 
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 struct imquic_moq_context {
        imquic_connection *conn;
        imquic_moq_version version;
        gboolean version_set;
        imquic_moq_role_type type;
        gboolean role_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_subscribe_id, next_subscribe_id;
        uint64_t max_subscribe_id, local_max_subscribe_id;
        imquic_mutex mutex;
        volatile gint connected;
        volatile gint destroyed;
        imquic_refcount ref;
} imquic_moq_context;
 
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_stream {
        imquic_moq_data_message_type type;
        uint64_t stream_id;
        uint64_t subscribe_id;
        uint64_t track_alias;
        uint64_t group_id;
        uint64_t subgroup_id;
        uint64_t object_id;
        imquic_moq_object_status object_status;
        uint64_t object_send_order;
        uint8_t priority;
        uint64_t stream_offset;
        imquic_moq_buffer *buffer;
        gboolean closed;
} imquic_moq_stream;
void imquic_moq_stream_destroy(imquic_moq_stream *moq_stream);
 
typedef struct imquic_moq_subscription {
        uint64_t subscribe_id;
        uint64_t track_alias;
        gboolean fetch;
        imquic_moq_stream *stream;
        GHashTable *streams_by_group;
        GHashTable *streams_by_subgroup;
} imquic_moq_subscription;
imquic_moq_subscription *imquic_moq_subscription_create(uint64_t subscribe_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_subscribe_id(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_announce(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_announce_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_announce_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_unannounce(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_announce_cancel(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_subscribe_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_announces(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_announces_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_subscribe_announces_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint8_t *error);
size_t imquic_moq_parse_unsubscribe_announces(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_request(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_object_stream(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, 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);
size_t imquic_moq_parse_stream_header_group(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
int imquic_moq_parse_stream_header_group_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete);
size_t imquic_moq_parse_stream_header_subgroup(imquic_moq_context *moq, imquic_moq_stream *moq_stream, uint8_t *bytes, size_t blen, uint8_t *error);
int imquic_moq_parse_stream_header_subgroup_object(imquic_moq_context *moq, imquic_moq_stream *moq_stream, gboolean complete);
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);
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, size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_server_setup(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint32_t version, size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_max_subscribe_id(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t max_subscribe_id);
size_t imquic_moq_add_announce(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace,
        size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_announce_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_announce_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace,
        imquic_moq_error_code error, const char *reason);
size_t imquic_moq_add_unannounce(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_announce_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_subscribe_v03(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id, uint64_t track_alias,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, imquic_moq_location *start_group, imquic_moq_location *start_object,
        imquic_moq_location *end_group, imquic_moq_location *end_object, size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_subscribe(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id, uint64_t track_alias,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, 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, size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_subscribe_update(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object, uint8_t priority,
        size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_subscribe_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        uint64_t expires, imquic_moq_group_order group_order, gboolean content_exists, uint64_t largest_group_id, uint64_t largest_object_id,
        size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_subscribe_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_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 subscribe_id);
size_t imquic_moq_add_subscribe_done(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        imquic_moq_sub_done_code status, const char *reason, gboolean content_exists, uint64_t final_group, uint64_t final_object);
size_t imquic_moq_add_subscribe_announces(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace,
        size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_subscribe_announces_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace);
size_t imquic_moq_add_subscribe_announces_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_moq_namespace *track_namespace,
        imquic_moq_error_code error, const char *reason);
size_t imquic_moq_add_unsubscribe_announces(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, uint64_t subscribe_id,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint8_t priority, imquic_moq_group_order group_order,
        uint64_t start_group, uint64_t start_object, uint64_t end_group, uint64_t end_object, size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_fetch_cancel(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id);
size_t imquic_moq_add_fetch_ok(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        uint8_t group_order, uint8_t end_of_track, uint64_t largest_group_id, uint64_t largest_object_id,
        size_t params_num, imquic_data *parameters);
size_t imquic_moq_add_fetch_error(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        imquic_moq_sub_error_code error, const char *reason);
size_t imquic_moq_add_track_status_request(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name);
size_t imquic_moq_add_track_status(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_namespace *track_namespace, imquic_moq_name *track_name, uint64_t status_code, uint64_t last_group_id, uint64_t last_object_id);
size_t imquic_moq_add_object_stream(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id, uint64_t track_alias,
        uint64_t group_id, uint64_t object_id, uint64_t object_status, uint64_t object_send_order, uint8_t priority, uint8_t *payload, size_t plen);
size_t imquic_moq_add_object_datagram(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id, uint64_t track_alias,
        uint64_t group_id, uint64_t object_id, uint64_t object_status, uint64_t object_send_order, uint8_t priority, uint8_t *payload, size_t plen);
size_t imquic_moq_add_stream_header_track(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t subscribe_id, uint64_t track_alias, uint64_t object_send_order, 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_stream_header_group(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        uint64_t track_alias, uint64_t group_id, uint64_t object_send_order, uint8_t priority);
size_t imquic_moq_add_stream_header_group_object(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t object_id, uint64_t object_status, uint8_t *payload, size_t plen);
size_t imquic_moq_add_stream_header_subgroup(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_id,
        uint64_t track_alias, uint64_t group_id, uint64_t subgroup_id, uint8_t priority);
size_t imquic_moq_add_stream_header_subgroup_object(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        uint64_t object_id, uint64_t object_status, uint8_t *payload, size_t plen);
size_t imquic_moq_add_fetch_header(imquic_moq_context *moq, uint8_t *bytes, size_t blen, uint64_t subscribe_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 imquic_moq_add_goaway(imquic_moq_context *moq, uint8_t *bytes, size_t blen, imquic_data *new_session_uri);
 
 
size_t imquic_moq_parse_setup_parameter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_parsed_setup_parameter *param, uint8_t *error);
size_t imquic_moq_parse_subscribe_parameter(imquic_moq_context *moq, uint8_t *bytes, size_t blen,
        imquic_moq_parsed_subscribe_parameter *param, 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);
 
typedef struct imquic_moq_callbacks {
        void (* new_connection)(imquic_connection *conn, void *user_data);
        void (* moq_ready)(imquic_connection *conn);
        void (* incoming_announce)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* incoming_announce_cancel)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* announce_accepted)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* announce_error)(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason);
        void (* incoming_unannounce)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t subscribe_id, uint64_t track_alias, imquic_moq_namespace *tns, imquic_moq_name *tn, imquic_moq_auth_info *auth);
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t subscribe_id, uint64_t expires, gboolean descending);
        void (* subscribe_error)(imquic_connection *conn, uint64_t subscribe_id, int error_code, const char *reason, uint64_t track_alias);
        void (* subscribe_done)(imquic_connection *conn, uint64_t subscribe_id, int status_code, const char *reason);
        void (* incoming_unsubscribe)(imquic_connection *conn, uint64_t subscribe_id);
        void (* incoming_subscribe_announces)(imquic_connection *conn, imquic_moq_namespace *tns, imquic_moq_auth_info *auth);
        void (* subscribe_announces_accepted)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* subscribe_announces_error)(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason);
        void (* incoming_unsubscribe_announces)(imquic_connection *conn, imquic_moq_namespace *tns);
        void (* incoming_fetch)(imquic_connection *conn, uint64_t subscribe_id, imquic_moq_namespace *tns, imquic_moq_name *tn, gboolean descending, imquic_moq_fetch_range *range, imquic_moq_auth_info *auth);
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t subscribe_id);
        void (* fetch_accepted)(imquic_connection *conn, uint64_t subscribe_id, gboolean descending, imquic_moq_position *largest);
        void (* fetch_error)(imquic_connection *conn, uint64_t subscribe_id, int 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);
 
#endif