moq.h

Go to the documentation of this file.

 
#ifndef IMQUIC_MOQ_H
#define IMQUIC_MOQ_H
 
#include "imquic.h"


typedef enum imquic_moq_version {
        /* Base */
        IMQUIC_MOQ_VERSION_BASE = 0xff000000,
        /* Draft version -16 */
        IMQUIC_MOQ_VERSION_MIN = 0xff000010,
        IMQUIC_MOQ_VERSION_16 = 0xff000010,
        /* Draft version -17 */
        IMQUIC_MOQ_VERSION_17 = 0xff000011,
        /* Draft version -18 */
        IMQUIC_MOQ_VERSION_18 = 0xff000012,
        IMQUIC_MOQ_VERSION_MAX = IMQUIC_MOQ_VERSION_18,
        /* Any version starting from v15: for client, it means offer all supported versions;
         * for servers, it means accept the first supported offered version */
        IMQUIC_MOQ_VERSION_ANY = 0xff0000ff,
} imquic_moq_version;

const char *imquic_moq_version_str(imquic_moq_version version);
imquic_moq_version imquic_moq_get_version(imquic_connection *conn);

typedef struct imquic_moq_namespace {
        uint8_t *buffer;
        size_t length;
        struct imquic_moq_namespace *next;
} imquic_moq_namespace;

const char *imquic_moq_namespace_str(imquic_moq_namespace *tns, char *buffer, size_t blen, gboolean tuple);
gboolean imquic_moq_namespace_equals(imquic_moq_namespace *first, imquic_moq_namespace *second);
gboolean imquic_moq_namespace_contains(imquic_moq_namespace *parent, imquic_moq_namespace *child);
imquic_moq_namespace *imquic_moq_namespace_duplicate(imquic_moq_namespace *tns);
gboolean imquic_moq_namespace_is_valid(imquic_moq_namespace *tns, gboolean fail_if_empty, uint64_t *tns_num);
void imquic_moq_namespace_free(imquic_moq_namespace *tns);

typedef struct imquic_moq_track {
        uint8_t *buffer;
        size_t length;
} imquic_moq_track;
/* Helper to stringify a track name
 * @param[in] tn The track name to stringify
 * @param[out] buffer The buffer to write the string to
 * @param[in] blen The size of the output buffer
 * @returns A pointer to the output buffer, if successful, or NULL otherwise */
const char *imquic_moq_track_str(imquic_moq_track *tn, char *buffer, size_t blen);
gboolean imquic_moq_track_equals(imquic_moq_track *first, imquic_moq_track *second);
imquic_moq_track *imquic_moq_track_duplicate(imquic_moq_track *tn);
gboolean imquic_moq_track_is_valid(imquic_moq_track *tn);
void imquic_moq_track_free(imquic_moq_track *tn);

typedef struct imquic_moq_redirect {
        /* Connect URI */
        char *connect_uri;
        /* Track Namespace */
        imquic_moq_namespace *track_namespace;
        /* Track Name */
        imquic_moq_track *track_name;
} imquic_moq_redirect;

typedef enum imquic_moq_group_order {
        IMQUIC_MOQ_ORDERING_ORIGINAL = 0x0,
        IMQUIC_MOQ_ORDERING_ASCENDING = 0x1,
        IMQUIC_MOQ_ORDERING_DESCENDING = 0x2,
} imquic_moq_group_order;

const char *imquic_moq_group_order_str(imquic_moq_group_order type);

