moq.h

Go to the documentation of this file.

 
#ifndef IMQUIC_MOQ_H
#define IMQUIC_MOQ_H
 
#include "imquic.h"
 
 
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);
 
typedef struct imquic_moq_name {
        uint8_t *buffer;
        size_t length;
} imquic_moq_name;
/* 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_name *tn, char *buffer, size_t blen);
 
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 enum imquic_moq_delivery {
        IMQUIC_MOQ_USE_DATAGRAM,
        IMQUIC_MOQ_USE_SUBGROUP,
        IMQUIC_MOQ_USE_TRACK,
        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_OBJECT_DOESNT_EXIST = 0x1,
        IMQUIC_MOQ_END_OF_GROUP = 0x3,
        IMQUIC_MOQ_END_OF_TRACK_AND_GROUP = 0x4,
        IMQUIC_MOQ_END_OF_TRACK = 0x5,
} imquic_moq_object_status;
const char *imquic_moq_object_status_str(imquic_moq_object_status status);
 
typedef struct imquic_moq_object_extension {
        uint32_t id;
        union {
                uint64_t number;
                struct imquic_moq_object_extension_data {
                        uint64_t length;
                        uint8_t *buffer;
                } data;
        } value;
} imquic_moq_object_extension;
GList *imquic_moq_parse_object_extensions(uint8_t *extensions, size_t elen);
size_t imquic_moq_build_object_extensions(GList *extensions, uint8_t *bytes, size_t blen);
 
typedef enum imquic_moq_extension_type {
        /* Prior Group ID Gap */
        IMQUIC_MOQ_EXT_PRIOR_GROUP_ID_GAP = 0x3C,
        /* Prior Object ID Gap */
        IMQUIC_MOQ_EXT_PRIOR_OBJECT_ID_GAP = 0x3E,
        /* Immutable Extensions */
        IMQUIC_MOQ_EXT_IMMUTABLE_EXTENSIONS = 0xB,
} imquic_moq_extension_type;
const char *imquic_moq_extension_type_str(imquic_moq_extension_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;
        uint8_t *extensions;
        size_t extensions_len;
        size_t extensions_count;
        imquic_moq_delivery delivery;
        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(uint8_t *bytes, size_t blen, imquic_moq_auth_token *token);
size_t imquic_moq_build_auth_token(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_TOO_MANY_REQUESTS = 0x7,
        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_publish_namespace_error_code {
        IMQUIC_MOQ_PUBNSERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_PUBNSERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_PUBNSERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_PUBNSERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_PUBNSERR_UNINTERESTED = 0x4,
        IMQUIC_MOQ_PUBNSERR_MALFORMED_AUTH_TOKEN = 0x10,
        IMQUIC_MOQ_PUBNSERR_UNKNOWN_AUTH_TOKEN_ALIAS = 0x11,    /* Deprecated in v12 */
        IMQUIC_MOQ_PUBNSERR_EXPIRED_AUTH_TOKEN = 0x12,
} imquic_moq_publish_namespace_error_code;
const char *imquic_moq_publish_namespace_error_code_str(imquic_moq_publish_namespace_error_code code);
 
typedef enum imquic_moq_pub_error_code {
        IMQUIC_MOQ_PUBERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_PUBERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_PUBERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_PUBERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_PUBERR_UNINTERESTED = 0x4,
} imquic_moq_pub_error_code;
const char *imquic_moq_pub_error_code_str(imquic_moq_pub_error_code code);
 
typedef enum imquic_moq_sub_error_code {
        IMQUIC_MOQ_SUBERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_SUBERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_SUBERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_SUBERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_SUBERR_TRACK_DOES_NOT_EXIST = 0x4,
        IMQUIC_MOQ_SUBERR_INVALID_RANGE = 0x5,
        IMQUIC_MOQ_SUBERR_RETRY_TRACK_ALIAS = 0x6,      /* Deprecated in v12 */
        IMQUIC_MOQ_SUBERR_MALFORMED_AUTH_TOKEN = 0x10,
        IMQUIC_MOQ_SUBERR_UNKNOWN_AUTH_TOKEN_ALIAS = 0x11,      /* Deprecated in v12 */
        IMQUIC_MOQ_SUBERR_EXPIRED_AUTH_TOKEN = 0x12,
} imquic_moq_sub_error_code;
const char *imquic_moq_sub_error_code_str(imquic_moq_sub_error_code code);
 
typedef enum imquic_moq_subns_error_code {
        IMQUIC_MOQ_SUBNSERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_SUBNSERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_SUBNSERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_SUBNSERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_SUBNSERR_NAMESPACE_PREFIX_UNKNOWN = 0x4,
        IMQUIC_MOQ_SUBNSERR_MALFORMED_AUTH_TOKEN = 0x10,
        IMQUIC_MOQ_SUBNSERR_UNKNOWN_AUTH_TOKEN_ALIAS = 0x11,    /* Deprecated in v12 */
        IMQUIC_MOQ_SUBNSERR_EXPIRED_AUTH_TOKEN = 0x12,
} imquic_moq_subns_error_code;
const char *imquic_moq_subns_error_code_str(imquic_moq_subns_error_code code);
 
typedef enum imquic_moq_fetch_error_code {
        IMQUIC_MOQ_FETCHERR_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_FETCHERR_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_FETCHERR_TIMEOUT = 0x2,
        IMQUIC_MOQ_FETCHERR_NOT_SUPPORTED = 0x3,
        IMQUIC_MOQ_FETCHERR_TRACK_DOES_NOT_EXIST = 0x4,
        IMQUIC_MOQ_FETCHERR_INVALID_RANGE = 0x5,
        IMQUIC_MOQ_FETCHERR_NO_OBJECTS = 0x6,
        IMQUIC_MOQ_FETCHERR_INVALID_JOINING_REQUEST_ID = 0x7,
        IMQUIC_MOQ_FETCHERR_UNKNOWN_STATUS_IN_RANGE = 0x8,
        IMQUIC_MOQ_FETCHERR_MALFORMED_TRACK = 0x9,
        IMQUIC_MOQ_FETCHERR_MALFORMED_AUTH_TOKEN = 0x10,
        IMQUIC_MOQ_FETCHERR_UNKNOWN_AUTH_TOKEN_ALIAS = 0x11,    /* Deprecated in v12 */
        IMQUIC_MOQ_FETCHERR_EXPIRED_AUTH_TOKEN = 0x12,
} imquic_moq_fetch_error_code;
const char *imquic_moq_fetch_error_code_str(imquic_moq_fetch_error_code code);
 
typedef enum imquic_moq_sub_done_code {
        IMQUIC_MOQ_SUBDONE_INTERNAL_ERROR = 0x0,
        IMQUIC_MOQ_SUBDONE_UNAUTHORIZED = 0x1,
        IMQUIC_MOQ_SUBDONE_TRACK_ENDED = 0x2,
        IMQUIC_MOQ_SUBDONE_SUBSCRIPTION_ENDED = 0x3,
        IMQUIC_MOQ_SUBDONE_GOING_AWAY = 0x4,
        IMQUIC_MOQ_SUBDONE_EXPIRED = 0x5,
        IMQUIC_MOQ_SUBDONE_TOO_FAR_BEHIND = 0x6,
        IMQUIC_MOQ_SUBDONE_MALFORMED_TRACK = 0x7
} imquic_moq_sub_done_code;
const char *imquic_moq_sub_done_code_str(imquic_moq_sub_done_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, uint8_t *auth, size_t authlen));
void imquic_set_incoming_publish_namespace_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_publish_namespace_cancel)(imquic_connection *conn, imquic_moq_namespace *tns, imquic_moq_publish_namespace_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_namespace *tns));
void imquic_set_publish_namespace_error_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_publish_namespace_error_code error_code, const char *reason));
void imquic_set_publish_namespace_done_cb(imquic_endpoint *endpoint,
        void (* publish_namespace_done)(imquic_connection *conn, imquic_moq_namespace *tns));
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_name *tn, uint64_t track_alias,
                gboolean descending, imquic_moq_location *largest, gboolean forward, uint8_t *auth, size_t authlen));
