moqctl.h

Go to the documentation of this file.

#ifndef MOQCTL_H
#define MOQCTL_H
 
#include "app/moqt/ver/moqver.h"
#include "common/bytes/span/span.h"
#include "common/bytes/varint/varint.h"
#include "common/platform/sys/syscall.h"


#define MOQCTL_OK 1
#define MOQCTL_INSUFFICIENT 0
#define MOQCTL_VIOLATION (-1)
 
/* Message Type IDs this codec knows how to decode/encode (SS10 table). */
#define MOQCTL_T_SETUP 0x2F00ULL
#define MOQCTL_T_GOAWAY 0x10ULL
#define MOQCTL_T_SUBSCRIBE 0x3ULL
#define MOQCTL_T_SUBSCRIBE_OK 0x4ULL
#define MOQCTL_T_REQUEST_ERROR 0x5ULL
#define MOQCTL_T_REQUEST_OK 0x7ULL
#define MOQCTL_T_PUBLISH_DONE 0xBULL
#define MOQCTL_T_PUBLISH 0x1DULL
#define MOQCTL_T_PUBLISH_SKIPPED 0xFULL
#define MOQCTL_T_SUBSCRIBE_TRACKS 0x51ULL
#define MOQCTL_T_PUBLISH_OK18 0x1EULL
#define MOQCTL_T_PUBLISH_STATE_NOTIFY 0x22ULL

#define MOQCTL_UNKNOWN_TYPE (-2)
#define MOQCTL_KNOWN_UNIMPLEMENTED (-3)
 
/* Wire limits (draft-ietf-moq-transport-18/19/22: the same in all three;
 * draft-19 sections). */
#define MOQCTL_MAX_MSG_LEN 0xFFFF
#define MOQCTL_MAX_REASON_LEN 1024
#define MOQCTL_MAX_URI_LEN 8192
#define MOQCTL_MAX_NS_FIELDS 32
#define MOQCTL_MAX_FTN_LEN 4096
#define MOQCTL_MAX_PARAMS 64

#define MOQCTL_ERR_INTERNAL_ERROR 0x0ULL
#define MOQCTL_ERR_NOT_SUPPORTED 0x3ULL
#define MOQCTL_ERR_GOING_AWAY 0x6ULL
#define MOQCTL_ERR_DOES_NOT_EXIST 0x10ULL
#define MOQCTL_ERR_INVALID_RANGE 0x11ULL
#define MOQCTL_ERR_UNINTERESTED 0x20ULL
#define MOQCTL_ERR_UNAUTHORIZED 0x1ULL
#define MOQCTL_ERR_MALFORMED_AUTH_TOKEN 0x4ULL
#define MOQCTL_ERR_INVALID_FILTER 0x36ULL
#define MOQCTL_ERR_REDIRECT 0x34ULL
#define MOQCTL_ERR_PREFIX_OVERLAP 0x30ULL
#define MOQCTL_ERR_EXCESSIVE_LOAD 0x9ULL
#define MOQCTL_ERR_DUPLICATE_SUBSCRIPTION 0x19ULL
#define MOQCTL_ERR_INVALID_JOINING_REQUEST_ID 0x32ULL
#define MOQCTL_ERR_CONFLICTING_FILTERS 0x35ULL
#define MOQCTL_ERR_INVALID_SWITCH 0x32ULL
#define MOQCTL_ERR_UNSUPPORTED_EXTENSION 0x33ULL

#define MOQCTL_DONE_INTERNAL_ERROR 0x0ULL
#define MOQCTL_DONE_TRACK_ENDED 0x2ULL
#define MOQCTL_DONE_GOING_AWAY 0x4ULL
#define MOQCTL_DONE_UPDATE_FAILED 0x8ULL
#define MOQCTL_DONE_SUBSCRIPTION_ENDED 0x3ULL
#define MOQCTL_DONE_MALFORMED_TRACK 0x12ULL
#define MOQCTL_DONE_SWITCHED 0x3ULL