typedef enum imquic_moq_filter_type {
        IMQUIC_MOQ_FILTER_NEXT_GROUP_START = 0x1,
        IMQUIC_MOQ_FILTER_LARGEST_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 struct imquic_moq_location {
        uint64_t group;
        uint64_t object;
} imquic_moq_location;

typedef struct imquic_moq_location_range {
        imquic_moq_location start;
        imquic_moq_location end;
} imquic_moq_location_range;

typedef struct imquic_moq_subscription_filter {
        imquic_moq_filter_type type;
        imquic_moq_location start_location;
        uint64_t end_group;
} imquic_moq_subscription_filter;

typedef enum imquic_moq_subscribe_namespace_options {
        IMQUIC_MOQ_WANT_PUBLISH = 0x0,
        IMQUIC_MOQ_WANT_NAMESPACE = 0x1,
        IMQUIC_MOQ_WANT_PUBLISH_AND_NAMESPACE = 0x2,
} imquic_moq_subscribe_namespace_options;

const char *imquic_moq_subscribe_namespace_options_str(imquic_moq_subscribe_namespace_options type);

typedef struct imquic_moq_request_parameters {
        gboolean auth_token_set;
        uint8_t auth_token[256];
        size_t auth_token_len;
        gboolean delivery_timeout_set;
        uint64_t delivery_timeout;
        gboolean object_delivery_timeout_set;
        uint64_t object_delivery_timeout;
        gboolean subgroup_delivery_timeout_set;
        uint64_t subgroup_delivery_timeout;
        gboolean fill_timeout_set;
        uint64_t fill_timeout;
        gboolean rendezvous_timeout_set;
        uint64_t rendezvous_timeout;
        gboolean subscriber_priority_set;
        uint8_t subscriber_priority;
        gboolean group_order_set;
        imquic_moq_group_order group_order;
        gboolean subscription_filter_set;
        imquic_moq_subscription_filter subscription_filter;
        gboolean expires_set;
        uint64_t expires;
        gboolean largest_object_set;
        imquic_moq_location largest_object;
        gboolean forward_set;
        gboolean forward;
        gboolean new_group_request_set;
        uint64_t new_group_request;
        gboolean track_namespace_prefix_set;
        imquic_moq_namespace track_namespace_prefix[32];
        gboolean unknown;
} imquic_moq_request_parameters;

void imquic_moq_request_parameters_init_defaults(imquic_moq_request_parameters *parameters);

typedef enum imquic_moq_delivery {
        IMQUIC_MOQ_USE_DATAGRAM,
        IMQUIC_MOQ_USE_SUBGROUP,
        IMQUIC_MOQ_USE_FETCH
} imquic_moq_delivery;

const char *imquic_moq_delivery_str(imquic_moq_delivery type);

typedef enum imquic_moq_object_status {
        IMQUIC_MOQ_NORMAL_OBJECT = 0x0,
        IMQUIC_MOQ_END_OF_GROUP = 0x3,
        IMQUIC_MOQ_END_OF_TRACK = 0x4,
} imquic_moq_object_status;

const char *imquic_moq_object_status_str(imquic_moq_object_status status);

typedef struct imquic_moq_property {
        uint32_t id;
        union {
                uint64_t number;
                struct imquic_moq_property_data {
                        uint64_t length;
                        uint8_t *buffer;
                } data;
        } value;
} imquic_moq_property;

typedef enum imquic_moq_property_type {
        /* Object Delivery Timeout (added in v18) */
        IMQUIC_MOQ_PROPERTY_OBJECT_DELIVERY_TIMEOUT = 0x02,
                /* Delivery Timeout (deprecated in v18) */
                IMQUIC_MOQ_PROPERTY_DELIVERY_TIMEOUT = 0x02,
        /* Max Cache Duration */
        IMQUIC_MOQ_PROPERTY_MAX_CACHE_DURATION = 0x04,
        /* Subgroup Delivery Timeout (added in v18) */
        IMQUIC_MOQ_PROPERTY_SUBGROUP_DELIVERY_TIMEOUT = 0x06,
        /* Default Publisher Priority */
        IMQUIC_MOQ_PROPERTY_DEFAULT_PUBLISHER_PRIORITY = 0x0E,
        /* Default Group Order */
        IMQUIC_MOQ_PROPERTY_DEFAULT_GROUP_ORDER = 0x22,
        /* Dynamic Groups */
        IMQUIC_MOQ_PROPERTY_DYNAMIC_GROUPS = 0x30,
        /* Prior Group ID Gap */
        IMQUIC_MOQ_PROPERTY_PRIOR_GROUP_ID_GAP = 0x3C,
        /* Prior Object ID Gap */
        IMQUIC_MOQ_PROPERTY_PRIOR_OBJECT_ID_GAP = 0x3E,
        /* Immutable Properties */
        IMQUIC_MOQ_PROPERTY_IMMUTABLE_PROPERTIES = 0xB,
} imquic_moq_property_type;

const char *imquic_moq_property_type_str(imquic_moq_version version, imquic_moq_property_type type);

typedef struct imquic_moq_object {
        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;
        uint8_t *payload;
        size_t payload_len;
        GList *properties;
        imquic_moq_delivery delivery;
        gboolean first_of_subgroup;
        gboolean end_of_stream;
} imquic_moq_object;



typedef enum imquic_moq_auth_token_alias_type {
        IMQUIC_MOQ_AUTH_TOKEN_DELETE = 0x0,
        IMQUIC_MOQ_AUTH_TOKEN_REGISTER = 0x1,
        IMQUIC_MOQ_AUTH_TOKEN_USE_ALIAS = 0x2,
        IMQUIC_MOQ_AUTH_TOKEN_USE_VALUE = 0x3,
} imquic_moq_auth_token_alias_type;

const char *imquic_moq_auth_token_alias_type_str(imquic_moq_auth_token_alias_type type);

typedef struct imquic_moq_auth_token {
        imquic_moq_auth_token_alias_type alias_type;
        gboolean token_alias_set;
        uint64_t token_alias;
        gboolean token_type_set;
        uint64_t token_type;
        struct imquic_moq_auth_token_value {
                uint64_t length;
                uint8_t *buffer;
        } token_value;
} imquic_moq_auth_token;

int imquic_moq_parse_auth_token(imquic_moq_version version, uint8_t *bytes, size_t blen, imquic_moq_auth_token *token);
size_t imquic_moq_build_auth_token(imquic_moq_version version, imquic_moq_auth_token *token, uint8_t *bytes, size_t blen);
 


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_INVALID_REQUEST_ID = 0x4,
        IMQUIC_MOQ_DUPLICATE_TRACK_ALIAS = 0x5,
        IMQUIC_MOQ_KEYVALUE_FORMATTING_ERROR = 0x6,
                IMQUIC_MOQ_INVALID_REQUIRED_REQUEST_ID = 0x7,     /* Deprecated in v18 */
                IMQUIC_MOQ_TOO_MANY_REQUESTS = 0x7,         /* Deprecated in v17 */
        IMQUIC_MOQ_INVALID_PATH = 0x8,
        IMQUIC_MOQ_MALFORMED_PATH = 0x9,
        IMQUIC_MOQ_GOAWAY_TIMEOUT = 0x10,
        IMQUIC_MOQ_CONTROL_MESSAGE_TIMEOUT = 0x11,
        IMQUIC_MOQ_DATA_STREAM_TIMEOUT = 0x12,
        IMQUIC_MOQ_AUTH_TOKEN_CACHE_OVERFLOW = 0x13,
        IMQUIC_MOQ_DUPLICATE_AUTH_TOKEN_ALIAS = 0x14,
        IMQUIC_MOQ_VERSION_NEGOTIATION_FAILED = 0x15,
        IMQUIC_MOQ_MALFORMED_AUTH_TOKEN = 0x16,
        IMQUIC_MOQ_UNKNOWN_AUTH_TOKEN_ALIAS = 0x17,
        IMQUIC_MOQ_EXPIRED_AUTH_TOKEN = 0x18,
        IMQUIC_MOQ_INVALID_AUTHORITY = 0x19,
        IMQUIC_MOQ_MALFORMED_AUTHORITY = 0x1A,
        /* Not an actual error */
        IMQUIC_MOQ_UNKNOWN_ERROR = 0xFF
} imquic_moq_error_code;