void imquic_set_publish_accepted_cb(imquic_endpoint *endpoint,
        void (* publish_accepted)(imquic_connection *conn, uint64_t request_id, gboolean forward, uint8_t priority, gboolean descending,
                imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen));
void imquic_set_publish_error_cb(imquic_endpoint *endpoint,
        void (* publish_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_pub_error_code error_code, const char *reason));
void imquic_set_incoming_subscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_namespace *tns, imquic_moq_name *tn,
                uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen));
void imquic_set_subscribe_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest));
void imquic_set_subscribe_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason, uint64_t track_alias));
void imquic_set_subscribe_updated_cb(imquic_endpoint *endpoint,
        void (* subscribe_updated)(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_location *start_location, uint64_t end_group, uint8_t priority, gboolean forward));
void imquic_set_publish_done_cb(imquic_endpoint *endpoint,
        void (* publish_done)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_done_code status_code, uint64_t streams_count, const char *reason));
void 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, uint8_t *auth, size_t authlen));
void imquic_set_subscribe_namespace_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_namespace_accepted)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns));
void imquic_set_subscribe_namespace_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_namespace_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_subns_error_code error_code, const char *reason));
void imquic_set_incoming_unsubscribe_namespace_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_namespace)(imquic_connection *conn, imquic_moq_namespace *tns));
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_name *tn, gboolean descending, imquic_moq_location_range *range, uint8_t *auth, size_t authlen));
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, gboolean descending, uint8_t *auth, size_t authlen));
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, gboolean descending, imquic_moq_location *largest));
void imquic_set_fetch_error_cb(imquic_endpoint *endpoint,
        void (* fetch_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_fetch_error_code error_code, const char *reason));
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_name *tn,
                uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen));
