ssl/quic/quic_impl.c

   1 /*
   2  * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   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
   8  */
   9
  10 #include <openssl/macros.h>
  11 #include <openssl/objects.h>
  12 #include <openssl/sslerr.h>
  13 #include <crypto/rand.h>
  14 #include "quic_local.h"
  15 #include "internal/quic_tls.h"
  16 #include "internal/quic_rx_depack.h"
  17 #include "internal/quic_error.h"
  18 #include "internal/quic_engine.h"
  19 #include "internal/quic_port.h"
  20 #include "internal/time.h"
  21
  22 typedef struct qctx_st QCTX;
  23
  24 static void aon_write_finish(QUIC_XSO *xso);
  25 static int create_channel(QUIC_CONNECTION *qc);
  26 static QUIC_XSO *create_xso_from_stream(QUIC_CONNECTION *qc, QUIC_STREAM *qs);
  27 static int qc_try_create_default_xso_for_write(QCTX *ctx);
  28 static int qc_wait_for_default_xso_for_read(QCTX *ctx);
  29 static void quic_lock(QUIC_CONNECTION *qc);
  30 static void quic_unlock(QUIC_CONNECTION *qc);
  31 static void quic_lock_for_io(QCTX *ctx);
  32 static int quic_do_handshake(QCTX *ctx);
  33 static void qc_update_reject_policy(QUIC_CONNECTION *qc);
  34 static void qc_touch_default_xso(QUIC_CONNECTION *qc);
  35 static void qc_set_default_xso(QUIC_CONNECTION *qc, QUIC_XSO *xso, int touch);
  36 static void qc_set_default_xso_keep_ref(QUIC_CONNECTION *qc, QUIC_XSO *xso,
  37                                         int touch, QUIC_XSO **old_xso);
  38 static SSL *quic_conn_stream_new(QCTX *ctx, uint64_t flags, int need_lock);
  39 static int quic_validate_for_write(QUIC_XSO *xso, int *err);
  40 static int quic_mutation_allowed(QUIC_CONNECTION *qc, int req_active);
  41 static int qc_blocking_mode(const QUIC_CONNECTION *qc);
  42 static int xso_blocking_mode(const QUIC_XSO *xso);
  43 static void qctx_maybe_autotick(QCTX *ctx);
  44 static int qctx_should_autotick(QCTX *ctx);
  45
  46 /*
  47  * QUIC Front-End I/O API: Common Utilities
  48  * ========================================
  49  */
  50
  51 /*
  52  * Block until a predicate is met.
  53  *
  54  * Precondition: Must have a channel.
  55  * Precondition: Must hold channel lock (unchecked).
  56  */
  57 QUIC_NEEDS_LOCK
  58 static int block_until_pred(QUIC_CONNECTION *qc,
  59                             int (*pred)(void *arg), void *pred_arg,
  60                             uint32_t flags)
  61 {
  62     QUIC_REACTOR *rtor;
  63
  64     assert(qc->ch != NULL);
  65
  66     /*
  67      * Any attempt to block auto-disables tick inhibition as otherwise we will
  68      * hang around forever.
  69      */
  70     ossl_quic_engine_set_inhibit_tick(qc->engine, 0);
  71
  72     rtor = ossl_quic_channel_get_reactor(qc->ch);
  73     return ossl_quic_reactor_block_until_pred(rtor, pred, pred_arg, flags,
  74                                               qc->mutex);
  75 }
  76
  77 static OSSL_TIME get_time(QUIC_CONNECTION *qc)
  78 {
  79     if (qc->override_now_cb != NULL)
  80         return qc->override_now_cb(qc->override_now_cb_arg);
  81     else
  82         return ossl_time_now();
  83 }
  84
  85 static OSSL_TIME get_time_cb(void *arg)
  86 {
  87     QUIC_CONNECTION *qc = arg;
  88
  89     return get_time(qc);
  90 }
  91
  92 /*
  93  * QCTX is a utility structure which provides information we commonly wish to
  94  * unwrap upon an API call being dispatched to us, namely:
  95  *
  96  *   - a pointer to the QUIC_CONNECTION (regardless of whether a QCSO or QSSO
  97  *     was passed);
  98  *   - a pointer to any applicable QUIC_XSO (e.g. if a QSSO was passed, or if
  99  *     a QCSO with a default stream was passed);
 100  *   - whether a QSSO was passed (xso == NULL must not be used to determine this
 101  *     because it may be non-NULL when a QCSO is passed if that QCSO has a
 102  *     default stream);
 103  *   - whether we are in "I/O context", meaning that non-normal errors can
 104  *     be reported via SSL_get_error() as well as via ERR. Functions such as
 105  *     SSL_read(), SSL_write() and SSL_do_handshake() are "I/O context"
 106  *     functions which are allowed to change the value returned by
 107  *     SSL_get_error. However, other functions (including functions which call
 108  *     SSL_do_handshake() implicitly) are not allowed to change the return value
 109  *     of SSL_get_error.
 110  */
 111 struct qctx_st {
 112     QUIC_CONNECTION *qc;
 113     QUIC_XSO        *xso;
 114     int             is_stream, in_io;
 115 };
 116
 117 QUIC_NEEDS_LOCK
 118 static void quic_set_last_error(QCTX *ctx, int last_error)
 119 {
 120     if (!ctx->in_io)
 121         return;
 122
 123     if (ctx->is_stream && ctx->xso != NULL)
 124         ctx->xso->last_error = last_error;
 125     else if (!ctx->is_stream && ctx->qc != NULL)
 126         ctx->qc->last_error = last_error;
 127 }
 128
 129 /*
 130  * Raise a 'normal' error, meaning one that can be reported via SSL_get_error()
 131  * rather than via ERR. Note that normal errors must always be raised while
 132  * holding a lock.
 133  */
 134 QUIC_NEEDS_LOCK
 135 static int quic_raise_normal_error(QCTX *ctx,
 136                                    int err)
 137 {
 138     assert(ctx->in_io);
 139     quic_set_last_error(ctx, err);
 140
 141     return 0;
 142 }
 143
 144 /*
 145  * Raise a 'non-normal' error, meaning any error that is not reported via
 146  * SSL_get_error() and must be reported via ERR.
 147  *
 148  * qc should be provided if available. In exceptional circumstances when qc is
 149  * not known NULL may be passed. This should generally only happen when an
 150  * expect_...() function defined below fails, which generally indicates a
 151  * dispatch error or caller error.
 152  *
 153  * ctx should be NULL if the connection lock is not held.
 154  */
 155 static int quic_raise_non_normal_error(QCTX *ctx,
 156                                        const char *file,
 157                                        int line,
 158                                        const char *func,
 159                                        int reason,
 160                                        const char *fmt,
 161                                        ...)
 162 {
 163     va_list args;
 164
 165     if (ctx != NULL) {
 166         quic_set_last_error(ctx, SSL_ERROR_SSL);
 167
 168         if (reason == SSL_R_PROTOCOL_IS_SHUTDOWN && ctx->qc != NULL)
 169             ossl_quic_channel_restore_err_state(ctx->qc->ch);
 170     }
 171
 172     ERR_new();
 173     ERR_set_debug(file, line, func);
 174
 175     va_start(args, fmt);
 176     ERR_vset_error(ERR_LIB_SSL, reason, fmt, args);
 177     va_end(args);
 178
 179     return 0;
 180 }
 181
 182 #define QUIC_RAISE_NORMAL_ERROR(ctx, err)                       \
 183     quic_raise_normal_error((ctx), (err))
 184
 185 #define QUIC_RAISE_NON_NORMAL_ERROR(ctx, reason, msg)           \
 186     quic_raise_non_normal_error((ctx),                          \
 187                                 OPENSSL_FILE, OPENSSL_LINE,     \
 188                                 OPENSSL_FUNC,                   \
 189                                 (reason),                       \
 190                                 (msg))
 191
 192 /*
 193  * Given a QCSO or QSSO, initialises a QCTX, determining the contextually
 194  * applicable QUIC_CONNECTION pointer and, if applicable, QUIC_XSO pointer.
 195  *
 196  * After this returns 1, all fields of the passed QCTX are initialised.
 197  * Returns 0 on failure. This function is intended to be used to provide API
 198  * semantics and as such, it invokes QUIC_RAISE_NON_NORMAL_ERROR() on failure.
 199  */
 200 static int expect_quic(const SSL *s, QCTX *ctx)
 201 {
 202     QUIC_CONNECTION *qc;
 203     QUIC_XSO *xso;
 204
 205     ctx->qc         = NULL;
 206     ctx->xso        = NULL;
 207     ctx->is_stream  = 0;
 208
 209     if (s == NULL)
 210         return QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_PASSED_NULL_PARAMETER, NULL);
 211
 212     switch (s->type) {
 213     case SSL_TYPE_QUIC_CONNECTION:
 214         qc              = (QUIC_CONNECTION *)s;
 215         ctx->qc         = qc;
 216         ctx->xso        = qc->default_xso;
 217         ctx->is_stream  = 0;
 218         ctx->in_io      = 0;
 219         return 1;
 220
 221     case SSL_TYPE_QUIC_XSO:
 222         xso             = (QUIC_XSO *)s;
 223         ctx->qc         = xso->conn;
 224         ctx->xso        = xso;
 225         ctx->is_stream  = 1;
 226         ctx->in_io      = 0;
 227         return 1;
 228
 229     default:
 230         return QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
 231     }
 232 }
 233
 234 /*
 235  * Like expect_quic(), but requires a QUIC_XSO be contextually available. In
 236  * other words, requires that the passed QSO be a QSSO or a QCSO with a default
 237  * stream.
 238  *
 239  * remote_init determines if we expect the default XSO to be remotely created or
 240  * not. If it is -1, do not instantiate a default XSO if one does not yet exist.
 241  *
 242  * Channel mutex is acquired and retained on success.
 243  */
 244 QUIC_ACQUIRES_LOCK
 245 static int ossl_unused expect_quic_with_stream_lock(const SSL *s, int remote_init,
 246                                                     int in_io, QCTX *ctx)
 247 {
 248     if (!expect_quic(s, ctx))
 249         return 0;
 250
 251     if (in_io)
 252         quic_lock_for_io(ctx);
 253     else
 254         quic_lock(ctx->qc);
 255
 256     if (ctx->xso == NULL && remote_init >= 0) {
 257         if (!quic_mutation_allowed(ctx->qc, /*req_active=*/0)) {
 258             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
 259             goto err;
 260         }
 261
 262         /* If we haven't finished the handshake, try to advance it. */
 263         if (quic_do_handshake(ctx) < 1)
 264             /* ossl_quic_do_handshake raised error here */
 265             goto err;
 266
 267         if (remote_init == 0) {
 268             if (!qc_try_create_default_xso_for_write(ctx))
 269                 goto err;
 270         } else {
 271             if (!qc_wait_for_default_xso_for_read(ctx))
 272                 goto err;
 273         }
 274
 275         ctx->xso = ctx->qc->default_xso;
 276     }
 277
 278     if (ctx->xso == NULL) {
 279         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_NO_STREAM, NULL);
 280         goto err;
 281     }
 282
 283     return 1; /* coverity[missing_unlock]: lock held */
 284
 285 err:
 286     quic_unlock(ctx->qc);
 287     return 0;
 288 }
 289
 290 /*
 291  * Like expect_quic(), but fails if called on a QUIC_XSO. ctx->xso may still
 292  * be non-NULL if the QCSO has a default stream.
 293  */
 294 static int ossl_unused expect_quic_conn_only(const SSL *s, QCTX *ctx)
 295 {
 296     if (!expect_quic(s, ctx))
 297         return 0;
 298
 299     if (ctx->is_stream)
 300         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_CONN_USE_ONLY, NULL);
 301
 302     return 1;
 303 }
 304
 305 /*
 306  * Ensures that the channel mutex is held for a method which touches channel
 307  * state.
 308  *
 309  * Precondition: Channel mutex is not held (unchecked)
 310  */
 311 static void quic_lock(QUIC_CONNECTION *qc)
 312 {
 313 #if defined(OPENSSL_THREADS)
 314     ossl_crypto_mutex_lock(qc->mutex);
 315 #endif
 316 }
 317
 318 static void quic_lock_for_io(QCTX *ctx)
 319 {
 320     quic_lock(ctx->qc);
 321     ctx->in_io = 1;
 322
 323     /*
 324      * We are entering an I/O function so we must update the values returned by
 325      * SSL_get_error and SSL_want. Set no error. This will be overridden later
 326      * if a call to QUIC_RAISE_NORMAL_ERROR or QUIC_RAISE_NON_NORMAL_ERROR
 327      * occurs during the API call.
 328      */
 329     quic_set_last_error(ctx, SSL_ERROR_NONE);
 330 }
 331
 332 /* Precondition: Channel mutex is held (unchecked) */
 333 QUIC_NEEDS_LOCK
 334 static void quic_unlock(QUIC_CONNECTION *qc)
 335 {
 336 #if defined(OPENSSL_THREADS)
 337     ossl_crypto_mutex_unlock(qc->mutex);
 338 #endif
 339 }
 340
 341 /*
 342  * This predicate is the criterion which should determine API call rejection for
 343  * *most* mutating API calls, particularly stream-related operations for send
 344  * parts.
 345  *
 346  * A call is rejected (this function returns 0) if shutdown is in progress
 347  * (stream flushing), or we are in a TERMINATING or TERMINATED state. If
 348  * req_active=1, the connection must be active (i.e., the IDLE state is also
 349  * rejected).
 350  */
 351 static int quic_mutation_allowed(QUIC_CONNECTION *qc, int req_active)
 352 {
 353     if (qc->shutting_down || ossl_quic_channel_is_term_any(qc->ch))
 354         return 0;
 355
 356     if (req_active && !ossl_quic_channel_is_active(qc->ch))
 357         return 0;
 358
 359     return 1;
 360 }
 361
 362 /*
 363  * QUIC Front-End I/O API: Initialization
 364  * ======================================
 365  *
 366  *         SSL_new                  => ossl_quic_new
 367  *                                     ossl_quic_init
 368  *         SSL_reset                => ossl_quic_reset
 369  *         SSL_clear                => ossl_quic_clear
 370  *                                     ossl_quic_deinit
 371  *         SSL_free                 => ossl_quic_free
 372  *
 373  *         SSL_set_options          => ossl_quic_set_options
 374  *         SSL_get_options          => ossl_quic_get_options
 375  *         SSL_clear_options        => ossl_quic_clear_options
 376  *
 377  */
 378
 379 /* SSL_new */
 380 SSL *ossl_quic_new(SSL_CTX *ctx)
 381 {
 382     QUIC_CONNECTION *qc = NULL;
 383     SSL *ssl_base = NULL;
 384     SSL_CONNECTION *sc = NULL;
 385
 386     qc = OPENSSL_zalloc(sizeof(*qc));
 387     if (qc == NULL) {
 388         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_CRYPTO_LIB, NULL);
 389         return NULL;
 390     }
 391 #if defined(OPENSSL_THREADS)
 392     if ((qc->mutex = ossl_crypto_mutex_new()) == NULL) {
 393         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_CRYPTO_LIB, NULL);
 394         goto err;
 395     }
 396 #endif
 397
 398     /* Initialise the QUIC_CONNECTION's stub header. */
 399     ssl_base = &qc->ssl;
 400     if (!ossl_ssl_init(ssl_base, ctx, ctx->method, SSL_TYPE_QUIC_CONNECTION)) {
 401         ssl_base = NULL;
 402         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
 403         goto err;
 404     }
 405
 406     qc->tls = ossl_ssl_connection_new_int(ctx, TLS_method());
 407     if (qc->tls == NULL || (sc = SSL_CONNECTION_FROM_SSL(qc->tls)) == NULL) {
 408         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
 409         goto err;
 410     }
 411
 412     /* override the user_ssl of the inner connection */
 413     sc->s3.flags |= TLS1_FLAGS_QUIC;
 414
 415     /* Restrict options derived from the SSL_CTX. */
 416     sc->options &= OSSL_QUIC_PERMITTED_OPTIONS_CONN;
 417     sc->pha_enabled = 0;
 418
 419 #if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)
 420     qc->is_thread_assisted
 421         = (ssl_base->method == OSSL_QUIC_client_thread_method());
 422 #endif
 423
 424     qc->as_server       = 0; /* TODO(QUIC SERVER): add server support */
 425     qc->as_server_state = qc->as_server;
 426
 427     qc->default_stream_mode     = SSL_DEFAULT_STREAM_MODE_AUTO_BIDI;
 428     qc->default_ssl_mode        = qc->ssl.ctx->mode;
 429     qc->default_ssl_options     = qc->ssl.ctx->options & OSSL_QUIC_PERMITTED_OPTIONS;
 430     qc->desires_blocking        = 1;
 431     qc->blocking                = 0;
 432     qc->incoming_stream_policy  = SSL_INCOMING_STREAM_POLICY_AUTO;
 433     qc->last_error              = SSL_ERROR_NONE;
 434
 435     if (!create_channel(qc))
 436         goto err;
 437
 438     ossl_quic_channel_set_msg_callback(qc->ch, ctx->msg_callback, ssl_base);
 439     ossl_quic_channel_set_msg_callback_arg(qc->ch, ctx->msg_callback_arg);
 440
 441     qc_update_reject_policy(qc);
 442
 443     /*
 444      * We do not create the default XSO yet. The reason for this is that the
 445      * stream ID of the default XSO will depend on whether the stream is client
 446      * or server-initiated, which depends on who transmits first. Since we do
 447      * not know whether the application will be using a client-transmits-first
 448      * or server-transmits-first protocol, we defer default XSO creation until
 449      * the client calls SSL_read() or SSL_write(). If it calls SSL_read() first,
 450      * we take that as a cue that the client is expecting a server-initiated
 451      * stream, and vice versa if SSL_write() is called first.
 452      */
 453     return ssl_base;
 454
 455 err:
 456     if (ssl_base == NULL) {
 457 #if defined(OPENSSL_THREADS)
 458         ossl_crypto_mutex_free(&qc->mutex);
 459 #endif
 460         OPENSSL_free(qc);
 461     } else {
 462         SSL_free(ssl_base);
 463     }
 464     return NULL;
 465 }
 466
 467 /* SSL_free */
 468 QUIC_TAKES_LOCK
 469 void ossl_quic_free(SSL *s)
 470 {
 471     QCTX ctx;
 472     int is_default;
 473
 474     /* We should never be called on anything but a QSO. */
 475     if (!expect_quic(s, &ctx))
 476         return;
 477
 478     quic_lock(ctx.qc);
 479
 480     if (ctx.is_stream) {
 481         /*
 482          * When a QSSO is freed, the XSO is freed immediately, because the XSO
 483          * itself only contains API personality layer data. However the
 484          * underlying QUIC_STREAM is not freed immediately but is instead marked
 485          * as deleted for later collection.
 486          */
 487
 488         assert(ctx.qc->num_xso > 0);
 489         --ctx.qc->num_xso;
 490
 491         /* If a stream's send part has not been finished, auto-reset it. */
 492         if ((   ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_READY
 493              || ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_SEND)
 494             && !ossl_quic_sstream_get_final_size(ctx.xso->stream->sstream, NULL))
 495             ossl_quic_stream_map_reset_stream_send_part(ossl_quic_channel_get_qsm(ctx.qc->ch),
 496                                                         ctx.xso->stream, 0);
 497
 498         /* Do STOP_SENDING for the receive part, if applicable. */
 499         if (   ctx.xso->stream->recv_state == QUIC_RSTREAM_STATE_RECV
 500             || ctx.xso->stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN)
 501             ossl_quic_stream_map_stop_sending_recv_part(ossl_quic_channel_get_qsm(ctx.qc->ch),
 502                                                         ctx.xso->stream, 0);
 503
 504         /* Update stream state. */
 505         ctx.xso->stream->deleted = 1;
 506         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(ctx.qc->ch),
 507                                           ctx.xso->stream);
 508
 509         is_default = (ctx.xso == ctx.qc->default_xso);
 510         quic_unlock(ctx.qc);
 511
 512         /*
 513          * Unref the connection in most cases; the XSO has a ref to the QC and
 514          * not vice versa. But for a default XSO, to avoid circular references,
 515          * the QC refs the XSO but the XSO does not ref the QC. If we are the
 516          * default XSO, we only get here when the QC is being torn down anyway,
 517          * so don't call SSL_free(qc) as we are already in it.
 518          */
 519         if (!is_default)
 520             SSL_free(&ctx.qc->ssl);
 521
 522         /* Note: SSL_free calls OPENSSL_free(xso) for us */
 523         return;
 524     }
 525
 526     /*
 527      * Free the default XSO, if any. The QUIC_STREAM is not deleted at this
 528      * stage, but is freed during the channel free when the whole QSM is freed.
 529      */
 530     if (ctx.qc->default_xso != NULL) {
 531         QUIC_XSO *xso = ctx.qc->default_xso;
 532
 533         quic_unlock(ctx.qc);
 534         SSL_free(&xso->ssl);
 535         quic_lock(ctx.qc);
 536         ctx.qc->default_xso = NULL;
 537     }
 538
 539     /* Ensure we have no remaining XSOs. */
 540     assert(ctx.qc->num_xso == 0);
 541
 542 #if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)
 543     if (ctx.qc->is_thread_assisted && ctx.qc->started) {
 544         ossl_quic_thread_assist_wait_stopped(&ctx.qc->thread_assist);
 545         ossl_quic_thread_assist_cleanup(&ctx.qc->thread_assist);
 546     }
 547 #endif
 548
 549     SSL_free(ctx.qc->tls);
 550
 551     ossl_quic_channel_free(ctx.qc->ch);
 552     ossl_quic_port_free(ctx.qc->port);
 553     ossl_quic_engine_free(ctx.qc->engine);
 554
 555     BIO_free_all(ctx.qc->net_rbio);
 556     BIO_free_all(ctx.qc->net_wbio);
 557
 558     quic_unlock(ctx.qc); /* tsan doesn't like freeing locked mutexes */
 559 #if defined(OPENSSL_THREADS)
 560     ossl_crypto_mutex_free(&ctx.qc->mutex);
 561 #endif
 562
 563     /*
 564      * Note: SSL_free (that called this function) calls OPENSSL_free(ctx.qc) for
 565      * us
 566      */
 567 }
 568
 569 /* SSL method init */
 570 int ossl_quic_init(SSL *s)
 571 {
 572     /* Same op as SSL_clear, forward the call. */
 573     return ossl_quic_clear(s);
 574 }
 575
 576 /* SSL method deinit */
 577 void ossl_quic_deinit(SSL *s)
 578 {
 579     /* No-op. */
 580 }
 581
 582 /* SSL_clear (ssl_reset method) */
 583 int ossl_quic_reset(SSL *s)
 584 {
 585     QCTX ctx;
 586
 587     if (!expect_quic(s, &ctx))
 588         return 0;
 589
 590     ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED);
 591     return 0;
 592 }
 593
 594 /* ssl_clear method (unused) */
 595 int ossl_quic_clear(SSL *s)
 596 {
 597     QCTX ctx;
 598
 599     if (!expect_quic(s, &ctx))
 600         return 0;
 601
 602     ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED);
 603     return 0;
 604 }
 605
 606 int ossl_quic_conn_set_override_now_cb(SSL *s,
 607                                        OSSL_TIME (*now_cb)(void *arg),
 608                                        void *now_cb_arg)
 609 {
 610     QCTX ctx;
 611
 612     if (!expect_quic(s, &ctx))
 613         return 0;
 614
 615     quic_lock(ctx.qc);
 616
 617     ctx.qc->override_now_cb     = now_cb;
 618     ctx.qc->override_now_cb_arg = now_cb_arg;
 619
 620     quic_unlock(ctx.qc);
 621     return 1;
 622 }
 623
 624 void ossl_quic_conn_force_assist_thread_wake(SSL *s)
 625 {
 626     QCTX ctx;
 627
 628     if (!expect_quic(s, &ctx))
 629         return;
 630
 631 #if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)
 632     if (ctx.qc->is_thread_assisted && ctx.qc->started)
 633         ossl_quic_thread_assist_notify_deadline_changed(&ctx.qc->thread_assist);
 634 #endif
 635 }
 636
 637 QUIC_NEEDS_LOCK
 638 static void qc_touch_default_xso(QUIC_CONNECTION *qc)
 639 {
 640     qc->default_xso_created = 1;
 641     qc_update_reject_policy(qc);
 642 }
 643
 644 /*
 645  * Changes default XSO. Allows caller to keep reference to the old default XSO
 646  * (if any). Reference to new XSO is transferred from caller.
 647  */
 648 QUIC_NEEDS_LOCK
 649 static void qc_set_default_xso_keep_ref(QUIC_CONNECTION *qc, QUIC_XSO *xso,
 650                                         int touch,
 651                                         QUIC_XSO **old_xso)
 652 {
 653     int refs;
 654
 655     *old_xso = NULL;
 656
 657     if (qc->default_xso != xso) {
 658         *old_xso = qc->default_xso; /* transfer old XSO ref to caller */
 659
 660         qc->default_xso = xso;
 661
 662         if (xso == NULL) {
 663             /*
 664              * Changing to not having a default XSO. XSO becomes standalone and
 665              * now has a ref to the QC.
 666              */
 667             if (!ossl_assert(SSL_up_ref(&qc->ssl)))
 668                 return;
 669         } else {
 670             /*
 671              * Changing from not having a default XSO to having one. The new XSO
 672              * will have had a reference to the QC we need to drop to avoid a
 673              * circular reference.
 674              *
 675              * Currently we never change directly from one default XSO to
 676              * another, though this function would also still be correct if this
 677              * weren't the case.
 678              */
 679             assert(*old_xso == NULL);
 680
 681             CRYPTO_DOWN_REF(&qc->ssl.references, &refs);
 682             assert(refs > 0);
 683         }
 684     }
 685
 686     if (touch)
 687         qc_touch_default_xso(qc);
 688 }
 689
 690 /*
 691  * Changes default XSO, releasing the reference to any previous default XSO.
 692  * Reference to new XSO is transferred from caller.
 693  */
 694 QUIC_NEEDS_LOCK
 695 static void qc_set_default_xso(QUIC_CONNECTION *qc, QUIC_XSO *xso, int touch)
 696 {
 697     QUIC_XSO *old_xso = NULL;
 698
 699     qc_set_default_xso_keep_ref(qc, xso, touch, &old_xso);
 700
 701     if (old_xso != NULL)
 702         SSL_free(&old_xso->ssl);
 703 }
 704
 705 QUIC_NEEDS_LOCK
 706 static void xso_update_options(QUIC_XSO *xso)
 707 {
 708     int cleanse = ((xso->ssl_options & SSL_OP_CLEANSE_PLAINTEXT) != 0);
 709
 710     if (xso->stream->rstream != NULL)
 711         ossl_quic_rstream_set_cleanse(xso->stream->rstream, cleanse);
 712
 713     if (xso->stream->sstream != NULL)
 714         ossl_quic_sstream_set_cleanse(xso->stream->sstream, cleanse);
 715 }
 716
 717 /*
 718  * SSL_set_options
 719  * ---------------
 720  *
 721  * Setting options on a QCSO
 722  *   - configures the handshake-layer options;
 723  *   - configures the default data-plane options for new streams;
 724  *   - configures the data-plane options on the default XSO, if there is one.
 725  *
 726  * Setting options on a QSSO
 727  *   - configures data-plane options for that stream only.
 728  */
 729 QUIC_TAKES_LOCK
 730 static uint64_t quic_mask_or_options(SSL *ssl, uint64_t mask_value, uint64_t or_value)
 731 {
 732     QCTX ctx;
 733     uint64_t hs_mask_value, hs_or_value, ret;
 734
 735     if (!expect_quic(ssl, &ctx))
 736         return 0;
 737
 738     quic_lock(ctx.qc);
 739
 740     if (!ctx.is_stream) {
 741         /*
 742          * If we were called on the connection, we apply any handshake option
 743          * changes.
 744          */
 745         hs_mask_value = (mask_value & OSSL_QUIC_PERMITTED_OPTIONS_CONN);
 746         hs_or_value   = (or_value   & OSSL_QUIC_PERMITTED_OPTIONS_CONN);
 747
 748         SSL_clear_options(ctx.qc->tls, hs_mask_value);
 749         SSL_set_options(ctx.qc->tls, hs_or_value);
 750
 751         /* Update defaults for new streams. */
 752         ctx.qc->default_ssl_options
 753             = ((ctx.qc->default_ssl_options & ~mask_value) | or_value)
 754               & OSSL_QUIC_PERMITTED_OPTIONS;
 755     }
 756
 757     if (ctx.xso != NULL) {
 758         ctx.xso->ssl_options
 759             = ((ctx.xso->ssl_options & ~mask_value) | or_value)
 760             & OSSL_QUIC_PERMITTED_OPTIONS_STREAM;
 761
 762         xso_update_options(ctx.xso);
 763     }
 764
 765     ret = ctx.is_stream ? ctx.xso->ssl_options : ctx.qc->default_ssl_options;
 766
 767     quic_unlock(ctx.qc);
 768     return ret;
 769 }
 770
 771 uint64_t ossl_quic_set_options(SSL *ssl, uint64_t options)
 772 {
 773     return quic_mask_or_options(ssl, 0, options);
 774 }
 775
 776 /* SSL_clear_options */
 777 uint64_t ossl_quic_clear_options(SSL *ssl, uint64_t options)
 778 {
 779     return quic_mask_or_options(ssl, options, 0);
 780 }
 781
 782 /* SSL_get_options */
 783 uint64_t ossl_quic_get_options(const SSL *ssl)
 784 {
 785     return quic_mask_or_options((SSL *)ssl, 0, 0);
 786 }
 787
 788 /*
 789  * QUIC Front-End I/O API: Network BIO Configuration
 790  * =================================================
 791  *
 792  * Handling the different BIOs is difficult:
 793  *
 794  *   - It is more or less a requirement that we use non-blocking network I/O;
 795  *     we need to be able to have timeouts on recv() calls, and make best effort
 796  *     (non blocking) send() and recv() calls.
 797  *
 798  *     The only sensible way to do this is to configure the socket into
 799  *     non-blocking mode. We could try to do select() before calling send() or
 800  *     recv() to get a guarantee that the call will not block, but this will
 801  *     probably run into issues with buggy OSes which generate spurious socket
 802  *     readiness events. In any case, relying on this to work reliably does not
 803  *     seem sane.
 804  *
 805  *     Timeouts could be handled via setsockopt() socket timeout options, but
 806  *     this depends on OS support and adds another syscall to every network I/O
 807  *     operation. It also has obvious thread safety concerns if we want to move
 808  *     to concurrent use of a single socket at some later date.
 809  *
 810  *     Some OSes support a MSG_DONTWAIT flag which allows a single I/O option to
 811  *     be made non-blocking. However some OSes (e.g. Windows) do not support
 812  *     this, so we cannot rely on this.
 813  *
 814  *     As such, we need to configure any FD in non-blocking mode. This may
 815  *     confound users who pass a blocking socket to libssl. However, in practice
 816  *     it would be extremely strange for a user of QUIC to pass an FD to us,
 817  *     then also try and send receive traffic on the same socket(!). Thus the
 818  *     impact of this should be limited, and can be documented.
 819  *
 820  *   - We support both blocking and non-blocking operation in terms of the API
 821  *     presented to the user. One prospect is to set the blocking mode based on
 822  *     whether the socket passed to us was already in blocking mode. However,
 823  *     Windows has no API for determining if a socket is in blocking mode (!),
 824  *     therefore this cannot be done portably. Currently therefore we expose an
 825  *     explicit API call to set this, and default to blocking mode.
 826  *
 827  *   - We need to determine our initial destination UDP address. The "natural"
 828  *     way for a user to do this is to set the peer variable on a BIO_dgram.
 829  *     However, this has problems because BIO_dgram's peer variable is used for
 830  *     both transmission and reception. This means it can be constantly being
 831  *     changed to a malicious value (e.g. if some random unrelated entity on the
 832  *     network starts sending traffic to us) on every read call. This is not a
 833  *     direct issue because we use the 'stateless' BIO_sendmmsg and BIO_recvmmsg
 834  *     calls only, which do not use this variable. However, we do need to let
 835  *     the user specify the peer in a 'normal' manner. The compromise here is
 836  *     that we grab the current peer value set at the time the write BIO is set
 837  *     and do not read the value again.
 838  *
 839  *   - We also need to support memory BIOs (e.g. BIO_dgram_pair) or custom BIOs.
 840  *     Currently we do this by only supporting non-blocking mode.
 841  *
 842  */
 843
 844 /*
 845  * Determines what initial destination UDP address we should use, if possible.
 846  * If this fails the client must set the destination address manually, or use a
 847  * BIO which does not need a destination address.
 848  */
 849 static int csm_analyse_init_peer_addr(BIO *net_wbio, BIO_ADDR *peer)
 850 {
 851     if (BIO_dgram_detect_peer_addr(net_wbio, peer) <= 0)
 852         return 0;
 853
 854     return 1;
 855 }
 856
 857 static int qc_can_support_blocking_cached(QUIC_CONNECTION *qc)
 858 {
 859     QUIC_REACTOR *rtor = ossl_quic_channel_get_reactor(qc->ch);
 860
 861     return ossl_quic_reactor_can_poll_r(rtor)
 862         && ossl_quic_reactor_can_poll_w(rtor);
 863 }
 864
 865 static void qc_update_can_support_blocking(QUIC_CONNECTION *qc)
 866 {
 867     ossl_quic_port_update_poll_descriptors(qc->port); /* best effort */
 868 }
 869
 870 static void qc_update_blocking_mode(QUIC_CONNECTION *qc)
 871 {
 872     qc->blocking = qc->desires_blocking && qc_can_support_blocking_cached(qc);
 873 }
 874
 875 void ossl_quic_conn_set0_net_rbio(SSL *s, BIO *net_rbio)
 876 {
 877     QCTX ctx;
 878
 879     if (!expect_quic(s, &ctx))
 880         return;
 881
 882     if (ctx.qc->net_rbio == net_rbio)
 883         return;
 884
 885     if (!ossl_quic_port_set_net_rbio(ctx.qc->port, net_rbio))
 886         return;
 887
 888     BIO_free_all(ctx.qc->net_rbio);
 889     ctx.qc->net_rbio = net_rbio;
 890
 891     if (net_rbio != NULL)
 892         BIO_set_nbio(net_rbio, 1); /* best effort autoconfig */
 893
 894     /*
 895      * Determine if the current pair of read/write BIOs now set allows blocking
 896      * mode to be supported.
 897      */
 898     qc_update_can_support_blocking(ctx.qc);
 899     qc_update_blocking_mode(ctx.qc);
 900 }
 901
 902 void ossl_quic_conn_set0_net_wbio(SSL *s, BIO *net_wbio)
 903 {
 904     QCTX ctx;
 905
 906     if (!expect_quic(s, &ctx))
 907         return;
 908
 909     if (ctx.qc->net_wbio == net_wbio)
 910         return;
 911
 912     if (!ossl_quic_port_set_net_wbio(ctx.qc->port, net_wbio))
 913         return;
 914
 915     BIO_free_all(ctx.qc->net_wbio);
 916     ctx.qc->net_wbio = net_wbio;
 917
 918     if (net_wbio != NULL)
 919         BIO_set_nbio(net_wbio, 1); /* best effort autoconfig */
 920
 921     /*
 922      * Determine if the current pair of read/write BIOs now set allows blocking
 923      * mode to be supported.
 924      */
 925     qc_update_can_support_blocking(ctx.qc);
 926     qc_update_blocking_mode(ctx.qc);
 927 }
 928
 929 BIO *ossl_quic_conn_get_net_rbio(const SSL *s)
 930 {
 931     QCTX ctx;
 932
 933     if (!expect_quic(s, &ctx))
 934         return NULL;
 935
 936     return ctx.qc->net_rbio;
 937 }
 938
 939 BIO *ossl_quic_conn_get_net_wbio(const SSL *s)
 940 {
 941     QCTX ctx;
 942
 943     if (!expect_quic(s, &ctx))
 944         return NULL;
 945
 946     return ctx.qc->net_wbio;
 947 }
 948
 949 int ossl_quic_conn_get_blocking_mode(const SSL *s)
 950 {
 951     QCTX ctx;
 952
 953     if (!expect_quic(s, &ctx))
 954         return 0;
 955
 956     if (ctx.is_stream)
 957         return xso_blocking_mode(ctx.xso);
 958
 959     return qc_blocking_mode(ctx.qc);
 960 }
 961
 962 QUIC_TAKES_LOCK
 963 int ossl_quic_conn_set_blocking_mode(SSL *s, int blocking)
 964 {
 965     int ret = 0;
 966     QCTX ctx;
 967
 968     if (!expect_quic(s, &ctx))
 969         return 0;
 970
 971     quic_lock(ctx.qc);
 972
 973     /* Sanity check - can we support the request given the current network BIO? */
 974     if (blocking) {
 975         /*
 976          * If called directly on a QCSO, update our information on network BIO
 977          * capabilities.
 978          */
 979         if (!ctx.is_stream)
 980             qc_update_can_support_blocking(ctx.qc);
 981
 982         /* Cannot enable blocking mode if we do not have pollable FDs. */
 983         if (!qc_can_support_blocking_cached(ctx.qc)) {
 984             ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_UNSUPPORTED, NULL);
 985             goto out;
 986         }
 987     }
 988
 989     if (!ctx.is_stream)
 990         /*
 991          * If called directly on a QCSO, update default and connection-level
 992          * blocking modes.
 993          */
 994         ctx.qc->desires_blocking = (blocking != 0);
 995
 996     if (ctx.xso != NULL) {
 997         /*
 998          * If called on a QSSO or a QCSO with a default XSO, update the blocking
 999          * mode.
1000          */
1001         ctx.xso->desires_blocking       = (blocking != 0);
1002         ctx.xso->desires_blocking_set   = 1;
1003     }
1004
1005     ret = 1;
1006 out:
1007     qc_update_blocking_mode(ctx.qc);
1008     quic_unlock(ctx.qc);
1009     return ret;
1010 }
1011
1012 int ossl_quic_conn_set_initial_peer_addr(SSL *s,
1013                                          const BIO_ADDR *peer_addr)
1014 {
1015     QCTX ctx;
1016
1017     if (!expect_quic(s, &ctx))
1018         return 0;
1019
1020     if (ctx.qc->started)
1021         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
1022                                        NULL);
1023
1024     if (peer_addr == NULL) {
1025         BIO_ADDR_clear(&ctx.qc->init_peer_addr);
1026         return 1;
1027     }
1028
1029     ctx.qc->init_peer_addr = *peer_addr;
1030     return 1;
1031 }
1032
1033 /*
1034  * QUIC Front-End I/O API: Asynchronous I/O Management
1035  * ===================================================
1036  *
1037  *   (BIO/)SSL_handle_events        => ossl_quic_handle_events
1038  *   (BIO/)SSL_get_event_timeout    => ossl_quic_get_event_timeout
1039  *   (BIO/)SSL_get_poll_fd          => ossl_quic_get_poll_fd
1040  *
1041  */
1042
1043 /* Returns 1 if the connection is being used in blocking mode. */
1044 static int qc_blocking_mode(const QUIC_CONNECTION *qc)
1045 {
1046     return qc->blocking;
1047 }
1048
1049 static int xso_blocking_mode(const QUIC_XSO *xso)
1050 {
1051     if (xso->desires_blocking_set)
1052         return xso->desires_blocking && qc_can_support_blocking_cached(xso->conn);
1053     else
1054         /* Only ever set if we can support blocking. */
1055         return xso->conn->blocking;
1056 }
1057
1058 /* SSL_handle_events; performs QUIC I/O and timeout processing. */
1059 QUIC_TAKES_LOCK
1060 int ossl_quic_handle_events(SSL *s)
1061 {
1062     QCTX ctx;
1063
1064     if (!expect_quic(s, &ctx))
1065         return 0;
1066
1067     quic_lock(ctx.qc);
1068     ossl_quic_reactor_tick(ossl_quic_channel_get_reactor(ctx.qc->ch), 0);
1069     quic_unlock(ctx.qc);
1070     return 1;
1071 }
1072
1073 /*
1074  * SSL_get_event_timeout. Get the time in milliseconds until the SSL object
1075  * should next have events handled by the application by calling
1076  * SSL_handle_events(). tv is set to 0 if the object should have events handled
1077  * immediately. If no timeout is currently active, *is_infinite is set to 1 and
1078  * the value of *tv is undefined.
1079  */
1080 QUIC_TAKES_LOCK
1081 int ossl_quic_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite)
1082 {
1083     QCTX ctx;
1084     OSSL_TIME deadline = ossl_time_infinite();
1085
1086     if (!expect_quic(s, &ctx))
1087         return 0;
1088
1089     quic_lock(ctx.qc);
1090
1091     deadline
1092         = ossl_quic_reactor_get_tick_deadline(ossl_quic_channel_get_reactor(ctx.qc->ch));
1093
1094     if (ossl_time_is_infinite(deadline)) {
1095         *is_infinite = 1;
1096
1097         /*
1098          * Robustness against faulty applications that don't check *is_infinite;
1099          * harmless long timeout.
1100          */
1101         tv->tv_sec  = 1000000;
1102         tv->tv_usec = 0;
1103
1104         quic_unlock(ctx.qc);
1105         return 1;
1106     }
1107
1108     *tv = ossl_time_to_timeval(ossl_time_subtract(deadline, get_time(ctx.qc)));
1109     *is_infinite = 0;
1110     quic_unlock(ctx.qc);
1111     return 1;
1112 }
1113
1114 /* SSL_get_rpoll_descriptor */
1115 int ossl_quic_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
1116 {
1117     QCTX ctx;
1118
1119     if (!expect_quic(s, &ctx))
1120         return 0;
1121
1122     if (desc == NULL || ctx.qc->net_rbio == NULL)
1123         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
1124                                        NULL);
1125
1126     return BIO_get_rpoll_descriptor(ctx.qc->net_rbio, desc);
1127 }
1128
1129 /* SSL_get_wpoll_descriptor */
1130 int ossl_quic_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
1131 {
1132     QCTX ctx;
1133
1134     if (!expect_quic(s, &ctx))
1135         return 0;
1136
1137     if (desc == NULL || ctx.qc->net_wbio == NULL)
1138         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
1139                                        NULL);
1140
1141     return BIO_get_wpoll_descriptor(ctx.qc->net_wbio, desc);
1142 }
1143
1144 /* SSL_net_read_desired */
1145 QUIC_TAKES_LOCK
1146 int ossl_quic_get_net_read_desired(SSL *s)
1147 {
1148     QCTX ctx;
1149     int ret;
1150
1151     if (!expect_quic(s, &ctx))
1152         return 0;
1153
1154     quic_lock(ctx.qc);
1155     ret = ossl_quic_reactor_net_read_desired(ossl_quic_channel_get_reactor(ctx.qc->ch));
1156     quic_unlock(ctx.qc);
1157     return ret;
1158 }
1159
1160 /* SSL_net_write_desired */
1161 QUIC_TAKES_LOCK
1162 int ossl_quic_get_net_write_desired(SSL *s)
1163 {
1164     int ret;
1165     QCTX ctx;
1166
1167     if (!expect_quic(s, &ctx))
1168         return 0;
1169
1170     quic_lock(ctx.qc);
1171     ret = ossl_quic_reactor_net_write_desired(ossl_quic_channel_get_reactor(ctx.qc->ch));
1172     quic_unlock(ctx.qc);
1173     return ret;
1174 }
1175
1176 /*
1177  * QUIC Front-End I/O API: Connection Lifecycle Operations
1178  * =======================================================
1179  *
1180  *         SSL_do_handshake         => ossl_quic_do_handshake
1181  *         SSL_set_connect_state    => ossl_quic_set_connect_state
1182  *         SSL_set_accept_state     => ossl_quic_set_accept_state
1183  *         SSL_shutdown             => ossl_quic_shutdown
1184  *         SSL_ctrl                 => ossl_quic_ctrl
1185  *   (BIO/)SSL_connect              => ossl_quic_connect
1186  *   (BIO/)SSL_accept               => ossl_quic_accept
1187  *
1188  */
1189
1190 QUIC_NEEDS_LOCK
1191 static void qc_shutdown_flush_init(QUIC_CONNECTION *qc)
1192 {
1193     QUIC_STREAM_MAP *qsm;
1194
1195     if (qc->shutting_down)
1196         return;
1197
1198     qsm = ossl_quic_channel_get_qsm(qc->ch);
1199
1200     ossl_quic_stream_map_begin_shutdown_flush(qsm);
1201     qc->shutting_down = 1;
1202 }
1203
1204 /* Returns 1 if all shutdown-flush streams have been done with. */
1205 QUIC_NEEDS_LOCK
1206 static int qc_shutdown_flush_finished(QUIC_CONNECTION *qc)
1207 {
1208     QUIC_STREAM_MAP *qsm = ossl_quic_channel_get_qsm(qc->ch);
1209
1210     return qc->shutting_down
1211         && ossl_quic_stream_map_is_shutdown_flush_finished(qsm);
1212 }
1213
1214 /* SSL_shutdown */
1215 static int quic_shutdown_wait(void *arg)
1216 {
1217     QUIC_CONNECTION *qc = arg;
1218
1219     return ossl_quic_channel_is_terminated(qc->ch);
1220 }
1221
1222 /* Returns 1 if shutdown flush process has finished or is inapplicable. */
1223 static int quic_shutdown_flush_wait(void *arg)
1224 {
1225     QUIC_CONNECTION *qc = arg;
1226
1227     return ossl_quic_channel_is_term_any(qc->ch)
1228         || qc_shutdown_flush_finished(qc);
1229 }
1230
1231 static int quic_shutdown_peer_wait(void *arg)
1232 {
1233     QUIC_CONNECTION *qc = arg;
1234     return ossl_quic_channel_is_term_any(qc->ch);
1235 }
1236
1237 QUIC_TAKES_LOCK
1238 int ossl_quic_conn_shutdown(SSL *s, uint64_t flags,
1239                             const SSL_SHUTDOWN_EX_ARGS *args,
1240                             size_t args_len)
1241 {
1242     int ret;
1243     QCTX ctx;
1244     int stream_flush = ((flags & SSL_SHUTDOWN_FLAG_NO_STREAM_FLUSH) == 0);
1245     int no_block = ((flags & SSL_SHUTDOWN_FLAG_NO_BLOCK) != 0);
1246     int wait_peer = ((flags & SSL_SHUTDOWN_FLAG_WAIT_PEER) != 0);
1247
1248     if (!expect_quic(s, &ctx))
1249         return -1;
1250
1251     if (ctx.is_stream) {
1252         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_CONN_USE_ONLY, NULL);
1253         return -1;
1254     }
1255
1256     quic_lock(ctx.qc);
1257
1258     if (ossl_quic_channel_is_terminated(ctx.qc->ch)) {
1259         quic_unlock(ctx.qc);
1260         return 1;
1261     }
1262
1263     /* Phase 1: Stream Flushing */
1264     if (!wait_peer && stream_flush) {
1265         qc_shutdown_flush_init(ctx.qc);
1266
1267         if (!qc_shutdown_flush_finished(ctx.qc)) {
1268             if (!no_block && qc_blocking_mode(ctx.qc)) {
1269                 ret = block_until_pred(ctx.qc, quic_shutdown_flush_wait, ctx.qc, 0);
1270                 if (ret < 1) {
1271                     ret = 0;
1272                     goto err;
1273                 }
1274             } else {
1275                 qctx_maybe_autotick(&ctx);
1276             }
1277         }
1278
1279         if (!qc_shutdown_flush_finished(ctx.qc)) {
1280             quic_unlock(ctx.qc);
1281             return 0; /* ongoing */
1282         }
1283     }
1284
1285     /* Phase 2: Connection Closure */
1286     if (wait_peer && !ossl_quic_channel_is_term_any(ctx.qc->ch)) {
1287         if (!no_block && qc_blocking_mode(ctx.qc)) {
1288             ret = block_until_pred(ctx.qc, quic_shutdown_peer_wait, ctx.qc, 0);
1289             if (ret < 1) {
1290                 ret = 0;
1291                 goto err;
1292             }
1293         } else {
1294             qctx_maybe_autotick(&ctx);
1295         }
1296
1297         if (!ossl_quic_channel_is_term_any(ctx.qc->ch)) {
1298             ret = 0; /* peer hasn't closed yet - still not done */
1299             goto err;
1300         }
1301
1302         /*
1303          * We are at least terminating - go through the normal process of
1304          * waiting until we are in the TERMINATED state.
1305          */
1306     }
1307
1308     /* Block mutation ops regardless of if we did stream flush. */
1309     ctx.qc->shutting_down = 1;
1310
1311     /*
1312      * This call is a no-op if we are already terminating, so it doesn't
1313      * affect the wait_peer case.
1314      */
1315     ossl_quic_channel_local_close(ctx.qc->ch,
1316                                   args != NULL ? args->quic_error_code : 0,
1317                                   args != NULL ? args->quic_reason : NULL);
1318
1319     SSL_set_shutdown(ctx.qc->tls, SSL_SENT_SHUTDOWN);
1320
1321     if (ossl_quic_channel_is_terminated(ctx.qc->ch)) {
1322         quic_unlock(ctx.qc);
1323         return 1;
1324     }
1325
1326     /* Phase 3: Terminating Wait Time */
1327     if (!no_block && qc_blocking_mode(ctx.qc)
1328         && (flags & SSL_SHUTDOWN_FLAG_RAPID) == 0) {
1329         ret = block_until_pred(ctx.qc, quic_shutdown_wait, ctx.qc, 0);
1330         if (ret < 1) {
1331             ret = 0;
1332             goto err;
1333         }
1334     } else {
1335         qctx_maybe_autotick(&ctx);
1336     }
1337
1338     ret = ossl_quic_channel_is_terminated(ctx.qc->ch);
1339 err:
1340     quic_unlock(ctx.qc);
1341     return ret;
1342 }
1343
1344 /* SSL_ctrl */
1345 long ossl_quic_ctrl(SSL *s, int cmd, long larg, void *parg)
1346 {
1347     QCTX ctx;
1348
1349     if (!expect_quic(s, &ctx))
1350         return 0;
1351
1352     switch (cmd) {
1353     case SSL_CTRL_MODE:
1354         /* If called on a QCSO, update the default mode. */
1355         if (!ctx.is_stream)
1356             ctx.qc->default_ssl_mode |= (uint32_t)larg;
1357
1358         /*
1359          * If we were called on a QSSO or have a default stream, we also update
1360          * that.
1361          */
1362         if (ctx.xso != NULL) {
1363             /* Cannot enable EPW while AON write in progress. */
1364             if (ctx.xso->aon_write_in_progress)
1365                 larg &= ~SSL_MODE_ENABLE_PARTIAL_WRITE;
1366
1367             ctx.xso->ssl_mode |= (uint32_t)larg;
1368             return ctx.xso->ssl_mode;
1369         }
1370
1371         return ctx.qc->default_ssl_mode;
1372     case SSL_CTRL_CLEAR_MODE:
1373         if (!ctx.is_stream)
1374             ctx.qc->default_ssl_mode &= ~(uint32_t)larg;
1375
1376         if (ctx.xso != NULL) {
1377             ctx.xso->ssl_mode &= ~(uint32_t)larg;
1378             return ctx.xso->ssl_mode;
1379         }
1380
1381         return ctx.qc->default_ssl_mode;
1382
1383     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1384         ossl_quic_channel_set_msg_callback_arg(ctx.qc->ch, parg);
1385         /* This ctrl also needs to be passed to the internal SSL object */
1386         return SSL_ctrl(ctx.qc->tls, cmd, larg, parg);
1387
1388     case DTLS_CTRL_GET_TIMEOUT: /* DTLSv1_get_timeout */
1389         {
1390             int is_infinite;
1391
1392             if (!ossl_quic_get_event_timeout(s, parg, &is_infinite))
1393                 return 0;
1394
1395             return !is_infinite;
1396         }
1397     case DTLS_CTRL_HANDLE_TIMEOUT: /* DTLSv1_handle_timeout */
1398         /* For legacy compatibility with DTLS calls. */
1399         return ossl_quic_handle_events(s) == 1 ? 1 : -1;
1400
1401         /* Mask ctrls we shouldn't support for QUIC. */
1402     case SSL_CTRL_GET_READ_AHEAD:
1403     case SSL_CTRL_SET_READ_AHEAD:
1404     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1405     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
1406     case SSL_CTRL_SET_MAX_PIPELINES:
1407         return 0;
1408
1409     default:
1410         /*
1411          * Probably a TLS related ctrl. Send back to the frontend SSL_ctrl
1412          * implementation. Either SSL_ctrl will handle it itself by direct
1413          * access into handshake layer state, or failing that, it will be passed
1414          * to the handshake layer via the SSL_METHOD vtable. If the ctrl is not
1415          * supported by anything, the handshake layer's ctrl method will finally
1416          * return 0.
1417          */
1418         return ossl_ctrl_internal(&ctx.qc->ssl, cmd, larg, parg, /*no_quic=*/1);
1419     }
1420 }
1421
1422 /* SSL_set_connect_state */
1423 void ossl_quic_set_connect_state(SSL *s)
1424 {
1425     QCTX ctx;
1426
1427     if (!expect_quic(s, &ctx))
1428         return;
1429
1430     /* Cannot be changed after handshake started */
1431     if (ctx.qc->started || ctx.is_stream)
1432         return;
1433
1434     ctx.qc->as_server_state = 0;
1435 }
1436
1437 /* SSL_set_accept_state */
1438 void ossl_quic_set_accept_state(SSL *s)
1439 {
1440     QCTX ctx;
1441
1442     if (!expect_quic(s, &ctx))
1443         return;
1444
1445     /* Cannot be changed after handshake started */
1446     if (ctx.qc->started || ctx.is_stream)
1447         return;
1448
1449     ctx.qc->as_server_state = 1;
1450 }
1451
1452 /* SSL_do_handshake */
1453 struct quic_handshake_wait_args {
1454     QUIC_CONNECTION     *qc;
1455 };
1456
1457 static int tls_wants_non_io_retry(QUIC_CONNECTION *qc)
1458 {
1459     int want = SSL_want(qc->tls);
1460
1461     if (want == SSL_X509_LOOKUP
1462             || want == SSL_CLIENT_HELLO_CB
1463             || want == SSL_RETRY_VERIFY)
1464         return 1;
1465
1466     return 0;
1467 }
1468
1469 static int quic_handshake_wait(void *arg)
1470 {
1471     struct quic_handshake_wait_args *args = arg;
1472
1473     if (!quic_mutation_allowed(args->qc, /*req_active=*/1))
1474         return -1;
1475
1476     if (ossl_quic_channel_is_handshake_complete(args->qc->ch))
1477         return 1;
1478
1479     if (tls_wants_non_io_retry(args->qc))
1480         return 1;
1481
1482     return 0;
1483 }
1484
1485 static int configure_channel(QUIC_CONNECTION *qc)
1486 {
1487     assert(qc->ch != NULL);
1488
1489     if (!ossl_quic_port_set_net_rbio(qc->port, qc->net_rbio)
1490         || !ossl_quic_port_set_net_wbio(qc->port, qc->net_wbio)
1491         || !ossl_quic_channel_set_peer_addr(qc->ch, &qc->init_peer_addr))
1492         return 0;
1493
1494     return 1;
1495 }
1496
1497 QUIC_NEEDS_LOCK
1498 static int create_channel(QUIC_CONNECTION *qc)
1499 {
1500     QUIC_ENGINE_ARGS engine_args = {0};
1501     QUIC_PORT_ARGS port_args = {0};
1502
1503     engine_args.libctx        = qc->ssl.ctx->libctx;
1504     engine_args.propq         = qc->ssl.ctx->propq;
1505     engine_args.mutex         = qc->mutex;
1506     engine_args.now_cb        = get_time_cb;
1507     engine_args.now_cb_arg    = qc;
1508     qc->engine = ossl_quic_engine_new(&engine_args);
1509     if (qc->engine == NULL) {
1510         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
1511         return 0;
1512     }
1513
1514     port_args.channel_ctx = qc->ssl.ctx;
1515     qc->port = ossl_quic_engine_create_port(qc->engine, &port_args);
1516     if (qc->port == NULL) {
1517         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
1518         ossl_quic_engine_free(qc->engine);
1519         return 0;
1520     }
1521
1522     qc->ch = ossl_quic_port_create_outgoing(qc->port, qc->tls);
1523     if (qc->ch == NULL) {
1524         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
1525         ossl_quic_port_free(qc->port);
1526         ossl_quic_engine_free(qc->engine);
1527         return 0;
1528     }
1529
1530     return 1;
1531 }
1532
1533 /*
1534  * Configures a channel with the information we have accumulated via calls made
1535  * to us from the application prior to starting a handshake attempt.
1536  */
1537 QUIC_NEEDS_LOCK
1538 static int ensure_channel_started(QCTX *ctx)
1539 {
1540     QUIC_CONNECTION *qc = ctx->qc;
1541
1542     if (!qc->started) {
1543         if (!configure_channel(qc)) {
1544             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
1545                                         "failed to configure channel");
1546             return 0;
1547         }
1548
1549         if (!ossl_quic_channel_start(qc->ch)) {
1550             ossl_quic_channel_restore_err_state(qc->ch);
1551             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
1552                                         "failed to start channel");
1553             return 0;
1554         }
1555
1556 #if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)
1557         if (qc->is_thread_assisted)
1558             if (!ossl_quic_thread_assist_init_start(&qc->thread_assist, qc->ch,
1559                                                     qc->override_now_cb,
1560                                                     qc->override_now_cb_arg)) {
1561                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
1562                                             "failed to start assist thread");
1563                 return 0;
1564             }
1565 #endif
1566     }
1567
1568     qc->started = 1;
1569     return 1;
1570 }
1571
1572 QUIC_NEEDS_LOCK
1573 static int quic_do_handshake(QCTX *ctx)
1574 {
1575     int ret;
1576     QUIC_CONNECTION *qc = ctx->qc;
1577
1578     if (ossl_quic_channel_is_handshake_complete(qc->ch))
1579         /* Handshake already completed. */
1580         return 1;
1581
1582     if (!quic_mutation_allowed(qc, /*req_active=*/0))
1583         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
1584
1585     if (qc->as_server != qc->as_server_state) {
1586         QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_PASSED_INVALID_ARGUMENT, NULL);
1587         return -1; /* Non-protocol error */
1588     }
1589
1590     if (qc->net_rbio == NULL || qc->net_wbio == NULL) {
1591         /* Need read and write BIOs. */
1592         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_BIO_NOT_SET, NULL);
1593         return -1; /* Non-protocol error */
1594     }
1595
1596     /*
1597      * We need to determine our addressing mode. There are basically two
1598      * ways we can use L4 addresses:
1599      *
1600      *   - Addressed mode, in which our BIO_sendmmsg calls have destination
1601      *     addresses attached to them which we expect the underlying network BIO
1602      *     to handle;
1603      *
1604      *   - Unaddressed mode, in which the BIO provided to us on the
1605      *     network side neither provides us with L4 addresses nor is capable of
1606      *     honouring ones we provide. We don't know where the QUIC traffic we
1607      *     send ends up exactly and trust the application to know what it is
1608      *     doing.
1609      *
1610      * Addressed mode is preferred because it enables support for connection
1611      * migration, multipath, etc. in the future. Addressed mode is automatically
1612      * enabled if we are using e.g. BIO_s_datagram, with or without
1613      * BIO_s_connect.
1614      *
1615      * If we are passed a BIO_s_dgram_pair (or some custom BIO) we may have to
1616      * use unaddressed mode unless that BIO supports capability flags indicating
1617      * it can provide and honour L4 addresses.
1618      *
1619      * Our strategy for determining address mode is simple: we probe the
1620      * underlying network BIOs for their capabilities. If the network BIOs
1621      * support what we need, we use addressed mode. Otherwise, we use
1622      * unaddressed mode.
1623      *
1624      * If addressed mode is chosen, we require an initial peer address to be
1625      * set. If this is not set, we fail. If unaddressed mode is used, we do not
1626      * require this, as such an address is superfluous, though it can be set if
1627      * desired.
1628      */
1629     if (!qc->started && !qc->addressing_probe_done) {
1630         long rcaps = BIO_dgram_get_effective_caps(qc->net_rbio);
1631         long wcaps = BIO_dgram_get_effective_caps(qc->net_wbio);
1632
1633         qc->addressed_mode_r = ((rcaps & BIO_DGRAM_CAP_PROVIDES_SRC_ADDR) != 0);
1634         qc->addressed_mode_w = ((wcaps & BIO_DGRAM_CAP_HANDLES_DST_ADDR) != 0);
1635         qc->addressing_probe_done = 1;
1636     }
1637
1638     if (!qc->started && qc->addressed_mode_w
1639         && BIO_ADDR_family(&qc->init_peer_addr) == AF_UNSPEC) {
1640         /*
1641          * We are trying to connect and are using addressed mode, which means we
1642          * need an initial peer address; if we do not have a peer address yet,
1643          * we should try to autodetect one.
1644          *
1645          * We do this as late as possible because some BIOs (e.g. BIO_s_connect)
1646          * may not be able to provide us with a peer address until they have
1647          * finished their own processing. They may not be able to perform this
1648          * processing until an application has finished configuring that BIO
1649          * (e.g. with setter calls), which might happen after SSL_set_bio is
1650          * called.
1651          */
1652         if (!csm_analyse_init_peer_addr(qc->net_wbio, &qc->init_peer_addr))
1653             /* best effort */
1654             BIO_ADDR_clear(&qc->init_peer_addr);
1655         else
1656             ossl_quic_channel_set_peer_addr(qc->ch, &qc->init_peer_addr);
1657     }
1658
1659     if (!qc->started
1660         && qc->addressed_mode_w
1661         && BIO_ADDR_family(&qc->init_peer_addr) == AF_UNSPEC) {
1662         /*
1663          * If we still don't have a peer address in addressed mode, we can't do
1664          * anything.
1665          */
1666         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_REMOTE_PEER_ADDRESS_NOT_SET, NULL);
1667         return -1; /* Non-protocol error */
1668     }
1669
1670     /*
1671      * Start connection process. Note we may come here multiple times in
1672      * non-blocking mode, which is fine.
1673      */
1674     if (!ensure_channel_started(ctx)) /* raises on failure */
1675         return -1; /* Non-protocol error */
1676
1677     if (ossl_quic_channel_is_handshake_complete(qc->ch))
1678         /* The handshake is now done. */
1679         return 1;
1680
1681     if (!qc_blocking_mode(qc)) {
1682         /* Try to advance the reactor. */
1683         qctx_maybe_autotick(ctx);
1684
1685         if (ossl_quic_channel_is_handshake_complete(qc->ch))
1686             /* The handshake is now done. */
1687             return 1;
1688
1689         if (ossl_quic_channel_is_term_any(qc->ch)) {
1690             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
1691             return 0;
1692         } else if (qc->desires_blocking) {
1693             /*
1694              * As a special case when doing a handshake when blocking mode is
1695              * desired yet not available, see if the network BIOs have become
1696              * poll descriptor-enabled. This supports BIOs such as BIO_s_connect
1697              * which do late creation of socket FDs and therefore cannot expose
1698              * a poll descriptor until after a network BIO is set on the QCSO.
1699              */
1700             assert(!qc->blocking);
1701             qc_update_can_support_blocking(qc);
1702             qc_update_blocking_mode(qc);
1703         }
1704     }
1705
1706     /*
1707      * We are either in blocking mode or just entered it due to the code above.
1708      */
1709     if (qc_blocking_mode(qc)) {
1710         /* In blocking mode, wait for the handshake to complete. */
1711         struct quic_handshake_wait_args args;
1712
1713         args.qc     = qc;
1714
1715         ret = block_until_pred(qc, quic_handshake_wait, &args, 0);
1716         if (!quic_mutation_allowed(qc, /*req_active=*/1)) {
1717             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
1718             return 0; /* Shutdown before completion */
1719         } else if (ret <= 0) {
1720             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
1721             return -1; /* Non-protocol error */
1722         }
1723
1724         if (tls_wants_non_io_retry(qc)) {
1725             QUIC_RAISE_NORMAL_ERROR(ctx, SSL_get_error(qc->tls, 0));
1726             return -1;
1727         }
1728
1729         assert(ossl_quic_channel_is_handshake_complete(qc->ch));
1730         return 1;
1731     }
1732
1733     if (tls_wants_non_io_retry(qc)) {
1734         QUIC_RAISE_NORMAL_ERROR(ctx, SSL_get_error(qc->tls, 0));
1735         return -1;
1736     }
1737
1738     /*
1739      * Otherwise, indicate that the handshake isn't done yet.
1740      * We can only get here in non-blocking mode.
1741      */
1742     QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_WANT_READ);
1743     return -1; /* Non-protocol error */
1744 }
1745
1746 QUIC_TAKES_LOCK
1747 int ossl_quic_do_handshake(SSL *s)
1748 {
1749     int ret;
1750     QCTX ctx;
1751
1752     if (!expect_quic(s, &ctx))
1753         return 0;
1754
1755     quic_lock_for_io(&ctx);
1756
1757     ret = quic_do_handshake(&ctx);
1758     quic_unlock(ctx.qc);
1759     return ret;
1760 }
1761
1762 /* SSL_connect */
1763 int ossl_quic_connect(SSL *s)
1764 {
1765     /* Ensure we are in connect state (no-op if non-idle). */
1766     ossl_quic_set_connect_state(s);
1767
1768     /* Begin or continue the handshake */
1769     return ossl_quic_do_handshake(s);
1770 }
1771
1772 /* SSL_accept */
1773 int ossl_quic_accept(SSL *s)
1774 {
1775     /* Ensure we are in accept state (no-op if non-idle). */
1776     ossl_quic_set_accept_state(s);
1777
1778     /* Begin or continue the handshake */
1779     return ossl_quic_do_handshake(s);
1780 }
1781
1782 /*
1783  * QUIC Front-End I/O API: Stream Lifecycle Operations
1784  * ===================================================
1785  *
1786  *         SSL_stream_new       => ossl_quic_conn_stream_new
1787  *
1788  */
1789
1790 /*
1791  * Try to create the default XSO if it doesn't already exist. Returns 1 if the
1792  * default XSO was created. Returns 0 if it was not (e.g. because it already
1793  * exists). Note that this is NOT an error condition.
1794  */
1795 QUIC_NEEDS_LOCK
1796 static int qc_try_create_default_xso_for_write(QCTX *ctx)
1797 {
1798     uint64_t flags = 0;
1799     QUIC_CONNECTION *qc = ctx->qc;
1800
1801     if (qc->default_xso_created
1802         || qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
1803         /*
1804          * We only do this once. If the user detaches a previously created
1805          * default XSO we don't auto-create another one.
1806          */
1807         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_NO_STREAM, NULL);
1808
1809     /* Create a locally-initiated stream. */
1810     if (qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_AUTO_UNI)
1811         flags |= SSL_STREAM_FLAG_UNI;
1812
1813     qc_set_default_xso(qc, (QUIC_XSO *)quic_conn_stream_new(ctx, flags,
1814                                                             /*needs_lock=*/0),
1815                        /*touch=*/0);
1816     if (qc->default_xso == NULL)
1817         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
1818
1819     qc_touch_default_xso(qc);
1820     return 1;
1821 }
1822
1823 struct quic_wait_for_stream_args {
1824     QUIC_CONNECTION *qc;
1825     QUIC_STREAM     *qs;
1826     QCTX            *ctx;
1827     uint64_t        expect_id;
1828 };
1829
1830 QUIC_NEEDS_LOCK
1831 static int quic_wait_for_stream(void *arg)
1832 {
1833     struct quic_wait_for_stream_args *args = arg;
1834
1835     if (!quic_mutation_allowed(args->qc, /*req_active=*/1)) {
1836         /* If connection is torn down due to an error while blocking, stop. */
1837         QUIC_RAISE_NON_NORMAL_ERROR(args->ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
1838         return -1;
1839     }
1840
1841     args->qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(args->qc->ch),
1842                                               args->expect_id | QUIC_STREAM_DIR_BIDI);
1843     if (args->qs == NULL)
1844         args->qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(args->qc->ch),
1845                                                   args->expect_id | QUIC_STREAM_DIR_UNI);
1846
1847     if (args->qs != NULL)
1848         return 1; /* stream now exists */
1849
1850     return 0; /* did not get a stream, keep trying */
1851 }
1852
1853 QUIC_NEEDS_LOCK
1854 static int qc_wait_for_default_xso_for_read(QCTX *ctx)
1855 {
1856     /* Called on a QCSO and we don't currently have a default stream. */
1857     uint64_t expect_id;
1858     QUIC_CONNECTION *qc = ctx->qc;
1859     QUIC_STREAM *qs;
1860     int res;
1861     struct quic_wait_for_stream_args wargs;
1862     OSSL_RTT_INFO rtt_info;
1863
1864     /*
1865      * If default stream functionality is disabled or we already detached
1866      * one, don't make another default stream and just fail.
1867      */
1868     if (qc->default_xso_created
1869         || qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
1870         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_NO_STREAM, NULL);
1871
1872     /*
1873      * The peer may have opened a stream since we last ticked. So tick and
1874      * see if the stream with ordinal 0 (remote, bidi/uni based on stream
1875      * mode) exists yet. QUIC stream IDs must be allocated in order, so the
1876      * first stream created by a peer must have an ordinal of 0.
1877      */
1878     expect_id = qc->as_server
1879         ? QUIC_STREAM_INITIATOR_CLIENT
1880         : QUIC_STREAM_INITIATOR_SERVER;
1881
1882     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
1883                                         expect_id | QUIC_STREAM_DIR_BIDI);
1884     if (qs == NULL)
1885         qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
1886                                             expect_id | QUIC_STREAM_DIR_UNI);
1887
1888     if (qs == NULL) {
1889         qctx_maybe_autotick(ctx);
1890
1891         qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
1892                                             expect_id);
1893     }
1894
1895     if (qs == NULL) {
1896         if (!qc_blocking_mode(qc))
1897             /* Non-blocking mode, so just bail immediately. */
1898             return QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_WANT_READ);
1899
1900         /* Block until we have a stream. */
1901         wargs.qc        = qc;
1902         wargs.qs        = NULL;
1903         wargs.ctx       = ctx;
1904         wargs.expect_id = expect_id;
1905
1906         res = block_until_pred(qc, quic_wait_for_stream, &wargs, 0);
1907         if (res == 0)
1908             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
1909         else if (res < 0 || wargs.qs == NULL)
1910             /* quic_wait_for_stream raised error here */
1911             return 0;
1912
1913         qs = wargs.qs;
1914     }
1915
1916     /*
1917      * We now have qs != NULL. Remove it from the incoming stream queue so that
1918      * it isn't also returned by any future SSL_accept_stream calls.
1919      */
1920     ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(qc->ch), &rtt_info);
1921     ossl_quic_stream_map_remove_from_accept_queue(ossl_quic_channel_get_qsm(qc->ch),
1922                                                   qs, rtt_info.smoothed_rtt);
1923
1924     /*
1925      * Now make qs the default stream, creating the necessary XSO.
1926      */
1927     qc_set_default_xso(qc, create_xso_from_stream(qc, qs), /*touch=*/0);
1928     if (qc->default_xso == NULL)
1929         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
1930
1931     qc_touch_default_xso(qc); /* inhibits default XSO */
1932     return 1;
1933 }
1934
1935 QUIC_NEEDS_LOCK
1936 static QUIC_XSO *create_xso_from_stream(QUIC_CONNECTION *qc, QUIC_STREAM *qs)
1937 {
1938     QUIC_XSO *xso = NULL;
1939
1940     if ((xso = OPENSSL_zalloc(sizeof(*xso))) == NULL) {
1941         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_CRYPTO_LIB, NULL);
1942         goto err;
1943     }
1944
1945     if (!ossl_ssl_init(&xso->ssl, qc->ssl.ctx, qc->ssl.method, SSL_TYPE_QUIC_XSO)) {
1946         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
1947         goto err;
1948     }
1949
1950     /* XSO refs QC */
1951     if (!SSL_up_ref(&qc->ssl)) {
1952         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_SSL_LIB, NULL);
1953         goto err;
1954     }
1955
1956     xso->conn       = qc;
1957     xso->ssl_mode   = qc->default_ssl_mode;
1958     xso->ssl_options
1959         = qc->default_ssl_options & OSSL_QUIC_PERMITTED_OPTIONS_STREAM;
1960     xso->last_error = SSL_ERROR_NONE;
1961
1962     xso->stream     = qs;
1963
1964     ++qc->num_xso;
1965     xso_update_options(xso);
1966     return xso;
1967
1968 err:
1969     OPENSSL_free(xso);
1970     return NULL;
1971 }
1972
1973 struct quic_new_stream_wait_args {
1974     QUIC_CONNECTION *qc;
1975     int is_uni;
1976 };
1977
1978 static int quic_new_stream_wait(void *arg)
1979 {
1980     struct quic_new_stream_wait_args *args = arg;
1981     QUIC_CONNECTION *qc = args->qc;
1982
1983     if (!quic_mutation_allowed(qc, /*req_active=*/1))
1984         return -1;
1985
1986     if (ossl_quic_channel_is_new_local_stream_admissible(qc->ch, args->is_uni))
1987         return 1;
1988
1989     return 0;
1990 }
1991
1992 /* locking depends on need_lock */
1993 static SSL *quic_conn_stream_new(QCTX *ctx, uint64_t flags, int need_lock)
1994 {
1995     int ret;
1996     QUIC_CONNECTION *qc = ctx->qc;
1997     QUIC_XSO *xso = NULL;
1998     QUIC_STREAM *qs = NULL;
1999     int is_uni = ((flags & SSL_STREAM_FLAG_UNI) != 0);
2000     int no_blocking = ((flags & SSL_STREAM_FLAG_NO_BLOCK) != 0);
2001     int advance = ((flags & SSL_STREAM_FLAG_ADVANCE) != 0);
2002
2003     if (need_lock)
2004         quic_lock(qc);
2005
2006     if (!quic_mutation_allowed(qc, /*req_active=*/0)) {
2007         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2008         goto err;
2009     }
2010
2011     if (!advance
2012         && !ossl_quic_channel_is_new_local_stream_admissible(qc->ch, is_uni)) {
2013         struct quic_new_stream_wait_args args;
2014
2015         /*
2016          * Stream count flow control currently doesn't permit this stream to be
2017          * opened.
2018          */
2019         if (no_blocking || !qc_blocking_mode(qc)) {
2020             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_STREAM_COUNT_LIMITED, NULL);
2021             goto err;
2022         }
2023
2024         args.qc     = qc;
2025         args.is_uni = is_uni;
2026
2027         /* Blocking mode - wait until we can get a stream. */
2028         ret = block_until_pred(ctx->qc, quic_new_stream_wait, &args, 0);
2029         if (!quic_mutation_allowed(qc, /*req_active=*/1)) {
2030             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2031             goto err; /* Shutdown before completion */
2032         } else if (ret <= 0) {
2033             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2034             goto err; /* Non-protocol error */
2035         }
2036     }
2037
2038     qs = ossl_quic_channel_new_stream_local(qc->ch, is_uni);
2039     if (qs == NULL) {
2040         QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2041         goto err;
2042     }
2043
2044     xso = create_xso_from_stream(qc, qs);
2045     if (xso == NULL)
2046         goto err;
2047
2048     qc_touch_default_xso(qc); /* inhibits default XSO */
2049     if (need_lock)
2050         quic_unlock(qc);
2051
2052     return &xso->ssl;
2053
2054 err:
2055     OPENSSL_free(xso);
2056     ossl_quic_stream_map_release(ossl_quic_channel_get_qsm(qc->ch), qs);
2057     if (need_lock)
2058         quic_unlock(qc);
2059
2060     return NULL;
2061
2062 }
2063
2064 QUIC_TAKES_LOCK
2065 SSL *ossl_quic_conn_stream_new(SSL *s, uint64_t flags)
2066 {
2067     QCTX ctx;
2068
2069     if (!expect_quic_conn_only(s, &ctx))
2070         return NULL;
2071
2072     return quic_conn_stream_new(&ctx, flags, /*need_lock=*/1);
2073 }
2074
2075 /*
2076  * QUIC Front-End I/O API: Steady-State Operations
2077  * ===============================================
2078  *
2079  * Here we dispatch calls to the steady-state front-end I/O API functions; that
2080  * is, the functions used during the established phase of a QUIC connection
2081  * (e.g. SSL_read, SSL_write).
2082  *
2083  * Each function must handle both blocking and non-blocking modes. As discussed
2084  * above, all QUIC I/O is implemented using non-blocking mode internally.
2085  *
2086  *         SSL_get_error        => partially implemented by ossl_quic_get_error
2087  *         SSL_want             => ossl_quic_want
2088  *   (BIO/)SSL_read             => ossl_quic_read
2089  *   (BIO/)SSL_write            => ossl_quic_write
2090  *         SSL_pending          => ossl_quic_pending
2091  *         SSL_stream_conclude  => ossl_quic_conn_stream_conclude
2092  *         SSL_key_update       => ossl_quic_key_update
2093  */
2094
2095 /* SSL_get_error */
2096 int ossl_quic_get_error(const SSL *s, int i)
2097 {
2098     QCTX ctx;
2099     int net_error, last_error;
2100
2101     if (!expect_quic(s, &ctx))
2102         return 0;
2103
2104     quic_lock(ctx.qc);
2105     net_error = ossl_quic_channel_net_error(ctx.qc->ch);
2106     last_error = ctx.is_stream ? ctx.xso->last_error : ctx.qc->last_error;
2107     quic_unlock(ctx.qc);
2108
2109     if (net_error)
2110         return SSL_ERROR_SYSCALL;
2111
2112     return last_error;
2113 }
2114
2115 /* Converts a code returned by SSL_get_error to a code returned by SSL_want. */
2116 static int error_to_want(int error)
2117 {
2118     switch (error) {
2119     case SSL_ERROR_WANT_CONNECT: /* never used - UDP is connectionless */
2120     case SSL_ERROR_WANT_ACCEPT:  /* never used - UDP is connectionless */
2121     case SSL_ERROR_ZERO_RETURN:
2122     default:
2123         return SSL_NOTHING;
2124
2125     case SSL_ERROR_WANT_READ:
2126         return SSL_READING;
2127
2128     case SSL_ERROR_WANT_WRITE:
2129         return SSL_WRITING;
2130
2131     case SSL_ERROR_WANT_RETRY_VERIFY:
2132         return SSL_RETRY_VERIFY;
2133
2134     case SSL_ERROR_WANT_CLIENT_HELLO_CB:
2135         return SSL_CLIENT_HELLO_CB;
2136
2137     case SSL_ERROR_WANT_X509_LOOKUP:
2138         return SSL_X509_LOOKUP;
2139     }
2140 }
2141
2142 /* SSL_want */
2143 int ossl_quic_want(const SSL *s)
2144 {
2145     QCTX ctx;
2146     int w;
2147
2148     if (!expect_quic(s, &ctx))
2149         return SSL_NOTHING;
2150
2151     quic_lock(ctx.qc);
2152
2153     w = error_to_want(ctx.is_stream ? ctx.xso->last_error : ctx.qc->last_error);
2154
2155     quic_unlock(ctx.qc);
2156     return w;
2157 }
2158
2159 /*
2160  * SSL_write
2161  * ---------
2162  *
2163  * The set of functions below provide the implementation of the public SSL_write
2164  * function. We must handle:
2165  *
2166  *   - both blocking and non-blocking operation at the application level,
2167  *     depending on how we are configured;
2168  *
2169  *   - SSL_MODE_ENABLE_PARTIAL_WRITE being on or off;
2170  *
2171  *   - SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER.
2172  *
2173  */
2174 QUIC_NEEDS_LOCK
2175 static void quic_post_write(QUIC_XSO *xso, int did_append,
2176                             int did_append_all, uint64_t flags,
2177                             int do_tick)
2178 {
2179     /*
2180      * We have appended at least one byte to the stream.
2181      * Potentially mark stream as active, depending on FC.
2182      */
2183     if (did_append)
2184         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(xso->conn->ch),
2185                                           xso->stream);
2186
2187     if (did_append_all && (flags & SSL_WRITE_FLAG_CONCLUDE) != 0)
2188         ossl_quic_sstream_fin(xso->stream->sstream);
2189
2190     /*
2191      * Try and send.
2192      *
2193      * TODO(QUIC FUTURE): It is probably inefficient to try and do this
2194      * immediately, plus we should eventually consider Nagle's algorithm.
2195      */
2196     if (do_tick)
2197         ossl_quic_reactor_tick(ossl_quic_channel_get_reactor(xso->conn->ch), 0);
2198 }
2199
2200 struct quic_write_again_args {
2201     QUIC_XSO            *xso;
2202     const unsigned char *buf;
2203     size_t              len;
2204     size_t              total_written;
2205     int                 err;
2206     uint64_t            flags;
2207 };
2208
2209 /*
2210  * Absolute maximum write buffer size, enforced to prevent a rogue peer from
2211  * deliberately inducing DoS. This has been chosen based on the optimal buffer
2212  * size for an RTT of 500ms and a bandwidth of 100 Mb/s.
2213  */
2214 #define MAX_WRITE_BUF_SIZE      (6 * 1024 * 1024)
2215
2216 /*
2217  * Ensure spare buffer space available (up until a limit, at least).
2218  */
2219 QUIC_NEEDS_LOCK
2220 static int sstream_ensure_spare(QUIC_SSTREAM *sstream, uint64_t spare)
2221 {
2222     size_t cur_sz = ossl_quic_sstream_get_buffer_size(sstream);
2223     size_t avail = ossl_quic_sstream_get_buffer_avail(sstream);
2224     size_t spare_ = (spare > SIZE_MAX) ? SIZE_MAX : (size_t)spare;
2225     size_t new_sz, growth;
2226
2227     if (spare_ <= avail || cur_sz == MAX_WRITE_BUF_SIZE)
2228         return 1;
2229
2230     growth = spare_ - avail;
2231     if (cur_sz + growth > MAX_WRITE_BUF_SIZE)
2232         new_sz = MAX_WRITE_BUF_SIZE;
2233     else
2234         new_sz = cur_sz + growth;
2235
2236     return ossl_quic_sstream_set_buffer_size(sstream, new_sz);
2237 }
2238
2239 /*
2240  * Append to a QUIC_STREAM's QUIC_SSTREAM, ensuring buffer space is expanded
2241  * as needed according to flow control.
2242  */
2243 QUIC_NEEDS_LOCK
2244 static int xso_sstream_append(QUIC_XSO *xso, const unsigned char *buf,
2245                               size_t len, size_t *actual_written)
2246 {
2247     QUIC_SSTREAM *sstream = xso->stream->sstream;
2248     uint64_t cur = ossl_quic_sstream_get_cur_size(sstream);
2249     uint64_t cwm = ossl_quic_txfc_get_cwm(&xso->stream->txfc);
2250     uint64_t permitted = (cwm >= cur ? cwm - cur : 0);
2251
2252     if (len > permitted)
2253         len = (size_t)permitted;
2254
2255     if (!sstream_ensure_spare(sstream, len))
2256         return 0;
2257
2258     return ossl_quic_sstream_append(sstream, buf, len, actual_written);
2259 }
2260
2261 QUIC_NEEDS_LOCK
2262 static int quic_write_again(void *arg)
2263 {
2264     struct quic_write_again_args *args = arg;
2265     size_t actual_written = 0;
2266
2267     if (!quic_mutation_allowed(args->xso->conn, /*req_active=*/1))
2268         /* If connection is torn down due to an error while blocking, stop. */
2269         return -2;
2270
2271     if (!quic_validate_for_write(args->xso, &args->err))
2272         /*
2273          * Stream may have become invalid for write due to connection events
2274          * while we blocked.
2275          */
2276         return -2;
2277
2278     args->err = ERR_R_INTERNAL_ERROR;
2279     if (!xso_sstream_append(args->xso, args->buf, args->len, &actual_written))
2280         return -2;
2281
2282     quic_post_write(args->xso, actual_written > 0,
2283                     args->len == actual_written, args->flags, 0);
2284
2285     args->buf           += actual_written;
2286     args->len           -= actual_written;
2287     args->total_written += actual_written;
2288
2289     if (args->len == 0)
2290         /* Written everything, done. */
2291         return 1;
2292
2293     /* Not written everything yet, keep trying. */
2294     return 0;
2295 }
2296
2297 QUIC_NEEDS_LOCK
2298 static int quic_write_blocking(QCTX *ctx, const void *buf, size_t len,
2299                                uint64_t flags, size_t *written)
2300 {
2301     int res;
2302     QUIC_XSO *xso = ctx->xso;
2303     struct quic_write_again_args args;
2304     size_t actual_written = 0;
2305
2306     /* First make a best effort to append as much of the data as possible. */
2307     if (!xso_sstream_append(xso, buf, len, &actual_written)) {
2308         /* Stream already finished or allocation error. */
2309         *written = 0;
2310         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2311     }
2312
2313     quic_post_write(xso, actual_written > 0, actual_written == len, flags, 1);
2314
2315     if (actual_written == len) {
2316         /* Managed to append everything on the first try. */
2317         *written = actual_written;
2318         return 1;
2319     }
2320
2321     /*
2322      * We did not manage to append all of the data immediately, so the stream
2323      * buffer has probably filled up. This means we need to block until some of
2324      * it is freed up.
2325      */
2326     args.xso            = xso;
2327     args.buf            = (const unsigned char *)buf + actual_written;
2328     args.len            = len - actual_written;
2329     args.total_written  = 0;
2330     args.err            = ERR_R_INTERNAL_ERROR;
2331     args.flags          = flags;
2332
2333     res = block_until_pred(xso->conn, quic_write_again, &args, 0);
2334     if (res <= 0) {
2335         if (!quic_mutation_allowed(xso->conn, /*req_active=*/1))
2336             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2337         else
2338             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, args.err, NULL);
2339     }
2340
2341     *written = args.total_written;
2342     return 1;
2343 }
2344
2345 /*
2346  * Functions to manage All-or-Nothing (AON) (that is, non-ENABLE_PARTIAL_WRITE)
2347  * write semantics.
2348  */
2349 static void aon_write_begin(QUIC_XSO *xso, const unsigned char *buf,
2350                             size_t buf_len, size_t already_sent)
2351 {
2352     assert(!xso->aon_write_in_progress);
2353
2354     xso->aon_write_in_progress = 1;
2355     xso->aon_buf_base          = buf;
2356     xso->aon_buf_pos           = already_sent;
2357     xso->aon_buf_len           = buf_len;
2358 }
2359
2360 static void aon_write_finish(QUIC_XSO *xso)
2361 {
2362     xso->aon_write_in_progress   = 0;
2363     xso->aon_buf_base            = NULL;
2364     xso->aon_buf_pos             = 0;
2365     xso->aon_buf_len             = 0;
2366 }
2367
2368 QUIC_NEEDS_LOCK
2369 static int quic_write_nonblocking_aon(QCTX *ctx, const void *buf,
2370                                       size_t len, uint64_t flags,
2371                                       size_t *written)
2372 {
2373     QUIC_XSO *xso = ctx->xso;
2374     const void *actual_buf;
2375     size_t actual_len, actual_written = 0;
2376     int accept_moving_buffer
2377         = ((xso->ssl_mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER) != 0);
2378
2379     if (xso->aon_write_in_progress) {
2380         /*
2381          * We are in the middle of an AON write (i.e., a previous write did not
2382          * manage to append all data to the SSTREAM and we have Enable Partial
2383          * Write (EPW) mode disabled.)
2384          */
2385         if ((!accept_moving_buffer && xso->aon_buf_base != buf)
2386             || len != xso->aon_buf_len)
2387             /*
2388              * Pointer must not have changed if we are not in accept moving
2389              * buffer mode. Length must never change.
2390              */
2391             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_BAD_WRITE_RETRY, NULL);
2392
2393         actual_buf = (unsigned char *)buf + xso->aon_buf_pos;
2394         actual_len = len - xso->aon_buf_pos;
2395         assert(actual_len > 0);
2396     } else {
2397         actual_buf = buf;
2398         actual_len = len;
2399     }
2400
2401     /* First make a best effort to append as much of the data as possible. */
2402     if (!xso_sstream_append(xso, actual_buf, actual_len, &actual_written)) {
2403         /* Stream already finished or allocation error. */
2404         *written = 0;
2405         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2406     }
2407
2408     quic_post_write(xso, actual_written > 0, actual_written == actual_len,
2409                     flags, qctx_should_autotick(ctx));
2410
2411     if (actual_written == actual_len) {
2412         /* We have sent everything. */
2413         if (xso->aon_write_in_progress) {
2414             /*
2415              * We have sent everything, and we were in the middle of an AON
2416              * write. The output write length is the total length of the AON
2417              * buffer, not however many bytes we managed to write to the stream
2418              * in this call.
2419              */
2420             *written = xso->aon_buf_len;
2421             aon_write_finish(xso);
2422         } else {
2423             *written = actual_written;
2424         }
2425
2426         return 1;
2427     }
2428
2429     if (xso->aon_write_in_progress) {
2430         /*
2431          * AON write is in progress but we have not written everything yet. We
2432          * may have managed to send zero bytes, or some number of bytes less
2433          * than the total remaining which need to be appended during this
2434          * AON operation.
2435          */
2436         xso->aon_buf_pos += actual_written;
2437         assert(xso->aon_buf_pos < xso->aon_buf_len);
2438         return QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_WANT_WRITE);
2439     }
2440
2441     /*
2442      * Not in an existing AON operation but partial write is not enabled, so we
2443      * need to begin a new AON operation. However we needn't bother if we didn't
2444      * actually append anything.
2445      */
2446     if (actual_written > 0)
2447         aon_write_begin(xso, buf, len, actual_written);
2448
2449     /*
2450      * AON - We do not publicly admit to having appended anything until AON
2451      * completes.
2452      */
2453     *written = 0;
2454     return QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_WANT_WRITE);
2455 }
2456
2457 QUIC_NEEDS_LOCK
2458 static int quic_write_nonblocking_epw(QCTX *ctx, const void *buf, size_t len,
2459                                       uint64_t flags, size_t *written)
2460 {
2461     QUIC_XSO *xso = ctx->xso;
2462
2463     /* Simple best effort operation. */
2464     if (!xso_sstream_append(xso, buf, len, written)) {
2465         /* Stream already finished or allocation error. */
2466         *written = 0;
2467         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2468     }
2469
2470     quic_post_write(xso, *written > 0, *written == len, flags,
2471                     qctx_should_autotick(ctx));
2472     return 1;
2473 }
2474
2475 QUIC_NEEDS_LOCK
2476 static int quic_validate_for_write(QUIC_XSO *xso, int *err)
2477 {
2478     QUIC_STREAM_MAP *qsm;
2479
2480     if (xso == NULL || xso->stream == NULL) {
2481         *err = ERR_R_INTERNAL_ERROR;
2482         return 0;
2483     }
2484
2485     switch (xso->stream->send_state) {
2486     default:
2487     case QUIC_SSTREAM_STATE_NONE:
2488         *err = SSL_R_STREAM_RECV_ONLY;
2489         return 0;
2490
2491     case QUIC_SSTREAM_STATE_READY:
2492         qsm = ossl_quic_channel_get_qsm(xso->conn->ch);
2493
2494         if (!ossl_quic_stream_map_ensure_send_part_id(qsm, xso->stream)) {
2495             *err = ERR_R_INTERNAL_ERROR;
2496             return 0;
2497         }
2498
2499         /* FALLTHROUGH */
2500     case QUIC_SSTREAM_STATE_SEND:
2501     case QUIC_SSTREAM_STATE_DATA_SENT:
2502     case QUIC_SSTREAM_STATE_DATA_RECVD:
2503         if (ossl_quic_sstream_get_final_size(xso->stream->sstream, NULL)) {
2504             *err = SSL_R_STREAM_FINISHED;
2505             return 0;
2506         }
2507
2508         return 1;
2509
2510     case QUIC_SSTREAM_STATE_RESET_SENT:
2511     case QUIC_SSTREAM_STATE_RESET_RECVD:
2512         *err = SSL_R_STREAM_RESET;
2513         return 0;
2514     }
2515 }
2516
2517 QUIC_TAKES_LOCK
2518 int ossl_quic_write_flags(SSL *s, const void *buf, size_t len,
2519                           uint64_t flags, size_t *written)
2520 {
2521     int ret;
2522     QCTX ctx;
2523     int partial_write, err;
2524
2525     *written = 0;
2526
2527     if (!expect_quic_with_stream_lock(s, /*remote_init=*/0, /*io=*/1, &ctx))
2528         return 0;
2529
2530     partial_write = ((ctx.xso->ssl_mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0);
2531
2532     if ((flags & ~SSL_WRITE_FLAG_CONCLUDE) != 0) {
2533         ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_UNSUPPORTED_WRITE_FLAG, NULL);
2534         goto out;
2535     }
2536
2537     if (!quic_mutation_allowed(ctx.qc, /*req_active=*/0)) {
2538         ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2539         goto out;
2540     }
2541
2542     /*
2543      * If we haven't finished the handshake, try to advance it.
2544      * We don't accept writes until the handshake is completed.
2545      */
2546     if (quic_do_handshake(&ctx) < 1) {
2547         ret = 0;
2548         goto out;
2549     }
2550
2551     /* Ensure correct stream state, stream send part not concluded, etc. */
2552     if (!quic_validate_for_write(ctx.xso, &err)) {
2553         ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, err, NULL);
2554         goto out;
2555     }
2556
2557     if (len == 0) {
2558         if ((flags & SSL_WRITE_FLAG_CONCLUDE) != 0)
2559             quic_post_write(ctx.xso, 0, 1, flags,
2560                             qctx_should_autotick(&ctx));
2561
2562         ret = 1;
2563         goto out;
2564     }
2565
2566     if (xso_blocking_mode(ctx.xso))
2567         ret = quic_write_blocking(&ctx, buf, len, flags, written);
2568     else if (partial_write)
2569         ret = quic_write_nonblocking_epw(&ctx, buf, len, flags, written);
2570     else
2571         ret = quic_write_nonblocking_aon(&ctx, buf, len, flags, written);
2572
2573 out:
2574     quic_unlock(ctx.qc);
2575     return ret;
2576 }
2577
2578 QUIC_TAKES_LOCK
2579 int ossl_quic_write(SSL *s, const void *buf, size_t len, size_t *written)
2580 {
2581     return ossl_quic_write_flags(s, buf, len, 0, written);
2582 }
2583
2584 /*
2585  * SSL_read
2586  * --------
2587  */
2588 struct quic_read_again_args {
2589     QCTX            *ctx;
2590     QUIC_STREAM     *stream;
2591     void            *buf;
2592     size_t          len;
2593     size_t          *bytes_read;
2594     int             peek;
2595 };
2596
2597 QUIC_NEEDS_LOCK
2598 static int quic_validate_for_read(QUIC_XSO *xso, int *err, int *eos)
2599 {
2600     QUIC_STREAM_MAP *qsm;
2601
2602     *eos = 0;
2603
2604     if (xso == NULL || xso->stream == NULL) {
2605         *err = ERR_R_INTERNAL_ERROR;
2606         return 0;
2607     }
2608
2609     switch (xso->stream->recv_state) {
2610     default:
2611     case QUIC_RSTREAM_STATE_NONE:
2612         *err = SSL_R_STREAM_SEND_ONLY;
2613         return 0;
2614
2615     case QUIC_RSTREAM_STATE_RECV:
2616     case QUIC_RSTREAM_STATE_SIZE_KNOWN:
2617     case QUIC_RSTREAM_STATE_DATA_RECVD:
2618         return 1;
2619
2620     case QUIC_RSTREAM_STATE_DATA_READ:
2621         *eos = 1;
2622         return 0;
2623
2624     case QUIC_RSTREAM_STATE_RESET_RECVD:
2625         qsm = ossl_quic_channel_get_qsm(xso->conn->ch);
2626         ossl_quic_stream_map_notify_app_read_reset_recv_part(qsm, xso->stream);
2627
2628         /* FALLTHROUGH */
2629     case QUIC_RSTREAM_STATE_RESET_READ:
2630         *err = SSL_R_STREAM_RESET;
2631         return 0;
2632     }
2633 }
2634
2635 QUIC_NEEDS_LOCK
2636 static int quic_read_actual(QCTX *ctx,
2637                             QUIC_STREAM *stream,
2638                             void *buf, size_t buf_len,
2639                             size_t *bytes_read,
2640                             int peek)
2641 {
2642     int is_fin = 0, err, eos;
2643     QUIC_CONNECTION *qc = ctx->qc;
2644
2645     if (!quic_validate_for_read(ctx->xso, &err, &eos)) {
2646         if (eos) {
2647             ctx->xso->retired_fin = 1;
2648             return QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_ZERO_RETURN);
2649         } else {
2650             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, err, NULL);
2651         }
2652     }
2653
2654     if (peek) {
2655         if (!ossl_quic_rstream_peek(stream->rstream, buf, buf_len,
2656                                     bytes_read, &is_fin))
2657             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2658
2659     } else {
2660         if (!ossl_quic_rstream_read(stream->rstream, buf, buf_len,
2661                                     bytes_read, &is_fin))
2662             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2663     }
2664
2665     if (!peek) {
2666         if (*bytes_read > 0) {
2667             /*
2668              * We have read at least one byte from the stream. Inform stream-level
2669              * RXFC of the retirement of controlled bytes. Update the active stream
2670              * status (the RXFC may now want to emit a frame granting more credit to
2671              * the peer).
2672              */
2673             OSSL_RTT_INFO rtt_info;
2674
2675             ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(qc->ch), &rtt_info);
2676
2677             if (!ossl_quic_rxfc_on_retire(&stream->rxfc, *bytes_read,
2678                                           rtt_info.smoothed_rtt))
2679                 return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
2680         }
2681
2682         if (is_fin && !peek) {
2683             QUIC_STREAM_MAP *qsm = ossl_quic_channel_get_qsm(ctx->qc->ch);
2684
2685             ossl_quic_stream_map_notify_totally_read(qsm, ctx->xso->stream);
2686         }
2687
2688         if (*bytes_read > 0)
2689             ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(qc->ch),
2690                                               stream);
2691     }
2692
2693     if (*bytes_read == 0 && is_fin) {
2694         ctx->xso->retired_fin = 1;
2695         return QUIC_RAISE_NORMAL_ERROR(ctx, SSL_ERROR_ZERO_RETURN);
2696     }
2697
2698     return 1;
2699 }
2700
2701 QUIC_NEEDS_LOCK
2702 static int quic_read_again(void *arg)
2703 {
2704     struct quic_read_again_args *args = arg;
2705
2706     if (!quic_mutation_allowed(args->ctx->qc, /*req_active=*/1)) {
2707         /* If connection is torn down due to an error while blocking, stop. */
2708         QUIC_RAISE_NON_NORMAL_ERROR(args->ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2709         return -1;
2710     }
2711
2712     if (!quic_read_actual(args->ctx, args->stream,
2713                           args->buf, args->len, args->bytes_read,
2714                           args->peek))
2715         return -1;
2716
2717     if (*args->bytes_read > 0)
2718         /* got at least one byte, the SSL_read op can finish now */
2719         return 1;
2720
2721     return 0; /* did not read anything, keep trying */
2722 }
2723
2724 QUIC_TAKES_LOCK
2725 static int quic_read(SSL *s, void *buf, size_t len, size_t *bytes_read, int peek)
2726 {
2727     int ret, res;
2728     QCTX ctx;
2729     struct quic_read_again_args args;
2730
2731     *bytes_read = 0;
2732
2733     if (!expect_quic(s, &ctx))
2734         return 0;
2735
2736     quic_lock_for_io(&ctx);
2737
2738     if (!quic_mutation_allowed(ctx.qc, /*req_active=*/0)) {
2739         ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2740         goto out;
2741     }
2742
2743     /* If we haven't finished the handshake, try to advance it. */
2744     if (quic_do_handshake(&ctx) < 1) {
2745         ret = 0; /* ossl_quic_do_handshake raised error here */
2746         goto out;
2747     }
2748
2749     if (ctx.xso == NULL) {
2750         /*
2751          * Called on a QCSO and we don't currently have a default stream.
2752          *
2753          * Wait until we get a stream initiated by the peer (blocking mode) or
2754          * fail if we don't have one yet (non-blocking mode).
2755          */
2756         if (!qc_wait_for_default_xso_for_read(&ctx)) {
2757             ret = 0; /* error already raised here */
2758             goto out;
2759         }
2760
2761         ctx.xso = ctx.qc->default_xso;
2762     }
2763
2764     if (!quic_read_actual(&ctx, ctx.xso->stream, buf, len, bytes_read, peek)) {
2765         ret = 0; /* quic_read_actual raised error here */
2766         goto out;
2767     }
2768
2769     if (*bytes_read > 0) {
2770         /*
2771          * Even though we succeeded, tick the reactor here to ensure we are
2772          * handling other aspects of the QUIC connection.
2773          */
2774         qctx_maybe_autotick(&ctx);
2775         ret = 1;
2776     } else if (xso_blocking_mode(ctx.xso)) {
2777         /*
2778          * We were not able to read anything immediately, so our stream
2779          * buffer is empty. This means we need to block until we get
2780          * at least one byte.
2781          */
2782         args.ctx        = &ctx;
2783         args.stream     = ctx.xso->stream;
2784         args.buf        = buf;
2785         args.len        = len;
2786         args.bytes_read = bytes_read;
2787         args.peek       = peek;
2788
2789         res = block_until_pred(ctx.qc, quic_read_again, &args, 0);
2790         if (res == 0) {
2791             ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR, NULL);
2792             goto out;
2793         } else if (res < 0) {
2794             ret = 0; /* quic_read_again raised error here */
2795             goto out;
2796         }
2797
2798         ret = 1;
2799     } else {
2800         /*
2801          * We did not get any bytes and are not in blocking mode.
2802          * Tick to see if this delivers any more.
2803          */
2804         qctx_maybe_autotick(&ctx);
2805
2806         /* Try the read again. */
2807         if (!quic_read_actual(&ctx, ctx.xso->stream, buf, len, bytes_read, peek)) {
2808             ret = 0; /* quic_read_actual raised error here */
2809             goto out;
2810         }
2811
2812         if (*bytes_read > 0)
2813             ret = 1; /* Succeeded this time. */
2814         else
2815             ret = QUIC_RAISE_NORMAL_ERROR(&ctx, SSL_ERROR_WANT_READ);
2816     }
2817
2818 out:
2819     quic_unlock(ctx.qc);
2820     return ret;
2821 }
2822
2823 int ossl_quic_read(SSL *s, void *buf, size_t len, size_t *bytes_read)
2824 {
2825     return quic_read(s, buf, len, bytes_read, 0);
2826 }
2827
2828 int ossl_quic_peek(SSL *s, void *buf, size_t len, size_t *bytes_read)
2829 {
2830     return quic_read(s, buf, len, bytes_read, 1);
2831 }
2832
2833 /*
2834  * SSL_pending
2835  * -----------
2836  */
2837
2838 QUIC_TAKES_LOCK
2839 static size_t ossl_quic_pending_int(const SSL *s, int check_channel)
2840 {
2841     QCTX ctx;
2842     size_t avail = 0;
2843     int fin = 0;
2844
2845
2846     if (!expect_quic(s, &ctx))
2847         return 0;
2848
2849     quic_lock(ctx.qc);
2850
2851     if (ctx.xso == NULL) {
2852         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_NO_STREAM, NULL);
2853         goto out;
2854     }
2855
2856     if (ctx.xso->stream == NULL
2857         || !ossl_quic_stream_has_recv_buffer(ctx.xso->stream)) {
2858         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR, NULL);
2859         goto out;
2860     }
2861
2862     if (!ossl_quic_rstream_available(ctx.xso->stream->rstream, &avail, &fin))
2863         avail = 0;
2864
2865     if (avail == 0 && check_channel && ossl_quic_channel_has_pending(ctx.qc->ch))
2866         avail = 1;
2867
2868 out:
2869     quic_unlock(ctx.qc);
2870     return avail;
2871 }
2872
2873 size_t ossl_quic_pending(const SSL *s)
2874 {
2875     return ossl_quic_pending_int(s, /*check_channel=*/0);
2876 }
2877
2878 int ossl_quic_has_pending(const SSL *s)
2879 {
2880     /* Do we have app-side pending data or pending URXEs or RXEs? */
2881     return ossl_quic_pending_int(s, /*check_channel=*/1) > 0;
2882 }
2883
2884 /*
2885  * SSL_stream_conclude
2886  * -------------------
2887  */
2888 QUIC_TAKES_LOCK
2889 int ossl_quic_conn_stream_conclude(SSL *s)
2890 {
2891     QCTX ctx;
2892     QUIC_STREAM *qs;
2893     int err;
2894
2895     if (!expect_quic_with_stream_lock(s, /*remote_init=*/0, /*io=*/0, &ctx))
2896         return 0;
2897
2898     qs = ctx.xso->stream;
2899
2900     if (!quic_mutation_allowed(ctx.qc, /*req_active=*/1)) {
2901         quic_unlock(ctx.qc);
2902         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
2903     }
2904
2905     if (!quic_validate_for_write(ctx.xso, &err)) {
2906         quic_unlock(ctx.qc);
2907         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, err, NULL);
2908     }
2909
2910     if (ossl_quic_sstream_get_final_size(qs->sstream, NULL)) {
2911         quic_unlock(ctx.qc);
2912         return 1;
2913     }
2914
2915     ossl_quic_sstream_fin(qs->sstream);
2916     quic_post_write(ctx.xso, 1, 0, 0, qctx_should_autotick(&ctx));
2917     quic_unlock(ctx.qc);
2918     return 1;
2919 }
2920
2921 /*
2922  * SSL_inject_net_dgram
2923  * --------------------
2924  */
2925 QUIC_TAKES_LOCK
2926 int SSL_inject_net_dgram(SSL *s, const unsigned char *buf,
2927                          size_t buf_len,
2928                          const BIO_ADDR *peer,
2929                          const BIO_ADDR *local)
2930 {
2931     int ret;
2932     QCTX ctx;
2933     QUIC_DEMUX *demux;
2934
2935     if (!expect_quic(s, &ctx))
2936         return 0;
2937
2938     quic_lock(ctx.qc);
2939
2940     demux = ossl_quic_channel_get0_demux(ctx.qc->ch);
2941     ret = ossl_quic_demux_inject(demux, buf, buf_len, peer, local);
2942
2943     quic_unlock(ctx.qc);
2944     return ret;
2945 }
2946
2947 /*
2948  * SSL_get0_connection
2949  * -------------------
2950  */
2951 SSL *ossl_quic_get0_connection(SSL *s)
2952 {
2953     QCTX ctx;
2954
2955     if (!expect_quic(s, &ctx))
2956         return NULL;
2957
2958     return &ctx.qc->ssl;
2959 }
2960
2961 /*
2962  * SSL_get_stream_type
2963  * -------------------
2964  */
2965 int ossl_quic_get_stream_type(SSL *s)
2966 {
2967     QCTX ctx;
2968
2969     if (!expect_quic(s, &ctx))
2970         return SSL_STREAM_TYPE_BIDI;
2971
2972     if (ctx.xso == NULL) {
2973         /*
2974          * If deferred XSO creation has yet to occur, proceed according to the
2975          * default stream mode. If AUTO_BIDI or AUTO_UNI is set, we cannot know
2976          * what kind of stream will be created yet, so return BIDI on the basis
2977          * that at this time, the client still has the option of calling
2978          * SSL_read() or SSL_write() first.
2979          */
2980         if (ctx.qc->default_xso_created
2981             || ctx.qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
2982             return SSL_STREAM_TYPE_NONE;
2983         else
2984             return SSL_STREAM_TYPE_BIDI;
2985     }
2986
2987     if (ossl_quic_stream_is_bidi(ctx.xso->stream))
2988         return SSL_STREAM_TYPE_BIDI;
2989
2990     if (ossl_quic_stream_is_server_init(ctx.xso->stream) != ctx.qc->as_server)
2991         return SSL_STREAM_TYPE_READ;
2992     else
2993         return SSL_STREAM_TYPE_WRITE;
2994 }
2995
2996 /*
2997  * SSL_get_stream_id
2998  * -----------------
2999  */
3000 QUIC_TAKES_LOCK
3001 uint64_t ossl_quic_get_stream_id(SSL *s)
3002 {
3003     QCTX ctx;
3004     uint64_t id;
3005
3006     if (!expect_quic_with_stream_lock(s, /*remote_init=*/-1, /*io=*/0, &ctx))
3007         return UINT64_MAX;
3008
3009     id = ctx.xso->stream->id;
3010     quic_unlock(ctx.qc);
3011
3012     return id;
3013 }
3014
3015 /*
3016  * SSL_is_stream_local
3017  * -------------------
3018  */
3019 QUIC_TAKES_LOCK
3020 int ossl_quic_is_stream_local(SSL *s)
3021 {
3022     QCTX ctx;
3023     int is_local;
3024
3025     if (!expect_quic_with_stream_lock(s, /*remote_init=*/-1, /*io=*/0, &ctx))
3026         return -1;
3027
3028     is_local = ossl_quic_stream_is_local_init(ctx.xso->stream);
3029     quic_unlock(ctx.qc);
3030
3031     return is_local;
3032 }
3033
3034 /*
3035  * SSL_set_default_stream_mode
3036  * ---------------------------
3037  */
3038 QUIC_TAKES_LOCK
3039 int ossl_quic_set_default_stream_mode(SSL *s, uint32_t mode)
3040 {
3041     QCTX ctx;
3042
3043     if (!expect_quic_conn_only(s, &ctx))
3044         return 0;
3045
3046     quic_lock(ctx.qc);
3047
3048     if (ctx.qc->default_xso_created) {
3049         quic_unlock(ctx.qc);
3050         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
3051                                        "too late to change default stream mode");
3052     }
3053
3054     switch (mode) {
3055     case SSL_DEFAULT_STREAM_MODE_NONE:
3056     case SSL_DEFAULT_STREAM_MODE_AUTO_BIDI:
3057     case SSL_DEFAULT_STREAM_MODE_AUTO_UNI:
3058         ctx.qc->default_stream_mode = mode;
3059         break;
3060     default:
3061         quic_unlock(ctx.qc);
3062         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
3063                                        "bad default stream type");
3064     }
3065
3066     quic_unlock(ctx.qc);
3067     return 1;
3068 }
3069
3070 /*
3071  * SSL_detach_stream
3072  * -----------------
3073  */
3074 QUIC_TAKES_LOCK
3075 SSL *ossl_quic_detach_stream(SSL *s)
3076 {
3077     QCTX ctx;
3078     QUIC_XSO *xso = NULL;
3079
3080     if (!expect_quic_conn_only(s, &ctx))
3081         return NULL;
3082
3083     quic_lock(ctx.qc);
3084
3085     /* Calling this function inhibits default XSO autocreation. */
3086     /* QC ref to any default XSO is transferred to us and to caller. */
3087     qc_set_default_xso_keep_ref(ctx.qc, NULL, /*touch=*/1, &xso);
3088
3089     quic_unlock(ctx.qc);
3090
3091     return xso != NULL ? &xso->ssl : NULL;
3092 }
3093
3094 /*
3095  * SSL_attach_stream
3096  * -----------------
3097  */
3098 QUIC_TAKES_LOCK
3099 int ossl_quic_attach_stream(SSL *conn, SSL *stream)
3100 {
3101     QCTX ctx;
3102     QUIC_XSO *xso;
3103     int nref;
3104
3105     if (!expect_quic_conn_only(conn, &ctx))
3106         return 0;
3107
3108     if (stream == NULL || stream->type != SSL_TYPE_QUIC_XSO)
3109         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_NULL_PARAMETER,
3110                                        "stream to attach must be a valid QUIC stream");
3111
3112     xso = (QUIC_XSO *)stream;
3113
3114     quic_lock(ctx.qc);
3115
3116     if (ctx.qc->default_xso != NULL) {
3117         quic_unlock(ctx.qc);
3118         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
3119                                        "connection already has a default stream");
3120     }
3121
3122     /*
3123      * It is a caller error for the XSO being attached as a default XSO to have
3124      * more than one ref.
3125      */
3126     if (!CRYPTO_GET_REF(&xso->ssl.references, &nref)) {
3127         quic_unlock(ctx.qc);
3128         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR,
3129                                        "ref");
3130     }
3131
3132     if (nref != 1) {
3133         quic_unlock(ctx.qc);
3134         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
3135                                        "stream being attached must have "
3136                                        "only 1 reference");
3137     }
3138
3139     /* Caller's reference to the XSO is transferred to us. */
3140     /* Calling this function inhibits default XSO autocreation. */
3141     qc_set_default_xso(ctx.qc, xso, /*touch=*/1);
3142
3143     quic_unlock(ctx.qc);
3144     return 1;
3145 }
3146
3147 /*
3148  * SSL_set_incoming_stream_policy
3149  * ------------------------------
3150  */
3151 QUIC_NEEDS_LOCK
3152 static int qc_get_effective_incoming_stream_policy(QUIC_CONNECTION *qc)
3153 {
3154     switch (qc->incoming_stream_policy) {
3155         case SSL_INCOMING_STREAM_POLICY_AUTO:
3156             if ((qc->default_xso == NULL && !qc->default_xso_created)
3157                 || qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
3158                 return SSL_INCOMING_STREAM_POLICY_ACCEPT;
3159             else
3160                 return SSL_INCOMING_STREAM_POLICY_REJECT;
3161
3162         default:
3163             return qc->incoming_stream_policy;
3164     }
3165 }
3166
3167 QUIC_NEEDS_LOCK
3168 static void qc_update_reject_policy(QUIC_CONNECTION *qc)
3169 {
3170     int policy = qc_get_effective_incoming_stream_policy(qc);
3171     int enable_reject = (policy == SSL_INCOMING_STREAM_POLICY_REJECT);
3172
3173     ossl_quic_channel_set_incoming_stream_auto_reject(qc->ch,
3174                                                       enable_reject,
3175                                                       qc->incoming_stream_aec);
3176 }
3177
3178 QUIC_TAKES_LOCK
3179 int ossl_quic_set_incoming_stream_policy(SSL *s, int policy,
3180                                          uint64_t aec)
3181 {
3182     int ret = 1;
3183     QCTX ctx;
3184
3185     if (!expect_quic_conn_only(s, &ctx))
3186         return 0;
3187
3188     quic_lock(ctx.qc);
3189
3190     switch (policy) {
3191     case SSL_INCOMING_STREAM_POLICY_AUTO:
3192     case SSL_INCOMING_STREAM_POLICY_ACCEPT:
3193     case SSL_INCOMING_STREAM_POLICY_REJECT:
3194         ctx.qc->incoming_stream_policy = policy;
3195         ctx.qc->incoming_stream_aec    = aec;
3196         break;
3197
3198     default:
3199         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT, NULL);
3200         ret = 0;
3201         break;
3202     }
3203
3204     qc_update_reject_policy(ctx.qc);
3205     quic_unlock(ctx.qc);
3206     return ret;
3207 }
3208
3209 /*
3210  * SSL_get_value, SSL_set_value
3211  * ----------------------------
3212  */
3213 QUIC_TAKES_LOCK
3214 static int qc_getset_idle_timeout(QCTX *ctx, uint32_t class_,
3215                                   uint64_t *p_value_out, uint64_t *p_value_in)
3216 {
3217     int ret = 0;
3218     uint64_t value_out = 0, value_in;
3219
3220     quic_lock(ctx->qc);
3221
3222     switch (class_) {
3223     case SSL_VALUE_CLASS_FEATURE_REQUEST:
3224         value_out = ossl_quic_channel_get_max_idle_timeout_request(ctx->qc->ch);
3225
3226         if (p_value_in != NULL) {
3227             value_in = *p_value_in;
3228             if (value_in > OSSL_QUIC_VLINT_MAX) {
3229                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_PASSED_INVALID_ARGUMENT,
3230                                             NULL);
3231                 goto err;
3232             }
3233
3234             if (ossl_quic_channel_have_generated_transport_params(ctx->qc->ch)) {
3235                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_FEATURE_NOT_RENEGOTIABLE,
3236                                             NULL);
3237                 goto err;
3238             }
3239
3240             ossl_quic_channel_set_max_idle_timeout_request(ctx->qc->ch, value_in);
3241         }
3242         break;
3243
3244     case SSL_VALUE_CLASS_FEATURE_PEER_REQUEST:
3245     case SSL_VALUE_CLASS_FEATURE_NEGOTIATED:
3246         if (p_value_in != NULL) {
3247             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_OP,
3248                                         NULL);
3249             goto err;
3250         }
3251
3252         if (!ossl_quic_channel_is_handshake_complete(ctx->qc->ch)) {
3253             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_FEATURE_NEGOTIATION_NOT_COMPLETE,
3254                                         NULL);
3255             goto err;
3256         }
3257
3258         value_out = (class_ == SSL_VALUE_CLASS_FEATURE_NEGOTIATED)
3259             ? ossl_quic_channel_get_max_idle_timeout_actual(ctx->qc->ch)
3260             : ossl_quic_channel_get_max_idle_timeout_peer_request(ctx->qc->ch);
3261         break;
3262
3263     default:
3264         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
3265                                     NULL);
3266         goto err;
3267     }
3268
3269     ret = 1;
3270 err:
3271     quic_unlock(ctx->qc);
3272     if (ret && p_value_out != NULL)
3273         *p_value_out = value_out;
3274
3275     return ret;
3276 }
3277
3278 QUIC_TAKES_LOCK
3279 static int qc_get_stream_avail(QCTX *ctx, uint32_t class_,
3280                                int is_uni, int is_remote,
3281                                uint64_t *value)
3282 {
3283     int ret = 0;
3284
3285     if (class_ != SSL_VALUE_CLASS_GENERIC) {
3286         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
3287                                     NULL);
3288         return 0;
3289     }
3290
3291     quic_lock(ctx->qc);
3292
3293     *value = is_remote
3294         ? ossl_quic_channel_get_remote_stream_count_avail(ctx->qc->ch, is_uni)
3295         : ossl_quic_channel_get_local_stream_count_avail(ctx->qc->ch, is_uni);
3296
3297     ret = 1;
3298     quic_unlock(ctx->qc);
3299     return ret;
3300 }
3301
3302 QUIC_NEEDS_LOCK
3303 static int qctx_should_autotick(QCTX *ctx)
3304 {
3305     int event_handling_mode;
3306
3307     if (ctx->is_stream) {
3308         event_handling_mode = ctx->xso->event_handling_mode;
3309         if (event_handling_mode != SSL_VALUE_EVENT_HANDLING_MODE_INHERIT)
3310             return event_handling_mode != SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT;
3311     }
3312
3313     event_handling_mode = ctx->qc->event_handling_mode;
3314     return event_handling_mode != SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT;
3315 }
3316
3317 QUIC_NEEDS_LOCK
3318 static void qctx_maybe_autotick(QCTX *ctx)
3319 {
3320     if (!qctx_should_autotick(ctx))
3321         return;
3322
3323     ossl_quic_reactor_tick(ossl_quic_channel_get_reactor(ctx->qc->ch), 0);
3324 }
3325
3326 QUIC_TAKES_LOCK
3327 static int qc_getset_event_handling(QCTX *ctx, uint32_t class_,
3328                                     uint64_t *p_value_out,
3329                                     uint64_t *p_value_in)
3330 {
3331     int ret = 0;
3332     uint64_t value_out = 0;
3333
3334     quic_lock(ctx->qc);
3335
3336     if (class_ != SSL_VALUE_CLASS_GENERIC) {
3337         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
3338                                     NULL);
3339         goto err;
3340     }
3341
3342     if (p_value_in != NULL) {
3343         switch (*p_value_in) {
3344         case SSL_VALUE_EVENT_HANDLING_MODE_INHERIT:
3345         case SSL_VALUE_EVENT_HANDLING_MODE_IMPLICIT:
3346         case SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT:
3347             break;
3348         default:
3349             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_PASSED_INVALID_ARGUMENT,
3350                                         NULL);
3351             goto err;
3352         }
3353
3354         value_out = *p_value_in;
3355         if (ctx->is_stream)
3356             ctx->xso->event_handling_mode = (int)value_out;
3357         else
3358             ctx->qc->event_handling_mode = (int)value_out;
3359     } else {
3360         value_out = ctx->is_stream
3361             ? ctx->xso->event_handling_mode
3362             : ctx->qc->event_handling_mode;
3363     }
3364
3365     ret = 1;
3366 err:
3367     quic_unlock(ctx->qc);
3368     if (ret && p_value_out != NULL)
3369         *p_value_out = value_out;
3370
3371     return ret;
3372 }
3373
3374 QUIC_TAKES_LOCK
3375 static int qc_get_stream_write_buf_stat(QCTX *ctx, uint32_t class_,
3376                                         uint64_t *p_value_out,
3377                                         size_t (*getter)(QUIC_SSTREAM *sstream))
3378 {
3379     int ret = 0;
3380     size_t value = 0;
3381
3382     quic_lock(ctx->qc);
3383
3384     if (class_ != SSL_VALUE_CLASS_GENERIC) {
3385         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
3386                                     NULL);
3387         goto err;
3388     }
3389
3390     if (ctx->xso == NULL) {
3391         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_NO_STREAM, NULL);
3392         goto err;
3393     }
3394
3395     if (!ossl_quic_stream_has_send(ctx->xso->stream)) {
3396         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_STREAM_RECV_ONLY, NULL);
3397         goto err;
3398     }
3399
3400     if (ossl_quic_stream_has_send_buffer(ctx->xso->stream))
3401         value = getter(ctx->xso->stream->sstream);
3402
3403     ret = 1;
3404 err:
3405     quic_unlock(ctx->qc);
3406     *p_value_out = (uint64_t)value;
3407     return ret;
3408 }
3409
3410 QUIC_NEEDS_LOCK
3411 static int expect_quic_for_value(SSL *s, QCTX *ctx, uint32_t id)
3412 {
3413     switch (id) {
3414     case SSL_VALUE_EVENT_HANDLING_MODE:
3415     case SSL_VALUE_STREAM_WRITE_BUF_SIZE:
3416     case SSL_VALUE_STREAM_WRITE_BUF_USED:
3417     case SSL_VALUE_STREAM_WRITE_BUF_AVAIL:
3418         return expect_quic(s, ctx);
3419     default:
3420         return expect_quic_conn_only(s, ctx);
3421     }
3422 }
3423
3424 QUIC_TAKES_LOCK
3425 int ossl_quic_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
3426                              uint64_t *value)
3427 {
3428     QCTX ctx;
3429
3430     if (!expect_quic_for_value(s, &ctx, id))
3431         return 0;
3432
3433     if (value == NULL)
3434         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
3435                                            ERR_R_PASSED_INVALID_ARGUMENT, NULL);
3436
3437     switch (id) {
3438     case SSL_VALUE_QUIC_IDLE_TIMEOUT:
3439         return qc_getset_idle_timeout(&ctx, class_, value, NULL);
3440
3441     case SSL_VALUE_QUIC_STREAM_BIDI_LOCAL_AVAIL:
3442         return qc_get_stream_avail(&ctx, class_, /*uni=*/0, /*remote=*/0, value);
3443     case SSL_VALUE_QUIC_STREAM_BIDI_REMOTE_AVAIL:
3444         return qc_get_stream_avail(&ctx, class_, /*uni=*/0, /*remote=*/1, value);
3445     case SSL_VALUE_QUIC_STREAM_UNI_LOCAL_AVAIL:
3446         return qc_get_stream_avail(&ctx, class_, /*uni=*/1, /*remote=*/0, value);
3447     case SSL_VALUE_QUIC_STREAM_UNI_REMOTE_AVAIL:
3448         return qc_get_stream_avail(&ctx, class_, /*uni=*/1, /*remote=*/1, value);
3449
3450     case SSL_VALUE_EVENT_HANDLING_MODE:
3451         return qc_getset_event_handling(&ctx, class_, value, NULL);
3452
3453     case SSL_VALUE_STREAM_WRITE_BUF_SIZE:
3454         return qc_get_stream_write_buf_stat(&ctx, class_, value,
3455                                             ossl_quic_sstream_get_buffer_size);
3456     case SSL_VALUE_STREAM_WRITE_BUF_USED:
3457         return qc_get_stream_write_buf_stat(&ctx, class_, value,
3458                                             ossl_quic_sstream_get_buffer_used);
3459     case SSL_VALUE_STREAM_WRITE_BUF_AVAIL:
3460         return qc_get_stream_write_buf_stat(&ctx, class_, value,
3461                                             ossl_quic_sstream_get_buffer_avail);
3462
3463     default:
3464         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
3465                                            SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
3466     }
3467
3468     return 1;
3469 }
3470
3471 QUIC_TAKES_LOCK
3472 int ossl_quic_set_value_uint(SSL *s, uint32_t class_, uint32_t id,
3473                              uint64_t value)
3474 {
3475     QCTX ctx;
3476
3477     if (!expect_quic_for_value(s, &ctx, id))
3478         return 0;
3479
3480     switch (id) {
3481     case SSL_VALUE_QUIC_IDLE_TIMEOUT:
3482         return qc_getset_idle_timeout(&ctx, class_, NULL, &value);
3483
3484     case SSL_VALUE_EVENT_HANDLING_MODE:
3485         return qc_getset_event_handling(&ctx, class_, NULL, &value);
3486
3487     default:
3488         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
3489                                            SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
3490     }
3491
3492     return 1;
3493 }
3494
3495 /*
3496  * SSL_accept_stream
3497  * -----------------
3498  */
3499 struct wait_for_incoming_stream_args {
3500     QCTX            *ctx;
3501     QUIC_STREAM     *qs;
3502 };
3503
3504 QUIC_NEEDS_LOCK
3505 static int wait_for_incoming_stream(void *arg)
3506 {
3507     struct wait_for_incoming_stream_args *args = arg;
3508     QUIC_CONNECTION *qc = args->ctx->qc;
3509     QUIC_STREAM_MAP *qsm = ossl_quic_channel_get_qsm(qc->ch);
3510
3511     if (!quic_mutation_allowed(qc, /*req_active=*/1)) {
3512         /* If connection is torn down due to an error while blocking, stop. */
3513         QUIC_RAISE_NON_NORMAL_ERROR(args->ctx, SSL_R_PROTOCOL_IS_SHUTDOWN, NULL);
3514         return -1;
3515     }
3516
3517     args->qs = ossl_quic_stream_map_peek_accept_queue(qsm);
3518     if (args->qs != NULL)
3519         return 1; /* got a stream */
3520
3521     return 0; /* did not get a stream, keep trying */
3522 }
3523
3524 QUIC_TAKES_LOCK
3525 SSL *ossl_quic_accept_stream(SSL *s, uint64_t flags)
3526 {
3527     QCTX ctx;
3528     int ret;
3529     SSL *new_s = NULL;
3530     QUIC_STREAM_MAP *qsm;
3531     QUIC_STREAM *qs;
3532     QUIC_XSO *xso;
3533     OSSL_RTT_INFO rtt_info;
3534
3535     if (!expect_quic_conn_only(s, &ctx))
3536         return NULL;
3537
3538     quic_lock(ctx.qc);
3539
3540     if (qc_get_effective_incoming_stream_policy(ctx.qc)
3541         == SSL_INCOMING_STREAM_POLICY_REJECT) {
3542         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED, NULL);
3543         goto out;
3544     }
3545
3546     qsm = ossl_quic_channel_get_qsm(ctx.qc->ch);
3547
3548     qs = ossl_quic_stream_map_peek_accept_queue(qsm);
3549     if (qs == NULL) {
3550         if (qc_blocking_mode(ctx.qc)
3551             && (flags & SSL_ACCEPT_STREAM_NO_BLOCK) == 0) {
3552             struct wait_for_incoming_stream_args args;
3553
3554             args.ctx = &ctx;
3555             args.qs = NULL;
3556
3557             ret = block_until_pred(ctx.qc, wait_for_incoming_stream, &args, 0);
3558             if (ret == 0) {
3559                 QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR, NULL);
3560                 goto out;
3561             } else if (ret < 0 || args.qs == NULL) {
3562                 goto out;
3563             }
3564
3565             qs = args.qs;
3566         } else {
3567             goto out;
3568         }
3569     }
3570
3571     xso = create_xso_from_stream(ctx.qc, qs);
3572     if (xso == NULL)
3573         goto out;
3574
3575     ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(ctx.qc->ch), &rtt_info);
3576     ossl_quic_stream_map_remove_from_accept_queue(qsm, qs,
3577                                                   rtt_info.smoothed_rtt);
3578     new_s = &xso->ssl;
3579
3580     /* Calling this function inhibits default XSO autocreation. */
3581     qc_touch_default_xso(ctx.qc); /* inhibits default XSO */
3582
3583 out:
3584     quic_unlock(ctx.qc);
3585     return new_s;
3586 }
3587
3588 /*
3589  * SSL_get_accept_stream_queue_len
3590  * -------------------------------
3591  */
3592 QUIC_TAKES_LOCK
3593 size_t ossl_quic_get_accept_stream_queue_len(SSL *s)
3594 {
3595     QCTX ctx;
3596     size_t v;
3597
3598     if (!expect_quic_conn_only(s, &ctx))
3599         return 0;
3600
3601     quic_lock(ctx.qc);
3602
3603     v = ossl_quic_stream_map_get_total_accept_queue_len(ossl_quic_channel_get_qsm(ctx.qc->ch));
3604
3605     quic_unlock(ctx.qc);
3606     return v;
3607 }
3608
3609 /*
3610  * SSL_stream_reset
3611  * ----------------
3612  */
3613 int ossl_quic_stream_reset(SSL *ssl,
3614                            const SSL_STREAM_RESET_ARGS *args,
3615                            size_t args_len)
3616 {
3617     QCTX ctx;
3618     QUIC_STREAM_MAP *qsm;
3619     QUIC_STREAM *qs;
3620     uint64_t error_code;
3621     int ok, err;
3622
3623     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/0, /*io=*/0, &ctx))
3624         return 0;
3625
3626     qsm         = ossl_quic_channel_get_qsm(ctx.qc->ch);
3627     qs          = ctx.xso->stream;
3628     error_code  = (args != NULL ? args->quic_error_code : 0);
3629
3630     if (!quic_validate_for_write(ctx.xso, &err)) {
3631         ok = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, err, NULL);
3632         goto err;
3633     }
3634
3635     ok = ossl_quic_stream_map_reset_stream_send_part(qsm, qs, error_code);
3636     if (ok)
3637         ctx.xso->requested_reset = 1;
3638
3639 err:
3640     quic_unlock(ctx.qc);
3641     return ok;
3642 }
3643
3644 /*
3645  * SSL_get_stream_read_state
3646  * -------------------------
3647  */
3648 static void quic_classify_stream(QUIC_CONNECTION *qc,
3649                                  QUIC_STREAM *qs,
3650                                  int is_write,
3651                                  int *state,
3652                                  uint64_t *app_error_code)
3653 {
3654     int local_init;
3655     uint64_t final_size;
3656
3657     local_init = (ossl_quic_stream_is_server_init(qs) == qc->as_server);
3658
3659     if (app_error_code != NULL)
3660         *app_error_code = UINT64_MAX;
3661     else
3662         app_error_code = &final_size; /* throw away value */
3663
3664     if (!ossl_quic_stream_is_bidi(qs) && local_init != is_write) {
3665         /*
3666          * Unidirectional stream and this direction of transmission doesn't
3667          * exist.
3668          */
3669         *state = SSL_STREAM_STATE_WRONG_DIR;
3670     } else if (ossl_quic_channel_is_term_any(qc->ch)) {
3671         /* Connection already closed. */
3672         *state = SSL_STREAM_STATE_CONN_CLOSED;
3673     } else if (!is_write && qs->recv_state == QUIC_RSTREAM_STATE_DATA_READ) {
3674         /* Application has read a FIN. */
3675         *state = SSL_STREAM_STATE_FINISHED;
3676     } else if ((!is_write && qs->stop_sending)
3677                || (is_write && ossl_quic_stream_send_is_reset(qs))) {
3678         /*
3679          * Stream has been reset locally. FIN takes precedence over this for the
3680          * read case as the application need not care if the stream is reset
3681          * after a FIN has been successfully processed.
3682          */
3683         *state          = SSL_STREAM_STATE_RESET_LOCAL;
3684         *app_error_code = !is_write
3685             ? qs->stop_sending_aec
3686             : qs->reset_stream_aec;
3687     } else if ((!is_write && ossl_quic_stream_recv_is_reset(qs))
3688                || (is_write && qs->peer_stop_sending)) {
3689         /*
3690          * Stream has been reset remotely. */
3691         *state          = SSL_STREAM_STATE_RESET_REMOTE;
3692         *app_error_code = !is_write
3693             ? qs->peer_reset_stream_aec
3694             : qs->peer_stop_sending_aec;
3695     } else if (is_write && ossl_quic_sstream_get_final_size(qs->sstream,
3696                                                             &final_size)) {
3697         /*
3698          * Stream has been finished. Stream reset takes precedence over this for
3699          * the write case as peer may not have received all data.
3700          */
3701         *state = SSL_STREAM_STATE_FINISHED;
3702     } else {
3703         /* Stream still healthy. */
3704         *state = SSL_STREAM_STATE_OK;
3705     }
3706 }
3707
3708 static int quic_get_stream_state(SSL *ssl, int is_write)
3709 {
3710     QCTX ctx;
3711     int state;
3712
3713     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/-1, /*io=*/0, &ctx))
3714         return SSL_STREAM_STATE_NONE;
3715
3716     quic_classify_stream(ctx.qc, ctx.xso->stream, is_write, &state, NULL);
3717     quic_unlock(ctx.qc);
3718     return state;
3719 }
3720
3721 int ossl_quic_get_stream_read_state(SSL *ssl)
3722 {
3723     return quic_get_stream_state(ssl, /*is_write=*/0);
3724 }
3725
3726 /*
3727  * SSL_get_stream_write_state
3728  * --------------------------
3729  */
3730 int ossl_quic_get_stream_write_state(SSL *ssl)
3731 {
3732     return quic_get_stream_state(ssl, /*is_write=*/1);
3733 }
3734
3735 /*
3736  * SSL_get_stream_read_error_code
3737  * ------------------------------
3738  */
3739 static int quic_get_stream_error_code(SSL *ssl, int is_write,
3740                                       uint64_t *app_error_code)
3741 {
3742     QCTX ctx;
3743     int state;
3744
3745     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/-1, /*io=*/0, &ctx))
3746         return -1;
3747
3748     quic_classify_stream(ctx.qc, ctx.xso->stream, /*is_write=*/0,
3749                          &state, app_error_code);
3750
3751     quic_unlock(ctx.qc);
3752     switch (state) {
3753         case SSL_STREAM_STATE_FINISHED:
3754              return 0;
3755         case SSL_STREAM_STATE_RESET_LOCAL:
3756         case SSL_STREAM_STATE_RESET_REMOTE:
3757              return 1;
3758         default:
3759              return -1;
3760     }
3761 }
3762
3763 int ossl_quic_get_stream_read_error_code(SSL *ssl, uint64_t *app_error_code)
3764 {
3765     return quic_get_stream_error_code(ssl, /*is_write=*/0, app_error_code);
3766 }
3767
3768 /*
3769  * SSL_get_stream_write_error_code
3770  * -------------------------------
3771  */
3772 int ossl_quic_get_stream_write_error_code(SSL *ssl, uint64_t *app_error_code)
3773 {
3774     return quic_get_stream_error_code(ssl, /*is_write=*/1, app_error_code);
3775 }
3776
3777 /*
3778  * Write buffer size mutation
3779  * --------------------------
3780  */
3781 int ossl_quic_set_write_buffer_size(SSL *ssl, size_t size)
3782 {
3783     int ret = 0;
3784     QCTX ctx;
3785
3786     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/-1, /*io=*/0, &ctx))
3787         return 0;
3788
3789     if (!ossl_quic_stream_has_send(ctx.xso->stream)) {
3790         /* Called on a unidirectional receive-only stream - error. */
3791         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED, NULL);
3792         goto out;
3793     }
3794
3795     if (!ossl_quic_stream_has_send_buffer(ctx.xso->stream)) {
3796         /*
3797          * If the stream has a send part but we have disposed of it because we
3798          * no longer need it, this is a no-op.
3799          */
3800         ret = 1;
3801         goto out;
3802     }
3803
3804     if (!ossl_quic_sstream_set_buffer_size(ctx.xso->stream->sstream, size)) {
3805         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR, NULL);
3806         goto out;
3807     }
3808
3809     ret = 1;
3810
3811 out:
3812     quic_unlock(ctx.qc);
3813     return ret;
3814 }
3815
3816 /*
3817  * SSL_get_conn_close_info
3818  * -----------------------
3819  */
3820 int ossl_quic_get_conn_close_info(SSL *ssl,
3821                                   SSL_CONN_CLOSE_INFO *info,
3822                                   size_t info_len)
3823 {
3824     QCTX ctx;
3825     const QUIC_TERMINATE_CAUSE *tc;
3826
3827     if (!expect_quic_conn_only(ssl, &ctx))
3828         return -1;
3829
3830     tc = ossl_quic_channel_get_terminate_cause(ctx.qc->ch);
3831     if (tc == NULL)
3832         return 0;
3833
3834     info->error_code    = tc->error_code;
3835     info->frame_type    = tc->frame_type;
3836     info->reason        = tc->reason;
3837     info->reason_len    = tc->reason_len;
3838     info->flags         = 0;
3839     if (!tc->remote)
3840         info->flags |= SSL_CONN_CLOSE_FLAG_LOCAL;
3841     if (!tc->app)
3842         info->flags |= SSL_CONN_CLOSE_FLAG_TRANSPORT;
3843     return 1;
3844 }
3845
3846 /*
3847  * SSL_key_update
3848  * --------------
3849  */
3850 int ossl_quic_key_update(SSL *ssl, int update_type)
3851 {
3852     QCTX ctx;
3853
3854     if (!expect_quic_conn_only(ssl, &ctx))
3855         return 0;
3856
3857     switch (update_type) {
3858     case SSL_KEY_UPDATE_NOT_REQUESTED:
3859         /*
3860          * QUIC signals peer key update implicily by triggering a local
3861          * spontaneous TXKU. Silently upgrade this to SSL_KEY_UPDATE_REQUESTED.
3862          */
3863     case SSL_KEY_UPDATE_REQUESTED:
3864         break;
3865
3866     default:
3867         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT, NULL);
3868         return 0;
3869     }
3870
3871     quic_lock(ctx.qc);
3872
3873     /* Attempt to perform a TXKU. */
3874     if (!ossl_quic_channel_trigger_txku(ctx.qc->ch)) {
3875         QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_TOO_MANY_KEY_UPDATES, NULL);
3876         quic_unlock(ctx.qc);
3877         return 0;
3878     }
3879
3880     quic_unlock(ctx.qc);
3881     return 1;
3882 }
3883
3884 /*
3885  * SSL_get_key_update_type
3886  * -----------------------
3887  */
3888 int ossl_quic_get_key_update_type(const SSL *s)
3889 {
3890     /*
3891      * We always handle key updates immediately so a key update is never
3892      * pending.
3893      */
3894     return SSL_KEY_UPDATE_NONE;
3895 }
3896
3897 /*
3898  * QUIC Front-End I/O API: SSL_CTX Management
3899  * ==========================================
3900  */
3901
3902 long ossl_quic_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
3903 {
3904     switch (cmd) {
3905     default:
3906         return ssl3_ctx_ctrl(ctx, cmd, larg, parg);
3907     }
3908 }
3909
3910 long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
3911 {
3912     QCTX ctx;
3913
3914     if (!expect_quic_conn_only(s, &ctx))
3915         return 0;
3916
3917     switch (cmd) {
3918     case SSL_CTRL_SET_MSG_CALLBACK:
3919         ossl_quic_channel_set_msg_callback(ctx.qc->ch, (ossl_msg_cb)fp,
3920                                            &ctx.qc->ssl);
3921         /* This callback also needs to be set on the internal SSL object */
3922         return ssl3_callback_ctrl(ctx.qc->tls, cmd, fp);;
3923
3924     default:
3925         /* Probably a TLS related ctrl. Defer to our internal SSL object */
3926         return ssl3_callback_ctrl(ctx.qc->tls, cmd, fp);
3927     }
3928 }
3929
3930 long ossl_quic_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
3931 {
3932     return ssl3_ctx_callback_ctrl(ctx, cmd, fp);
3933 }
3934
3935 int ossl_quic_renegotiate_check(SSL *ssl, int initok)
3936 {
3937     /* We never do renegotiation. */
3938     return 0;
3939 }
3940
3941 const SSL_CIPHER *ossl_quic_get_cipher_by_char(const unsigned char *p)
3942 {
3943     const SSL_CIPHER *ciph = ssl3_get_cipher_by_char(p);
3944
3945     if ((ciph->algorithm2 & SSL_QUIC) == 0)
3946         return NULL;
3947
3948     return ciph;
3949 }
3950
3951 /*
3952  * These functions define the TLSv1.2 (and below) ciphers that are supported by
3953  * the SSL_METHOD. Since QUIC only supports TLSv1.3 we don't support any.
3954  */
3955
3956 int ossl_quic_num_ciphers(void)
3957 {
3958     return 0;
3959 }
3960
3961 const SSL_CIPHER *ossl_quic_get_cipher(unsigned int u)
3962 {
3963     return NULL;
3964 }
3965
3966 /*
3967  * SSL_get_shutdown()
3968  * ------------------
3969  */
3970 int ossl_quic_get_shutdown(const SSL *s)
3971 {
3972     QCTX ctx;
3973     int shut = 0;
3974
3975     if (!expect_quic_conn_only(s, &ctx))
3976         return 0;
3977
3978     if (ossl_quic_channel_is_term_any(ctx.qc->ch)) {
3979         shut |= SSL_SENT_SHUTDOWN;
3980         if (!ossl_quic_channel_is_closing(ctx.qc->ch))
3981             shut |= SSL_RECEIVED_SHUTDOWN;
3982     }
3983
3984     return shut;
3985 }
3986
3987 /*
3988  * QUIC Polling Support APIs
3989  * =========================
3990  */
3991
3992 /* Do we have the R (read) condition? */
3993 QUIC_NEEDS_LOCK
3994 static int test_poll_event_r(QUIC_XSO *xso)
3995 {
3996     int fin = 0;
3997     size_t avail = 0;
3998
3999     return ossl_quic_stream_has_recv_buffer(xso->stream)
4000         && ossl_quic_rstream_available(xso->stream->rstream, &avail, &fin)
4001         && (avail > 0 || (fin && !xso->retired_fin));
4002 }
4003
4004 /* Do we have the ER (exception: read) condition? */
4005 QUIC_NEEDS_LOCK
4006 static int test_poll_event_er(QUIC_XSO *xso)
4007 {
4008     return ossl_quic_stream_has_recv(xso->stream)
4009         && ossl_quic_stream_recv_is_reset(xso->stream)
4010         && !xso->retired_fin;
4011 }
4012
4013 /* Do we have the W (write) condition? */
4014 QUIC_NEEDS_LOCK
4015 static int test_poll_event_w(QUIC_XSO *xso)
4016 {
4017     return !xso->conn->shutting_down
4018         && ossl_quic_stream_has_send_buffer(xso->stream)
4019         && ossl_quic_sstream_get_buffer_avail(xso->stream->sstream)
4020         && !ossl_quic_sstream_get_final_size(xso->stream->sstream, NULL)
4021         && quic_mutation_allowed(xso->conn, /*req_active=*/1);
4022 }
4023
4024 /* Do we have the EW (exception: write) condition? */
4025 QUIC_NEEDS_LOCK
4026 static int test_poll_event_ew(QUIC_XSO *xso)
4027 {
4028     return ossl_quic_stream_has_send(xso->stream)
4029         && xso->stream->peer_stop_sending
4030         && !xso->requested_reset
4031         && !xso->conn->shutting_down;
4032 }
4033
4034 /* Do we have the EC (exception: connection) condition? */
4035 QUIC_NEEDS_LOCK
4036 static int test_poll_event_ec(QUIC_CONNECTION *qc)
4037 {
4038     return ossl_quic_channel_is_term_any(qc->ch);
4039 }
4040
4041 /* Do we have the ECD (exception: connection drained) condition? */
4042 QUIC_NEEDS_LOCK
4043 static int test_poll_event_ecd(QUIC_CONNECTION *qc)
4044 {
4045     return ossl_quic_channel_is_terminated(qc->ch);
4046 }
4047
4048 /* Do we have the IS (incoming: stream) condition? */
4049 QUIC_NEEDS_LOCK
4050 static int test_poll_event_is(QUIC_CONNECTION *qc, int is_uni)
4051 {
4052     return ossl_quic_stream_map_get_accept_queue_len(ossl_quic_channel_get_qsm(qc->ch),
4053                                                      is_uni);
4054 }
4055
4056 /* Do we have the OS (outgoing: stream) condition? */
4057 QUIC_NEEDS_LOCK
4058 static int test_poll_event_os(QUIC_CONNECTION *qc, int is_uni)
4059 {
4060     /* Is it currently possible for us to make an outgoing stream? */
4061     return quic_mutation_allowed(qc, /*req_active=*/1)
4062         && ossl_quic_channel_get_local_stream_count_avail(qc->ch, is_uni) > 0;
4063 }
4064
4065 QUIC_TAKES_LOCK
4066 int ossl_quic_conn_poll_events(SSL *ssl, uint64_t events, int do_tick,
4067                                uint64_t *p_revents)
4068 {
4069     QCTX ctx;
4070     uint64_t revents = 0;
4071
4072     if (!expect_quic(ssl, &ctx))
4073         return 0;
4074
4075     quic_lock(ctx.qc);
4076
4077     if (do_tick)
4078         ossl_quic_reactor_tick(ossl_quic_channel_get_reactor(ctx.qc->ch), 0);
4079
4080     if (ctx.xso != NULL) {
4081         /* SSL object has a stream component. */
4082
4083         if ((events & SSL_POLL_EVENT_R) != 0
4084             && test_poll_event_r(ctx.xso))
4085             revents |= SSL_POLL_EVENT_R;
4086
4087         if ((events & SSL_POLL_EVENT_ER) != 0
4088             && test_poll_event_er(ctx.xso))
4089             revents |= SSL_POLL_EVENT_ER;
4090
4091         if ((events & SSL_POLL_EVENT_W) != 0
4092             && test_poll_event_w(ctx.xso))
4093             revents |= SSL_POLL_EVENT_W;
4094
4095         if ((events & SSL_POLL_EVENT_EW) != 0
4096             && test_poll_event_ew(ctx.xso))
4097             revents |= SSL_POLL_EVENT_EW;
4098     }
4099
4100     if (!ctx.is_stream) {
4101         if ((events & SSL_POLL_EVENT_EC) != 0
4102             && test_poll_event_ec(ctx.qc))
4103             revents |= SSL_POLL_EVENT_EC;
4104
4105         if ((events & SSL_POLL_EVENT_ECD) != 0
4106             && test_poll_event_ecd(ctx.qc))
4107             revents |= SSL_POLL_EVENT_ECD;
4108
4109         if ((events & SSL_POLL_EVENT_ISB) != 0
4110             && test_poll_event_is(ctx.qc, /*uni=*/0))
4111             revents |= SSL_POLL_EVENT_ISB;
4112
4113         if ((events & SSL_POLL_EVENT_ISU) != 0
4114             && test_poll_event_is(ctx.qc, /*uni=*/1))
4115             revents |= SSL_POLL_EVENT_ISU;
4116
4117         if ((events & SSL_POLL_EVENT_OSB) != 0
4118             && test_poll_event_os(ctx.qc, /*uni=*/0))
4119             revents |= SSL_POLL_EVENT_OSB;
4120
4121         if ((events & SSL_POLL_EVENT_OSU) != 0
4122             && test_poll_event_os(ctx.qc, /*uni=*/1))
4123             revents |= SSL_POLL_EVENT_OSU;
4124     }
4125
4126     quic_unlock(ctx.qc);
4127     *p_revents = revents;
4128     return 1;
4129 }
4130
4131 /*
4132  * Internal Testing APIs
4133  * =====================
4134  */
4135
4136 QUIC_CHANNEL *ossl_quic_conn_get_channel(SSL *s)
4137 {
4138     QCTX ctx;
4139
4140     if (!expect_quic_conn_only(s, &ctx))
4141         return NULL;
4142
4143     return ctx.qc->ch;
4144 }
4145
4146 int ossl_quic_set_diag_title(SSL_CTX *ctx, const char *title)
4147 {
4148 #ifndef OPENSSL_NO_QLOG
4149     OPENSSL_free(ctx->qlog_title);
4150     ctx->qlog_title = NULL;
4151
4152     if (title == NULL)
4153         return 1;
4154
4155     if ((ctx->qlog_title = OPENSSL_strdup(title)) == NULL)
4156         return 0;
4157 #endif
4158
4159     return 1;
4160 }