mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-11-28 06:11:32 +01:00
Code Issues Projects Releases Wiki Activity

CLEANUP: quic: rename frame variables

Browse Source 
Rename all frame variables with the suffix _frm. This helps to
differentiate frame instances from other internal objects.

This should be backported up to 2.7.
This commit is contained in:
Amaury Denoyelle 2023-04-24 15:32:23 +02:00
parent 888c5f283a
commit d5f03cd576
5 changed files with 292 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/haproxy/quic_conn.h
View File

@ -199,13 +199,13 @@ static inline void free_quic_conn_cids(struct quic_conn *conn)
static inline void quic_connection_id_to_frm_cpy(struct quic_frame *dst,
struct quic_connection_id *src)
{
struct qf_new_connection_id *to = &dst->new_connection_id;
struct qf_new_connection_id *ncid_frm = &dst->new_connection_id;
to->seq_num = src->seq_num.key;
to->retire_prior_to = src->retire_prior_to;
to->cid.len = src->cid.len;
to->cid.data = src->cid.data;
to->stateless_reset_token = src->stateless_reset_token;
ncid_frm->seq_num = src->seq_num.key;
ncid_frm->retire_prior_to = src->retire_prior_to;
ncid_frm->cid.len = src->cid.len;
ncid_frm->cid.data = src->cid.data;
ncid_frm->stateless_reset_token = src->stateless_reset_token;
}
/* Return a 32-bits integer in <val> from QUIC packet with <buf> as address.

14
include/haproxy/quic_frame.h
View File

@ -278,18 +278,18 @@ static inline void qc_frm_free(struct quic_frame **frm)
/* Move forward <strm> STREAM frame by <data> bytes. */
static inline void qc_stream_frm_mv_fwd(struct quic_frame *frm, uint64_t data)
{
struct qf_stream *strm = &frm->stream;
struct qf_stream *strm_frm = &frm->stream;
struct buffer cf_buf;
/* Set offset bit if not already there. */
strm->offset.key += data;
strm_frm->offset.key += data;
frm->type |= QUIC_STREAM_FRAME_TYPE_OFF_BIT;
strm->len -= data;
cf_buf = b_make(b_orig(strm->buf),
b_size(strm->buf),
(char *)strm->data - b_orig(strm->buf), 0);
strm->data = (unsigned char *)b_peek(&cf_buf, data);
strm_frm->len -= data;
cf_buf = b_make(b_orig(strm_frm->buf),
b_size(strm_frm->buf),
(char *)strm_frm->data - b_orig(strm_frm->buf), 0);
strm_frm->data = (unsigned char *)b_peek(&cf_buf, data);
}
#endif /* USE_QUIC */

116
src/quic_conn.c
View File

