mirror of https://github.com/openssl/openssl
606 lines
21 KiB
C
606 lines
21 KiB
C
/*
|
|
* Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
|
|
*
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
* in the file LICENSE in the source distribution or at
|
|
* https://www.openssl.org/source/license.html
|
|
*/
|
|
#include "internal/packet.h"
|
|
#include "internal/quic_stream.h"
|
|
#include "testutil.h"
|
|
|
|
static int compare_iov(const unsigned char *ref, size_t ref_len,
|
|
const OSSL_QTX_IOVEC *iov, size_t iov_len)
|
|
{
|
|
size_t i, total_len = 0;
|
|
const unsigned char *cur = ref;
|
|
|
|
for (i = 0; i < iov_len; ++i)
|
|
total_len += iov[i].buf_len;
|
|
|
|
if (ref_len != total_len)
|
|
return 0;
|
|
|
|
for (i = 0; i < iov_len; ++i) {
|
|
if (memcmp(cur, iov[i].buf, iov[i].buf_len))
|
|
return 0;
|
|
|
|
cur += iov[i].buf_len;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static const unsigned char data_1[] = {
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
|
|
0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f
|
|
};
|
|
|
|
static int test_sstream_simple(void)
|
|
{
|
|
int testresult = 0;
|
|
QUIC_SSTREAM *sstream = NULL;
|
|
OSSL_QUIC_FRAME_STREAM hdr;
|
|
OSSL_QTX_IOVEC iov[2];
|
|
size_t num_iov = 0, wr = 0, i, init_size = 8192;
|
|
|
|
if (!TEST_ptr(sstream = ossl_quic_sstream_new(init_size)))
|
|
goto err;
|
|
|
|
/* A stream with nothing yet appended is totally acked */
|
|
if (!TEST_true(ossl_quic_sstream_is_totally_acked(sstream)))
|
|
goto err;
|
|
|
|
/* Should not have any data yet */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
/* Append data */
|
|
if (!TEST_true(ossl_quic_sstream_append(sstream, data_1, sizeof(data_1),
|
|
&wr))
|
|
|| !TEST_size_t_eq(wr, sizeof(data_1)))
|
|
goto err;
|
|
|
|
/* No longer totally acked */
|
|
if (!TEST_false(ossl_quic_sstream_is_totally_acked(sstream)))
|
|
goto err;
|
|
|
|
/* Read data */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov))
|
|
|| !TEST_size_t_gt(num_iov, 0)
|
|
|| !TEST_uint64_t_eq(hdr.offset, 0)
|
|
|| !TEST_uint64_t_eq(hdr.len, sizeof(data_1))
|
|
|| !TEST_false(hdr.is_fin))
|
|
goto err;
|
|
|
|
if (!TEST_true(compare_iov(data_1, sizeof(data_1), iov, num_iov)))
|
|
goto err;
|
|
|
|
/* Mark data as half transmitted */
|
|
if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 0, 7)))
|
|
goto err;
|
|
|
|
/* Read data */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov))
|
|
|| !TEST_size_t_gt(num_iov, 0)
|
|
|| !TEST_uint64_t_eq(hdr.offset, 8)
|
|
|| !TEST_uint64_t_eq(hdr.len, sizeof(data_1) - 8)
|
|
|| !TEST_false(hdr.is_fin))
|
|
goto err;
|
|
|
|
if (!TEST_true(compare_iov(data_1 + 8, sizeof(data_1) - 8, iov, num_iov)))
|
|
goto err;
|
|
|
|
if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 8, 15)))
|
|
goto err;
|
|
|
|
/* Read more data; should not be any more */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
/* Now we have lost bytes 4-6 */
|
|
if (!TEST_true(ossl_quic_sstream_mark_lost(sstream, 4, 6)))
|
|
goto err;
|
|
|
|
/* Should be able to read them */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov))
|
|
|| !TEST_size_t_gt(num_iov, 0)
|
|
|| !TEST_uint64_t_eq(hdr.offset, 4)
|
|
|| !TEST_uint64_t_eq(hdr.len, 3)
|
|
|| !TEST_false(hdr.is_fin))
|
|
goto err;
|
|
|
|
if (!TEST_true(compare_iov(data_1 + 4, 3, iov, num_iov)))
|
|
goto err;
|
|
|
|
/* Retransmit */
|
|
if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 4, 6)))
|
|
goto err;
|
|
|
|
/* Read more data; should not be any more */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 16))
|
|
goto err;
|
|
|
|
/* Data has been acknowledged, space should be not be freed yet */
|
|
if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 1, 7))
|
|
|| !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 16))
|
|
goto err;
|
|
|
|
/* Now data should be freed */
|
|
if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 0, 0))
|
|
|| !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 8))
|
|
goto err;
|
|
|
|
if (!TEST_true(ossl_quic_sstream_mark_acked(sstream, 0, 15))
|
|
|| !TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), 0))
|
|
goto err;
|
|
|
|
/* Now FIN */
|
|
ossl_quic_sstream_fin(sstream);
|
|
|
|
/* Get FIN frame */
|
|
for (i = 0; i < 2; ++i) {
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov))
|
|
|| !TEST_uint64_t_eq(hdr.offset, 16)
|
|
|| !TEST_uint64_t_eq(hdr.len, 0)
|
|
|| !TEST_true(hdr.is_fin)
|
|
|| !TEST_size_t_eq(num_iov, 0))
|
|
goto err;
|
|
}
|
|
|
|
if (!TEST_true(ossl_quic_sstream_mark_transmitted_fin(sstream, 16)))
|
|
goto err;
|
|
|
|
/* Read more data; FIN should not be returned any more */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
/* Lose FIN frame */
|
|
if (!TEST_true(ossl_quic_sstream_mark_lost_fin(sstream)))
|
|
goto err;
|
|
|
|
/* Get FIN frame */
|
|
for (i = 0; i < 2; ++i) {
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov))
|
|
|| !TEST_uint64_t_eq(hdr.offset, 16)
|
|
|| !TEST_uint64_t_eq(hdr.len, 0)
|
|
|| !TEST_true(hdr.is_fin)
|
|
|| !TEST_size_t_eq(num_iov, 0))
|
|
goto err;
|
|
}
|
|
|
|
if (!TEST_true(ossl_quic_sstream_mark_transmitted_fin(sstream, 16)))
|
|
goto err;
|
|
|
|
/* Read more data; FIN should not be returned any more */
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_false(ossl_quic_sstream_get_stream_frame(sstream, 0, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
/* Acknowledge fin. */
|
|
if (!TEST_true(ossl_quic_sstream_mark_acked_fin(sstream)))
|
|
goto err;
|
|
|
|
if (!TEST_true(ossl_quic_sstream_is_totally_acked(sstream)))
|
|
goto err;
|
|
|
|
testresult = 1;
|
|
err:
|
|
ossl_quic_sstream_free(sstream);
|
|
return testresult;
|
|
}
|
|
|
|
static int test_sstream_bulk(int idx)
|
|
{
|
|
int testresult = 0;
|
|
QUIC_SSTREAM *sstream = NULL;
|
|
OSSL_QUIC_FRAME_STREAM hdr;
|
|
OSSL_QTX_IOVEC iov[2];
|
|
size_t i, j, num_iov = 0, init_size = 8192, l;
|
|
size_t consumed = 0, total_written = 0, rd, cur_rd, expected = 0, start_at;
|
|
unsigned char *src_buf = NULL, *dst_buf = NULL;
|
|
unsigned char *ref_src_buf = NULL, *ref_dst_buf = NULL;
|
|
unsigned char *ref_dst_cur, *ref_src_cur, *dst_cur;
|
|
|
|
if (!TEST_ptr(sstream = ossl_quic_sstream_new(init_size)))
|
|
goto err;
|
|
|
|
if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_size(sstream), init_size))
|
|
goto err;
|
|
|
|
if (!TEST_ptr(src_buf = OPENSSL_zalloc(init_size)))
|
|
goto err;
|
|
|
|
if (!TEST_ptr(dst_buf = OPENSSL_malloc(init_size)))
|
|
goto err;
|
|
|
|
if (!TEST_ptr(ref_src_buf = OPENSSL_malloc(init_size)))
|
|
goto err;
|
|
|
|
if (!TEST_ptr(ref_dst_buf = OPENSSL_malloc(init_size)))
|
|
goto err;
|
|
|
|
/*
|
|
* Append a preliminary buffer to allow later code to exercise wraparound.
|
|
*/
|
|
if (!TEST_true(ossl_quic_sstream_append(sstream, src_buf, init_size / 2,
|
|
&consumed))
|
|
|| !TEST_size_t_eq(consumed, init_size / 2)
|
|
|| !TEST_true(ossl_quic_sstream_mark_transmitted(sstream, 0,
|
|
init_size / 2 - 1))
|
|
|| !TEST_true(ossl_quic_sstream_mark_acked(sstream, 0,
|
|
init_size / 2 - 1)))
|
|
goto err;
|
|
|
|
start_at = init_size / 2;
|
|
|
|
/* Generate a random buffer. */
|
|
for (i = 0; i < init_size; ++i)
|
|
src_buf[i] = (unsigned char)(test_random() & 0xFF);
|
|
|
|
/* Append bytes into the buffer in chunks of random length. */
|
|
ref_src_cur = ref_src_buf;
|
|
do {
|
|
l = (test_random() % init_size) + 1;
|
|
if (!TEST_true(ossl_quic_sstream_append(sstream, src_buf, l, &consumed)))
|
|
goto err;
|
|
|
|
memcpy(ref_src_cur, src_buf, consumed);
|
|
ref_src_cur += consumed;
|
|
total_written += consumed;
|
|
} while (consumed > 0);
|
|
|
|
if (!TEST_size_t_eq(ossl_quic_sstream_get_buffer_used(sstream), init_size)
|
|
|| !TEST_size_t_eq(ossl_quic_sstream_get_buffer_avail(sstream), 0))
|
|
goto err;
|
|
|
|
/*
|
|
* Randomly select bytes out of the buffer by marking them as transmitted.
|
|
* Record the remaining bytes, which should be the sequence of bytes
|
|
* returned.
|
|
*/
|
|
ref_src_cur = ref_src_buf;
|
|
ref_dst_cur = ref_dst_buf;
|
|
for (i = 0; i < total_written; ++i) {
|
|
if ((test_random() & 1) != 0) {
|
|
*ref_dst_cur++ = *ref_src_cur;
|
|
++expected;
|
|
} else if (!TEST_true(ossl_quic_sstream_mark_transmitted(sstream,
|
|
start_at + i,
|
|
start_at + i)))
|
|
goto err;
|
|
|
|
++ref_src_cur;
|
|
}
|
|
|
|
/* Exercise resize. */
|
|
if (!TEST_true(ossl_quic_sstream_set_buffer_size(sstream, init_size * 2))
|
|
|| !TEST_true(ossl_quic_sstream_set_buffer_size(sstream, init_size)))
|
|
goto err;
|
|
|
|
/* Readout and verification. */
|
|
dst_cur = dst_buf;
|
|
for (i = 0, rd = 0; rd < expected; ++i) {
|
|
num_iov = OSSL_NELEM(iov);
|
|
if (!TEST_true(ossl_quic_sstream_get_stream_frame(sstream, i, &hdr, iov,
|
|
&num_iov)))
|
|
goto err;
|
|
|
|
cur_rd = 0;
|
|
for (j = 0; j < num_iov; ++j) {
|
|
if (!TEST_size_t_le(iov[j].buf_len + rd, expected))
|
|
goto err;
|
|
|
|
memcpy(dst_cur, iov[j].buf, iov[j].buf_len);
|
|
dst_cur += iov[j].buf_len;
|
|
cur_rd += iov[j].buf_len;
|
|
}
|
|
|
|
if (!TEST_uint64_t_eq(cur_rd, hdr.len))
|
|
goto err;
|
|
|
|
rd += cur_rd;
|
|
}
|
|
|
|
if (!TEST_mem_eq(dst_buf, rd, ref_dst_buf, expected))
|
|
goto err;
|
|
|
|
testresult = 1;
|
|
err:
|
|
OPENSSL_free(src_buf);
|
|
OPENSSL_free(dst_buf);
|
|
OPENSSL_free(ref_src_buf);
|
|
OPENSSL_free(ref_dst_buf);
|
|
ossl_quic_sstream_free(sstream);
|
|
return testresult;
|
|
}
|
|
|
|
static int test_single_copy_read(QUIC_RSTREAM *qrs,
|
|
unsigned char *buf, size_t size,
|
|
size_t *readbytes, int *fin)
|
|
{
|
|
const unsigned char *record;
|
|
size_t rec_len;
|
|
|
|
*readbytes = 0;
|
|
|
|
for (;;) {
|
|
if (!ossl_quic_rstream_get_record(qrs, &record, &rec_len, fin))
|
|
return 0;
|
|
if (rec_len == 0)
|
|
break;
|
|
if (rec_len > size) {
|
|
rec_len = size;
|
|
*fin = 0;
|
|
}
|
|
memcpy(buf, record, rec_len);
|
|
size -= rec_len;
|
|
*readbytes += rec_len;
|
|
buf += rec_len;
|
|
|
|
if (!ossl_quic_rstream_release_record(qrs, rec_len))
|
|
return 0;
|
|
if (*fin || size == 0)
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static const unsigned char simple_data[] =
|
|
"Hello world! And thank you for all the fish!";
|
|
|
|
static int test_rstream_simple(int idx)
|
|
{
|
|
QUIC_RSTREAM *rstream = NULL;
|
|
int ret = 0;
|
|
unsigned char buf[sizeof(simple_data)];
|
|
size_t readbytes = 0, avail = 0;
|
|
int fin = 0;
|
|
int use_rbuf = idx > 1;
|
|
int use_sc = idx % 2;
|
|
int (* read_fn)(QUIC_RSTREAM *, unsigned char *, size_t, size_t *,
|
|
int *) = use_sc ? test_single_copy_read
|
|
: ossl_quic_rstream_read;
|
|
|
|
if (!TEST_ptr(rstream = ossl_quic_rstream_new(NULL, NULL, 0)))
|
|
goto err;
|
|
|
|
if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, 5,
|
|
simple_data + 5, 10, 0))
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
sizeof(simple_data) - 1,
|
|
simple_data + sizeof(simple_data) - 1,
|
|
1, 1))
|
|
|| !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
|
|
&readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 0)
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
sizeof(simple_data) - 10,
|
|
simple_data + sizeof(simple_data) - 10,
|
|
10, 1))
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, 0,
|
|
simple_data, 1, 0))
|
|
|| !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
|
|
&readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 1)
|
|
|| !TEST_mem_eq(buf, 1, simple_data, 1)
|
|
|| (use_rbuf && !TEST_false(ossl_quic_rstream_move_to_rbuf(rstream)))
|
|
|| (use_rbuf
|
|
&& !TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
|
|
sizeof(simple_data))))
|
|
|| (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
0, simple_data,
|
|
10, 0))
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
sizeof(simple_data),
|
|
NULL,
|
|
0, 1))
|
|
|| !TEST_true(ossl_quic_rstream_peek(rstream, buf, sizeof(buf),
|
|
&readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 15)
|
|
|| !TEST_mem_eq(buf, 15, simple_data, 15)
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
15,
|
|
simple_data + 15,
|
|
sizeof(simple_data) - 15, 1))
|
|
|| !TEST_true(ossl_quic_rstream_available(rstream, &avail, &fin))
|
|
|| !TEST_true(fin)
|
|
|| !TEST_size_t_eq(avail, sizeof(simple_data))
|
|
|| !TEST_true(read_fn(rstream, buf, 2, &readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 2)
|
|
|| !TEST_mem_eq(buf, 2, simple_data, 2)
|
|
|| !TEST_true(read_fn(rstream, buf + 2, 12, &readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 12)
|
|
|| !TEST_mem_eq(buf + 2, 12, simple_data + 2, 12)
|
|
|| !TEST_true(ossl_quic_rstream_queue_data(rstream, NULL,
|
|
sizeof(simple_data),
|
|
NULL,
|
|
0, 1))
|
|
|| (use_rbuf
|
|
&& !TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
|
|
2 * sizeof(simple_data))))
|
|
|| (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
|
|
|| !TEST_true(read_fn(rstream, buf + 14, 5, &readbytes, &fin))
|
|
|| !TEST_false(fin)
|
|
|| !TEST_size_t_eq(readbytes, 5)
|
|
|| !TEST_mem_eq(buf, 14 + 5, simple_data, 14 + 5)
|
|
|| !TEST_true(read_fn(rstream, buf + 14 + 5, sizeof(buf) - 14 - 5,
|
|
&readbytes, &fin))
|
|
|| !TEST_true(fin)
|
|
|| !TEST_size_t_eq(readbytes, sizeof(buf) - 14 - 5)
|
|
|| !TEST_mem_eq(buf, sizeof(buf), simple_data, sizeof(simple_data))
|
|
|| (use_rbuf && !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
|
|
|| !TEST_true(read_fn(rstream, buf, sizeof(buf), &readbytes, &fin))
|
|
|| !TEST_true(fin)
|
|
|| !TEST_size_t_eq(readbytes, 0))
|
|
goto err;
|
|
|
|
ret = 1;
|
|
|
|
err:
|
|
ossl_quic_rstream_free(rstream);
|
|
return ret;
|
|
}
|
|
|
|
static int test_rstream_random(int idx)
|
|
{
|
|
unsigned char *bulk_data = NULL;
|
|
unsigned char *read_buf = NULL;
|
|
QUIC_RSTREAM *rstream = NULL;
|
|
size_t i, read_off, queued_min, queued_max;
|
|
const size_t data_size = 10000;
|
|
int r, s, fin = 0, fin_set = 0;
|
|
int ret = 0;
|
|
size_t readbytes = 0;
|
|
|
|
if (!TEST_ptr(bulk_data = OPENSSL_malloc(data_size))
|
|
|| !TEST_ptr(read_buf = OPENSSL_malloc(data_size))
|
|
|| !TEST_ptr(rstream = ossl_quic_rstream_new(NULL, NULL, 0)))
|
|
goto err;
|
|
|
|
if (idx % 3 == 0)
|
|
ossl_quic_rstream_set_cleanse(rstream, 1);
|
|
|
|
for (i = 0; i < data_size; ++i)
|
|
bulk_data[i] = (unsigned char)(test_random() & 0xFF);
|
|
|
|
read_off = queued_min = queued_max = 0;
|
|
for (r = 0; r < 100; ++r) {
|
|
for (s = 0; s < 10; ++s) {
|
|
size_t off = (r * 10 + s) * 10, size = 10;
|
|
|
|
if (test_random() % 10 == 0)
|
|
/* drop packet */
|
|
continue;
|
|
|
|
if (off <= queued_min && off + size > queued_min)
|
|
queued_min = off + size;
|
|
|
|
if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, off,
|
|
bulk_data + off,
|
|
size, 0)))
|
|
goto err;
|
|
if (queued_max < off + size)
|
|
queued_max = off + size;
|
|
|
|
if (test_random() % 5 != 0)
|
|
continue;
|
|
|
|
/* random overlapping retransmit */
|
|
off = read_off + test_random() % 50;
|
|
if (off > 50)
|
|
off -= 50;
|
|
size = test_random() % 100 + 1;
|
|
if (off + size > data_size)
|
|
off = data_size - size;
|
|
if (off <= queued_min && off + size > queued_min)
|
|
queued_min = off + size;
|
|
|
|
if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, off,
|
|
bulk_data + off,
|
|
size, 0)))
|
|
goto err;
|
|
if (queued_max < off + size)
|
|
queued_max = off + size;
|
|
}
|
|
if (idx % 2 == 0) {
|
|
if (!TEST_true(test_single_copy_read(rstream, read_buf, data_size,
|
|
&readbytes, &fin)))
|
|
goto err;
|
|
} else if (!TEST_true(ossl_quic_rstream_read(rstream, read_buf,
|
|
data_size,
|
|
&readbytes, &fin))) {
|
|
goto err;
|
|
}
|
|
if (!TEST_size_t_ge(readbytes, queued_min - read_off)
|
|
|| !TEST_size_t_le(readbytes + read_off, data_size)
|
|
|| (idx % 3 != 0
|
|
&& !TEST_mem_eq(read_buf, readbytes, bulk_data + read_off,
|
|
readbytes)))
|
|
goto err;
|
|
read_off += readbytes;
|
|
queued_min = read_off;
|
|
if (test_random() % 50 == 0)
|
|
if (!TEST_true(ossl_quic_rstream_resize_rbuf(rstream,
|
|
queued_max - read_off + 1))
|
|
|| !TEST_true(ossl_quic_rstream_move_to_rbuf(rstream)))
|
|
goto err;
|
|
if (!fin_set && queued_max >= data_size - test_random() % 200) {
|
|
fin_set = 1;
|
|
/* Queue empty fin frame */
|
|
if (!TEST_true(ossl_quic_rstream_queue_data(rstream, NULL, data_size,
|
|
NULL, 0, 1)))
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
TEST_info("Total read bytes: %zu Fin rcvd: %d", read_off, fin);
|
|
|
|
if (idx % 3 == 0)
|
|
for (i = 0; i < read_off; i++)
|
|
if (!TEST_uchar_eq(bulk_data[i], 0))
|
|
goto err;
|
|
|
|
if (read_off == data_size && fin_set && !fin) {
|
|
/* We might still receive the final empty frame */
|
|
if (idx % 2 == 0) {
|
|
if (!TEST_true(test_single_copy_read(rstream, read_buf, data_size,
|
|
&readbytes, &fin)))
|
|
goto err;
|
|
} else if (!TEST_true(ossl_quic_rstream_read(rstream, read_buf,
|
|
data_size,
|
|
&readbytes, &fin))) {
|
|
goto err;
|
|
}
|
|
if (!TEST_size_t_eq(readbytes, 0) || !TEST_true(fin))
|
|
goto err;
|
|
}
|
|
|
|
ret = 1;
|
|
|
|
err:
|
|
ossl_quic_rstream_free(rstream);
|
|
OPENSSL_free(bulk_data);
|
|
OPENSSL_free(read_buf);
|
|
return ret;
|
|
}
|
|
|
|
int setup_tests(void)
|
|
{
|
|
ADD_TEST(test_sstream_simple);
|
|
ADD_ALL_TESTS(test_sstream_bulk, 100);
|
|
ADD_ALL_TESTS(test_rstream_simple, 4);
|
|
ADD_ALL_TESTS(test_rstream_random, 100);
|
|
return 1;
|
|
}
|