const char *imquic_moq_error_code_str(imquic_moq_error_code code);

typedef enum imquic_moq_request_error_code {
        IMQUIC_MOQ_REQERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_REQERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_REQERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_REQERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_REQERR_MALFORMED_AUTH_TOKEN = 0x4,
        IMQUIC_MOQ_REQERR_EXPIRED_AUTH_TOKEN = 0x5,
        IMQUIC_MOQ_REQERR_GOING_AWAY = 0x6,
        IMQUIC_MOQ_REQERR_EXCESSIVE_LOAD = 0x9,
        /* The following are returned by publishers */
        IMQUIC_MOQ_REQERR_DOES_NOT_EXIST = 0x10,
        IMQUIC_MOQ_REQERR_INVALID_RANGE = 0x11,
        IMQUIC_MOQ_REQERR_MALFORMED_TRACK = 0x12,
        IMQUIC_MOQ_REQERR_DUPLICATE_SUBSCRIPTION = 0x19,
        /* The following are returned by subscribers */
        IMQUIC_MOQ_REQERR_UNINTERESTED = 0x20,
        /* Others */
        IMQUIC_MOQ_REQERR_PREFIX_OVERLAP = 0x30,
        IMQUIC_MOQ_REQERR_NAMESPACE_TOO_LARGE = 0x31,
        IMQUIC_MOQ_REQERR_INVALID_JOINING_REQUEST_ID = 0x32,
        IMQUIC_MOQ_REQERR_UNSUPPORTED_EXTENSION = 0x33,  /* Added in v18 */
        IMQUIC_MOQ_REQERR_REDIRECT = 0x34,    /* Added in v18 */
} imquic_moq_request_error_code;

