lsquic.h

Go to the documentation of this file.

/* Copyright (c) 2017 LiteSpeed Technologies Inc.  See LICENSE. */
#ifndef __LSQUIC_H__
#define __LSQUIC_H__

#include <stdarg.h>
#include <lsquic_types.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <time.h>

struct iovec;
struct sockaddr;

#ifdef __cplusplus
extern "C" {
#endif

#define LSENG_SERVER (1 << 0)

#define LSENG_HTTP  (1 << 1)

#define LSENG_HTTP_SERVER (LSENG_SERVER|LSENG_HTTP)

enum lsquic_version
{

    LSQVER_035,

    LSQVER_037,

    LSQVER_038,

    LSQVER_039,

    LSQVER_041,

    N_LSQVER
};

#define LSQUIC_SUPPORTED_VERSIONS ((1 << LSQVER_035) | (1 << LSQVER_037) | \
                    (1 << LSQVER_038) | (1 << LSQVER_039) | (1 << LSQVER_041))

#define LSQUIC_EXPERIMENTAL_VERSIONS ((1 << LSQVER_041))

struct lsquic_stream_if {

    lsquic_conn_ctx_t *(*on_new_conn)(void *stream_if_ctx,
                                                        lsquic_conn_t *c);

    void (*on_goaway_received)(lsquic_conn_t *c);
    void (*on_conn_closed)(lsquic_conn_t *c);

    lsquic_stream_ctx_t *
         (*on_new_stream)(void *stream_if_ctx, lsquic_stream_t *s);

    void (*on_read)     (lsquic_stream_t *s, lsquic_stream_ctx_t *h);
    void (*on_write)    (lsquic_stream_t *s, lsquic_stream_ctx_t *h);
    void (*on_close)    (lsquic_stream_t *s, lsquic_stream_ctx_t *h);
};

#define      LSQUIC_MIN_FCW             (16 * 1024)

/* Each LSQUIC_DF_* value corresponds to es_* entry in
 * lsquic_engine_settings below.
 */

#define LSQUIC_DF_VERSIONS         (LSQUIC_SUPPORTED_VERSIONS & \
                                            ~LSQUIC_EXPERIMENTAL_VERSIONS)

#define LSQUIC_DF_CFCW_SERVER      (3 * 1024 * 1024 / 2)
#define LSQUIC_DF_CFCW_CLIENT      (15 * 1024 * 1024)
#define LSQUIC_DF_SFCW_SERVER      (1 * 1024 * 1024)
#define LSQUIC_DF_SFCW_CLIENT      (6 * 1024 * 1024)
#define LSQUIC_DF_MAX_STREAMS_IN   100

#define LSQUIC_DF_HANDSHAKE_TO     (10 * 1000 * 1000)

#define LSQUIC_DF_IDLE_CONN_TO     (30 * 1000 * 1000)
#define LSQUIC_DF_SILENT_CLOSE     1

#define LSQUIC_DF_MAX_HEADER_LIST_SIZE 0

#define LSQUIC_DF_UA               "LSQUIC"

#define LSQUIC_DF_STTL               86400
#define LSQUIC_DF_MAX_INCHOATE     (1 * 1000 * 1000)
#define LSQUIC_DF_SUPPORT_SREJ_SERVER  1
#define LSQUIC_DF_SUPPORT_SREJ_CLIENT  0       /* TODO: client support */

#define LSQUIC_DF_SUPPORT_NSTP     0
#define LSQUIC_DF_SUPPORT_PUSH         1
#define LSQUIC_DF_SUPPORT_TCID0    1

#define LSQUIC_DF_HONOR_PRST       0

#define LSQUIC_DF_PROGRESS_CHECK    1000

#define LSQUIC_DF_PENDRW_CHECK      10

#define LSQUIC_DF_RW_ONCE           0

#define LSQUIC_DF_PROC_TIME_THRESH  0

#define LSQUIC_DF_PACE_PACKETS      1

struct lsquic_engine_settings {
    unsigned        es_versions;

    unsigned        es_cfcw;

    unsigned        es_sfcw;