#define MOQCTL_CLOSE_INVALID_AUTHORITY 0x19ULL
#define MOQCTL_CLOSE_INVALID_PATH 0x8ULL
#define MOQCTL_CLOSE_KVFMT_ERROR 0x6ULL

#define MOQCTL_OPT_PATH 0x1ULL
#define MOQCTL_OPT_AUTHORITY 0x5ULL
#define MOQCTL_OPT_MAX_FILTER_RANGES 0x6ULL
#define MOQCTL_OPT_MOQT_IMPLEMENTATION 0x7ULL
#define MOQCTL_OPT_MAX_REQUEST_UPDATES 0x8ULL
#define MOQCTL_OPT_SSTS_ALGORITHMS 0x9ULL

#define MOQCTL_SSTS_ALG_DEFAULT 0x0ULL
#define MOQCTL_SSTS_ALG_BACKPRESSURE 0xff01ULL
#define MOQCTL_SSTS_MAX_ALGS 4

#define MOQCTL_PARAM_AUTHORIZATION_TOKEN 0x03ULL
#define MOQCTL_PARAM_OBJECT_DELIVERY_TIMEOUT 0x02ULL
#define MOQCTL_PARAM_SUBGROUP_DELIVERY_TIMEOUT 0x06ULL
#define MOQCTL_PARAM_FORWARD 0x10ULL
#define MOQCTL_PARAM_RENDEZVOUS_TIMEOUT 0x04ULL
#define MOQCTL_PARAM_EXPIRES 0x08ULL
#define MOQCTL_PARAM_LARGEST_OBJECT 0x09ULL
#define MOQCTL_PARAM_FILL_TIMEOUT 0x0AULL
#define MOQCTL_PARAM_SUBSCRIBER_PRIORITY 0x20ULL
#define MOQCTL_PARAM_LOCATION_FILTER 0x21ULL
#define MOQCTL_PARAM_GROUP_ORDER 0x22ULL
#define MOQCTL_PARAM_SUBGROUP_FILTER 0x25ULL
#define MOQCTL_PARAM_OBJECTID_FILTER 0x26ULL
#define MOQCTL_PARAM_PRIORITY_FILTER 0x27ULL
#define MOQCTL_PARAM_OBJECT_PROPERTY_FILTER 0x28ULL
#define MOQCTL_PARAM_TRACK_PROPERTY_FILTER 0x29ULL
#define MOQCTL_PARAM_NEW_GROUP_REQUEST 0x32ULL
#define MOQCTL_PARAM_TRACK_NAMESPACE_PREFIX 0x34ULL
#define MOQCTL_PARAM_FILL_PARAMETERS 0x23ULL
#define MOQCTL_PARAM_INCLUDE_PROPERTIES 0x35ULL
#define MOQCTL_PARAM_SWITCH_FROM 0x24ULL
#define MOQCTL_PARAM_SWITCHING_SET_ASSIGNMENT 0x41ULL

#define MOQCTL_SWITCH_HARD 0
#define MOQCTL_SWITCH_SOFT 1