const char *imquic_moq_request_error_code_str(imquic_moq_request_error_code code);

typedef enum imquic_moq_pub_done_code {
        IMQUIC_MOQ_PUBDONE_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_PUBDONE_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_PUBDONE_TRACK_ENDED = 0x2,
        IMQUIC_MOQ_PUBDONE_SUBSCRIPTION_ENDED = 0x3,
        IMQUIC_MOQ_PUBDONE_GOING_AWAY = 0x4,
        IMQUIC_MOQ_PUBDONE_TOO_FAR_BEHIND = 0x5,       /* Swapped in v18 */
        IMQUIC_MOQ_PUBDONE_EXPIRED = 0x6,     /* Swapped in v18 */
        IMQUIC_MOQ_PUBDONE_UPDATE_FAILED = 0x8,
        IMQUIC_MOQ_PUBDONE_EXCESSIVE_LOAD = 0x9,
        IMQUIC_MOQ_PUBDONE_MALFORMED_TRACK = 0x12,
} imquic_moq_pub_done_code;

const char *imquic_moq_pub_done_code_str(imquic_moq_pub_done_code code);

typedef enum imquic_moq_reset_stream_code {
        IMQUIC_MOQ_RESET_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_RESET_CANCELLED = 0x1,
        IMQUIC_MOQ_RESET_DELIVERY_TIMEOUT = 0x2,
        IMQUIC_MOQ_RESET_SESSION_CLOSED = 0x3,
        IMQUIC_MOQ_RESET_GOING_AWAY = 0x4,   /* Added in v18 */
        IMQUIC_MOQ_RESET_TOO_FAR_BEHIND = 0x5,
        IMQUIC_MOQ_RESET_UNKNOWN_OBJECT_STATUS = 0x6,     /* Value changed in v18 */
        IMQUIC_MOQ_RESET_EXPIRED_AUTH_TOKEN = 0x7,   /* Added in v18 */
        IMQUIC_MOQ_RESET_EXCESSIVE_LOAD = 0x9,
        IMQUIC_MOQ_RESET_MALFORMED_TRACK = 0x12,
} imquic_moq_reset_stream_code;

const char *imquic_moq_reset_stream_code_str(imquic_moq_reset_stream_code code);


imquic_server *imquic_create_moq_server(const char *name, ...);
imquic_client *imquic_create_moq_client(const char *name, ...);

void imquic_set_new_moq_connection_cb(imquic_endpoint *endpoint,
        void (* new_moq_connection)(imquic_connection *conn, void *user_data));
void imquic_set_incoming_moq_connection_cb(imquic_endpoint *endpoint,
        uint64_t (* incoming_moq_connection)(imquic_connection *conn, uint8_t *auth, size_t authlen));
void imquic_set_moq_ready_cb(imquic_endpoint *endpoint,
        void (* moq_ready)(imquic_connection *conn));
void imquic_set_incoming_publish_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters));
void imquic_set_incoming_publish_namespace_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_error_code error_code, const char *reason));
void imquic_set_publish_namespace_accepted_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_publish_namespace_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_publish_namespace_done_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_done)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_publish_cb(imquic_endpoint *endpoint,
        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 imquic_set_publish_accepted_cb(imquic_endpoint *endpoint,
        void (* publish_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_publish_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_subscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_subscribe_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_request_updated_cb(imquic_endpoint *endpoint,
        void (* request_updated)(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_request_parameters *parameters));
void imquic_set_request_update_accepted_cb(imquic_endpoint *endpoint,
        void (* request_update_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_request_update_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_publish_done_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_unsubscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe)(imquic_connection *conn, uint64_t request_id));
void imquic_set_requests_blocked_cb(imquic_endpoint *endpoint,
        void (* requests_blocked)(imquic_connection *conn, uint64_t max_request_id));
void imquic_set_incoming_subscribe_namespace_cb(imquic_endpoint *endpoint,
        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 imquic_set_subscribe_namespace_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_namespace_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_unsubscribe_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_subscribe_tracks_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe_tracks)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_tracks_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_tracks_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters));
void imquic_set_subscribe_tracks_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_unsubscribe_tracks_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_tracks)(imquic_connection *conn, uint64_t request_id));
void imquic_set_incoming_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_namespace)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns));
void imquic_set_incoming_namespace_done_cb(imquic_endpoint *endpoint,
        void (* incoming_namespace_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns));
