path: root/demos/http3/ossl-nghttp3.c

#include "ossl-nghttp3.h"
#include <openssl/err.h>
#include <assert.h>

#define ARRAY_LEN(x) (sizeof(x)/sizeof((x)[0]))

enum {
    H3_STREAM_TYPE_CTRL_SEND,
    H3_STREAM_TYPE_QPACK_ENC_SEND,
    H3_STREAM_TYPE_QPACK_DEC_SEND,
    H3_STREAM_TYPE_REQ,
};

#define BUF_SIZE    4096

struct h3_stream_st {
    uint64_t            id;             /* QUIC stream ID */
    SSL                 *s;             /* QUIC stream SSL object */
    int                 done_recv_fin;  /* Received FIN */
    void                *user_data;

    uint8_t             buf[BUF_SIZE];
    size_t              buf_cur, buf_total;
};

DEFINE_LHASH_OF_EX(H3_STREAM);

static void h3_stream_free(H3_STREAM *s)
{
    if (s == NULL)
        return;

    SSL_free(s->s);
    OPENSSL_free(s);
}

static unsigned long h3_stream_hash(const H3_STREAM *s)
{
    return (unsigned long)s->id;
}

static int h3_stream_eq(const H3_STREAM *a, const H3_STREAM *b)
{
    if (a->id < b->id) return -1;
    if (a->id > b->id) return 1;
    return 0;
}

void *H3_STREAM_get_user_data(const H3_STREAM *s)
{
    return s->user_data;
}

struct h3_conn_st {
    SSL                 *qconn;         /* QUIC connection SSL object */
    BIO                 *qconn_bio;     /* BIO wrapping QCSO */
    nghttp3_conn        *h3conn;        /* HTTP/3 connection object */
    LHASH_OF(H3_STREAM) *streams;       /* map of stream IDs to H3_STREAMs */
    void                *user_data;     /* opaque user data pointer */

    int                 pump_res;
    size_t              consumed_app_data;

    /* Forwarding callbacks */
    nghttp3_recv_data           recv_data_cb;
    nghttp3_stream_close        stream_close_cb;
    nghttp3_stop_sending        stop_sending_cb;
    nghttp3_reset_stream        reset_stream_cb;
    nghttp3_deferred_consume    deferred_consume_cb;
};

void H3_CONN_free(H3_CONN *conn)
{
    if (conn == NULL)
        return;

    lh_H3_STREAM_doall(conn->streams, h3_stream_free);

    nghttp3_conn_del(conn->h3conn);
    BIO_free_all(conn->qconn_bio);
    lh_H3_STREAM_free(conn->streams);
    OPENSSL_free(conn);
}

static H3_STREAM *h3_conn_create_stream(H3_CONN *conn, int type)
{
    H3_STREAM *s;
    uint64_t flags = SSL_STREAM_FLAG_ADVANCE;

    if ((s = OPENSSL_zalloc(sizeof(H3_STREAM))) == NULL)
        return NULL;

    if (type != H3_STREAM_TYPE_REQ)
        flags |= SSL_STREAM_FLAG_UNI;

    if ((s->s = SSL_new_stream(conn->qconn, flags)) == NULL) {
        ERR_raise_data(ERR_LIB_USER, ERR_R_INTERNAL_ERROR,
                       "could not create QUIC stream object");
        goto err;
    }

    s->id   = SSL_get_stream_id(s->s);
    lh_H3_STREAM_insert(conn->streams, s);
    return s;

err:
    OPENSSL_free(s);
    return NULL;
}

static H3_STREAM *h3_conn_accept_stream(H3_CONN *conn, SSL *qstream)
{
    H3_STREAM *s;

    if ((s = OPENSSL_zalloc(sizeof(H3_STREAM))) == NULL)
        return NULL;

    s->id   = SSL_get_stream_id(qstream);
    s->s    = qstream;
    lh_H3_STREAM_insert(conn->streams, s);
    return s;
}

static void h3_conn_remove_stream(H3_CONN *conn, H3_STREAM *s)
{
    if (s == NULL)
        return;

    lh_H3_STREAM_delete(conn->streams, s);
    h3_stream_free(s);
}

static int h3_conn_recv_data(nghttp3_conn *h3conn, int64_t stream_id,
                             const uint8_t *data, size_t datalen,
                             void *conn_user_data, void *stream_user_data)
{
    H3_CONN *conn = conn_user_data;

    conn->consumed_app_data += datalen;
    if (conn->recv_data_cb == NULL)
        return 0;

    return conn->recv_data_cb(h3conn, stream_id, data, datalen,
                              conn_user_data, stream_user_data);
}

static int h3_conn_stream_close(nghttp3_conn *h3conn, int64_t stream_id,
                                uint64_t app_error_code,
                                void *conn_user_data, void *stream_user_data)
{
    int ret = 0;
    H3_CONN *conn = conn_user_data;
    H3_STREAM *stream = stream_user_data;

    if (conn->stream_close_cb != NULL)
        ret = conn->stream_close_cb(h3conn, stream_id, app_error_code,
                                    conn_user_data, stream_user_data);

    h3_conn_remove_stream(conn, stream);
    return ret;
}

static int h3_conn_stop_sending(nghttp3_conn *h3conn, int64_t stream_id,
                                uint64_t app_error_code,
                                void *conn_user_data, void *stream_user_data)
{
    int ret = 0;
    H3_CONN *conn = conn_user_data;
    H3_STREAM *stream = stream_user_data;

    if (conn->stop_sending_cb != NULL)
        ret = conn->stop_sending_cb(h3conn, stream_id, app_error_code,
                                    conn_user_data, stream_user_data);

    SSL_free(stream->s);
    stream->s = NULL;
    return ret;
}

static int h3_conn_reset_stream(nghttp3_conn *h3conn, int64_t stream_id,
                                uint64_t app_error_code,
                                void *conn_user_data, void *stream_user_data)
{
    int ret = 0;
    H3_CONN *conn = conn_user_data;
    H3_STREAM *stream = stream_user_data;
    SSL_STREAM_RESET_ARGS args = {0};

    if (conn->reset_stream_cb != NULL)
        ret = conn->reset_stream_cb(h3conn, stream_id, app_error_code,
                                   conn_user_data, stream_user_data);

    if (stream->s != NULL) {
        args.quic_error_code = app_error_code;

        if (!SSL_stream_reset(stream->s, &args, sizeof(args)))
            return 1;
    }

    return ret;
}

static int h3_conn_deferred_consume(nghttp3_conn *h3conn, int64_t stream_id,
                                    size_t consumed,
                                    void *conn_user_data, void *stream_user_data)
{
    int ret = 0;
    H3_CONN *conn = conn_user_data;

    if (conn->deferred_consume_cb != NULL)
        ret = conn->deferred_consume_cb(h3conn, stream_id,