test/quic_txp_test.c

   1 /*
   2  * Copyright 2022 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 #include "internal/packet.h"
  10 #include "internal/quic_txp.h"
  11 #include "internal/quic_statm.h"
  12 #include "internal/quic_demux.h"
  13 #include "internal/quic_record_rx.h"
  14 #include "testutil.h"
  15 #include "quic_record_test_util.h"
  16
  17 static const QUIC_CONN_ID scid_1 = {
  18     1, { 0x5f }
  19 };
  20
  21 static const QUIC_CONN_ID dcid_1 = {
  22     8, { 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8 }
  23 };
  24
  25 static const QUIC_CONN_ID cid_1 = {
  26     8, { 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8 }
  27 };
  28
  29 static const unsigned char reset_token_1[16] = {
  30     0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
  31     0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x12,
  32 };
  33
  34 static const unsigned char secret_1[32] = {
  35     0x01
  36 };
  37
  38 static OSSL_TIME fake_now(void *arg)
  39 {
  40     return ossl_time_now(); /* TODO */
  41 }
  42
  43 struct helper {
  44     OSSL_QUIC_TX_PACKETISER         *txp;
  45     OSSL_QUIC_TX_PACKETISER_ARGS    args;
  46     OSSL_QTX_ARGS                   qtx_args;
  47     BIO                             *bio1, *bio2;
  48     QUIC_TXFC                       conn_txfc;
  49     QUIC_RXFC                       conn_rxfc, stream_rxfc;
  50     QUIC_RXFC                       max_streams_bidi_rxfc, max_streams_uni_rxfc;
  51     OSSL_STATM                      statm;
  52     OSSL_CC_DATA                    *cc_data;
  53     const OSSL_CC_METHOD            *cc_method;
  54     QUIC_STREAM_MAP                 qsm;
  55     char                            have_statm, have_qsm;
  56     QUIC_DEMUX                      *demux;
  57     OSSL_QRX                        *qrx;
  58     OSSL_QRX_ARGS                   qrx_args;
  59     OSSL_QRX_PKT                    *qrx_pkt;
  60     PACKET                          pkt;
  61     uint64_t                        frame_type;
  62     union {
  63         uint64_t                        max_data;
  64         OSSL_QUIC_FRAME_NEW_CONN_ID     new_conn_id;
  65         OSSL_QUIC_FRAME_ACK             ack;
  66         struct {
  67             const unsigned char *token;
  68             size_t              token_len;
  69         } new_token;
  70         OSSL_QUIC_FRAME_CRYPTO          crypto;
  71         OSSL_QUIC_FRAME_STREAM          stream;
  72         OSSL_QUIC_FRAME_STOP_SENDING    stop_sending;
  73         OSSL_QUIC_FRAME_RESET_STREAM    reset_stream;
  74         OSSL_QUIC_FRAME_CONN_CLOSE      conn_close;
  75     } frame;
  76     OSSL_QUIC_ACK_RANGE     ack_ranges[16];
  77 };
  78
  79 static void helper_cleanup(struct helper *h)
  80 {
  81     size_t i;
  82     uint32_t pn_space;
  83
  84     ossl_qrx_pkt_release(h->qrx_pkt);
  85     h->qrx_pkt = NULL;
  86
  87     for (pn_space = QUIC_PN_SPACE_INITIAL;
  88          pn_space < QUIC_PN_SPACE_NUM;
  89          ++pn_space)
  90         ossl_ackm_on_pkt_space_discarded(h->args.ackm, pn_space);
  91
  92     ossl_quic_tx_packetiser_free(h->txp);
  93     ossl_qtx_free(h->args.qtx);
  94     ossl_quic_txpim_free(h->args.txpim);
  95     ossl_quic_cfq_free(h->args.cfq);
  96     if (h->cc_data != NULL)
  97         h->cc_method->free(h->cc_data);
  98     if (h->have_statm)
  99         ossl_statm_destroy(&h->statm);
 100     if (h->have_qsm)
 101         ossl_quic_stream_map_cleanup(&h->qsm);
 102     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 103         ossl_quic_sstream_free(h->args.crypto[i]);
 104     ossl_ackm_free(h->args.ackm);
 105     ossl_qrx_free(h->qrx);
 106     ossl_quic_demux_free(h->demux);
 107     BIO_free(h->bio1);
 108     BIO_free(h->bio2);
 109 }
 110
 111 static int helper_init(struct helper *h)
 112 {
 113     int rc = 0;
 114     size_t i;
 115
 116     memset(h, 0, sizeof(*h));
 117
 118     /* Initialisation */
 119     if (!TEST_true(BIO_new_bio_dgram_pair(&h->bio1, 0, &h->bio2, 0)))
 120         goto err;
 121
 122     h->qtx_args.bio    = h->bio1;
 123     h->qtx_args.mdpl   = 1200;
 124
 125     if (!TEST_ptr(h->args.qtx = ossl_qtx_new(&h->qtx_args)))
 126         goto err;
 127
 128     if (!TEST_ptr(h->args.txpim = ossl_quic_txpim_new()))
 129         goto err;
 130
 131     if (!TEST_ptr(h->args.cfq = ossl_quic_cfq_new()))
 132         goto err;
 133
 134     if (!TEST_true(ossl_quic_txfc_init(&h->conn_txfc, NULL)))
 135         goto err;
 136
 137     if (!TEST_true(ossl_quic_rxfc_init(&h->conn_rxfc, NULL,
 138                                        2 * 1024 * 1024,
 139                                        10 * 1024 * 1024,
 140                                        fake_now,
 141                                        NULL)))
 142         goto err;
 143
 144     if (!TEST_true(ossl_quic_rxfc_init(&h->stream_rxfc, &h->conn_rxfc,
 145                                        1 * 1024 * 1024,
 146                                        5 * 1024 * 1024,
 147                                        fake_now,
 148                                        NULL)))
 149         goto err;
 150
 151     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_bidi_rxfc, NULL,
 152                                        100, 100,
 153                                        fake_now,
 154                                        NULL)))
 155         goto err;
 156
 157     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_uni_rxfc, NULL,
 158                                        100, 100,
 159                                        fake_now,
 160                                        NULL)))
 161
 162     if (!TEST_true(ossl_statm_init(&h->statm)))
 163         goto err;
 164
 165     h->have_statm = 1;
 166
 167     h->cc_method = &ossl_cc_dummy_method;
 168     if (!TEST_ptr(h->cc_data = h->cc_method->new(fake_now, NULL)))
 169         goto err;
 170
 171     if (!TEST_ptr(h->args.ackm = ossl_ackm_new(fake_now, NULL,
 172                                                &h->statm,
 173                                                h->cc_method,
 174                                                h->cc_data)))
 175         goto err;
 176
 177     if (!TEST_true(ossl_quic_stream_map_init(&h->qsm, NULL, NULL,
 178                                              &h->max_streams_bidi_rxfc,
 179                                              &h->max_streams_uni_rxfc,
 180                                              /*is_server=*/0)))
 181         goto err;
 182
 183     h->have_qsm = 1;
 184
 185     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 186         if (!TEST_ptr(h->args.crypto[i] = ossl_quic_sstream_new(4096)))
 187             goto err;
 188
 189     h->args.cur_scid                = scid_1;
 190     h->args.cur_dcid                = dcid_1;
 191     h->args.qsm                     = &h->qsm;
 192     h->args.conn_txfc               = &h->conn_txfc;
 193     h->args.conn_rxfc               = &h->conn_rxfc;
 194     h->args.max_streams_bidi_rxfc   = &h->max_streams_bidi_rxfc;
 195     h->args.max_streams_uni_rxfc    = &h->max_streams_uni_rxfc;
 196     h->args.cc_method               = h->cc_method;
 197     h->args.cc_data                 = h->cc_data;
 198     h->args.now                     = fake_now;
 199
 200     if (!TEST_ptr(h->txp = ossl_quic_tx_packetiser_new(&h->args)))
 201         goto err;
 202
 203     if (!TEST_ptr(h->demux = ossl_quic_demux_new(h->bio2, 8,
 204                                                  fake_now, NULL)))
 205         goto err;
 206
 207     h->qrx_args.demux                  = h->demux;
 208     h->qrx_args.short_conn_id_len      = 8;
 209     h->qrx_args.max_deferred           = 32;
 210
 211     if (!TEST_ptr(h->qrx = ossl_qrx_new(&h->qrx_args)))
 212         goto err;
 213
 214     if (!TEST_true(ossl_qrx_add_dst_conn_id(h->qrx, &dcid_1)))
 215         goto err;
 216
 217     rc = 1;
 218 err:
 219     if (!rc)
 220         helper_cleanup(h);
 221
 222     return rc;
 223 }
 224
 225 #define OPK_END                     0   /* End of Script */
 226 #define OPK_TXP_GENERATE            1   /* Call generate, expect packet output */
 227 #define OPK_TXP_GENERATE_NONE       2   /* Call generate, expect no packet output */
 228 #define OPK_RX_PKT                  3   /* Receive, expect packet */
 229 #define OPK_RX_PKT_NONE             4   /* Receive, expect no packet */
 230 #define OPK_EXPECT_DGRAM_LEN        5   /* Expect received datagram length in range */
 231 #define OPK_EXPECT_FRAME            6   /* Expect next frame is of type */
 232 #define OPK_EXPECT_INITIAL_TOKEN    7   /* Expect initial token buffer match */
 233 #define OPK_EXPECT_HDR              8   /* Expect header structure match */
 234 #define OPK_CHECK                   9   /* Call check function */
 235 #define OPK_NEXT_FRAME              10  /* Next frame */
 236 #define OPK_EXPECT_NO_FRAME         11  /* Expect no further frames */
 237 #define OPK_PROVIDE_SECRET          12  /* Provide secret to QTX and QRX */
 238 #define OPK_DISCARD_EL              13  /* Discard QTX EL */
 239 #define OPK_CRYPTO_SEND             14  /* Push data into crypto send stream */
 240 #define OPK_STREAM_NEW              15  /* Create new application stream */
 241 #define OPK_STREAM_SEND             16  /* Push data into application send stream */
 242 #define OPK_STREAM_FIN              17  /* Mark stream as finished */
 243 #define OPK_STOP_SENDING            18  /* Mark stream for STOP_SENDING */
 244 #define OPK_RESET_STREAM            19  /* Mark stream for RESET_STREAM */
 245 #define OPK_CONN_TXFC_BUMP          20  /* Bump connection TXFC CWM */
 246 #define OPK_STREAM_TXFC_BUMP        21  /* Bump stream TXFC CWM */
 247 #define OPK_HANDSHAKE_COMPLETE      22  /* Mark handshake as complete */
 248
 249 struct script_op {
 250     uint32_t opcode;
 251     uint64_t arg0, arg1;
 252     const void *buf;
 253     size_t buf_len;
 254     int (*check_func)(struct helper *h);
 255 };
 256
 257 #define OP_END      \
 258     { OPK_END }
 259 #define OP_TXP_GENERATE(archetype) \
 260     { OPK_TXP_GENERATE, (archetype) },
 261 #define OP_TXP_GENERATE_NONE(archetype) \
 262     { OPK_TXP_GENERATE_NONE, (archetype) },
 263 #define OP_RX_PKT() \
 264     { OPK_RX_PKT },
 265 #define OP_RX_PKT_NONE() \
 266     { OPK_RX_PKT_NONE },
 267 #define OP_EXPECT_DGRAM_LEN(lo, hi) \
 268     { OPK_EXPECT_DGRAM_LEN, (lo), (hi) },
 269 #define OP_EXPECT_FRAME(frame_type) \
 270     { OPK_EXPECT_FRAME, (frame_type) },
 271 #define OP_EXPECT_INITIAL_TOKEN(buf) \
 272     { OPK_EXPECT_INITIAL_TOKEN, sizeof(buf), 0, buf },
 273 #define OP_EXPECT_HDR(hdr) \
 274     { OPK_EXPECT_HDR, 0, 0, &(hdr) },
 275 #define OP_CHECK(func) \
 276     { OPK_CHECK, 0, 0, NULL, 0, (func) },
 277 #define OP_NEXT_FRAME() \
 278     { OPK_NEXT_FRAME },
 279 #define OP_EXPECT_NO_FRAME() \
 280     { OPK_EXPECT_NO_FRAME },
 281 #define OP_PROVIDE_SECRET(el, suite, secret) \
 282     { OPK_PROVIDE_SECRET, (el), (suite), (secret), sizeof(secret) },
 283 #define OP_DISCARD_EL(el) \
 284     { OPK_DISCARD_EL, (el) },
 285 #define OP_CRYPTO_SEND(pn_space, buf) \
 286     { OPK_CRYPTO_SEND, (pn_space), 0, (buf), sizeof(buf) },
 287 #define OP_STREAM_NEW(id) \
 288     { OPK_STREAM_NEW, (id) },
 289 #define OP_STREAM_SEND(id, buf) \
 290     { OPK_STREAM_SEND, (id), 0, (buf), sizeof(buf) },
 291 #define OP_STREAM_FIN(id) \
 292     { OPK_STREAM_FIN, (id) },
 293 #define OP_STOP_SENDING(id, aec) \
 294     { OPK_STOP_SENDING, (id), (aec) },
 295 #define OP_RESET_STREAM(id, aec) \
 296     { OPK_RESET_STREAM, (id), (aec) },
 297 #define OP_CONN_TXFC_BUMP(cwm) \
 298     { OPK_CONN_TXFC_BUMP, (cwm) },
 299 #define OP_STREAM_TXFC_BUMP(id, cwm) \
 300     { OPK_STREAM_TXFC_BUMP, (cwm), (id) },
 301 #define OP_HANDSHAKE_COMPLETE() \
 302     { OPK_HANDSHAKE_COMPLETE },
 303
 304 static int schedule_handshake_done(struct helper *h)
 305 {
 306     ossl_quic_tx_packetiser_schedule_handshake_done(h->txp);
 307     return 1;
 308 }
 309
 310 static int schedule_ack_eliciting_app(struct helper *h)
 311 {
 312     ossl_quic_tx_packetiser_schedule_ack_eliciting(h->txp, QUIC_PN_SPACE_APP);
 313     return 1;
 314 }
 315
 316 /* 1. 1-RTT, Single Handshake Done Frame */
 317 static const struct script_op script_1[] = {
 318     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 319     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 320     OP_CHECK(schedule_handshake_done)
 321     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 322     OP_RX_PKT()
 323     /* Should not be long */
 324     OP_EXPECT_DGRAM_LEN(21, 32)
 325     OP_NEXT_FRAME()
 326     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
 327     OP_EXPECT_NO_FRAME()
 328     OP_RX_PKT_NONE()
 329     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 330     OP_END
 331 };
 332
 333 /* 2. 1-RTT, Forced ACK-Eliciting Frame */
 334 static const struct script_op script_2[] = {
 335     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 336     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 337     OP_CHECK(schedule_ack_eliciting_app)
 338     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 339     OP_RX_PKT()
 340     /* Should not be long */
 341     OP_EXPECT_DGRAM_LEN(21, 32)
 342     /* A PING frame should have been added */
 343     OP_NEXT_FRAME()
 344     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
 345     OP_EXPECT_NO_FRAME()
 346     OP_RX_PKT_NONE()
 347     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 348     OP_END
 349 };
 350
 351 /* 3. 1-RTT, MAX_DATA */
 352 static int schedule_max_data(struct helper *h)
 353 {
 354     uint64_t cwm;
 355
 356     cwm = ossl_quic_rxfc_get_cwm(&h->stream_rxfc);
 357
 358     if (!TEST_true(ossl_quic_rxfc_on_rx_stream_frame(&h->stream_rxfc, cwm, 0))
 359         || !TEST_true(ossl_quic_rxfc_on_retire(&h->stream_rxfc, cwm,
 360                                                ossl_ticks2time(OSSL_TIME_MS))))
 361         return 0;
 362
 363     return 1;
 364 }
 365
 366 static const struct script_op script_3[] = {
 367     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 368     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 369     OP_CHECK(schedule_max_data)
 370     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 371     OP_RX_PKT()
 372     /* Should not be long */
 373     OP_EXPECT_DGRAM_LEN(21, 40)
 374     /* A PING frame should have been added */
 375     OP_NEXT_FRAME()
 376     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_MAX_DATA)
 377     OP_EXPECT_NO_FRAME()
 378     OP_RX_PKT_NONE()
 379     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 380     OP_END
 381 };
 382
 383 /* 4. 1-RTT, CFQ (NEW_CONN_ID) */
 384 static void free_buf_mem(unsigned char *buf, size_t buf_len, void *arg)
 385 {
 386     BUF_MEM_free((BUF_MEM *)arg);
 387 }
 388
 389 static int schedule_cfq_new_conn_id(struct helper *h)
 390 {
 391     int rc = 0;
 392     QUIC_CFQ_ITEM *cfq_item;
 393     WPACKET wpkt;
 394     BUF_MEM *buf_mem = NULL;
 395     size_t l = 0;
 396     OSSL_QUIC_FRAME_NEW_CONN_ID ncid = {0};
 397
 398     ncid.seq_num         = 2345;
 399     ncid.retire_prior_to = 1234;
 400     ncid.conn_id         = cid_1;
 401     memcpy(ncid.stateless_reset_token, reset_token_1, sizeof(reset_token_1));
 402
 403     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 404         goto err;
 405
 406     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 407         goto err;
 408
 409     if (!TEST_true(ossl_quic_wire_encode_frame_new_conn_id(&wpkt, &ncid))) {
 410         WPACKET_cleanup(&wpkt);
 411         goto err;
 412     }
 413
 414     WPACKET_finish(&wpkt);
 415
 416     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 417         goto err;
 418
 419     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 420                                                      QUIC_PN_SPACE_APP,
 421                                                      OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
 422                                                      (unsigned char *)buf_mem->data, l,
 423                                                      free_buf_mem,
 424                                                      buf_mem)))
 425         goto err;
 426
 427     rc = 1;
 428 err:
 429     if (!rc)
 430         BUF_MEM_free(buf_mem);
 431     return rc;
 432 }
 433
 434 static int check_cfq_new_conn_id(struct helper *h)
 435 {
 436     if (!TEST_uint64_t_eq(h->frame.new_conn_id.seq_num, 2345)
 437         || !TEST_uint64_t_eq(h->frame.new_conn_id.retire_prior_to, 1234)
 438         || !TEST_mem_eq(&h->frame.new_conn_id.conn_id, sizeof(cid_1),
 439                         &cid_1, sizeof(cid_1))
 440         || !TEST_mem_eq(&h->frame.new_conn_id.stateless_reset_token,
 441                         sizeof(reset_token_1),
 442                         reset_token_1,
 443                         sizeof(reset_token_1)))
 444         return 0;
 445
 446     return 1;
 447 }
 448
 449 static const struct script_op script_4[] = {
 450     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 451     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 452     OP_CHECK(schedule_cfq_new_conn_id)
 453     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 454     OP_RX_PKT()
 455     OP_EXPECT_DGRAM_LEN(21, 128)
 456     OP_NEXT_FRAME()
 457     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID)
 458     OP_CHECK(check_cfq_new_conn_id)
 459     OP_EXPECT_NO_FRAME()
 460     OP_RX_PKT_NONE()
 461     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 462     OP_END
 463 };
 464
 465 /* 5. 1-RTT, CFQ (NEW_TOKEN) */
 466 static const unsigned char token_1[] = {
 467     0x10, 0x11, 0x12, 0x13, 0x14, 0x15
 468 };
 469
 470 static int schedule_cfq_new_token(struct helper *h)
 471 {
 472     int rc = 0;
 473     QUIC_CFQ_ITEM *cfq_item;
 474     WPACKET wpkt;
 475     BUF_MEM *buf_mem = NULL;
 476     size_t l = 0;
 477
 478     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 479         goto err;
 480
 481     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 482         goto err;
 483
 484     if (!TEST_true(ossl_quic_wire_encode_frame_new_token(&wpkt, token_1,
 485                                                          sizeof(token_1)))) {
 486         WPACKET_cleanup(&wpkt);
 487         goto err;
 488     }
 489
 490     WPACKET_finish(&wpkt);
 491
 492     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 493         goto err;
 494
 495     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 496                                                      QUIC_PN_SPACE_APP,
 497                                                      OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
 498                                                      (unsigned char *)buf_mem->data, l,
 499                                                      free_buf_mem,
 500                                                      buf_mem)))
 501         goto err;
 502
 503     rc = 1;
 504 err:
 505     if (!rc)
 506         BUF_MEM_free(buf_mem);
 507     return rc;
 508 }
 509
 510 static int check_cfq_new_token(struct helper *h)
 511 {
 512     if (!TEST_mem_eq(h->frame.new_token.token,
 513                      h->frame.new_token.token_len,
 514                      token_1,
 515                      sizeof(token_1)))
 516         return 0;
 517
 518     return 1;
 519 }
 520
 521 static const struct script_op script_5[] = {
 522     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 523     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 524     OP_CHECK(schedule_cfq_new_token)
 525     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 526     OP_RX_PKT()
 527     OP_EXPECT_DGRAM_LEN(21, 512)
 528     OP_NEXT_FRAME()
 529     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 530     OP_CHECK(check_cfq_new_token)
 531     OP_EXPECT_NO_FRAME()
 532     OP_RX_PKT_NONE()
 533     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 534     OP_END
 535 };
 536
 537 /* 6. 1-RTT, ACK */
 538 static int schedule_ack(struct helper *h)
 539 {
 540     size_t i;
 541     OSSL_ACKM_RX_PKT rx_pkt = {0};
 542
 543     /* Stimulate ACK emission by simulating a few received packets. */
 544     for (i = 0; i < 5; ++i) {
 545         rx_pkt.pkt_num          = i;
 546         rx_pkt.time             = fake_now(NULL);
 547         rx_pkt.pkt_space        = QUIC_PN_SPACE_APP;
 548         rx_pkt.is_ack_eliciting = 1;
 549
 550         if (!TEST_true(ossl_ackm_on_rx_packet(h->args.ackm, &rx_pkt)))
 551             return 0;
 552     }
 553
 554     return 1;
 555 }
 556
 557 static const struct script_op script_6[] = {
 558     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 559     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 560     OP_CHECK(schedule_ack)
 561     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 562     OP_RX_PKT()
 563     OP_EXPECT_DGRAM_LEN(21, 512)
 564     OP_NEXT_FRAME()
 565     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 566     OP_EXPECT_NO_FRAME()
 567     OP_RX_PKT_NONE()
 568     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 569     OP_END
 570 };
 571
 572 /* 7. 1-RTT, ACK, NEW_TOKEN */
 573 static const struct script_op script_7[] = {
 574     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 575     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 576     OP_CHECK(schedule_cfq_new_token)
 577     OP_CHECK(schedule_ack)
 578     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 579     OP_RX_PKT()
 580     OP_EXPECT_DGRAM_LEN(21, 512)
 581     /* ACK must come before NEW_TOKEN */
 582     OP_NEXT_FRAME()
 583     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 584     OP_NEXT_FRAME()
 585     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 586     OP_EXPECT_NO_FRAME()
 587     OP_RX_PKT_NONE()
 588     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 589     OP_END
 590 };
 591
 592 /* 8. 1-RTT, CRYPTO */
 593 static const unsigned char crypto_1[] = {
 594     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09
 595 };
 596
 597 static const struct script_op script_8[] = {
 598     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 599     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 600     OP_CRYPTO_SEND(QUIC_PN_SPACE_APP, crypto_1)
 601     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 602     OP_RX_PKT()
 603     OP_EXPECT_DGRAM_LEN(21, 512)
 604     OP_NEXT_FRAME()
 605     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 606     OP_EXPECT_NO_FRAME()
 607     OP_RX_PKT_NONE()
 608     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 609     OP_END
 610 };
 611
 612 /* 9. 1-RTT, STREAM */
 613 static const unsigned char stream_9[] = {
 614     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
 615 };
 616
 617 static int check_stream_9(struct helper *h)
 618 {
 619     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 620                      stream_9, sizeof(stream_9)))
 621         return 0;
 622
 623     return 1;
 624 }
 625
 626 static const struct script_op script_9[] = {
 627     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 628     OP_HANDSHAKE_COMPLETE()
 629     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 630     OP_STREAM_NEW(42)
 631     OP_STREAM_SEND(42, stream_9)
 632     /* Still no output because of TXFC */
 633     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 634     /* Now grant a TXFC budget */
 635     OP_CONN_TXFC_BUMP(1000)
 636     OP_STREAM_TXFC_BUMP(42, 1000)
 637     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 638     OP_RX_PKT()
 639     OP_EXPECT_DGRAM_LEN(21, 512)
 640     OP_NEXT_FRAME()
 641     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 642     OP_CHECK(check_stream_9)
 643     OP_EXPECT_NO_FRAME()
 644     OP_RX_PKT_NONE()
 645     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 646     OP_END
 647 };
 648
 649 /* 10. 1-RTT, STREAM, round robin */
 650 /* The data below is randomly generated data. */
 651 static const unsigned char stream_10a[1300] = {
 652     0x40, 0x0d, 0xb6, 0x0d, 0x25, 0x5f, 0xdd, 0xb9, 0x05, 0x79, 0xa8, 0xe3,
 653     0x79, 0x32, 0xb2, 0xa7, 0x30, 0x6d, 0x29, 0xf6, 0xba, 0x50, 0xbe, 0x83,
 654     0xcb, 0x56, 0xec, 0xd6, 0xc7, 0x80, 0x84, 0xa2, 0x2f, 0xeb, 0xc4, 0x37,
 655     0x40, 0x44, 0xef, 0xd8, 0x78, 0xbb, 0x92, 0x80, 0x22, 0x33, 0xc0, 0xce,
 656     0x33, 0x5b, 0x75, 0x8c, 0xa5, 0x1a, 0x7a, 0x2a, 0xa9, 0x88, 0xaf, 0xf6,
 657     0x3a, 0xe2, 0x5e, 0x60, 0x52, 0x6d, 0xef, 0x7f, 0x2a, 0x9a, 0xaa, 0x17,
 658     0x0e, 0x12, 0x51, 0x82, 0x08, 0x2f, 0x0f, 0x5b, 0xff, 0xf5, 0x7c, 0x7c,
 659     0x89, 0x04, 0xfb, 0xa7, 0x80, 0x4e, 0xda, 0x12, 0x89, 0x01, 0x4a, 0x81,
 660     0x84, 0x78, 0x15, 0xa9, 0x12, 0x28, 0x69, 0x4a, 0x25, 0xe5, 0x8b, 0x69,
 661     0xc2, 0x9f, 0xb6, 0x59, 0x49, 0xe3, 0x53, 0x90, 0xef, 0xc9, 0xb8, 0x40,
 662     0xdd, 0x62, 0x5f, 0x99, 0x68, 0xd2, 0x0a, 0x77, 0xde, 0xf3, 0x11, 0x39,
 663     0x7f, 0x93, 0x8b, 0x81, 0x69, 0x36, 0xa7, 0x76, 0xa4, 0x10, 0x56, 0x51,
 664     0xe5, 0x45, 0x3a, 0x42, 0x49, 0x6c, 0xc6, 0xa0, 0xb4, 0x13, 0x46, 0x59,
 665     0x0e, 0x48, 0x60, 0xc9, 0xff, 0x70, 0x10, 0x8d, 0x6a, 0xf9, 0x5b, 0x94,
 666     0xc2, 0x9e, 0x49, 0x19, 0x56, 0xf2, 0xc1, 0xff, 0x08, 0x3f, 0x9e, 0x26,
 667     0x8e, 0x99, 0x71, 0xc4, 0x25, 0xb1, 0x4e, 0xcc, 0x7e, 0x5f, 0xf0, 0x4e,
 668     0x25, 0xa2, 0x2f, 0x3f, 0x68, 0xaa, 0xcf, 0xbd, 0x19, 0x19, 0x1c, 0x92,
 669     0xa0, 0xb6, 0xb8, 0x32, 0xb1, 0x0b, 0x91, 0x05, 0xa9, 0xf8, 0x1a, 0x4b,
 670     0x74, 0x09, 0xf9, 0x57, 0xd0, 0x1c, 0x38, 0x10, 0x05, 0x54, 0xd8, 0x4e,
 671     0x12, 0x67, 0xcc, 0x43, 0xa3, 0x81, 0xa9, 0x3a, 0x12, 0x57, 0xe7, 0x4b,
 672     0x0e, 0xe5, 0x51, 0xf9, 0x5f, 0xd4, 0x46, 0x73, 0xa2, 0x78, 0xb7, 0x00,
 673     0x24, 0x69, 0x35, 0x10, 0x1e, 0xb8, 0xa7, 0x4a, 0x9b, 0xbc, 0xfc, 0x04,
 674     0x6f, 0x1a, 0xb0, 0x4f, 0x12, 0xc9, 0x2b, 0x3b, 0x94, 0x85, 0x1b, 0x8e,
 675     0xba, 0xac, 0xfd, 0x10, 0x22, 0x68, 0x90, 0x17, 0x13, 0x44, 0x18, 0x2f,
 676     0x33, 0x37, 0x1a, 0x89, 0xc0, 0x2c, 0x14, 0x59, 0xb2, 0xaf, 0xc0, 0x6b,
 677     0xdc, 0x28, 0xe1, 0xe9, 0xc1, 0x0c, 0xb4, 0x80, 0x90, 0xb9, 0x1f, 0x45,
 678     0xb4, 0x63, 0x9a, 0x0e, 0xfa, 0x33, 0xf5, 0x75, 0x3a, 0x4f, 0xc3, 0x8c,
 679     0x70, 0xdb, 0xd7, 0xbf, 0xf6, 0xb8, 0x7f, 0xcc, 0xe5, 0x85, 0xb6, 0xae,
 680     0x25, 0x60, 0x18, 0x5b, 0xf1, 0x51, 0x1a, 0x85, 0xc1, 0x7f, 0xf3, 0xbe,
 681     0xb6, 0x82, 0x38, 0xe3, 0xd2, 0xff, 0x8a, 0xc4, 0xdb, 0x08, 0xe6, 0x96,
 682     0xd5, 0x3d, 0x1f, 0xc5, 0x12, 0x35, 0x45, 0x75, 0x5d, 0x17, 0x4e, 0xe1,
 683     0xb8, 0xc9, 0xf0, 0x45, 0x95, 0x0b, 0x03, 0xcb, 0x85, 0x47, 0xaf, 0xc7,
 684     0x88, 0xb6, 0xc1, 0x2c, 0xb8, 0x9b, 0xe6, 0x8b, 0x51, 0xd5, 0x2e, 0x71,
 685     0xba, 0xc9, 0xa9, 0x37, 0x5e, 0x1c, 0x2c, 0x03, 0xf0, 0xc7, 0xc1, 0xd3,
 686     0x72, 0xaa, 0x4d, 0x19, 0xd6, 0x51, 0x64, 0x12, 0xeb, 0x39, 0xeb, 0x45,
 687     0xe9, 0xb4, 0x84, 0x08, 0xb6, 0x6c, 0xc7, 0x3e, 0xf0, 0x88, 0x64, 0xc2,
 688     0x91, 0xb7, 0xa5, 0x86, 0x66, 0x83, 0xd5, 0xd3, 0x41, 0x24, 0xb2, 0x1c,
 689     0x9a, 0x18, 0x10, 0x0e, 0xa5, 0xc9, 0xef, 0xcd, 0x06, 0xce, 0xa8, 0xaf,
 690     0x22, 0x52, 0x25, 0x0b, 0x99, 0x3d, 0xe9, 0x26, 0xda, 0xa9, 0x47, 0xd1,
 691     0x4b, 0xa6, 0x4c, 0xfc, 0x80, 0xaf, 0x6a, 0x59, 0x4b, 0x35, 0xa4, 0x93,
 692     0x39, 0x5b, 0xfa, 0x91, 0x9d, 0xdf, 0x9d, 0x3c, 0xfb, 0x53, 0xca, 0x18,
 693     0x19, 0xe4, 0xda, 0x95, 0x47, 0x5a, 0x37, 0x59, 0xd7, 0xd2, 0xe4, 0x75,
 694     0x45, 0x0d, 0x03, 0x7f, 0xa0, 0xa9, 0xa0, 0x71, 0x06, 0xb1, 0x9d, 0x46,
 695     0xbd, 0xcf, 0x4a, 0x8b, 0x73, 0xc1, 0x45, 0x5c, 0x00, 0x61, 0xfd, 0xd1,
 696     0xa4, 0xa2, 0x3e, 0xaa, 0xbe, 0x72, 0xf1, 0x7a, 0x1a, 0x76, 0x88, 0x5c,
 697     0x9e, 0x74, 0x6d, 0x2a, 0x34, 0xfc, 0xf7, 0x41, 0x28, 0xe8, 0xa3, 0x43,
 698     0x4d, 0x43, 0x1d, 0x6c, 0x36, 0xb1, 0x45, 0x71, 0x5a, 0x3c, 0xd3, 0x28,
 699     0x44, 0xe4, 0x9b, 0xbf, 0x54, 0x16, 0xc3, 0x99, 0x6c, 0x42, 0xd8, 0x20,
 700     0xb6, 0x20, 0x5f, 0x6e, 0xbc, 0xba, 0x88, 0x5e, 0x2f, 0xa5, 0xd1, 0x82,
 701     0x5c, 0x92, 0xd0, 0x79, 0xfd, 0xcc, 0x61, 0x49, 0xd0, 0x73, 0x92, 0xe6,
 702     0x98, 0xe3, 0x80, 0x7a, 0xf9, 0x56, 0x63, 0x33, 0x19, 0xda, 0x54, 0x13,
 703     0xf0, 0x21, 0xa8, 0x15, 0xf6, 0xb7, 0x43, 0x7c, 0x1c, 0x1e, 0xb1, 0x89,
 704     0x8d, 0xce, 0x20, 0x54, 0x81, 0x80, 0xb5, 0x8f, 0x9b, 0xb1, 0x09, 0x92,
 705     0xdb, 0x25, 0x6f, 0x30, 0x29, 0x08, 0x1a, 0x05, 0x08, 0xf4, 0x83, 0x8b,
 706     0x1e, 0x2d, 0xfd, 0xe4, 0xb2, 0x76, 0xc8, 0x4d, 0xf3, 0xa6, 0x49, 0x5f,
 707     0x2c, 0x99, 0x78, 0xbd, 0x07, 0xef, 0xc8, 0xd9, 0xb5, 0x70, 0x3b, 0x0a,
 708     0xcb, 0xbd, 0xa0, 0xea, 0x15, 0xfb, 0xd1, 0x6e, 0x61, 0x83, 0xcb, 0x90,
 709     0xd0, 0xa3, 0x81, 0x28, 0xdc, 0xd5, 0x84, 0xae, 0x55, 0x28, 0x13, 0x9e,
 710     0xc6, 0xd8, 0xf4, 0x67, 0xd6, 0x0d, 0xd4, 0x69, 0xac, 0xf6, 0x35, 0x95,
 711     0x99, 0x44, 0x26, 0x72, 0x36, 0x55, 0xf9, 0x42, 0xa6, 0x1b, 0x00, 0x93,
 712     0x00, 0x19, 0x2f, 0x70, 0xd3, 0x16, 0x66, 0x4e, 0x80, 0xbb, 0xb6, 0x84,
 713     0xa1, 0x2c, 0x09, 0xfb, 0x41, 0xdf, 0x63, 0xde, 0x62, 0x3e, 0xd0, 0xa8,
 714     0xd8, 0x0c, 0x03, 0x06, 0xa9, 0x82, 0x17, 0x9c, 0xd2, 0xa9, 0xd5, 0x6f,
 715     0xcc, 0xc0, 0xf2, 0x5d, 0xb1, 0xba, 0xf8, 0x2e, 0x37, 0x8b, 0xe6, 0x5d,
 716     0x9f, 0x1b, 0xfb, 0x53, 0x0a, 0x96, 0xbe, 0x69, 0x31, 0x19, 0x8f, 0x44,
 717     0x1b, 0xc2, 0x42, 0x7e, 0x65, 0x12, 0x1d, 0x52, 0x1e, 0xe2, 0xc0, 0x86,
 718     0x70, 0x88, 0xe5, 0xf6, 0x87, 0x5d, 0x03, 0x4b, 0x12, 0x3c, 0x2d, 0xaf,
 719     0x09, 0xf5, 0x4f, 0x82, 0x2e, 0x2e, 0xbe, 0x07, 0xe8, 0x8d, 0x57, 0x6e,
 720     0xc0, 0xeb, 0xf9, 0x37, 0xac, 0x89, 0x01, 0xb7, 0xc6, 0x52, 0x1c, 0x86,
 721     0xe5, 0xbc, 0x1f, 0xbd, 0xde, 0xa2, 0x42, 0xb6, 0x73, 0x85, 0x6f, 0x06,
 722     0x36, 0x56, 0x40, 0x2b, 0xea, 0x16, 0x8c, 0xf4, 0x7b, 0x65, 0x6a, 0xca,
 723     0x3c, 0x56, 0x68, 0x01, 0xe3, 0x9c, 0xbb, 0xb9, 0x45, 0x54, 0xcd, 0x13,
 724     0x74, 0xad, 0x80, 0x40, 0xbc, 0xd0, 0x74, 0xb4, 0x31, 0xe4, 0xca, 0xd5,
 725     0xf8, 0x4f, 0x08, 0x5b, 0xc4, 0x15, 0x1a, 0x51, 0x3b, 0xc6, 0x40, 0xc8,
 726     0xea, 0x76, 0x30, 0x95, 0xb7, 0x76, 0xa4, 0xda, 0x20, 0xdb, 0x75, 0x1c,
 727     0xf4, 0x87, 0x24, 0x29, 0x54, 0xc6, 0x59, 0x0c, 0xf0, 0xed, 0xf5, 0x3d,
 728     0xce, 0x95, 0x23, 0x30, 0x49, 0x91, 0xa7, 0x7b, 0x22, 0xb5, 0xd7, 0x71,
 729     0xb0, 0x60, 0xe1, 0xf0, 0x84, 0x74, 0x0e, 0x2f, 0xa8, 0x79, 0x35, 0xb9,
 730     0x03, 0xb5, 0x2c, 0xdc, 0x60, 0x48, 0x12, 0xd9, 0x14, 0x5a, 0x58, 0x5d,
 731     0x95, 0xc6, 0x47, 0xfd, 0xaf, 0x09, 0xc2, 0x67, 0xa5, 0x09, 0xae, 0xff,
 732     0x4b, 0xd5, 0x6c, 0x2f, 0x1d, 0x33, 0x31, 0xcb, 0xdb, 0xcf, 0xf5, 0xf6,
 733     0xbc, 0x90, 0xb2, 0x15, 0xd4, 0x34, 0xeb, 0xde, 0x0e, 0x8f, 0x3d, 0xea,
 734     0xa4, 0x9b, 0x29, 0x8a, 0xf9, 0x4a, 0xac, 0x38, 0x1e, 0x46, 0xb2, 0x2d,
 735     0xa2, 0x61, 0xc5, 0x99, 0x5e, 0x85, 0x36, 0x85, 0xb0, 0xb1, 0x6b, 0xc4,
 736     0x06, 0x68, 0xc7, 0x9b, 0x54, 0xb9, 0xc8, 0x9d, 0xf3, 0x1a, 0xe0, 0x67,
 737     0x0e, 0x4d, 0x5c, 0x13, 0x54, 0xa4, 0x62, 0x62, 0x6f, 0xae, 0x0e, 0x86,
 738     0xa2, 0xe0, 0x31, 0xc7, 0x72, 0xa1, 0xbb, 0x87, 0x3e, 0x61, 0x96, 0xb7,
 739     0x53, 0xf9, 0x34, 0xcb, 0xfd, 0x6c, 0x67, 0x25, 0x73, 0x61, 0x75, 0x4f,
 740     0xab, 0x37, 0x08, 0xef, 0x35, 0x5a, 0x03, 0xe5, 0x08, 0x43, 0xec, 0xdc,
 741     0xb5, 0x2c, 0x1f, 0xe6, 0xeb, 0xc6, 0x06, 0x0b, 0xed, 0xad, 0x74, 0xf4,
 742     0x55, 0xef, 0xe0, 0x2e, 0x83, 0x00, 0xdb, 0x32, 0xde, 0xe9, 0xe4, 0x2f,
 743     0xf5, 0x20, 0x6d, 0x72, 0x47, 0xf4, 0x68, 0xa6, 0x7f, 0x3e, 0x6a, 0x5a,
 744     0x21, 0x76, 0x31, 0x97, 0xa0, 0xc6, 0x7d, 0x03, 0xf7, 0x27, 0x45, 0x5a,
 745     0x75, 0x03, 0xc1, 0x5c, 0x94, 0x2b, 0x37, 0x9f, 0x46, 0x8f, 0xc3, 0xa7,
 746     0x50, 0xe4, 0xe7, 0x23, 0xf7, 0x20, 0xa2, 0x8e, 0x4b, 0xfd, 0x7a, 0xa7,
 747     0x8a, 0x54, 0x7b, 0x32, 0xef, 0x0e, 0x82, 0xb9, 0xf9, 0x14, 0x62, 0x68,
 748     0x32, 0x9e, 0x55, 0xc0, 0xd8, 0xc7, 0x41, 0x9c, 0x67, 0x95, 0xbf, 0xc3,
 749     0x86, 0x74, 0x70, 0x64, 0x44, 0x23, 0x77, 0x79, 0x82, 0x23, 0x1c, 0xf4,
 750     0xa1, 0x05, 0xd3, 0x98, 0x89, 0xde, 0x7d, 0xb3, 0x5b, 0xef, 0x38, 0xd2,
 751     0x07, 0xbc, 0x5a, 0x69, 0xa3, 0xe4, 0x37, 0x9b, 0x53, 0xff, 0x04, 0x6b,
 752     0xd9, 0xd8, 0x32, 0x89, 0xf7, 0x82, 0x77, 0xcf, 0xe6, 0xff, 0xf4, 0x15,
 753     0x54, 0x91, 0x65, 0x96, 0x49, 0xd7, 0x0a, 0xa4, 0xf3, 0x55, 0x2b, 0xc1,
 754     0x48, 0xc1, 0x7e, 0x56, 0x69, 0x27, 0xf4, 0xd1, 0x47, 0x1f, 0xde, 0x86,
 755     0x15, 0x67, 0x04, 0x9d, 0x41, 0x1f, 0xe8, 0xe1, 0x23, 0xe4, 0x56, 0xb9,
 756     0xdb, 0x4e, 0xe4, 0x84, 0x6c, 0x63, 0x39, 0xad, 0x44, 0x6d, 0x4e, 0x28,
 757     0xcd, 0xf6, 0xac, 0xec, 0xc2, 0xad, 0xcd, 0xc3, 0xed, 0x03, 0x63, 0x5d,
 758     0xef, 0x1d, 0x40, 0x8d, 0x9a, 0x02, 0x67, 0x4b, 0x55, 0xb5, 0xfe, 0x75,
 759     0xb6, 0x53, 0x34, 0x1d, 0x7b, 0x26, 0x23, 0xfe, 0xb9, 0x21, 0xd3, 0xe0,
 760     0xa0, 0x1a, 0x85, 0xe5
 761 };
 762
 763 static const unsigned char stream_10b[1300] = {
 764     0x18, 0x00, 0xd7, 0xfb, 0x12, 0xda, 0xdb, 0x68, 0xeb, 0x38, 0x4d, 0xf6,
 765     0xb2, 0x45, 0x74, 0x4c, 0xcc, 0xe7, 0xa7, 0xc1, 0x26, 0x84, 0x3d, 0xdf,
 766     0x7d, 0xc5, 0xe9, 0xd4, 0x31, 0xa2, 0x51, 0x38, 0x95, 0xe2, 0x68, 0x11,
 767     0x9d, 0xd1, 0x52, 0xb5, 0xef, 0x76, 0xe0, 0x3d, 0x11, 0x50, 0xd7, 0xb2,
 768     0xc1, 0x7d, 0x12, 0xaf, 0x02, 0x52, 0x97, 0x03, 0xf3, 0x2e, 0x54, 0xdf,
 769     0xa0, 0x40, 0x76, 0x52, 0x82, 0x23, 0x3c, 0xbd, 0x20, 0x6d, 0x0a, 0x6f,
 770     0x81, 0xfc, 0x41, 0x9d, 0x2e, 0xa7, 0x2c, 0x78, 0x9c, 0xd8, 0x56, 0xb0,
 771     0x31, 0x35, 0xc8, 0x53, 0xef, 0xf9, 0x43, 0x17, 0xc0, 0x8c, 0x2c, 0x8f,
 772     0x4a, 0x68, 0xe8, 0x9f, 0xbd, 0x3f, 0xf2, 0x18, 0xb8, 0xe6, 0x55, 0xea,
 773     0x2a, 0x37, 0x3e, 0xac, 0xb0, 0x75, 0xd4, 0x75, 0x12, 0x82, 0xec, 0x21,
 774     0xb9, 0xce, 0xe5, 0xc1, 0x62, 0x49, 0xd5, 0xf1, 0xca, 0xd4, 0x32, 0x76,
 775     0x34, 0x5f, 0x3e, 0xc9, 0xb3, 0x54, 0xe4, 0xd0, 0xa9, 0x7d, 0x0c, 0x64,
 776     0x48, 0x0a, 0x74, 0x38, 0x03, 0xd0, 0x20, 0xac, 0xe3, 0x58, 0x3d, 0x4b,
 777     0xa7, 0x46, 0xac, 0x57, 0x63, 0x12, 0x17, 0xcb, 0x96, 0xed, 0xc9, 0x39,
 778     0x64, 0xde, 0xff, 0xc6, 0xb2, 0x40, 0x2c, 0xf9, 0x1d, 0xa6, 0x94, 0x2a,
 779     0x16, 0x4d, 0x7f, 0x22, 0x91, 0x8b, 0xfe, 0x83, 0x77, 0x02, 0x68, 0x62,
 780     0x27, 0x77, 0x2e, 0xe9, 0xce, 0xbc, 0x20, 0xe8, 0xfb, 0xf8, 0x4e, 0x17,
 781     0x07, 0xe1, 0xaa, 0x29, 0xb7, 0x50, 0xcf, 0xb0, 0x6a, 0xcf, 0x01, 0xec,
 782     0xbf, 0xff, 0xb5, 0x9f, 0x00, 0x64, 0x80, 0xbb, 0xa6, 0xe4, 0xa2, 0x1e,
 783     0xe4, 0xf8, 0xa3, 0x0d, 0xc7, 0x65, 0x45, 0xb7, 0x01, 0x33, 0x80, 0x37,
 784     0x11, 0x16, 0x34, 0xc1, 0x06, 0xc5, 0xd3, 0xc4, 0x70, 0x62, 0x75, 0xd8,
 785     0xa3, 0xba, 0x84, 0x9f, 0x81, 0x9f, 0xda, 0x01, 0x83, 0x42, 0x84, 0x05,
 786     0x69, 0x68, 0xb0, 0x74, 0x73, 0x0f, 0x68, 0x39, 0xd3, 0x11, 0xc5, 0x55,
 787     0x3e, 0xf2, 0xb7, 0xf4, 0xa6, 0xed, 0x0b, 0x50, 0xbe, 0x44, 0xf8, 0x67,
 788     0x48, 0x46, 0x5e, 0x71, 0x07, 0xcf, 0xca, 0x8a, 0xbc, 0xa4, 0x3c, 0xd2,
 789     0x4a, 0x80, 0x2e, 0x4f, 0xc5, 0x3b, 0x61, 0xc1, 0x7e, 0x93, 0x9e, 0xe0,
 790     0x05, 0xfb, 0x10, 0xe8, 0x53, 0xff, 0x16, 0x5e, 0x18, 0xe0, 0x9f, 0x39,
 791     0xbf, 0xaa, 0x80, 0x6d, 0xb7, 0x9f, 0x51, 0x91, 0xa0, 0xf6, 0xce, 0xad,
 792     0xed, 0x56, 0x15, 0xb9, 0x12, 0x57, 0x60, 0xa6, 0xae, 0x54, 0x6e, 0x36,
 793     0xf3, 0xe0, 0x05, 0xd8, 0x3e, 0x6d, 0x08, 0x36, 0xc9, 0x79, 0x64, 0x51,
 794     0x63, 0x92, 0xa8, 0xa1, 0xbf, 0x55, 0x26, 0x80, 0x75, 0x44, 0x33, 0x33,
 795     0xfb, 0xb7, 0xec, 0xf9, 0xc6, 0x01, 0xf9, 0xd5, 0x93, 0xfc, 0xb7, 0x43,
 796     0xa2, 0x38, 0x0d, 0x17, 0x75, 0x67, 0xec, 0xc9, 0x98, 0xd6, 0x25, 0xe6,
 797     0xb9, 0xed, 0x61, 0xa4, 0xee, 0x2c, 0xda, 0x27, 0xbd, 0xff, 0x86, 0x1e,
 798     0x45, 0x64, 0xfe, 0xcf, 0x0c, 0x9b, 0x7b, 0x75, 0x5f, 0xf1, 0xe0, 0xba,
 799     0x77, 0x8c, 0x03, 0x8f, 0xb4, 0x3a, 0xb6, 0x9c, 0xda, 0x9a, 0x83, 0xcb,
 800     0xe9, 0xcb, 0x3f, 0xf4, 0x10, 0x99, 0x5b, 0xe1, 0x19, 0x8f, 0x6b, 0x95,
 801     0x50, 0xe6, 0x78, 0xc9, 0x35, 0xb6, 0x87, 0xd8, 0x9e, 0x17, 0x30, 0x96,
 802     0x70, 0xa3, 0x04, 0x69, 0x1c, 0xa2, 0x6c, 0xd4, 0x88, 0x48, 0x44, 0x14,
 803     0x94, 0xd4, 0xc9, 0x4d, 0xe3, 0x82, 0x7e, 0x62, 0xf0, 0x0a, 0x18, 0x4d,
 804     0xd0, 0xd6, 0x63, 0xa3, 0xdf, 0xea, 0x28, 0xf4, 0x00, 0x75, 0x70, 0x78,
 805     0x08, 0x70, 0x3f, 0xff, 0x84, 0x86, 0x72, 0xea, 0x4f, 0x15, 0x8c, 0x17,
 806     0x60, 0x5f, 0xa1, 0x50, 0xa0, 0xfc, 0x6f, 0x8a, 0x46, 0xfc, 0x01, 0x8d,
 807     0x7c, 0xdc, 0x69, 0x6a, 0xd3, 0x74, 0x69, 0x76, 0x77, 0xdd, 0xe4, 0x9c,
 808     0x49, 0x1e, 0x6f, 0x7d, 0x31, 0x14, 0xd9, 0xe9, 0xe7, 0x17, 0x66, 0x82,
 809     0x1b, 0xf1, 0x0f, 0xe2, 0xba, 0xd2, 0x28, 0xd1, 0x6f, 0x48, 0xc7, 0xac,
 810     0x08, 0x4e, 0xee, 0x94, 0x66, 0x99, 0x34, 0x16, 0x5d, 0x95, 0xae, 0xe3,
 811     0x59, 0x79, 0x7f, 0x8e, 0x9f, 0xe3, 0xdb, 0xff, 0xdc, 0x4d, 0xb0, 0xbf,
 812     0xf9, 0xf3, 0x3e, 0xec, 0xcf, 0x50, 0x3d, 0x2d, 0xba, 0x94, 0x1f, 0x1a,
 813     0xab, 0xa4, 0xf4, 0x67, 0x43, 0x7e, 0xb9, 0x65, 0x20, 0x13, 0xb1, 0xd9,
 814     0x88, 0x4a, 0x24, 0x13, 0x84, 0x86, 0xae, 0x2b, 0x0c, 0x6c, 0x7e, 0xd4,
 815     0x25, 0x6e, 0xaa, 0x8d, 0x0c, 0x54, 0x99, 0xde, 0x1d, 0xac, 0x8c, 0x5c,
 816     0x73, 0x94, 0xd9, 0x75, 0xcb, 0x5a, 0x54, 0x3d, 0xeb, 0xff, 0xc1, 0x95,
 817     0x53, 0xb5, 0x39, 0xf7, 0xe5, 0xf1, 0x77, 0xd1, 0x42, 0x82, 0x4b, 0xb0,
 818     0xab, 0x19, 0x28, 0xff, 0x53, 0x28, 0x87, 0x46, 0xc6, 0x6f, 0x05, 0x06,
 819     0xa6, 0x0c, 0x97, 0x93, 0x68, 0x38, 0xe1, 0x61, 0xed, 0xf8, 0x90, 0x13,
 820     0xa3, 0x6f, 0xf2, 0x08, 0x37, 0xd7, 0x05, 0x25, 0x34, 0x43, 0x57, 0x72,
 821     0xfd, 0x6c, 0xc2, 0x19, 0x26, 0xe7, 0x50, 0x30, 0xb8, 0x6d, 0x09, 0x71,
 822     0x83, 0x75, 0xd4, 0x11, 0x25, 0x29, 0xc6, 0xee, 0xb2, 0x51, 0x1c, 0x1c,
 823     0x9e, 0x2d, 0x09, 0xb9, 0x73, 0x2b, 0xbf, 0xda, 0xc8, 0x1e, 0x2b, 0xe5,
 824     0x3f, 0x1e, 0x63, 0xe9, 0xc0, 0x6d, 0x04, 0x3a, 0x48, 0x61, 0xa8, 0xc6,
 825     0x16, 0x8d, 0x69, 0xc0, 0x67, 0x0c, 0x3b, 0xc4, 0x05, 0x36, 0xa1, 0x30,
 826     0x62, 0x92, 0x4d, 0x44, 0x31, 0x66, 0x46, 0xda, 0xef, 0x0f, 0x4e, 0xfb,
 827     0x78, 0x6a, 0xa9, 0x5b, 0xf8, 0x56, 0x26, 0x74, 0x16, 0xab, 0x17, 0x93,
 828     0x3c, 0x36, 0xbb, 0xa2, 0xbf, 0xad, 0xba, 0xb1, 0xfe, 0xc4, 0x9f, 0x75,
 829     0x47, 0x1e, 0x99, 0x7e, 0x32, 0xe8, 0xd4, 0x6c, 0xa4, 0xf8, 0xd2, 0xe4,
 830     0xb2, 0x51, 0xbb, 0xb2, 0xd7, 0xce, 0x94, 0xaf, 0x7f, 0xe6, 0x2c, 0x13,
 831     0xae, 0xd2, 0x29, 0x30, 0x7b, 0xfd, 0x25, 0x61, 0xf9, 0xe8, 0x35, 0x2d,
 832     0x1a, 0xc9, 0x81, 0xa5, 0xfe, 0xce, 0xf6, 0x17, 0xc5, 0xfb, 0x8c, 0x79,
 833     0x67, 0xa8, 0x5f, 0x5c, 0x31, 0xbc, 0xfc, 0xf3, 0x6b, 0xd3, 0x0d, 0xe0,
 834     0x62, 0xab, 0x86, 0xc3, 0x17, 0x5a, 0xba, 0x97, 0x86, 0x8f, 0x65, 0xd6,
 835     0xbd, 0x0c, 0xa1, 0xfb, 0x7f, 0x7c, 0xdc, 0xcb, 0x94, 0x30, 0x0b, 0x04,
 836     0x54, 0xc4, 0x31, 0xa1, 0xca, 0x1e, 0xc5, 0xf0, 0xb6, 0x08, 0xd7, 0x2e,
 837     0xa1, 0x90, 0x41, 0xce, 0xd9, 0xef, 0x3a, 0x58, 0x01, 0x1a, 0x73, 0x18,
 838     0xad, 0xdc, 0x20, 0x25, 0x95, 0x1a, 0xfe, 0x61, 0xf1, 0x58, 0x32, 0x8b,
 839     0x43, 0x59, 0xd6, 0x21, 0xdb, 0xa9, 0x8e, 0x54, 0xe6, 0x21, 0xcf, 0xd3,
 840     0x6b, 0x59, 0x29, 0x9b, 0x3e, 0x6c, 0x7f, 0xe2, 0x29, 0x72, 0x8c, 0xd1,
 841     0x3e, 0x9a, 0x84, 0x98, 0xb0, 0xf3, 0x20, 0x30, 0x34, 0x71, 0xa7, 0x5b,
 842     0xf0, 0x26, 0xe1, 0xf4, 0x76, 0x65, 0xc9, 0xd7, 0xe4, 0xb9, 0x25, 0x48,
 843     0xc2, 0x7e, 0xa6, 0x0b, 0x0d, 0x05, 0x68, 0xa1, 0x96, 0x61, 0x0b, 0x4c,
 844     0x2f, 0x1a, 0xe3, 0x56, 0x71, 0x89, 0x48, 0x66, 0xd8, 0xd0, 0x69, 0x37,
 845     0x7a, 0xdf, 0xdb, 0xed, 0xad, 0x82, 0xaa, 0x40, 0x25, 0x47, 0x3e, 0x75,
 846     0xa6, 0x0e, 0xf5, 0x2f, 0xa7, 0x4e, 0x97, 0xa2, 0x5f, 0x01, 0x99, 0x48,
 847     0x3a, 0x63, 0x18, 0x20, 0x61, 0x72, 0xe4, 0xcf, 0x4b, 0x3b, 0x99, 0x36,
 848     0xe1, 0xf3, 0xbf, 0xae, 0x2b, 0x6b, 0xa1, 0x94, 0xa0, 0x15, 0x94, 0xd6,
 849     0xe0, 0xba, 0x71, 0xa2, 0x85, 0xa0, 0x8c, 0x5e, 0x58, 0xe2, 0xde, 0x6b,
 850     0x08, 0x68, 0x90, 0x82, 0x71, 0x8d, 0xfd, 0x12, 0xa2, 0x49, 0x87, 0x70,
 851     0xee, 0x2a, 0x08, 0xe2, 0x26, 0xaf, 0xeb, 0x85, 0x35, 0xd2, 0x0e, 0xfd,
 852     0x2b, 0x6f, 0xc0, 0xfe, 0x41, 0xbb, 0xd7, 0x0a, 0xa3, 0x8d, 0x8b, 0xec,
 853     0x44, 0x9f, 0x46, 0x59, 0x4d, 0xac, 0x04, 0x1e, 0xde, 0x10, 0x7b, 0x17,
 854     0x0a, 0xb0, 0xcc, 0x26, 0x0c, 0xa9, 0x3c, 0x5f, 0xd8, 0xe6, 0x52, 0xd3,
 855     0xfd, 0x0b, 0x66, 0x75, 0x06, 0x84, 0x23, 0x64, 0x2b, 0x80, 0x68, 0xf9,
 856     0xcb, 0xcd, 0x04, 0x07, 0xf7, 0xe0, 0x07, 0xb4, 0xc6, 0xa0, 0x08, 0xd0,
 857     0x76, 0x16, 0x77, 0xd8, 0x48, 0xf0, 0x45, 0x4e, 0xe2, 0xf2, 0x88, 0xcd,
 858     0x0f, 0xbd, 0x7d, 0xb6, 0xbe, 0x4e, 0x9e, 0x5d, 0x6c, 0x47, 0x26, 0x34,
 859     0x94, 0xfb, 0xc5, 0x4f, 0x5c, 0xb5, 0xb5, 0xfc, 0x99, 0x34, 0x71, 0xe5,
 860     0xe1, 0x36, 0x0c, 0xd2, 0x95, 0xb8, 0x93, 0x3c, 0x5d, 0x2d, 0x71, 0x55,
 861     0x0b, 0x96, 0x4e, 0x9f, 0x07, 0x9a, 0x38, 0x9a, 0xcc, 0x24, 0xb5, 0xac,
 862     0x05, 0x8b, 0x1c, 0x61, 0xd4, 0xf2, 0xdf, 0x9e, 0x11, 0xe3, 0x7d, 0x64,
 863     0x2f, 0xe5, 0x13, 0xd4, 0x0a, 0xe9, 0x32, 0x26, 0xa8, 0x93, 0x21, 0x59,
 864     0xf3, 0x41, 0x48, 0x0a, 0xbd, 0x59, 0x8f, 0xf8, 0x72, 0xab, 0xd3, 0x65,
 865     0x8e, 0xdc, 0xaa, 0x0c, 0xc0, 0x01, 0x36, 0xb7, 0xf5, 0x84, 0x27, 0x9a,
 866     0x98, 0x89, 0x73, 0x3a, 0xeb, 0x55, 0x15, 0xc9, 0x3d, 0xe1, 0xf8, 0xea,
 867     0xf6, 0x11, 0x28, 0xe0, 0x80, 0x93, 0xcc, 0xba, 0xe1, 0xf1, 0x81, 0xbc,
 868     0xa4, 0x30, 0xbc, 0x98, 0xe8, 0x9e, 0x8d, 0x17, 0x7e, 0xb7, 0xb1, 0x27,
 869     0x6f, 0xcf, 0x9c, 0x0d, 0x1d, 0x01, 0xea, 0x45, 0xc0, 0x90, 0xda, 0x53,
 870     0xf6, 0xde, 0xdf, 0x12, 0xa1, 0x23, 0x3d, 0x92, 0x89, 0x77, 0xa7, 0x2a,
 871     0xe7, 0x45, 0x24, 0xdd, 0xf2, 0x17, 0x10, 0xca, 0x6e, 0x14, 0xb2, 0x77,
 872     0x08, 0xc4, 0x18, 0xcd
 873 };
 874
 875 static uint64_t stream_10a_off, stream_10b_off;
 876
 877 static int check_stream_10a(struct helper *h)
 878 {
 879     /*
 880      * Must have filled or almost filled the packet (using default MDPL of
 881      * 1200).
 882      */
 883     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 884         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 885         return 0;
 886
 887     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 888                      stream_10a, (size_t)h->frame.stream.len))
 889         return 0;
 890
 891     stream_10a_off = h->frame.stream.offset + h->frame.stream.len;
 892     return 1;
 893 }
 894
 895 static int check_stream_10b(struct helper *h)
 896 {
 897     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 898         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 899         return 0;
 900
 901     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 902                      stream_10b, (size_t)h->frame.stream.len))
 903         return 0;
 904
 905     stream_10b_off = h->frame.stream.offset + h->frame.stream.len;
 906     return 1;
 907 }
 908
 909 static int check_stream_10c(struct helper *h)
 910 {
 911     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 912         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 913         return 0;
 914
 915     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 916                      stream_10a + stream_10a_off, (size_t)h->frame.stream.len))
 917         return 0;
 918
 919     return 1;
 920 }
 921
 922 static int check_stream_10d(struct helper *h)
 923 {
 924     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 925         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 926         return 0;
 927
 928     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 929                      stream_10b + stream_10b_off, (size_t)h->frame.stream.len))
 930         return 0;
 931
 932     return 1;
 933 }
 934
 935 static const struct script_op script_10[] = {
 936     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 937     OP_HANDSHAKE_COMPLETE()
 938     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 939     OP_STREAM_NEW(42)
 940     OP_STREAM_NEW(43)
 941     OP_CONN_TXFC_BUMP(10000)
 942     OP_STREAM_TXFC_BUMP(42, 5000)
 943     OP_STREAM_TXFC_BUMP(43, 5000)
 944     OP_STREAM_SEND(42, stream_10a)
 945     OP_STREAM_SEND(43, stream_10b)
 946
 947     /* First packet containing data from stream 42 */
 948     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 949     OP_RX_PKT()
 950     OP_EXPECT_DGRAM_LEN(1100, 1200)
 951     OP_NEXT_FRAME()
 952     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 953     OP_CHECK(check_stream_10a)
 954     OP_EXPECT_NO_FRAME()
 955
 956     /* Second packet containing data from stream 43 */
 957     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 958     OP_RX_PKT()
 959     OP_EXPECT_DGRAM_LEN(1100, 1200)
 960     OP_NEXT_FRAME()
 961     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 962     OP_CHECK(check_stream_10b)
 963     OP_EXPECT_NO_FRAME()
 964
 965     /* Third packet containing data from stream 42 */
 966     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 967     OP_RX_PKT()
 968     OP_EXPECT_DGRAM_LEN(200, 500)
 969     OP_NEXT_FRAME()
 970     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN)
 971     OP_CHECK(check_stream_10c)
 972     OP_NEXT_FRAME()
 973     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF)
 974     OP_CHECK(check_stream_10d)
 975     OP_EXPECT_NO_FRAME()
 976
 977     OP_RX_PKT_NONE()
 978     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 979
 980     OP_END
 981 };
 982
 983 /* 11. Initial, CRYPTO */
 984 static const struct script_op script_11[] = {
 985     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
 986     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 987     OP_CRYPTO_SEND(QUIC_PN_SPACE_INITIAL, crypto_1)
 988     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
 989     OP_RX_PKT()
 990     OP_EXPECT_DGRAM_LEN(1200, 1200)
 991     OP_NEXT_FRAME()
 992     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 993     OP_EXPECT_NO_FRAME()
 994     OP_RX_PKT_NONE()
 995     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
 996     OP_END
 997 };
 998
 999 /* 12. 1-RTT, STOP_SENDING */