    unsigned        es_max_cfcw;

    unsigned        es_max_sfcw;

    unsigned        es_max_streams_in;

    unsigned long   es_handshake_to;

    unsigned long   es_idle_conn_to;

    int             es_silent_close;

    unsigned        es_max_header_list_size;

    const char     *es_ua;

    uint32_t        es_pdmd; /* One fixed value X509 */
    uint32_t        es_aead; /* One fixed value AESG */
    uint32_t        es_kexs; /* One fixed value C255 */

    int             es_support_srej;

    int             es_support_push;

    int             es_support_tcid0;

    int             es_support_nstp;

    int             es_honor_prst;

    unsigned        es_progress_check;

    unsigned        es_pendrw_check;

    int             es_rw_once;

    unsigned        es_proc_time_thresh;

    int             es_pace_packets;

};

/* Initialize `settings' to default values */
void
lsquic_engine_init_settings (struct lsquic_engine_settings *,
                             unsigned lsquic_engine_flags);

int
lsquic_engine_check_settings (const struct lsquic_engine_settings *settings,
                              unsigned lsquic_engine_flags,
                              char *err_buf, size_t err_buf_sz);

struct lsquic_out_spec
{
    const unsigned char   *buf;
    size_t                 sz;
    const struct sockaddr *local_sa;
    const struct sockaddr *dest_sa;
    void                  *peer_ctx;
};

typedef int (*lsquic_packets_out_f)(
    void                          *packets_out_ctx,
    const struct lsquic_out_spec  *out_spec,
    unsigned                       n_packets_out
);

struct lsquic_packout_mem_if
{
    void *  (*pmi_allocate) (void *pmi_ctx, size_t sz);
    void    (*pmi_release)  (void *pmi_ctx, void *obj);
};

/* TODO: describe this important data structure */
typedef struct lsquic_engine_api
{
    const struct lsquic_engine_settings *ea_settings;   /* Optional */
    const struct lsquic_stream_if       *ea_stream_if;
    void                                *ea_stream_if_ctx;
    lsquic_packets_out_f                 ea_packets_out;
    void                                *ea_packets_out_ctx;
    const struct lsquic_packout_mem_if  *ea_pmi;
    void                                *ea_pmi_ctx;
} lsquic_engine_api_t;

lsquic_engine_t *
lsquic_engine_new (unsigned lsquic_engine_flags,
                   const struct lsquic_engine_api *);

int
lsquic_engine_connect (lsquic_engine_t *, const struct sockaddr *peer_sa,
                       void *peer_ctx, const char *hostname,
                       unsigned short max_packet_size);

int
lsquic_engine_packet_in (lsquic_engine_t *,
        const unsigned char *packet_in_data, size_t packet_in_size,
        const struct sockaddr *sa_local, const struct sockaddr *sa_peer,
        void *peer_ctx);

void
lsquic_engine_proc_all (lsquic_engine_t *engine);

void
lsquic_engine_process_conns_with_incoming (lsquic_engine_t *);

void
lsquic_engine_process_conns_to_tick (lsquic_engine_t *);

int
lsquic_engine_has_pend_rw (lsquic_engine_t *);

void
lsquic_engine_process_conns_with_pend_rw (lsquic_engine_t *);

int
lsquic_engine_has_unsent_packets (lsquic_engine_t *engine);

void
lsquic_engine_send_unsent_packets (lsquic_engine_t *engine);

void
lsquic_engine_destroy (lsquic_engine_t *);

void lsquic_conn_make_stream(lsquic_conn_t *);

unsigned
lsquic_conn_n_pending_streams (const lsquic_conn_t *);

unsigned
lsquic_conn_cancel_pending_streams (lsquic_conn_t *, unsigned n);

void
lsquic_conn_going_away(lsquic_conn_t *conn);

void lsquic_conn_close(lsquic_conn_t *conn);

int lsquic_stream_wantread(lsquic_stream_t *s, int is_want);
ssize_t lsquic_stream_read(lsquic_stream_t *s, void *buf, size_t len);
ssize_t lsquic_stream_readv(lsquic_stream_t *s, const struct iovec *,
                                                            int iovcnt);