void imquic_set_track_status_accepted_cb(imquic_endpoint *endpoint,
        void (* track_status_accepted)(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest));
void imquic_set_track_status_error_cb(imquic_endpoint *endpoint,
        void (* track_status_error)(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason));
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));
void imquic_set_moq_connection_gone_cb(imquic_endpoint *endpoint,
        void (* moq_connection_gone)(imquic_connection *conn));
 
typedef enum imquic_moq_role {
        IMQUIC_MOQ_ENDPOINT,    /* Since -08, there are no roles anymore */
        IMQUIC_MOQ_PUBLISHER,
        IMQUIC_MOQ_SUBSCRIBER,
        IMQUIC_MOQ_PUBSUB
} imquic_moq_role;
const char *imquic_moq_role_str(imquic_moq_role role);
int imquic_moq_set_role(imquic_connection *conn, imquic_moq_role role);
imquic_moq_role imquic_moq_get_role(imquic_connection *conn);
 
typedef enum imquic_moq_version {
        /* Base */
        IMQUIC_MOQ_VERSION_BASE = 0xff000000,
        /* Draft version -06 */
        IMQUIC_MOQ_VERSION_MIN = 0xff000006,
        IMQUIC_MOQ_VERSION_06 = 0xff000006,
        /* Draft version -07 */
        IMQUIC_MOQ_VERSION_07 = 0xff000007,
        /* Draft version -08 */
        IMQUIC_MOQ_VERSION_08 = 0xff000008,
        /* Draft version -09 */
        IMQUIC_MOQ_VERSION_09 = 0xff000009,
        /* Draft version -10 */
        IMQUIC_MOQ_VERSION_10 = 0xff00000A,
        /* Draft version -11 */
        IMQUIC_MOQ_VERSION_11 = 0xff00000B,
        /* Draft version -12 */
        IMQUIC_MOQ_VERSION_12 = 0xff00000C,
        /* Draft version -13 */
        IMQUIC_MOQ_VERSION_13 = 0xff00000D,
        /* Draft version -14 */
        IMQUIC_MOQ_VERSION_14 = 0xff00000E,
        IMQUIC_MOQ_VERSION_MAX = IMQUIC_MOQ_VERSION_14,
        /* Any post-v11 version: for client, it means offer all supported versions;
         * for servers, it means accept the first supported offered version */
        IMQUIC_MOQ_VERSION_ANY = 0xffffffff,
        /* Any version between v06 and v11: for client, it means offer all those versions;
         * for servers, it means accept the first supported offered version */
        IMQUIC_MOQ_VERSION_ANY_LEGACY = 0xfffffffe
} imquic_moq_version;
const char *imquic_moq_version_str(imquic_moq_version version);
int imquic_moq_set_version(imquic_connection *conn, imquic_moq_version version);
imquic_moq_version imquic_moq_get_version(imquic_connection *conn);
 
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);
 