@ -576,11 +576,11 @@ static void quic_trace(enum trace_level level, uint64_t mask, const struct trace
}
if (mask & QUIC_EV_CONN_ACKSTRM) {
const struct qf_stream *s = a2;
const struct qf_stream *strm_frm = a2;
const struct qc_stream_desc *stream = a3;
if (s)
chunk_appendf(&trace_buf, " off=%llu len=%llu", (ull)s->offset.key, (ull)s->len);
if (strm_frm)
chunk_appendf(&trace_buf, " off=%llu len=%llu", (ull)strm_frm->offset.key, (ull)strm_frm->len);
if (stream)
chunk_appendf(&trace_buf, " ack_offset=%llu", (ull)stream->ack_offset);
}
@ -1737,13 +1737,13 @@ static int quic_stream_try_to_consume(struct quic_conn *qc,
ret = 0;
frm_node = eb64_first(&stream->acked_frms);
while (frm_node) {
struct qf_stream *strm;
struct qf_stream *strm_frm;
struct quic_frame *frm;
size_t offset, len;
strm = eb64_entry(frm_node, struct qf_stream, offset);
offset = strm->offset.key;
len = strm->len;
strm_frm = eb64_entry(frm_node, struct qf_stream, offset);
offset = strm_frm->offset.key;
len = strm_frm->len;
if (offset > stream->ack_offset)
break;
@ -1751,7 +1751,7 @@ static int quic_stream_try_to_consume(struct quic_conn *qc,
if (qc_stream_desc_ack(&stream, offset, len)) {
/* cf. next comment : frame may be freed at this stage. */
TRACE_DEVEL("stream consumed", QUIC_EV_CONN_ACKSTRM,
qc, stream ? strm : NULL, stream);
qc, stream ? strm_frm : NULL, stream);
ret = 1;
}
@ -1766,9 +1766,9 @@ static int quic_stream_try_to_consume(struct quic_conn *qc,
}
frm_node = eb64_next(frm_node);
eb64_delete(&strm->offset);
eb64_delete(&strm_frm->offset);
frm = container_of(strm, struct quic_frame, stream);
frm = container_of(strm_frm, struct quic_frame, stream);
qc_release_frm(qc, frm);
}
@ -2209,7 +2209,7 @@ static inline int qc_parse_ack_frm(struct quic_conn *qc,
unsigned int *rtt_sample,
const unsigned char **pos, const unsigned char *end)
{
struct qf_ack *ack = &frm->ack;
struct qf_ack *ack_frm = &frm->ack;
uint64_t smallest, largest;
struct eb_root *pkts;
struct eb64_node *largest_node;
@ -2220,26 +2220,26 @@ static inline int qc_parse_ack_frm(struct quic_conn *qc,
TRACE_ENTER(QUIC_EV_CONN_PRSAFRM, qc);
if (ack->largest_ack > qel->pktns->tx.next_pn) {
if (ack_frm->largest_ack > qel->pktns->tx.next_pn) {
TRACE_DEVEL("ACK for not sent packet", QUIC_EV_CONN_PRSAFRM,
qc, NULL, &ack->largest_ack);
qc, NULL, &ack_frm->largest_ack);
goto err;
}
if (ack->first_ack_range > ack->largest_ack) {
if (ack_frm->first_ack_range > ack_frm->largest_ack) {
TRACE_DEVEL("too big first ACK range", QUIC_EV_CONN_PRSAFRM,
qc, NULL, &ack->first_ack_range);
qc, NULL, &ack_frm->first_ack_range);
goto err;
}
largest = ack->largest_ack;
smallest = largest - ack->first_ack_range;
largest = ack_frm->largest_ack;
smallest = largest - ack_frm->first_ack_range;
pkts = &qel->pktns->tx.pkts;
pkt_flags = 0;
largest_node = NULL;
time_sent = 0;
if ((int64_t)ack->largest_ack > qel->pktns->rx.largest_acked_pn) {
if ((int64_t)ack_frm->largest_ack > qel->pktns->rx.largest_acked_pn) {
largest_node = eb64_lookup(pkts, largest);
if (!largest_node) {
TRACE_DEVEL("Largest acked packet not found",
@ -2258,7 +2258,7 @@ static inline int qc_parse_ack_frm(struct quic_conn *qc,
qc_ackrng_pkts(qc, pkts, &pkt_flags, &newly_acked_pkts,
largest_node, largest, smallest);
if (!ack->ack_range_num--)
if (!ack_frm->ack_range_num--)
break;
if (!quic_dec_int(&gap, pos, end)) {
@ -2295,7 +2295,7 @@ static inline int qc_parse_ack_frm(struct quic_conn *qc,
if (time_sent && (pkt_flags & QUIC_FL_TX_PACKET_ACK_ELICITING)) {
*rtt_sample = tick_remain(time_sent, now_ms);
qel->pktns->rx.largest_acked_pn = ack->largest_ack;
qel->pktns->rx.largest_acked_pn = ack_frm->largest_ack;
}
if (!LIST_ISEMPTY(&newly_acked_pkts)) {
@ -2903,15 +2903,15 @@ static struct ncbuf *quic_get_ncbuf(struct ncbuf *ncbuf)
* CRYPTO data.
*/
static int qc_handle_crypto_frm(struct quic_conn *qc,
struct qf_crypto *frm, struct quic_rx_packet *pkt,
struct qf_crypto *crypto_frm, struct quic_rx_packet *pkt,
struct quic_enc_level *qel, int *fast_retrans)
{
int ret = 0;
enum ncb_ret ncb_ret;
/* XXX TO DO: <cfdebug> is used only for the traces. */
struct quic_rx_crypto_frm cfdebug = {
.offset_node.key = frm->offset,
.len = frm->len,
.offset_node.key = crypto_frm->offset,
.len = crypto_frm->len,
};
struct quic_cstream *cstream = qel->cstream;
struct ncbuf *ncbuf = &qel->cstream->rx.ncbuf;
@ -2923,10 +2923,10 @@ static int qc_handle_crypto_frm(struct quic_conn *qc,
goto done;
}
if (unlikely(frm->offset < cstream->rx.offset)) {
if (unlikely(crypto_frm->offset < cstream->rx.offset)) {
size_t diff;
if (frm->offset + frm->len <= cstream->rx.offset) {
if (crypto_frm->offset + crypto_frm->len <= cstream->rx.offset) {
/* Nothing to do */
TRACE_PROTO("Already received CRYPTO data",
QUIC_EV_CONN_RXPKT, qc, pkt, &cfdebug);
@ -2939,20 +2939,20 @@ static int qc_handle_crypto_frm(struct quic_conn *qc,
TRACE_PROTO("Partially already received CRYPTO data",
QUIC_EV_CONN_RXPKT, qc, pkt, &cfdebug);
diff = cstream->rx.offset - frm->offset;
frm->len -= diff;
frm->data += diff;
frm->offset = cstream->rx.offset;
diff = cstream->rx.offset - crypto_frm->offset;
crypto_frm->len -= diff;
crypto_frm->data += diff;
crypto_frm->offset = cstream->rx.offset;
}
if (frm->offset == cstream->rx.offset && ncb_is_empty(ncbuf)) {
if (!qc_provide_cdata(qel, qc->xprt_ctx, frm->data, frm->len,
if (crypto_frm->offset == cstream->rx.offset && ncb_is_empty(ncbuf)) {
if (!qc_provide_cdata(qel, qc->xprt_ctx, crypto_frm->data, crypto_frm->len,
pkt, &cfdebug)) {
// trace already emitted by function above
goto leave;
}
cstream->rx.offset += frm->len;
cstream->rx.offset += crypto_frm->len;
TRACE_DEVEL("increment crypto level offset", QUIC_EV_CONN_PHPKTS, qc, qel);
goto done;
}
@ -2963,9 +2963,9 @@ static int qc_handle_crypto_frm(struct quic_conn *qc,
goto leave;
}
/* frm->offset > cstream-trx.offset */
ncb_ret = ncb_add(ncbuf, frm->offset - cstream->rx.offset,
(const char *)frm->data, frm->len, NCB_ADD_COMPARE);
/* crypto_frm->offset > cstream-trx.offset */
ncb_ret = ncb_add(ncbuf, crypto_frm->offset - cstream->rx.offset,
(const char *)crypto_frm->data, crypto_frm->len, NCB_ADD_COMPARE);
if (ncb_ret != NCB_RET_OK) {
if (ncb_ret == NCB_RET_DATA_REJ) {
TRACE_ERROR("overlapping data rejected", QUIC_EV_CONN_PRSHPKT, qc);
@ -3024,7 +3024,7 @@ static int qc_handle_retire_connection_id_frm(struct quic_conn *qc,
struct quic_connection_id **to_retire)
{
int ret = 0;
struct qf_retire_connection_id *rcid = &frm->retire_connection_id;
struct qf_retire_connection_id *rcid_frm = &frm->retire_connection_id;
struct eb64_node *node;
struct quic_connection_id *conn_id;
@ -3035,7 +3035,7 @@ static int qc_handle_retire_connection_id_frm(struct quic_conn *qc,
* than any previously sent to the peer MUST be treated as a connection error
* of type PROTOCOL_VIOLATION.
*/
if (rcid->seq_num >= qc->next_cid_seq_num) {
if (rcid_frm->seq_num >= qc->next_cid_seq_num) {
TRACE_PROTO("CID seq. number too big", QUIC_EV_CONN_PSTRM, qc, frm);
goto protocol_violation;
}
@ -3045,7 +3045,7 @@ static int qc_handle_retire_connection_id_frm(struct quic_conn *qc,
* the Destination Connection ID field of the packet in which the frame is contained.
* The peer MAY treat this as a connection error of type PROTOCOL_VIOLATION.
*/
node = eb64_lookup(&qc->cids, rcid->seq_num);
node = eb64_lookup(&qc->cids, rcid_frm->seq_num);
if (!node) {
TRACE_PROTO("CID already retired", QUIC_EV_CONN_PSTRM, qc, frm);
goto out;
@ -3154,16 +3154,16 @@ static int qc_parse_pkt_frms(struct quic_conn *qc, struct quic_rx_packet *pkt,
}
case QUIC_FT_RESET_STREAM:
if (qc->mux_state == QC_MUX_READY) {
struct qf_reset_stream *rs = &frm.reset_stream;
qcc_recv_reset_stream(qc->qcc, rs->id, rs->app_error_code, rs->final_size);
struct qf_reset_stream *rs_frm = &frm.reset_stream;
qcc_recv_reset_stream(qc->qcc, rs_frm->id, rs_frm->app_error_code, rs_frm->final_size);
}
break;
case QUIC_FT_STOP_SENDING:
{
struct qf_stop_sending *stop_sending = &frm.stop_sending;
struct qf_stop_sending *ss_frm = &frm.stop_sending;
if (qc->mux_state == QC_MUX_READY) {
if (qcc_recv_stop_sending(qc->qcc, stop_sending->id,
stop_sending->app_error_code)) {
if (qcc_recv_stop_sending(qc->qcc, ss_frm->id,
ss_frm->app_error_code)) {
TRACE_ERROR("qcc_recv_stop_sending() failed", QUIC_EV_CONN_PRSHPKT, qc);
goto leave;
}
@ -3176,19 +3176,19 @@ static int qc_parse_pkt_frms(struct quic_conn *qc, struct quic_rx_packet *pkt,
break;
case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
{
struct qf_stream *stream = &frm.stream;
unsigned nb_streams = qc->rx.strms[qcs_id_type(stream->id)].nb_streams;
struct qf_stream *strm_frm = &frm.stream;
unsigned nb_streams = qc->rx.strms[qcs_id_type(strm_frm->id)].nb_streams;
const char fin = frm.type & QUIC_STREAM_FRAME_TYPE_FIN_BIT;
/* The upper layer may not be allocated. */
if (qc->mux_state != QC_MUX_READY) {
if ((stream->id >> QCS_ID_TYPE_SHIFT) < nb_streams) {
if ((strm_frm->id >> QCS_ID_TYPE_SHIFT) < nb_streams) {
TRACE_DATA("Already closed stream", QUIC_EV_CONN_PRSHPKT, qc);
}
else {
TRACE_DEVEL("No mux for new stream", QUIC_EV_CONN_PRSHPKT, qc);
if (qc->app_ops == &h3_ops) {
if (!qc_h3_request_reject(qc, stream->id)) {
if (!qc_h3_request_reject(qc, strm_frm->id)) {
TRACE_ERROR("error on request rejection", QUIC_EV_CONN_PRSHPKT, qc);
/* This packet will not be acknowledged */
goto leave;
@ -3203,7 +3203,7 @@ static int qc_parse_pkt_frms(struct quic_conn *qc, struct quic_rx_packet *pkt,
break;
}
if (!qc_handle_strm_frm(pkt, stream, qc, fin)) {
if (!qc_handle_strm_frm(pkt, strm_frm, qc, fin)) {
TRACE_ERROR("qc_handle_strm_frm() failed", QUIC_EV_CONN_PRSHPKT, qc);
goto leave;
}
@ -3212,15 +3212,15 @@ static int qc_parse_pkt_frms(struct quic_conn *qc, struct quic_rx_packet *pkt,
}
case QUIC_FT_MAX_DATA:
if (qc->mux_state == QC_MUX_READY) {
struct qf_max_data *data = &frm.max_data;
qcc_recv_max_data(qc->qcc, data->max_data);
struct qf_max_data *md_frm = &frm.max_data;
qcc_recv_max_data(qc->qcc, md_frm->max_data);
}
break;
case QUIC_FT_MAX_STREAM_DATA:
if (qc->mux_state == QC_MUX_READY) {
struct qf_max_stream_data *data = &frm.max_stream_data;
if (qcc_recv_max_stream_data(qc->qcc, data->id,
data->max_stream_data)) {
struct qf_max_stream_data *msd_frm = &frm.max_stream_data;
if (qcc_recv_max_stream_data(qc->qcc, msd_frm->id,
msd_frm->max_stream_data)) {
TRACE_ERROR("qcc_recv_max_stream_data() failed", QUIC_EV_CONN_PRSHPKT, qc);
goto leave;
}
@ -7557,13 +7557,13 @@ static inline int qc_build_frms(struct list *outlist, struct list *inlist,
if (cf->stream.dup) {
struct eb64_node *node = NULL;
struct qc_stream_desc *stream_desc = NULL;
struct qf_stream *strm = &cf->stream;
struct qf_stream *strm_frm = &cf->stream;
/* As this frame has been already lost, ensure the stream is always
* available or the range of this frame is not consumed before
* resending it.
*/
node = eb64_lookup(&qc->streams_by_id, strm->id);
node = eb64_lookup(&qc->streams_by_id, strm_frm->id);
if (!node) {
TRACE_DEVEL("released stream", QUIC_EV_CONN_PRSAFRM, qc, cf);
qc_frm_free(&cf);
@ -7571,14 +7571,14 @@ static inline int qc_build_frms(struct list *outlist, struct list *inlist,
}
stream_desc = eb64_entry(node, struct qc_stream_desc, by_id);
if (strm->offset.key + strm->len <= stream_desc->ack_offset) {
if (strm_frm->offset.key + strm_frm->len <= stream_desc->ack_offset) {
TRACE_DEVEL("ignored frame frame in already acked range",
QUIC_EV_CONN_PRSAFRM, qc, cf);
qc_frm_free(&cf);
continue;
}
else if (strm->offset.key < stream_desc->ack_offset) {
uint64_t diff = stream_desc->ack_offset - strm->offset.key;
else if (strm_frm->offset.key < stream_desc->ack_offset) {
uint64_t diff = stream_desc->ack_offset - strm_frm->offset.key;
qc_stream_frm_mv_fwd(cf, diff);
TRACE_DEVEL("updated partially acked frame",

434
src/quic_frame.c
View File

@ -109,111 +109,111 @@ void chunk_frm_appendf(struct buffer *buf, const struct quic_frame *frm)
switch (frm->type) {
case QUIC_FT_CRYPTO:
{
const struct qf_crypto *cf = &frm->crypto;
const struct qf_crypto *crypto_frm = &frm->crypto;
chunk_appendf(buf, " cfoff=%llu cflen=%llu",
(ull)cf->offset, (ull)cf->len);
(ull)crypto_frm->offset, (ull)crypto_frm->len);
break;
}
case QUIC_FT_RESET_STREAM:
{
const struct qf_reset_stream *rs = &frm->reset_stream;
const struct qf_reset_stream *rs_frm = &frm->reset_stream;
chunk_appendf(buf, " id=%llu app_error_code=%llu final_size=%llu",
(ull)rs->id, (ull)rs->app_error_code, (ull)rs->final_size);
(ull)rs_frm->id, (ull)rs_frm->app_error_code, (ull)rs_frm->final_size);
break;
}
case QUIC_FT_STOP_SENDING:
{
const struct qf_stop_sending *s = &frm->stop_sending;
const struct qf_stop_sending *ss_frm = &frm->stop_sending;
chunk_appendf(&trace_buf, " id=%llu app_error_code=%llu",
(ull)s->id, (ull)s->app_error_code);
(ull)ss_frm->id, (ull)ss_frm->app_error_code);
break;
}
case QUIC_FT_STREAM_8 ... QUIC_FT_STREAM_F:
{
const struct qf_stream *s = &frm->stream;
const struct qf_stream *strm_frm = &frm->stream;
chunk_appendf(&trace_buf, " uni=%d fin=%d id=%llu off=%llu len=%llu",
!!(s->id & QUIC_STREAM_FRAME_ID_DIR_BIT),
!!(strm_frm->id & QUIC_STREAM_FRAME_ID_DIR_BIT),
!!(frm->type & QUIC_STREAM_FRAME_TYPE_FIN_BIT),
(ull)s->id, (ull)s->offset.key, (ull)s->len);
(ull)strm_frm->id, (ull)strm_frm->offset.key, (ull)strm_frm->len);
break;
}
case QUIC_FT_MAX_DATA:
{
const struct qf_max_data *s = &frm->max_data;
chunk_appendf(&trace_buf, " max_data=%llu", (ull)s->max_data);
const struct qf_max_data *md_frm = &frm->max_data;
chunk_appendf(&trace_buf, " max_data=%llu", (ull)md_frm->max_data);
break;
}
case QUIC_FT_MAX_STREAM_DATA:
{
const struct qf_max_stream_data *s = &frm->max_stream_data;
const struct qf_max_stream_data *msd_frm = &frm->max_stream_data;
chunk_appendf(&trace_buf, " id=%llu max_stream_data=%llu",
(ull)s->id, (ull)s->max_stream_data);
(ull)msd_frm->id, (ull)msd_frm->max_stream_data);
break;
}
case QUIC_FT_MAX_STREAMS_BIDI:
{
const struct qf_max_streams *s = &frm->max_streams_bidi;
chunk_appendf(&trace_buf, " max_streams=%llu", (ull)s->max_streams);
const struct qf_max_streams *ms_frm = &frm->max_streams_bidi;
chunk_appendf(&trace_buf, " max_streams=%llu", (ull)ms_frm->max_streams);
break;
}
case QUIC_FT_MAX_STREAMS_UNI:
{
const struct qf_max_streams *s = &frm->max_streams_uni;
chunk_appendf(&trace_buf, " max_streams=%llu", (ull)s->max_streams);
const struct qf_max_streams *ms_frm = &frm->max_streams_uni;
chunk_appendf(&trace_buf, " max_streams=%llu", (ull)ms_frm->max_streams);
break;
}
case QUIC_FT_DATA_BLOCKED:
{
const struct qf_data_blocked *s = &frm->data_blocked;
chunk_appendf(&trace_buf, " limit=%llu", (ull)s->limit);
const struct qf_data_blocked *db_frm = &frm->data_blocked;
chunk_appendf(&trace_buf, " limit=%llu", (ull)db_frm->limit);
break;
}
case QUIC_FT_STREAM_DATA_BLOCKED:
{
const struct qf_stream_data_blocked *s = &frm->stream_data_blocked;
const struct qf_stream_data_blocked *sdb_frm = &frm->stream_data_blocked;
chunk_appendf(&trace_buf, " id=%llu limit=%llu",
(ull)s->id, (ull)s->limit);
(ull)sdb_frm->id, (ull)sdb_frm->limit);
break;
}
case QUIC_FT_STREAMS_BLOCKED_BIDI:
{
const struct qf_streams_blocked *s = &frm->streams_blocked_bidi;
chunk_appendf(&trace_buf, " limit=%llu", (ull)s->limit);
const struct qf_streams_blocked *sb_frm = &frm->streams_blocked_bidi;
chunk_appendf(&trace_buf, " limit=%llu", (ull)sb_frm->limit);
break;
}
case QUIC_FT_STREAMS_BLOCKED_UNI:
{
const struct qf_streams_blocked *s = &frm->streams_blocked_uni;
chunk_appendf(&trace_buf, " limit=%llu", (ull)s->limit);
const struct qf_streams_blocked *sb_frm = &frm->streams_blocked_uni;
chunk_appendf(&trace_buf, " limit=%llu", (ull)sb_frm->limit);
break;
}
case QUIC_FT_RETIRE_CONNECTION_ID:
{
const struct qf_retire_connection_id *rci = &frm->retire_connection_id;
chunk_appendf(&trace_buf, " seq_num=%llu", (ull)rci->seq_num);
const struct qf_retire_connection_id *rcid_frm = &frm->retire_connection_id;
chunk_appendf(&trace_buf, " seq_num=%llu", (ull)rcid_frm->seq_num);
break;
}
case QUIC_FT_CONNECTION_CLOSE:
{
const struct qf_connection_close *cc = &frm->connection_close;
size_t plen = QUIC_MIN((size_t)cc->reason_phrase_len, sizeof cc->reason_phrase);
const struct qf_connection_close *cc_frm = &frm->connection_close;
size_t plen = QUIC_MIN((size_t)cc_frm->reason_phrase_len, sizeof cc_frm->reason_phrase);
chunk_appendf(&trace_buf,
" error_code=%llu frame_type=%llu reason_phrase_len=%llu",
(ull)cc->error_code, (ull)cc->frame_type,
(ull)cc->reason_phrase_len);
(ull)cc_frm->error_code, (ull)cc_frm->frame_type,
(ull)cc_frm->reason_phrase_len);
if (plen)
chunk_cc_phrase_appendf(&trace_buf, cc->reason_phrase, plen);
chunk_cc_phrase_appendf(&trace_buf, cc_frm->reason_phrase, plen);
break;
}
case QUIC_FT_CONNECTION_CLOSE_APP:
{
const struct qf_connection_close_app *cc = &frm->connection_close_app;
size_t plen = QUIC_MIN((size_t)cc->reason_phrase_len, sizeof cc->reason_phrase);
const struct qf_connection_close_app *cc_frm = &frm->connection_close_app;
size_t plen = QUIC_MIN((size_t)cc_frm->reason_phrase_len, sizeof cc_frm->reason_phrase);
chunk_appendf(&trace_buf,
" error_code=%llu reason_phrase_len=%llu",
(ull)cc->error_code, (ull)cc->reason_phrase_len);
(ull)cc_frm->error_code, (ull)cc_frm->reason_phrase_len);
if (plen)
chunk_cc_phrase_appendf(&trace_buf, cc->reason_phrase, plen);
chunk_cc_phrase_appendf(&trace_buf, cc_frm->reason_phrase, plen);
break;
}
}
@ -225,13 +225,13 @@ void chunk_frm_appendf(struct buffer *buf, const struct quic_frame *frm)
static int quic_build_padding_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_padding *padding = &frm->padding;
struct qf_padding *padding_frm = &frm->padding;
if (end - *buf < padding->len - 1)
if (end - *buf < padding_frm->len - 1)
return 0;
memset(*buf, 0, padding->len - 1);
*buf += padding->len - 1;
memset(*buf, 0, padding_frm->len - 1);
*buf += padding_frm->len - 1;
return 1;
}
@ -243,13 +243,13 @@ static int quic_parse_padding_frame(struct quic_frame *frm, struct quic_conn *qc
const unsigned char **buf, const unsigned char *end)
{
const unsigned char *beg;
struct qf_padding *padding = &frm->padding;
struct qf_padding *padding_frm = &frm->padding;
beg = *buf;
padding->len = 1;
padding_frm->len = 1;
while (*buf < end && !**buf)
(*buf)++;
padding->len += *buf - beg;
padding_frm->len += *buf - beg;
return 1;
}
@ -280,17 +280,17 @@ static int quic_parse_ping_frame(struct quic_frame *frm, struct quic_conn *qc,
static int quic_build_ack_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *qc)
{
struct qf_tx_ack *tx_ack = &frm->tx_ack;
struct qf_tx_ack *ack_frm = &frm->tx_ack;
struct eb64_node *ar, *prev_ar;
struct quic_arng_node *ar_node, *prev_ar_node;
ar = eb64_last(&tx_ack->arngs->root);
ar = eb64_last(&ack_frm->arngs->root);
ar_node = eb64_entry(ar, struct quic_arng_node, first);
TRACE_PROTO("TX ack range", QUIC_EV_CONN_PRSAFRM,
qc,, &ar_node->last, &ar_node->first.key);
if (!quic_enc_int(buf, end, ar_node->last) ||
!quic_enc_int(buf, end, tx_ack->ack_delay) ||
!quic_enc_int(buf, end, tx_ack->arngs->sz - 1) ||
!quic_enc_int(buf, end, ack_frm->ack_delay) ||
!quic_enc_int(buf, end, ack_frm->arngs->sz - 1) ||
!quic_enc_int(buf, end, ar_node->last - ar_node->first.key))
return 0;
@ -316,21 +316,21 @@ static int quic_parse_ack_frame_header(struct quic_frame *frm, struct quic_conn
const unsigned char **buf, const unsigned char *end)
{
int ret;
struct qf_ack *ack = &frm->ack;
struct qf_ack *ack_frm = &frm->ack;
ret = quic_dec_int(&ack->largest_ack, buf, end);
ret = quic_dec_int(&ack_frm->largest_ack, buf, end);
if (!ret)
return 0;
ret = quic_dec_int(&ack->ack_delay, buf, end);
ret = quic_dec_int(&ack_frm->ack_delay, buf, end);
if (!ret)
return 0;
ret = quic_dec_int(&ack->ack_range_num, buf, end);
ret = quic_dec_int(&ack_frm->ack_range_num, buf, end);
if (!ret)
return 0;
ret = quic_dec_int(&ack->first_ack_range, buf, end);
ret = quic_dec_int(&ack_frm->first_ack_range, buf, end);
if (!ret)
return 0;
@ -343,12 +343,12 @@ static int quic_parse_ack_frame_header(struct quic_frame *frm, struct quic_conn
static int quic_build_ack_ecn_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_ack *ack = &frm->ack;
struct qf_ack *ack_frm = &frm->ack;
return quic_enc_int(buf, end, ack->largest_ack) &&
quic_enc_int(buf, end, ack->ack_delay) &&
quic_enc_int(buf, end, ack->first_ack_range) &&
quic_enc_int(buf, end, ack->ack_range_num);
return quic_enc_int(buf, end, ack_frm->largest_ack) &&
quic_enc_int(buf, end, ack_frm->ack_delay) &&
quic_enc_int(buf, end, ack_frm->first_ack_range) &&
quic_enc_int(buf, end, ack_frm->ack_range_num);
}
/* Parse an ACK_ECN frame from <buf> buffer with <end> as end into <frm> frame.
@ -357,12 +357,12 @@ static int quic_build_ack_ecn_frame(unsigned char **buf, const unsigned char *en
static int quic_parse_ack_ecn_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_ack *ack = &frm->ack;
struct qf_ack *ack_frm = &frm->ack;
return quic_dec_int(&ack->largest_ack, buf, end) &&
quic_dec_int(&ack->ack_delay, buf, end) &&
quic_dec_int(&ack->first_ack_range, buf, end) &&
quic_dec_int(&ack->ack_range_num, buf, end);
return quic_dec_int(&ack_frm->largest_ack, buf, end) &&
quic_dec_int(&ack_frm->ack_delay, buf, end) &&
quic_dec_int(&ack_frm->first_ack_range, buf, end) &&
quic_dec_int(&ack_frm->ack_range_num, buf, end);
}
/* Encode a RESET_STREAM frame into <buf> buffer.
@ -371,11 +371,11 @@ static int quic_parse_ack_ecn_frame(struct quic_frame *frm, struct quic_conn *qc
static int quic_build_reset_stream_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_reset_stream *reset_stream = &frm->reset_stream;
struct qf_reset_stream *rs_frm = &frm->reset_stream;
return quic_enc_int(buf, end, reset_stream->id) &&
quic_enc_int(buf, end, reset_stream->app_error_code) &&
quic_enc_int(buf, end, reset_stream->final_size);
return quic_enc_int(buf, end, rs_frm->id) &&
quic_enc_int(buf, end, rs_frm->app_error_code) &&
quic_enc_int(buf, end, rs_frm->final_size);
}
/* Parse a RESET_STREAM frame from <buf> buffer with <end> as end into <frm> frame.
@ -384,11 +384,11 @@ static int quic_build_reset_stream_frame(unsigned char **buf, const unsigned cha
static int quic_parse_reset_stream_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_reset_stream *reset_stream = &frm->reset_stream;
struct qf_reset_stream *rs_frm = &frm->reset_stream;
return quic_dec_int(&reset_stream->id, buf, end) &&
quic_dec_int(&reset_stream->app_error_code, buf, end) &&
quic_dec_int(&reset_stream->final_size, buf, end);
return quic_dec_int(&rs_frm->id, buf, end) &&
quic_dec_int(&rs_frm->app_error_code, buf, end) &&
quic_dec_int(&rs_frm->final_size, buf, end);
}
/* Encode a STOP_SENDING frame.
@ -397,10 +397,10 @@ static int quic_parse_reset_stream_frame(struct quic_frame *frm, struct quic_con
static int quic_build_stop_sending_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_stop_sending *stop_sending = &frm->stop_sending;
struct qf_stop_sending *ss_frm = &frm->stop_sending;
return quic_enc_int(buf, end, stop_sending->id) &&
quic_enc_int(buf, end, stop_sending->app_error_code);
return quic_enc_int(buf, end, ss_frm->id) &&
quic_enc_int(buf, end, ss_frm->app_error_code);
}
/* Parse a STOP_SENDING frame from <buf> buffer with <end> as end into <frm> frame.
@ -409,10 +409,10 @@ static int quic_build_stop_sending_frame(unsigned char **buf, const unsigned cha
static int quic_parse_stop_sending_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_stop_sending *stop_sending = &frm->stop_sending;
struct qf_stop_sending *ss_frm = &frm->stop_sending;
return quic_dec_int(&stop_sending->id, buf, end) &&
quic_dec_int(&stop_sending->app_error_code, buf, end);
return quic_dec_int(&ss_frm->id, buf, end) &&
quic_dec_int(&ss_frm->app_error_code, buf, end);
}
/* Encode a CRYPTO frame into <buf> buffer.
@ -421,16 +421,16 @@ static int quic_parse_stop_sending_frame(struct quic_frame *frm, struct quic_con
static int quic_build_crypto_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_crypto *crypto = &frm->crypto;
const struct quic_enc_level *qel = crypto->qel;
struct qf_crypto *crypto_frm = &frm->crypto;
const struct quic_enc_level *qel = crypto_frm->qel;
size_t offset, len;
if (!quic_enc_int(buf, end, crypto->offset) ||
!quic_enc_int(buf, end, crypto->len) || end - *buf < crypto->len)
if (!quic_enc_int(buf, end, crypto_frm->offset) ||
!quic_enc_int(buf, end, crypto_frm->len) || end - *buf < crypto_frm->len)
return 0;
len = crypto->len;
offset = crypto->offset;
len = crypto_frm->len;
offset = crypto_frm->offset;
while (len) {
int idx;
size_t to_copy;
@ -456,14 +456,14 @@ static int quic_build_crypto_frame(unsigned char **buf, const unsigned char *end
static int quic_parse_crypto_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_crypto *crypto = &frm->crypto;
struct qf_crypto *crypto_frm = &frm->crypto;
if (!quic_dec_int(&crypto->offset, buf, end) ||
!quic_dec_int(&crypto->len, buf, end) || end - *buf < crypto->len)
if (!quic_dec_int(&crypto_frm->offset, buf, end) ||
!quic_dec_int(&crypto_frm->len, buf, end) || end - *buf < crypto_frm->len)
return 0;
crypto->data = *buf;
*buf += crypto->len;
crypto_frm->data = *buf;
*buf += crypto_frm->len;
return 1;
}
@ -474,12 +474,12 @@ static int quic_parse_crypto_frame(struct quic_frame *frm, struct quic_conn *qc,
static int quic_build_new_token_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_new_token *new_token = &frm->new_token;
struct qf_new_token *new_token_frm = &frm->new_token;
if (!quic_enc_int(buf, end, new_token->len) || end - *buf < new_token->len)
if (!quic_enc_int(buf, end, new_token_frm->len) || end - *buf < new_token_frm->len)
return 0;
memcpy(*buf, new_token->data, new_token->len);
memcpy(*buf, new_token_frm->data, new_token_frm->len);
return 1;
}
@ -490,13 +490,13 @@ static int quic_build_new_token_frame(unsigned char **buf, const unsigned char *
static int quic_parse_new_token_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_new_token *new_token = &frm->new_token;
struct qf_new_token *new_token_frm = &frm->new_token;
if (!quic_dec_int(&new_token->len, buf, end) || end - *buf < new_token->len)
if (!quic_dec_int(&new_token_frm->len, buf, end) || end - *buf < new_token_frm->len)
return 0;
new_token->data = *buf;
*buf += new_token->len;
new_token_frm->data = *buf;
*buf += new_token_frm->len;
return 1;
}
@ -507,32 +507,32 @@ static int quic_parse_new_token_frame(struct quic_frame *frm, struct quic_conn *
static int quic_build_stream_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_stream *stream = &frm->stream;
struct qf_stream *strm_frm = &frm->stream;
const unsigned char *wrap;
/* Caller must set OFF bit if and only if a non-null offset is used. */
BUG_ON(!!(frm->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT) !=
!!stream->offset.key);
!!strm_frm->offset.key);
if (!quic_enc_int(buf, end, stream->id) ||
((frm->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT) && !quic_enc_int(buf, end, stream->offset.key)) ||
if (!quic_enc_int(buf, end, strm_frm->id) ||
((frm->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT) && !quic_enc_int(buf, end, strm_frm->offset.key)) ||
((frm->type & QUIC_STREAM_FRAME_TYPE_LEN_BIT) &&
(!quic_enc_int(buf, end, stream->len) || end - *buf < stream->len)))
(!quic_enc_int(buf, end, strm_frm->len) || end - *buf < strm_frm->len)))
return 0;
wrap = (const unsigned char *)b_wrap(stream->buf);
if (stream->data + stream->len > wrap) {
size_t to_copy = wrap - stream->data;
memcpy(*buf, stream->data, to_copy);
wrap = (const unsigned char *)b_wrap(strm_frm->buf);
if (strm_frm->data + strm_frm->len > wrap) {
size_t to_copy = wrap - strm_frm->data;
memcpy(*buf, strm_frm->data, to_copy);
*buf += to_copy;
to_copy = stream->len - to_copy;
memcpy(*buf, b_orig(stream->buf), to_copy);
to_copy = strm_frm->len - to_copy;
memcpy(*buf, b_orig(strm_frm->buf), to_copy);
*buf += to_copy;
}
else {
memcpy(*buf, stream->data, stream->len);
*buf += stream->len;
memcpy(*buf, strm_frm->data, strm_frm->len);
*buf += strm_frm->len;
}
return 1;
@ -544,27 +544,27 @@ static int quic_build_stream_frame(unsigned char **buf, const unsigned char *end
static int quic_parse_stream_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_stream *stream = &frm->stream;
struct qf_stream *strm_frm = &frm->stream;
if (!quic_dec_int(&stream->id, buf, end))
if (!quic_dec_int(&strm_frm->id, buf, end))
return 0;
/* Offset parsing */
if (!(frm->type & QUIC_STREAM_FRAME_TYPE_OFF_BIT)) {
stream->offset.key = 0;
strm_frm->offset.key = 0;
}
else if (!quic_dec_int((uint64_t *)&stream->offset.key, buf, end))
else if (!quic_dec_int((uint64_t *)&strm_frm->offset.key, buf, end))
return 0;
/* Length parsing */
if (!(frm->type & QUIC_STREAM_FRAME_TYPE_LEN_BIT)) {
stream->len = end - *buf;
strm_frm->len = end - *buf;
}
else if (!quic_dec_int(&stream->len, buf, end) || end - *buf < stream->len)
else if (!quic_dec_int(&strm_frm->len, buf, end) || end - *buf < strm_frm->len)
return 0;
stream->data = *buf;
*buf += stream->len;
strm_frm->data = *buf;
*buf += strm_frm->len;
return 1;
}
@ -575,9 +575,9 @@ static int quic_parse_stream_frame(struct quic_frame *frm, struct quic_conn *qc,
static int quic_build_max_data_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_max_data *max_data = &frm->max_data;
struct qf_max_data *md_frm = &frm->max_data;
return quic_enc_int(buf, end, max_data->max_data);
return quic_enc_int(buf, end, md_frm->max_data);
}
/* Parse a MAX_DATA frame from <buf> buffer with <end> as end into <frm> frame.
@ -586,9 +586,9 @@ static int quic_build_max_data_frame(unsigned char **buf, const unsigned char *e
static int quic_parse_max_data_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_max_data *max_data = &frm->max_data;
struct qf_max_data *md_frm = &frm->max_data;
return quic_dec_int(&max_data->max_data, buf, end);
return quic_dec_int(&md_frm->max_data, buf, end);
}
/* Encode a MAX_STREAM_DATA frame into <buf> buffer.
@ -597,10 +597,10 @@ static int quic_parse_max_data_frame(struct quic_frame *frm, struct quic_conn *q
static int quic_build_max_stream_data_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_max_stream_data *max_stream_data = &frm->max_stream_data;
struct qf_max_stream_data *msd_frm = &frm->max_stream_data;
return quic_enc_int(buf, end, max_stream_data->id) &&
quic_enc_int(buf, end, max_stream_data->max_stream_data);
return quic_enc_int(buf, end, msd_frm->id) &&
quic_enc_int(buf, end, msd_frm->max_stream_data);
}
/* Parse a MAX_STREAM_DATA frame from <buf> buffer with <end> as end into <frm> frame.
@ -609,10 +609,10 @@ static int quic_build_max_stream_data_frame(unsigned char **buf, const unsigned
static int quic_parse_max_stream_data_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_max_stream_data *max_stream_data = &frm->max_stream_data;
struct qf_max_stream_data *msd_frm = &frm->max_stream_data;
return quic_dec_int(&max_stream_data->id, buf, end) &&
quic_dec_int(&max_stream_data->max_stream_data, buf, end);
return quic_dec_int(&msd_frm->id, buf, end) &&
quic_dec_int(&msd_frm->max_stream_data, buf, end);
}
/* Encode a MAX_STREAMS frame for bidirectional streams into <buf> buffer.
@ -621,9 +621,9 @@ static int quic_parse_max_stream_data_frame(struct quic_frame *frm, struct quic_
static int quic_build_max_streams_bidi_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_max_streams *max_streams_bidi = &frm->max_streams_bidi;
struct qf_max_streams *ms_frm = &frm->max_streams_bidi;
return quic_enc_int(buf, end, max_streams_bidi->max_streams);
return quic_enc_int(buf, end, ms_frm->max_streams);
}
/* Parse a MAX_STREAMS frame for bidirectional streams from <buf> buffer with <end>
@ -633,9 +633,9 @@ static int quic_build_max_streams_bidi_frame(unsigned char **buf, const unsigned
static int quic_parse_max_streams_bidi_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_max_streams *max_streams_bidi = &frm->max_streams_bidi;
struct qf_max_streams *ms_frm = &frm->max_streams_bidi;
return quic_dec_int(&max_streams_bidi->max_streams, buf, end);
return quic_dec_int(&ms_frm->max_streams, buf, end);
}
/* Encode a MAX_STREAMS frame for unidirectional streams into <buf> buffer.
@ -644,9 +644,9 @@ static int quic_parse_max_streams_bidi_frame(struct quic_frame *frm, struct quic
static int quic_build_max_streams_uni_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_max_streams *max_streams_uni = &frm->max_streams_uni;
struct qf_max_streams *ms_frm = &frm->max_streams_uni;
return quic_enc_int(buf, end, max_streams_uni->max_streams);
return quic_enc_int(buf, end, ms_frm->max_streams);
}
/* Parse a MAX_STREAMS frame for undirectional streams from <buf> buffer with <end>
@ -656,9 +656,9 @@ static int quic_build_max_streams_uni_frame(unsigned char **buf, const unsigned
static int quic_parse_max_streams_uni_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_max_streams *max_streams_uni = &frm->max_streams_uni;
struct qf_max_streams *ms_frm = &frm->max_streams_uni;
return quic_dec_int(&max_streams_uni->max_streams, buf, end);
return quic_dec_int(&ms_frm->max_streams, buf, end);
}
/* Encode a DATA_BLOCKED frame into <buf> buffer.
@ -667,9 +667,9 @@ static int quic_parse_max_streams_uni_frame(struct quic_frame *frm, struct quic_
static int quic_build_data_blocked_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_data_blocked *data_blocked = &frm->data_blocked;
struct qf_data_blocked *db_frm = &frm->data_blocked;
return quic_enc_int(buf, end, data_blocked->limit);
return quic_enc_int(buf, end, db_frm->limit);
}
/* Parse a DATA_BLOCKED frame from <buf> buffer with <end> as end into <frm> frame.
@ -678,9 +678,9 @@ static int quic_build_data_blocked_frame(unsigned char **buf, const unsigned cha
static int quic_parse_data_blocked_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_data_blocked *data_blocked = &frm->data_blocked;
struct qf_data_blocked *db_frm = &frm->data_blocked;
return quic_dec_int(&data_blocked->limit, buf, end);
return quic_dec_int(&db_frm->limit, buf, end);
}
/* Encode a STREAM_DATA_BLOCKED into <buf> buffer.
@ -689,10 +689,10 @@ static int quic_parse_data_blocked_frame(struct quic_frame *frm, struct quic_con
static int quic_build_stream_data_blocked_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_stream_data_blocked *stream_data_blocked = &frm->stream_data_blocked;
struct qf_stream_data_blocked *sdb_frm = &frm->stream_data_blocked;
return quic_enc_int(buf, end, stream_data_blocked->id) &&
quic_enc_int(buf, end, stream_data_blocked->limit);
return quic_enc_int(buf, end, sdb_frm->id) &&
quic_enc_int(buf, end, sdb_frm->limit);
}
/* Parse a STREAM_DATA_BLOCKED frame from <buf> buffer with <end> as end into <frm> frame.
@ -701,10 +701,10 @@ static int quic_build_stream_data_blocked_frame(unsigned char **buf, const unsig
static int quic_parse_stream_data_blocked_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_stream_data_blocked *stream_data_blocked = &frm->stream_data_blocked;
struct qf_stream_data_blocked *sdb_frm = &frm->stream_data_blocked;
return quic_dec_int(&stream_data_blocked->id, buf, end) &&
quic_dec_int(&stream_data_blocked->limit, buf, end);
return quic_dec_int(&sdb_frm->id, buf, end) &&
quic_dec_int(&sdb_frm->limit, buf, end);
}
/* Encode a STREAMS_BLOCKED frame for bidirectional streams into <buf> buffer.
@ -713,9 +713,9 @@ static int quic_parse_stream_data_blocked_frame(struct quic_frame *frm, struct q
static int quic_build_streams_blocked_bidi_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_streams_blocked *streams_blocked_bidi = &frm->streams_blocked_bidi;
struct qf_streams_blocked *sb_frm = &frm->streams_blocked_bidi;
return quic_enc_int(buf, end, streams_blocked_bidi->limit);
return quic_enc_int(buf, end, sb_frm->limit);
}
/* Parse a STREAMS_BLOCKED frame for bidirectional streams from <buf> buffer with <end>
@ -725,9 +725,9 @@ static int quic_build_streams_blocked_bidi_frame(unsigned char **buf, const unsi
static int quic_parse_streams_blocked_bidi_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_streams_blocked *streams_blocked_bidi = &frm->streams_blocked_bidi;
struct qf_streams_blocked *sb_frm = &frm->streams_blocked_bidi;
return quic_dec_int(&streams_blocked_bidi->limit, buf, end);
return quic_dec_int(&sb_frm->limit, buf, end);
}
/* Encode a STREAMS_BLOCKED frame for unidirectional streams into <buf> buffer.
@ -736,9 +736,9 @@ static int quic_parse_streams_blocked_bidi_frame(struct quic_frame *frm, struct
static int quic_build_streams_blocked_uni_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_streams_blocked *streams_blocked_uni = &frm->streams_blocked_uni;
struct qf_streams_blocked *sb_frm = &frm->streams_blocked_uni;
return quic_enc_int(buf, end, streams_blocked_uni->limit);
return quic_enc_int(buf, end, sb_frm->limit);
}
/* Parse a STREAMS_BLOCKED frame for unidirectional streams from <buf> buffer with <end>
@ -748,9 +748,9 @@ static int quic_build_streams_blocked_uni_frame(unsigned char **buf, const unsig
static int quic_parse_streams_blocked_uni_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_streams_blocked *streams_blocked_uni = &frm->streams_blocked_uni;
struct qf_streams_blocked *sb_frm = &frm->streams_blocked_uni;
return quic_dec_int(&streams_blocked_uni->limit, buf, end);
return quic_dec_int(&sb_frm->limit, buf, end);
}
/* Encode a NEW_CONNECTION_ID frame into <buf> buffer.
@ -759,20 +759,20 @@ static int quic_parse_streams_blocked_uni_frame(struct quic_frame *frm, struct q
static int quic_build_new_connection_id_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_new_connection_id *new_cid = &frm->new_connection_id;
struct qf_new_connection_id *ncid_frm = &frm->new_connection_id;
if (!quic_enc_int(buf, end, new_cid->seq_num) ||
!quic_enc_int(buf, end, new_cid->retire_prior_to) ||
end - *buf < sizeof new_cid->cid.len + new_cid->cid.len + QUIC_STATELESS_RESET_TOKEN_LEN)
if (!quic_enc_int(buf, end, ncid_frm->seq_num) ||
!quic_enc_int(buf, end, ncid_frm->retire_prior_to) ||
end - *buf < sizeof ncid_frm->cid.len + ncid_frm->cid.len + QUIC_STATELESS_RESET_TOKEN_LEN)
return 0;
*(*buf)++ = new_cid->cid.len;
*(*buf)++ = ncid_frm->cid.len;
if (new_cid->cid.len) {
memcpy(*buf, new_cid->cid.data, new_cid->cid.len);
*buf += new_cid->cid.len;
if (ncid_frm->cid.len) {
memcpy(*buf, ncid_frm->cid.data, ncid_frm->cid.len);
*buf += ncid_frm->cid.len;
}
memcpy(*buf, new_cid->stateless_reset_token, QUIC_STATELESS_RESET_TOKEN_LEN);
memcpy(*buf, ncid_frm->stateless_reset_token, QUIC_STATELESS_RESET_TOKEN_LEN);
*buf += QUIC_STATELESS_RESET_TOKEN_LEN;
return 1;
@ -784,21 +784,21 @@ static int quic_build_new_connection_id_frame(unsigned char **buf, const unsigne
static int quic_parse_new_connection_id_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_new_connection_id *new_cid = &frm->new_connection_id;
struct qf_new_connection_id *ncid_frm = &frm->new_connection_id;
if (!quic_dec_int(&new_cid->seq_num, buf, end) ||
!quic_dec_int(&new_cid->retire_prior_to, buf, end) || end <= *buf)
if (!quic_dec_int(&ncid_frm->seq_num, buf, end) ||
!quic_dec_int(&ncid_frm->retire_prior_to, buf, end) || end <= *buf)
return 0;
new_cid->cid.len = *(*buf)++;
if (end - *buf < new_cid->cid.len + QUIC_STATELESS_RESET_TOKEN_LEN)
ncid_frm->cid.len = *(*buf)++;
if (end - *buf < ncid_frm->cid.len + QUIC_STATELESS_RESET_TOKEN_LEN)
return 0;
if (new_cid->cid.len) {
new_cid->cid.data = *buf;
*buf += new_cid->cid.len;
if (ncid_frm->cid.len) {
ncid_frm->cid.data = *buf;
*buf += ncid_frm->cid.len;
}
new_cid->stateless_reset_token = *buf;
ncid_frm->stateless_reset_token = *buf;
*buf += QUIC_STATELESS_RESET_TOKEN_LEN;
return 1;
@ -810,9 +810,9 @@ static int quic_parse_new_connection_id_frame(struct quic_frame *frm, struct qui
static int quic_build_retire_connection_id_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_retire_connection_id *retire_connection_id = &frm->retire_connection_id;
struct qf_retire_connection_id *rcid_frm = &frm->retire_connection_id;
return quic_enc_int(buf, end, retire_connection_id->seq_num);
return quic_enc_int(buf, end, rcid_frm->seq_num);
}
/* Parse a RETIRE_CONNECTION_ID frame from <buf> buffer with <end> as end into <frm> frame.
@ -821,9 +821,9 @@ static int quic_build_retire_connection_id_frame(unsigned char **buf, const unsi
static int quic_parse_retire_connection_id_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_retire_connection_id *retire_connection_id = &frm->retire_connection_id;
struct qf_retire_connection_id *rcid_frm = &frm->retire_connection_id;
return quic_dec_int(&retire_connection_id->seq_num, buf, end);
return quic_dec_int(&rcid_frm->seq_num, buf, end);
}
/* Encode a PATH_CHALLENGE frame into <buf> buffer.
@ -832,13 +832,13 @@ static int quic_parse_retire_connection_id_frame(struct quic_frame *frm, struct
static int quic_build_path_challenge_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_path_challenge *path_challenge = &frm->path_challenge;
struct qf_path_challenge *pc_frm = &frm->path_challenge;
if (end - *buf < sizeof path_challenge->data)
if (end - *buf < sizeof pc_frm->data)
return 0;
memcpy(*buf, path_challenge->data, sizeof path_challenge->data);
*buf += sizeof path_challenge->data;
memcpy(*buf, pc_frm->data, sizeof pc_frm->data);
*buf += sizeof pc_frm->data;
return 1;
}
@ -849,13 +849,13 @@ static int quic_build_path_challenge_frame(unsigned char **buf, const unsigned c
static int quic_parse_path_challenge_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_path_challenge *path_challenge = &frm->path_challenge;
struct qf_path_challenge *pc_frm = &frm->path_challenge;
if (end - *buf < sizeof path_challenge->data)
if (end - *buf < sizeof pc_frm->data)
return 0;
memcpy(path_challenge->data, *buf, sizeof path_challenge->data);
*buf += sizeof path_challenge->data;
memcpy(pc_frm->data, *buf, sizeof pc_frm->data);
*buf += sizeof pc_frm->data;
return 1;
}
@ -867,13 +867,13 @@ static int quic_parse_path_challenge_frame(struct quic_frame *frm, struct quic_c
static int quic_build_path_response_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_path_challenge_response *path_challenge_response = &frm->path_challenge_response;
struct qf_path_challenge_response *pcr_frm = &frm->path_challenge_response;
if (end - *buf < sizeof path_challenge_response->data)
if (end - *buf < sizeof pcr_frm->data)
return 0;
memcpy(*buf, path_challenge_response->data, sizeof path_challenge_response->data);
*buf += sizeof path_challenge_response->data;
memcpy(*buf, pcr_frm->data, sizeof pcr_frm->data);
*buf += sizeof pcr_frm->data;
return 1;
}
@ -884,13 +884,13 @@ static int quic_build_path_response_frame(unsigned char **buf, const unsigned ch
static int quic_parse_path_response_frame(struct quic_frame *frm, struct quic_conn *qc,
const unsigned char **buf, const unsigned char *end)
{
struct qf_path_challenge_response *path_challenge_response = &frm->path_challenge_response;
struct qf_path_challenge_response *pcr_frm = &frm->path_challenge_response;
if (end - *buf < sizeof path_challenge_response->data)
if (end - *buf < sizeof pcr_frm->data)
return 0;
memcpy(path_challenge_response->data, *buf, sizeof path_challenge_response->data);
*buf += sizeof path_challenge_response->data;
memcpy(pcr_frm->data, *buf, sizeof pcr_frm->data);
*buf += sizeof pcr_frm->data;
return 1;
}
@ -903,16 +903,16 @@ static int quic_parse_path_response_frame(struct quic_frame *frm, struct quic_co
static int quic_build_connection_close_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_connection_close *cc = &frm->connection_close;
struct qf_connection_close *cc_frm = &frm->connection_close;
if (!quic_enc_int(buf, end, cc->error_code) ||
!quic_enc_int(buf, end, cc->frame_type) ||
!quic_enc_int(buf, end, cc->reason_phrase_len) ||
end - *buf < cc->reason_phrase_len)
if (!quic_enc_int(buf, end, cc_frm->error_code) ||
!quic_enc_int(buf, end, cc_frm->frame_type) ||
!quic_enc_int(buf, end, cc_frm->reason_phrase_len) ||
end - *buf < cc_frm->reason_phrase_len)
return 0;
memcpy(*buf, cc->reason_phrase, cc->reason_phrase_len);
*buf += cc->reason_phrase_len;
memcpy(*buf, cc_frm->reason_phrase, cc_frm->reason_phrase_len);
*buf += cc_frm->reason_phrase_len;
return 1;
}
@ -926,17 +926,17 @@ static int quic_parse_connection_close_frame(struct quic_frame *frm, struct quic
const unsigned char **buf, const unsigned char *end)
{
size_t plen;
struct qf_connection_close *cc = &frm->connection_close;
struct qf_connection_close *cc_frm = &frm->connection_close;
if (!quic_dec_int(&cc->error_code, buf, end) ||
!quic_dec_int(&cc->frame_type, buf, end) ||
!quic_dec_int(&cc->reason_phrase_len, buf, end) ||
end - *buf < cc->reason_phrase_len)
if (!quic_dec_int(&cc_frm->error_code, buf, end) ||
!quic_dec_int(&cc_frm->frame_type, buf, end) ||
!quic_dec_int(&cc_frm->reason_phrase_len, buf, end) ||
end - *buf < cc_frm->reason_phrase_len)
return 0;
plen = QUIC_MIN((size_t)cc->reason_phrase_len, sizeof cc->reason_phrase);
memcpy(cc->reason_phrase, *buf, plen);
*buf += cc->reason_phrase_len;
plen = QUIC_MIN((size_t)cc_frm->reason_phrase_len, sizeof cc_frm->reason_phrase);
memcpy(cc_frm->reason_phrase, *buf, plen);
*buf += cc_frm->reason_phrase_len;
return 1;
}
@ -949,15 +949,15 @@ static int quic_parse_connection_close_frame(struct quic_frame *frm, struct quic
static int quic_build_connection_close_app_frame(unsigned char **buf, const unsigned char *end,
struct quic_frame *frm, struct quic_conn *conn)
{
struct qf_connection_close_app *cc = &frm->connection_close_app;
struct qf_connection_close_app *cc_frm = &frm->connection_close_app;
if (!quic_enc_int(buf, end, cc->error_code) ||
!quic_enc_int(buf, end, cc->reason_phrase_len) ||
end - *buf < cc->reason_phrase_len)
if (!quic_enc_int(buf, end, cc_frm->error_code) ||
!quic_enc_int(buf, end, cc_frm->reason_phrase_len) ||
end - *buf < cc_frm->reason_phrase_len)
return 0;
memcpy(*buf, cc->reason_phrase, cc->reason_phrase_len);
*buf += cc->reason_phrase_len;
memcpy(*buf, cc_frm->reason_phrase, cc_frm->reason_phrase_len);
*buf += cc_frm->reason_phrase_len;
return 1;
}
@ -971,16 +971,16 @@ static int quic_parse_connection_close_app_frame(struct quic_frame *frm, struct
const unsigned char **buf, const unsigned char *end)
{
size_t plen;
struct qf_connection_close_app *cc = &frm->connection_close_app;
struct qf_connection_close_app *cc_frm = &frm->connection_close_app;
if (!quic_dec_int(&cc->error_code, buf, end) ||
!quic_dec_int(&cc->reason_phrase_len, buf, end) ||
end - *buf < cc->reason_phrase_len)
if (!quic_dec_int(&cc_frm->error_code, buf, end) ||
!quic_dec_int(&cc_frm->reason_phrase_len, buf, end) ||
end - *buf < cc_frm->reason_phrase_len)
return 0;
plen = QUIC_MIN((size_t)cc->reason_phrase_len, sizeof cc->reason_phrase);
memcpy(cc->reason_phrase, *buf, plen);
*buf += cc->reason_phrase_len;
plen = QUIC_MIN((size_t)cc_frm->reason_phrase_len, sizeof cc_frm->reason_phrase);
memcpy(cc_frm->reason_phrase, *buf, plen);
*buf += cc_frm->reason_phrase_len;
return 1;
}

8
src/quic_stream.c
View File

@ -189,15 +189,15 @@ void qc_stream_desc_free(struct qc_stream_desc *stream, int closing)
*/
frm_node = eb64_first(&stream->acked_frms);
while (frm_node) {
struct qf_stream *strm;
struct qf_stream *strm_frm;
struct quic_frame *frm;
strm = eb64_entry(frm_node, struct qf_stream, offset);
strm_frm = eb64_entry(frm_node, struct qf_stream, offset);
frm_node = eb64_next(frm_node);
eb64_delete(&strm->offset);
eb64_delete(&strm_frm->offset);
frm = container_of(strm, struct quic_frame, stream);
frm = container_of(strm_frm, struct quic_frame, stream);
qc_release_frm(qc, frm);
}