iv-org-mirror
/
litespeed-quic
mirror of https://gitea.invidious.io/iv-org/litespeed-quic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
litespeed-quic/src/liblsquic/lsquic_mini_conn.c

2269 lines
73 KiB
C
Raw Blame History

/* Copyright (c) 2017 - 2021 LiteSpeed Technologies Inc. See LICENSE. */
/*
* lsquic_mini_conn.c -- Mini connection.
*
* Mini connection is only used in server mode -- this assumption is relied
* upon by the code in this file.
*
* The purpose of this connection is to process incoming handshakes using
* minimal amount of resources until we confirm that the client is sending
* valid data. Here, we only process Stream 1 data; other packets are
* spooled, if necessary. When mini connection is promoted to full
* connection, the state, including spooled incoming packets, is transferred
* to the full connection.
*/
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>
#include <time.h>
#include "lsquic.h"
#include "lsquic_int_types.h"
#include "lsquic_hash.h"
#include "lsquic_conn.h"
#include "lsquic_rtt.h"
#include "lsquic_mini_conn.h"
#include "lsquic_mm.h"
#include "lsquic_malo.h"
#include "lsquic_packet_common.h"
#include "lsquic_packet_gquic.h"
#include "lsquic_packet_ietf.h"
#include "lsquic_packet_in.h"
#include "lsquic_packet_out.h"
#include "lsquic_util.h"
#include "lsquic_str.h"
#include "lsquic_enc_sess.h"
#include "lsquic_parse.h"
#include "lsquic_engine_public.h"
#include "lsquic_sfcw.h"
#include "lsquic_varint.h"
#include "lsquic_hq.h"
#include "lsquic_stream.h"
#include "lsquic_rechist.h"
#include "lsquic_ev_log.h"
#include "lsquic_qtags.h"
#include "lsquic_attq.h"
#include "lsquic_alarmset.h"
#define LSQUIC_LOGGER_MODULE LSQLM_MINI_CONN
#define LSQUIC_LOG_CONN_ID lsquic_conn_log_cid(&mc->mc_conn)
#include "lsquic_logger.h"
static const struct conn_iface mini_conn_iface_standard;
static const struct conn_iface mini_conn_iface_standard_Q050;
#if LSQUIC_KEEP_MINICONN_HISTORY
static void
mchist_append (struct mini_conn *mc, enum miniconn_history_event mh_event)
{
enum miniconn_history_event prev_event;
mchist_idx_t idx;
int plus;
idx = (mc->mc_hist_idx - 1) & MCHIST_MASK;
plus = MCHE_PLUS == mc->mc_hist_buf[ idx ];
idx = (idx - plus) & MCHIST_MASK;
prev_event = mc->mc_hist_buf[ idx ];
if (!(prev_event == mh_event && plus))
{
if (prev_event == mh_event)
mh_event = MCHE_PLUS;
mc->mc_hist_buf[ MCHIST_MASK & mc->mc_hist_idx++ ] = mh_event;
}
}
# define MCHIST_APPEND(mc, event) mchist_append(mc, event)
#else
# define MCHIST_APPEND(mc, event)
#endif
static void
process_deferred_packets (struct mini_conn *mc);
/* If this is not true, highest_bit_set() may be broken */
typedef char packno_set_is_unsigned_long[
sizeof(unsigned long long) == sizeof(mconn_packno_set_t) ? 1 : -1 ];
static unsigned
highest_bit_set (unsigned long long sz)
{
#if __GNUC__
unsigned clz = __builtin_clzll(sz);
return 63 - clz;
#else
unsigned long y;
unsigned n;
n = 64;
y = sz >> 32; if (y) { n -= 32; sz = y; }
y = sz >> 16; if (y) { n -= 16; sz = y; }
y = sz >> 8; if (y) { n -= 8; sz = y; }
y = sz >> 4; if (y) { n -= 4; sz = y; }
y = sz >> 2; if (y) { n -= 2; sz = y; }
y = sz >> 1; if (y) return 63 - n + 2;
return 63 - n + sz;
#endif
}
static unsigned
lowest_bit_set (unsigned v)
{
#if __GNUC__
return __builtin_ctz(v);
#else
unsigned n;
n = 0;
if (0 == (v & ((1 << 16) - 1))) { n += 16; v >>= 16; }
if (0 == (v & ((1 << 8) - 1))) { n += 8; v >>= 8; }
if (0 == (v & ((1 << 4) - 1))) { n += 4; v >>= 4; }
if (0 == (v & ((1 << 2) - 1))) { n += 2; v >>= 2; }
if (0 == (v & ((1 << 1) - 1))) { n += 1; }
return n;
#endif
}
static int
is_handshake_stream_id (const struct mini_conn *conn,
lsquic_stream_id_t stream_id)
{
return conn->mc_conn.cn_version < LSQVER_050 && stream_id == 1;
}
static void
mini_destroy_packet (struct mini_conn *mc, struct lsquic_packet_out *packet_out)
{
lsquic_packet_out_destroy(packet_out, mc->mc_enpub,
mc->mc_path.np_peer_ctx);
}
static int
packet_in_is_ok (enum lsquic_version version,
const struct lsquic_packet_in *packet_in)
{
size_t min_size;
if (packet_in->pi_data_sz > GQUIC_MAX_PACKET_SZ)
{
LSQ_LOG1(LSQ_LOG_DEBUG, "incoming packet too large: %hu bytes",
packet_in->pi_data_sz);
return 0;
}
if ((1 << version) & LSQUIC_GQUIC_HEADER_VERSIONS)
/* This is a very lax number, it allows the server to send
* 64 * 200 = 12KB of output (REJ and SHLO).
*/
min_size = 200;
else
/* Chrome enforces 1200-byte minimum initial packet limit */
min_size = IQUIC_MIN_INIT_PACKET_SZ;
if (packet_in->pi_data_sz < min_size)
{
LSQ_LOG1(LSQ_LOG_DEBUG, "incoming packet too small: %hu bytes",
packet_in->pi_data_sz);
return 0;
}
return 1;
}
lsquic_conn_t *
lsquic_mini_conn_new (struct lsquic_engine_public *enp,
const struct lsquic_packet_in *packet_in,
enum lsquic_version version)
{
struct mini_conn *mc;
const struct conn_iface *conn_iface;
if (!packet_in_is_ok(version, packet_in))
return NULL;
switch (version)
{
case LSQVER_050:
conn_iface = &mini_conn_iface_standard_Q050;
break;
default:
conn_iface = &mini_conn_iface_standard;
break;
}
mc = lsquic_malo_get(enp->enp_mm.malo.mini_conn);
if (!mc)
{
LSQ_LOG1(LSQ_LOG_WARN, "cannot allocate mini connection: %s",
strerror(errno));
return NULL;
}
memset(mc, 0, sizeof(*mc));
TAILQ_INIT(&mc->mc_deferred);
TAILQ_INIT(&mc->mc_packets_in);
TAILQ_INIT(&mc->mc_packets_out);
mc->mc_enpub = enp;
mc->mc_created = packet_in->pi_received;
mc->mc_path.np_pack_size = packet_in->pi_data_sz;
mc->mc_conn.cn_cces = mc->mc_cces;
mc->mc_conn.cn_cces_mask = 1;
mc->mc_conn.cn_n_cces = sizeof(mc->mc_cces) / sizeof(mc->mc_cces[0]);
mc->mc_conn.cn_version = version;
mc->mc_conn.cn_pf = select_pf_by_ver(version);
mc->mc_conn.cn_esf_c = select_esf_common_by_ver(version);
mc->mc_conn.cn_esf.g = select_esf_gquic_by_ver(version);
mc->mc_conn.cn_cid = packet_in->pi_conn_id;
mc->mc_conn.cn_flags = LSCONN_MINI | LSCONN_SERVER;
mc->mc_conn.cn_if = conn_iface;
LSQ_DEBUG("created mini connection object");
MCHIST_APPEND(mc, MCHE_CREATED);
return &mc->mc_conn;
}
static int
in_acked_range (const struct ack_info *acki, lsquic_packno_t n) /* This is a copy */
{
int in_range = 0;
unsigned i;
for (i = 0; i < acki->n_ranges; ++i)
in_range += acki->ranges[i].high >= n
&& acki->ranges[i].low <= n;
return in_range > 0;
}
static void
take_rtt_sample (struct mini_conn *mc, const lsquic_packet_out_t *packet_out,
lsquic_time_t now, lsquic_time_t lack_delta)
{
assert(packet_out->po_sent);
lsquic_time_t measured_rtt = now - packet_out->po_sent;
if (lack_delta < measured_rtt)
{
lsquic_rtt_stats_update(&mc->mc_rtt_stats, measured_rtt, lack_delta);
LSQ_DEBUG("srtt: %"PRIu64" usec, var: %"PRIu64,
lsquic_rtt_stats_get_srtt(&mc->mc_rtt_stats),
lsquic_rtt_stats_get_rttvar(&mc->mc_rtt_stats));
}
}
static unsigned
process_ack_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
int parsed_len;
int n_newly_acked;
unsigned n;
lsquic_packet_out_t *packet_out, *next;
struct ack_info *acki;
lsquic_packno_t packno;
lsquic_time_t warn_time;
char buf[200];
acki = mc->mc_enpub->enp_mm.acki;
parsed_len = mc->mc_conn.cn_pf->pf_parse_ack_frame(p, len, acki, 0);
if (parsed_len < 0)
return 0;
if (empty_ack_frame(acki))
{
LSQ_DEBUG("Ignore empty ACK frame");
return parsed_len;
}
if (packet_in->pi_packno <= mc->mc_max_ack_packno)
{
LSQ_DEBUG("Ignore old ack (max %u)", mc->mc_max_ack_packno);
return parsed_len;
}
if (packet_in->pi_packno <= UCHAR_MAX)
mc->mc_max_ack_packno = packet_in->pi_packno;
/* Verify ACK frame and update list of acked packet numbers: */
for (n = 0; n < acki->n_ranges; ++n)
for (packno = acki->ranges[n].low; packno <= acki->ranges[n].high;
++packno)
if (packno > MINICONN_MAX_PACKETS ||
0 == (MCONN_PACKET_MASK(packno) & mc->mc_sent_packnos))
{
warn_time = lsquic_time_now();
if (0 == mc->mc_enpub->enp_last_warning[WT_ACKPARSE_MINI]
|| mc->mc_enpub->enp_last_warning[WT_ACKPARSE_MINI]
+ WARNING_INTERVAL < warn_time)
{
mc->mc_enpub->enp_last_warning[WT_ACKPARSE_MINI]
= warn_time;
lsquic_hexdump(p, len, buf, sizeof(buf));
LSQ_WARN("packet %"PRIu64" was never sent; ACK "
"frame:\n%s", packno, buf);
}
else
LSQ_DEBUG("packet %"PRIu64" was never sent", packno);
MCHIST_APPEND(mc, MCHE_UNSENT_ACKED);
return 0;
}
else
mc->mc_acked_packnos |= MCONN_PACKET_MASK(packno);
EV_LOG_ACK_FRAME_IN(LSQUIC_LOG_CONN_ID, acki);
n_newly_acked = 0;
for (packet_out = TAILQ_FIRST(&mc->mc_packets_out); packet_out;
packet_out = next)
{
next = TAILQ_NEXT(packet_out, po_next);
if (in_acked_range(acki, packet_out->po_packno))
{
++n_newly_acked;
LSQ_DEBUG("Got ACK for packet %"PRIu64, packet_out->po_packno);
if (packet_out->po_packno == largest_acked(acki))
take_rtt_sample(mc, packet_out, packet_in->pi_received,
acki->lack_delta);
TAILQ_REMOVE(&mc->mc_packets_out, packet_out, po_next);
mini_destroy_packet(mc, packet_out);
}
}
if (n_newly_acked > 0)
mc->mc_hsk_count = 0;
return parsed_len;
}
static unsigned
process_blocked_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
lsquic_stream_id_t stream_id;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_blocked_frame(p, len, &stream_id);
if (parsed_len < 0)
return 0;
EV_LOG_BLOCKED_FRAME_IN(LSQUIC_LOG_CONN_ID, stream_id);
LSQ_DEBUG("Peer reports stream %"PRIu64" as blocked", stream_id);
return parsed_len;
}
static mconn_packno_set_t
drop_packets_out (struct mini_conn *mc)
{
struct lsquic_packet_out *packet_out;
mconn_packno_set_t in_flight = 0;
while ((packet_out = TAILQ_FIRST(&mc->mc_packets_out)))
{
TAILQ_REMOVE(&mc->mc_packets_out, packet_out, po_next);
if (packet_out->po_flags & PO_SENT)
in_flight |= MCONN_PACKET_MASK(packet_out->po_packno);
mini_destroy_packet(mc, packet_out);
}
return in_flight;
}
static unsigned
process_connection_close_frame (struct mini_conn *mc,
lsquic_packet_in_t *packet_in, const unsigned char *p, size_t len)
{
uint64_t error_code;
uint16_t reason_len;
uint8_t reason_off;
int parsed_len;
(void) drop_packets_out(mc);
parsed_len = mc->mc_conn.cn_pf->pf_parse_connect_close_frame(p, len,
NULL, &error_code, &reason_len, &reason_off);
if (parsed_len < 0)
return 0;
mc->mc_error_code = (uint64_t) error_code;
EV_LOG_CONNECTION_CLOSE_FRAME_IN(LSQUIC_LOG_CONN_ID, error_code,
(int) reason_len, (const char *) p + reason_off);
if (error_code != 25 /* No recent network activity */
&& error_code != 62 /* An active session exists for the given IP */
&& error_code != 27 ) /* Write failed with error: -142 (Unknown error)*/
{
LSQ_WARN("Received CONNECTION_CLOSE frame (code: %"PRIu64"; reason: %.*s)",
error_code, (int) reason_len, (const char *) p + reason_off);
}
MCHIST_APPEND(mc, MCHE_CONN_CLOSE);
return 0; /* This shuts down the connection */
}
static unsigned
process_goaway_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
lsquic_stream_id_t stream_id;
uint32_t error_code;
uint16_t reason_length;
const char *reason;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_goaway_frame(p, len, &error_code, &stream_id,
&reason_length, &reason);
if (parsed_len < 0)
return 0;
EV_LOG_GOAWAY_FRAME_IN(LSQUIC_LOG_CONN_ID, error_code, stream_id,
reason_length, reason);
LSQ_DEBUG("received GOAWAY frame, last good stream ID: %"PRIu64", "
"error code: 0x%X, reason: `%.*s'", stream_id, error_code,
reason_length, reason);
if (stream_id != 0) /* This is odd. We warn: */
LSQ_WARN("stream ID is %"PRIu64" in GOAWAY frame", stream_id);
mc->mc_conn.cn_flags |= LSCONN_PEER_GOING_AWAY;
return parsed_len;
}
static unsigned
process_invalid_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
LSQ_INFO("invalid frame");
MCHIST_APPEND(mc, MCHE_INVALID_FRAME);
return 0;
}
static unsigned
count_zero_bytes (const unsigned char *p, size_t len)
{
const unsigned char *const end = p + len;
while (p < end && 0 == *p)
++p;
return len - (end - p);
}
static unsigned
process_padding_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
len = (size_t) count_zero_bytes(p, len);
EV_LOG_PADDING_FRAME_IN(LSQUIC_LOG_CONN_ID, len);
return len;
}
static unsigned
process_ping_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
EV_LOG_PING_FRAME_IN(LSQUIC_LOG_CONN_ID);
return 1;
}
static unsigned
process_rst_stream_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
lsquic_stream_id_t stream_id;
uint64_t offset, error_code;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_rst_frame(p, len, &stream_id, &offset, &error_code);
if (parsed_len < 0)
return 0;
EV_LOG_RST_STREAM_FRAME_IN(LSQUIC_LOG_CONN_ID, stream_id, offset,
error_code);
LSQ_DEBUG("Got RST_STREAM; stream: %"PRIu64"; offset: 0x%"PRIX64, stream_id,
offset);
if (is_handshake_stream_id(mc, stream_id))
{
LSQ_INFO("handshake stream reset, closing connection");
return 0;
}
else
return parsed_len;
}
static unsigned
process_stop_waiting_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
lsquic_packno_t least;
enum packno_bits bits = lsquic_packet_in_packno_bits(packet_in);
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_stop_waiting_frame(p, len, packet_in->pi_packno, bits,
&least);
if (parsed_len < 0)
return 0;
EV_LOG_STOP_WAITING_FRAME_IN(LSQUIC_LOG_CONN_ID, least);
LSQ_DEBUG("Got STOP_WAITING frame, least unacked: %"PRIu64, least);
if (least > MINICONN_MAX_PACKETS)
return 0;
else
{
mc->mc_cutoff = least;
return parsed_len;
}
}
static unsigned
process_stream_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
stream_frame_t stream_frame;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_stream_frame(p, len, &stream_frame);
if (parsed_len < 0)
return 0;
EV_LOG_STREAM_FRAME_IN(LSQUIC_LOG_CONN_ID, &stream_frame);
LSQ_DEBUG("Got stream frame for stream #%"PRIu64, stream_frame.stream_id);
if (is_handshake_stream_id(mc, stream_frame.stream_id))
{
if (packet_in->pi_flags & PI_HSK_STREAM)
{ /* This is not supported for simplicity. The spec recommends
* not putting more than one stream frame from the same stream
* into a single packet. If this changes and clients actually
* do that, we can revisit this code.
*/
LSQ_INFO("two handshake stream frames in single incoming packet");
MCHIST_APPEND(mc, MCHE_2HSK_1STREAM);
return 0;
}
if (stream_frame.data_frame.df_offset >= mc->mc_read_off)
{
packet_in->pi_flags |= PI_HSK_STREAM;
packet_in->pi_hsk_stream = p - packet_in->pi_data;
mc->mc_flags |= MC_HAVE_NEW_HSK;
MCHIST_APPEND(mc, MCHE_NEW_HSK);
if (0 == stream_frame.data_frame.df_offset)
{
/* First CHLO message: update maximum packet size */
mc->mc_path.np_pack_size = packet_in->pi_data_sz;
LSQ_DEBUG("update packet size to %hu",
mc->mc_path.np_pack_size);
}
}
else
{
LSQ_DEBUG("drop duplicate frame");
MCHIST_APPEND(mc, MCHE_DUP_HSK);
}
}
return parsed_len;
}
static unsigned
process_crypto_frame (struct mini_conn *mc, struct lsquic_packet_in *packet_in,
const unsigned char *p, size_t len)
{
stream_frame_t stream_frame;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_crypto_frame(p, len,
&stream_frame);
if (parsed_len < 0)
return 0;
EV_LOG_CRYPTO_FRAME_IN(LSQUIC_LOG_CONN_ID, &stream_frame,
lsquic_packet_in_enc_level(packet_in));
LSQ_DEBUG("Got CRYPTO frame at encryption level %s",
lsquic_enclev2str[lsquic_packet_in_enc_level(packet_in)]);
if (packet_in->pi_flags & PI_HSK_STREAM)
{ /* This is not supported for simplicity: assume a single CRYPTO frame
* per packet. If this changes, we can revisit this code.
*/
LSQ_INFO("two CRYPTO frames in single incoming packet");
MCHIST_APPEND(mc, MCHE_2HSK_1STREAM);
return 0;
}
if (stream_frame.data_frame.df_offset >= mc->mc_read_off)
{
packet_in->pi_flags |= PI_HSK_STREAM;
packet_in->pi_hsk_stream = p - packet_in->pi_data;
mc->mc_flags |= MC_HAVE_NEW_HSK;
MCHIST_APPEND(mc, MCHE_NEW_HSK);
if (0 == stream_frame.data_frame.df_offset)
{
/* First CHLO message: update maximum packet size */
mc->mc_path.np_pack_size = packet_in->pi_data_sz
/* Q050 and later adjust pi_data_sz of Initial packets during
* decryption, here we have to add the tag length back:
*/
+ mc->mc_conn.cn_esf_c->esf_tag_len;
LSQ_DEBUG("update packet size to %hu", mc->mc_path.np_pack_size);
}
}
else
{
LSQ_DEBUG("drop duplicate frame");
MCHIST_APPEND(mc, MCHE_DUP_HSK);
}
return parsed_len;
}
static unsigned
process_window_update_frame (struct mini_conn *mc,
lsquic_packet_in_t *packet_in, const unsigned char *p, size_t len)
{
lsquic_stream_id_t stream_id;
uint64_t offset;
int parsed_len;
parsed_len = mc->mc_conn.cn_pf->pf_parse_window_update_frame(p, len, &stream_id, &offset);
if (parsed_len < 0)
return 0;
EV_LOG_WINDOW_UPDATE_FRAME_IN(LSQUIC_LOG_CONN_ID, stream_id, offset);
if (is_handshake_stream_id(mc, stream_id))
/* This should not happen: why would the client send us WINDOW_UPDATE
* on stream 1?
*/
LSQ_WARN("client sent WINDOW_UPDATE for handshake stream, "
"offset %"PRIu64, offset);
return parsed_len;
}
typedef unsigned (*process_frame_f)(
struct mini_conn *, lsquic_packet_in_t *, const unsigned char *p, size_t);
static process_frame_f const process_frames[N_QUIC_FRAMES] =
{
[QUIC_FRAME_ACK] = process_ack_frame,
[QUIC_FRAME_BLOCKED] = process_blocked_frame,
[QUIC_FRAME_CONNECTION_CLOSE] = process_connection_close_frame,
[QUIC_FRAME_CRYPTO] = process_crypto_frame,
[QUIC_FRAME_GOAWAY] = process_goaway_frame,
[QUIC_FRAME_INVALID] = process_invalid_frame,
[QUIC_FRAME_PADDING] = process_padding_frame,
[QUIC_FRAME_PING] = process_ping_frame,
[QUIC_FRAME_RST_STREAM] = process_rst_stream_frame,
[QUIC_FRAME_STOP_WAITING] = process_stop_waiting_frame,
[QUIC_FRAME_STREAM] = process_stream_frame,
[QUIC_FRAME_WINDOW_UPDATE] = process_window_update_frame,
};
static unsigned
process_packet_frame (struct mini_conn *mc, lsquic_packet_in_t *packet_in,
const unsigned char *p, size_t len)
{
enum quic_frame_type type = mc->mc_conn.cn_pf->pf_parse_frame_type(p, len);
packet_in->pi_frame_types |= 1 << type;
return process_frames[type](mc, packet_in, p, len);
}
static void
record_largest_recv (struct mini_conn *mc, lsquic_time_t t)
{
if (t < mc->mc_created)
{
LSQ_WARN("largest received predates creation");
return;
}
t -= mc->mc_created;
mc->mc_largest_recv[0] = t;
mc->mc_largest_recv[1] = t >> 8;
mc->mc_largest_recv[2] = t >> 16;
LSQ_DEBUG("recorded largest received timestamp as %"PRIu64" usec since "
"creation", t);
}
static enum dec_packin
conn_decrypt_packet (struct mini_conn *conn, lsquic_packet_in_t *packet_in)
{
return conn->mc_conn.cn_esf_c->esf_decrypt_packet(
conn->mc_conn.cn_enc_session, conn->mc_enpub,
&conn->mc_conn, packet_in);
}
/* PRP: Process Regular Packet */
enum proc_rp { PRP_KEEP, PRP_DEFER, PRP_DROP, PRP_ERROR, };
static enum proc_rp
conn_decrypt_packet_or (struct mini_conn *mc,
struct lsquic_packet_in *packet_in)
{
if (DECPI_OK == conn_decrypt_packet(mc, packet_in))
{
MCHIST_APPEND(mc, MCHE_DECRYPTED);
return PRP_KEEP;
}
else if (mc->mc_conn.cn_esf.g->esf_have_key_gt_one(
mc->mc_conn.cn_enc_session))
{
LSQ_INFO("could not decrypt packet: drop");
mc->mc_dropped_packnos |= MCONN_PACKET_MASK(packet_in->pi_packno);
MCHIST_APPEND(mc, MCHE_UNDECR_DROP);
return PRP_DROP;
}
else if ((packet_in->pi_flags & PI_OWN_DATA) ||
0 == lsquic_conn_copy_and_release_pi_data(&mc->mc_conn,
mc->mc_enpub, packet_in))
{
assert(packet_in->pi_flags & PI_OWN_DATA);
LSQ_INFO("could not decrypt packet: defer");
mc->mc_deferred_packnos |= MCONN_PACKET_MASK(packet_in->pi_packno);
MCHIST_APPEND(mc, MCHE_UNDECR_DEFER);
return PRP_DEFER;
}
else
{
MCHIST_APPEND(mc, MCHE_ENOMEM);
return PRP_ERROR; /* Memory allocation must have failed */
}
}
static enum proc_rp
process_regular_packet (struct mini_conn *mc, lsquic_packet_in_t *packet_in)
{
const unsigned char *p, *pend;
enum proc_rp prp;
unsigned len;
/* Decrypt packet if necessary */
if (0 == (packet_in->pi_flags & PI_DECRYPTED))
{
prp = conn_decrypt_packet_or(mc, packet_in);
if (prp != PRP_KEEP)
return prp;
}
/* Update receive history before processing the packet: if there is an
* error, the connection is terminated and recording this packet number
* is helpful when it is printed along with other diagnostics in dtor.
*/
if (0 == mc->mc_received_packnos ||
packet_in->pi_packno > highest_bit_set(mc->mc_received_packnos) + 1)
record_largest_recv(mc, packet_in->pi_received);
mc->mc_received_packnos |= MCONN_PACKET_MASK(packet_in->pi_packno);
/* Parse and process frames */
p = packet_in->pi_data + packet_in->pi_header_sz;
pend = packet_in->pi_data + packet_in->pi_data_sz;
while (p < pend)
{
len = process_packet_frame(mc, packet_in, p, pend - p);
if (len > 0)
p += len;
else
{
if (mc->mc_conn.cn_pf->pf_parse_frame_type(p, pend - p) !=
QUIC_FRAME_CONNECTION_CLOSE)
LSQ_WARN("error parsing frame: packno %"PRIu64"; sz: %u; type: "
"0x%X", packet_in->pi_packno, packet_in->pi_data_sz, p[0]);
MCHIST_APPEND(mc, MCHE_EFRAME);
return PRP_ERROR;
}
}
mc->mc_flags |= MC_GEN_ACK;
return PRP_KEEP;
}
struct hsk_chunk
{
lsquic_packet_in_t *hsk_packet_in;
const unsigned char *hsk_data;
unsigned hsk_off;
unsigned hsk_sz;
};
static int
compare_hsk_chunks (const void *ap, const void *bp)
{
const struct hsk_chunk *a = ap;
const struct hsk_chunk *b = bp;
return (a->hsk_off > b->hsk_off) - (b->hsk_off > a->hsk_off);
}
struct mini_stream_ctx
{
const unsigned char *buf;
size_t bufsz;
size_t off;
};
static int
mini_stream_has_data (const struct mini_stream_ctx *ms_ctx)
{
return ms_ctx->off < ms_ctx->bufsz;
}
static size_t
mini_stream_read (void *stream, void *buf, size_t len, int *reached_fin)
{
struct mini_stream_ctx *ms_ctx = stream;
size_t avail = ms_ctx->bufsz - ms_ctx->off;
if (avail < len)
len = avail;
memcpy(buf, ms_ctx->buf + ms_ctx->off, len);
ms_ctx->off += len;
*reached_fin = 0;
return len;
}
/* Wrapper to throw out reached_fin */
static size_t
mini_stream_read_for_crypto (void *stream, void *buf, size_t len, int *fin)
{
size_t retval;
int reached_fin;
retval = mini_stream_read(stream, buf, len, &reached_fin);
return retval;
}
static size_t
mini_stream_size (void *stream)
{
struct mini_stream_ctx *ms_ctx = stream;
size_t avail = ms_ctx->bufsz - ms_ctx->off;
return avail;
}
static int
mini_stream_fin (void *stream)
{ /* There is never a FIN on the handshake stream */
return 0;
}
static lsquic_packno_t
next_packno (struct mini_conn *mc)
{
if (mc->mc_cur_packno < MINICONN_MAX_PACKETS)
{
return ++mc->mc_cur_packno;
}
else
{
if (!(mc->mc_flags & MC_OO_PACKNOS))
{
MCHIST_APPEND(mc, MCHE_OUT_OF_PACKNOS);
mc->mc_flags |= MC_OO_PACKNOS;
LSQ_DEBUG("ran out of outgoing packet numbers");
}
return MINICONN_MAX_PACKETS + 1;
}
}
static lsquic_packet_out_t *
allocate_packet_out (struct mini_conn *mc, const unsigned char *nonce)
{
lsquic_packet_out_t *packet_out;
lsquic_packno_t packno;
packno = next_packno(mc);
if (packno > MINICONN_MAX_PACKETS)
{
LSQ_DEBUG("ran out of outgoing packet numbers, won't allocate packet");
return NULL;
}
packet_out = lsquic_packet_out_new(&mc->mc_enpub->enp_mm, NULL, 1,
&mc->mc_conn, GQUIC_PACKNO_LEN_1, NULL, nonce, &mc->mc_path,
HETY_NOT_SET);
if (!packet_out)
{
LSQ_WARN("could not allocate packet: %s", strerror(errno));
return NULL;
}
packet_out->po_loss_chain = packet_out;
packet_out->po_packno = packno;
packet_out->po_flags |= PO_MINI;
if (mc->mc_flags & MC_HAVE_SHLO)
{
packet_out->po_flags |= PO_HELLO;
packet_out->po_header_type = HETY_0RTT;
}
if (mc->mc_conn.cn_version >= LSQVER_050)
{
if (nonce)
packet_out->po_header_type = HETY_0RTT;
else
packet_out->po_header_type = HETY_INITIAL;
}
lsquic_packet_out_set_pns(packet_out, PNS_APP);
TAILQ_INSERT_TAIL(&mc->mc_packets_out, packet_out, po_next);
LSQ_DEBUG("allocated packet #%"PRIu64", nonce: %d", packno, !!nonce);
MCHIST_APPEND(mc, MCHE_NEW_PACKET_OUT);
EV_LOG_PACKET_CREATED(LSQUIC_LOG_CONN_ID, packet_out);
return packet_out;
}
static struct lsquic_packet_out *
to_packet_pre_Q050 (struct mini_conn *mc, struct mini_stream_ctx *ms_ctx,
const unsigned char *nonce)
{
struct lsquic_packet_out *packet_out;
size_t cur_off;
int len;
packet_out = allocate_packet_out(mc, nonce);
if (!packet_out)
return NULL;
cur_off = ms_ctx->off;
len = mc->mc_conn.cn_pf->pf_gen_stream_frame(
packet_out->po_data + packet_out->po_data_sz,
lsquic_packet_out_avail(packet_out),
1, mc->mc_write_off, mini_stream_fin(ms_ctx),
mini_stream_size(ms_ctx), mini_stream_read, ms_ctx);
if (len < 0)
{
LSQ_WARN("cannot generate STREAM frame (avail: %u)",
lsquic_packet_out_avail(packet_out));
return NULL;
}
mc->mc_write_off += ms_ctx->off - cur_off;
EV_LOG_GENERATED_STREAM_FRAME(LSQUIC_LOG_CONN_ID, mc->mc_conn.cn_pf,
packet_out->po_data + packet_out->po_data_sz, len);
packet_out->po_data_sz += len;
packet_out->po_frame_types |= 1 << QUIC_FRAME_STREAM;
if (0 == lsquic_packet_out_avail(packet_out))
packet_out->po_flags |= PO_STREAM_END;
return packet_out;
}
static struct lsquic_packet_out *
to_packet_Q050plus (struct mini_conn *mc, struct mini_stream_ctx *ms_ctx,
const unsigned char *nonce)
{
struct lsquic_packet_out *packet_out;
size_t cur_off;
int len;
if (nonce && !(mc->mc_flags & MC_WR_OFF_RESET))
{
mc->mc_write_off = 0;
mc->mc_flags |= MC_WR_OFF_RESET;
}
packet_out = allocate_packet_out(mc, nonce);
if (!packet_out)
return NULL;
cur_off = ms_ctx->off;
len = mc->mc_conn.cn_pf->pf_gen_crypto_frame(
packet_out->po_data + packet_out->po_data_sz,
lsquic_packet_out_avail(packet_out), 0, mc->mc_write_off, 0,
mini_stream_size(ms_ctx), mini_stream_read_for_crypto, ms_ctx);
if (len < 0)
{
LSQ_WARN("cannot generate CRYPTO frame (avail: %u)",
lsquic_packet_out_avail(packet_out));
return NULL;
}
mc->mc_write_off += ms_ctx->off - cur_off;
EV_LOG_GENERATED_CRYPTO_FRAME(LSQUIC_LOG_CONN_ID, mc->mc_conn.cn_pf,
packet_out->po_data + packet_out->po_data_sz, len);
packet_out->po_data_sz += len;
packet_out->po_frame_types |= 1 << QUIC_FRAME_CRYPTO;
return packet_out;
}
static int
packetize_response (struct mini_conn *mc, const unsigned char *buf,
size_t bufsz, const unsigned char *nonce)
{
struct mini_stream_ctx ms_ctx;
lsquic_packet_out_t *packet_out;
struct lsquic_packet_out * (*const to_packet) (struct mini_conn *,
struct mini_stream_ctx *, const unsigned char *)
= mc->mc_conn.cn_version < LSQVER_050
? to_packet_pre_Q050 : to_packet_Q050plus;
LSQ_DEBUG("Packetizing %zd bytes of handshake response", bufsz);
ms_ctx.buf = buf;
ms_ctx.bufsz = bufsz;
ms_ctx.off = 0;
do
{
packet_out = to_packet(mc, &ms_ctx, nonce);
if (!packet_out)
return -1;
}
while (mini_stream_has_data(&ms_ctx));
/* PAD the last packet with NULs. ACK and STOP_WAITING go into a separate
* packet.
*/
if (lsquic_packet_out_avail(packet_out))
{
EV_LOG_CONN_EVENT(LSQUIC_LOG_CONN_ID, "generated PADDING frame %u "
"bytes long", lsquic_packet_out_avail(packet_out));
memset(packet_out->po_data + packet_out->po_data_sz, 0,
lsquic_packet_out_avail(packet_out));
packet_out->po_data_sz += lsquic_packet_out_avail(packet_out);
packet_out->po_frame_types |= 1 << QUIC_FRAME_PADDING;
}
return 0;
}
static int
continue_handshake (struct mini_conn *mc)
{
lsquic_packet_in_t *packet_in;
unsigned n_hsk_chunks = 0, n_contig, n, bufsz, off;
int s, rv;
size_t out_len;
enum handshake_error he;
unsigned char *buf_in_16k, *buf_out;
const unsigned char *buf_in;
time_t t;
stream_frame_t frame;
struct hsk_chunk hsk_chunks[MINICONN_MAX_PACKETS], *hsk_chunk;
unsigned char nonce_buf[32];
int nonce_set = 0;
int (*parse_frame)(const unsigned char *, size_t, struct stream_frame *)
= mc->mc_conn.cn_version < LSQVER_050
? mc->mc_conn.cn_pf->pf_parse_stream_frame
: mc->mc_conn.cn_pf->pf_parse_crypto_frame;
/* Get handshake stream data from each packet that contains a handshake
* stream frame and place them into `hsk_chunks' array.
*/
TAILQ_FOREACH(packet_in, &mc->mc_packets_in, pi_next)
{
assert(n_hsk_chunks < sizeof(hsk_chunks) / sizeof(hsk_chunks[0]));
if (0 == (packet_in->pi_flags & PI_HSK_STREAM))
continue;
s = parse_frame(packet_in->pi_data + packet_in->pi_hsk_stream,
packet_in->pi_data_sz - packet_in->pi_hsk_stream, &frame);
if (-1 == s)
{
LSQ_WARN("cannot process hsk stream frame in packet %"PRIu64,
packet_in->pi_packno);
return -1;
}
hsk_chunk = &hsk_chunks[ n_hsk_chunks++ ];
hsk_chunk->hsk_packet_in = packet_in;
hsk_chunk->hsk_data = frame.data_frame.df_data;
hsk_chunk->hsk_off = frame.data_frame.df_offset;
hsk_chunk->hsk_sz = frame.data_frame.df_size;
}
assert(n_hsk_chunks > 0);
if (n_hsk_chunks > 1)
{
/* Sort handshake stream data */
qsort(hsk_chunks, n_hsk_chunks, sizeof(hsk_chunks[0]),
compare_hsk_chunks);
/* Figure out how many packets contain handshake stream data in a
* contiguous buffer and how large this data is.
*/
for (n = 1, n_contig = 1, bufsz = hsk_chunks[0].hsk_sz;
n < n_hsk_chunks; ++n)
if (hsk_chunks[n - 1].hsk_off + hsk_chunks[n - 1].hsk_sz ==
hsk_chunks[n].hsk_off)
{
++n_contig;
bufsz += hsk_chunks[n].hsk_sz;
}
else
break;
}
else
{
n_contig = 1;
bufsz = hsk_chunks[0].hsk_sz;
}
/* Handshake handler expects to start reading at a particular offset.
*/
if (hsk_chunks[0].hsk_off != mc->mc_read_off)
{
LSQ_DEBUG("smallest hsk offset is %u, need %hu",
hsk_chunks[0].hsk_off, mc->mc_read_off);
MCHIST_APPEND(mc, MCHE_HELLO_HOLE);
return 0;
}
LSQ_DEBUG("# of contiguous stream frames: %u out of %u; offset: %u; "
"total size: %u", n_contig, n_hsk_chunks, hsk_chunks[0].hsk_off, bufsz);
if (bufsz > 16 * 1024)
{
LSQ_INFO("too much contiguous handshake data (%u bytes); max: %u",
bufsz, 16 * 1024);
MCHIST_APPEND(mc, MCHE_HELLO_TOO_MUCH);
return -1;
}
/* From here on, since we need to clean up, we use `rv' and `goto end'
* to handle error conditions and cleanup.
*/
rv = -1;
if (n_contig > 1)
{
buf_in = buf_in_16k = lsquic_mm_get_16k(&mc->mc_enpub->enp_mm);
if (!buf_in)
{
LSQ_WARN("could not allocate in buffer: %s", strerror(errno));
buf_out = NULL;
goto end;
}
/* Create a single contiguous buffer to pass to lsquic_enc_session_handle_chlo */
off = 0;
for (n = 0; n < n_contig; ++n)
{
memcpy(buf_in_16k + off, hsk_chunks[n].hsk_data,
hsk_chunks[n].hsk_sz);
off += hsk_chunks[n].hsk_sz;
}
assert(off == bufsz);
}
else
{
buf_in_16k = NULL;
buf_in = hsk_chunks[0].hsk_data;
}
buf_out = lsquic_mm_get_16k(&mc->mc_enpub->enp_mm);
if (!buf_out)
{
LSQ_WARN("could not allocate out buffer: %s", strerror(errno));
goto end;
}
out_len = 16 * 1024;
/* Allocate enc_session for the server if first time around: */
if (!mc->mc_conn.cn_enc_session)
{
mc->mc_conn.cn_enc_session =
mc->mc_conn.cn_esf.g->esf_create_server(&mc->mc_conn,
mc->mc_conn.cn_cid, mc->mc_enpub);
if (!mc->mc_conn.cn_enc_session)
{
LSQ_WARN("cannot create new enc session");
goto end;
}
MCHIST_APPEND(mc, MCHE_NEW_ENC_SESS);
}
t = time(NULL);
he = mc->mc_conn.cn_esf.g->esf_handle_chlo(mc->mc_conn.cn_enc_session,
mc->mc_conn.cn_version,
buf_in, bufsz, t, NP_PEER_SA(&mc->mc_path),
NP_LOCAL_SA(&mc->mc_path),
buf_out, &out_len, nonce_buf, &nonce_set);
if (HS_SHLO == he)
mc->mc_flags |= MC_HAVE_SHLO;
else
mc->mc_flags &= ~MC_HAVE_SHLO;
MCHIST_APPEND(mc, he == DATA_NOT_ENOUGH ? MCHE_HANDLE_NOT_ENOUGH :
he == HS_SHLO ? MCHE_HANDLE_SHLO :
he == HS_1RTT ? MCHE_HANDLE_1RTT :
he == HS_SREJ ? MCHE_HANDLE_SREJ :
he == HS_ERROR ? MCHE_HANDLE_ERROR :
MCHE_HAHDLE_UNKNOWN);
if ((HS_SHLO == he || HS_1RTT == he) && !mc->mc_rtt_stats.srtt)
{
uint32_t irtt;
if (0 == mc->mc_conn.cn_esf.g->esf_get_peer_setting(
mc->mc_conn.cn_enc_session, QTAG_IRTT, &irtt))
{
/* Do not allow the client to specify unreasonable values:
* smaller than 10ms or larger than 15s. Per reference
* implementation.
*/
if (irtt > 15 * 1000 * 1000)
irtt = 15 * 1000 * 1000;
else if (irtt < 10 * 1000)
irtt = 10 * 1000;
lsquic_rtt_stats_update(&mc->mc_rtt_stats, irtt, 0);
LSQ_DEBUG("Set initial SRTT to %"PRIu32" usec based on client-"
"supplied IRTT value", irtt);
}
}
switch (he)
{
case DATA_NOT_ENOUGH:
LSQ_DEBUG("lsquic_enc_session_handle_chlo needs more data");
break;
case HS_SHLO:
mc->mc_conn.cn_flags |= LSCONN_HANDSHAKE_DONE;
mc->mc_flags |= MC_PROMOTE;
LSQ_DEBUG("lsquic_enc_session_handle_chlo returned %d, promote", he);
/* Fall through */
case HS_1RTT:
assert(out_len > 0);
if (mc->mc_conn.cn_version < LSQVER_046
&& !mc->mc_conn.cn_esf.g->esf_get_peer_option(
mc->mc_conn.cn_enc_session, QTAG_NSTP))
mc->mc_flags |= MC_STOP_WAIT_ON;
if (0 != packetize_response(mc, buf_out, out_len,
nonce_set ? nonce_buf : NULL))
goto end;
mc->mc_read_off += bufsz;
for (n = 0; n < n_contig; ++n)
hsk_chunks[n].hsk_packet_in->pi_flags &= ~PI_HSK_STREAM;
LSQ_DEBUG("read offset is now %hu", mc->mc_read_off);
break;
default:
LSQ_WARN("unexpected return value from lsquic_enc_session_handle_chlo: %u", he);
/* fallthru */
case HS_ERROR:
#if !LSQUIC_KEEP_ENC_SESS_HISTORY
mc->mc_conn.cn_esf.g->esf_destroy(mc->mc_conn.cn_enc_session);
mc->mc_conn.cn_enc_session = NULL;
#endif
mc->mc_flags |= MC_HSK_ERR;
LSQ_INFO("lsquic_enc_session_handle_chlo returned an error (%d)", he);
goto end;
}
rv = 0;
end:
mc->mc_flags &= ~MC_HAVE_SHLO;
if (buf_in_16k)
lsquic_mm_put_16k(&mc->mc_enpub->enp_mm, buf_in_16k);
if (buf_out)
lsquic_mm_put_16k(&mc->mc_enpub->enp_mm, buf_out);
return rv;
}
struct mini_rechist
{
const struct mini_conn *mc;
mconn_packno_set_t cur_set;
int cur_idx;
struct lsquic_packno_range range; /* We return a pointer to this */
};
static void
mini_rechist_init (struct mini_rechist *rechist, const struct mini_conn *mc)
{
rechist->mc = mc;
rechist->cur_set = 0;
rechist->cur_idx = 0;
}
static lsquic_time_t
mini_rechist_largest_recv (void *rechist_ctx)
{
struct mini_rechist *rechist = rechist_ctx;
const struct mini_conn *mc = rechist->mc;
lsquic_time_t delta = mc->mc_largest_recv[0]
+ (mc->mc_largest_recv[1] << 8)
+ (mc->mc_largest_recv[2] << 16);
LSQ_DEBUG("%s: largest received: %"PRIu64" usec since creation",
__func__, delta);
return mc->mc_created + delta;
}
static const struct lsquic_packno_range *
mini_rechist_next (void *rechist_ctx)
{
struct mini_rechist *rechist = rechist_ctx;
const struct mini_conn *mc = rechist->mc;
mconn_packno_set_t packnos;
int i;
packnos = rechist->cur_set;
if (0 == packnos)
return NULL;
/* There may be a faster way to do this, but for now, we just want
* correctness.
*/
for (i = rechist->cur_idx; i >= 0; --i)
if (packnos & (1ULL << i))
{
rechist->range.low = i + 1;
rechist->range.high = i + 1;
break;
}
assert(i >= 0); /* We must have hit at least one bit */
--i;
for ( ; i >= 0 && (packnos & (1ULL << i)); --i)
rechist->range.low = i + 1;
if (i >= 0)
{
rechist->cur_set = packnos & ((1ULL << i) - 1);
rechist->cur_idx = i;
}
else
rechist->cur_set = 0;
LSQ_DEBUG("%s: return [%"PRIu64", %"PRIu64"]", __func__,
rechist->range.low, rechist->range.high);
return &rechist->range;
}
static const struct lsquic_packno_range *
mini_rechist_first (void *rechist_ctx)
{
struct mini_rechist *rechist = rechist_ctx;
rechist->cur_set = rechist->mc->mc_received_packnos;
rechist->cur_idx = highest_bit_set(rechist->cur_set);
return mini_rechist_next(rechist_ctx);
}
static lsquic_packno_t
least_unacked (const struct mini_conn *mc)
{
mconn_packno_set_t unacked;
lsquic_packno_t packno;
unacked = mc->mc_sent_packnos & ~mc->mc_acked_packnos;
if (unacked)
packno = lowest_bit_set(unacked) + 1;
else
packno = highest_bit_set(mc->mc_sent_packnos) + 2;
LSQ_DEBUG("%s: least unacked: %"PRIu64, __func__, packno);
return packno;
}
static int
generate_ack_and_stop_waiting (struct mini_conn *mc, lsquic_time_t now)
{
lsquic_packet_out_t *packet_out;
struct mini_rechist rechist;
int len, not_used_has_missing;
lsquic_packno_t lunack;
/* Chrome's quic_server places ACK and STOP_WAITING frames into a separate
* packet.
*/
packet_out = allocate_packet_out(mc, NULL);
if (!packet_out)
return -1;
/* Generate ACK frame */
mini_rechist_init(&rechist, mc);
len = mc->mc_conn.cn_pf->pf_gen_ack_frame(packet_out->po_data + packet_out->po_data_sz,
lsquic_packet_out_avail(packet_out), mini_rechist_first,
mini_rechist_next, mini_rechist_largest_recv, &rechist,
now, &not_used_has_missing, &packet_out->po_ack2ed, NULL);
if (len < 0)
{
LSQ_WARN("could not generate ACK frame");
return -1;
}
EV_LOG_GENERATED_ACK_FRAME(LSQUIC_LOG_CONN_ID, mc->mc_conn.cn_pf,
packet_out->po_data + packet_out->po_data_sz, len);
packet_out->po_frame_types |= 1 << QUIC_FRAME_ACK;
packet_out->po_data_sz += len;
packet_out->po_regen_sz += len;
LSQ_DEBUG("wrote ACK frame of size %d", len);
/* Generate STOP_WAITING frame */
if ((mc->mc_flags & MC_STOP_WAIT_ON) && mc->mc_sent_packnos)
{
lunack = least_unacked(mc);
len = mc->mc_conn.cn_pf->pf_gen_stop_waiting_frame(packet_out->po_data +
packet_out->po_data_sz,
lsquic_packet_out_avail(packet_out), packet_out->po_packno,
lsquic_packet_out_packno_bits(packet_out), lunack);
if (len < 0)
{
LSQ_WARN("could not generate STOP_WAITING frame");
return -1;
}
packet_out->po_data_sz += len;
packet_out->po_regen_sz += len;
packet_out->po_frame_types |= 1 << QUIC_FRAME_STOP_WAITING;
LSQ_DEBUG("wrote STOP_WAITING frame of size %d", len);
EV_LOG_GENERATED_STOP_WAITING_FRAME(LSQUIC_LOG_CONN_ID, lunack);
}
else if (mc->mc_flags & MC_STOP_WAIT_ON)
LSQ_DEBUG("nothing sent: no need to generate STOP_WAITING frame");
mc->mc_flags |= MC_UNSENT_ACK;
return 0;
}
static int
calc_retx_timeout (const struct mini_conn *mc)
{
lsquic_time_t to;
to = lsquic_rtt_stats_get_srtt(&mc->mc_rtt_stats);
if (to)
{
to += to / 2;
if (to < 10000)
to = 10000;
}
else
to = 300000;
return to << mc->mc_hsk_count;
}
static void
return_enc_data (struct mini_conn *mc, struct lsquic_packet_out *packet_out)
{
mc->mc_enpub->enp_pmi->pmi_return(mc->mc_enpub->enp_pmi_ctx,
mc->mc_path.np_peer_ctx, packet_out->po_enc_data,
lsquic_packet_out_ipv6(packet_out));
packet_out->po_flags &= ~PO_ENCRYPTED;
packet_out->po_enc_data = NULL;
}
static int
repackage_packet (struct mini_conn *mc, lsquic_packet_out_t *packet_out)
{
const lsquic_packno_t oldno = packet_out->po_packno;
const lsquic_packno_t packno = next_packno(mc);
if (packno > MINICONN_MAX_PACKETS)
return -1;
LSQ_DEBUG("Packet %"PRIu64" repackaged for resending as packet %"PRIu64,
oldno, packno);
EV_LOG_CONN_EVENT(LSQUIC_LOG_CONN_ID, "packet %"PRIu64" repackaged for "
"resending as packet %"PRIu64, oldno, packno);
packet_out->po_packno = packno;
packet_out->po_flags &= ~PO_SENT;
if (packet_out->po_flags & PO_ENCRYPTED)
return_enc_data(mc, packet_out);
TAILQ_INSERT_TAIL(&mc->mc_packets_out, packet_out, po_next);
return 0;
}
static int
handle_losses_and_have_unsent (struct mini_conn *mc, lsquic_time_t now)
{
TAILQ_HEAD(, lsquic_packet_out) lost_packets =
TAILQ_HEAD_INITIALIZER(lost_packets);
lsquic_packet_out_t *packet_out, *next;
lsquic_time_t retx_to = 0;
unsigned n_to_send = 0;
for (packet_out = TAILQ_FIRST(&mc->mc_packets_out); packet_out;
packet_out = next)
{
next = TAILQ_NEXT(packet_out, po_next);
if (packet_out->po_flags & PO_SENT)
{
if (0 == retx_to)
retx_to = calc_retx_timeout(mc);
if (packet_out->po_sent + retx_to < now)
{
LSQ_DEBUG("packet %"PRIu64" has been lost (rto: %"PRIu64")",
packet_out->po_packno, retx_to);
TAILQ_REMOVE(&mc->mc_packets_out, packet_out, po_next);
TAILQ_INSERT_TAIL(&lost_packets, packet_out, po_next);
mc->mc_lost_packnos |= MCONN_PACKET_MASK(packet_out->po_packno);
MCHIST_APPEND(mc, MCHE_PACKET_LOST);
}
}
else
++n_to_send;
}
mc->mc_hsk_count += !TAILQ_EMPTY(&lost_packets);
while ((packet_out = TAILQ_FIRST(&lost_packets)))
{
TAILQ_REMOVE(&lost_packets, packet_out, po_next);
if ((packet_out->po_frame_types & GQUIC_FRAME_RETRANSMITTABLE_MASK)
&& 0 == repackage_packet(mc, packet_out))
++n_to_send;
else
mini_destroy_packet(mc, packet_out);
}
return n_to_send > 0;
}
static int
warning_is_warranted (const struct mini_conn *mc)
{
return (mc->mc_flags & (MC_HSK_ERR|MC_OO_PACKNOS))
|| 0x1C /* QUIC_HANDSHAKE_FAILED */ == mc->mc_error_code
|| 0x1D /* QUIC_CRYPTO_TAGS_OUT_OF_ORDER */ == mc->mc_error_code
|| 0x1E /* QUIC_CRYPTO_TOO_MANY_ENTRIES */ == mc->mc_error_code
|| 0x1F /* QUIC_CRYPTO_INVALID_VALUE_LENGTH */ == mc->mc_error_code
|| 0x21 /* QUIC_INVALID_CRYPTO_MESSAGE_TYPE */ == mc->mc_error_code
|| 0x22 /* QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER */ == mc->mc_error_code
|| 0x23 /* QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND */ == mc->mc_error_code
|| 0x24 /* QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP */ == mc->mc_error_code
|| 0x29 /* QUIC_CRYPTO_TOO_MANY_REJECTS */ == mc->mc_error_code
|| 0x2A /* QUIC_PROOF_INVALID */ == mc->mc_error_code
|| 0x2B /* QUIC_CRYPTO_DUPLICATE_TAG */ == mc->mc_error_code
|| 0x2C /* QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT */ == mc->mc_error_code
|| 0x2D /* QUIC_CRYPTO_SERVER_CONFIG_EXPIRED */ == mc->mc_error_code
|| 0x35 /* QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED */ == mc->mc_error_code
;
}
#if LSQUIC_KEEP_ENC_SESS_HISTORY
static void
maybe_log_enc_sess_history (const struct mini_conn *mc)
{
char eshist[ESHIST_STR_SIZE];
enum lsq_log_level log_level;
const char *ua;
if (warning_is_warranted(mc))
log_level = LSQ_LOG_WARN;
else
log_level = LSQ_LOG_DEBUG;
if (mc->mc_conn.cn_enc_session)
{
mc->mc_conn.cn_esf.g->esf_get_hist(mc->mc_conn.cn_enc_session, eshist);
ua = mc->mc_conn.cn_esf.g->esf_get_ua(mc->mc_conn.cn_enc_session);
LSQ_LOG1(log_level, "enc hist %s; User-Agent: %s", eshist,
ua ? ua : "<not set>");
}
else
LSQ_LOG1(log_level, "enc session gone: no history to log");
}
#endif
static int
have_packets_to_send (struct mini_conn *mc, lsquic_time_t now)
{
return handle_losses_and_have_unsent(mc, now);
}
static enum tick_st
mini_conn_ci_tick (struct lsquic_conn *lconn, lsquic_time_t now)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
enum tick_st tick;
++mc->mc_n_ticks;
if (mc->mc_created + mc->mc_enpub->enp_settings.es_handshake_to < now)
{
LSQ_DEBUG("connection expired: closing");
tick = TICK_CLOSE;
goto end;
}
if (mc->mc_flags & MC_ERROR)
{
tick = TICK_CLOSE;
goto end;
}
if ((mc->mc_flags & (MC_UNSENT_ACK|MC_GEN_ACK)) == MC_GEN_ACK)
{
if (0 != generate_ack_and_stop_waiting(mc, now))
{
mc->mc_flags |= MC_ERROR;
tick = TICK_CLOSE;
goto end;
}
else
mc->mc_flags &= ~MC_GEN_ACK;
}
if (have_packets_to_send(mc, now))
tick = TICK_SEND;
else
tick = TICK_QUIET;
if (mc->mc_flags & MC_PROMOTE)
tick |= TICK_PROMOTE;
end:
#if LSQUIC_KEEP_ENC_SESS_HISTORY
if (tick & (TICK_CLOSE|TICK_PROMOTE))
maybe_log_enc_sess_history(mc);
#endif
return tick;
}
static void
process_packet (struct mini_conn *mc, struct lsquic_packet_in *packet_in)
{
switch (process_regular_packet(mc, packet_in))
{
case PRP_KEEP:
assert(packet_in->pi_flags & PI_OWN_DATA);
lsquic_packet_in_upref(packet_in);
TAILQ_INSERT_TAIL(&mc->mc_packets_in, packet_in, pi_next);
if (mc->mc_flags & MC_HAVE_NEW_HSK)
{
if (0 != continue_handshake(mc))
mc->mc_flags |= MC_ERROR;
mc->mc_flags &= ~MC_HAVE_NEW_HSK;
}
break;
case PRP_DEFER:
assert(packet_in->pi_flags & PI_OWN_DATA);
lsquic_packet_in_upref(packet_in);
if (mc->mc_n_deferred < MINI_CONN_MAX_DEFERRED)
{
TAILQ_INSERT_TAIL(&mc->mc_deferred, packet_in, pi_next);
++mc->mc_n_deferred;
}
else
LSQ_DEBUG("won't defer more than %u packets: drop",
MINI_CONN_MAX_DEFERRED);
break;
case PRP_ERROR:
mc->mc_flags |= MC_ERROR;
break;
case PRP_DROP:
break;
}
}
/* Keep deferred list ordered by packet number, so that we can process all
* of them in a single pass.
*/
static void
insert_into_deferred (struct mini_conn *mc, lsquic_packet_in_t *new_packet)
{
lsquic_packet_in_t *packet_in;
lsquic_packet_in_upref(new_packet);
TAILQ_FOREACH(packet_in, &mc->mc_deferred, pi_next)
if (packet_in->pi_packno > new_packet->pi_packno)
break;
if (packet_in)
TAILQ_INSERT_BEFORE(packet_in, new_packet, pi_next);
else
TAILQ_INSERT_TAIL(&mc->mc_deferred, new_packet, pi_next);
++mc->mc_n_deferred;
}
static void
process_deferred_packets (struct mini_conn *mc)
{
lsquic_packet_in_t *last, *packet_in;
int reached_last;
last = TAILQ_LAST(&mc->mc_deferred, head_packet_in);
do
{
packet_in = TAILQ_FIRST(&mc->mc_deferred);
TAILQ_REMOVE(&mc->mc_deferred, packet_in, pi_next);
--mc->mc_n_deferred;
process_packet(mc, packet_in);
reached_last = packet_in == last;
lsquic_packet_in_put(&mc->mc_enpub->enp_mm, packet_in);
}
while (!reached_last);
}
#if LSQUIC_RECORD_INORD_HIST
/* FIXME This does not work for Q050, where 0 is a valid packet number. */
/* Packet number is encoded as a sequence of 1-bits and stored in mc_inord_hist
* separated by 0 bits. For example, sequence of packet numbers 3, 2, 1 would
* be encoded as (starting with LSB) 1110110100000000... This is not the most
* space-efficient scheme, but it is simple to implement and should suffice for
* our purposes.
*/
static void
record_inord_packno (struct mini_conn *mc, lsquic_packno_t packno)
{
int n_avail;
lsquic_packno_t mask;
for ( ; mc->mc_inord_idx < sizeof(mc->mc_inord_hist) /
sizeof(mc->mc_inord_hist[0]); ++mc->mc_inord_idx)
{
if (mc->mc_inord_hist[ mc->mc_inord_idx ])
n_avail = __builtin_clzll(mc->mc_inord_hist[ mc->mc_inord_idx ]) - 1;
else
n_avail = sizeof(mc->mc_inord_hist[ mc->mc_inord_idx ]) * 8;
if (n_avail >= (int) packno)
{
mask = (1ULL << (int) packno) - 1;
mask <<= sizeof(mc->mc_inord_hist[ mc->mc_inord_idx ]) * 8 - n_avail;
mc->mc_inord_hist[ mc->mc_inord_idx ] |= mask;
return; /* Success */
}
}
}
#if __GNUC__
# define ctz __builtin_ctzll
#else
static unsigned
ctz (unsigned long long x)
{
unsigned n = 0;
if (0 == (x & ((1ULL << 32) - 1))) { n += 32; x >>= 32; }
if (0 == (x & ((1ULL << 16) - 1))) { n += 16; x >>= 16; }
if (0 == (x & ((1ULL << 8) - 1))) { n += 8; x >>= 8; }
if (0 == (x & ((1ULL << 4) - 1))) { n += 4; x >>= 4; }
if (0 == (x & ((1ULL << 2) - 1))) { n += 2; x >>= 2; }
if (0 == (x & ((1ULL << 1) - 1))) { n += 1; x >>= 1; }
return n;
}
#endif
static void
inord_to_str (const struct mini_conn *mc, char *buf, size_t bufsz)
{
unsigned long long hist;
size_t off;
ssize_t nw;
unsigned n;
int n_trail;
off = 0;
for (n = 0; n < sizeof(mc->mc_inord_hist) /
sizeof(mc->mc_inord_hist[0]); ++n)
{
hist = mc->mc_inord_hist[n];
while (hist)
{
n_trail = ctz(~hist);
nw = snprintf(buf + off, bufsz - off,
/* No spaces are included on purpose: this makes it a single
* field and thus easy to process log using standard command-
* line tools, such as sork -k, for example.
*/
(off ? ",%d" : "%d"), n_trail);
if ((size_t) nw > bufsz - off || nw < 0)
break;
off += nw;
hist >>= n_trail + 1;
}
}
buf[ bufsz - 1 ] = '\0'; /* CYA */
}
#endif
static void
mini_conn_ci_packet_in (struct lsquic_conn *lconn,
struct lsquic_packet_in *packet_in)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
#if LSQUIC_RECORD_INORD_HIST
record_inord_packno(mc, packet_in->pi_packno);
#endif
#if 0
/* A convenient way to test lsquic_is_valid_hs_packet(): */
if (!(mc->mc_sent_packnos))
assert(lsquic_is_valid_hs_packet(NULL, packet_in->pi_data,
packet_in->pi_data_sz));
#endif
if (mc->mc_flags & MC_ERROR)
{
LSQ_DEBUG("error state: ignore packet %"PRIu64, packet_in->pi_packno);
return;
}
if (lsquic_packet_in_is_gquic_prst(packet_in))
{
LSQ_INFO("received reset packet");
mc->mc_flags |= MC_ERROR;
MCHIST_APPEND(mc, MCHE_PRST_IN);
return;
}
LSQ_DEBUG("packet in: %"PRIu64, packet_in->pi_packno);
EV_LOG_PACKET_IN(LSQUIC_LOG_CONN_ID, packet_in);
/* Check receive history */
if (0 == packet_in->pi_packno)
{
LSQ_DEBUG("invalid packet number 0");
mc->mc_flags |= MC_ERROR;
MCHIST_APPEND(mc, MCHE_PACKET0_IN);
return;
}
if (packet_in->pi_packno > MINICONN_MAX_PACKETS)
{
LSQ_DEBUG("packet number %"PRIu64" is too large (max %zd)",
packet_in->pi_packno, MINICONN_MAX_PACKETS);
mc->mc_flags |= MC_ERROR;
MCHIST_APPEND(mc, MCHE_PACKET2LARGE_IN);
return;
}
if (MCONN_PACKET_MASK(packet_in->pi_packno) & mc->mc_received_packnos)
{
LSQ_DEBUG("duplicate packet %"PRIu64", ignoring", packet_in->pi_packno);
MCHIST_APPEND(mc, MCHE_PACKET_DUP_IN);
return;
}
if (TAILQ_EMPTY(&mc->mc_deferred))
process_packet(mc, packet_in);
else if (mc->mc_n_deferred < MINI_CONN_MAX_DEFERRED)
{
insert_into_deferred(mc, packet_in);
process_deferred_packets(mc);
}
else
LSQ_DEBUG("won't defer more than %u packets: drop",
MINI_CONN_MAX_DEFERRED);
}
/* Q050 is different is that packet numbers are not known until after the
* packet is decrypted, so we have to follow different logic here.
*/
static void
mini_conn_ci_Q050_packet_in (struct lsquic_conn *lconn,
struct lsquic_packet_in *packet_in)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
enum proc_rp prp;
if (mc->mc_flags & MC_ERROR)
{
LSQ_DEBUG("error state: ignore packet");
return;
}
if (!mc->mc_conn.cn_enc_session)
{
mc->mc_conn.cn_enc_session =
mc->mc_conn.cn_esf.g->esf_create_server(&mc->mc_conn,
mc->mc_conn.cn_cid, mc->mc_enpub);
if (!mc->mc_conn.cn_enc_session)
{
LSQ_WARN("cannot create new enc session");
mc->mc_flags |= MC_ERROR;
return;
}
MCHIST_APPEND(mc, MCHE_NEW_ENC_SESS);
}
assert(!(packet_in->pi_flags & PI_DECRYPTED));
prp = conn_decrypt_packet_or(mc, packet_in);
switch (prp)
{
case PRP_KEEP:
break;
case PRP_DROP:
return;
case PRP_ERROR:
mc->mc_flags |= MC_ERROR;
return;
default:
if (mc->mc_n_deferred >= MINI_CONN_MAX_DEFERRED)
{
LSQ_DEBUG("won't defer more than %u packets: drop",
MINI_CONN_MAX_DEFERRED);
return;
}
assert(prp == PRP_DEFER);
assert(packet_in->pi_flags & PI_OWN_DATA);
lsquic_packet_in_upref(packet_in);
TAILQ_INSERT_TAIL(&mc->mc_deferred, packet_in, pi_next);
++mc->mc_n_deferred;
return;
}
assert(prp == PRP_KEEP);
process_packet(mc, packet_in);
}
static struct lsquic_packet_out *
mini_conn_ci_next_packet_to_send (struct lsquic_conn *lconn,
const struct to_coal *to_coal_UNUSED)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
lsquic_packet_out_t *packet_out;
assert(NULL == to_coal_UNUSED);
TAILQ_FOREACH(packet_out, &mc->mc_packets_out, po_next)
{
if (packet_out->po_flags & PO_SENT)
continue;
packet_out->po_flags |= PO_SENT;
LSQ_DEBUG("packet_to_send: %"PRIu64, packet_out->po_packno);
return packet_out;
}
return NULL;
}
static void
mini_conn_ci_packet_sent (struct lsquic_conn *lconn,
struct lsquic_packet_out *packet_out)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
mc->mc_sent_packnos |= MCONN_PACKET_MASK(packet_out->po_packno);
if (packet_out->po_frame_types & (1 << QUIC_FRAME_ACK))
{
assert(mc->mc_flags & MC_UNSENT_ACK);
mc->mc_flags &= ~MC_UNSENT_ACK;
}
LSQ_DEBUG("%s: packet %"PRIu64" sent", __func__, packet_out->po_packno);
MCHIST_APPEND(mc, MCHE_PACKET_SENT);
}
static void
mini_conn_ci_packet_not_sent (struct lsquic_conn *lconn,
struct lsquic_packet_out *packet_out)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
packet_out->po_flags &= ~PO_SENT;
LSQ_DEBUG("%s: packet %"PRIu64" not sent", __func__, packet_out->po_packno);
MCHIST_APPEND(mc, MCHE_PACKET_DELAYED);
}
static void
mini_conn_ci_destroy (struct lsquic_conn *lconn)
{
assert(!(lconn->cn_flags & LSCONN_HASHED));
struct mini_conn *mc = (struct mini_conn *) lconn;
lsquic_packet_in_t *packet_in;
mconn_packno_set_t still_deferred = 0, in_flight;
enum lsq_log_level log_level;
#if LSQUIC_RECORD_INORD_HIST
char inord_str[0x100];
#endif
while ((packet_in = TAILQ_FIRST(&mc->mc_packets_in)))
{
TAILQ_REMOVE(&mc->mc_packets_in, packet_in, pi_next);
lsquic_packet_in_put(&mc->mc_enpub->enp_mm, packet_in);
}
while ((packet_in = TAILQ_FIRST(&mc->mc_deferred)))
{
TAILQ_REMOVE(&mc->mc_deferred, packet_in, pi_next);
--mc->mc_n_deferred;
still_deferred |= MCONN_PACKET_MASK(packet_in->pi_packno);
lsquic_packet_in_put(&mc->mc_enpub->enp_mm, packet_in);
}
if (TAILQ_EMPTY(&mc->mc_packets_out))
in_flight = ~0ull; /* Indicates that packets were dropped before */
else
in_flight = drop_packets_out(mc);
if (mc->mc_conn.cn_enc_session)
mc->mc_conn.cn_esf.g->esf_destroy(mc->mc_conn.cn_enc_session);
log_level = warning_is_warranted(mc) ? LSQ_LOG_WARN : LSQ_LOG_DEBUG;
#if LSQUIC_RECORD_INORD_HIST
if (LSQ_LOG_ENABLED(log_level))
inord_to_str(mc, inord_str, sizeof(inord_str));
#endif
#if LSQUIC_KEEP_MINICONN_HISTORY
const unsigned hist_idx = MCHIST_MASK & mc->mc_hist_idx;
if (MCHE_EMPTY == mc->mc_hist_buf[ hist_idx ])
LSQ_LOG(log_level, "destroyed. Diagnostics: conn flags: 0x%X, "
"mc flags: 0x%X, "
#if LSQUIC_RECORD_INORD_HIST
"incoming-history (trunc: %d) %s, "
#endif
"received: %"PRIX64", sent: %"PRIX64", lost: %"PRIX64", "
"deferred: %"PRIX64", still-deferred: %"PRIX64", "
"dropped: %"PRIX64", in-flight: %"PRIX64", acked: %"PRIX64", "
"error_code: 0x%X, ticks: %hu, pack size: %hu, "
"lifetime: %"PRIu64" usec, version: %s, "
"mc hist: %.*s", mc->mc_conn.cn_flags,
mc->mc_flags,
#if LSQUIC_RECORD_INORD_HIST
mc->mc_inord_idx >= sizeof(mc->mc_inord_hist) /
sizeof(mc->mc_inord_hist[0]), inord_str,
#endif
mc->mc_received_packnos, mc->mc_sent_packnos, mc->mc_lost_packnos,
mc->mc_deferred_packnos, still_deferred,
mc->mc_dropped_packnos, in_flight, mc->mc_acked_packnos,
mc->mc_error_code, mc->mc_n_ticks, mc->mc_path.np_pack_size,
lsquic_time_now() - mc->mc_created,
lsquic_ver2str[mc->mc_conn.cn_version],
(int) hist_idx, mc->mc_hist_buf);
else
LSQ_LOG(log_level, "destroyed. Diagnostics: conn flags: 0x%X, "
"mc flags: 0x%X, "
#if LSQUIC_RECORD_INORD_HIST
"incoming-history (trunc: %d) %s, "
#endif
"received: %"PRIX64", sent: %"PRIX64", lost: %"PRIX64", "
"deferred: %"PRIX64", still-deferred: %"PRIX64", "
"dropped: %"PRIX64", in-flight: %"PRIX64", acked: %"PRIX64", "
"error_code: 0x%X, ticks: %hu, pack size: %hu, "
"lifetime: %"PRIu64" usec, version: %s, "
"mc hist: %.*s%.*s", mc->mc_conn.cn_flags,
mc->mc_flags,
#if LSQUIC_RECORD_INORD_HIST
mc->mc_inord_idx >= sizeof(mc->mc_inord_hist) /
sizeof(mc->mc_inord_hist[0]), inord_str,
#endif
mc->mc_received_packnos, mc->mc_sent_packnos, mc->mc_lost_packnos,
mc->mc_deferred_packnos, still_deferred,
mc->mc_dropped_packnos, in_flight, mc->mc_acked_packnos,
mc->mc_error_code, mc->mc_n_ticks, mc->mc_path.np_pack_size,
lsquic_time_now() - mc->mc_created,
lsquic_ver2str[mc->mc_conn.cn_version],
(int) (sizeof(mc->mc_hist_buf) - hist_idx),
mc->mc_hist_buf + hist_idx, (int) hist_idx, mc->mc_hist_buf);
#else
if (LSQ_LOG_ENABLED(log_level))
lsquic_logger_log2(log_level, LSQUIC_LOGGER_MODULE,
LSQUIC_LOG_CONN_ID,
"destroyed. Diagnostics: conn flags: 0x%X, "
"mc flags: 0x%X, "
#if LSQUIC_RECORD_INORD_HIST
"incoming-history (trunc: %d) %s, "
#endif
"received: %"PRIX64", sent: %"PRIX64", lost: %"PRIX64", "
"deferred: %"PRIX64", still-deferred: %"PRIX64", "
"dropped: %"PRIX64", in-flight: %"PRIX64", acked: %"PRIX64", "
"error_code: 0x%X, ticks: %hu, pack size: %hu, "
"lifetime: %"PRIu64" usec",
mc->mc_conn.cn_flags,
mc->mc_flags,
#if LSQUIC_RECORD_INORD_HIST
mc->mc_inord_idx >= sizeof(mc->mc_inord_hist) /
sizeof(mc->mc_inord_hist[0]), inord_str,
#endif
mc->mc_received_packnos, mc->mc_sent_packnos, mc->mc_lost_packnos,
mc->mc_deferred_packnos, still_deferred,
mc->mc_dropped_packnos, in_flight, mc->mc_acked_packnos,
mc->mc_error_code, mc->mc_n_ticks, mc->mc_path.np_pack_size,
lsquic_time_now() - mc->mc_created);
#endif
EV_LOG_CONN_EVENT(LSQUIC_LOG_CONN_ID, "mini connection destroyed");
lsquic_malo_put(mc);
}
static struct lsquic_engine *
mini_conn_ci_get_engine (struct lsquic_conn *lconn)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
return mc->mc_enpub->enp_engine;
}
static void
mini_conn_ci_hsk_done (struct lsquic_conn *lconn, enum lsquic_hsk_status status)
{
assert(0);
}
/* A mini connection is only tickable if it has unsent packets. This can
* occur when packet sending is delayed.
*
* Otherwise, a mini connection is not tickable: Either there are incoming
* packets, in which case, the connection is going to be ticked, or there is
* an alarm pending, in which case it will be handled via the attq.
*/
static int
mini_conn_ci_is_tickable (struct lsquic_conn *lconn)
{
struct mini_conn *const mc = (struct mini_conn *) lconn;
const struct lsquic_packet_out *packet_out;
if (mc->mc_enpub->enp_flags & ENPUB_CAN_SEND)
TAILQ_FOREACH(packet_out, &mc->mc_packets_out, po_next)
if (!(packet_out->po_flags & PO_SENT))
return 1;
return 0;
}
static lsquic_time_t
mini_conn_ci_next_tick_time (struct lsquic_conn *lconn, unsigned *why)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
lsquic_packet_out_t *packet_out;
lsquic_time_t exp_time, retx_time;
exp_time = mc->mc_created + mc->mc_enpub->enp_settings.es_handshake_to;
TAILQ_FOREACH(packet_out, &mc->mc_packets_out, po_next)
if (packet_out->po_flags & PO_SENT)
{
retx_time = packet_out->po_sent + calc_retx_timeout(mc);
if (retx_time < exp_time)
{
*why = N_AEWS + AL_RETX_HSK;
return retx_time;
}
else
{
*why = AEW_MINI_EXPIRE;
return exp_time;
}
}
*why = AEW_MINI_EXPIRE;
return exp_time;
}
static void
mini_conn_ci_client_call_on_new (struct lsquic_conn *lconn)
{
assert(0);
}
static void
mini_conn_ci_internal_error (struct lsquic_conn *lconn,
const char *format, ...)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
LSQ_INFO("internal error reported");
mc->mc_flags |= MC_ERROR;
}
/* This function should not be called, as this is specific to IETF QUIC */
static void
mini_conn_ci_abort_error (struct lsquic_conn *lconn, int is_app,
unsigned error_code, const char *fmt, ...)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
assert(0);
LSQ_WARN("(GQUIC) abort error is called unexpectedly");
mc->mc_flags |= MC_ERROR;
}
static void
mini_conn_ci_tls_alert (struct lsquic_conn *lconn, uint8_t alert)
{
assert(0);
}
static unsigned char
mini_conn_ci_record_addrs (struct lsquic_conn *lconn, void *peer_ctx,
const struct sockaddr *local_sa, const struct sockaddr *peer_sa)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
struct lsquic_packet_out *packet_out;
size_t len;
if (NP_IS_IPv6(&mc->mc_path) != (AF_INET6 == peer_sa->sa_family))
TAILQ_FOREACH(packet_out, &mc->mc_packets_out, po_next)
if ((packet_out->po_flags & (PO_SENT|PO_ENCRYPTED)) == PO_ENCRYPTED)
return_enc_data(mc, packet_out);
len = local_sa->sa_family == AF_INET ? sizeof(struct sockaddr_in)
: sizeof(struct sockaddr_in6);
memcpy(mc->mc_path.np_peer_addr, peer_sa, len);
memcpy(mc->mc_path.np_local_addr, local_sa, len);
mc->mc_path.np_peer_ctx = peer_ctx;
return 0;
}
static struct network_path *
mini_conn_ci_get_path (struct lsquic_conn *lconn, const struct sockaddr *sa)
{
struct mini_conn *mc = (struct mini_conn *) lconn;
return &mc->mc_path;
}
static const struct conn_iface mini_conn_iface_standard = {
.ci_abort_error = mini_conn_ci_abort_error,
.ci_client_call_on_new = mini_conn_ci_client_call_on_new,
.ci_destroy = mini_conn_ci_destroy,
.ci_get_engine = mini_conn_ci_get_engine,
.ci_get_path = mini_conn_ci_get_path,
.ci_hsk_done = mini_conn_ci_hsk_done,
.ci_internal_error = mini_conn_ci_internal_error,
.ci_is_tickable = mini_conn_ci_is_tickable,
.ci_next_packet_to_send = mini_conn_ci_next_packet_to_send,
.ci_next_tick_time = mini_conn_ci_next_tick_time,
.ci_packet_in = mini_conn_ci_packet_in,
.ci_packet_not_sent = mini_conn_ci_packet_not_sent,
.ci_packet_sent = mini_conn_ci_packet_sent,
.ci_record_addrs = mini_conn_ci_record_addrs,
.ci_tick = mini_conn_ci_tick,
.ci_tls_alert = mini_conn_ci_tls_alert,
};
static const struct conn_iface mini_conn_iface_standard_Q050 = {
.ci_abort_error = mini_conn_ci_abort_error,
.ci_client_call_on_new = mini_conn_ci_client_call_on_new,
.ci_destroy = mini_conn_ci_destroy,
.ci_get_engine = mini_conn_ci_get_engine,
.ci_get_path = mini_conn_ci_get_path,
.ci_hsk_done = mini_conn_ci_hsk_done,
.ci_internal_error = mini_conn_ci_internal_error,
.ci_is_tickable = mini_conn_ci_is_tickable,
.ci_next_packet_to_send = mini_conn_ci_next_packet_to_send,
.ci_next_tick_time = mini_conn_ci_next_tick_time,
.ci_packet_in = mini_conn_ci_Q050_packet_in,
.ci_packet_not_sent = mini_conn_ci_packet_not_sent,
.ci_packet_sent = mini_conn_ci_packet_sent,
.ci_record_addrs = mini_conn_ci_record_addrs,
.ci_tick = mini_conn_ci_tick,
.ci_tls_alert = mini_conn_ci_tls_alert,
};
typedef char largest_recv_holds_at_least_16_seconds[
((1 << (sizeof(((struct mini_conn *) 0)->mc_largest_recv) * 8)) / 1000000
>= 16) ? 1 : -1];
typedef char max_lifespan_smaller_than_largest_recv[
((1 << (sizeof(((struct mini_conn *) 0)->mc_largest_recv) * 8)) >
MAX_MINI_CONN_LIFESPAN_IN_USEC) ? 1 : -1];
Reference in New Issue View Git Blame Copy Permalink