mirror of
https://gitea.invidious.io/iv-org/litespeed-quic.git
synced 2024-08-15 00:53:43 +00:00
- [BUGFIX] Do not drop incoming data when STOP_SENDING is received. - [BUGFIX] Receipt of STOP_SENDING should not cause read-reset. - [BUGFIX] Allow stream writes after receiving RESET. - [BUGFIX] Typo in stream: ANDing enum with wrong flag. - [BUGFIX] Reset elision: do not use zero as special stream ID value, for zero is a valid stream ID in IETF QUIC. - [API] Add optional on_conncloseframe_received() callback. - Use zero error code in RESET stream sent in response to STOP_SENDING.
3821 lines
128 KiB
C
3821 lines
128 KiB
C
/* Copyright (c) 2017 - 2020 LiteSpeed Technologies Inc. See LICENSE. */
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#ifndef WIN32
|
|
#include <unistd.h>
|
|
#else
|
|
#include <getopt.h>
|
|
#endif
|
|
|
|
#include "lsquic.h"
|
|
|
|
#include "lsquic_packet_common.h"
|
|
#include "lsquic_alarmset.h"
|
|
#include "lsquic_packet_in.h"
|
|
#include "lsquic_conn_flow.h"
|
|
#include "lsquic_rtt.h"
|
|
#include "lsquic_sfcw.h"
|
|
#include "lsquic_varint.h"
|
|
#include "lsquic_hq.h"
|
|
#include "lsquic_hash.h"
|
|
#include "lsquic_stream.h"
|
|
#include "lsquic_types.h"
|
|
#include "lsquic_malo.h"
|
|
#include "lsquic_mm.h"
|
|
#include "lsquic_conn_public.h"
|
|
#include "lsquic_logger.h"
|
|
#include "lsquic_parse.h"
|
|
#include "lsquic_conn.h"
|
|
#include "lsquic_engine_public.h"
|
|
#include "lsquic_cubic.h"
|
|
#include "lsquic_pacer.h"
|
|
#include "lsquic_senhist.h"
|
|
#include "lsquic_bw_sampler.h"
|
|
#include "lsquic_minmax.h"
|
|
#include "lsquic_bbr.h"
|
|
#include "lsquic_adaptive_cc.h"
|
|
#include "lsquic_send_ctl.h"
|
|
#include "lsquic_ver_neg.h"
|
|
#include "lsquic_packet_out.h"
|
|
#include "lsquic_enc_sess.h"
|
|
#include "lsqpack.h"
|
|
#include "lsquic_frab_list.h"
|
|
#include "lsquic_qenc_hdl.h"
|
|
#include "lsquic_varint.h"
|
|
#include "lsquic_hq.h"
|
|
#include "lsquic_data_in_if.h"
|
|
|
|
static const struct parse_funcs *g_pf = select_pf_by_ver(LSQVER_043);
|
|
|
|
static int g_use_crypto_ctor;
|
|
|
|
struct test_ctl_settings
|
|
{
|
|
int tcs_schedule_stream_packets_immediately;
|
|
int tcs_have_delayed_packets;
|
|
int tcs_can_send;
|
|
int tcs_write_ack;
|
|
enum buf_packet_type
|
|
tcs_bp_type;
|
|
enum packno_bits
|
|
tcs_guess_packno_bits,
|
|
tcs_calc_packno_bits;
|
|
};
|
|
|
|
|
|
static struct test_ctl_settings g_ctl_settings;
|
|
|
|
|
|
static void
|
|
init_buf (void *buf, size_t sz);
|
|
|
|
|
|
/* Set values to default */
|
|
static void
|
|
init_test_ctl_settings (struct test_ctl_settings *settings)
|
|
{
|
|
settings->tcs_schedule_stream_packets_immediately = 1;
|
|
settings->tcs_have_delayed_packets = 0;
|
|
settings->tcs_can_send = 1;
|
|
settings->tcs_write_ack = 0;
|
|
settings->tcs_bp_type = BPT_HIGHEST_PRIO;
|
|
settings->tcs_guess_packno_bits = GQUIC_PACKNO_LEN_2;
|
|
settings->tcs_calc_packno_bits = GQUIC_PACKNO_LEN_2;
|
|
}
|
|
|
|
|
|
#if __GNUC__
|
|
__attribute__((unused))
|
|
#endif
|
|
static void
|
|
apply_test_ctl_settings (const struct test_ctl_settings *settings)
|
|
{
|
|
g_ctl_settings = *settings;
|
|
}
|
|
|
|
|
|
enum packno_bits
|
|
lsquic_send_ctl_calc_packno_bits (struct lsquic_send_ctl *ctl)
|
|
{
|
|
return g_ctl_settings.tcs_calc_packno_bits;
|
|
}
|
|
|
|
|
|
int
|
|
lsquic_send_ctl_schedule_stream_packets_immediately (struct lsquic_send_ctl *ctl)
|
|
{
|
|
return g_ctl_settings.tcs_schedule_stream_packets_immediately;
|
|
}
|
|
|
|
|
|
int
|
|
lsquic_send_ctl_have_delayed_packets (const struct lsquic_send_ctl *ctl)
|
|
{
|
|
return g_ctl_settings.tcs_have_delayed_packets;
|
|
}
|
|
|
|
|
|
int
|
|
lsquic_send_ctl_can_send (struct lsquic_send_ctl *ctl)
|
|
{
|
|
return g_ctl_settings.tcs_can_send;
|
|
}
|
|
|
|
|
|
enum packno_bits
|
|
lsquic_send_ctl_guess_packno_bits (struct lsquic_send_ctl *ctl)
|
|
{
|
|
return g_ctl_settings.tcs_guess_packno_bits;
|
|
}
|
|
|
|
|
|
enum buf_packet_type
|
|
lsquic_send_ctl_determine_bpt (struct lsquic_send_ctl *ctl,
|
|
const struct lsquic_stream *stream)
|
|
{
|
|
return g_ctl_settings.tcs_bp_type;
|
|
}
|
|
|
|
|
|
/* This function is only here to avoid crash in the test: */
|
|
void
|
|
lsquic_engine_add_conn_to_tickable (struct lsquic_engine_public *enpub,
|
|
lsquic_conn_t *conn)
|
|
{
|
|
}
|
|
|
|
|
|
static unsigned n_closed;
|
|
static enum stream_ctor_flags stream_ctor_flags =
|
|
SCF_CALL_ON_NEW|SCF_DI_AUTOSWITCH;
|
|
|
|
struct test_ctx {
|
|
lsquic_stream_t *stream;
|
|
};
|
|
|
|
|
|
static lsquic_stream_ctx_t *
|
|
on_new_stream (void *stream_if_ctx, lsquic_stream_t *stream)
|
|
{
|
|
struct test_ctx *test_ctx = stream_if_ctx;
|
|
test_ctx->stream = stream;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
on_close (lsquic_stream_t *stream, lsquic_stream_ctx_t *st_h)
|
|
{
|
|
++n_closed;
|
|
}
|
|
|
|
|
|
static struct reset_call_ctx {
|
|
struct lsquic_stream *stream;
|
|
int how;
|
|
} s_onreset_called = { NULL, -1, };
|
|
|
|
|
|
static void
|
|
on_reset (lsquic_stream_t *stream, lsquic_stream_ctx_t *h, int how)
|
|
{
|
|
s_onreset_called = (struct reset_call_ctx) { stream, how, };
|
|
}
|
|
|
|
|
|
const struct lsquic_stream_if stream_if = {
|
|
.on_new_stream = on_new_stream,
|
|
.on_close = on_close,
|
|
.on_reset = on_reset,
|
|
};
|
|
|
|
|
|
/* This does not do anything beyond just acking the packet: we do not attempt
|
|
* to update the send controller to have the correct state.
|
|
*/
|
|
static void
|
|
ack_packet (lsquic_send_ctl_t *send_ctl, lsquic_packno_t packno)
|
|
{
|
|
struct lsquic_packet_out *packet_out;
|
|
TAILQ_FOREACH(packet_out, &send_ctl->sc_unacked_packets[PNS_APP], po_next)
|
|
if (packet_out->po_packno == packno)
|
|
{
|
|
lsquic_packet_out_ack_streams(packet_out);
|
|
return;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
|
|
static size_t
|
|
read_from_scheduled_packets (lsquic_send_ctl_t *send_ctl, lsquic_stream_id_t stream_id,
|
|
unsigned char *const begin, size_t bufsz, uint64_t first_offset, int *p_fin,
|
|
int fullcheck)
|
|
{
|
|
const struct parse_funcs *const pf_local = send_ctl->sc_conn_pub->lconn->cn_pf;
|
|
unsigned char *p = begin;
|
|
unsigned char *const end = p + bufsz;
|
|
const struct frame_rec *frec;
|
|
struct packet_out_frec_iter pofi;
|
|
struct lsquic_packet_out *packet_out;
|
|
struct stream_frame frame;
|
|
enum quic_frame_type expected_type;
|
|
int len, fin = 0;
|
|
|
|
if (g_use_crypto_ctor)
|
|
expected_type = QUIC_FRAME_CRYPTO;
|
|
else
|
|
expected_type = QUIC_FRAME_STREAM;
|
|
|
|
TAILQ_FOREACH(packet_out, &send_ctl->sc_scheduled_packets, po_next)
|
|
for (frec = lsquic_pofi_first(&pofi, packet_out); frec;
|
|
frec = lsquic_pofi_next(&pofi))
|
|
{
|
|
if (fullcheck)
|
|
{
|
|
assert(frec->fe_frame_type == expected_type);
|
|
if (packet_out->po_packno != 1)
|
|
{
|
|
/* First packet may contain two stream frames, do not
|
|
* check it.
|
|
*/
|
|
assert(!lsquic_pofi_next(&pofi));
|
|
if (TAILQ_NEXT(packet_out, po_next))
|
|
{
|
|
assert(packet_out->po_data_sz == packet_out->po_n_alloc);
|
|
assert(frec->fe_len == packet_out->po_data_sz);
|
|
}
|
|
}
|
|
}
|
|
if (frec->fe_frame_type == expected_type &&
|
|
frec->fe_stream->id == stream_id)
|
|
{
|
|
assert(!fin);
|
|
if (QUIC_FRAME_STREAM == expected_type)
|
|
len = pf_local->pf_parse_stream_frame(packet_out->po_data + frec->fe_off,
|
|
packet_out->po_data_sz - frec->fe_off, &frame);
|
|
else
|
|
len = pf_local->pf_parse_crypto_frame(packet_out->po_data + frec->fe_off,
|
|
packet_out->po_data_sz - frec->fe_off, &frame);
|
|
assert(len > 0);
|
|
if (QUIC_FRAME_STREAM == expected_type)
|
|
assert(frame.stream_id == frec->fe_stream->id);
|
|
else
|
|
assert(frame.stream_id == ~0ULL);
|
|
/* Otherwise not enough to copy to: */
|
|
assert(end - p >= frame.data_frame.df_size);
|
|
/* Checks offset ordering: */
|
|
assert(frame.data_frame.df_offset ==
|
|
first_offset + (uintptr_t) (p - begin));
|
|
if (frame.data_frame.df_fin)
|
|
{
|
|
assert(!fin);
|
|
fin = 1;
|
|
}
|
|
memcpy(p, packet_out->po_data + frec->fe_off + len -
|
|
frame.data_frame.df_size, frame.data_frame.df_size);
|
|
p += frame.data_frame.df_size;
|
|
}
|
|
}
|
|
|
|
if (p_fin)
|
|
*p_fin = fin;
|
|
return p + bufsz - end;
|
|
}
|
|
|
|
|
|
static struct test_ctx test_ctx;
|
|
|
|
|
|
struct test_objs {
|
|
struct lsquic_conn lconn;
|
|
struct lsquic_engine_public eng_pub;
|
|
struct lsquic_conn_public conn_pub;
|
|
struct lsquic_send_ctl send_ctl;
|
|
struct lsquic_alarmset alset;
|
|
void *stream_if_ctx;
|
|
struct ver_neg ver_neg;
|
|
const struct lsquic_stream_if *
|
|
stream_if;
|
|
unsigned initial_stream_window;
|
|
enum stream_ctor_flags ctor_flags;
|
|
struct qpack_enc_hdl qeh;
|
|
};
|
|
|
|
|
|
static struct network_path network_path;
|
|
|
|
static struct network_path *
|
|
get_network_path (struct lsquic_conn *lconn, const struct sockaddr *sa)
|
|
{
|
|
return &network_path;
|
|
}
|
|
|
|
|
|
static int
|
|
can_write_ack (struct lsquic_conn *lconn)
|
|
{
|
|
return g_ctl_settings.tcs_write_ack;
|
|
}
|
|
|
|
|
|
static void
|
|
write_ack (struct lsquic_conn *lconn, struct lsquic_packet_out *packet_out)
|
|
{
|
|
struct test_objs *const tobjs = (void *) lconn;
|
|
const size_t ack_size = 9; /* Arbitrary */
|
|
int s;
|
|
|
|
packet_out->po_frame_types |= 1 << QUIC_FRAME_ACK;
|
|
s = lsquic_packet_out_add_frame(packet_out, &tobjs->eng_pub.enp_mm, 0,
|
|
QUIC_FRAME_ACK, packet_out->po_data_sz, ack_size);
|
|
assert(s == 0);
|
|
memcpy(packet_out->po_data + packet_out->po_data_sz, "ACKACKACK", 9);
|
|
lsquic_send_ctl_incr_pack_sz(&tobjs->send_ctl, packet_out, ack_size);
|
|
packet_out->po_regen_sz += ack_size;
|
|
}
|
|
|
|
|
|
static const struct conn_iface our_conn_if =
|
|
{
|
|
.ci_can_write_ack = can_write_ack,
|
|
.ci_get_path = get_network_path,
|
|
.ci_write_ack = write_ack,
|
|
};
|
|
|
|
static struct conn_stats s_conn_stats;
|
|
|
|
static void
|
|
init_test_objs (struct test_objs *tobjs, unsigned initial_conn_window,
|
|
unsigned initial_stream_window, const struct parse_funcs *pf)
|
|
{
|
|
int s;
|
|
memset(tobjs, 0, sizeof(*tobjs));
|
|
LSCONN_INITIALIZE(&tobjs->lconn);
|
|
tobjs->lconn.cn_pf = pf ? pf : g_pf;
|
|
tobjs->lconn.cn_version = tobjs->lconn.cn_pf == &lsquic_parse_funcs_ietf_v1 ?
|
|
LSQVER_ID27 : LSQVER_043;
|
|
tobjs->lconn.cn_esf_c = &lsquic_enc_session_common_gquic_1;
|
|
network_path.np_pack_size = 1370;
|
|
tobjs->lconn.cn_if = &our_conn_if;
|
|
lsquic_mm_init(&tobjs->eng_pub.enp_mm);
|
|
TAILQ_INIT(&tobjs->conn_pub.sending_streams);
|
|
TAILQ_INIT(&tobjs->conn_pub.read_streams);
|
|
TAILQ_INIT(&tobjs->conn_pub.write_streams);
|
|
TAILQ_INIT(&tobjs->conn_pub.service_streams);
|
|
lsquic_cfcw_init(&tobjs->conn_pub.cfcw, &tobjs->conn_pub,
|
|
initial_conn_window);
|
|
lsquic_conn_cap_init(&tobjs->conn_pub.conn_cap, initial_conn_window);
|
|
lsquic_alarmset_init(&tobjs->alset, 0);
|
|
tobjs->conn_pub.mm = &tobjs->eng_pub.enp_mm;
|
|
tobjs->conn_pub.lconn = &tobjs->lconn;
|
|
tobjs->conn_pub.enpub = &tobjs->eng_pub;
|
|
tobjs->conn_pub.send_ctl = &tobjs->send_ctl;
|
|
tobjs->conn_pub.packet_out_malo =
|
|
lsquic_malo_create(sizeof(struct lsquic_packet_out));
|
|
tobjs->conn_pub.path = &network_path;
|
|
tobjs->conn_pub.conn_stats = &s_conn_stats;
|
|
tobjs->initial_stream_window = initial_stream_window;
|
|
lsquic_send_ctl_init(&tobjs->send_ctl, &tobjs->alset, &tobjs->eng_pub,
|
|
&tobjs->ver_neg, &tobjs->conn_pub, 0);
|
|
tobjs->stream_if = &stream_if;
|
|
tobjs->stream_if_ctx = &test_ctx;
|
|
tobjs->ctor_flags = stream_ctor_flags;
|
|
if ((1 << tobjs->lconn.cn_version) & LSQUIC_IETF_VERSIONS)
|
|
{
|
|
lsquic_qeh_init(&tobjs->qeh, &tobjs->lconn);
|
|
s = lsquic_qeh_settings(&tobjs->qeh, 0, 0, 0, 0);
|
|
assert(0 == s);
|
|
tobjs->conn_pub.u.ietf.qeh = &tobjs->qeh;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
deinit_test_objs (struct test_objs *tobjs)
|
|
{
|
|
assert(!lsquic_malo_first(tobjs->eng_pub.enp_mm.malo.stream_frame));
|
|
lsquic_send_ctl_cleanup(&tobjs->send_ctl);
|
|
lsquic_malo_destroy(tobjs->conn_pub.packet_out_malo);
|
|
lsquic_mm_cleanup(&tobjs->eng_pub.enp_mm);
|
|
if ((1 << tobjs->lconn.cn_version) & LSQUIC_IETF_VERSIONS)
|
|
{
|
|
lsquic_qeh_cleanup(&tobjs->qeh);
|
|
}
|
|
}
|
|
|
|
|
|
/* Create a new stream frame. Each stream frame has a real packet_in to
|
|
* back it up, just like in real code. The contents of the packet do
|
|
* not matter.
|
|
*/
|
|
static stream_frame_t *
|
|
new_frame_in_ext (struct test_objs *tobjs, size_t off, size_t sz, int fin,
|
|
const void *data)
|
|
{
|
|
lsquic_packet_in_t *packet_in;
|
|
stream_frame_t *frame;
|
|
|
|
assert(sz <= 1370);
|
|
|
|
packet_in = lsquic_mm_get_packet_in(&tobjs->eng_pub.enp_mm);
|
|
if (data)
|
|
packet_in->pi_data = (void *) data;
|
|
else
|
|
{
|
|
packet_in->pi_data = lsquic_mm_get_packet_in_buf(&tobjs->eng_pub.enp_mm, 1370);
|
|
packet_in->pi_flags |= PI_OWN_DATA;
|
|
memset(packet_in->pi_data, 'A', sz);
|
|
}
|
|
/* This is not how stream frame looks in the packet: we have no
|
|
* header. In our test case it does not matter, as we only care
|
|
* about stream frame.
|
|
*/
|
|
packet_in->pi_data_sz = sz;
|
|
packet_in->pi_refcnt = 1;
|
|
|
|
frame = lsquic_malo_get(tobjs->eng_pub.enp_mm.malo.stream_frame);
|
|
memset(frame, 0, sizeof(*frame));
|
|
frame->packet_in = packet_in;
|
|
frame->data_frame.df_offset = off;
|
|
frame->data_frame.df_size = sz;
|
|
frame->data_frame.df_data = &packet_in->pi_data[0];
|
|
frame->data_frame.df_fin = fin;
|
|
|
|
return frame;
|
|
}
|
|
|
|
|
|
static stream_frame_t *
|
|
new_frame_in (struct test_objs *tobjs, size_t off, size_t sz, int fin)
|
|
{
|
|
return new_frame_in_ext(tobjs, off, sz, fin, NULL);
|
|
}
|
|
|
|
|
|
static lsquic_stream_t *
|
|
new_stream_ext (struct test_objs *tobjs, unsigned stream_id, uint64_t send_off)
|
|
{
|
|
enum stream_ctor_flags ctor_flags;
|
|
|
|
if (g_use_crypto_ctor)
|
|
return lsquic_stream_new_crypto(stream_id, &tobjs->conn_pub,
|
|
tobjs->stream_if, tobjs->stream_if_ctx,
|
|
tobjs->ctor_flags | SCF_CRITICAL);
|
|
else
|
|
{
|
|
/* For the purposes of the unit test, consider streams 1 and 3 critical */
|
|
if (stream_id == 3 || stream_id == 1)
|
|
ctor_flags = SCF_CRITICAL;
|
|
else
|
|
ctor_flags = 0;
|
|
if ((1 << tobjs->lconn.cn_version) & LSQUIC_IETF_VERSIONS)
|
|
ctor_flags |= SCF_IETF;
|
|
return lsquic_stream_new(stream_id, &tobjs->conn_pub, tobjs->stream_if,
|
|
tobjs->stream_if_ctx, tobjs->initial_stream_window, send_off,
|
|
tobjs->ctor_flags | ctor_flags);
|
|
}
|
|
}
|
|
|
|
|
|
static lsquic_stream_t *
|
|
new_stream (struct test_objs *tobjs, unsigned stream_id)
|
|
{
|
|
return new_stream_ext(tobjs, stream_id, 16 * 1024);
|
|
}
|
|
|
|
|
|
static void
|
|
run_frame_ordering_test (uint64_t run_id /* This is used to make it easier to set breakpoints */,
|
|
int *idx, size_t idx_sz, int read_asap)
|
|
{
|
|
int s;
|
|
size_t nw = 0, i;
|
|
char buf[0x1000];
|
|
|
|
struct test_objs tobjs;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
lsquic_stream_t *stream = new_stream(&tobjs, 123);
|
|
struct lsquic_mm *const mm = &tobjs.eng_pub.enp_mm;
|
|
struct malo *const frame_malo = mm->malo.stream_frame;
|
|
|
|
lsquic_packet_in_t *packet_in = lsquic_mm_get_packet_in(mm);
|
|
packet_in->pi_data = lsquic_mm_get_packet_in_buf(mm, 1370);
|
|
packet_in->pi_flags |= PI_OWN_DATA;
|
|
assert(idx_sz <= 10);
|
|
memcpy(packet_in->pi_data, "0123456789", 10);
|
|
packet_in->pi_data_sz = 10;
|
|
packet_in->pi_refcnt = idx_sz;
|
|
|
|
printf("inserting ");
|
|
for (i = 0; i < idx_sz; ++i)
|
|
{
|
|
stream_frame_t *frame;
|
|
frame = lsquic_malo_get(frame_malo);
|
|
memset(frame, 0, sizeof(*frame));
|
|
frame->packet_in = packet_in;
|
|
frame->data_frame.df_offset = idx[i];
|
|
if (idx[i] + 1 == (int) idx_sz)
|
|
{
|
|
printf("<FIN>");
|
|
frame->data_frame.df_size = 0;
|
|
frame->data_frame.df_fin = 1;
|
|
}
|
|
else
|
|
{
|
|
printf("%c", packet_in->pi_data[idx[i]]);
|
|
frame->data_frame.df_size = 1;
|
|
frame->data_frame.df_data = &packet_in->pi_data[idx[i]];
|
|
}
|
|
if (frame->data_frame.df_fin && read_asap && i + 1 == idx_sz)
|
|
{ /* Last frame is the FIN frame. Read before inserting zero-sized
|
|
* FIN frame.
|
|
*/
|
|
nw = lsquic_stream_read(stream, buf, 10);
|
|
assert(("Read idx_sz bytes", nw == idx_sz - 1));
|
|
assert(("Have not reached fin yet (frame has not come in)",
|
|
-1 == lsquic_stream_read(stream, buf, 1) && errno == EWOULDBLOCK));
|
|
}
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame", 0 == s));
|
|
}
|
|
printf("\n");
|
|
|
|
if (read_asap && nw == idx_sz - 1)
|
|
{
|
|
assert(("Reached fin", 0 == lsquic_stream_read(stream, buf, 1)));
|
|
}
|
|
else
|
|
{
|
|
nw = lsquic_stream_read(stream, buf, 10);
|
|
assert(("Read idx_sz bytes", nw == idx_sz - 1));
|
|
assert(("Reached fin", 0 == lsquic_stream_read(stream, buf, 1)));
|
|
}
|
|
|
|
lsquic_stream_destroy(stream);
|
|
|
|
assert(("all frames have been released", !lsquic_malo_first(frame_malo)));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
permute_and_run (uint64_t run_id,
|
|
int mask, int level, int *idx, size_t idx_sz)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < idx_sz; ++i)
|
|
{
|
|
if (!(mask & (1 << i)))
|
|
{
|
|
idx[level] = i;
|
|
if (level + 1 == (int) idx_sz)
|
|
{
|
|
run_frame_ordering_test(run_id, idx, idx_sz, 0);
|
|
run_frame_ordering_test(run_id, idx, idx_sz, 1);
|
|
}
|
|
else
|
|
permute_and_run(run_id | (i << (8 * level)),
|
|
mask | (1 << i), level + 1, idx, idx_sz);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Client: we send some data and FIN, and remote end sends some data and
|
|
* FIN.
|
|
*/
|
|
static void
|
|
test_loc_FIN_rem_FIN (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
lsquic_packet_out_t *packet_out;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
ssize_t n;
|
|
int s, fin;
|
|
enum stream_state_sending sss;
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
s = lsquic_stream_shutdown(stream, 1);
|
|
assert(s == 0);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl)); /* Shutdown performs a flush */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* No need to close stream yet */
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 100, &fin, 0);
|
|
assert(0 == n);
|
|
assert(fin);
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_DATA_SENT == sss);
|
|
|
|
/* Pretend we sent out this packet as well: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* No need to close stream yet */
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(60 == n);
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(40 == n);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 100, 0, 1));
|
|
assert(0 == s);
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(0 == n);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
s = lsquic_stream_shutdown(stream, 0);
|
|
assert(0 == s);
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == (SMQF_CALL_ONCLOSE));
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
ack_packet(&tobjs->send_ctl, 2);
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == (SMQF_CALL_ONCLOSE|SMQF_FREE_STREAM));
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_DATA_RECVD == sss);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Server: we read data and FIN, and then send data and FIN.
|
|
*/
|
|
static void
|
|
test_rem_FIN_loc_FIN (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
size_t n;
|
|
int s, fin;
|
|
lsquic_packet_out_t *packet_out;
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(60 == n);
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(40 == n);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 100, 0, 1));
|
|
assert(0 == s);
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(0 == n);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
s = lsquic_stream_shutdown(stream, 0);
|
|
assert(0 == s);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* No need to close stream yet */
|
|
|
|
s = lsquic_stream_shutdown(stream, 1);
|
|
assert(s == 0);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl)); /* Shutdown performs a flush */
|
|
|
|
/* Now we can call on_close: */
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == SMQF_CALL_ONCLOSE);
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 100, &fin, 0);
|
|
assert(0 == n);
|
|
assert(fin);
|
|
|
|
/* Pretend we sent out this packet as well: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
/* Cannot free stream yet: packets have not been acked */
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == SMQF_CALL_ONCLOSE);
|
|
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
ack_packet(&tobjs->send_ctl, 2);
|
|
|
|
/* Now we can free the stream: */
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == (SMQF_CALL_ONCLOSE|SMQF_FREE_STREAM));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Server: we read data and close the read side before reading FIN, which
|
|
* results in stream being reset.
|
|
*/
|
|
static void
|
|
test_rem_data_loc_close_and_rst_in (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
char buf[0x100];
|
|
ssize_t n;
|
|
int s;
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(60 == n);
|
|
|
|
s = lsquic_stream_shutdown(stream, 0);
|
|
assert(0 == s);
|
|
/* Early read shutdown results in different frames on different QUIC
|
|
* transports:
|
|
*/
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(stream->sm_qflags & SMQF_SEND_STOP_SENDING);
|
|
else
|
|
assert(stream->sm_qflags & SMQF_SEND_RST);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(!((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == SMQF_CALL_ONCLOSE));
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(n == -1); /* Cannot read from closed stream */
|
|
|
|
/* Close write side */
|
|
s = lsquic_stream_shutdown(stream, 1);
|
|
assert(0 == s);
|
|
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl)); /* Shutdown performs a flush */
|
|
assert(stream->n_unacked == 1);
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == SMQF_CALL_ONCLOSE);
|
|
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
s = lsquic_stream_rst_in(stream, 100, 1);
|
|
assert(0 == s);
|
|
assert(s_onreset_called.stream == stream);
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(s_onreset_called.how == 0);
|
|
else
|
|
assert(s_onreset_called.how == 2);
|
|
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM)); /* Not yet */
|
|
assert(stream->sm_qflags & SMQF_CALL_ONCLOSE);
|
|
|
|
lsquic_stream_rst_frame_sent(stream);
|
|
stream->n_unacked++; /* RESET frame take a reference */
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM)); /* Not yet,
|
|
because: */ assert(stream->n_unacked == 2);
|
|
|
|
lsquic_stream_acked(stream, QUIC_FRAME_STREAM);
|
|
lsquic_stream_acked(stream, QUIC_FRAME_RST_STREAM);
|
|
assert(stream->sm_qflags & SMQF_FREE_STREAM); /* OK, now */
|
|
|
|
lsquic_stream_destroy(stream);
|
|
/* This simply checks that the stream got removed from the queue: */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Server: we read data and close the read side before reading FIN. No
|
|
* FIN or RST arrive from peer. This should schedule RST_STREAM to be
|
|
* sent (this is gQUIC) and add "wait for known FIN" flag.
|
|
*/
|
|
static void
|
|
test_rem_data_loc_close (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
char buf[0x100];
|
|
ssize_t n;
|
|
int s;
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(60 == n);
|
|
|
|
s = lsquic_stream_shutdown(stream, 0);
|
|
assert(0 == s);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(!(stream->sm_qflags & SMQF_CALL_ONCLOSE));
|
|
|
|
n = lsquic_stream_read(stream, buf, 60);
|
|
assert(n == -1); /* Cannot read from closed stream */
|
|
|
|
/* Close write side */
|
|
s = lsquic_stream_shutdown(stream, 1);
|
|
assert(0 == s);
|
|
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl)); /* Shutdown performs a flush */
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(stream->sm_qflags & SMQF_CALL_ONCLOSE);
|
|
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM));
|
|
lsquic_stream_acked(stream, QUIC_FRAME_STREAM);
|
|
|
|
lsquic_stream_rst_frame_sent(stream);
|
|
stream->n_unacked++; /* RESET frame take a reference */
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM)); /* No */
|
|
|
|
lsquic_stream_acked(stream, QUIC_FRAME_RST_STREAM);
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM)); /* Still no */
|
|
|
|
/* Stream will linger until we have the offset: */
|
|
assert(stream->sm_qflags & SMQF_WAIT_FIN_OFF);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
/* This simply checks that the stream got removed from the queue: */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Client: we send some data and FIN, but remote end sends some data and
|
|
* then resets the stream. The client gets an error when it reads from
|
|
* stream, after which it closes and destroys the stream.
|
|
*/
|
|
static void
|
|
test_loc_FIN_rem_RST (struct test_objs *tobjs)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
lsquic_stream_t *stream;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
ssize_t n;
|
|
int s, fin;
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
s = lsquic_stream_shutdown(stream, 1);
|
|
assert(s == 0);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl)); /* Shutdown performs a flush */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* No need to close stream yet */
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 100, &fin, 0);
|
|
assert(0 == n);
|
|
assert(fin);
|
|
|
|
/* Pretend we sent out this packet as well: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* No need to close stream yet */
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
s = lsquic_stream_rst_in(stream, 100, 0);
|
|
assert(0 == s);
|
|
assert(s_onreset_called.stream == stream);
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(s_onreset_called.how == 0);
|
|
else
|
|
assert(s_onreset_called.how == 2);
|
|
|
|
/* No RST to send, we already sent FIN */
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
/* The stream is not yet done: the user code has not closed it yet */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(0 == (stream->sm_qflags & (SMQF_SERVICE_FLAGS)));
|
|
assert(0 == (stream->stream_flags & STREAM_U_READ_DONE));
|
|
|
|
s = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(-1 == s); /* Error collected */
|
|
s = lsquic_stream_close(stream);
|
|
assert(0 == s); /* Stream closed successfully */
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == (SMQF_CALL_ONCLOSE));
|
|
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
ack_packet(&tobjs->send_ctl, 2);
|
|
|
|
#if 0
|
|
/* OK, here we pretend that we sent a RESET and it was acked */
|
|
assert(stream->sm_qflags & SMQF_SEND_RST);
|
|
stream->sm_qflags |= SMQF_SEND_RST;
|
|
stream->stream_flags
|
|
#endif
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & (SMQF_SERVICE_FLAGS)) == (SMQF_CALL_ONCLOSE|SMQF_FREE_STREAM));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(100 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Client: we send some data (no FIN), and remote end sends some data and
|
|
* then resets the stream.
|
|
*/
|
|
static void
|
|
test_loc_data_rem_RST (struct test_objs *tobjs)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
lsquic_stream_t *stream;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
ssize_t n;
|
|
int s, fin;
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
s = lsquic_stream_rst_in(stream, 200, 0);
|
|
assert(0 == s);
|
|
assert(s_onreset_called.stream == stream);
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(s_onreset_called.how == 0);
|
|
else
|
|
assert(s_onreset_called.how == 2);
|
|
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
|
|
if (!(stream->sm_bflags & SMBF_IETF))
|
|
{
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
assert((stream->sm_qflags & SMQF_SENDING_FLAGS) == SMQF_SEND_RST);
|
|
}
|
|
|
|
/* Not yet closed: error needs to be collected */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(0 == (stream->sm_qflags & SMQF_SERVICE_FLAGS));
|
|
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(100 == n); /* Write successful after reset in IETF */
|
|
else
|
|
assert(-1 == n); /* Error collected */
|
|
s = lsquic_stream_close(stream);
|
|
assert(0 == s); /* Stream successfully closed */
|
|
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(stream->n_unacked == 1);
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_CALL_ONCLOSE);
|
|
|
|
if (!(stream->sm_bflags & SMBF_IETF))
|
|
lsquic_stream_rst_frame_sent(stream);
|
|
|
|
lsquic_stream_call_on_close(stream);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
{
|
|
/* FIN packet has not been acked yet: */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
/* Now ack it: */
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
}
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_FREE_STREAM);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(200 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(200 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Client: we send some data (no FIN), and remote end sends some data and
|
|
* then sends STOP_SENDING
|
|
*/
|
|
static void
|
|
test_loc_data_rem_SS (struct test_objs *tobjs)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
lsquic_stream_t *stream;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
ssize_t n;
|
|
int s, fin;
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
assert(stream->sm_bflags & SMBF_IETF); /* STOP_SENDING is IETF-only */
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 100, 0));
|
|
assert(0 == s);
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
lsquic_stream_stop_sending_in(stream, 12345);
|
|
assert(s_onreset_called.stream == stream);
|
|
assert(s_onreset_called.how == 1);
|
|
|
|
/* Incoming STOP_SENDING should not affect the ability to read from
|
|
* stream.
|
|
*/
|
|
unsigned char mybuf[123];
|
|
const ssize_t nread = lsquic_stream_read(stream, mybuf, sizeof(mybuf));
|
|
assert(nread == 100);
|
|
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
|
|
if (!(stream->sm_bflags & SMBF_IETF))
|
|
{
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
assert((stream->sm_qflags & SMQF_SENDING_FLAGS) == SMQF_SEND_RST);
|
|
}
|
|
|
|
/* Not yet closed: error needs to be collected */
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert(0 == (stream->sm_qflags & SMQF_SERVICE_FLAGS));
|
|
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
assert(-1 == n); /* Error collected */
|
|
s = lsquic_stream_close(stream);
|
|
assert(0 == s); /* Stream successfully closed */
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_CALL_ONCLOSE);
|
|
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
lsquic_stream_ss_frame_sent(stream);
|
|
lsquic_stream_rst_frame_sent(stream);
|
|
lsquic_stream_call_on_close(stream);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
if (stream->sm_bflags & SMBF_IETF)
|
|
assert(stream->sm_qflags & SMQF_WAIT_FIN_OFF);
|
|
else
|
|
{
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_FREE_STREAM);
|
|
}
|
|
|
|
const unsigned expected_nread = stream->sm_bflags & SMBF_IETF ? 100 : 200;
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(expected_nread == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(expected_nread == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* We send some data and RST, receive data and FIN
|
|
*/
|
|
static void
|
|
test_loc_RST_rem_FIN (struct test_objs *tobjs)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
lsquic_stream_t *stream;
|
|
char buf_out[0x100];
|
|
unsigned char buf[0x100];
|
|
size_t n;
|
|
int s, fin;
|
|
enum stream_state_sending sss;
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
stream = new_stream(tobjs, 345);
|
|
|
|
n = lsquic_stream_write(stream, buf_out, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(100 == n);
|
|
assert(0 == memcmp(buf_out, buf, 100));
|
|
assert(!fin);
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
assert(1 == stream->n_unacked);
|
|
ack_packet(&tobjs->send_ctl, 1);
|
|
assert(0 == stream->n_unacked);
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_SEND == sss);
|
|
|
|
lsquic_stream_reset(stream, 0);
|
|
++stream->n_unacked; /* Fake sending of packet with RST_STREAM */
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
assert((stream->sm_qflags & SMQF_SENDING_FLAGS) == SMQF_SEND_RST);
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_DATA_SENT == sss); /* FIN was packetized */
|
|
|
|
s = lsquic_stream_frame_in(stream, new_frame_in(tobjs, 0, 90, 1));
|
|
assert(s == 0);
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_CALL_ONCLOSE);
|
|
|
|
lsquic_stream_rst_frame_sent(stream);
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_RESET_SENT == sss);
|
|
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_RESET_SENT == sss);
|
|
lsquic_stream_acked(stream, QUIC_FRAME_RST_STREAM); /* Fake ack of RST_STREAM packet */
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_RESET_RECVD == sss);
|
|
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.sending_streams));
|
|
|
|
lsquic_stream_call_on_close(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams)); /* Not acked yet */
|
|
lsquic_stream_acked(stream, QUIC_FRAME_STREAM);
|
|
|
|
assert(!TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
assert((stream->sm_qflags & SMQF_SERVICE_FLAGS) == SMQF_FREE_STREAM);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(TAILQ_EMPTY(&tobjs->conn_pub.service_streams));
|
|
|
|
assert(90 == tobjs->conn_pub.cfcw.cf_max_recv_off);
|
|
assert(90 == tobjs->conn_pub.cfcw.cf_read_off);
|
|
}
|
|
|
|
|
|
/* Test that when stream frame is elided and the packet is dropped,
|
|
* the send controller produces a gapless sequence.
|
|
*
|
|
* Case "middle": 3 packets with STREAM frames for streams A, B, and A.
|
|
* Stream B is reset. We should get a gapless sequence
|
|
* of packets 1, 2.
|
|
*/
|
|
static void
|
|
test_gapless_elision_middle (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *streamA, *streamB;
|
|
unsigned char buf[0x1000], buf_out[0x1000];
|
|
size_t n, thresh, written_to_A = 0;
|
|
int s, fin;
|
|
lsquic_packet_out_t *packet_out;
|
|
|
|
streamA = new_stream(tobjs, 345);
|
|
streamB = new_stream(tobjs, 347);
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
thresh = lsquic_stream_flush_threshold(streamA, 0);
|
|
n = lsquic_stream_write(streamA, buf_out, thresh);
|
|
assert(n == thresh);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
written_to_A += n;
|
|
|
|
thresh = lsquic_stream_flush_threshold(streamB, 0);
|
|
n = lsquic_stream_write(streamB, buf_out, thresh);
|
|
assert(n == thresh);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
thresh = lsquic_stream_flush_threshold(streamA, 0);
|
|
n = lsquic_stream_write(streamA, buf_out + written_to_A, thresh);
|
|
assert(n == thresh);
|
|
assert(3 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
written_to_A += n;
|
|
|
|
/* Verify contents of A: */
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, streamA->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(n == written_to_A);
|
|
assert(0 == memcmp(buf, buf_out, written_to_A));
|
|
|
|
/* Now reset stream B: */
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
if (streamB->sm_bflags & SMBF_IETF)
|
|
lsquic_stream_stop_sending_in(streamB, 12345);
|
|
else
|
|
{
|
|
s = lsquic_stream_rst_in(streamB, 0, 0);
|
|
assert(s == 0);
|
|
}
|
|
assert(s_onreset_called.stream == streamB);
|
|
if (streamB->sm_bflags & SMBF_IETF)
|
|
assert(s_onreset_called.how == 1);
|
|
else
|
|
assert(s_onreset_called.how == 2);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
/* Verify A again: */
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, streamA->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(n == written_to_A);
|
|
assert(0 == memcmp(buf, buf_out, written_to_A));
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(packet_out->po_packno == 1);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(packet_out->po_packno == 2);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(!packet_out);
|
|
|
|
/* Now we can call on_close: */
|
|
lsquic_stream_destroy(streamA);
|
|
lsquic_stream_destroy(streamB);
|
|
}
|
|
|
|
|
|
/* Test that when stream frame is elided and the packet is dropped,
|
|
* the send controller produces a gapless sequence.
|
|
*
|
|
* Case "beginnig": 3 packets with STREAM frames for streams B, A, and A.
|
|
* Stream B is reset. We should get a gapless sequence
|
|
* of packets 1, 2.
|
|
*/
|
|
static void
|
|
test_gapless_elision_beginning (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *streamA, *streamB;
|
|
unsigned char buf[0x1000], buf_out[0x1000];
|
|
size_t n, thresh, written_to_A = 0;
|
|
int s, fin;
|
|
lsquic_packet_out_t *packet_out;
|
|
|
|
streamA = new_stream(tobjs, 345);
|
|
streamB = new_stream(tobjs, 347);
|
|
|
|
init_buf(buf_out, sizeof(buf_out));
|
|
|
|
thresh = lsquic_stream_flush_threshold(streamB, 0);
|
|
n = lsquic_stream_write(streamB, buf_out, thresh);
|
|
assert(n == thresh);
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
thresh = lsquic_stream_flush_threshold(streamA, 0);
|
|
n = lsquic_stream_write(streamA, buf_out, thresh);
|
|
assert(n == thresh);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
written_to_A += n;
|
|
|
|
thresh = lsquic_stream_flush_threshold(streamA, 0);
|
|
n = lsquic_stream_write(streamA, buf_out + written_to_A, thresh);
|
|
assert(n == thresh);
|
|
assert(3 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
written_to_A += n;
|
|
|
|
/* Verify contents of A: */
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, streamA->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(n == written_to_A);
|
|
assert(0 == memcmp(buf, buf_out, written_to_A));
|
|
|
|
/* Now reset stream B: */
|
|
assert(!(streamB->stream_flags & STREAM_FRAMES_ELIDED));
|
|
if (streamB->sm_bflags & SMBF_IETF)
|
|
lsquic_stream_stop_sending_in(streamB, 12345);
|
|
else
|
|
{
|
|
s = lsquic_stream_rst_in(streamB, 0, 0);
|
|
assert(s == 0);
|
|
}
|
|
assert(streamB->stream_flags & STREAM_FRAMES_ELIDED);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
/* Verify A again: */
|
|
n = read_from_scheduled_packets(&tobjs->send_ctl, streamA->id, buf,
|
|
sizeof(buf), 0, &fin, 0);
|
|
assert(n == written_to_A);
|
|
assert(0 == memcmp(buf, buf_out, written_to_A));
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(packet_out->po_packno == 1);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(packet_out->po_packno == 2);
|
|
lsquic_send_ctl_sent_packet(&tobjs->send_ctl, packet_out);
|
|
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs->send_ctl, 0);
|
|
assert(!packet_out);
|
|
|
|
/* Test on_reset() behavior. This is unrelated to the gapless elision
|
|
* test, but convenient to do here.
|
|
*/
|
|
if (streamA->sm_bflags & SMBF_IETF)
|
|
{
|
|
s_onreset_called = (struct reset_call_ctx) { NULL, -1, };
|
|
lsquic_stream_stop_sending_in(streamA, 12345);
|
|
assert(s_onreset_called.stream == streamA);
|
|
assert(s_onreset_called.how == 1);
|
|
}
|
|
|
|
/* Now we can call on_close: */
|
|
lsquic_stream_destroy(streamA);
|
|
lsquic_stream_destroy(streamB);
|
|
}
|
|
|
|
|
|
|
|
/* Write data to the stream, but do not flush: connection cap take a hit.
|
|
* After stream is destroyed, connection cap should go back up.
|
|
*/
|
|
static void
|
|
test_reset_stream_with_unflushed_data (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
char buf[0x100];
|
|
size_t n;
|
|
const struct lsquic_conn_cap *const cap = &tobjs->conn_pub.conn_cap;
|
|
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Self-check */
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
assert(n == 100);
|
|
|
|
/* Unflushed data counts towards connection cap for connection-limited
|
|
* stream:
|
|
*/
|
|
assert(0x4000 - 100 == lsquic_conn_cap_avail(cap));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Goes back up */
|
|
}
|
|
|
|
|
|
/* Write a little data to the stream, flush and then reset it: connection
|
|
* cap should NOT go back up.
|
|
*/
|
|
static void
|
|
test_reset_stream_with_flushed_data (struct test_objs *tobjs)
|
|
{
|
|
char buf[0x100];
|
|
size_t n;
|
|
lsquic_stream_t *stream;
|
|
const struct lsquic_conn_cap *const cap = &tobjs->conn_pub.conn_cap;
|
|
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Self-check */
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
assert(n == 100);
|
|
|
|
/* Unflushed data counts towards connection cap for
|
|
* connection-limited stream:
|
|
*/
|
|
assert(0x4000 - 100 == lsquic_conn_cap_avail(cap));
|
|
|
|
/* Flush the stream: */
|
|
lsquic_stream_flush(stream);
|
|
assert(0x4000 - 100 == lsquic_conn_cap_avail(cap));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(0x4000 - 100 == lsquic_conn_cap_avail(cap)); /* Still unchanged */
|
|
}
|
|
|
|
|
|
/* Write data to the handshake stream and flush: this should not affect
|
|
* connection cap.
|
|
*/
|
|
static void
|
|
test_unlimited_stream_flush_data (struct test_objs *tobjs)
|
|
{
|
|
char buf[0x100];
|
|
size_t n;
|
|
lsquic_stream_t *stream;
|
|
const struct lsquic_conn_cap *const cap = &tobjs->conn_pub.conn_cap;
|
|
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Self-check */
|
|
stream = new_stream(tobjs, 1);
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
assert(n == 100);
|
|
|
|
/* We DO NOT take connection cap hit after stream is flushed: */
|
|
lsquic_stream_flush(stream);
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap));
|
|
|
|
lsquic_stream_reset(stream, 0xF00DF00D);
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Still unchanged */
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Still unchanged */
|
|
}
|
|
|
|
|
|
/* Test that data gets flushed when stream is closed. */
|
|
static void
|
|
test_data_flush_on_close (struct test_objs *tobjs)
|
|
{
|
|
lsquic_stream_t *stream;
|
|
const struct lsquic_conn_cap *const cap = &tobjs->conn_pub.conn_cap;
|
|
char buf[0x100];
|
|
size_t n;
|
|
|
|
assert(0x4000 == lsquic_conn_cap_avail(cap)); /* Self-check */
|
|
stream = new_stream(tobjs, 345);
|
|
n = lsquic_stream_write(stream, buf, 100);
|
|
assert(n == 100);
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
lsquic_stream_close(stream);
|
|
/* Nothing is scheduled because STREAM frames are elided */
|
|
assert(0 == lsquic_send_ctl_n_scheduled(&tobjs->send_ctl));
|
|
|
|
assert(stream->sm_qflags & SMQF_SEND_RST);
|
|
assert(!(stream->sm_qflags & SMQF_FREE_STREAM));
|
|
assert(stream->sm_qflags & SMQF_WAIT_FIN_OFF);
|
|
|
|
/* We take connection cap hit after stream is flushed: */
|
|
assert(0x4000 - 100 == lsquic_conn_cap_avail(cap)); /* Conn cap hit */
|
|
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
|
|
/* In this function, we test stream termination conditions. In particular,
|
|
* we are interested in when the stream becomes finished (this is when
|
|
* connection closes it and starts ignoring frames that come after this):
|
|
* we need to test the following scenarios, both normal and abnormal
|
|
* termination, initiated both locally and remotely.
|
|
*
|
|
* We avoid formalities like calling wantread() and wantwrite() and
|
|
* dispatching read and write callbacks.
|
|
*/
|
|
static void
|
|
test_termination (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
const struct {
|
|
int gquic;
|
|
int ietf;
|
|
void (*func)(struct test_objs *);
|
|
} test_funcs[] = {
|
|
{ 1, 1, test_loc_FIN_rem_FIN, },
|
|
{ 1, 1, test_rem_FIN_loc_FIN, },
|
|
{ 1, 0, test_rem_data_loc_close_and_rst_in, },
|
|
{ 1, 0, test_rem_data_loc_close, },
|
|
{ 1, 1, test_loc_FIN_rem_RST, },
|
|
{ 1, 1, test_loc_data_rem_RST, },
|
|
{ 0, 1, test_loc_data_rem_SS, },
|
|
{ 1, 0, test_loc_RST_rem_FIN, },
|
|
{ 1, 1, test_gapless_elision_beginning, },
|
|
{ 1, 1, test_gapless_elision_middle, },
|
|
}, *tf;
|
|
|
|
for (tf = test_funcs; tf < test_funcs + sizeof(test_funcs) / sizeof(test_funcs[0]); ++tf)
|
|
{
|
|
if (tf->gquic)
|
|
{
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, select_pf_by_ver(LSQVER_043));
|
|
tf->func(&tobjs);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
if (tf->ietf)
|
|
{
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, select_pf_by_ver(LSQVER_ID27));
|
|
tf->func(&tobjs);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Test flush-related corner cases */
|
|
static void
|
|
test_flushing (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
unsigned i;
|
|
void (*const test_funcs[])(struct test_objs *) = {
|
|
test_reset_stream_with_unflushed_data,
|
|
test_reset_stream_with_flushed_data,
|
|
test_unlimited_stream_flush_data,
|
|
test_data_flush_on_close,
|
|
};
|
|
|
|
for (i = 0; i < sizeof(test_funcs) / sizeof(test_funcs[0]); ++i)
|
|
{
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
test_funcs[i](&tobjs);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
test_writev (void)
|
|
{
|
|
unsigned i;
|
|
struct test_objs tobjs;
|
|
lsquic_stream_t *stream;
|
|
ssize_t n;
|
|
unsigned char buf_in[0x4000];
|
|
unsigned char buf_out[0x4000];
|
|
int fin;
|
|
|
|
struct {
|
|
struct iovec iov[0x20];
|
|
int count;
|
|
} tests[] = {
|
|
{ .iov = {
|
|
{ .iov_base = buf_in, .iov_len = 0x4000, },
|
|
},
|
|
.count = 1,
|
|
},
|
|
{ .iov = {
|
|
{ .iov_base = buf_in , .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x1000, .iov_len = 0x3000, },
|
|
},
|
|
.count = 2,
|
|
},
|
|
{ .iov = {
|
|
{ .iov_base = buf_in , .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x1000, .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x2000, .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x3000, .iov_len = 0x1000, },
|
|
},
|
|
.count = 4,
|
|
},
|
|
{ .iov = {
|
|
{ .iov_base = buf_in , .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x1000, .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x2000, .iov_len = 0x1000, },
|
|
{ .iov_base = buf_in + 0x3000, .iov_len = 0xFF0, },
|
|
{ .iov_base = buf_in + 0x3FF0, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF1, .iov_len = 0, },
|
|
{ .iov_base = buf_in + 0x3FF1, .iov_len = 0, },
|
|
{ .iov_base = buf_in + 0x3FF1, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF2, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF3, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF4, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF5, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF6, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF7, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF8, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FF9, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFA, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFB, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFC, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFD, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFE, .iov_len = 1, },
|
|
{ .iov_base = buf_in + 0x3FFF, .iov_len = 1, },
|
|
},
|
|
.count = 22,
|
|
},
|
|
};
|
|
|
|
memset(buf_in, 'A', 0x1000);
|
|
memset(buf_in + 0x1000, 'B', 0x1000);
|
|
memset(buf_in + 0x2000, 'C', 0x1000);
|
|
memset(buf_in + 0x3000, 'D', 0x1000);
|
|
|
|
for (i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i)
|
|
{
|
|
init_test_objs(&tobjs, UINT_MAX, UINT_MAX, NULL);
|
|
stream = new_stream(&tobjs, 12345);
|
|
n = lsquic_stream_writev(stream, tests[i].iov, tests[i].count);
|
|
assert(0x4000 == n);
|
|
lsquic_stream_flush(stream);
|
|
n = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(0x4000 == n);
|
|
assert(0 == memcmp(buf_out, buf_in, 0x1000));
|
|
assert(!fin);
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
test_prio_conversion (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
lsquic_stream_t *stream;
|
|
unsigned prio;
|
|
int s;
|
|
|
|
init_test_objs(&tobjs, UINT_MAX, UINT_MAX, NULL);
|
|
stream = new_stream(&tobjs, 123);
|
|
|
|
s = lsquic_stream_set_priority(stream, -2);
|
|
assert(-1 == s);
|
|
s = lsquic_stream_set_priority(stream, 0);
|
|
assert(-1 == s);
|
|
s = lsquic_stream_set_priority(stream, 257);
|
|
assert(-1 == s);
|
|
|
|
for (prio = 1; prio <= 256; ++prio)
|
|
{
|
|
s = lsquic_stream_set_priority(stream, prio);
|
|
assert(0 == s);
|
|
assert(prio == lsquic_stream_priority(stream));
|
|
}
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
test_read_in_middle (void)
|
|
{
|
|
int s;
|
|
size_t nw = 0;
|
|
char buf[0x1000];
|
|
const char data[] = "AAABBBCCC";
|
|
struct test_objs tobjs;
|
|
stream_frame_t *frame;
|
|
uint64_t n_readable;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
lsquic_stream_t *stream = new_stream(&tobjs, 123);
|
|
|
|
frame = new_frame_in_ext(&tobjs, 0, 3, 0, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
n_readable = stream->data_in->di_if->di_readable_bytes(stream->data_in, 0);
|
|
assert(3 == n_readable);
|
|
|
|
/* Hole */
|
|
|
|
frame = new_frame_in_ext(&tobjs, 6, 3, 0, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
n_readable = stream->data_in->di_if->di_readable_bytes(stream->data_in, 0);
|
|
assert(3 == n_readable);
|
|
|
|
/* Read up to hole */
|
|
|
|
nw = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(3 == nw);
|
|
assert(0 == memcmp(buf, "AAA", 3));
|
|
n_readable = stream->data_in->di_if->di_readable_bytes(stream->data_in, 3);
|
|
assert(0 == n_readable);
|
|
|
|
frame = new_frame_in_ext(&tobjs, 3, 3, 0, &data[3]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
n_readable = stream->data_in->di_if->di_readable_bytes(stream->data_in, 3);
|
|
assert(6 == n_readable);
|
|
|
|
nw = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(6 == nw);
|
|
assert(0 == memcmp(buf, "BBBCCC", 6));
|
|
n_readable = stream->data_in->di_if->di_readable_bytes(stream->data_in, 9);
|
|
assert(0 == n_readable);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test that connection flow control does not go past the max when both
|
|
* connection limited and unlimited streams are used.
|
|
*/
|
|
static void
|
|
test_conn_unlimited (void)
|
|
{
|
|
size_t nw;
|
|
struct test_objs tobjs;
|
|
lsquic_stream_t *header_stream, *data_stream;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
unsigned char *const data = calloc(1, 0x4000);
|
|
|
|
/* Test 1: first write headers, then data stream */
|
|
header_stream = new_stream(&tobjs, 1);
|
|
data_stream = new_stream(&tobjs, 123);
|
|
nw = lsquic_stream_write(header_stream, data, 98);
|
|
assert(98 == nw);
|
|
lsquic_stream_flush(header_stream);
|
|
nw = lsquic_stream_write(data_stream, data, 0x4000);
|
|
assert(0x4000 == nw);
|
|
assert(tobjs.conn_pub.conn_cap.cc_sent <= tobjs.conn_pub.conn_cap.cc_max);
|
|
lsquic_stream_destroy(header_stream);
|
|
lsquic_stream_destroy(data_stream);
|
|
|
|
/* Test 2: first write data, then headers stream */
|
|
header_stream = new_stream(&tobjs, 1);
|
|
data_stream = new_stream(&tobjs, 123);
|
|
lsquic_conn_cap_init(&tobjs.conn_pub.conn_cap, 0x4000);
|
|
nw = lsquic_stream_write(data_stream, data, 0x4000);
|
|
assert(0x4000 == nw);
|
|
nw = lsquic_stream_write(header_stream, data, 98);
|
|
assert(98 == nw);
|
|
lsquic_stream_flush(header_stream);
|
|
assert(tobjs.conn_pub.conn_cap.cc_sent <= tobjs.conn_pub.conn_cap.cc_max);
|
|
|
|
lsquic_stream_destroy(header_stream);
|
|
lsquic_stream_destroy(data_stream);
|
|
|
|
deinit_test_objs(&tobjs);
|
|
free(data);
|
|
}
|
|
|
|
|
|
static void
|
|
test_reading_from_stream2 (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
char buf[0x1000];
|
|
struct iovec iov[2];
|
|
lsquic_packet_in_t *packet_in;
|
|
lsquic_stream_t *stream;
|
|
stream_frame_t *frame;
|
|
ssize_t nw;
|
|
int s;
|
|
enum stream_state_receiving ssr;
|
|
const char data[] = "1234567890";
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
stream = new_stream(&tobjs, 123);
|
|
ssr = lsquic_stream_receiving_state(stream);
|
|
assert(SSR_RECV == ssr);
|
|
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 0, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #1", 0 == s));
|
|
|
|
frame = new_frame_in_ext(&tobjs, 6, 4, 0, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #2", 0 == s));
|
|
|
|
/* Invalid frame: FIN in the middle */
|
|
frame = new_frame_in(&tobjs, 6, 0, 1);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Invalid frame: FIN in the middle", -1 == s));
|
|
|
|
/* Test for overlaps and DUPs: */
|
|
if (!(stream_ctor_flags & SCF_USE_DI_HASH))
|
|
{
|
|
int dup;
|
|
unsigned offset, length;
|
|
for (offset = 0; offset < 7; ++offset)
|
|
{
|
|
for (length = 1; length <= sizeof(data) - 1 - offset; ++length)
|
|
{
|
|
dup = (offset == 0 && length == 6)
|
|
|| (offset == 6 && length == 4);
|
|
frame = new_frame_in_ext(&tobjs, offset, length, 0, data + offset);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
if (dup)
|
|
assert(("Dup OK", 0 == s));
|
|
else
|
|
assert(("Overlap OK", 0 == s));
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
uint64_t n_readable;
|
|
|
|
n_readable = stream->data_in->di_if
|
|
->di_readable_bytes(stream->data_in, 0);
|
|
assert(10 == n_readable);
|
|
}
|
|
|
|
nw = lsquic_stream_read(stream, buf, 8);
|
|
assert(("Read 8 bytes", nw == 8));
|
|
assert(("Expected 8 bytes", 0 == memcmp(buf, "12345678", nw)));
|
|
|
|
/* Insert invalid frame: its offset + length is before the already-read
|
|
* offset.
|
|
*/
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 0, &data[0]);
|
|
packet_in = lsquic_packet_in_get(frame->packet_in); /* incref to check for dups below */
|
|
assert(2 == packet_in->pi_refcnt); /* Self-check */
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Insert frame before already-read offset succeeds (duplicate)",
|
|
s == 0));
|
|
assert(("Duplicate frame has been thrown out",
|
|
packet_in->pi_refcnt == 1));
|
|
lsquic_packet_in_put(&tobjs.eng_pub.enp_mm, packet_in);
|
|
packet_in = NULL;
|
|
|
|
iov[0].iov_base = buf;
|
|
iov[0].iov_len = 1;
|
|
iov[1].iov_base = buf + 1;
|
|
iov[1].iov_len = sizeof(buf) - 1;
|
|
nw = lsquic_stream_readv(stream, iov, 2);
|
|
assert(("Read 2 bytes", nw == 2));
|
|
assert(("Expected 2 bytes", 0 == memcmp(buf, "90", nw)));
|
|
nw = lsquic_stream_read(stream, buf, 8);
|
|
assert(("Read -1 bytes (EWOULDBLOCK)", -1 == nw && errno == EWOULDBLOCK));
|
|
nw = lsquic_stream_read(stream, buf, 8);
|
|
assert(("Read -1 bytes again (EWOULDBLOCK)", -1 == nw && errno == EWOULDBLOCK));
|
|
|
|
/* Insert invalid frame: its offset + length is before the already-read
|
|
* offset. This test is different from before: now there is buffered
|
|
* incoming data.
|
|
*/
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 0, &data[0]);
|
|
packet_in = lsquic_packet_in_get(frame->packet_in); /* incref to check for dups below */
|
|
assert(2 == packet_in->pi_refcnt); /* Self-check */
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Insert frame before already-read offset succeeds (duplicate)",
|
|
s == 0));
|
|
assert(("Duplicate frame has been thrown out",
|
|
packet_in->pi_refcnt == 1));
|
|
lsquic_packet_in_put(&tobjs.eng_pub.enp_mm, packet_in);
|
|
packet_in = NULL;
|
|
|
|
/* Last frame has no data but has a FIN flag set */
|
|
frame = new_frame_in_ext(&tobjs, 10, 0, 1,
|
|
(void *) 1234 /* Intentionally invalid: this pointer
|
|
* should not be used
|
|
*/);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #3", 0 == s));
|
|
ssr = lsquic_stream_receiving_state(stream);
|
|
assert(SSR_DATA_RECVD == ssr);
|
|
|
|
/* Invalid frame: writing after FIN */
|
|
frame = new_frame_in(&tobjs, 10, 2, 0);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Invalid frame caught", -1 == s));
|
|
|
|
/* Duplicate FIN frame */
|
|
frame = new_frame_in_ext(&tobjs, 10, 0, 1,
|
|
(void *) 1234 /* Intentionally invalid: this pointer
|
|
* should not be used
|
|
*/);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Duplicate FIN frame", 0 == s));
|
|
|
|
nw = lsquic_stream_read(stream, buf, 1);
|
|
assert(("Read 0 bytes (at EOR)", 0 == nw));
|
|
ssr = lsquic_stream_receiving_state(stream);
|
|
assert(SSR_DATA_READ == ssr);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* This tests stream overlap support */
|
|
static void
|
|
test_overlaps (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
char buf[0x1000];
|
|
lsquic_stream_t *stream;
|
|
stream_frame_t *frame;
|
|
int s;
|
|
const char data[] = "1234567890";
|
|
|
|
struct frame_spec
|
|
{
|
|
unsigned off;
|
|
unsigned len;
|
|
signed char fin;
|
|
};
|
|
|
|
struct frame_step
|
|
{
|
|
struct frame_spec frame_spec;
|
|
int insert_res; /* Expected result */
|
|
};
|
|
|
|
struct overlap_test
|
|
{
|
|
int line; /* Test identifier */
|
|
struct frame_step steps[10]; /* Sequence of steps */
|
|
unsigned n_steps;
|
|
const unsigned char buf[20]; /* Expected result of read */
|
|
ssize_t sz; /* Expected size of first read */
|
|
ssize_t second_read; /* Expected size of second read:
|
|
* 0 means EOS (FIN).
|
|
*/
|
|
};
|
|
|
|
static const struct overlap_test tests[] =
|
|
{
|
|
|
|
{
|
|
.line = __LINE__,
|
|
.steps =
|
|
{
|
|
{
|
|
.frame_spec = { .off = 0, .len = 10, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
},
|
|
.n_steps = 1,
|
|
.buf = "0123456789",
|
|
.sz = 10,
|
|
.second_read = -1,
|
|
},
|
|
|
|
{
|
|
.line = __LINE__,
|
|
.steps =
|
|
{
|
|
{
|
|
.frame_spec = { .off = 0, .len = 5, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
{
|
|
.frame_spec = { .off = 0, .len = 10, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
},
|
|
.n_steps = 2,
|
|
.buf = "0123456789",
|
|
.sz = 10,
|
|
.second_read = -1,
|
|
},
|
|
|
|
{
|
|
.line = __LINE__,
|
|
.steps =
|
|
{
|
|
{
|
|
.frame_spec = { .off = 1, .len = 9, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
{
|
|
.frame_spec = { .off = 1, .len = 9, .fin = 1, },
|
|
.insert_res = 0,
|
|
},
|
|
{
|
|
.frame_spec = { .off = 0, .len = 2, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
{
|
|
.frame_spec = { .off = 2, .len = 6, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
},
|
|
.n_steps = 4,
|
|
.buf = "0123456789",
|
|
.sz = 10,
|
|
.second_read = 0,
|
|
},
|
|
|
|
{
|
|
.line = __LINE__,
|
|
.steps =
|
|
{
|
|
{
|
|
.frame_spec = { .off = 1, .len = 9, .fin = 1, },
|
|
.insert_res = 0,
|
|
},
|
|
{
|
|
.frame_spec = { .off = 0, .len = 2, .fin = 0, },
|
|
.insert_res = 0,
|
|
},
|
|
},
|
|
.n_steps = 2,
|
|
.buf = "0123456789",
|
|
.sz = 10,
|
|
.second_read = 0,
|
|
},
|
|
|
|
{
|
|
.line = __LINE__,
|
|
.steps =
|
|
{
|
|
{ .frame_spec = { .off = 1, .len = 6, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 2, .len = 1, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 8, .len = 2, .fin = 1, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 3, .len = 2, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 4, .len = 1, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 5, .len = 2, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 6, .len = 1, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 7, .len = 3, .fin = 0, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 9, .len = 1, .fin = 1, }, .insert_res = 0, },
|
|
{ .frame_spec = { .off = 0, .len = 2, .fin = 0, }, .insert_res = 0, },
|
|
},
|
|
.n_steps = 10,
|
|
.buf = "0123456789",
|
|
.sz = 10,
|
|
.second_read = 0,
|
|
},
|
|
|
|
};
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
const struct overlap_test *test;
|
|
for (test = tests; test < tests + sizeof(tests) / sizeof(tests[0]); ++test)
|
|
{
|
|
LSQ_NOTICE("executing stream overlap test, line %d", test->line);
|
|
stream = new_stream(&tobjs, test->line);
|
|
|
|
const struct frame_step *step;
|
|
for (step = test->steps; step < test->steps + test->n_steps; ++step)
|
|
{
|
|
frame = new_frame_in_ext(&tobjs, step->frame_spec.off,
|
|
step->frame_spec.len, step->frame_spec.fin,
|
|
&data[step->frame_spec.off]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(s == step->insert_res);
|
|
}
|
|
|
|
ssize_t nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == test->sz);
|
|
assert(0 == memcmp(data, buf, test->sz));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == test->second_read);
|
|
if (nread < 0)
|
|
assert(EWOULDBLOCK == errno);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
{
|
|
LSQ_NOTICE("Special test on line %d", __LINE__);
|
|
stream = new_stream(&tobjs, __LINE__);
|
|
frame = new_frame_in_ext(&tobjs, 0, 5, 0, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
ssize_t nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 5);
|
|
assert(0 == memcmp(data, buf, 5));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread < 0);
|
|
assert(EWOULDBLOCK == errno);
|
|
/* Test that a frame with FIN that ends before the read offset
|
|
* results in an error.
|
|
*/
|
|
frame = new_frame_in_ext(&tobjs, 0, 3, 1, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(s < 0);
|
|
/* This frame should be a DUP: the next read should still return -1.
|
|
*/
|
|
frame = new_frame_in_ext(&tobjs, 3, 2, 0, &data[3]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(s == 0);
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread < 0);
|
|
assert(EWOULDBLOCK == errno);
|
|
/* This frame should be an overlap: FIN should register and
|
|
* the next read should return 0.
|
|
*/
|
|
frame = new_frame_in_ext(&tobjs, 0, 5, 1, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(s == 0);
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 0);
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
{
|
|
LSQ_NOTICE("Special test for bug 106 on line %d", __LINE__);
|
|
char *const data = malloc(5862);
|
|
init_buf(data, 5862);
|
|
assert(data);
|
|
stream = new_stream(&tobjs, __LINE__);
|
|
/* Insert four frames: */
|
|
frame = new_frame_in_ext(&tobjs, 0, 1173, 0, data);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
frame = new_frame_in_ext(&tobjs, 1173, 1173, 0, data + 1173);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
frame = new_frame_in_ext(&tobjs, 2346, 1172, 0, data + 2346);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
frame = new_frame_in_ext(&tobjs, 3518, 578, 0, data + 3518);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
/* Read all data: */
|
|
ssize_t nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 4096);
|
|
assert(0 == memcmp(data, buf, 4096));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread < 0);
|
|
assert(EWOULDBLOCK == errno);
|
|
/* Insert overlapped frame and one more: */
|
|
frame = new_frame_in_ext(&tobjs, 3518, 1172, 0, data + 3518);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
frame = new_frame_in_ext(&tobjs, 4690, 1172, 0, data + 4690);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(0 == s);
|
|
/* Verify that continued read from offset 4096 succeeds and
|
|
* contains expected data:
|
|
*/
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 5862 - 4096);
|
|
assert(0 == memcmp(data + 4096, buf, 5862 - 4096));
|
|
lsquic_stream_destroy(stream);
|
|
free(data);
|
|
}
|
|
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
test_insert_edge_cases (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
lsquic_stream_t *stream;
|
|
stream_frame_t *frame;
|
|
int s;
|
|
ssize_t nread;
|
|
const char data[] = "1234567890";
|
|
enum stream_state_receiving ssr;
|
|
unsigned buf[0x1000];
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
{
|
|
stream = new_stream(&tobjs, 123);
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 1, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #1", 0 == s));
|
|
ssr = lsquic_stream_receiving_state(stream);
|
|
assert(SSR_DATA_RECVD == ssr);
|
|
/* Invalid frame: different FIN location */
|
|
frame = new_frame_in_ext(&tobjs, 3, 2, 1, &data[3]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Invalid frame: different FIN location", -1 == s));
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
{
|
|
stream = new_stream(&tobjs, 123);
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 0, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #1", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(6 == nread);
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 0, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Duplicate frame", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == -1 && errno == EWOULDBLOCK);
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 1, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Frame OK", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 0); /* Hit EOF */
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 1, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Duplicate FIN frame", 0 == s));
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
{
|
|
stream = new_stream(&tobjs, 123);
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 1, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Frame OK", 0 == s));
|
|
ssr = lsquic_stream_receiving_state(stream);
|
|
assert(SSR_SIZE_KNOWN == ssr);
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 0, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #1", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(6 == nread);
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 0, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Duplicate frame", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(nread == 0); /* Hit EOF */
|
|
frame = new_frame_in_ext(&tobjs, 6, 0, 1, &data[6]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Duplicate FIN frame", 0 == s));
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
{
|
|
stream = new_stream(&tobjs, 123);
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 1, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted frame #1", 0 == s));
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(6 == nread);
|
|
nread = lsquic_stream_read(stream, buf, sizeof(buf));
|
|
assert(0 == nread); /* Hit EOF */
|
|
frame = new_frame_in_ext(&tobjs, 0, 6, 1, &data[0]);
|
|
s = lsquic_stream_frame_in(stream, frame);
|
|
assert(("Inserted duplicate frame", 0 == s));
|
|
lsquic_stream_destroy(stream);
|
|
}
|
|
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* When HTTP stream is closed unexpectedly, send a reset instead of creating
|
|
* an empty STREAM frame with a FIN bit set.
|
|
*/
|
|
static void
|
|
test_unexpected_http_close (void)
|
|
{
|
|
struct test_objs tobjs;
|
|
lsquic_stream_t *stream;
|
|
int s;
|
|
|
|
stream_ctor_flags |= SCF_HTTP;
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
stream = new_stream(&tobjs, 123);
|
|
assert(stream->sm_bflags & SMBF_USE_HEADERS); /* Self-check */
|
|
s = lsquic_stream_close(stream);
|
|
assert(s == 0);
|
|
assert(stream->sm_qflags & SMQF_SEND_RST);
|
|
assert(stream->sm_qflags & SMQF_CALL_ONCLOSE);
|
|
assert(!lsquic_send_ctl_has_buffered(&tobjs.send_ctl));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
stream_ctor_flags &= ~SCF_HTTP;
|
|
}
|
|
|
|
|
|
static void
|
|
test_writing_to_stream_schedule_stream_packets_immediately (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_conn *const lconn = &tobjs.lconn;
|
|
struct lsquic_stream *stream;
|
|
int s;
|
|
unsigned char buf[0x1000];
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
stream = new_stream(&tobjs, 123);
|
|
assert(("Stream initialized", stream));
|
|
const struct test_ctx *const test_ctx_local = tobjs.stream_if_ctx;
|
|
assert(("on_new_stream called correctly", stream == test_ctx_local->stream));
|
|
assert(LSQUIC_STREAM_DEFAULT_PRIO == lsquic_stream_priority(stream));
|
|
|
|
assert(lconn == lsquic_stream_conn(stream));
|
|
|
|
nw = lsquic_stream_write(stream, "Dude, where is", 14);
|
|
assert(("14 bytes written correctly", nw == 14));
|
|
|
|
assert(("not packetized",
|
|
0 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)));
|
|
/* Cap hit is taken immediately, even for flushed data */
|
|
assert(("connection cap is reduced by 14 bytes",
|
|
lsquic_conn_cap_avail(conn_cap) == 0x4000 - 14));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("packetized -- 1 packet",
|
|
1 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)));
|
|
|
|
nw = lsquic_stream_write(stream, " my car?!", 9);
|
|
assert(("9 bytes written correctly", nw == 9));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("packetized -- still 1 packet",
|
|
1 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)));
|
|
|
|
assert(("connection cap is reduced by 23 bytes",
|
|
lsquic_conn_cap_avail(conn_cap) == 0x4000 - 23));
|
|
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, NULL, 0);
|
|
assert(23 == nw);
|
|
assert(0 == memcmp(buf, "Dude, where is my car?!", 23));
|
|
assert(("cannot reduce max_send below what's been sent already",
|
|
-1 == lsquic_stream_set_max_send_off(stream, 15)));
|
|
assert(("cannot reduce max_send below what's been sent already #2",
|
|
-1 == lsquic_stream_set_max_send_off(stream, 22)));
|
|
assert(("can set to the same value...",
|
|
0 == lsquic_stream_set_max_send_off(stream, 23)));
|
|
assert(("...or larger",
|
|
0 == lsquic_stream_set_max_send_off(stream, 23000)));
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
test_writing_to_stream_outside_callback (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_conn *const lconn = &tobjs.lconn;
|
|
struct lsquic_stream *stream;
|
|
int s;
|
|
unsigned char buf[0x1000];
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_bp_type = BPT_OTHER_PRIO;
|
|
const struct buf_packet_q *const bpq =
|
|
&tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
stream = new_stream(&tobjs, 123);
|
|
assert(("Stream initialized", stream));
|
|
const struct test_ctx *const test_ctx_local = tobjs.stream_if_ctx;
|
|
assert(("on_new_stream called correctly", stream == test_ctx_local->stream));
|
|
assert(LSQUIC_STREAM_DEFAULT_PRIO == lsquic_stream_priority(stream));
|
|
|
|
assert(lconn == lsquic_stream_conn(stream));
|
|
|
|
nw = lsquic_stream_write(stream, "Dude, where is", 14);
|
|
assert(("14 bytes written correctly", nw == 14));
|
|
|
|
assert(("not packetized", 0 == bpq->bpq_count));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("packetized -- 1 packet", 1 == bpq->bpq_count));
|
|
|
|
nw = lsquic_stream_write(stream, " my car?!", 9);
|
|
assert(("9 bytes written correctly", nw == 9));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("packetized -- still 1 packet", 1 == bpq->bpq_count));
|
|
|
|
assert(("connection cap is reduced by 23 bytes",
|
|
lsquic_conn_cap_avail(conn_cap) == 0x4000 - 23));
|
|
|
|
/* Now we are magically inside the callback: */
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
assert(("packetized -- 1 packet",
|
|
1 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)));
|
|
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, NULL, 0);
|
|
assert(23 == nw);
|
|
assert(0 == memcmp(buf, "Dude, where is my car?!", 23));
|
|
assert(("cannot reduce max_send below what's been sent already",
|
|
-1 == lsquic_stream_set_max_send_off(stream, 15)));
|
|
assert(("cannot reduce max_send below what's been sent already #2",
|
|
-1 == lsquic_stream_set_max_send_off(stream, 22)));
|
|
assert(("can set to the same value...",
|
|
0 == lsquic_stream_set_max_send_off(stream, 23)));
|
|
assert(("...or larger",
|
|
0 == lsquic_stream_set_max_send_off(stream, 23000)));
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
verify_ack (struct lsquic_packet_out *packet_out)
|
|
{
|
|
struct packet_out_frec_iter pofi;
|
|
const struct frame_rec *frec;
|
|
unsigned short regen_sz;
|
|
enum quic_ft_bit frame_types;
|
|
|
|
assert(packet_out->po_regen_sz > 0);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_ACK));
|
|
|
|
regen_sz = 0;
|
|
frame_types = 0;
|
|
for (frec = lsquic_pofi_first(&pofi, packet_out); frec;
|
|
frec = lsquic_pofi_next(&pofi))
|
|
{
|
|
frame_types |= 1 << frec->fe_frame_type;
|
|
if (frec->fe_frame_type == QUIC_FRAME_ACK)
|
|
{
|
|
assert(frec->fe_len == 9);
|
|
assert(0 == memcmp(packet_out->po_data + frec->fe_off, "ACKACKACK", 9));
|
|
assert(regen_sz == frec->fe_off);
|
|
regen_sz += frec->fe_len;
|
|
}
|
|
}
|
|
|
|
assert(frame_types & (1 << QUIC_FRAME_ACK));
|
|
assert(regen_sz == packet_out->po_regen_sz);
|
|
}
|
|
|
|
|
|
/* Write to buffered streams: first to low-priority, then high-priority. This
|
|
* should trigger ACK generation and move.
|
|
*/
|
|
static void
|
|
test_stealing_ack (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_conn *const lconn = &tobjs.lconn;
|
|
struct lsquic_stream *lo_stream, *hi_stream;;
|
|
int s;
|
|
const struct buf_packet_q *bpq;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_write_ack = 1;
|
|
g_ctl_settings.tcs_bp_type = BPT_OTHER_PRIO;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
|
|
lo_stream = new_stream(&tobjs, 123);
|
|
assert(("Stream initialized", lo_stream));
|
|
assert(LSQUIC_STREAM_DEFAULT_PRIO == lsquic_stream_priority(lo_stream));
|
|
assert(lconn == lsquic_stream_conn(lo_stream));
|
|
nw = lsquic_stream_write(lo_stream, "Dude, where is", 14);
|
|
assert(("14 bytes written correctly", nw == 14));
|
|
s = lsquic_stream_flush(lo_stream);
|
|
assert(0 == s);
|
|
|
|
bpq = &tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
verify_ack(TAILQ_FIRST(&bpq->bpq_packets));
|
|
|
|
g_ctl_settings.tcs_bp_type = BPT_HIGHEST_PRIO;
|
|
|
|
hi_stream = new_stream(&tobjs, 1);
|
|
assert(("Stream initialized", hi_stream));
|
|
assert(lconn == lsquic_stream_conn(hi_stream));
|
|
nw = lsquic_stream_write(hi_stream, "DATA", 4);
|
|
assert(("4 bytes written correctly", nw == 4));
|
|
s = lsquic_stream_flush(hi_stream);
|
|
assert(0 == s);
|
|
|
|
/* ACK is moved (stolen) from low-priority stream to high-priority stream */
|
|
/* Check old packet */
|
|
assert(!(TAILQ_FIRST(&bpq->bpq_packets)->po_frame_types & (1 << QUIC_FRAME_ACK)));
|
|
/* Check new packet */
|
|
bpq = &tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
verify_ack(TAILQ_FIRST(&bpq->bpq_packets));
|
|
|
|
/* And now chop regen, see if we hit any asserts there */
|
|
lsquic_packet_out_chop_regen(TAILQ_FIRST(&bpq->bpq_packets));
|
|
/* And now verify that ACK is gone */
|
|
assert(!(TAILQ_FIRST(&bpq->bpq_packets)->po_frame_types & (1 << QUIC_FRAME_ACK)));
|
|
|
|
lsquic_stream_destroy(lo_stream);
|
|
lsquic_stream_destroy(hi_stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
test_changing_pack_size (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_conn *lconn = &tobjs.lconn;
|
|
struct lsquic_stream *stream;
|
|
int s, i;
|
|
unsigned char buf[0x2000];
|
|
size_t len;
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
enum lsquic_version versions_to_test[3] =
|
|
{
|
|
LSQVER_046,
|
|
LSQVER_ID27,
|
|
};
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
g_pf = select_pf_by_ver(versions_to_test[i]);
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_bp_type = BPT_OTHER_PRIO;
|
|
const struct buf_packet_q *const bpq =
|
|
&tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
{
|
|
tobjs.ctor_flags |= SCF_IETF;
|
|
lconn->cn_flags |= LSCONN_IETF;
|
|
network_path.np_pack_size = 4096;
|
|
}
|
|
stream = new_stream(&tobjs, 5);
|
|
assert(("Stream initialized", stream));
|
|
const struct test_ctx *const test_ctx_local = tobjs.stream_if_ctx;
|
|
assert(("on_new_stream called correctly", stream == test_ctx_local->stream));
|
|
|
|
len = ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS) ? 2048 : 1024;
|
|
nw = lsquic_stream_write(stream, buf, len);
|
|
assert(("n bytes written correctly", (size_t)nw == len));
|
|
|
|
assert(("not packetized", 0 == bpq->bpq_count));
|
|
|
|
/* IETF: shrink packet size before a flush */
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
network_path.np_pack_size = 1370;
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
assert(("packetized -- 2 packets", 2 == bpq->bpq_count));
|
|
else
|
|
assert(("packetized -- 1 packets", 1 == bpq->bpq_count));
|
|
|
|
/* IETF: expand packet size before a write */
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
network_path.np_pack_size = 4096;
|
|
|
|
len = ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS) ? 2048 : 1024;
|
|
nw = lsquic_stream_write(stream, buf, len);
|
|
assert(("n bytes written correctly", (size_t)nw == len));
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
assert(("packetized -- 3 packets", 3 == bpq->bpq_count));
|
|
else
|
|
assert(("packetized -- 1 packets", 1 == bpq->bpq_count));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
assert(("packetized -- 3 packets", 3 == bpq->bpq_count));
|
|
else
|
|
assert(("packetized -- 2 packets", 2 == bpq->bpq_count));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
g_pf = select_pf_by_ver(LSQVER_043);
|
|
}
|
|
|
|
|
|
/* This tests what happens when a stream data is buffered using one packet
|
|
* size, but then packet size get smaller (which is what happens when an RTO
|
|
* occurs), and then more data is written.
|
|
*
|
|
* In particular, the write sizes in this tests are structured to make
|
|
* maybe_resize_threshold() change the threshold.
|
|
*/
|
|
static void
|
|
test_reducing_pack_size (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_conn *lconn = &tobjs.lconn;
|
|
struct lsquic_stream *stream;
|
|
int s;
|
|
unsigned i;
|
|
unsigned char buf[0x4000];
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
enum lsquic_version versions_to_test[] =
|
|
{
|
|
LSQVER_050,
|
|
LSQVER_ID29,
|
|
};
|
|
|
|
/* Particular versions should not matter as this is tests the logic in
|
|
* stream only, but we do it for completeness.
|
|
*/
|
|
for (i = 0; i < sizeof(versions_to_test) / sizeof(versions_to_test[0]); i++)
|
|
{
|
|
g_pf = select_pf_by_ver(versions_to_test[i]);
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
g_ctl_settings.tcs_bp_type = BPT_OTHER_PRIO;
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
if ((1 << versions_to_test[i]) & LSQUIC_IETF_VERSIONS)
|
|
{
|
|
tobjs.ctor_flags |= SCF_IETF;
|
|
lconn->cn_flags |= LSCONN_IETF;
|
|
}
|
|
network_path.np_pack_size = 2000;
|
|
stream = new_stream(&tobjs, 5);
|
|
assert(("Stream initialized", stream));
|
|
const struct test_ctx *const test_ctx_local = tobjs.stream_if_ctx;
|
|
assert(("on_new_stream called correctly", stream == test_ctx_local->stream));
|
|
|
|
nw = lsquic_stream_write(stream, buf, 1400);
|
|
assert(stream->sm_n_allocated <= 2000);
|
|
assert(stream->sm_n_buffered > 0);
|
|
assert(("n bytes written correctly", (size_t)nw == 1400));
|
|
|
|
/* Shrink packet size */
|
|
network_path.np_pack_size = 1300;
|
|
|
|
nw = lsquic_stream_write(stream, buf, 3000);
|
|
assert(stream->sm_n_allocated <= 1300);
|
|
assert(stream->sm_n_buffered > 0);
|
|
assert(("n bytes written correctly", (size_t)nw == 3000));
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(stream->sm_n_buffered == 0);
|
|
assert(0 == s);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
g_pf = select_pf_by_ver(LSQVER_043);
|
|
}
|
|
|
|
|
|
/* Test window update logic, connection-limited */
|
|
static void
|
|
test_window_update1 (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *stream;
|
|
unsigned char buf[0x1000];
|
|
lsquic_packet_out_t *packet_out;
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
int s;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
stream = new_stream_ext(&tobjs, 123, 3);
|
|
nw = lsquic_stream_write(stream, "1234567890", 10);
|
|
assert(("lsquic_stream_write is limited by the send window", 3 == nw));
|
|
assert(("cc_tosend is updated immediately",
|
|
3 == conn_cap->cc_sent));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("cc_tosend is updated when limited by connection",
|
|
3 == conn_cap->cc_sent));
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, NULL, 0);
|
|
assert(nw == 3);
|
|
assert(0 == memcmp(buf, "123", 3));
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
|
|
lsquic_stream_window_update(stream, 20);
|
|
nw = lsquic_stream_write(stream, "4567890", 7);
|
|
assert(("lsquic_stream_write: wrote remainig 7 bytes", 7 == nw));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 3, NULL, 0);
|
|
assert(nw == 7);
|
|
assert(0 == memcmp(buf, "4567890", 7));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test two: large frame in the middle */
|
|
static void
|
|
test_bad_packbits_guess_2 (void)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[3];
|
|
char buf[0x1000];
|
|
unsigned char buf_out[0x1000];
|
|
int s, fin;
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_guess_packno_bits = GQUIC_PACKNO_LEN_1;
|
|
|
|
init_test_objs(&tobjs, 0x1000, 0x1000, NULL);
|
|
streams[0] = new_stream(&tobjs, 5);
|
|
streams[1] = new_stream(&tobjs, 7);
|
|
streams[2] = new_stream(&tobjs, 9);
|
|
|
|
/* Perfrom writes on the three streams. This is tuned to fill a single
|
|
* packet completely -- we check this later in this function.
|
|
*/
|
|
s = lsquic_stream_shutdown(streams[0], 1);
|
|
assert(s == 0);
|
|
nw = lsquic_stream_write(streams[1], buf, 1337);
|
|
assert(nw == 1337);
|
|
s = lsquic_stream_flush(streams[1]);
|
|
assert(0 == s);
|
|
nw = lsquic_stream_write(streams[2], buf + 1337, 1);
|
|
assert(nw == 1);
|
|
s = lsquic_stream_shutdown(streams[2], 1);
|
|
assert(s == 0);
|
|
|
|
/* Verify that we got one packet filled to the top: */
|
|
const struct buf_packet_q *const bpq =
|
|
&tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
assert(("packetized -- 1 packet", 1 == bpq->bpq_count));
|
|
packet_out = TAILQ_FIRST(&bpq->bpq_packets);
|
|
assert(0 == lsquic_packet_out_avail(packet_out));
|
|
|
|
assert(1 == streams[0]->n_unacked);
|
|
assert(1 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
g_ctl_settings.tcs_calc_packno_bits = GQUIC_PACKNO_LEN_6;
|
|
s = lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl));
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 0);
|
|
assert(fin);
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[1]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 1337);
|
|
assert(!fin);
|
|
assert(0 == memcmp(buf, buf_out, 1337));
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[2]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 1);
|
|
assert(fin);
|
|
assert(0 == memcmp(buf + 1337, buf_out, 1));
|
|
|
|
/* Verify packets */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(1 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(2 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
|
|
assert(1 == streams[0]->n_unacked);
|
|
assert(1 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 1);
|
|
assert(0 == streams[0]->n_unacked);
|
|
assert(0 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 2);
|
|
assert(0 == streams[0]->n_unacked);
|
|
assert(0 == streams[1]->n_unacked);
|
|
assert(0 == streams[2]->n_unacked);
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
lsquic_stream_destroy(streams[1]);
|
|
lsquic_stream_destroy(streams[2]);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test three: split large STREAM frame into two halves. The second half
|
|
* goes into new packet.
|
|
*/
|
|
static void
|
|
test_bad_packbits_guess_3 (void)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[1];
|
|
char buf[0x1000];
|
|
unsigned char buf_out[0x1000];
|
|
int s, fin;
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_guess_packno_bits = GQUIC_PACKNO_LEN_1;
|
|
|
|
init_test_objs(&tobjs, 0x1000, 0x1000, NULL);
|
|
streams[0] = new_stream(&tobjs, 5);
|
|
|
|
nw = lsquic_stream_write(streams[0], buf,
|
|
/* Use odd number to test halving logic: */ 1343);
|
|
assert(nw == 1343);
|
|
s = lsquic_stream_shutdown(streams[0], 1);
|
|
assert(s == 0);
|
|
|
|
/* Verify that we got one packet filled to the top (minus one byte) */
|
|
const struct buf_packet_q *const bpq =
|
|
&tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
assert(("packetized -- 1 packet", 1 == bpq->bpq_count));
|
|
packet_out = TAILQ_FIRST(&bpq->bpq_packets);
|
|
assert(1 == lsquic_packet_out_avail(packet_out));
|
|
|
|
assert(1 == streams[0]->n_unacked);
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
g_ctl_settings.tcs_calc_packno_bits = GQUIC_PACKNO_LEN_6;
|
|
s = lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl));
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 1343);
|
|
assert(fin);
|
|
assert(0 == memcmp(buf, buf_out, 1343));
|
|
|
|
/* Verify packets */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(1 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(2 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
|
|
assert(2 == streams[0]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 1);
|
|
assert(1 == streams[0]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 2);
|
|
assert(0 == streams[0]->n_unacked);
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test resizing of buffered packets:
|
|
* 1. Write data to buffered packets
|
|
* 2. Reduce packet size
|
|
* 3. Resize buffered packets
|
|
* 4. Schedule them
|
|
* 5. Check contents
|
|
*/
|
|
static void
|
|
test_resize_buffered (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[1];
|
|
const struct parse_funcs *const pf = select_pf_by_ver(LSQVER_ID27);
|
|
char buf[0x10000];
|
|
unsigned char buf_out[0x10000];
|
|
int s, fin;
|
|
unsigned packet_counts[2];
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
lsquic_send_ctl_set_max_bpq_count(UINT_MAX);
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
|
|
init_test_objs(&tobjs, 0x100000, 0x100000, pf);
|
|
tobjs.send_ctl.sc_flags |= SC_IETF; /* work around asserts lsquic_send_ctl_resize() */
|
|
network_path.np_pack_size = 4096;
|
|
streams[0] = new_stream_ext(&tobjs, 8, 0x100000);
|
|
|
|
nw = lsquic_stream_write(streams[0], buf, sizeof(buf));
|
|
assert(nw == sizeof(buf));
|
|
s = lsquic_stream_shutdown(streams[0], 1);
|
|
assert(s == 0);
|
|
packet_counts[0] = tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type].bpq_count;
|
|
|
|
assert(streams[0]->n_unacked > 0);
|
|
|
|
network_path.np_pack_size = 1234;
|
|
lsquic_send_ctl_resize(&tobjs.send_ctl);
|
|
packet_counts[1] = tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type].bpq_count;
|
|
assert(packet_counts[1] > packet_counts[0]);
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
s = lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
assert(lsquic_send_ctl_n_scheduled(&tobjs.send_ctl) > 0);
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == sizeof(buf));
|
|
assert(fin);
|
|
assert(0 == memcmp(buf, buf_out, nw));
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
deinit_test_objs(&tobjs);
|
|
lsquic_send_ctl_set_max_bpq_count(10);
|
|
}
|
|
|
|
|
|
/* Test resizing of buffered packets:
|
|
* 1. Write data to buffered packets
|
|
* 2. Schedule them
|
|
* 3. Reduce packet size
|
|
* 4. Resize packets
|
|
* 5. Check contents
|
|
*/
|
|
static void
|
|
test_resize_scheduled (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[1];
|
|
const struct parse_funcs *const pf = select_pf_by_ver(LSQVER_ID27);
|
|
char buf[0x10000];
|
|
unsigned char buf_out[0x10000];
|
|
int s, fin;
|
|
unsigned packet_counts[2];
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
lsquic_send_ctl_set_max_bpq_count(UINT_MAX);
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
|
|
init_test_objs(&tobjs, 0x100000, 0x100000, pf);
|
|
tobjs.send_ctl.sc_flags |= SC_IETF; /* work around asserts lsquic_send_ctl_resize() */
|
|
network_path.np_pack_size = 4096;
|
|
streams[0] = new_stream_ext(&tobjs, 8, 0x100000);
|
|
|
|
nw = lsquic_stream_write(streams[0], buf, sizeof(buf));
|
|
assert(nw == sizeof(buf));
|
|
s = lsquic_stream_shutdown(streams[0], 1);
|
|
assert(s == 0);
|
|
|
|
assert(streams[0]->n_unacked > 0);
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
s = lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
packet_counts[0] = lsquic_send_ctl_n_scheduled(&tobjs.send_ctl);
|
|
assert(packet_counts[0] > 0);
|
|
|
|
network_path.np_pack_size = 1234;
|
|
lsquic_send_ctl_resize(&tobjs.send_ctl);
|
|
packet_counts[1] = lsquic_send_ctl_n_scheduled(&tobjs.send_ctl);
|
|
assert(packet_counts[1] > packet_counts[0]);
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == sizeof(buf));
|
|
assert(fin);
|
|
assert(0 == memcmp(buf, buf_out, nw));
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
deinit_test_objs(&tobjs);
|
|
lsquic_send_ctl_set_max_bpq_count(10);
|
|
}
|
|
|
|
|
|
struct packetization_test_stream_ctx
|
|
{
|
|
const unsigned char *buf;
|
|
unsigned len, off, write_size;
|
|
};
|
|
|
|
|
|
static lsquic_stream_ctx_t *
|
|
packetization_on_new_stream (void *stream_if_ctx, lsquic_stream_t *stream)
|
|
{
|
|
lsquic_stream_wantwrite(stream, 1);
|
|
return stream_if_ctx;
|
|
}
|
|
|
|
|
|
static void
|
|
packetization_on_close (lsquic_stream_t *stream, lsquic_stream_ctx_t *st_h)
|
|
{
|
|
}
|
|
|
|
|
|
#define RANDOM_WRITE_SIZE ~0U
|
|
|
|
static unsigned
|
|
calc_n_to_write (unsigned write_size)
|
|
{
|
|
if (write_size == RANDOM_WRITE_SIZE)
|
|
return rand() % 1000 + 1;
|
|
else
|
|
return write_size;
|
|
}
|
|
|
|
|
|
static void
|
|
packetization_write_as_much_as_you_can (lsquic_stream_t *stream,
|
|
lsquic_stream_ctx_t *ctx)
|
|
{
|
|
struct packetization_test_stream_ctx *const pack_ctx = (void *) ctx;
|
|
unsigned n_to_write;
|
|
ssize_t n_written;
|
|
int s;
|
|
|
|
while (pack_ctx->off < pack_ctx->len)
|
|
{
|
|
n_to_write = calc_n_to_write(pack_ctx->write_size);
|
|
if (n_to_write > pack_ctx->len - pack_ctx->off)
|
|
n_to_write = pack_ctx->len - pack_ctx->off;
|
|
n_written = lsquic_stream_write(stream, pack_ctx->buf + pack_ctx->off,
|
|
n_to_write);
|
|
assert(n_written >= 0);
|
|
if (n_written == 0)
|
|
break;
|
|
pack_ctx->off += n_written;
|
|
}
|
|
|
|
s = lsquic_stream_flush(stream);
|
|
assert(s == 0);
|
|
lsquic_stream_wantwrite(stream, 0);
|
|
}
|
|
|
|
|
|
static void
|
|
packetization_perform_one_write (lsquic_stream_t *stream,
|
|
lsquic_stream_ctx_t *ctx)
|
|
{
|
|
struct packetization_test_stream_ctx *const pack_ctx = (void *) ctx;
|
|
unsigned n_to_write;
|
|
ssize_t n_written;
|
|
|
|
n_to_write = calc_n_to_write(pack_ctx->write_size);
|
|
if (n_to_write > pack_ctx->len - pack_ctx->off)
|
|
n_to_write = pack_ctx->len - pack_ctx->off;
|
|
n_written = lsquic_stream_write(stream, pack_ctx->buf + pack_ctx->off,
|
|
n_to_write);
|
|
assert(n_written >= 0);
|
|
pack_ctx->off += n_written;
|
|
if (n_written == 0)
|
|
lsquic_stream_wantwrite(stream, 0);
|
|
}
|
|
|
|
|
|
static const struct lsquic_stream_if packetization_inside_once_stream_if = {
|
|
.on_new_stream = packetization_on_new_stream,
|
|
.on_close = packetization_on_close,
|
|
.on_write = packetization_write_as_much_as_you_can,
|
|
};
|
|
|
|
|
|
static const struct lsquic_stream_if packetization_inside_many_stream_if = {
|
|
.on_new_stream = packetization_on_new_stream,
|
|
.on_close = packetization_on_close,
|
|
.on_write = packetization_perform_one_write,
|
|
};
|
|
|
|
|
|
static void
|
|
test_packetization (int schedule_stream_packets_immediately, int dispatch_once,
|
|
unsigned write_size, unsigned first_stream_sz)
|
|
{
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[2];
|
|
size_t nw;
|
|
int fin;
|
|
unsigned stream_ids[2];
|
|
unsigned char buf[0x8000];
|
|
unsigned char buf_out[0x8000];
|
|
|
|
struct packetization_test_stream_ctx packet_stream_ctx =
|
|
{
|
|
.buf = buf,
|
|
.off = 0,
|
|
.len = sizeof(buf),
|
|
.write_size = write_size,
|
|
};
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = schedule_stream_packets_immediately;
|
|
|
|
init_test_objs(&tobjs,
|
|
/* Test limits a bit while we are at it: */
|
|
sizeof(buf) - 1, sizeof(buf) - 1, NULL);
|
|
tobjs.stream_if_ctx = &packet_stream_ctx;
|
|
|
|
if (schedule_stream_packets_immediately)
|
|
{
|
|
if (dispatch_once)
|
|
{
|
|
tobjs.stream_if = &packetization_inside_once_stream_if;
|
|
tobjs.ctor_flags |= SCF_DISP_RW_ONCE;
|
|
}
|
|
else
|
|
tobjs.stream_if = &packetization_inside_many_stream_if;
|
|
}
|
|
else
|
|
/* Need this for on_new_stream() callback not to mess with
|
|
* the context, otherwise this is not used.
|
|
*/
|
|
tobjs.stream_if = &packetization_inside_many_stream_if;
|
|
|
|
if (g_use_crypto_ctor)
|
|
{
|
|
stream_ids[0] = ENC_LEV_CLEAR;
|
|
stream_ids[1] = ENC_LEV_INIT;
|
|
}
|
|
else
|
|
{
|
|
stream_ids[0] = 7;
|
|
stream_ids[1] = 5;
|
|
}
|
|
|
|
streams[0] = new_stream(&tobjs, stream_ids[0]);
|
|
streams[1] = new_stream_ext(&tobjs, stream_ids[1], sizeof(buf) - 1);
|
|
|
|
if (first_stream_sz)
|
|
{
|
|
lsquic_stream_write(streams[0], buf, first_stream_sz);
|
|
lsquic_stream_flush(streams[0]);
|
|
}
|
|
|
|
if (schedule_stream_packets_immediately)
|
|
{
|
|
lsquic_stream_dispatch_write_events(streams[1]);
|
|
lsquic_stream_flush(streams[1]);
|
|
}
|
|
else
|
|
{
|
|
packetization_write_as_much_as_you_can(streams[1],
|
|
(void *) &packet_stream_ctx);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl, BPT_HIGHEST_PRIO);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
}
|
|
|
|
if (!g_use_crypto_ctor)
|
|
assert(packet_stream_ctx.off == packet_stream_ctx.len - first_stream_sz - 1);
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[1]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 1);
|
|
if (!g_use_crypto_ctor)
|
|
{
|
|
assert(nw == sizeof(buf) - first_stream_sz - 1);
|
|
assert(!fin);
|
|
assert(0 == memcmp(buf, buf_out, sizeof(buf) - first_stream_sz - 1));
|
|
}
|
|
else
|
|
{
|
|
assert(sizeof(buf) == nw);
|
|
assert(0 == memcmp(buf, buf_out, nw));
|
|
}
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
lsquic_stream_destroy(streams[1]);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test condition when the room necessary to write a STREAM frame to a packet
|
|
* is miscalculated and a brand-new packet has to be allocated.
|
|
*
|
|
* This does not affect IETF QUIC because the STREAM frame uses varint data
|
|
* length representation and thus uses just a single byte to represent the
|
|
* length of a 1-byte stream data chunk.
|
|
*/
|
|
static void
|
|
test_cant_fit_frame (const struct parse_funcs *pf)
|
|
{
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[2];
|
|
struct lsquic_packet_out *packet_out;
|
|
size_t pad_len, rem, nr;
|
|
int fin, s;
|
|
const char dude[] = "Dude, where is my car?!";
|
|
unsigned char buf_out[100];
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
|
|
init_test_objs(&tobjs, 0x8000, 0x8000, pf);
|
|
|
|
streams[0] = new_stream(&tobjs, 5);
|
|
streams[1] = new_stream(&tobjs, 7);
|
|
|
|
/* Allocate a packet and pad it so just a few bytes remain to trigger
|
|
* the condition we're after.
|
|
*/
|
|
lsquic_stream_write(streams[0], dude, sizeof(dude) - 1);
|
|
lsquic_stream_flush(streams[0]);
|
|
|
|
rem = pf->pf_calc_stream_frame_header_sz(streams[1]->id, 0, 1)
|
|
+ 1 /* We'll write one byte */
|
|
+ 1 /* This triggers the refit condition */
|
|
;
|
|
|
|
packet_out = TAILQ_FIRST(&tobjs.send_ctl.sc_buffered_packets[0].bpq_packets);
|
|
assert(NULL == TAILQ_NEXT(packet_out, po_next));
|
|
pad_len = packet_out->po_n_alloc - packet_out->po_data_sz - rem;
|
|
memset(packet_out->po_data + packet_out->po_data_sz, 0, pad_len);
|
|
packet_out->po_data_sz += pad_len;
|
|
|
|
lsquic_stream_write(streams[1], "A", 1);
|
|
s = lsquic_stream_flush(streams[1]);
|
|
assert(0 == s);
|
|
/* Allocated another packet */
|
|
assert(TAILQ_NEXT(packet_out, po_next));
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl, BPT_HIGHEST_PRIO);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
|
|
/* Verify written data: */
|
|
nr = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 1);
|
|
assert(nr == sizeof(dude) - 1);
|
|
assert(!fin);
|
|
assert(0 == memcmp(dude, buf_out, sizeof(dude) - 1));
|
|
nr = read_from_scheduled_packets(&tobjs.send_ctl, streams[1]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 1);
|
|
assert(nr == 1);
|
|
assert(!fin);
|
|
assert(buf_out[0] == 'A');
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
lsquic_stream_destroy(streams[1]);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test window update logic, not connection limited */
|
|
static void
|
|
test_window_update2 (void)
|
|
{
|
|
ssize_t nw;
|
|
int s;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *stream;
|
|
lsquic_packet_out_t *packet_out;
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
unsigned char buf[0x1000];
|
|
|
|
init_test_objs(&tobjs, 0x4000, 0x4000, NULL);
|
|
n_closed = 0;
|
|
stream = new_stream_ext(&tobjs, 1, 3);
|
|
nw = lsquic_stream_write(stream, "1234567890", 10);
|
|
lsquic_stream_flush(stream);
|
|
assert(("lsquic_stream_write is limited by the send window", 3 == nw));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("cc_tosend is not updated when not limited by connection",
|
|
0 == conn_cap->cc_sent));
|
|
assert(stream->sm_qflags & SMQF_SEND_BLOCKED);
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 0, NULL, 0);
|
|
assert(nw == 3);
|
|
assert(0 == memcmp(buf, "123", 3));
|
|
|
|
/* Pretend we sent out a packet: */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
|
|
lsquic_stream_window_update(stream, 20);
|
|
nw = lsquic_stream_write(stream, "4567890", 7);
|
|
assert(("lsquic_stream_write: wrote remainig 7 bytes", 7 == nw));
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, stream->id, buf,
|
|
sizeof(buf), 3, NULL, 0);
|
|
assert(nw == 7);
|
|
assert(0 == memcmp(buf, "4567890", 7));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
assert(("on_close called", 1 == n_closed));
|
|
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test that stream is marked as both stream- and connection-blocked */
|
|
static void
|
|
test_blocked_flags (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *stream;
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
int s;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
|
|
init_test_objs(&tobjs, 3, 3, NULL);
|
|
stream = new_stream_ext(&tobjs, 123, 3);
|
|
nw = lsquic_stream_write(stream, "1234567890", 10);
|
|
assert(("lsquic_stream_write is limited by the send window", 3 == nw));
|
|
assert(("cc_tosend is updated immediately",
|
|
3 == conn_cap->cc_sent));
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)); /* Flush occurred already */
|
|
s = lsquic_stream_flush(stream);
|
|
assert(0 == s);
|
|
assert(("cc_tosend is updated when limited by connection",
|
|
3 == conn_cap->cc_sent));
|
|
assert(stream->sm_qflags & SMQF_SEND_BLOCKED);
|
|
assert(3 == stream->blocked_off);
|
|
assert(tobjs.lconn.cn_flags & LSCONN_SEND_BLOCKED);
|
|
assert(3 == conn_cap->cc_blocked);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
test_forced_flush_when_conn_blocked (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *stream;
|
|
struct lsquic_conn_cap *const conn_cap = &tobjs.conn_pub.conn_cap;
|
|
enum stream_state_sending sss;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
|
|
init_test_objs(&tobjs, 3, 0x1000, NULL);
|
|
stream = new_stream(&tobjs, 123);
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_READY == sss);
|
|
nw = lsquic_stream_write(stream, "1234567890", 10);
|
|
assert(("lsquic_stream_write is limited by the send window", 3 == nw));
|
|
assert(("cc_tosend is updated immediately",
|
|
3 == conn_cap->cc_sent));
|
|
assert(1 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl)); /* Flush occurred */
|
|
sss = lsquic_stream_sending_state(stream);
|
|
assert(SSS_SEND == sss);
|
|
assert(tobjs.lconn.cn_flags & LSCONN_SEND_BLOCKED);
|
|
assert(3 == conn_cap->cc_blocked);
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static int
|
|
my_gen_stream_frame_err (unsigned char *buf, size_t bufsz,
|
|
lsquic_stream_id_t stream_id, uint64_t offset,
|
|
int fin, size_t size, gsf_read_f read,
|
|
void *stream)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
static void
|
|
test_conn_abort (void)
|
|
{
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *stream;
|
|
struct parse_funcs my_pf;
|
|
int s;
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
|
|
init_test_objs(&tobjs, 0x1000, 0x1000, NULL);
|
|
my_pf = *tobjs.lconn.cn_pf;
|
|
my_pf.pf_gen_stream_frame = my_gen_stream_frame_err;
|
|
tobjs.lconn.cn_pf = &my_pf;
|
|
|
|
stream = new_stream(&tobjs, 123);
|
|
nw = lsquic_stream_write(stream, "1234567890", 10);
|
|
assert(10 == nw); /* No error yet */
|
|
s = lsquic_stream_flush(stream);
|
|
assert(s < 0);
|
|
assert(stream->sm_qflags & SMQF_ABORT_CONN);
|
|
assert(!TAILQ_EMPTY(&tobjs.conn_pub.service_streams));
|
|
|
|
lsquic_stream_destroy(stream);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
/* Test one: large frame first, followed by small frames to finish off
|
|
* the packet.
|
|
*/
|
|
static void
|
|
test_bad_packbits_guess_1 (void)
|
|
{
|
|
lsquic_packet_out_t *packet_out;
|
|
ssize_t nw;
|
|
struct test_objs tobjs;
|
|
struct lsquic_stream *streams[3];
|
|
char buf[0x1000];
|
|
unsigned char buf_out[0x1000];
|
|
int s, fin;
|
|
|
|
init_buf(buf, sizeof(buf));
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 0;
|
|
g_ctl_settings.tcs_guess_packno_bits = GQUIC_PACKNO_LEN_1;
|
|
|
|
init_test_objs(&tobjs, 0x1000, 0x1000, NULL);
|
|
streams[0] = new_stream(&tobjs, 5);
|
|
streams[1] = new_stream(&tobjs, 7);
|
|
streams[2] = new_stream(&tobjs, 9);
|
|
|
|
/* Perfrom writes on the three streams. This is tuned to fill a single
|
|
* packet completely -- we check this later in this function.
|
|
*/
|
|
nw = lsquic_stream_write(streams[0], buf, 1337);
|
|
assert(nw == 1337);
|
|
s = lsquic_stream_flush(streams[0]);
|
|
assert(0 == s);
|
|
s = lsquic_stream_shutdown(streams[1], 1);
|
|
assert(s == 0);
|
|
nw = lsquic_stream_write(streams[2], buf + 1337, 1);
|
|
assert(nw == 1);
|
|
s = lsquic_stream_shutdown(streams[2], 1);
|
|
assert(s == 0);
|
|
|
|
/* Verify that we got one packet filled to the top: */
|
|
const struct buf_packet_q *const bpq =
|
|
&tobjs.send_ctl.sc_buffered_packets[g_ctl_settings.tcs_bp_type];
|
|
assert(("packetized -- 1 packet", 1 == bpq->bpq_count));
|
|
packet_out = TAILQ_FIRST(&bpq->bpq_packets);
|
|
assert(0 == lsquic_packet_out_avail(packet_out));
|
|
|
|
assert(1 == streams[0]->n_unacked);
|
|
assert(1 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
|
|
g_ctl_settings.tcs_schedule_stream_packets_immediately = 1;
|
|
g_ctl_settings.tcs_calc_packno_bits = GQUIC_PACKNO_LEN_6;
|
|
s = lsquic_send_ctl_schedule_buffered(&tobjs.send_ctl,
|
|
g_ctl_settings.tcs_bp_type);
|
|
assert(2 == lsquic_send_ctl_n_scheduled(&tobjs.send_ctl));
|
|
|
|
/* Verify written data: */
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[0]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 1337);
|
|
assert(!fin);
|
|
assert(0 == memcmp(buf, buf_out, 1337));
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[1]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 0);
|
|
assert(fin);
|
|
nw = read_from_scheduled_packets(&tobjs.send_ctl, streams[2]->id, buf_out,
|
|
sizeof(buf_out), 0, &fin, 0);
|
|
assert(nw == 1);
|
|
assert(fin);
|
|
assert(0 == memcmp(buf + 1337, buf_out, 1));
|
|
|
|
/* Verify packets */
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(1 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
packet_out = lsquic_send_ctl_next_packet_to_send(&tobjs.send_ctl, 0);
|
|
assert(lsquic_packet_out_packno_bits(packet_out) == GQUIC_PACKNO_LEN_6);
|
|
assert(2 == packet_out->po_packno);
|
|
assert(packet_out->po_frame_types & (1 << QUIC_FRAME_STREAM));
|
|
lsquic_send_ctl_sent_packet(&tobjs.send_ctl, packet_out);
|
|
|
|
assert(1 == streams[0]->n_unacked);
|
|
assert(1 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 1);
|
|
assert(0 == streams[0]->n_unacked);
|
|
assert(1 == streams[1]->n_unacked);
|
|
assert(1 == streams[2]->n_unacked);
|
|
ack_packet(&tobjs.send_ctl, 2);
|
|
assert(0 == streams[0]->n_unacked);
|
|
assert(0 == streams[1]->n_unacked);
|
|
assert(0 == streams[2]->n_unacked);
|
|
|
|
lsquic_stream_destroy(streams[0]);
|
|
lsquic_stream_destroy(streams[1]);
|
|
lsquic_stream_destroy(streams[2]);
|
|
deinit_test_objs(&tobjs);
|
|
}
|
|
|
|
|
|
static void
|
|
main_test_packetization (void)
|
|
{
|
|
const unsigned fp_sizes[] = { 0, 10, 100, 501, 1290, };
|
|
unsigned i;
|
|
for (i = 0; i < sizeof(fp_sizes) / sizeof(fp_sizes[0]); ++i)
|
|
{
|
|
int once;
|
|
unsigned write_size;
|
|
if (!g_use_crypto_ctor) /* No buffered packets for CRYPTO frames */
|
|
{
|
|
for (write_size = 1; write_size < GQUIC_MAX_PACKET_SZ; ++write_size)
|
|
test_packetization(0, 0, write_size, fp_sizes[i]);
|
|
srand(7891);
|
|
for (write_size = 1; write_size < GQUIC_MAX_PACKET_SZ * 10; ++write_size)
|
|
test_packetization(0, 0, RANDOM_WRITE_SIZE, fp_sizes[i]);
|
|
}
|
|
for (once = 0; once < 2; ++once)
|
|
{
|
|
for (write_size = 1; write_size < GQUIC_MAX_PACKET_SZ; ++write_size)
|
|
test_packetization(1, once, write_size, fp_sizes[i]);
|
|
srand(7891);
|
|
for (write_size = 1; write_size < GQUIC_MAX_PACKET_SZ * 10; ++write_size)
|
|
test_packetization(1, once, RANDOM_WRITE_SIZE, fp_sizes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
int opt;
|
|
|
|
lsquic_global_init(LSQUIC_GLOBAL_SERVER);
|
|
|
|
while (-1 != (opt = getopt(argc, argv, "Ahl:")))
|
|
{
|
|
switch (opt)
|
|
{
|
|
case 'A':
|
|
stream_ctor_flags &= ~SCF_DI_AUTOSWITCH;
|
|
break;
|
|
case 'h':
|
|
stream_ctor_flags |= SCF_USE_DI_HASH;
|
|
break;
|
|
case 'l':
|
|
lsquic_log_to_fstream(stderr, 0);
|
|
lsquic_logger_lopt(optarg);
|
|
break;
|
|
default:
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
init_test_ctl_settings(&g_ctl_settings);
|
|
|
|
test_writing_to_stream_schedule_stream_packets_immediately();
|
|
test_writing_to_stream_outside_callback();
|
|
test_stealing_ack();
|
|
test_changing_pack_size();
|
|
test_reducing_pack_size();
|
|
test_window_update1();
|
|
test_window_update2();
|
|
test_forced_flush_when_conn_blocked();
|
|
test_blocked_flags();
|
|
test_reading_from_stream2();
|
|
test_overlaps();
|
|
test_insert_edge_cases();
|
|
test_unexpected_http_close();
|
|
|
|
{
|
|
int idx[6];
|
|
permute_and_run(0, 0, 0, idx, sizeof(idx) / sizeof(idx[0]));
|
|
}
|
|
|
|
test_termination();
|
|
|
|
test_writev();
|
|
|
|
test_prio_conversion();
|
|
|
|
test_read_in_middle();
|
|
|
|
test_conn_unlimited();
|
|
|
|
test_flushing();
|
|
|
|
test_conn_abort();
|
|
|
|
test_bad_packbits_guess_1();
|
|
test_bad_packbits_guess_2();
|
|
test_bad_packbits_guess_3();
|
|
|
|
test_resize_buffered();
|
|
test_resize_scheduled();
|
|
|
|
main_test_packetization();
|
|
|
|
enum lsquic_version ver;
|
|
for (ver = 0; ver < N_LSQVER; ++ver)
|
|
if (!((1 << ver) & LSQUIC_IETF_VERSIONS))
|
|
test_cant_fit_frame(select_pf_by_ver(ver));
|
|
|
|
/* Redo some tests using crypto streams and frames */
|
|
g_use_crypto_ctor = 1;
|
|
g_pf = select_pf_by_ver(LSQVER_ID27);
|
|
main_test_packetization();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const char on_being_idle[] =
|
|
"ON BEING IDLE."
|
|
""
|
|
"Now, this is a subject on which I flatter myself I really am _au fait_."
|
|
"The gentleman who, when I was young, bathed me at wisdom's font for nine"
|
|
"guineas a term--no extras--used to say he never knew a boy who could"
|
|
"do less work in more time; and I remember my poor grandmother once"
|
|
"incidentally observing, in the course of an instruction upon the use"
|
|
"of the Prayer-book, that it was highly improbable that I should ever do"
|
|
"much that I ought not to do, but that she felt convinced beyond a doubt"
|
|
"that I should leave undone pretty well everything that I ought to do."
|
|
""
|
|
"I am afraid I have somewhat belied half the dear old lady's prophecy."
|
|
"Heaven help me! I have done a good many things that I ought not to have"
|
|
"done, in spite of my laziness. But I have fully confirmed the accuracy"
|
|
"of her judgment so far as neglecting much that I ought not to have"
|
|
"neglected is concerned. Idling always has been my strong point. I take"
|
|
"no credit to myself in the matter--it is a gift. Few possess it. There"
|
|
"are plenty of lazy people and plenty of slow-coaches, but a genuine"
|
|
"idler is a rarity. He is not a man who slouches about with his hands in"
|
|
"his pockets. On the contrary, his most startling characteristic is that"
|
|
"he is always intensely busy."
|
|
""
|
|
"It is impossible to enjoy idling thoroughly unless one has plenty of"
|
|
"work to do. There is no fun in doing nothing when you have nothing to"
|
|
"do. Wasting time is merely an occupation then, and a most exhausting"
|
|
"one. Idleness, like kisses, to be sweet must be stolen."
|
|
""
|
|
"Many years ago, when I was a young man, I was taken very ill--I never"
|
|
"could see myself that much was the matter with me, except that I had"
|
|
"a beastly cold. But I suppose it was something very serious, for the"
|
|
"doctor said that I ought to have come to him a month before, and that"
|
|
"if it (whatever it was) had gone on for another week he would not have"
|
|
"answered for the consequences. It is an extraordinary thing, but I"
|
|
"never knew a doctor called into any case yet but what it transpired"
|
|
"that another day's delay would have rendered cure hopeless. Our medical"
|
|
"guide, philosopher, and friend is like the hero in a melodrama--he"
|
|
"always comes upon the scene just, and only just, in the nick of time. It"
|
|
"is Providence, that is what it is."
|
|
""
|
|
"Well, as I was saying, I was very ill and was ordered to Buxton for a"
|
|
"month, with strict injunctions to do nothing whatever all the while"
|
|
"that I was there. \"Rest is what you require,\" said the doctor, \"perfect"
|
|
"rest.\""
|
|
""
|
|
"It seemed a delightful prospect. \"This man evidently understands my"
|
|
"complaint,\" said I, and I pictured to myself a glorious time--a four"
|
|
"weeks' _dolce far niente_ with a dash of illness in it. Not too much"
|
|
"illness, but just illness enough--just sufficient to give it the flavor"
|
|
"of suffering and make it poetical. I should get up late, sip chocolate,"
|
|
"and have my breakfast in slippers and a dressing-gown. I should lie out"
|
|
"in the garden in a hammock and read sentimental novels with a melancholy"
|
|
"ending, until the books should fall from my listless hand, and I should"
|
|
"recline there, dreamily gazing into the deep blue of the firmament,"
|
|
"watching the fleecy clouds floating like white-sailed ships across"
|
|
"its depths, and listening to the joyous song of the birds and the low"
|
|
"rustling of the trees. Or, on becoming too weak to go out of doors,"
|
|
"I should sit propped up with pillows at the open window of the"
|
|
"ground-floor front, and look wasted and interesting, so that all the"
|
|
"pretty girls would sigh as they passed by."
|
|
""
|
|
"And twice a day I should go down in a Bath chair to the Colonnade to"
|
|
"drink the waters. Oh, those waters! I knew nothing about them then,"
|
|
"and was rather taken with the idea. \"Drinking the waters\" sounded"
|
|
"fashionable and Queen Anne-fied, and I thought I should like them. But,"
|
|
"ugh! after the first three or four mornings! Sam Weller's description of"
|
|
"them as \"having a taste of warm flat-irons\" conveys only a faint idea of"
|
|
"their hideous nauseousness. If anything could make a sick man get well"
|
|
"quickly, it would be the knowledge that he must drink a glassful of them"
|
|
"every day until he was recovered. I drank them neat for six consecutive"
|
|
"days, and they nearly killed me; but after then I adopted the plan of"
|
|
"taking a stiff glass of brandy-and-water immediately on the top of them,"
|
|
"and found much relief thereby. I have been informed since, by various"
|
|
"eminent medical gentlemen, that the alcohol must have entirely"
|
|
"counteracted the effects of the chalybeate properties contained in the"
|
|
"water. I am glad I was lucky enough to hit upon the right thing."
|
|
;
|
|
|
|
static void
|
|
init_buf (void *buf, size_t sz)
|
|
{
|
|
unsigned char *p = buf;
|
|
unsigned char *const end = (unsigned char*)buf + sz;
|
|
size_t n;
|
|
|
|
while (p < end)
|
|
{
|
|
n = end - p;
|
|
if (sizeof(on_being_idle) - 1 < n)
|
|
n = sizeof(on_being_idle) - 1;
|
|
memcpy(p, on_being_idle, n);
|
|
p +=n;
|
|
}
|
|
|
|
assert(p == end);
|
|
}
|