2 * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
10 #include "internal/quic_port.h"
11 #include "internal/quic_channel.h"
12 #include "internal/quic_lcidm.h"
13 #include "internal/quic_srtm.h"
14 #include "quic_port_local.h"
15 #include "quic_channel_local.h"
16 #include "quic_engine_local.h"
17 #include "../ssl_local.h"
23 #define INIT_DCID_LEN 8
25 static int port_init(QUIC_PORT *port);
26 static void port_cleanup(QUIC_PORT *port);
27 static OSSL_TIME get_time(void *arg);
28 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
29 const QUIC_CONN_ID *dcid);
30 static void port_rx_pre(QUIC_PORT *port);
32 DEFINE_LIST_OF_IMPL(ch, QUIC_CHANNEL);
33 DEFINE_LIST_OF_IMPL(port, QUIC_PORT);
35 QUIC_PORT *ossl_quic_port_new(const QUIC_PORT_ARGS *args)
39 if ((port = OPENSSL_zalloc(sizeof(QUIC_PORT))) == NULL)
42 port->engine = args->engine;
43 port->channel_ctx = args->channel_ctx;
44 port->is_multi_conn = args->is_multi_conn;
46 if (!port_init(port)) {
54 void ossl_quic_port_free(QUIC_PORT *port)
63 static int port_init(QUIC_PORT *port)
65 size_t rx_short_dcid_len = (port->is_multi_conn ? INIT_DCID_LEN : 0);
67 if (port->engine == NULL || port->channel_ctx == NULL)
70 if ((port->err_state = OSSL_ERR_STATE_new()) == NULL)
73 if ((port->demux = ossl_quic_demux_new(/*BIO=*/NULL,
74 /*Short CID Len=*/rx_short_dcid_len,
75 get_time, port)) == NULL)
78 ossl_quic_demux_set_default_handler(port->demux,
79 port_default_packet_handler,
82 if ((port->srtm = ossl_quic_srtm_new(port->engine->libctx,
83 port->engine->propq)) == NULL)
86 if ((port->lcidm = ossl_quic_lcidm_new(port->engine->libctx,
87 rx_short_dcid_len)) == NULL)
90 port->rx_short_dcid_len = (unsigned char)rx_short_dcid_len;
91 port->tx_init_dcid_len = INIT_DCID_LEN;
92 port->state = QUIC_PORT_STATE_RUNNING;
94 ossl_list_port_insert_tail(&port->engine->port_list, port);
95 port->on_engine_list = 1;
103 static void port_cleanup(QUIC_PORT *port)
105 assert(ossl_list_ch_num(&port->channel_list) == 0);
107 ossl_quic_demux_free(port->demux);
110 ossl_quic_srtm_free(port->srtm);
113 ossl_quic_lcidm_free(port->lcidm);
116 OSSL_ERR_STATE_free(port->err_state);
117 port->err_state = NULL;
119 if (port->on_engine_list) {
120 ossl_list_port_remove(&port->engine->port_list, port);
121 port->on_engine_list = 0;
125 static void port_transition_failed(QUIC_PORT *port)
127 if (port->state == QUIC_PORT_STATE_FAILED)
130 port->state = QUIC_PORT_STATE_FAILED;
133 int ossl_quic_port_is_running(const QUIC_PORT *port)
135 return port->state == QUIC_PORT_STATE_RUNNING;
138 QUIC_ENGINE *ossl_quic_port_get0_engine(QUIC_PORT *port)
143 QUIC_REACTOR *ossl_quic_port_get0_reactor(QUIC_PORT *port)
145 return ossl_quic_engine_get0_reactor(port->engine);
148 QUIC_DEMUX *ossl_quic_port_get0_demux(QUIC_PORT *port)
153 CRYPTO_MUTEX *ossl_quic_port_get0_mutex(QUIC_PORT *port)
155 return ossl_quic_engine_get0_mutex(port->engine);
158 OSSL_TIME ossl_quic_port_get_time(QUIC_PORT *port)
160 return ossl_quic_engine_get_time(port->engine);
163 static OSSL_TIME get_time(void *port)
165 return ossl_quic_port_get_time((QUIC_PORT *)port);
168 int ossl_quic_port_get_rx_short_dcid_len(const QUIC_PORT *port)
170 return port->rx_short_dcid_len;
173 int ossl_quic_port_get_tx_init_dcid_len(const QUIC_PORT *port)
175 return port->tx_init_dcid_len;
179 * QUIC Port: Network BIO Configuration
180 * ====================================
183 /* Determines whether we can support a given poll descriptor. */
184 static int validate_poll_descriptor(const BIO_POLL_DESCRIPTOR *d)
186 if (d->type == BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD && d->value.fd < 0) {
187 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
194 BIO *ossl_quic_port_get_net_rbio(QUIC_PORT *port)
196 return port->net_rbio;
199 BIO *ossl_quic_port_get_net_wbio(QUIC_PORT *port)
201 return port->net_wbio;
204 static int port_update_poll_desc(QUIC_PORT *port, BIO *net_bio, int for_write)
206 BIO_POLL_DESCRIPTOR d = {0};
209 || (!for_write && !BIO_get_rpoll_descriptor(net_bio, &d))
210 || (for_write && !BIO_get_wpoll_descriptor(net_bio, &d)))
211 /* Non-pollable BIO */
212 d.type = BIO_POLL_DESCRIPTOR_TYPE_NONE;
214 if (!validate_poll_descriptor(&d))
218 * TODO(QUIC MULTIPORT): We currently only support one port per
219 * engine/domain. This is necessitated because QUIC_REACTOR only supports a
220 * single pollable currently. In the future, once complete polling
221 * infrastructure has been implemented, this limitation can be removed.
223 * For now, just update the descriptor on the the engine's reactor as we are
224 * guaranteed to be the only port under it.
227 ossl_quic_reactor_set_poll_w(&port->engine->rtor, &d);
229 ossl_quic_reactor_set_poll_r(&port->engine->rtor, &d);
234 int ossl_quic_port_update_poll_descriptors(QUIC_PORT *port)
238 if (!port_update_poll_desc(port, port->net_rbio, /*for_write=*/0))
241 if (!port_update_poll_desc(port, port->net_wbio, /*for_write=*/1))
248 * QUIC_PORT does not ref any BIO it is provided with, nor is any ref
249 * transferred to it. The caller (e.g., QUIC_CONNECTION) is responsible for
250 * ensuring the BIO lasts until the channel is freed or the BIO is switched out
251 * for another BIO by a subsequent successful call to this function.
253 int ossl_quic_port_set_net_rbio(QUIC_PORT *port, BIO *net_rbio)
255 if (port->net_rbio == net_rbio)
258 if (!port_update_poll_desc(port, net_rbio, /*for_write=*/0))
261 ossl_quic_demux_set_bio(port->demux, net_rbio);
262 port->net_rbio = net_rbio;
266 int ossl_quic_port_set_net_wbio(QUIC_PORT *port, BIO *net_wbio)
270 if (port->net_wbio == net_wbio)
273 if (!port_update_poll_desc(port, net_wbio, /*for_write=*/1))
276 LIST_FOREACH(ch, ch, &port->channel_list)
277 ossl_qtx_set_bio(ch->qtx, net_wbio);
279 port->net_wbio = net_wbio;
284 * QUIC Port: Channel Lifecycle
285 * ============================
288 static SSL *port_new_handshake_layer(QUIC_PORT *port)
291 SSL_CONNECTION *tls_conn = NULL;
293 tls = ossl_ssl_connection_new_int(port->channel_ctx, TLS_method());
294 if (tls == NULL || (tls_conn = SSL_CONNECTION_FROM_SSL(tls)) == NULL)
297 /* Override the user_ssl of the inner connection. */
298 tls_conn->s3.flags |= TLS1_FLAGS_QUIC;
300 /* Restrict options derived from the SSL_CTX. */
301 tls_conn->options &= OSSL_QUIC_PERMITTED_OPTIONS_CONN;
302 tls_conn->pha_enabled = 0;
306 static QUIC_CHANNEL *port_make_channel(QUIC_PORT *port, SSL *tls, int is_server)
308 QUIC_CHANNEL_ARGS args = {0};
312 args.is_server = is_server;
313 args.tls = (tls != NULL ? tls : port_new_handshake_layer(port));
314 args.lcidm = port->lcidm;
315 args.srtm = port->srtm;
316 if (args.tls == NULL)
319 ch = ossl_quic_channel_new(&args);
330 QUIC_CHANNEL *ossl_quic_port_create_outgoing(QUIC_PORT *port, SSL *tls)
332 return port_make_channel(port, tls, /*is_server=*/0);
335 QUIC_CHANNEL *ossl_quic_port_create_incoming(QUIC_PORT *port, SSL *tls)
339 assert(port->tserver_ch == NULL);
341 ch = port_make_channel(port, tls, /*is_server=*/1);
342 port->tserver_ch = ch;
348 * QUIC Port: Ticker-Mutator
349 * =========================
353 * Tick function for this port. This does everything related to network I/O for
354 * this port's network BIOs, and services child channels.
356 void ossl_quic_port_subtick(QUIC_PORT *port, QUIC_TICK_RESULT *res,
361 res->net_read_desired = 0;
362 res->net_write_desired = 0;
363 res->tick_deadline = ossl_time_infinite();
365 if (!port->engine->inhibit_tick) {
366 /* Handle any incoming data from network. */
367 if (ossl_quic_port_is_running(port))
370 /* Iterate through all channels and service them. */
371 LIST_FOREACH(ch, ch, &port->channel_list) {
372 QUIC_TICK_RESULT subr = {0};
374 ossl_quic_channel_subtick(ch, &subr, flags);
375 ossl_quic_tick_result_merge_into(res, &subr);
380 /* Process incoming datagrams, if any. */
381 static void port_rx_pre(QUIC_PORT *port)
386 * Originally, this check (don't RX before we have sent anything if we are
387 * not a server, because there can't be anything) was just intended as a
388 * minor optimisation. However, it is actually required on Windows, and
389 * removing this check will cause Windows to break.
391 * The reason is that under Win32, recvfrom() does not work on a UDP socket
392 * which has not had bind() called (???). However, calling sendto() will
393 * automatically bind an unbound UDP socket. Therefore, if we call a Winsock
394 * recv-type function before calling a Winsock send-type function, that call
395 * will fail with WSAEINVAL, which we will regard as a permanent network
398 * Therefore, this check is essential as we do not require our API users to
399 * bind a socket first when using the API in client mode.
401 if (!port->is_server && !port->have_sent_any_pkt)
405 * Get DEMUX to BIO_recvmmsg from the network and queue incoming datagrams
406 * to the appropriate QRX instances.
408 ret = ossl_quic_demux_pump(port->demux);
409 if (ret == QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL)
411 * We don't care about transient failure, but permanent failure means we
412 * should tear down the port. All connections skip straight to the
413 * Terminated state as there is no point trying to send CONNECTION_CLOSE
414 * frames if the network BIO is not operating correctly.
416 ossl_quic_port_raise_net_error(port, NULL);
420 * Handles an incoming connection request and potentially decides to make a
421 * connection from it. If a new connection is made, the new channel is written
424 static void port_on_new_conn(QUIC_PORT *port, const BIO_ADDR *peer,
425 const QUIC_CONN_ID *scid,
426 const QUIC_CONN_ID *dcid,
427 QUIC_CHANNEL **new_ch)
429 if (port->tserver_ch != NULL) {
430 /* Specially assign to existing channel */
431 if (!ossl_quic_channel_on_new_conn(port->tserver_ch, peer, scid, dcid))
434 *new_ch = port->tserver_ch;
435 port->tserver_ch = NULL;
440 static int port_try_handle_stateless_reset(QUIC_PORT *port, const QUIC_URXE *e)
443 const unsigned char *data = ossl_quic_urxe_data(e);
447 * Perform some fast and cheap checks for a packet not being a stateless
448 * reset token. RFC 9000 s. 10.3 specifies this layout for stateless
452 * Fixed Bits (2) = 1,
453 * Unpredictable Bits (38..),
454 * Stateless Reset Token (128),
458 * However, endpoints MUST treat any packet ending in a valid
459 * stateless reset token as a Stateless Reset, as other QUIC
460 * versions might allow the use of a long header.
462 * We can rapidly check for the minimum length and that the first pair
463 * of bits in the first byte are 01 or 11.
465 * The function returns 1 if it is a stateless reset packet, 0 if it isn't
466 * and -1 if an error was encountered.
468 if (e->data_len < QUIC_STATELESS_RESET_TOKEN_LEN + 5
469 || (0100 & *data) != 0100)
473 if (!ossl_quic_srtm_lookup(port->srtm,
474 (QUIC_STATELESS_RESET_TOKEN *)(data + e->data_len
475 - sizeof(QUIC_STATELESS_RESET_TOKEN)),
479 assert(opaque != NULL);
480 ossl_quic_channel_on_stateless_reset((QUIC_CHANNEL *)opaque);
487 * This is called by the demux when we get a packet not destined for any known
490 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
491 const QUIC_CONN_ID *dcid)
493 QUIC_PORT *port = arg;
496 QUIC_CHANNEL *ch = NULL, *new_ch = NULL;
498 /* Don't handle anything if we are no longer running. */
499 if (!ossl_quic_port_is_running(port))
502 if (port_try_handle_stateless_reset(port, e))
506 && ossl_quic_lcidm_lookup(port->lcidm, dcid, NULL,
509 ossl_quic_channel_inject(ch, e);
514 * If we have an incoming packet which doesn't match any existing connection
515 * we assume this is an attempt to make a new connection. Currently we
516 * require our caller to have precreated a latent 'incoming' channel via
517 * TSERVER which then gets turned into the new connection.
519 * TODO(QUIC SERVER): In the future we will construct channels dynamically
522 if (port->tserver_ch == NULL)
526 * We have got a packet for an unknown DCID. This might be an attempt to
527 * open a new connection.
529 if (e->data_len < QUIC_MIN_INITIAL_DGRAM_LEN)
532 if (!PACKET_buf_init(&pkt, ossl_quic_urxe_data(e), e->data_len))
536 * We set short_conn_id_len to SIZE_MAX here which will cause the decode
537 * operation to fail if we get a 1-RTT packet. This is fine since we only
538 * care about Initial packets.
540 if (!ossl_quic_wire_decode_pkt_hdr(&pkt, SIZE_MAX, 1, 0, &hdr, NULL))
543 switch (hdr.version) {
547 case QUIC_VERSION_NONE:
549 /* Unknown version or proactive version negotiation request, bail. */
550 /* TODO(QUIC SERVER): Handle version negotiation on server side */
555 * We only care about Initial packets which might be trying to establish a
558 if (hdr.type != QUIC_PKT_TYPE_INITIAL)
562 * Try to process this as a valid attempt to initiate a connection.
564 * The channel will do all the LCID registration needed, but as an
565 * optimization inject this packet directly into the channel's QRX for
566 * processing without going through the DEMUX again.
568 port_on_new_conn(port, &e->peer, &hdr.src_conn_id, &hdr.dst_conn_id,
571 ossl_qrx_inject_urxe(new_ch->qrx, e);
576 ossl_quic_demux_release_urxe(port->demux, e);
579 void ossl_quic_port_raise_net_error(QUIC_PORT *port,
580 QUIC_CHANNEL *triggering_ch)
584 if (!ossl_quic_port_is_running(port))
588 * Immediately capture any triggering error on the error stack, with a
591 ERR_raise_data(ERR_LIB_SSL, SSL_R_QUIC_NETWORK_ERROR,
592 "port failed due to network BIO I/O error");
593 OSSL_ERR_STATE_save(port->err_state);
595 port_transition_failed(port);
597 /* Give the triggering channel (if any) the first notification. */
598 if (triggering_ch != NULL)
599 ossl_quic_channel_raise_net_error(triggering_ch);
601 LIST_FOREACH(ch, ch, &port->channel_list)
602 if (ch != triggering_ch)
603 ossl_quic_channel_raise_net_error(ch);
606 void ossl_quic_port_restore_err_state(const QUIC_PORT *port)
609 OSSL_ERR_STATE_restore(port->err_state);