#define MOQCTL_PCTX_SUBSCRIBE 0x1u
#define MOQCTL_PCTX_SUBSCRIBE_OK 0x2u
#define MOQCTL_PCTX_PUBLISH 0x4u
#define MOQCTL_PCTX_PUBLISH_OK 0x8u
#define MOQCTL_PCTX_FETCH 0x10u
#define MOQCTL_PCTX_FETCH_OK 0x20u
#define MOQCTL_PCTX_TRACK_STATUS 0x40u
#define MOQCTL_PCTX_TRACK_STATUS_OK 0x80u
#define MOQCTL_PCTX_PUBLISH_NAMESPACE 0x100u
#define MOQCTL_PCTX_PUBLISH_NAMESPACE_OK 0x200u
#define MOQCTL_PCTX_SUBSCRIBE_NAMESPACE 0x400u
#define MOQCTL_PCTX_SUBSCRIBE_NAMESPACE_OK 0x800u
#define MOQCTL_PCTX_SUBSCRIBE_TRACKS 0x1000u
#define MOQCTL_PCTX_SUBSCRIBE_TRACKS_OK 0x2000u
#define MOQCTL_PCTX_UPDATE_SUBSCRIPTION 0x4000u
#define MOQCTL_PCTX_UPDATE_FETCH 0x8000u
#define MOQCTL_PCTX_UPDATE_SUBSCRIBE_NAMESPACE 0x10000u
#define MOQCTL_PCTX_UPDATE_SUBSCRIBE_TRACKS 0x20000u
#define MOQCTL_PCTX_UPDATE_PUBLISH_NAMESPACE 0x40000u
#define MOQCTL_PCTX_REQUEST_UPDATE_OK 0x80000u
#define MOQCTL_PCTX_REQUEST_OK_ANY                                         \
  (MOQCTL_PCTX_PUBLISH_OK | MOQCTL_PCTX_TRACK_STATUS_OK |                  \
   MOQCTL_PCTX_PUBLISH_NAMESPACE_OK | MOQCTL_PCTX_SUBSCRIBE_NAMESPACE_OK | \
   MOQCTL_PCTX_SUBSCRIBE_TRACKS_OK | MOQCTL_PCTX_REQUEST_UPDATE_OK)

#define MOQCTL_PENC_UINT8 0
#define MOQCTL_PENC_VARINT 1
#define MOQCTL_PENC_LOCATION 2
#define MOQCTL_PENC_BYTES 3
#define MOQCTL_PENC_TOKEN 4
#define MOQCTL_PENC_LOCFILTER 5
#define MOQCTL_PENC_NS 6
#define MOQCTL_PENC_RANGELOC22 7
#define MOQCTL_PENC_SWITCHFROM 8
#define MOQCTL_PENC_SSA 9

#define MOQCTL_TOKEN_DELETE 0x0ULL
#define MOQCTL_TOKEN_REGISTER 0x1ULL
#define MOQCTL_TOKEN_USE_ALIAS 0x2ULL
#define MOQCTL_TOKEN_USE_VALUE 0x3ULL

#define MOQCTL_FILTER_NEXT_GROUP 0x1ULL
#define MOQCTL_FILTER_LARGEST 0x2ULL
#define MOQCTL_FILTER_ABS_START 0x3ULL
#define MOQCTL_FILTER_ABS_RANGE 0x4ULL

int moqctl_is_grease(u64 v);

u64 moqctl_known_request_error(u64 code);
u64 moqctl_known_publish_done(u64 code);

u64 moqctl_request_error_for(int ver, u64 code);
u64 moqctl_publish_done_for(int ver, u64 code);

typedef struct {
  u64 group;
  u64 object;
} moqctl_loc;

static inline moqctl_loc moqctl_loc_of(u64 group, u64 object) {
  moqctl_loc l = {group, object};
  return l;
}

int moqctl_loc_less(moqctl_loc a, moqctl_loc b);

static inline moqctl_loc moqctl_loc_min(moqctl_loc a, moqctl_loc b) {
  return moqctl_loc_less(a, b) ? a : b;
}

static inline moqctl_loc moqctl_loc_max(moqctl_loc a, moqctl_loc b) {
  return moqctl_loc_less(a, b) ? b : a;
}

static inline moqctl_loc moqctl_loc_prev(moqctl_loc excl) {
  return excl.object ? moqctl_loc_of(excl.group, excl.object - 1)
                     : moqctl_loc_of(excl.group - 1, VARINT_MAX);
}

int moqctl_loc_take(wired_span buf, usz* off, moqctl_loc* out);
int moqctl_loc_put(wired_mspan buf, usz* off, moqctl_loc loc);

typedef struct {
  u64 type;
  moqctl_loc start;
  u64 end_group_delta;
} moqctl_locfilter;

int moqctl_locfilter_take(wired_span buf, usz* off, moqctl_locfilter* out);
int moqctl_locfilter_put(wired_mspan buf, usz* off, const moqctl_locfilter* f);

