2 * Copyright 2023-2024 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 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 #ifndef OPENSSL_NO_QLOG
320 args
.use_qlog
= 1; /* disabled if env not set */
321 args
.qlog_title
= args
.tls
->ctx
->qlog_title
;
324 ch
= ossl_quic_channel_new(&args
);
335 QUIC_CHANNEL
*ossl_quic_port_create_outgoing(QUIC_PORT
*port
, SSL
*tls
)
337 return port_make_channel(port
, tls
, /*is_server=*/0);
340 QUIC_CHANNEL
*ossl_quic_port_create_incoming(QUIC_PORT
*port
, SSL
*tls
)
344 assert(port
->tserver_ch
== NULL
);
346 ch
= port_make_channel(port
, tls
, /*is_server=*/1);
347 port
->tserver_ch
= ch
;
353 * QUIC Port: Ticker-Mutator
354 * =========================
358 * Tick function for this port. This does everything related to network I/O for
359 * this port's network BIOs, and services child channels.
361 void ossl_quic_port_subtick(QUIC_PORT
*port
, QUIC_TICK_RESULT
*res
,
366 res
->net_read_desired
= 0;
367 res
->net_write_desired
= 0;
368 res
->tick_deadline
= ossl_time_infinite();
370 if (!port
->engine
->inhibit_tick
) {
371 /* Handle any incoming data from network. */
372 if (ossl_quic_port_is_running(port
))
375 /* Iterate through all channels and service them. */
376 LIST_FOREACH(ch
, ch
, &port
->channel_list
) {
377 QUIC_TICK_RESULT subr
= {0};
379 ossl_quic_channel_subtick(ch
, &subr
, flags
);
380 ossl_quic_tick_result_merge_into(res
, &subr
);
385 /* Process incoming datagrams, if any. */
386 static void port_rx_pre(QUIC_PORT
*port
)
391 * Originally, this check (don't RX before we have sent anything if we are
392 * not a server, because there can't be anything) was just intended as a
393 * minor optimisation. However, it is actually required on Windows, and
394 * removing this check will cause Windows to break.
396 * The reason is that under Win32, recvfrom() does not work on a UDP socket
397 * which has not had bind() called (???). However, calling sendto() will
398 * automatically bind an unbound UDP socket. Therefore, if we call a Winsock
399 * recv-type function before calling a Winsock send-type function, that call
400 * will fail with WSAEINVAL, which we will regard as a permanent network
403 * Therefore, this check is essential as we do not require our API users to
404 * bind a socket first when using the API in client mode.
406 if (!port
->is_server
&& !port
->have_sent_any_pkt
)
410 * Get DEMUX to BIO_recvmmsg from the network and queue incoming datagrams
411 * to the appropriate QRX instances.
413 ret
= ossl_quic_demux_pump(port
->demux
);
414 if (ret
== QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL
)
416 * We don't care about transient failure, but permanent failure means we
417 * should tear down the port. All connections skip straight to the
418 * Terminated state as there is no point trying to send CONNECTION_CLOSE
419 * frames if the network BIO is not operating correctly.
421 ossl_quic_port_raise_net_error(port
, NULL
);
425 * Handles an incoming connection request and potentially decides to make a
426 * connection from it. If a new connection is made, the new channel is written
429 static void port_on_new_conn(QUIC_PORT
*port
, const BIO_ADDR
*peer
,
430 const QUIC_CONN_ID
*scid
,
431 const QUIC_CONN_ID
*dcid
,
432 QUIC_CHANNEL
**new_ch
)
434 if (port
->tserver_ch
!= NULL
) {
435 /* Specially assign to existing channel */
436 if (!ossl_quic_channel_on_new_conn(port
->tserver_ch
, peer
, scid
, dcid
))
439 *new_ch
= port
->tserver_ch
;
440 port
->tserver_ch
= NULL
;
445 static int port_try_handle_stateless_reset(QUIC_PORT
*port
, const QUIC_URXE
*e
)
448 const unsigned char *data
= ossl_quic_urxe_data(e
);
452 * Perform some fast and cheap checks for a packet not being a stateless
453 * reset token. RFC 9000 s. 10.3 specifies this layout for stateless
457 * Fixed Bits (2) = 1,
458 * Unpredictable Bits (38..),
459 * Stateless Reset Token (128),
463 * However, endpoints MUST treat any packet ending in a valid
464 * stateless reset token as a Stateless Reset, as other QUIC
465 * versions might allow the use of a long header.
467 * We can rapidly check for the minimum length and that the first pair
468 * of bits in the first byte are 01 or 11.
470 * The function returns 1 if it is a stateless reset packet, 0 if it isn't
471 * and -1 if an error was encountered.
473 if (e
->data_len
< QUIC_STATELESS_RESET_TOKEN_LEN
+ 5
474 || (0100 & *data
) != 0100)
478 if (!ossl_quic_srtm_lookup(port
->srtm
,
479 (QUIC_STATELESS_RESET_TOKEN
*)(data
+ e
->data_len
480 - sizeof(QUIC_STATELESS_RESET_TOKEN
)),
484 assert(opaque
!= NULL
);
485 ossl_quic_channel_on_stateless_reset((QUIC_CHANNEL
*)opaque
);
492 * This is called by the demux when we get a packet not destined for any known
495 static void port_default_packet_handler(QUIC_URXE
*e
, void *arg
,
496 const QUIC_CONN_ID
*dcid
)
498 QUIC_PORT
*port
= arg
;
501 QUIC_CHANNEL
*ch
= NULL
, *new_ch
= NULL
;
503 /* Don't handle anything if we are no longer running. */
504 if (!ossl_quic_port_is_running(port
))
507 if (port_try_handle_stateless_reset(port
, e
))
511 && ossl_quic_lcidm_lookup(port
->lcidm
, dcid
, NULL
,
514 ossl_quic_channel_inject(ch
, e
);
519 * If we have an incoming packet which doesn't match any existing connection
520 * we assume this is an attempt to make a new connection. Currently we
521 * require our caller to have precreated a latent 'incoming' channel via
522 * TSERVER which then gets turned into the new connection.
524 * TODO(QUIC SERVER): In the future we will construct channels dynamically
527 if (port
->tserver_ch
== NULL
)
531 * We have got a packet for an unknown DCID. This might be an attempt to
532 * open a new connection.
534 if (e
->data_len
< QUIC_MIN_INITIAL_DGRAM_LEN
)
537 if (!PACKET_buf_init(&pkt
, ossl_quic_urxe_data(e
), e
->data_len
))
541 * We set short_conn_id_len to SIZE_MAX here which will cause the decode
542 * operation to fail if we get a 1-RTT packet. This is fine since we only
543 * care about Initial packets.
545 if (!ossl_quic_wire_decode_pkt_hdr(&pkt
, SIZE_MAX
, 1, 0, &hdr
, NULL
))
548 switch (hdr
.version
) {
552 case QUIC_VERSION_NONE
:
554 /* Unknown version or proactive version negotiation request, bail. */
555 /* TODO(QUIC SERVER): Handle version negotiation on server side */
560 * We only care about Initial packets which might be trying to establish a
563 if (hdr
.type
!= QUIC_PKT_TYPE_INITIAL
)
567 * Try to process this as a valid attempt to initiate a connection.
569 * The channel will do all the LCID registration needed, but as an
570 * optimization inject this packet directly into the channel's QRX for
571 * processing without going through the DEMUX again.
573 port_on_new_conn(port
, &e
->peer
, &hdr
.src_conn_id
, &hdr
.dst_conn_id
,
576 ossl_qrx_inject_urxe(new_ch
->qrx
, e
);
581 ossl_quic_demux_release_urxe(port
->demux
, e
);
584 void ossl_quic_port_raise_net_error(QUIC_PORT
*port
,
585 QUIC_CHANNEL
*triggering_ch
)
589 if (!ossl_quic_port_is_running(port
))
593 * Immediately capture any triggering error on the error stack, with a
596 ERR_raise_data(ERR_LIB_SSL
, SSL_R_QUIC_NETWORK_ERROR
,
597 "port failed due to network BIO I/O error");
598 OSSL_ERR_STATE_save(port
->err_state
);
600 port_transition_failed(port
);
602 /* Give the triggering channel (if any) the first notification. */
603 if (triggering_ch
!= NULL
)
604 ossl_quic_channel_raise_net_error(triggering_ch
);
606 LIST_FOREACH(ch
, ch
, &port
->channel_list
)
607 if (ch
!= triggering_ch
)
608 ossl_quic_channel_raise_net_error(ch
);
611 void ossl_quic_port_restore_err_state(const QUIC_PORT
*port
)
614 OSSL_ERR_STATE_restore(port
->err_state
);