void imquic_set_incoming_publish_blocked_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_blocked)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn));
void imquic_set_incoming_standalone_fetch_cb(imquic_endpoint *endpoint,
        void (* incoming_standalone_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 imquic_set_incoming_joining_fetch_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_fetch_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t request_id));
void imquic_set_fetch_accepted_cb(imquic_endpoint *endpoint,
        void (* fetch_accepted)(imquic_connection *conn, uint64_t request_id,
                imquic_moq_location *largest, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_fetch_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_track_status_cb(imquic_endpoint *endpoint,
        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 imquic_set_track_status_accepted_cb(imquic_endpoint *endpoint,
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters, GList *track_properties));
void imquic_set_track_status_error_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_object_cb(imquic_endpoint *endpoint,
        void (* incoming_object)(imquic_connection *conn, imquic_moq_object *object));
void imquic_set_incoming_goaway_cb(imquic_endpoint *endpoint,
        void (* incoming_goaway)(imquic_connection *conn, const char *uri, uint64_t timeout));
void imquic_set_incoming_request_goaway_cb(imquic_endpoint *endpoint,
        void (* incoming_request_goaway)(imquic_connection *conn, uint64_t request_id, const char *uri, uint64_t timeout));
void imquic_set_moq_connection_gone_cb(imquic_endpoint *endpoint,
        void (* moq_connection_gone)(imquic_connection *conn, uint64_t error_code, const char *reason));

int imquic_moq_set_connection_auth(imquic_connection *conn, uint8_t *auth, size_t authlen);

int imquic_moq_set_max_request_id(imquic_connection *conn, uint64_t max_request_id);

uint64_t imquic_moq_get_next_request_id(imquic_connection *conn);

const char *imquic_moq_get_remote_implementation(imquic_connection *conn);

/* Namespaces and subscriptions */
int imquic_moq_publish_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_publish_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_publish_namespace(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);
int imquic_moq_publish_namespace_done(imquic_connection *conn, uint64_t request_id);
int imquic_moq_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);
int imquic_moq_accept_publish(imquic_connection *conn, uint64_t request_id, imquic_moq_request_parameters *parameters);
int imquic_moq_reject_publish(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);
int imquic_moq_subscribe(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_subscribe(imquic_connection *conn, uint64_t request_id,
        uint64_t track_alias, imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_subscribe(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);
int imquic_moq_update_request(imquic_connection *conn, uint64_t request_id,
        uint64_t sub_request_id, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_request_update(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_request_update(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);
int imquic_moq_publish_done(imquic_connection *conn, uint64_t request_id,
        imquic_moq_pub_done_code status_code, const char *reason);
int imquic_moq_unsubscribe(imquic_connection *conn, uint64_t request_id);
int imquic_moq_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);
int imquic_moq_accept_subscribe_namespace(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_subscribe_namespace(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);
int imquic_moq_unsubscribe_namespace(imquic_connection *conn, uint64_t request_id);
int imquic_moq_subscribe_tracks(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_subscribe_tracks(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters);
int imquic_moq_reject_subscribe_tracks(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);
int imquic_moq_unsubscribe_tracks(imquic_connection *conn, uint64_t request_id);
int imquic_moq_notify_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_notify_namespace_done(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_notify_publish_blocked(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_track *tn);
int imquic_moq_standalone_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);
int imquic_moq_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);
int imquic_moq_accept_fetch(imquic_connection *conn, uint64_t request_id,
        imquic_moq_location *largest, imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_fetch(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);
int imquic_moq_cancel_fetch(imquic_connection *conn, uint64_t request_id);
int imquic_moq_track_status(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_track *tn, imquic_moq_request_parameters *parameters);
int imquic_moq_accept_track_status(imquic_connection *conn, uint64_t request_id,
        imquic_moq_request_parameters *parameters, GList *track_properties);
int imquic_moq_reject_track_status(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);
int imquic_moq_send_object(imquic_connection *conn, imquic_moq_object *object);
int imquic_moq_send_padding(imquic_connection *conn, size_t padding, gboolean datagram);
int imquic_moq_requests_blocked(imquic_connection *conn);
int imquic_moq_goaway(imquic_connection *conn, const char *uri, uint64_t timeout);
int imquic_moq_request_goaway(imquic_connection *conn, uint64_t request_id, const char *uri, uint64_t timeout);
 
#endif