typedef enum {
  MOQCTL_RSK_REL_GROUP,
  MOQCTL_RSK_NEXT_OBJ,
  MOQCTL_RSK_ABS
} moqctl_rsk;

typedef enum {
  MOQCTL_REK_UNBOUNDED,
  MOQCTL_REK_GROUP,
  MOQCTL_REK_OBJ
} moqctl_rek;

typedef struct {
  moqctl_rsk sk;
  u64 start_group;
  u64 start_object;
  moqctl_rek ek;
  u64 end_group;
  u64 end_object;
} moqctl_rangeloc;

int moqctl_rangeloc19_take(wired_span buf, usz* off, moqctl_rangeloc* out);
int moqctl_rangeloc19_put(wired_mspan buf, usz* off, const moqctl_rangeloc* r);

int moqctl_rangeloc22_take(
    wired_span buf, usz* off, int* has_filter, moqctl_rangeloc* out);
int moqctl_rangeloc22_put(
    wired_mspan buf, usz* off, int has_filter, const moqctl_rangeloc* r);

#define MOQCTL_MAX_RANGES 4

typedef struct {
  u64 start;
  u64 end;
  int has_end;
} moqctl_range;

typedef struct {
  u64 set_id;
  int has_prop;
  u64 prop_type;
  int remove;
  int invalid;
  usz n;
  moqctl_range r[MOQCTL_MAX_RANGES];
} moqctl_rangefilter;

int moqctl_rangefilter_take(
    u64 ptype, wired_span value, moqctl_rangefilter* out);

int moqctl_rangefilter_put(
    wired_mspan buf, usz* off, u64 ptype, const moqctl_rangefilter* f);

typedef struct {
  wired_span fields[MOQCTL_MAX_NS_FIELDS];
  usz n;
} moqctl_ns;

typedef struct {
  moqctl_ns ns;
  wired_span name;
} moqctl_ftn;

int moqctl_ftn_take(wired_span buf, usz* off, moqctl_ftn* out);
int moqctl_ftn_put(wired_mspan buf, usz* off, const moqctl_ftn* f);

int moqctl_ns_take(wired_span buf, usz* off, moqctl_ns* out);
int moqctl_ns_put(wired_mspan buf, usz* off, const moqctl_ns* ns);

int moqctl_ns_put(wired_mspan buf, usz* off, const moqctl_ns* ns);

usz moqctl_ns_bytelen(const moqctl_ns* ns);

int moqctl_name_take(wired_span buf, usz* off, wired_span* name);

int moqctl_name_put(wired_mspan buf, usz* off, wired_span name);

int moqctl_param_take_uint8(wired_span buf, usz* at, u64* out);
int moqctl_param_put_uint8(wired_mspan buf, usz* at, u64 v);

int moqctl_ftn_eq(const moqctl_ftn* a, const moqctl_ftn* b);

typedef wired_span moqctl_reason;

int moqctl_reason_take(wired_span buf, usz* off, moqctl_reason* out);
int moqctl_reason_put(wired_mspan buf, usz* off, moqctl_reason reason);

typedef struct {
  u64 alias_type;
  u64 alias;
  u64 token_type;
  wired_span value;
} moqctl_token;

typedef struct {
  u64 request_id;
  u8 mode;
  u8 publish_done;
} moqctl_switchfrom;

typedef struct {
  u64 set_id;
  u64 algorithm_id;
  u64 threshold_kbps;
  u64 weight;
  u64 activate;
  u8 rank;
  u8 has_rank;
} moqctl_ssa;

typedef struct {
  u64 type;
  int enc;
  u64 u8v;
  u64 vi;
  moqctl_loc loc;
  wired_span bytes;
  moqctl_token token;
  moqctl_locfilter lf;
  int has_filter;
  moqctl_rangeloc rl;
  moqctl_switchfrom sw;
  moqctl_ssa ssa;
} moqctl_param;

typedef struct {
  moqctl_param items[MOQCTL_MAX_PARAMS];
  usz n;
} moqctl_params;