int lsquic_stream_wantwrite(lsquic_stream_t *s, int is_want);

ssize_t lsquic_stream_write(lsquic_stream_t *s, const void *buf, size_t len);

ssize_t lsquic_stream_writev(lsquic_stream_t *s, const struct iovec *vec, int count);

struct lsquic_reader
{
    size_t (*lsqr_read) (void *lsqr_ctx, void *buf, size_t count);
    size_t (*lsqr_size) (void *lsqr_ctx);
    void    *lsqr_ctx;
};

ssize_t
lsquic_stream_writef (lsquic_stream_t *, struct lsquic_reader *);

int
lsquic_stream_flush (lsquic_stream_t *s);

typedef struct lsquic_http_header
{
   struct iovec name;
   struct iovec value;
} lsquic_http_header_t;

struct lsquic_http_headers
{
    int                     count;
    lsquic_http_header_t   *headers;
};

int lsquic_stream_send_headers(lsquic_stream_t *s,
                               const lsquic_http_headers_t *h, int eos);

int lsquic_conn_is_push_enabled(lsquic_conn_t *c);

int lsquic_stream_shutdown(lsquic_stream_t *s, int how);

int lsquic_stream_close(lsquic_stream_t *s);

uint32_t
lsquic_stream_id (const lsquic_stream_t *s);

lsquic_stream_ctx_t *
lsquic_stream_get_ctx (const lsquic_stream_t *s);

int
lsquic_stream_is_pushed (const lsquic_stream_t *s);

int
lsquic_stream_refuse_push (lsquic_stream_t *s);

int
lsquic_stream_push_info (const lsquic_stream_t *, uint32_t *ref_stream_id,
                         const char **headers, size_t *headers_sz);

unsigned lsquic_stream_priority (const lsquic_stream_t *s);

int lsquic_stream_set_priority (lsquic_stream_t *s, unsigned priority);

lsquic_conn_t * lsquic_stream_conn(const lsquic_stream_t *s);

lsquic_stream_t *
lsquic_conn_get_stream_by_id (lsquic_conn_t *c, uint32_t stream_id);

lsquic_cid_t
lsquic_conn_id (const lsquic_conn_t *c);

int lsquic_conn_get_sockaddr(const lsquic_conn_t *c,
                const struct sockaddr **local, const struct sockaddr **peer);

struct lsquic_logger_if {
    int     (*vprintf)(void *logger_ctx, const char *fmt, va_list args);
};

enum lsquic_logger_timestamp_style {
    LLTS_NONE,

    LLTS_HHMMSSMS,

    LLTS_YYYYMMDD_HHMMSSMS,

    LLTS_CHROMELIKE,

    LLTS_HHMMSSUS,

    N_LLTS
};

void lsquic_logger_init(const struct lsquic_logger_if *, void *logger_ctx,
                        enum lsquic_logger_timestamp_style);

int
lsquic_set_log_level (const char *log_level);

int
lsquic_logger_lopt (const char *optarg);

unsigned lsquic_engine_quic_versions (const lsquic_engine_t *);

#define LSQUIC_GLOBAL_CLIENT (1 << 0)

#define LSQUIC_GLOBAL_SERVER (1 << 1)

int
lsquic_global_init (int flags);

void
lsquic_global_cleanup (void);

enum lsquic_version
lsquic_conn_quic_version (const lsquic_conn_t *c);

enum lsquic_version
lsquic_str2ver (const char *str, size_t len);

lsquic_conn_ctx_t *
lsquic_conn_get_ctx (const lsquic_conn_t *c);

void *lsquic_conn_get_peer_ctx( const lsquic_conn_t *lconn);

void
lsquic_conn_abort (lsquic_conn_t *c);

int
lsquic_engine_earliest_adv_tick (lsquic_engine_t *engine, int *diff);

unsigned
lsquic_engine_count_attq (lsquic_engine_t *engine, int from_now);

#ifdef __cplusplus
}
#endif

#endif //__LSQUIC_H__