blob: 6e273627e444136a9fe888a10c90b9c0d9551ad4 [file] [edit]
/*
* GPAC Multimedia Framework
*
* Authors: Jean Le Feuvre
* Copyright (c) Telecom Paris 2025-2026
* All rights reserved
*
* This file is part of GPAC / downloader sub-project
*
* GPAC is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* GPAC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "downloader.h"
/*
Functions prefixes:
h3_*: function used for hmux session function pointers
ngq_*: function callback for ngtcp2 lib (quic)
ngh3_*: function callback for nghttp3 lib
*/
#if !defined(GPAC_DISABLE_NETWORK) && defined(GPAC_HAS_NGTCP2)
#if defined(WIN32) && !defined(__GNUC__)
#pragma comment(lib, "libnghttp3.lib")
#pragma comment(lib, "libngtcp2_crypto_quictls.lib")
#pragma comment(lib, "libngtcp2.lib")
#endif
#include <ngtcp2/ngtcp2.h>
#include <ngtcp2/ngtcp2_crypto.h>
#include <ngtcp2/ngtcp2_crypto_quictls.h>
#include <nghttp3/nghttp3.h>
#define NGTCP2_STATELESS_RESET_BURST 100
#define NGTCP2_SV_SCIDLEN 18
#define MAX_CONNID_LEN 255
#define MAX_ADDR_LEN 100
const u8 *gf_sk_get_address(GF_Socket *sock, u32 *addr_size);
GF_Err gf_sk_bind_ex(GF_Socket *sock, const char *ifce_ip_or_name, u16 port, const char *peer_name, u16 peer_port, u32 options,
u8 **dst_sock_addr, u32 *dst_sock_addr_len, u8 **src_sock_addr, u32 *src_sock_addr_len);
GF_Err gf_sk_send_to(GF_Socket *sock, const u8 *buffer, u32 length, const u8 *addr, u32 addr_len, u32 *written);
GF_Err gf_sk_connect_ex(GF_Socket *sock, const char *PeerName, u16 PortNumber, const char *ifce_ip_or_name, Bool use_udp_connect);
//amount of bytes we store internally
#define SOCK_BUF_SIZE 200000
struct __gf_quic_server
{
GF_Socket *sock;
GF_DownloadManager *dm;
Bool (*accept_conn)(void *udta, GF_DownloadSession *sess, const char *address, u32 port);
void *udta;
SSL_CTX *ssl_ctx;
u8 *local_add;
u32 local_add_len;
GF_List *connections;
u8 secret[GF_SHA256_DIGEST_SIZE];
Bool validate_address;
u32 stateless_reset_count;
};
typedef struct
{
u8 dcid[MAX_CONNID_LEN];
u32 dcid_len;
Bool associated;
} ConnIDInfo;
#define MAC_CONN_ID 9
typedef struct __gf_quic_connection
{
GF_QuicServer *server;
ConnIDInfo conn_ids[MAC_CONN_ID];
u8 addr[MAX_ADDR_LEN];
u32 addr_len;
Bool closed;
u64 drain_period_end;
u64 close_period_end;
u8 closebuf[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
u32 closebuf_len;
GF_HMUX_Session *hmux;
Bool pck_sent;
} GF_QuicServerConnection;
typedef enum
{
QUIC_HANDSHAKE_NONE=0,
QUIC_HANDSHAKE_SENT,
QUIC_HANDSHAKE_DONE,
QUIC_HANDSHAKE_ERROR
} QuicHandshakeState;
typedef struct
{
//if server, pointer to the server, NULL otherwise
GF_QuicServerConnection *serv_conn;
// parent hmux downlaoder session
GF_HMUX_Session *hmux;
ngtcp2_path path;
ngtcp2_conn *conn;
ngtcp2_crypto_conn_ref conn_ref;
nghttp3_conn *http_conn;
ngtcp2_ccerr last_error;
//for both client and server
QuicHandshakeState handshake_state;
u8 cur_buf[1500];
u32 cur_buf_len;
ngtcp2_path_storage cur_path;
//for client
u8 secret[32];
} GF_QuicConnection;
typedef struct
{
nghttp3_data_reader data_read;
u32 local_buf_sent, local_buf_ack;
Bool wait_ack;
Bool is_put;
//we use a double buffer so that we can write to the second buffer while sending the first one:
//- we cannot reallocate the first buffer if commited for sent
//- if first buffer is done sending, we aggregate data in secnd buffer if not larger than SOCK_BUF_SIZE/2
//- when the first buffer is fully acked, we swap first and second
u8 *second_local_buf;
u32 second_local_buf_len, second_local_buf_alloc;
} GF_QuicDataRead;
static GF_Err quic_handle_error(GF_QuicConnection *qc);
static GF_Err quic_send_packet(GF_QuicServer *qs, const u8 *buf, u32 len, const u8 *to_a, u32 to_alen);
static GF_Err h3_session_write_ex(GF_DownloadSession *sess, GF_QuicConnection *qc);
static u64 ngtcp2_timestamp()
{
return 1000*gf_sys_clock_high_res();
}
static void ngq_rand_cb(uint8_t *dest, size_t destlen, const ngtcp2_rand_ctx *rand_ctx)
{
size_t i;
(void)rand_ctx;
for (i = 0; i < destlen; ++i) {
*dest = (uint8_t)gf_rand();
}
}
static int ngq_get_new_connection_id(ngtcp2_conn *conn, ngtcp2_cid *cid, uint8_t *token, size_t cidlen, void *user_data)
{
(void)conn;
GF_QuicConnection *qc = user_data;
if (RAND_bytes(cid->data, (int)cidlen) != 1) {
return NGTCP2_ERR_CALLBACK_FAILURE;
}
cid->datalen = cidlen;
if (RAND_bytes(token, NGTCP2_STATELESS_RESET_TOKENLEN) != 1) {
return NGTCP2_ERR_CALLBACK_FAILURE;
}
//server
if (qc->serv_conn) {
u32 conn_idx=0;
for (;conn_idx<MAC_CONN_ID; conn_idx++) {
ConnIDInfo *ci = &qc->serv_conn->conn_ids[conn_idx];
if (!ci->associated) {
memcpy(ci->dcid, cid->data, cid->datalen);
ci->dcid_len = cid->datalen;
ci->associated=GF_TRUE;
return 0;
}
}
return NGTCP2_ERR_CALLBACK_FAILURE;
} else {
if (ngtcp2_crypto_generate_stateless_reset_token(token, qc->secret, 32, cid) !=
0) {
return NGTCP2_ERR_CALLBACK_FAILURE;
}
}
return 0;
}
static int ngq_remove_connection_id(ngtcp2_conn *conn, const ngtcp2_cid *cid, void *user_data)
{
GF_QuicConnection *qc = user_data;
//client
if (!qc->serv_conn) return 0;
u32 conn_idx=0;
for (;conn_idx<MAC_CONN_ID; conn_idx++) {
ConnIDInfo *ci = &qc->serv_conn->conn_ids[conn_idx];
if (!memcmp(ci->dcid, cid->data, cid->datalen)) {
ci->associated = GF_FALSE;
return 0;
}
}
return 0;
}
static int ngq_extend_max_local_streams_bidi(ngtcp2_conn *conn, uint64_t max_streams,
void *user_data)
{
return 0;
}
static void ngq_printf(void *user_data, const char *format, ...)
{
va_list ap;
(void)user_data;
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
fprintf(stderr, "\n");
}
static void ngq_debug_trace(const char *format, va_list args)
{
vfprintf(stderr, format, args);
fprintf(stderr, "\n");
}
static void ngq_debug_trace_noop(const char *format, va_list args)
{
}
static nghttp3_ssize ngh3_data_source_read_callback(
nghttp3_conn *conn, int64_t stream_id, nghttp3_vec *vec, size_t veccnt,
uint32_t *pflags, void *conn_user_data, void *stream_user_data)
{
GF_DownloadSession *sess = stream_user_data;
GF_QuicDataRead *qr = sess->hmux_priv;
if (!sess->hmux_is_eos && !sess->local_buf_len && !qr->second_local_buf_len
) {
sess->hmux_data_paused = 1;
return NGHTTP3_ERR_WOULDBLOCK;
}
vec[0].len = sess->local_buf_len - qr->local_buf_sent;
if (!vec[0].len) {
if (sess->hmux_is_eos && !qr->second_local_buf_len
) {
*pflags |= NGHTTP3_DATA_FLAG_EOF;
sess->hmux_is_eos = 0;
sess->hmux_data_done = 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLD" sending EOS\n", stream_id));
gf_free(qr->second_local_buf);
qr->second_local_buf = NULL;
qr->second_local_buf_len = 0;
qr->second_local_buf_alloc = 0;
return 0;
}
sess->hmux_data_paused = 1;
qr->wait_ack = GF_TRUE;
return NGHTTP3_ERR_WOULDBLOCK;
}
vec[0].base = sess->local_buf + qr->local_buf_sent;
qr->local_buf_sent += vec[0].len;
return 1;
}
static GF_Err h3_setup_session(GF_DownloadSession *sess, Bool is_destroy)
{
if (is_destroy) {
if (sess->hmux_priv) {
GF_QuicDataRead *qr = sess->hmux_priv;
if (qr->second_local_buf) gf_free(qr->second_local_buf);
gf_free(sess->hmux_priv);
sess->hmux_priv = NULL;
}
return GF_OK;
}
if (!sess->hmux_priv) {
GF_SAFEALLOC(sess->hmux_priv, GF_QuicDataRead);
if (!sess->hmux_priv) return GF_OUT_OF_MEM;
if (sess->log_name) gf_free(sess->log_name);
sess->log_name = gf_strdup("HTTP/3");
}
GF_QuicDataRead *qr = sess->hmux_priv;
qr->data_read.read_data = ngh3_data_source_read_callback;
return GF_OK;
}
static int ngh3_recv_data(nghttp3_conn *conn, int64_t stream_id, const uint8_t *data,
size_t datalen, void *conn_user_data, void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
GF_DownloadSession *sess = stream_user_data;
ngtcp2_conn_extend_max_stream_offset(qc->conn, stream_id, datalen);
ngtcp2_conn_extend_max_offset(qc->conn, datalen);
if (!sess)
return NGHTTP3_ERR_CALLBACK_FAILURE;
if (sess->hmux_buf.size + datalen > sess->hmux_buf.alloc) {
sess->hmux_buf.alloc = sess->hmux_buf.size + (u32) datalen;
sess->hmux_buf.data = gf_realloc(sess->hmux_buf.data, sizeof(u8) * sess->hmux_buf.alloc);
if (!sess->hmux_buf.data) return NGHTTP3_ERR_NOMEM;
}
memcpy(sess->hmux_buf.data + sess->hmux_buf.size, data, datalen);
sess->hmux_buf.size += (u32) datalen;
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLD" received %d bytes (%d/%d total)\n", sess->hmux_stream_id, (u32) datalen, sess->hmux_buf.size, sess->total_size));
return 0;
}
static int ngh3_deferred_consume(nghttp3_conn *conn, int64_t stream_id,
size_t datalen, void *conn_user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
ngtcp2_conn_extend_max_stream_offset(qc->conn, stream_id, datalen);
ngtcp2_conn_extend_max_offset(qc->conn, datalen);
return 0;
}
static int ngh3_begin_headers(nghttp3_conn *conn, int64_t stream_id, void *conn_user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
GF_DownloadSession *sess = stream_user_data;
if (!sess && (qc->hmux->net_sess->hmux_stream_id==-2)) {
sess = qc->hmux->net_sess;
qc->hmux->net_sess->hmux_stream_id = stream_id;
nghttp3_conn_set_stream_user_data(conn, stream_id, sess);
}
if (!sess) {
GF_DownloadSession *par_sess = qc->hmux->net_sess;
if (!par_sess || !par_sess->server_mode)
return NGHTTP3_ERR_CALLBACK_FAILURE;
if (par_sess->user_proc) {
GF_NETIO_Parameter param;
memset(&param, 0, sizeof(GF_NETIO_Parameter));
param.msg_type = GF_NETIO_REQUEST_SESSION;
par_sess->in_callback = GF_TRUE;
param.sess = par_sess;
param.stream_id = stream_id;
par_sess->user_proc(par_sess->usr_cbk, &param);
par_sess->in_callback = GF_FALSE;
if (param.error == GF_OK) {
sess = hmux_get_session(qc->hmux, stream_id, GF_FALSE);
}
}
if (!sess)
return NGHTTP3_ERR_CALLBACK_FAILURE;
nghttp3_conn_set_stream_user_data(conn, stream_id, sess);
sess->hmux_stream_id = stream_id;
sess->flags |= GF_NETIO_SESSION_USE_QUIC;
}
GF_QuicDataRead *qr = sess->hmux_priv;
qr->is_put = GF_FALSE;
gf_dm_sess_clear_headers(sess);
return 0;
}
static int ngh3_recv_header(nghttp3_conn *conn, int64_t stream_id, int32_t token,
nghttp3_rcbuf *name, nghttp3_rcbuf *value, uint8_t flags,
void *conn_user_data, void *stream_user_data)
{
GF_DownloadSession *sess = stream_user_data;
GF_HTTPHeader *hdrp;
GF_SAFEALLOC(hdrp, GF_HTTPHeader);
if (!hdrp) return NGHTTP3_ERR_NOMEM;
nghttp3_vec v = nghttp3_rcbuf_get_buf(name);
hdrp->name = gf_malloc(v.len+1);
if (!hdrp->name) {
gf_free(hdrp);
return NGHTTP3_ERR_NOMEM;
}
memcpy(hdrp->name,v.base,v.len+1);
hdrp->name[v.len]=0;
v = nghttp3_rcbuf_get_buf(value);
hdrp->value = gf_malloc(v.len+1);
if (!hdrp->value) {
gf_free(hdrp->name);
gf_free(hdrp);
return NGHTTP3_ERR_NOMEM;
}
memcpy(hdrp->value,v.base,v.len+1);
hdrp->value[v.len]=0;
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLD" got header %s: %s\n", sess->hmux_stream_id, hdrp->name, hdrp->value));
gf_list_add(sess->headers, hdrp);
if (!strcmp(hdrp->name, ":method") && (!stricmp(hdrp->value, "PUT") || !stricmp(hdrp->value, "POST"))) {
GF_QuicDataRead *qr = sess->hmux_priv;
qr->is_put = GF_TRUE;
}
return 0;
}
static int ngh3_end_headers(nghttp3_conn *conn, int64_t stream_id, int fin,
void *conn_user_data, void *stream_user_data)
{
GF_DownloadSession *sess = stream_user_data;
sess->hmux_headers_seen = 1;
if (sess->server_mode) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] All headers received for stream ID "LLD"\n", sess->hmux_stream_id));
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] All headers received for stream ID "LLD"\n", sess->hmux_stream_id));
}
if (fin && !sess->server_mode) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLU" (%s) data done\n", stream_id, sess->remote_path ? sess->remote_path : sess->orig_url));
sess->hmux_data_done = 1;
sess->hmux_is_eos = 0;
sess->hmux_send_data = NULL;
sess->hmux_send_data_len = 0;
}
return 0;
}
static int ngh3_begin_trailers(nghttp3_conn *conn, int64_t stream_id, void *conn_user_data, void *stream_user_data) {
return 0;
}
static int ngh3_recv_trailer(nghttp3_conn *conn, int64_t stream_id, int32_t token,
nghttp3_rcbuf *name, nghttp3_rcbuf *value, uint8_t flags,
void *conn_user_data, void *stream_user_data)
{
return 0;
}
static int ngh3_end_trailers(nghttp3_conn *conn, int64_t stream_id, int fin,
void *conn_user_data, void *stream_user_data)
{
return 0;
}
static int ngh3_stop_sending(nghttp3_conn *conn, int64_t stream_id, uint64_t app_error_code,
void *conn_user_data, void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
if (!qc->http_conn) return 0;
int rv = nghttp3_conn_shutdown_stream_read(qc->http_conn, stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_shutdown_stream_read failed %s\n", nghttp3_strerror(rv) ));
return NGHTTP3_ERR_CALLBACK_FAILURE;
}
//TODO : abort put/post or server mode
return 0;
}
static int ngh3_reset_stream(nghttp3_conn *conn, int64_t stream_id, uint64_t app_error_code,
void *conn_user_data, void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
if (!qc->http_conn) return 0;
int rv = ngtcp2_conn_shutdown_stream_write(qc->conn, 0, stream_id, app_error_code);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] ngtcp2_conn_shutdown_stream_write failed %s\n", ngtcp2_strerror(rv) ));
return NGHTTP3_ERR_CALLBACK_FAILURE;
}
return 0;
}
static int ngh3_end_stream(nghttp3_conn *conn, int64_t stream_id, void *conn_user_data, void *stream_user_data)
{
GF_DownloadSession *sess = stream_user_data;
//session may have been detached once we detect EOS, ignore streamid mismatch
if (!sess || (sess->hmux_stream_id != stream_id))
return 0;
GF_QuicDataRead *qr = sess->hmux_priv;
if (sess->put_state) {
sess->put_state = 0;
sess->status = GF_NETIO_DATA_TRANSFERED;
sess->last_error = GF_OK;
}
if ((!sess->server_mode || qr->is_put) && !sess->hmux_data_done)
sess->hmux_is_eos = 1;
return 0;
}
static int ngh3_stream_close(nghttp3_conn *conn, int64_t stream_id, uint64_t app_error_code,
void *conn_user_data, void *stream_user_data)
{
Bool do_retry = GF_FALSE;
GF_DownloadSession *sess = stream_user_data;
//server: give the peer back the credit of each closed request stream, otherwise a connection can only ever
//open hx-max-st request streams (initial_max_streams_bidi is a total, not a concurrency limit)
if (ngtcp2_is_bidi_stream(stream_id)) {
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
if (!ngtcp2_conn_is_local_stream(qc->conn, stream_id))
ngtcp2_conn_extend_max_streams_bidi(qc->conn, 1);
}
//session may have been detached once we detect EOS, ignore streamid mismatch
if (!sess|| (sess->hmux_stream_id != stream_id))
return 0;
if (!ngtcp2_is_bidi_stream(stream_id)) {
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
assert(!ngtcp2_conn_is_local_stream(qc->conn, stream_id));
ngtcp2_conn_extend_max_streams_uni(qc->conn, 1);
}
gf_mx_p(sess->mx);
if ((app_error_code==NGHTTP3_H3_EXCESSIVE_LOAD)
|| (app_error_code==NGHTTP3_H3_REQUEST_REJECTED)
) {
do_retry = GF_TRUE;
} else if (sess->hmux_sess->do_shutdown && !sess->server_mode && !sess->bytes_done) {
do_retry = GF_TRUE;
}
if (do_retry) {
sess->hmux_sess->do_shutdown = GF_TRUE;
sess->hmux_switch_sess = GF_TRUE;
sess->status = GF_NETIO_SETUP;
SET_LAST_ERR(GF_OK)
gf_mx_v(sess->mx);
return 0;
}
if (app_error_code!=NGHTTP3_H3_NO_ERROR) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLU" (%s) closed with error_code=%d\n", stream_id, sess->remote_path ? sess->remote_path : sess->orig_url, app_error_code));
sess->status = GF_NETIO_STATE_ERROR;
SET_LAST_ERR(GF_IP_NETWORK_FAILURE)
sess->put_state = 0;
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] stream_id "LLU" (%s) closed (put state %d)\n", stream_id, sess->remote_path ? sess->remote_path : sess->orig_url, sess->put_state));
if (sess->put_state) {
sess->put_state = 0;
sess->status = GF_NETIO_DATA_TRANSFERED;
sess->last_error = GF_OK;
}
}
//stream closed
sess->hmux_stream_id = -1;
gf_mx_v(sess->mx);
return 0;
}
static int ngh3_acked_stream_data(nghttp3_conn *conn, int64_t stream_id, uint64_t datalen,
void *conn_user_data, void *stream_user_data)
{
GF_QuicConnection *qc = (GF_QuicConnection *)conn_user_data;
GF_DownloadSession *sess = stream_user_data;
GF_QuicDataRead *qr = sess->hmux_priv;
ngtcp2_conn_info ci;
ngtcp2_conn_get_conn_info(qc->conn, &ci);
gf_assert(sess->hmux_stream_id == stream_id);
qr->local_buf_ack += datalen;
assert(qr->local_buf_sent >= qr->local_buf_ack);
//only memove once ack
if (qr->local_buf_sent == qr->local_buf_ack) {
gf_mx_p(sess->mx);
assert(sess->local_buf_len >= qr->local_buf_sent);
if (sess->local_buf_len) {
sess->local_buf_len -= qr->local_buf_sent;
if (sess->local_buf_len)
memmove(sess->local_buf, sess->local_buf + qr->local_buf_sent, sess->local_buf_len);
}
qr->local_buf_sent = 0;
qr->local_buf_ack = 0;
//swap buffers
if (!sess->local_buf_len && qr->second_local_buf_len) {
u8 *tmp_buf = sess->local_buf;
u32 tmp = sess->local_buf_alloc;
sess->local_buf = qr->second_local_buf;
sess->local_buf_alloc = qr->second_local_buf_alloc;
sess->local_buf_len = qr->second_local_buf_len;
qr->second_local_buf = tmp_buf;
qr->second_local_buf_alloc = tmp;
qr->second_local_buf_len = 0;
}
gf_mx_v(sess->mx);
}
qr->wait_ack = GF_FALSE;
if ((sess->local_buf_len || sess->hmux_is_eos) && sess->hmux_data_paused) {
sess->hmux_data_paused = 0;
nghttp3_conn_resume_stream(qc->http_conn, sess->hmux_stream_id);
}
return 0;
}
static GF_Err h3_setup_http3(GF_HMUX_Session *hmux_sess)
{
GF_QuicConnection *qc = (GF_QuicConnection *)hmux_sess->hmux_udta;
if (qc->http_conn) return GF_OK;
if (ngtcp2_conn_get_streams_uni_left(qc->conn) < 3) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] peer does not allow at least 3 unidirectional streams.\n"));
return GF_REMOTE_SERVICE_ERROR;
}
nghttp3_callbacks callbacks = {
.stream_close = ngh3_stream_close,
.recv_data = ngh3_recv_data,
.deferred_consume = ngh3_deferred_consume,
.begin_headers = ngh3_begin_headers,
.recv_header = ngh3_recv_header,
.end_headers = ngh3_end_headers,
.begin_trailers = ngh3_begin_trailers,
.recv_trailer = ngh3_recv_trailer,
.end_trailers = ngh3_end_trailers,
.stop_sending = ngh3_stop_sending,
.reset_stream = ngh3_reset_stream,
.acked_stream_data = ngh3_acked_stream_data,
.end_stream = ngh3_end_stream
};
nghttp3_settings settings;
nghttp3_settings_default(&settings);
settings.qpack_max_dtable_capacity = 4096;
settings.qpack_blocked_streams = 100;
const nghttp3_mem *mem = nghttp3_mem_default();
int rv;
if (qc->serv_conn) {
rv = nghttp3_conn_server_new(&qc->http_conn, &callbacks, &settings, mem, hmux_sess->hmux_udta);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_server_new error %s\n", nghttp3_strerror(rv) ));
return GF_SERVICE_ERROR;
}
const ngtcp2_transport_params *params = ngtcp2_conn_get_local_transport_params(qc->conn);
nghttp3_conn_set_max_client_streams_bidi(qc->http_conn, params->initial_max_streams_bidi);
} else {
rv = nghttp3_conn_client_new(&qc->http_conn, &callbacks, &settings, mem, hmux_sess->hmux_udta);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_client_new error %s\n", nghttp3_strerror(rv) ));
return GF_SERVICE_ERROR;
}
}
hmux_sess->connected = GF_TRUE;
s64 ctrl_stream_id;
rv = ngtcp2_conn_open_uni_stream(qc->conn, &ctrl_stream_id, NULL);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_open_uni_stream: ", ngtcp2_strerror(rv) ));
return GF_SERVICE_ERROR;
}
rv = nghttp3_conn_bind_control_stream(qc->http_conn, ctrl_stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_bind_control_stream error %s\n", nghttp3_strerror(rv) ));
return GF_SERVICE_ERROR;
}
s64 qpack_enc_stream_id, qpack_dec_stream_id;
rv = ngtcp2_conn_open_uni_stream(qc->conn, &qpack_enc_stream_id, NULL);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_open_uni_stream error %s\n", ngtcp2_strerror(rv) ));
return GF_SERVICE_ERROR;
}
rv = ngtcp2_conn_open_uni_stream(qc->conn, &qpack_dec_stream_id, NULL);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_open_uni_stream error %s\n", ngtcp2_strerror(rv) ));
return GF_SERVICE_ERROR;
}
rv = nghttp3_conn_bind_qpack_streams(qc->http_conn, qpack_enc_stream_id, qpack_dec_stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_bind_qpack_streams error %s\n", nghttp3_strerror(rv) ));
return GF_SERVICE_ERROR;
}
return GF_OK;
}
#define NGH3_HDR(_hdr, _name, _value) { \
_hdr.name = (uint8_t *)_name;\
_hdr.value = (uint8_t *)_value;\
_hdr.namelen = (u32) strlen(_name);\
_hdr.valuelen = (u32) strlen(_value);\
_hdr.flags = NGHTTP3_NV_FLAG_NONE;\
}
static GF_Err h3_submit_request(GF_DownloadSession *sess, char *req_name, const char *url, const char *param_string, Bool has_body)
{
GF_QuicConnection *qc = (GF_QuicConnection *)sess->hmux_sess->hmux_udta;
if (!qc->http_conn)
return GF_SERVICE_ERROR;
u32 nb_hdrs, i;
char *hostport = NULL;
char *path = NULL;
char port[20];
nghttp3_nv *hdrs;
nb_hdrs = gf_list_count(sess->headers);
hdrs = gf_malloc(sizeof(nghttp3_nv) * (nb_hdrs + 4));
if (!hdrs) return GF_OUT_OF_MEM;
NGH3_HDR(hdrs[0], ":method", req_name);
NGH3_HDR(hdrs[1], ":scheme", "https");
gf_dynstrcat(&hostport, sess->server_name, NULL);
sprintf(port, ":%d", sess->port);
gf_dynstrcat(&hostport, port, NULL);
NGH3_HDR(hdrs[2], ":authority", hostport);
if (param_string) {
gf_dynstrcat(&path, url, NULL);
if (strchr(sess->remote_path, '?')) {
gf_dynstrcat(&path, param_string, "&");
} else {
gf_dynstrcat(&path, param_string, "?");
}
NGH3_HDR(hdrs[3], ":path", path);
} else {
NGH3_HDR(hdrs[3], ":path", url);
}
for (i=0; i<nb_hdrs; i++) {
GF_HTTPHeader *hdr = gf_list_get(sess->headers, i);
NGH3_HDR(hdrs[4+i], hdr->name, hdr->value);
}
GF_QuicDataRead *qr = NULL;
gf_assert((sess->hmux_stream_id<0) || sess->hmux_data_done);
qr = sess->hmux_priv;
gf_assert(qr->local_buf_sent == qr->local_buf_ack);
qr=NULL;
if (has_body) {
qr = (GF_QuicDataRead*)sess->hmux_priv;
gf_assert(qr && qr->data_read.read_data);
}
sess->hmux_data_done = 0;
sess->hmux_headers_seen = 0;
sess->hmux_ready_to_send = 0;
GF_Err e = GF_OK;
int rv = ngtcp2_conn_open_bidi_stream(qc->conn, &sess->hmux_stream_id, sess);
if (rv != 0) {
e = GF_SERVICE_ERROR;
}
if (!e) {
rv = nghttp3_conn_submit_request(qc->http_conn, sess->hmux_stream_id, hdrs, nb_hdrs+4,
qr ? &qr->data_read : NULL, sess);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_submit_request error %s\n", nghttp3_strerror(rv) ));
e = GF_SERVICE_ERROR;
}
}
#ifndef GPAC_DISABLE_LOG
if (!e && gf_log_tool_level_on(GF_LOG_HTTP, GF_LOG_DEBUG)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[HTTP/3] send request (has_body %d) for new stream_id "LLD":\n", has_body, sess->hmux_stream_id));
for (i=0; i<nb_hdrs+4; i++) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("\t%s: %s\n", hdrs[i].name, hdrs[i].value));
}
}
#endif
gf_free(hdrs);
gf_free(hostport);
if (path) gf_free(path);
if (e)
return e;
if (sess->hmux_stream_id < 0) {
return GF_IP_NETWORK_FAILURE;
}
return h3_session_write_ex(sess, NULL);
}
static GF_Err h3_data_pending(GF_DownloadSession *sess)
{
//always move pending data to local buffer
if (sess->hmux_send_data) {
gf_mx_p(sess->mx);
GF_QuicDataRead *qr = sess->hmux_priv;
Bool use_main = GF_FALSE;
if (!qr->second_local_buf_len) {
if (!sess->local_buf_alloc)
use_main = GF_TRUE;
else if (sess->local_buf_len + sess->hmux_send_data_len < sess->local_buf_alloc)
use_main = GF_TRUE;
}
if (use_main) gf_assert(qr->second_local_buf_len==0);
u8 **buf = use_main ? &sess->local_buf : &qr->second_local_buf;
u32 *size = use_main ? &sess->local_buf_len : &qr->second_local_buf_len;
u32 *allocated = use_main ? &sess->local_buf_alloc : &qr->second_local_buf_alloc;
if (! *buf || *size + sess->hmux_send_data_len > *allocated) {
*allocated = *size + sess->hmux_send_data_len;
if (*allocated < SOCK_BUF_SIZE/2) *allocated = SOCK_BUF_SIZE/2;
*buf = gf_realloc(*buf, *allocated);
if (! *buf) {
gf_mx_v(sess->mx);
return GF_OUT_OF_MEM;
}
}
memcpy(*buf + *size, sess->hmux_send_data, sess->hmux_send_data_len);
*size += sess->hmux_send_data_len;
sess->hmux_send_data_len = 0;
sess->hmux_send_data = NULL;
gf_mx_v(sess->mx);
if (sess->hmux_data_paused) {
sess->hmux_data_paused = 0;
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
nghttp3_conn_resume_stream(qc->http_conn, sess->hmux_stream_id);
}
}
return h3_session_write_ex(sess, NULL);
}
static GF_Err h3_send_reply(GF_DownloadSession *sess, u32 reply_code, const char *response_body, u32 body_len, Bool no_body)
{
GF_QuicConnection *qc = (GF_QuicConnection *)sess->hmux_sess->hmux_udta;
nghttp3_nv *hdrs;
char szFmt[20];
u32 i, count = gf_list_count(sess->headers);
if (response_body) {
no_body = GF_FALSE;
sess->hmux_send_data = (u8 *) response_body;
sess->hmux_send_data_len = body_len;
sess->hmux_is_eos = 1;
} else if (!no_body) {
switch (reply_code) {
case 200:
case 206:
no_body = GF_FALSE;
sess->hmux_is_eos = 0;
break;
default:
no_body = GF_TRUE;
break;
}
}
hdrs = gf_malloc(sizeof(nghttp3_nv) * (count + 1) );
sprintf(szFmt, "%d", reply_code);
NGH3_HDR(hdrs[0], ":status", szFmt);
GF_LOG(GF_LOG_INFO, GF_LOG_HTTP, ("[HTTP/3] send reply for stream_id "LLD" (body %d) headers:\n:status: %s\n", sess->hmux_stream_id, !no_body, szFmt));
for (i=0; i<count; i++) {
GF_HTTPHeader *hdr = gf_list_get(sess->headers, i);
NGH3_HDR(hdrs[i+1], hdr->name, hdr->value)
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("%s: %s\n", hdr->name, hdr->value));
}
GF_QuicDataRead *qr = NULL;
if (!no_body) {
if (!sess->hmux_priv)
h3_setup_session(sess, GF_FALSE);
qr = sess->hmux_priv;
gf_assert(qr && qr->data_read.read_data);
}
gf_mx_p(sess->mx);
int rv = nghttp3_conn_submit_response(qc->http_conn, sess->hmux_stream_id, hdrs, (count+1), no_body ? NULL : &qr->data_read);
gf_free(hdrs);
if (rv != 0) {
gf_mx_v(sess->mx);
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_submit_response error: %s\n", nghttp3_strerror(rv) ));
return GF_BAD_PARAM;
}
//in case we have a body already setup with this reply
//if none, this will call write anyway
h3_data_pending(sess);
gf_mx_v(sess->mx);
return GF_OK;
}
static GF_Err h3_session_write_ex(GF_DownloadSession *sess, GF_QuicConnection *qc)
{
GF_Err e, ret;
if (!qc) qc = (GF_QuicConnection *)sess->hmux_sess->hmux_udta;
if (!qc) return GF_BAD_PARAM;
if (qc->serv_conn && qc->serv_conn->closed) {
sess->local_buf_len = 0;
GF_QuicDataRead *qr = sess->hmux_priv;
qr->second_local_buf_len = 0;
return GF_IP_CONNECTION_CLOSED;
}
//flush blocked packet if any
if (qc->cur_buf_len) {
if (qc->serv_conn) {
e = quic_send_packet(qc->serv_conn->server, qc->cur_buf, qc->cur_buf_len, (const u8 *) qc->cur_path.path.remote.addr, (u32) qc->cur_path.path.remote.addrlen);
} else if (sess && sess->sock) {
u32 written=0;
e = gf_sk_send_ex(sess->sock, qc->cur_buf, qc->cur_buf_len, &written);
} else {
e = GF_IP_CONNECTION_CLOSED;
}
if (e==GF_IP_NETWORK_EMPTY) {
return GF_IP_NETWORK_EMPTY;
}
qc->cur_buf_len = 0;
}
ret = GF_IP_NETWORK_EMPTY;
u32 max_pay_size = ngtcp2_conn_get_max_tx_udp_payload_size(qc->conn);
u32 path_max_udp_size = ngtcp2_conn_get_path_max_tx_udp_payload_size(qc->conn);
u64 ts = ngtcp2_timestamp();
ngtcp2_pkt_info pi;
u32 pay_size=0;
ngtcp2_path_storage_zero(&qc->cur_path);
for (;;) {
s64 stream_id = -1;
s32 fin = 0;
nghttp3_vec vec[256];
u32 nb_vec=0;
vec[0].len = 0;
vec[0].base = NULL;
if (qc->http_conn && ngtcp2_conn_get_max_data_left(qc->conn)) {
s32 rv = nghttp3_conn_writev_stream(qc->http_conn, &stream_id, &fin, vec, GF_ARRAY_LENGTH(vec) );
if (rv < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_writev_stream error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return quic_handle_error(qc);
}
nb_vec = (u32) rv;
}
ngtcp2_ssize ndatalen;
u32 flags = NGTCP2_WRITE_STREAM_FLAG_MORE;
if (fin) {
flags |= NGTCP2_WRITE_STREAM_FLAG_FIN;
}
u32 buflen = pay_size >= max_pay_size ? max_pay_size : path_max_udp_size;
ndatalen=0;
ngtcp2_ssize nwrite = ngtcp2_conn_writev_stream(qc->conn, &qc->cur_path.path, &pi,
qc->cur_buf, buflen, &ndatalen, flags,
stream_id, (ngtcp2_vec*)vec, nb_vec,
ts
);
if (nwrite < 0) {
s32 rv;
switch (nwrite) {
case NGTCP2_ERR_STREAM_DATA_BLOCKED:
assert(ndatalen == -1);
nghttp3_conn_block_stream(qc->http_conn, stream_id);
continue;
case NGTCP2_ERR_STREAM_SHUT_WR:
assert(ndatalen == -1);
nghttp3_conn_shutdown_stream_write(qc->http_conn, stream_id);
continue;
case NGTCP2_ERR_WRITE_MORE:
assert(ndatalen >= 0);
rv = nghttp3_conn_add_write_offset(qc->http_conn, stream_id, ndatalen);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] Error in nghttp3_conn_add_write_offset: %s\n", nghttp3_strerror(rv)));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
if (!qc->handshake_state) qc->handshake_state = QUIC_HANDSHAKE_ERROR;
return quic_handle_error(qc);
}
continue;
}
assert(ndatalen == -1);
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] Error in ngtcp2_conn_write_stream: %s\n", ngtcp2_strerror(nwrite) ));
ngtcp2_ccerr_set_liberr(&qc->last_error, nwrite, NULL, 0);
if (!qc->handshake_state) qc->handshake_state = QUIC_HANDSHAKE_ERROR;
return quic_handle_error(qc);
}
if (ndatalen >= 0) {
s32 rv = nghttp3_conn_add_write_offset(qc->http_conn, stream_id, ndatalen);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] Error in nghttp3_conn_add_write_offset: %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
if (!qc->handshake_state) qc->handshake_state = QUIC_HANDSHAKE_ERROR;
return quic_handle_error(qc);
}
}
if (nwrite == 0) {
ngtcp2_conn_update_pkt_tx_time(qc->conn, ts);
return ret;
}
if (qc->serv_conn) {
e = quic_send_packet(qc->serv_conn->server, qc->cur_buf, nwrite, (const u8 *) qc->cur_path.path.remote.addr, (u32) qc->cur_path.path.remote.addrlen);
} else if (sess && sess->sock) {
u32 written=0;
e = gf_sk_send_ex(sess->sock, qc->cur_buf, nwrite, &written);
} else {
e = GF_IP_CONNECTION_CLOSED;
}
if (e==GF_IP_NETWORK_EMPTY) {
qc->cur_buf_len = (u32) nwrite;
break;
}
if (e) {
break;
}
ret = GF_OK;
}
return ret;
}
static GF_Err h3_session_write(GF_DownloadSession *sess)
{
return h3_session_write_ex(sess, NULL);
}
static void h3_stream_reset(GF_DownloadSession *sess, Bool is_abort)
{
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (is_abort && qc->http_conn && (sess->hmux_stream_id>=0)) {
nghttp3_conn_close_stream(qc->http_conn, sess->hmux_stream_id, NGHTTP3_H3_REQUEST_INCOMPLETE);
}
}
static GF_Err h3_resume_stream(GF_DownloadSession *sess)
{
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
GF_QuicDataRead *qr = sess->hmux_priv;
if (!qc->http_conn || (sess->hmux_stream_id<0) || (qc->serv_conn && qc->serv_conn->closed))
return GF_IP_CONNECTION_CLOSED;
if (qr->wait_ack) return GF_OK;
sess->hmux_data_paused = 0;
nghttp3_conn_resume_stream(qc->http_conn, sess->hmux_stream_id);
return GF_OK;
}
static void h3_close(struct _http_mux_session *hmux)
{
GF_QuicConnection *qc = hmux->hmux_udta;
if (!qc->conn || !hmux->net_sess || !hmux->net_sess->sock
|| ngtcp2_conn_in_closing_period(qc->conn)
|| ngtcp2_conn_in_draining_period(qc->conn)
) {
return;
}
ngtcp2_path_storage ps;
ngtcp2_path_storage_zero(&ps);
ngtcp2_pkt_info pi;
u8 buffer[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
int nwrite = ngtcp2_conn_write_connection_close(qc->conn, &ps.path, &pi, buffer, NGTCP2_MAX_UDP_PAYLOAD_SIZE, &qc->last_error, ngtcp2_timestamp() );
if (nwrite > 0) {
u32 written;
gf_sk_send_ex(hmux->net_sess->sock, buffer, nwrite, &written);
}
}
static void h3_destroy(struct _http_mux_session *hmux)
{
GF_QuicConnection *qc = hmux->hmux_udta;
if (qc->http_conn)
nghttp3_conn_del(qc->http_conn);
ngtcp2_conn_del(qc->conn);
if (qc->path.local.addr) gf_free(qc->path.local.addr);
if (qc->path.remote.addr) gf_free(qc->path.remote.addr);
if (qc->serv_conn) {
gf_list_del_item(qc->serv_conn->server->connections, qc->serv_conn);
gf_free(qc->serv_conn);
}
gf_free(qc);
}
static GF_Err h3_async_flush(GF_DownloadSession *sess, Bool for_close)
{
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (qc->serv_conn && qc->serv_conn->closed)
return GF_IP_CONNECTION_CLOSED;
//QUIC, resume data sending, send packets and check if we are done pushing local copy
//(we always do a local copy to deal with retransmits)
gf_mx_p(sess->mx);
if (!sess->server_mode) {
u8 buf[1500];
u32 res;
//read any frame pending from remote peer (ack, window update and co)
GF_Err e = gf_dm_read_data(sess, buf, 1500, &res);
if ((e<0) && (e != GF_IP_NETWORK_EMPTY)) {
sess->status = GF_NETIO_STATE_ERROR;
SET_LAST_ERR(sess->last_error)
return e;
}
}
h3_data_pending(sess);
gf_mx_v(sess->mx);
GF_QuicDataRead *qr = sess->hmux_priv;
if (for_close) {
if (qr->local_buf_sent>qr->local_buf_ack)
return GF_IP_NETWORK_EMPTY;
if (sess->put_state==1)
return GF_IP_NETWORK_EMPTY;
}
if (!sess->local_buf_len && !sess->hmux_is_eos) return GF_OK;
gf_assert(sess->hmux_send_data==NULL);
//EOS reached, we're done
if (sess->hmux_data_done) {
return GF_OK;
}
//EOS signaled on session, wait for everything to be acked
if (sess->hmux_is_eos && (sess->local_buf_len || qr->second_local_buf_len)) {
return GF_IP_NETWORK_EMPTY;
}
if (sess->local_buf_len + qr->second_local_buf_len > SOCK_BUF_SIZE) {
return GF_IP_NETWORK_EMPTY;
}
return GF_OK;
}
static GF_Err h3_data_received(GF_DownloadSession *sess, const u8 *data, u32 nb_bytes)
{
if (nb_bytes) {
GF_QuicConnection *qc = ( GF_QuicConnection *) sess->hmux_sess->hmux_udta;
ngtcp2_path path;
ngtcp2_pkt_info pi = {0};
path = qc->path;
int rv = ngtcp2_conn_read_pkt(qc->conn, &path, &pi, data, (size_t)nb_bytes, ngtcp2_timestamp() );
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_read_pkt: %s\n", ngtcp2_strerror(rv) ));
if (!qc->last_error.error_code) {
if (rv == NGTCP2_ERR_CRYPTO) {
ngtcp2_ccerr_set_tls_alert(&qc->last_error, ngtcp2_conn_get_tls_alert(qc->conn), NULL, 0);
} else {
ngtcp2_ccerr_set_liberr(&qc->last_error, rv, NULL, 0);
}
}
if (!qc->handshake_state) qc->handshake_state = QUIC_HANDSHAKE_ERROR;
return GF_IP_NETWORK_FAILURE;
}
}
/* send pending frames - hmux_sess may be NULL at this point if the connection was reset during processing of the above
this typically happens if we have a refused stream
*/
h3_session_write(sess);
return GF_OK;
}
static ngtcp2_conn *ngq_get_conn(ngtcp2_crypto_conn_ref *conn_ref)
{
GF_QuicConnection *qc = conn_ref->user_data;
return qc->conn;
}
static int ngq_handshake_completed(ngtcp2_conn *conn, void *user_data)
{
GF_QuicConnection *qc = user_data;
if (qc->handshake_state<QUIC_HANDSHAKE_DONE) {
qc->handshake_state = QUIC_HANDSHAKE_DONE;
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] Handshake done\n"));
}
return 0;
}
int ngq_recv_stream_data(ngtcp2_conn *conn, uint32_t flags, int64_t stream_id,
uint64_t offset, const uint8_t *data, size_t datalen,
void *user_data, void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
if (!qc->http_conn) return -1;
int rv = nghttp3_conn_read_stream(qc->http_conn, stream_id, data, datalen, flags & NGTCP2_STREAM_DATA_FLAG_FIN);
if (rv < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_read_stream error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return NGTCP2_ERR_CALLBACK_FAILURE;
}
ngtcp2_conn_extend_max_stream_offset(qc->conn, stream_id, rv);
ngtcp2_conn_extend_max_offset(qc->conn, rv);
return 0;
}
static int ngq_acked_stream_data_offset(ngtcp2_conn *conn, int64_t stream_id,
uint64_t offset, uint64_t datalen, void *user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
int rv = nghttp3_conn_add_ack_offset(qc->http_conn, stream_id, datalen);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_add_ack_offset error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return NGTCP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
int ngq_extend_max_stream_data(ngtcp2_conn *conn, int64_t stream_id,
uint64_t max_data, void *user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
int rv = nghttp3_conn_unblock_stream(qc->http_conn, stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_unblock_stream error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return NGTCP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
static int ngq_recv_rx_key(ngtcp2_conn *conn, ngtcp2_encryption_level level, void *user_data)
{
GF_QuicConnection *qc = user_data;
if (level != NGTCP2_ENCRYPTION_LEVEL_1RTT) return 0;
if (qc->http_conn) return GF_OK;
GF_Err e = h3_setup_http3(qc->hmux);
if (e) return NGTCP2_ERR_CALLBACK_FAILURE;
return 0;
}
static int ngq_stream_stop_sending(ngtcp2_conn *conn, int64_t stream_id,
uint64_t app_error_code, void *user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
if (!qc->http_conn) return 0;
int rv = nghttp3_conn_shutdown_stream_read(qc->http_conn, stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_shutdown_stream_read error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return NGTCP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
static int ngq_stream_close(ngtcp2_conn *conn, uint32_t flags, int64_t stream_id,
uint64_t app_error_code, void *user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
// GF_DownloadSession *sess = stream_user_data;
if (!(flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET)) {
app_error_code = NGHTTP3_H3_NO_ERROR;
}
if (!qc->http_conn) return 0;
if (app_error_code == 0) {
app_error_code = NGHTTP3_H3_NO_ERROR;
}
int rv = nghttp3_conn_close_stream(qc->http_conn, stream_id, app_error_code);
switch (rv) {
case 0:
break;
case NGHTTP3_ERR_STREAM_NOT_FOUND:
if (!ngtcp2_is_bidi_stream(stream_id)) {
assert(!ngtcp2_conn_is_local_stream(qc->conn, stream_id));
ngtcp2_conn_extend_max_streams_uni(qc->conn, 1);
}
break;
default:
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_close_stream error %s\n", nghttp3_strerror(rv) ));
ngtcp2_ccerr_set_application_error(&qc->last_error, nghttp3_err_infer_quic_app_error_code(rv), NULL, 0);
return NGTCP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
int ngq_stream_reset(ngtcp2_conn *conn, int64_t stream_id, uint64_t final_size,
uint64_t app_error_code, void *user_data,
void *stream_user_data)
{
GF_QuicConnection *qc = user_data;
if (!qc->http_conn) return 0;
int rv = nghttp3_conn_shutdown_stream_read(qc->http_conn, stream_id);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[HTTP/3] nghttp3_conn_shutdown_stream_read error %s\n", nghttp3_strerror(rv) ));
return NGTCP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
static int ngq_stream_open(ngtcp2_conn *conn, int64_t stream_id, void *user_data)
{
//GF_QuicConnection *qc = user_data;
if (!ngtcp2_is_bidi_stream(stream_id)) {
return 0;
}
return 0;
}
static void h3_close_session(GF_DownloadSession *sess)
{
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (!qc->http_conn) return;
if (qc->serv_conn && qc->serv_conn->closed) return;
nghttp3_conn_submit_shutdown_notice(qc->http_conn);
h3_session_write(sess);
nghttp3_conn_shutdown(qc->http_conn);
h3_session_write(sess);
sess->status = GF_NETIO_DISCONNECTED;
}
static GF_Err h3_initialize(GF_DownloadSession *sess, char *server, u32 server_port,
const ngtcp2_pkt_hd *srv_hd, const ngtcp2_cid *srv_ocid, u32 token_type, ngtcp2_path *srv_path, GF_QuicServerConnection *qsc)
{
GF_QuicConnection *ng_quic;
GF_Err e;
if (!sess->server_mode && sess->dm && (!sess->dm->ssl_ctx || !sess->ssl)) {
gf_ssl_try_connect(sess, NULL);
if (!sess->ssl) return GF_IO_ERR;
} else if (!sess->ssl) {
return GF_IP_CONNECTION_FAILURE;
}
GF_SAFEALLOC(sess->hmux_sess, GF_HMUX_Session);
if (!sess->hmux_sess) return GF_OUT_OF_MEM;
GF_SAFEALLOC(ng_quic, GF_QuicConnection);
if (!sess->hmux_sess) {
gf_free(sess->hmux_sess);
sess->hmux_sess = NULL;
return GF_OUT_OF_MEM;
}
ng_quic->serv_conn = qsc;
ng_quic->hmux = sess->hmux_sess;
sess->hmux_sess->hmux_udta = ng_quic;
ng_quic->conn_ref.get_conn = ngq_get_conn;
ng_quic->conn_ref.user_data = ng_quic;
RAND_bytes(ng_quic->secret, 32);
SSL_set_app_data(sess->ssl, &ng_quic->conn_ref);
if (qsc) qsc->hmux = sess->hmux_sess;
if (sess->server_mode) {
u8 *buf;
buf = gf_malloc(sizeof(u8) * srv_path->local.addrlen);
memcpy(buf, srv_path->local.addr, srv_path->local.addrlen);
ng_quic->path.local.addr = (ngtcp2_sockaddr *) buf;
ng_quic->path.local.addrlen = srv_path->local.addrlen;
buf = gf_malloc(sizeof(u8) * srv_path->remote.addrlen);
memcpy(buf, srv_path->remote.addr, srv_path->remote.addrlen);
ng_quic->path.remote.addr = (ngtcp2_sockaddr *) buf;
ng_quic->path.remote.addrlen = srv_path->remote.addrlen;
} else {
u8 *src, *dst;
u32 src_len, dst_len;
//bind to first avail port - we don't use port reuse here as we could bind two clients
//to the same server on a single machine, blocking the second client connection
u32 loc_port = 1234;
while (loc_port<0xFFFF) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] try binding port %u\n", loc_port));
e = gf_sk_bind_ex(sess->sock, "127.0.0.1", loc_port, server, server_port, 0, &dst, &dst_len, &src, &src_len);
if (e==GF_IP_CONNECTION_FAILURE) {
loc_port++;
continue;
}
break;
}
//UDP connect to make sure we only get datagrams for ourselves
if (!e) {
e = gf_sk_connect_ex(sess->sock, (char *) server, server_port, NULL, GF_TRUE);
}
if (e) {
if (src) gf_free(src);
if (dst) gf_free(dst);
goto err;
}
ng_quic->path.local.addr = (ngtcp2_sockaddr*)src;
ng_quic->path.local.addrlen = src_len;
ng_quic->path.remote.addr = (ngtcp2_sockaddr*)dst;
ng_quic->path.remote.addrlen = dst_len;
}
//setup callbacks
ngtcp2_callbacks callbacks = {
.handshake_completed = ngq_handshake_completed,
.recv_crypto_data = ngtcp2_crypto_recv_crypto_data_cb,
.encrypt = ngtcp2_crypto_encrypt_cb,
.decrypt = ngtcp2_crypto_decrypt_cb,
.hp_mask = ngtcp2_crypto_hp_mask_cb,
.recv_stream_data = ngq_recv_stream_data,
.acked_stream_data_offset = ngq_acked_stream_data_offset,
.extend_max_local_streams_bidi = ngq_extend_max_local_streams_bidi,
.rand = ngq_rand_cb,
.extend_max_stream_data = ngq_extend_max_stream_data,
.update_key = ngtcp2_crypto_update_key_cb,
.delete_crypto_aead_ctx = ngtcp2_crypto_delete_crypto_aead_ctx_cb,
.delete_crypto_cipher_ctx = ngtcp2_crypto_delete_crypto_cipher_ctx_cb,
.get_path_challenge_data = ngtcp2_crypto_get_path_challenge_data_cb,
.version_negotiation = ngtcp2_crypto_version_negotiation_cb,
.get_new_connection_id = ngq_get_new_connection_id,
.stream_close = ngq_stream_close,
.stream_reset = ngq_stream_reset,
.stream_stop_sending = ngq_stream_stop_sending,
};
if (sess->server_mode) {
callbacks.recv_client_initial = ngtcp2_crypto_recv_client_initial_cb;
callbacks.recv_tx_key = ngq_recv_rx_key;
callbacks.stream_open = ngq_stream_open;
callbacks.remove_connection_id = ngq_remove_connection_id;
//todo ?
// .path_validation = path_validation,
} else {
callbacks.recv_retry = ngtcp2_crypto_recv_retry_cb;
callbacks.client_initial = ngtcp2_crypto_client_initial_cb;
callbacks.recv_rx_key = ngq_recv_rx_key;
//todo ?
// callbacks.recv_version_negotiation = ::recv_version_negotiation,
// callbacks.path_validation = path_validation,
// callbacks.select_preferred_addr = ::select_preferred_address,
// callbacks.handshake_confirmed = ::handshake_confirmed,
// callbacks.recv_new_token = ::recv_new_token,
// callbacks.tls_early_data_rejected = ::early_data_rejected,
}
ngtcp2_cid scid;
ngtcp2_settings settings;
ngtcp2_transport_params params;
int rv;
if (sess->server_mode)
scid.datalen = NGTCP2_SV_SCIDLEN;
else
scid.datalen = 17;
if (RAND_bytes(scid.data, (int)scid.datalen) != 1) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] Failed to get random data for source connection ID\n"));
e = GF_IO_ERR;
goto err;
}
ngtcp2_settings_default(&settings);
if (gf_opts_get_bool("core", "h3-trace")) {
settings.log_printf = ngq_printf;
nghttp3_set_debug_vprintf_callback(ngq_debug_trace);
} else {
nghttp3_set_debug_vprintf_callback(ngq_debug_trace_noop);
}
settings.initial_ts = ngtcp2_timestamp();
settings.cc_algo = NGTCP2_CC_ALGO_CUBIC;
settings.initial_rtt = NGTCP2_DEFAULT_INITIAL_RTT;
settings.max_window = 0;
settings.max_stream_window = 0;
settings.handshake_timeout = ((u64)sess->conn_timeout)*1000000;
settings.no_pmtud = 0;
settings.ack_thresh = gf_opts_get_int("core", "h3-ack-threshold");
settings.initial_pkt_num = 1;
u32 h3_opt = gf_opts_get_int("core", "h3-mwnd");
if (h3_opt) settings.max_window = h3_opt;
h3_opt = gf_opts_get_int("core", "h3-st-mwnd");
if (h3_opt) settings.max_stream_window = h3_opt;
const char *h3_algo = gf_opts_get_key("temp", "h3-algo");
if (h3_algo) {
if (!strcmp(h3_algo, "bbr")) {
settings.cc_algo = NGTCP2_CC_ALGO_BBR;
} else if (!strcmp(h3_algo, "cubic")) {
settings.cc_algo = NGTCP2_CC_ALGO_CUBIC;
} else if (!strcmp(h3_algo, "reno")) {
settings.cc_algo = NGTCP2_CC_ALGO_RENO;
}
}
//server config
if (sess->server_mode) {
settings.token = srv_hd ? srv_hd->token : NULL;
settings.tokenlen = srv_hd ? srv_hd->tokenlen : 0;
settings.token_type = token_type;
settings.max_window = 6000000;
settings.max_stream_window = 6000000;
}
ngtcp2_transport_params_default(&params);
params.initial_max_data = gf_opts_get_int("core", "hx-iwnd");
h3_opt = gf_opts_get_int("core", "hx-st-iwnd");
params.initial_max_stream_data_bidi_local = sess->server_mode ? 0 : h3_opt;
params.initial_max_stream_data_bidi_remote = sess->server_mode ? h3_opt : 0;
params.initial_max_stream_data_uni = h3_opt;
params.initial_max_streams_bidi = sess->server_mode ? gf_opts_get_int("core", "hx-max-st") : 0;
params.initial_max_streams_uni = 3;
params.max_idle_timeout = 30 * NGTCP2_SECONDS;
params.active_connection_id_limit = 7;
params.grease_quic_bit = 1;
if (sess->server_mode) {
params.stateless_reset_token_present = 1;
if (srv_ocid) {
params.original_dcid = *srv_ocid;
params.retry_scid = srv_hd->dcid;
params.retry_scid_present = 1;
} else {
params.original_dcid = srv_hd->dcid;
}
params.original_dcid_present = 1;
rv = ngtcp2_crypto_generate_stateless_reset_token(params.stateless_reset_token, qsc->server->secret, GF_SHA256_DIGEST_SIZE, &scid);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_crypto_generate_stateless_reset_token error %s\n", ngtcp2_strerror(rv) ));
e = GF_IP_CONNECTION_FAILURE;
goto err;
}
ng_quic->serv_conn->conn_ids[0].dcid_len = scid.datalen;
memcpy(ng_quic->serv_conn->conn_ids[0].dcid, scid.data, scid.datalen);
rv = ngtcp2_conn_server_new(&ng_quic->conn, &srv_hd->scid, &scid, &ng_quic->path, NGTCP2_PROTO_VER_V1,
&callbacks, &settings, &params, NULL, ng_quic);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_server_new error %s\n", ngtcp2_strerror(rv) ));
e = GF_IP_CONNECTION_FAILURE;
goto err;
}
} else {
ngtcp2_cid dcid;
dcid.datalen = 18;
if (RAND_bytes(dcid.data, (int)dcid.datalen) != 1) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] Failed to get random data for destination connection ID\n"));
e = GF_IO_ERR;
goto err;
}
rv = ngtcp2_conn_client_new(&ng_quic->conn, &dcid, &scid, &ng_quic->path, NGTCP2_PROTO_VER_V1,
&callbacks, &settings, &params, NULL, ng_quic);
if (rv != 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_client_new error %s\n", ngtcp2_strerror(rv) ));
e = GF_IP_CONNECTION_FAILURE;
goto err;
}
}
ngtcp2_conn_set_tls_native_handle(ng_quic->conn, sess->ssl);
//set hmux callbacks
sess->hmux_sess->sessions = gf_list_new();
sess->hmux_sess->net_sess = sess;
sess->hmux_sess->submit_request = h3_submit_request;
sess->hmux_sess->send_reply = h3_send_reply;
sess->hmux_sess->write = h3_session_write;
sess->hmux_sess->close = h3_close;
sess->hmux_sess->destroy = h3_destroy;
sess->hmux_sess->stream_reset = h3_stream_reset;
sess->hmux_sess->resume = h3_resume_stream;
sess->hmux_sess->data_received = h3_data_received;
sess->hmux_sess->setup_session = h3_setup_session;
sess->hmux_sess->send_pending_data = h3_data_pending;
sess->hmux_sess->async_flush = h3_async_flush;
sess->hmux_sess->close_session = h3_close_session;
h3_setup_session(sess, GF_FALSE);
gf_list_add(sess->hmux_sess->sessions, sess);
if (!sess->mx) {
char szMXName[100];
sprintf(szMXName, "http3_%p", sess->hmux_sess);
sess->hmux_sess->mx = gf_mx_new(szMXName);
sess->mx = sess->hmux_sess->mx;
} else {
sess->hmux_sess->mx = sess->mx;
}
sess->chunked = GF_FALSE;
//don't flush packets now in server mode
if (qsc) return GF_OK;
return h3_session_write(sess);
err:
gf_free(sess->hmux_sess);
sess->hmux_sess = NULL;
if (ng_quic->path.local.addr) gf_free(ng_quic->path.local.addr);
if (ng_quic->path.remote.addr) gf_free(ng_quic->path.remote.addr);
gf_free(ng_quic);
return e;
}
GF_Err http3_connect(GF_DownloadSession *sess, char *server, u32 server_port)
{
if (!sess->hmux_sess) {
GF_Err e = h3_initialize(sess, server, server_port, NULL, NULL, 0, NULL, NULL);
if (e) return e;
return GF_IP_NETWORK_EMPTY;
}
if (!sess->hmux_sess)
return GF_IP_CONNECTION_CLOSED;
u32 res;
GF_Err e = gf_dm_read_data(sess, sess->http_buf, sess->http_buf_size, &res);
if (e) return e;
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (qc->handshake_state==QUIC_HANDSHAKE_ERROR)
return GF_IP_CONNECTION_FAILURE;
if (qc->handshake_state<QUIC_HANDSHAKE_DONE) return GF_IP_NETWORK_EMPTY;
return h3_setup_http3(sess->hmux_sess);
}
void gf_dm_sess_set_callback(GF_DownloadSession *sess, gf_dm_user_io user_io, void *usr_cbk)
{
if (!sess) return;
sess->user_proc = user_io;
sess->usr_cbk = usr_cbk;
}
static Bool ngtcp2_tls_init=GF_FALSE;
GF_Err gf_dm_quic_server_new(GF_DownloadManager *dm, void *ssl_ctx, GF_QuicServer **oq, const char *ip, u32 port, const char *netcap_id,
Bool (*accept_conn)(void *udta, GF_DownloadSession *sess, const char *address, u32 port),
void *udta)
{
GF_QuicServer *tmp;
if (!dm || !ssl_ctx || !accept_conn || !port) return GF_BAD_PARAM;
if (!ngtcp2_tls_init) {
if (ngtcp2_crypto_quictls_init() != 0) {
return GF_IO_ERR;
}
ngtcp2_tls_init=GF_TRUE;
}
GF_SAFEALLOC(tmp, GF_QuicServer);
if (!tmp) return GF_OUT_OF_MEM;
tmp->sock = gf_sk_new_ex(GF_SOCK_TYPE_UDP, netcap_id);
gf_sk_set_block_mode(tmp->sock, GF_TRUE);
GF_Err e = gf_sk_bind_ex(tmp->sock, NULL, port, ip, 0, GF_SOCK_REUSE_PORT, NULL, NULL, &tmp->local_add, &tmp->local_add_len);
if (e) {
gf_sk_del(tmp->sock);
gf_free(tmp);
return e;
}
gf_sk_set_block_mode(tmp->sock, GF_TRUE);
gf_sk_server_mode(tmp->sock, GF_TRUE);
tmp->connections = gf_list_new();
u8 buf[50];
RAND_bytes(buf, 50);
gf_sha256_csum(buf, 50, tmp->secret);
tmp->stateless_reset_count = NGTCP2_STATELESS_RESET_BURST;
tmp->ssl_ctx = ssl_ctx;
tmp->dm = dm;
tmp->accept_conn = accept_conn;
tmp->udta = udta;
*oq = tmp;
return GF_OK;
}
void gf_dm_quic_server_del(GF_QuicServer *qs)
{
gf_list_del(qs->connections);
if (qs->local_add) gf_free(qs->local_add);
gf_sk_del(qs->sock);
gf_free(qs);
}
GF_Socket *gf_dm_quic_get_socket(GF_QuicServer *qs)
{
return qs ? qs->sock : NULL;
}
static int quic_verify_token(GF_QuicServer *qs, const ngtcp2_pkt_hd *hd, const u8 *sa, u32 salen)
{
u64 ts = ngtcp2_timestamp();
if (ngtcp2_crypto_verify_regular_token(hd->token, hd->tokenlen,
qs->secret, GF_SHA256_DIGEST_SIZE,
(const ngtcp2_sockaddr *)sa, (ngtcp2_socklen) salen,
3600 * NGTCP2_SECONDS, ts) != 0) {
return -1;
}
return 0;
}
static int quic_verify_retry_token(GF_QuicServer *qs, ngtcp2_cid *ocid, const ngtcp2_pkt_hd *hd, const u8 *sa, u32 salen)
{
u64 ts = ngtcp2_timestamp();
int rv = ngtcp2_crypto_verify_retry_token2(
ocid, hd->token, hd->tokenlen,
qs->secret, GF_SHA256_DIGEST_SIZE,
hd->version, (const ngtcp2_sockaddr *)sa, (ngtcp2_socklen) salen, &hd->dcid,
10 * NGTCP2_SECONDS, ts);
switch (rv) {
case 0:
break;
case NGTCP2_CRYPTO_ERR_VERIFY_TOKEN:
return -1;
default:
return 1;
}
return 0;
}
static GF_Err quic_send_packet(GF_QuicServer *qs, const u8 *buf, u32 len, const u8 *to_a, u32 to_alen)
{
u32 written;
GF_Err e = gf_sk_send_to(qs->sock, buf, len, to_a, to_alen, &written);
if (e)
return e;
if (written!=len) {
return GF_IP_NETWORK_EMPTY;
}
return GF_OK;
}
static int quic_send_retry(GF_QuicServer *qs, const ngtcp2_pkt_hd *chd, const u8 *sa, u32 salen, u32 max_pktlen)
{
ngtcp2_cid scid;
scid.datalen = NGTCP2_SV_SCIDLEN;
if (RAND_bytes(scid.data, scid.datalen) != 1) {
return -1;
}
u8 token[NGTCP2_CRYPTO_MAX_RETRY_TOKENLEN2];
u64 ts = ngtcp2_timestamp();
int tokenlen = ngtcp2_crypto_generate_retry_token2(token, qs->secret, GF_SHA256_DIGEST_SIZE, chd->version,
(const ngtcp2_sockaddr *)sa, (ngtcp2_socklen) salen, &scid, &chd->dcid, ts);
if (tokenlen < 0) {
return -1;
}
u32 blen = MIN(NGTCP2_MAX_UDP_PAYLOAD_SIZE, max_pktlen);
u8 buf[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
int nwrite = ngtcp2_crypto_write_retry(buf, blen, chd->version, &chd->scid, &scid, &chd->dcid, token, tokenlen);
if (nwrite < 0) {
return -1;
}
GF_Err e = quic_send_packet(qs, buf, blen, sa, salen);
if (e) return -1;
return 0;
}
static int quic_send_stateless_reset(GF_QuicServer *qs, u32 pktlen, const u8 *dcid, u32 dcid_len, const u8 *sa, u32 salen)
{
if (qs->stateless_reset_count == 0) return 0;
qs->stateless_reset_count--;
ngtcp2_cid cid;
ngtcp2_cid_init(&cid, dcid, dcid_len);
u8 token[NGTCP2_STATELESS_RESET_TOKENLEN];
if (ngtcp2_crypto_generate_stateless_reset_token(token, qs->secret, GF_SHA256_DIGEST_SIZE, &cid) != 0) {
return -1;
}
u32 max_rand_byteslen = NGTCP2_MAX_CIDLEN + 22 - NGTCP2_STATELESS_RESET_TOKENLEN;
u8 rand_bytes[NGTCP2_MAX_CIDLEN + 22 - NGTCP2_STATELESS_RESET_TOKENLEN];
u32 rand_byteslen;
if (pktlen <= 43) {
rand_byteslen = pktlen - NGTCP2_STATELESS_RESET_TOKENLEN - 1;
} else {
rand_byteslen = max_rand_byteslen;
}
if (RAND_bytes(rand_bytes, rand_byteslen) != 1) {
return -1;
}
u8 buf[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
int nwrite = ngtcp2_pkt_write_stateless_reset(buf, NGTCP2_MAX_UDP_PAYLOAD_SIZE, token, rand_bytes, rand_byteslen);
if (nwrite < 0) {
return -1;
}
GF_Err e = quic_send_packet(qs, buf, nwrite, sa, salen);
if (e) return -1;
return 0;
}
static int quic_send_stateless_connection_close(GF_QuicServer *qs, const ngtcp2_pkt_hd *chd, const u8 *sa, u32 salen)
{
u8 buf[NGTCP2_MAX_UDP_PAYLOAD_SIZE];
int nwrite = ngtcp2_crypto_write_connection_close(buf, NGTCP2_MAX_UDP_PAYLOAD_SIZE, chd->version, &chd->scid, &chd->dcid, NGTCP2_INVALID_TOKEN, NULL, 0);
if (nwrite < 0) return -1;
GF_Err e = quic_send_packet(qs, buf, nwrite, sa, salen);
if (e) return -1;
return 0;
}
void quic_start_draining_period(GF_QuicConnection *qc)
{
qc->serv_conn->drain_period_end = gf_sys_clock_high_res();
qc->serv_conn->drain_period_end += ngtcp2_conn_get_pto(qc->conn)/1000;
qc->serv_conn->closed = GF_TRUE;
}
Bool quic_start_closing_period(GF_QuicConnection *qc)
{
if (!qc->conn) return GF_TRUE;
if (ngtcp2_conn_in_closing_period(qc->conn) || ngtcp2_conn_in_draining_period(qc->conn)) {
return GF_TRUE;
}
ngtcp2_path_storage ps;
ngtcp2_path_storage_zero(&ps);
ngtcp2_pkt_info pi;
int n = ngtcp2_conn_write_connection_close(qc->conn, &ps.path, &pi, qc->serv_conn->closebuf, NGTCP2_MAX_UDP_PAYLOAD_SIZE, &qc->last_error, ngtcp2_timestamp());
if (n<0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_write_connection_close error %s\n", ngtcp2_strerror(n) ));
return GF_FALSE;
}
qc->serv_conn->closebuf_len = n;
qc->serv_conn->closed = GF_TRUE;
qc->serv_conn->close_period_end = gf_sys_clock_high_res();
qc->serv_conn->close_period_end += ngtcp2_conn_get_pto(qc->conn)/1000; //(*3);
return GF_TRUE;
}
static int quic_send_conn_close(GF_QuicConnection *qc)
{
assert(qc->serv_conn && qc->serv_conn->closebuf_len);
assert(qc->conn);
assert(!ngtcp2_conn_in_draining_period(qc->conn));
const ngtcp2_path *path = ngtcp2_conn_get_path(qc->conn);
return quic_send_packet(qc->serv_conn->server, qc->serv_conn->closebuf, qc->serv_conn->closebuf_len, (const u8 *)&path->remote.addr, (u32) path->remote.addrlen);
}
static GF_Err quic_handle_error(GF_QuicConnection *qc)
{
if (qc->last_error.type == NGTCP2_CCERR_TYPE_IDLE_CLOSE) {
return GF_IP_CONNECTION_CLOSED;
}
if (! quic_start_closing_period(qc)) {
return GF_IP_CONNECTION_CLOSED;
}
if (ngtcp2_conn_in_draining_period(qc->conn)) {
return GF_IP_NETWORK_EMPTY;
}
GF_Err e = quic_send_conn_close(qc);
if (e) return e;
return GF_IP_NETWORK_EMPTY;
}
static void detach_connection(GF_QuicServerConnection *c)
{
u32 i;
for (i=0;i<MAC_CONN_ID;i++)
c->conn_ids[i].associated = 0;
//freeing the connection is done later
}
static GF_Err gf_quic_on_data(GF_QuicServerConnection *c, const u8 *data, u32 nb_bytes)
{
GF_QuicConnection *qc = (GF_QuicConnection *) c->hmux->hmux_udta;
ngtcp2_path path;
ngtcp2_pkt_info pi = {0};
path = qc->path;
int rv = ngtcp2_conn_read_pkt(qc->conn, &path, &pi, data, (size_t)nb_bytes, ngtcp2_timestamp() );
if (rv != 0) {
switch (rv) {
case NGTCP2_ERR_DRAINING:
quic_start_draining_period(qc);
return GF_IP_NETWORK_EMPTY;
case NGTCP2_ERR_RETRY:
return GF_IP_UDP_TIMEOUT;
case NGTCP2_ERR_DROP_CONN:
return GF_IP_CONNECTION_CLOSED;
case NGTCP2_ERR_CRYPTO:
if (!qc->last_error.error_code) {
if (rv == NGTCP2_ERR_CRYPTO) {
ngtcp2_ccerr_set_tls_alert(&qc->last_error, ngtcp2_conn_get_tls_alert(qc->conn), NULL, 0);
} else {
ngtcp2_ccerr_set_liberr(&qc->last_error, rv, NULL, 0);
}
}
return quic_handle_error(qc);
default:
GF_LOG(GF_LOG_ERROR, GF_LOG_HTTP, ("[QUIC] ngtcp2_conn_read_pkt: %s\n", ngtcp2_strerror(rv) ));
return quic_handle_error(qc);
}
}
return GF_OK;
}
static GF_Err quic_on_write(GF_QuicServerConnection *c)
{
GF_QuicConnection *qc = (GF_QuicConnection *) c->hmux->hmux_udta;
if (ngtcp2_conn_in_closing_period(qc->conn) || ngtcp2_conn_in_draining_period(qc->conn)) {
return GF_IP_NETWORK_EMPTY;
}
return h3_session_write_ex(NULL, qc);
}
static GF_Err gf_quic_create_connection(GF_QuicServer *qs, GF_QuicServerConnection **oc, ngtcp2_version_cid *vc, const u8 *data, u32 data_len, const u8 *s_add, u32 s_add_len)
{
GF_QuicServerConnection *c;
if (!s_add) return GF_IP_CONNECTION_FAILURE;
if (s_add_len>MAX_ADDR_LEN) return GF_BAD_PARAM;
if (vc->dcidlen>MAX_CONNID_LEN) return GF_BAD_PARAM;
ngtcp2_pkt_hd hd;
int rv = ngtcp2_accept(&hd, data, data_len);
if (rv != 0) {
if (!(data[0] & 0x80) && (data_len >= NGTCP2_SV_SCIDLEN + 22) ) {
quic_send_stateless_reset(qs, data_len, vc->dcid, vc->dcidlen, s_add, s_add_len);
}
return GF_IP_NETWORK_EMPTY;
}
ngtcp2_cid ocid;
ngtcp2_cid *pocid = NULL;
ngtcp2_token_type token_type = NGTCP2_TOKEN_TYPE_UNKNOWN;
assert(hd.type == NGTCP2_PKT_INITIAL);
if (qs->validate_address || hd.tokenlen) {
if (hd.tokenlen == 0) {
quic_send_retry(qs, &hd, s_add, s_add_len, data_len * 3);
return GF_IP_NETWORK_EMPTY;
}
if ((hd.token[0] != NGTCP2_CRYPTO_TOKEN_MAGIC_RETRY2) && (hd.dcid.datalen < NGTCP2_MIN_INITIAL_DCIDLEN)) {
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
return GF_IP_NETWORK_EMPTY;
}
switch (hd.token[0]) {
case NGTCP2_CRYPTO_TOKEN_MAGIC_RETRY2:
switch (quic_verify_retry_token(qs, &ocid, &hd, s_add, s_add_len)) {
case 0:
pocid = &ocid;
token_type = NGTCP2_TOKEN_TYPE_RETRY;
break;
case -1:
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
return GF_IP_NETWORK_EMPTY;
case 1:
hd.token = NULL;
hd.tokenlen = 0;
break;
}
break;
case NGTCP2_CRYPTO_TOKEN_MAGIC_REGULAR:
if (quic_verify_token(qs, &hd, s_add, s_add_len) != 0) {
if (qs->validate_address) {
quic_send_retry(qs, &hd, s_add, s_add_len, data_len * 3);
return GF_IP_NETWORK_EMPTY;
}
hd.token = NULL;
hd.tokenlen = 0;
} else {
token_type = NGTCP2_TOKEN_TYPE_NEW_TOKEN;
}
break;
default:
if (qs->validate_address) {
quic_send_retry(qs, &hd, s_add, s_add_len, data_len * 3);
return GF_IP_NETWORK_EMPTY;
}
hd.token = NULL;
hd.tokenlen = 0;
break;
}
}
//we have a new connection
char peer_address[GF_MAX_IP_NAME_LEN];
u32 peer_port;
gf_sk_get_remote_address_port(qs->sock, peer_address, &peer_port);
GF_Err e;
GF_DownloadSession *sess = gf_dm_sess_new_internal(qs->dm, NULL, GF_NETIO_SESSION_NO_BLOCK, NULL, NULL, NULL, GF_TRUE, &e);
if (e) {
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
return GF_IP_NETWORK_EMPTY;
}
sess->flags |= GF_NETIO_SESSION_USE_QUIC;
if (!qs->accept_conn(qs->udta, sess, peer_address, peer_port)) {
gf_dm_sess_del(sess);
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
return GF_IP_NETWORK_EMPTY;
}
//setup SSL
sess->ssl = SSL_new(qs->ssl_ctx);
if (!sess->ssl) {
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
sess->status = GF_NETIO_DISCONNECTED;
return GF_IP_CONNECTION_FAILURE;
}
SSL_set_accept_state(sess->ssl);
#ifndef LIBRESSL_VERSION_NUMBER
SSL_set_quic_early_data_enabled(sess->ssl, 1);
#endif // !defined(LIBRESSL_VERSION_NUMBER)
GF_SAFEALLOC(c, GF_QuicServerConnection)
if (!c) return GF_OUT_OF_MEM;
memcpy(c->addr, s_add, s_add_len);
c->conn_ids[0].associated = GF_TRUE;
c->conn_ids[0].dcid_len = vc->dcidlen;
memcpy(c->conn_ids[0].dcid, vc->dcid, vc->dcidlen);
c->addr_len = s_add_len;
c->server = qs;
gf_list_add(qs->connections, c);
*oc = c;
ngtcp2_path path;
path.local.addr = (ngtcp2_sockaddr *) qs->local_add;
path.local.addrlen = qs->local_add_len;
path.remote.addr = (ngtcp2_sockaddr *) s_add;
path.remote.addrlen = s_add_len;
e = h3_initialize(sess, NULL, 0, &hd, pocid, token_type, &path, c);
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (e) {
gf_list_del_item(qs->connections, c);
qc->serv_conn = NULL;
gf_free(qc);
sess->status = GF_NETIO_DISCONNECTED;
quic_send_stateless_connection_close(qs, &hd, s_add, s_add_len);
return GF_IP_CONNECTION_FAILURE;
}
sess->hmux_stream_id = -2;
e = gf_quic_on_data(c, data, data_len);
if (e) {
if (e == GF_IP_UDP_TIMEOUT)
quic_send_retry(qs, &hd, s_add, s_add_len, data_len * 3);
return GF_IP_NETWORK_EMPTY;
}
if (quic_on_write(qc->serv_conn))
return GF_IP_NETWORK_EMPTY;
return GF_OK;
}
GF_Err gf_dm_quic_process(GF_QuicServer *qs)
{
GF_Err e;
u8 buf[5000];
u32 nb_read;
GF_QuicServerConnection *qc = NULL;
restart:
nb_read=0;
e = gf_sk_receive(qs->sock, buf, 5000, &nb_read);
if (e) return e;
if (nb_read<22) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] wrong packet size, discarding\n"));
return GF_IP_NETWORK_EMPTY;
}
u32 src_add_len = 0;
const u8 *src_add = gf_sk_get_address(qs->sock, &src_add_len);
if (!src_add) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] Failed to fecth packet address\n"));
return GF_IP_NETWORK_EMPTY;
}
ngtcp2_version_cid vc;
int rv = ngtcp2_pkt_decode_version_cid(&vc, buf, 5000, NGTCP2_SV_SCIDLEN);
switch (rv) {
case 0:
break;
case NGTCP2_ERR_VERSION_NEGOTIATION:
//send_version_negotiation(vc.version, {vc.scid, vc.scidlen}, {vc.dcid, vc.dcidlen}, ep, local_addr, sa, salen);
return GF_IP_NETWORK_EMPTY;
default:
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] Could not decode version and CID: %s\n", ngtcp2_strerror(rv) ));
return GF_IP_NETWORK_EMPTY;
}
qc = NULL;
u32 i, count = gf_list_count(qs->connections);
for (i=0; i<count; i++) {
qc = gf_list_get(qs->connections, i);
u32 j;
ConnIDInfo *ci=NULL;
for (j=0; j<MAC_CONN_ID; j++) {
ci = &qc->conn_ids[j];
if (ci->associated
&& (ci->dcid_len == vc.dcidlen)
&& !memcmp(ci->dcid, vc.dcid, ci->dcid_len)
) {
break;
}
ci = NULL;
}
if (ci) break;
qc = NULL;
}
if (!qc) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] new connection detected\n"));
e = gf_quic_create_connection(qs, &qc, &vc, buf, nb_read, src_add, src_add_len);
if (e) return e;
qc = NULL;
goto restart;
}
GF_QuicConnection *q = qc->hmux->hmux_udta;
if (ngtcp2_conn_in_closing_period(q->conn)) {
if (quic_send_conn_close(q) != 0) {
detach_connection(qc);
return GF_IP_NETWORK_EMPTY;
}
return GF_IP_NETWORK_EMPTY;
}
if (ngtcp2_conn_in_draining_period(q->conn)) {
return GF_IP_NETWORK_EMPTY;
}
e = gf_quic_on_data(qc, buf, nb_read);
if (e) {
if (e != GF_IP_NETWORK_EMPTY) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_HTTP, ("[QUIC] packet decode error %s\n", gf_error_to_string(e) ));
detach_connection(qc);
return GF_IP_NETWORK_EMPTY;
}
return GF_IP_NETWORK_EMPTY;
}
goto restart;
return GF_OK;
}
GF_Err gf_dm_quic_verify(GF_QuicServer *qs)
{
if (!qs) return GF_IP_NETWORK_EMPTY;
GF_Err e = GF_IP_NETWORK_EMPTY;
u32 i, count = gf_list_count(qs->connections);
for (i=0; i<count; i++) {
GF_QuicServerConnection *qc = gf_list_get(qs->connections, i);
if (qc->close_period_end && (qc->close_period_end>gf_sys_clock_high_res()) ) {
GF_QuicConnection *qcpriv = qc->hmux->hmux_udta;
if (ngtcp2_conn_in_closing_period(qcpriv->conn)) {
continue;
}
qc->close_period_end = 0;
detach_connection(qc);
continue;
}
if (qc->drain_period_end && (qc->drain_period_end>gf_sys_clock_high_res()) ) {
GF_QuicConnection *qcpriv = qc->hmux->hmux_udta;
if (ngtcp2_conn_in_draining_period(qcpriv->conn)) {
continue;
}
qc->drain_period_end = 0;
detach_connection(qc);
continue;
}
if (qc->closed) continue;
if (quic_on_write(qc) == GF_OK) {
e = GF_OK;
}
}
return e;
}
GF_Err h3_check_sess(GF_DownloadSession *sess)
{
GF_QuicConnection *qc = sess->hmux_sess->hmux_udta;
if (qc->serv_conn && qc->serv_conn->closed)
return GF_IP_CONNECTION_CLOSED;
return GF_IP_NETWORK_EMPTY;
}
#endif // !defined(GPAC_DISABLE_NETWORK) && defined(GPAC_HAS_NGTCP2)