#define MOQCTL_PARAMS_KVFMT (-4)
int moqctl_params_take(
    int ver, wired_span buf, usz* off, u32 ctx, moqctl_params* out);
int moqctl_params_put(wired_mspan buf, usz* off, const moqctl_params* params);

const moqctl_param* moqctl_params_find(const moqctl_params* params, u64 type);

typedef struct {
  int has_path;
  wired_span path;
  int has_authority;
  wired_span authority;
  int has_implementation;
  wired_span implementation;
  u64 max_filter_ranges;
  u64 max_request_updates;
  u64 ssts_algs[MOQCTL_SSTS_MAX_ALGS];
  u8 ssts_alg_n;
  u8 has_ssts;
} moqctl_setup;

int moqctl_setup_take(wired_span buf, usz* off, moqctl_setup* out);
int moqctl_setup_encode(wired_mspan buf, usz* off, const moqctl_setup* s);

typedef struct {
  u64 request_id;
  moqctl_ftn name;
  moqctl_params params;
} moqctl_subscribe;

int moqctl_subscribe_take(
    int ver, wired_span buf, usz* off, moqctl_subscribe* out);
int moqctl_subscribe_encode(
    wired_mspan buf, usz* off, const moqctl_subscribe* m);

typedef struct {
  u64 track_alias;
  moqctl_params params;
  wired_span track_properties;
} moqctl_subscribe_ok;

int moqctl_subscribe_ok_take(
    int ver, wired_span buf, usz* off, moqctl_subscribe_ok* out);
int moqctl_subscribe_ok_encode(
    wired_mspan buf, usz* off, const moqctl_subscribe_ok* m);

typedef struct {
  u64 request_id;
  moqctl_ftn name;
  u64 track_alias;
  moqctl_params params;
  wired_span track_properties;
} moqctl_publish;

int moqctl_publish_take(int ver, wired_span buf, usz* off, moqctl_publish* out);
int moqctl_publish_encode(wired_mspan buf, usz* off, const moqctl_publish* m);

typedef struct {
  moqctl_params params;
  wired_span track_properties;
} moqctl_request_ok;

int moqctl_request_ok_take(
    int ver, wired_span buf, usz* off, moqctl_request_ok* out);
int moqctl_request_ok_encode(
    wired_mspan buf, usz* off, const moqctl_request_ok* m);

typedef struct {
  wired_span connect_uri;
  moqctl_ns track_namespace;
  wired_span track_name;
} moqctl_redirect;

typedef struct {
  u64 error_code;
  u64 retry_interval;
  moqctl_reason reason;
  int has_redirect;
  moqctl_redirect redirect;
} moqctl_request_error;

int moqctl_request_error_take(
    wired_span buf, usz* off, moqctl_request_error* out);
int moqctl_request_error_encode(
    wired_mspan buf, usz* off, const moqctl_request_error* m);

typedef struct {
  u64 status_code;
  u64 stream_count;
  moqctl_reason reason;
} moqctl_publish_done;

int moqctl_publish_done_take(
    wired_span buf, usz* off, moqctl_publish_done* out);
int moqctl_publish_done_encode(
    wired_mspan buf, usz* off, const moqctl_publish_done* m);

typedef struct {
  wired_span new_session_uri;
  u64 timeout;
  u64 request_id;
} moqctl_goaway;

int moqctl_goaway_take(wired_span buf, usz* off, moqctl_goaway* out);
int moqctl_goaway_encode(wired_mspan buf, usz* off, const moqctl_goaway* m);

int moqctl_goaway18_take(wired_span buf, usz* off, moqctl_goaway* out);
int moqctl_goaway18_encode(wired_mspan buf, usz* off, const moqctl_goaway* m);

int moqctl_peek_type(wired_span buf, usz* off, u64* type_out, wired_span* body);

int moqctl_type_ver(int ver, int peek, u64* type);

int moqctl_peek_header(wired_span buf, usz* at, u64* type, u16* len);

int moqctl_body_end(int r, usz off, wired_span body);
 
#endif