/* Namespaces and subscriptions */
int imquic_moq_publish_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns,
        uint8_t *auth, size_t authlen);
int imquic_moq_accept_publish_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_reject_publish_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_publish_namespace_error_code error_code, const char *reason);
int imquic_moq_publish_namespace_done(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_publish(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_name *tn, uint64_t track_alias,
        gboolean descending, imquic_moq_location *largest, gboolean forward, uint8_t *auth, size_t authlen);
int imquic_moq_accept_publish(imquic_connection *conn, uint64_t request_id, gboolean forward, uint8_t priority, gboolean descending,
        imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location);
int imquic_moq_reject_publish(imquic_connection *conn, uint64_t request_id, imquic_moq_pub_error_code error_code, const char *reason);
int imquic_moq_subscribe(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, imquic_moq_namespace *tns, imquic_moq_name *tn,
        uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen);
int imquic_moq_accept_subscribe(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest);
int imquic_moq_reject_subscribe(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason, uint64_t track_alias);
int imquic_moq_update_subscribe(imquic_connection *conn, uint64_t request_id, uint64_t sub_request_id, imquic_moq_location *start_location, uint64_t end_group, uint8_t priority, gboolean forward);
int imquic_moq_publish_done(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_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, uint8_t *auth, size_t authlen);
int imquic_moq_accept_subscribe_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns);
int imquic_moq_reject_subscribe_namespace(imquic_connection *conn, uint64_t request_id, imquic_moq_namespace *tns, imquic_moq_subns_error_code error_code, const char *reason);
int imquic_moq_unsubscribe_namespace(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_standalone_fetch(imquic_connection *conn, uint64_t request_id,
        imquic_moq_namespace *tns, imquic_moq_name *tn,
        gboolean descending, imquic_moq_location_range *range, uint8_t *auth, size_t authlen);
int imquic_moq_joining_fetch(imquic_connection *conn, uint64_t request_id, uint64_t joining_request_id,
        gboolean absolute, uint64_t joining_start, gboolean descending, uint8_t *auth, size_t authlen);
int imquic_moq_accept_fetch(imquic_connection *conn, uint64_t request_id, gboolean descending, imquic_moq_location *largest);
int imquic_moq_reject_fetch(imquic_connection *conn, uint64_t request_id, imquic_moq_fetch_error_code error_code, const char *reason);
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_name *tn,
        uint8_t priority, gboolean descending, gboolean forward, imquic_moq_filter_type filter_type, imquic_moq_location *start_location, imquic_moq_location *end_location, uint8_t *auth, size_t authlen);
int imquic_moq_accept_track_status(imquic_connection *conn, uint64_t request_id, uint64_t track_alias, uint64_t expires, gboolean descending, imquic_moq_location *largest);
int imquic_moq_reject_track_status(imquic_connection *conn, uint64_t request_id, imquic_moq_sub_error_code error_code, const char *reason);
int imquic_moq_send_object(imquic_connection *conn, imquic_moq_object *object);
int imquic_moq_requests_blocked(imquic_connection *conn);
int imquic_moq_goaway(imquic_connection *conn, const char *uri);
 
#endif