imquic/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;
 
typedef struct imquic_moq_name {
        uint8_t *buffer;
        size_t length;
} imquic_moq_name;
 
typedef struct imquic_moq_auth_info {
        uint8_t *buffer;
        size_t length;
} imquic_moq_auth_info;
 
typedef struct imquic_moq_position {
        uint64_t group;
        uint64_t object;
} imquic_moq_position;
 
typedef struct imquic_moq_fetch_range {
        imquic_moq_position start;
        imquic_moq_position end;
} imquic_moq_fetch_range;
 
typedef enum imquic_moq_delivery {
        IMQUIC_MOQ_USE_DATAGRAM,
        IMQUIC_MOQ_USE_STREAM,
        IMQUIC_MOQ_USE_GROUP,
        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_SUBGROUP = 0x5,
} imquic_moq_object_status;
const char *imquic_moq_object_status_str(imquic_moq_object_status status);
 
typedef struct imquic_moq_object {
        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;
        uint8_t *payload;
        size_t payload_len;
        imquic_moq_delivery delivery;
        gboolean end_of_stream;
} imquic_moq_object;
 
 
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_moq_ready_cb(imquic_endpoint *endpoint,
        void (* moq_ready)(imquic_connection *conn));
void imquic_set_incoming_announce_cb(imquic_endpoint *endpoint,
        void (* incoming_announce)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_incoming_announce_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_announce_cancel)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_announce_accepted_cb(imquic_endpoint *endpoint,
        void (* announce_accepted)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_announce_error_cb(imquic_endpoint *endpoint,
        void (* announce_error)(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason));
void imquic_set_incoming_unannounce_cb(imquic_endpoint *endpoint,
        void (* incoming_unannounce)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_incoming_subscribe_cb(imquic_endpoint *endpoint,
        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 imquic_set_subscribe_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_accepted)(imquic_connection *conn, uint64_t subscribe_id, uint64_t expires, gboolean descending));
void imquic_set_subscribe_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_error)(imquic_connection *conn, uint64_t subscribe_id, int error_code, const char *reason, uint64_t track_alias));
void imquic_set_subscribe_done_cb(imquic_endpoint *endpoint,
        void (* subscribe_done)(imquic_connection *conn, uint64_t subscribe_id, int status_code, const char *reason));
void imquic_set_incoming_unsubscribe_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe)(imquic_connection *conn, uint64_t subscribe_id));
void imquic_set_incoming_subscribe_announces_cb(imquic_endpoint *endpoint,
        void (* incoming_subscribe_announces)(imquic_connection *conn, imquic_moq_namespace *tns, imquic_moq_auth_info *auth));
void imquic_set_subscribe_announces_accepted_cb(imquic_endpoint *endpoint,
        void (* subscribe_announces_accepted)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_subscribe_announces_error_cb(imquic_endpoint *endpoint,
        void (* subscribe_announces_error)(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason));
void imquic_set_incoming_unsubscribe_announces_cb(imquic_endpoint *endpoint,
        void (* incoming_unsubscribe_announces)(imquic_connection *conn, imquic_moq_namespace *tns));
void imquic_set_incoming_fetch_cb(imquic_endpoint *endpoint,
        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 imquic_set_incoming_fetch_cancel_cb(imquic_endpoint *endpoint,
        void (* incoming_fetch_cancel)(imquic_connection *conn, uint64_t subscribe_id));
void imquic_set_fetch_accepted_cb(imquic_endpoint *endpoint,
        void (* fetch_accepted)(imquic_connection *conn, uint64_t subscribe_id, gboolean descending, imquic_moq_position *largest));
void imquic_set_fetch_error_cb(imquic_endpoint *endpoint,
        void (* fetch_error)(imquic_connection *conn, uint64_t subscribe_id, int 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_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 -03 */
        IMQUIC_MOQ_VERSION_MIN = 0xff000003,
        IMQUIC_MOQ_VERSION_03 = 0xff000003,
        /* Draft version -04 */
        IMQUIC_MOQ_VERSION_04 = 0xff000004,
        /* Draft version -05 */
        IMQUIC_MOQ_VERSION_05 = 0xff000005,
        /* Draft version -06 */
        IMQUIC_MOQ_VERSION_06 = 0xff000006,
        /* Draft version -07 */
        IMQUIC_MOQ_VERSION_07 = 0xff000007,
        /* Draft version -07 with a twist? */
        IMQUIC_MOQ_VERSION_07_PATCH = 0xff070001,
        IMQUIC_MOQ_VERSION_MAX = IMQUIC_MOQ_VERSION_07_PATCH,
        /* Any post-v06 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 pre-v06 version: for client, it means offer all supported 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_max_subscribe_id(imquic_connection *conn, uint64_t max_subscribe_id);
 
/* Namespaces and subscriptions */
int imquic_moq_announce(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_accept_announce(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_reject_announce(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason);
int imquic_moq_unannounce(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_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);
int imquic_moq_accept_subscribe(imquic_connection *conn, uint64_t subscribe_id, uint64_t expires, gboolean descending);
int imquic_moq_reject_subscribe(imquic_connection *conn, uint64_t subscribe_id, int error_code, const char *reason, uint64_t track_alias);
int imquic_moq_unsubscribe(imquic_connection *conn, uint64_t subscribe_id);
int imquic_moq_subscribe_announces(imquic_connection *conn, imquic_moq_namespace *tns, imquic_moq_auth_info *auth);
int imquic_moq_accept_subscribe_announces(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_reject_subscribe_announces(imquic_connection *conn, imquic_moq_namespace *tns, int error_code, const char *reason);
int imquic_moq_unsubscribe_announces(imquic_connection *conn, imquic_moq_namespace *tns);
int imquic_moq_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);
int imquic_moq_accept_fetch(imquic_connection *conn, uint64_t subscribe_id, gboolean descending, imquic_moq_position *largest);
int imquic_moq_reject_fetch(imquic_connection *conn, uint64_t subscribe_id, int error_code, const char *reason);
int imquic_moq_cancel_fetch(imquic_connection *conn, uint64_t subscribe_id);
int imquic_moq_send_object(imquic_connection *conn, imquic_moq_object *object);
 
#endif