1000 static int check_stream_12(struct helper *h)
1001 {
1002     if (!TEST_uint64_t_eq(h->frame.stop_sending.stream_id, 42)
1003         || !TEST_uint64_t_eq(h->frame.stop_sending.app_error_code, 4568))
1004         return 0;
1005
1006     return 1;
1007 }
1008
1009 static const struct script_op script_12[] = {
1010     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1011     OP_HANDSHAKE_COMPLETE()
1012     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1013     OP_STREAM_NEW(42)
1014     OP_STOP_SENDING(42, 4568)
1015     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1016     OP_RX_PKT()
1017     OP_EXPECT_DGRAM_LEN(21, 128)
1018     OP_NEXT_FRAME()
1019     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
1020     OP_CHECK(check_stream_12)
1021     OP_EXPECT_NO_FRAME()
1022     OP_RX_PKT_NONE()
1023     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1024     OP_END
1025 };
1026
1027 /* 13. 1-RTT, RESET_STREAM */
1028 static const unsigned char stream_13[] = {
1029     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
1030 };
1031
1032 static ossl_unused int check_stream_13(struct helper *h)
1033 {
1034     if (!TEST_uint64_t_eq(h->frame.reset_stream.stream_id, 42)
1035         || !TEST_uint64_t_eq(h->frame.reset_stream.app_error_code, 4568)
1036         || !TEST_uint64_t_eq(h->frame.reset_stream.final_size, 0))
1037         return 0;
1038
1039     return 1;
1040 }
1041
1042 static const struct script_op script_13[] = {
1043     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1044     OP_HANDSHAKE_COMPLETE()
1045     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1046     OP_STREAM_NEW(42)
1047     OP_CONN_TXFC_BUMP(8)
1048     OP_STREAM_TXFC_BUMP(42, 8)
1049     OP_STREAM_SEND(42, stream_13)
1050     OP_RESET_STREAM(42, 4568)
1051     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1052     OP_RX_PKT()
1053     OP_EXPECT_DGRAM_LEN(21, 128)
1054     OP_NEXT_FRAME()
1055     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
1056     OP_CHECK(check_stream_13)
1057     OP_NEXT_FRAME()
1058     OP_EXPECT_NO_FRAME()
1059     OP_RX_PKT_NONE()
1060     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1061     OP_END
1062 };
1063
1064 /* 14. 1-RTT, CONNECTION_CLOSE */
1065 static int gen_conn_close(struct helper *h)
1066 {
1067     OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
1068
1069     f.error_code     = 2345;
1070     f.frame_type     = OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE;
1071     f.reason         = "Reason string";
1072     f.reason_len     = strlen(f.reason);
1073
1074     if (!TEST_true(ossl_quic_tx_packetiser_schedule_conn_close(h->txp, &f)))
1075         return 0;
1076
1077     return 1;
1078 }
1079
1080 static int check_14(struct helper *h)
1081 {
1082     if (!TEST_int_eq(h->frame.conn_close.is_app, 0)
1083         || !TEST_uint64_t_eq(h->frame.conn_close.frame_type,
1084                              OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
1085         || !TEST_uint64_t_eq(h->frame.conn_close.error_code, 2345)
1086         || !TEST_mem_eq(h->frame.conn_close.reason, h->frame.conn_close.reason_len,
1087                         "Reason string", 13))
1088         return 0;
1089
1090     return 1;
1091 }
1092
1093 static const struct script_op script_14[] = {
1094     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1095     OP_HANDSHAKE_COMPLETE()
1096     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1097     OP_CHECK(gen_conn_close)
1098     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1099     OP_RX_PKT()
1100     OP_EXPECT_DGRAM_LEN(21, 512)
1101     OP_NEXT_FRAME()
1102     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT)
1103     OP_CHECK(check_14)
1104     OP_EXPECT_NO_FRAME()
1105     OP_RX_PKT_NONE()
1106     OP_END
1107 };
1108
1109 /* 15. INITIAL, Anti-Deadlock Probe Simulation */
1110 static int gen_probe_initial(struct helper *h)
1111 {
1112     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1113
1114     /*
1115      * Pretend the ACKM asked for an anti-deadlock Initial probe.
1116      * We test output of this in the ACKM unit tests.
1117      */
1118     ++probe->anti_deadlock_initial;
1119     return 1;
1120 }
1121
1122 static const struct script_op script_15[] = {
1123     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1124     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1125     OP_CHECK(gen_probe_initial)
1126     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1127     OP_RX_PKT()
1128     OP_EXPECT_DGRAM_LEN(1200, 1200)
1129     OP_NEXT_FRAME()
1130     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1131     OP_EXPECT_NO_FRAME()
1132     OP_RX_PKT_NONE()
1133     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1134     OP_END
1135 };
1136
1137 /* 16. HANDSHAKE, Anti-Deadlock Probe Simulation */
1138 static int gen_probe_handshake(struct helper *h)
1139 {
1140     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1141
1142     /*
1143      * Pretend the ACKM asked for an anti-deadlock Handshake probe.
1144      * We test output of this in the ACKM unit tests.
1145      */
1146     ++probe->anti_deadlock_handshake;
1147     return 1;
1148 }
1149
1150 static const struct script_op script_16[] = {
1151     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1152     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1153     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1154     OP_CHECK(gen_probe_handshake)
1155     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1156     OP_RX_PKT()
1157     OP_EXPECT_DGRAM_LEN(21, 512)
1158     OP_NEXT_FRAME()
1159     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1160     OP_EXPECT_NO_FRAME()
1161     OP_RX_PKT_NONE()
1162     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1163     OP_END
1164 };
1165
1166 /* 17. 1-RTT, Probe Simulation */
1167 static int gen_probe_1rtt(struct helper *h)
1168 {
1169     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1170
1171     /*
1172      * Pretend the ACKM asked for a 1-RTT PTO probe.
1173      * We test output of this in the ACKM unit tests.
1174      */
1175     ++probe->pto[QUIC_PN_SPACE_APP];
1176     return 1;
1177 }
1178
1179 static const struct script_op script_17[] = {
1180     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1181     OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
1182     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1183     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1184     OP_CHECK(gen_probe_1rtt)
1185     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1186     OP_RX_PKT()
1187     OP_EXPECT_DGRAM_LEN(21, 512)
1188     OP_NEXT_FRAME()
1189     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1190     OP_EXPECT_NO_FRAME()
1191     OP_RX_PKT_NONE()
1192     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1193     OP_END
1194 };
1195
1196 static const struct script_op *const scripts[] = {
1197     script_1,
1198     script_2,
1199     script_3,
1200     script_4,
1201     script_5,
1202     script_6,
1203     script_7,
1204     script_8,
1205     script_9,
1206     script_10,
1207     script_11,
1208     script_12,
1209     script_13,
1210     script_14,
1211     script_15,
1212     script_16,
1213     script_17
1214 };
1215
1216 static void skip_padding(struct helper *h)
1217 {
1218     uint64_t frame_type;
1219
1220     if (!ossl_quic_wire_peek_frame_header(&h->pkt, &frame_type, NULL))
1221         return; /* EOF */
1222
1223     if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING)
1224         ossl_quic_wire_decode_padding(&h->pkt);
1225 }
1226
1227 static int run_script(int script_idx, const struct script_op *script)
1228 {
1229     int testresult = 0, have_helper = 0;
1230     QUIC_TXP_STATUS status;
1231     struct helper h;
1232     const struct script_op *op;
1233     size_t opn = 0;
1234
1235     if (!helper_init(&h))
1236         goto err;
1237
1238     have_helper = 1;
1239     for (op = script, opn = 0; op->opcode != OPK_END; ++op, ++opn) {
1240         switch (op->opcode) {
1241         case OPK_TXP_GENERATE:
1242             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0,
1243                                                               &status),
1244                              TX_PACKETISER_RES_SENT_PKT))
1245                 goto err;
1246
1247             ossl_qtx_finish_dgram(h.args.qtx);
1248             ossl_qtx_flush_net(h.args.qtx);
1249             break;
1250         case OPK_TXP_GENERATE_NONE:
1251             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0,
1252                                                               &status),
1253                              TX_PACKETISER_RES_NO_PKT))
1254                 goto err;
1255
1256             break;
1257         case OPK_RX_PKT:
1258             ossl_quic_demux_pump(h.demux);
1259             ossl_qrx_pkt_release(h.qrx_pkt);
1260             h.qrx_pkt = NULL;
1261             if (!TEST_true(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1262                 goto err;
1263             if (!TEST_true(PACKET_buf_init(&h.pkt,
1264                                            h.qrx_pkt->hdr->data,
1265                                            h.qrx_pkt->hdr->len)))
1266                 goto err;
1267             h.frame_type = UINT64_MAX;
1268             break;
1269         case OPK_RX_PKT_NONE:
1270             ossl_quic_demux_pump(h.demux);
1271             if (!TEST_false(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1272                 goto err;
1273             h.frame_type = UINT64_MAX;
1274             break;
1275         case OPK_EXPECT_DGRAM_LEN:
1276             if (!TEST_size_t_ge(h.qrx_pkt->datagram_len, (size_t)op->arg0)
1277                 || !TEST_size_t_le(h.qrx_pkt->datagram_len, (size_t)op->arg1))
1278                 goto err;
1279             break;
1280         case OPK_EXPECT_FRAME:
1281             if (!TEST_uint64_t_eq(h.frame_type, op->arg0))
1282                 goto err;
1283             break;
1284         case OPK_EXPECT_INITIAL_TOKEN:
1285             if (!TEST_mem_eq(h.qrx_pkt->hdr->token, h.qrx_pkt->hdr->token_len,
1286                              op->buf, (size_t)op->arg0))
1287                 goto err;
1288             break;
1289         case OPK_EXPECT_HDR:
1290             if (!TEST_true(cmp_pkt_hdr(h.qrx_pkt->hdr, op->buf,
1291                                        NULL, 0, 0)))
1292                 goto err;
1293             break;
1294         case OPK_CHECK:
1295             if (!TEST_true(op->check_func(&h)))
1296                 goto err;
1297             break;
1298         case OPK_NEXT_FRAME:
1299             skip_padding(&h);
1300             if (!ossl_quic_wire_peek_frame_header(&h.pkt, &h.frame_type, NULL)) {
1301                 h.frame_type = UINT64_MAX;
1302                 break;
1303             }
1304
1305             switch (h.frame_type) {
1306             case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
1307                 if (!TEST_true(ossl_quic_wire_decode_frame_handshake_done(&h.pkt)))
1308                     goto err;
1309                 break;
1310             case OSSL_QUIC_FRAME_TYPE_PING:
1311                 if (!TEST_true(ossl_quic_wire_decode_frame_ping(&h.pkt)))
1312                     goto err;
1313                 break;
1314             case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
1315                 if (!TEST_true(ossl_quic_wire_decode_frame_max_data(&h.pkt,
1316                                                                     &h.frame.max_data)))
1317                     goto err;
1318                 break;
1319             case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
1320                 if (!TEST_true(ossl_quic_wire_decode_frame_new_conn_id(&h.pkt,
1321                                                                        &h.frame.new_conn_id)))
1322                     goto err;
1323                 break;
1324             case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
1325                 if (!TEST_true(ossl_quic_wire_decode_frame_new_token(&h.pkt,
1326                                                                      &h.frame.new_token.token,
1327                                                                      &h.frame.new_token.token_len)))
1328                     goto err;
1329                 break;
1330             case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
1331             case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN:
1332                 h.frame.ack.ack_ranges      = h.ack_ranges;
1333                 h.frame.ack.num_ack_ranges  = OSSL_NELEM(h.ack_ranges);
1334                 if (!TEST_true(ossl_quic_wire_decode_frame_ack(&h.pkt,
1335                                                                h.args.ack_delay_exponent,
1336                                                                &h.frame.ack,
1337                                                                NULL)))
1338                     goto err;
1339                 break;
1340             case OSSL_QUIC_FRAME_TYPE_CRYPTO:
1341                 if (!TEST_true(ossl_quic_wire_decode_frame_crypto(&h.pkt, 0, &h.frame.crypto)))
1342                     goto err;
1343                 break;
1344
1345             case OSSL_QUIC_FRAME_TYPE_STREAM:
1346             case OSSL_QUIC_FRAME_TYPE_STREAM_FIN:
1347             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN:
1348             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN:
1349             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF:
1350             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN:
1351             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN:
1352             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN:
1353                 if (!TEST_true(ossl_quic_wire_decode_frame_stream(&h.pkt, 0, &h.frame.stream)))
1354                     goto err;
1355                 break;
1356
1357             case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
1358                 if (!TEST_true(ossl_quic_wire_decode_frame_stop_sending(&h.pkt,
1359                                                                         &h.frame.stop_sending)))
1360                     goto err;
1361                 break;
1362
1363             case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
1364                 if (!TEST_true(ossl_quic_wire_decode_frame_reset_stream(&h.pkt,
1365                                                                         &h.frame.reset_stream)))
1366                     goto err;
1367                 break;
1368
1369             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT:
1370             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP:
1371                 if (!TEST_true(ossl_quic_wire_decode_frame_conn_close(&h.pkt,
1372                                                                       &h.frame.conn_close)))
1373                     goto err;
1374                 break;
1375
1376             default:
1377                 TEST_error("unknown frame type");
1378                 goto err;
1379             }
1380             break;
1381         case OPK_EXPECT_NO_FRAME:
1382             skip_padding(&h);
1383             if (!TEST_size_t_eq(PACKET_remaining(&h.pkt), 0))
1384                 goto err;
1385             break;
1386         case OPK_PROVIDE_SECRET:
1387             if (!TEST_true(ossl_qtx_provide_secret(h.args.qtx,
1388                                                    (uint32_t)op->arg0,
1389                                                    (uint32_t)op->arg1,
1390                                                    NULL, op->buf, op->buf_len)))
1391                 goto err;
1392             if (!TEST_true(ossl_qrx_provide_secret(h.qrx,
1393                                                    (uint32_t)op->arg0,
1394                                                    (uint32_t)op->arg1,
1395                                                    NULL, op->buf, op->buf_len)))
1396                 goto err;
1397             break;
1398         case OPK_DISCARD_EL:
1399             if (!TEST_true(ossl_quic_tx_packetiser_discard_enc_level(h.txp,
1400                                                                      (uint32_t)op->arg0)))
1401                 goto err;
1402             /*
1403              * We do not discard on the QRX here, the object is to test the
1404              * TXP so if the TXP does erroneously send at a discarded EL we
1405              * want to know about it.
1406              */
1407             break;
1408         case OPK_CRYPTO_SEND:
1409             {
1410                 size_t consumed = 0;
1411
1412                 if (!TEST_true(ossl_quic_sstream_append(h.args.crypto[op->arg0],
1413                                                         op->buf, op->buf_len,
1414                                                         &consumed)))
1415                     goto err;
1416
1417                 if (!TEST_size_t_eq(consumed, op->buf_len))
1418                     goto err;
1419             }
1420             break;
1421         case OPK_STREAM_NEW:
1422             {
1423                 QUIC_STREAM *s;
1424
1425                 if (!TEST_ptr(s = ossl_quic_stream_map_alloc(h.args.qsm, op->arg0,
1426                                                              QUIC_STREAM_DIR_BIDI)))
1427                     goto err;
1428
1429                 if (!TEST_ptr(s->sstream = ossl_quic_sstream_new(512 * 1024))
1430                     || !TEST_true(ossl_quic_txfc_init(&s->txfc, &h.conn_txfc))
1431                     || !TEST_true(ossl_quic_rxfc_init(&s->rxfc, &h.conn_rxfc,
1432                                                       1 * 1024 * 1024,
1433                                                       16 * 1024 * 1024,
1434                                                       fake_now, NULL))
1435                     || !TEST_ptr(s->rstream = ossl_quic_rstream_new(&s->rxfc,
1436                                                                     NULL, 1024))) {
1437                     ossl_quic_sstream_free(s->sstream);
1438                     ossl_quic_stream_map_release(h.args.qsm, s);
1439                     goto err;
1440                 }
1441             }
1442             break;
1443         case OPK_STREAM_SEND:
1444             {
1445                 QUIC_STREAM *s;
1446                 size_t consumed = 0;
1447
1448                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1449                                                                  op->arg0)))
1450                     goto err;
1451
1452                 if (!TEST_true(ossl_quic_sstream_append(s->sstream, op->buf,
1453                                                         op->buf_len, &consumed)))
1454                     goto err;
1455
1456                 if (!TEST_size_t_eq(consumed, op->buf_len))
1457                     goto err;
1458
1459                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1460             }
1461             break;
1462         case OPK_STREAM_FIN:
1463             {
1464                 QUIC_STREAM *s;
1465
1466                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1467                                                                  op->arg0)))
1468                     goto err;
1469
1470                 ossl_quic_sstream_fin(s->sstream);
1471             }
1472             break;
1473         case OPK_STOP_SENDING:
1474             {
1475                 QUIC_STREAM *s;
1476
1477                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1478                                                                  op->arg0)))
1479                     goto err;
1480
1481                 if (!TEST_true(ossl_quic_stream_map_stop_sending_recv_part(h.args.qsm,
1482                                                                            s, op->arg1)))
1483                     goto err;
1484
1485                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1486
1487                 if (!TEST_true(s->active))
1488                     goto err;
1489             }
1490             break;
1491         case OPK_RESET_STREAM:
1492             {
1493                 QUIC_STREAM *s;
1494
1495                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1496                                                                  op->arg0)))
1497                     goto err;
1498
1499                 if (!TEST_true(ossl_quic_stream_map_reset_stream_send_part(h.args.qsm,
1500                                                                            s, op->arg1)))
1501                     goto err;
1502
1503                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1504
1505                 if (!TEST_true(s->active))
1506                     goto err;
1507             }
1508             break;
1509         case OPK_CONN_TXFC_BUMP:
1510             if (!TEST_true(ossl_quic_txfc_bump_cwm(h.args.conn_txfc, op->arg0)))
1511                 goto err;
1512
1513             break;
1514         case OPK_STREAM_TXFC_BUMP:
1515             {
1516                 QUIC_STREAM *s;
1517
1518                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1519                                                                  op->arg1)))
1520                     goto err;
1521
1522                 if (!TEST_true(ossl_quic_txfc_bump_cwm(&s->txfc, op->arg0)))
1523                     goto err;
1524
1525                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1526             }
1527             break;
1528         case OPK_HANDSHAKE_COMPLETE:
1529             ossl_quic_tx_packetiser_notify_handshake_complete(h.txp);
1530             break;
1531         default:
1532             TEST_error("bad opcode");
1533             goto err;
1534         }
1535     }
1536
1537     testresult = 1;
1538 err:
1539     if (!testresult)
1540         TEST_error("script %d failed at op %zu", script_idx + 1, opn + 1);
1541     if (have_helper)
1542         helper_cleanup(&h);
1543     return testresult;
1544 }
1545
1546 static int test_script(int idx)
1547 {
1548     if (idx + 1 != 18) return 1;
1549     return run_script(idx, scripts[idx]);
1550 }
1551
1552 /*
1553  * Dynamic Script 1.
1554  *
1555  * This script exists to test the interactions between multiple packets (ELs) in
1556  * the same datagram when there is a padding requirement (due to the datagram
1557  * containing an Initial packet). There are boundary cases which are difficult
1558  * to get right so it is important to test this entire space. Examples of such
1559  * edge cases include:
1560  *
1561  * - If we are planning on generating both an Initial and Handshake packet in a
1562  *   datagram ordinarily we would plan on adding the padding frames to meet the
1563  *   mandatory minimum size to the last packet in the datagram (i.e., the
1564  *   Handshake packet). But if the amount of room remaining in a datagram is
1565  *   e.g. only 3 bytes after generating the Initial packet, this is not
1566  *   enough room for another packet and we have a problem as having finished
1567  *   the Initial packet we have no way to add the necessary padding.
1568  *
1569  * - If we do have room for another packet but it is not enough room to encode
1570  *   any desired frame.
1571  *
1572  * This test confirms we handle these cases correctly for multi-packet datagrams
1573  * by placing two packets in a datagram and varying the size of the first
1574  * datagram.
1575  */
1576 static const unsigned char dyn_script_1_crypto_1a[1200];
1577 static const unsigned char dyn_script_1_crypto_1b[1];
1578
1579 static struct script_op dyn_script_1[] = {
1580     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1581     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1582     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1583     OP_CRYPTO_SEND(QUIC_PN_SPACE_INITIAL, dyn_script_1_crypto_1a) /* [crypto_idx] */
1584     OP_CRYPTO_SEND(QUIC_PN_SPACE_HANDSHAKE, dyn_script_1_crypto_1b)
1585     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1586     OP_RX_PKT()
1587     OP_EXPECT_DGRAM_LEN(1200, 1200)
1588     OP_END
1589 };
1590
1591 static const size_t dyn_script_1_crypto_idx = 3;
1592 static const size_t dyn_script_1_start_from = 1000;
1593
1594 static int test_dyn_script_1(int idx)
1595 {
1596     size_t target_size = dyn_script_1_start_from + (size_t)idx;
1597
1598     dyn_script_1[dyn_script_1_crypto_idx].buf_len = target_size;
1599
1600     if (!run_script(idx, dyn_script_1)) {
1601         TEST_error("failed dyn script 1 with target size %zu", target_size);
1602         return 0;
1603     }
1604
1605     return 1;
1606 }
1607
1608 int setup_tests(void)
1609 {
1610     ADD_ALL_TESTS(test_script, OSSL_NELEM(scripts));
1611     ADD_ALL_TESTS(test_dyn_script_1,
1612                   OSSL_NELEM(dyn_script_1_crypto_1a)
1613                   - dyn_script_1_start_from + 1);
1614     return 1;
1615 }