diff --git a/include/haproxy/mux_quic-t.h b/include/haproxy/mux_quic-t.h index 6cf488e2c..02db4e8a5 100644 --- a/include/haproxy/mux_quic-t.h +++ b/include/haproxy/mux_quic-t.h @@ -46,6 +46,8 @@ struct qcc { enum qcc_app_st app_st; /* application layer state */ int glitches; /* total number of glitches on this connection */ + uint32_t term_evts_log; /* termination events log */ + /* flow-control fields set by us enforced on our side. */ struct { struct list frms; /* prepared frames related to flow-control */ diff --git a/include/haproxy/mux_quic.h b/include/haproxy/mux_quic.h index 31332ea5c..c2cad1536 100644 --- a/include/haproxy/mux_quic.h +++ b/include/haproxy/mux_quic.h @@ -20,7 +20,8 @@ _qcc_report_glitch(qcc, inc); \ }) -void qcc_set_error(struct qcc *qcc, int err, int app); +void qcc_set_error(struct qcc *qcc, int err, int app, int tevt); +void qcc_report_term_evt(struct qcc *qcc, enum muxc_term_event_type type); int _qcc_report_glitch(struct qcc *qcc, int inc); int qcc_fctl_avail_streams(const struct qcc *qcc, int bidi); struct qcs *qcc_init_stream_local(struct qcc *qcc, int bidi); diff --git a/src/h3.c b/src/h3.c index c15f873c6..2c3726843 100644 --- a/src/h3.c +++ b/src/h3.c @@ -202,7 +202,8 @@ static ssize_t h3_init_uni_stream(struct h3c *h3c, struct qcs *qcs, case H3_UNI_S_T_CTRL: if (h3c->flags & H3_CF_UNI_CTRL_SET) { TRACE_ERROR("duplicated control stream", H3_EV_H3S_NEW, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1, + muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -218,7 +219,8 @@ static ssize_t h3_init_uni_stream(struct h3c *h3c, struct qcs *qcs, case H3_UNI_S_T_QPACK_DEC: if (h3c->flags & H3_CF_UNI_QPACK_DEC_SET) { TRACE_ERROR("duplicated qpack decoder stream", H3_EV_H3S_NEW, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1, + muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -230,7 +232,8 @@ static ssize_t h3_init_uni_stream(struct h3c *h3c, struct qcs *qcs, case H3_UNI_S_T_QPACK_ENC: if (h3c->flags & H3_CF_UNI_QPACK_ENC_SET) { TRACE_ERROR("duplicated qpack encoder stream", H3_EV_H3S_NEW, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_STREAM_CREATION_ERROR, 1, + muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -1715,6 +1718,7 @@ static ssize_t h3_parse_goaway_frm(struct h3c *h3c, const struct buffer *buf, * establish a new connection to send additional requests. */ h3c->qcc->flags |= QC_CF_CONN_SHUT; + qcc_report_term_evt(h3c->qcc, muxc_tevt_type_goaway_rcvd); TRACE_LEAVE(H3_EV_RX_FRAME, h3c->qcc->conn); return ret; @@ -1773,7 +1777,8 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) */ if (h3s->type == H3S_T_CTRL && fin) { TRACE_ERROR("control stream closed by remote peer", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1); + qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1, + muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -1790,7 +1795,8 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) if (qcs_http_handle_standalone_fin(qcs)) { TRACE_ERROR("cannot set EOM", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1, + muxc_tevt_type_internal_err); goto err; } @@ -1816,7 +1822,7 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) if ((ret = h3_check_frame_valid(h3c, qcs, ftype))) { TRACE_ERROR("received an invalid frame", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, ret, 1); + qcc_set_error(qcs->qcc, ret, 1, muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -1857,7 +1863,8 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) */ if (flen > qmux_stream_rx_bufsz()) { TRACE_ERROR("received a too big frame", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_EXCESSIVE_LOAD, 1); + qcc_set_error(qcs->qcc, H3_ERR_EXCESSIVE_LOAD, 1, + muxc_tevt_type_other_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -1865,7 +1872,8 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) /* TODO extend parser to support the realignment of a frame. */ if (b_head(b) + b_data(b) > b_wrap(b)) { TRACE_ERROR("cannot parse unaligned data frame", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_EXCESSIVE_LOAD, 1); + qcc_set_error(qcs->qcc, H3_ERR_EXCESSIVE_LOAD, 1, + muxc_tevt_type_other_err); qcc_report_glitch(qcs->qcc, 1); goto err; } @@ -1926,7 +1934,7 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) ret = h3_parse_goaway_frm(qcs->qcc->ctx, b, flen); if (ret < 0) { TRACE_ERROR("error on GOAWAY parsing", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, h3c->err, 1); + qcc_set_error(qcs->qcc, h3c->err, 1, muxc_tevt_type_proto_err); goto err; } break; @@ -1940,7 +1948,7 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) ret = h3_parse_settings_frm(qcs->qcc->ctx, b, flen); if (ret < 0) { TRACE_ERROR("error on SETTINGS parsing", H3_EV_RX_FRAME, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, h3c->err, 1); + qcc_set_error(qcs->qcc, h3c->err, 1, muxc_tevt_type_proto_err); goto err; } h3c->flags |= H3_CF_SETTINGS_RECV; @@ -1975,12 +1983,12 @@ static ssize_t h3_rcv_buf(struct qcs *qcs, struct buffer *b, int fin) goto done; } else if (h3c->err) { - qcc_set_error(qcs->qcc, h3c->err, 1); + qcc_set_error(qcs->qcc, h3c->err, 1, muxc_tevt_type_proto_err); total = b_data(b); goto done; } else if (unlikely(ret < 0)) { - qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1, muxc_tevt_type_internal_err); goto err; } @@ -2915,7 +2923,7 @@ static size_t h3_snd_buf(struct qcs *qcs, struct buffer *buf, size_t count, char /* Interrupt sending on fatal error. */ if (unlikely(ret < 0)) { - qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1); + qcc_set_error(qcs->qcc, H3_ERR_INTERNAL_ERROR, 1, muxc_tevt_type_internal_err); goto out; } @@ -3075,7 +3083,8 @@ static int h3_close(struct qcs *qcs, enum qcc_app_ops_close_side side) */ if (qcs == h3c->ctrl_strm || h3s->type == H3S_T_CTRL) { TRACE_ERROR("closure detected on control stream", H3_EV_H3S_END, qcs->qcc->conn, qcs); - qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1); + qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1, + muxc_tevt_type_proto_err); qcc_report_glitch(qcs->qcc, 1); return 1; } @@ -3257,7 +3266,7 @@ static int h3_init(struct qcc *qcc) return 1; fail_no_h3: - qcc_set_error(qcc, H3_ERR_INTERNAL_ERROR, 1); + qcc_set_error(qcc, H3_ERR_INTERNAL_ERROR, 1, muxc_tevt_type_internal_err); TRACE_DEVEL("leaving on error", H3_EV_H3C_NEW, qcc->conn); return 0; } @@ -3288,7 +3297,8 @@ static int h3_finalize(void *ctx) */ if (qcc_fctl_avail_streams(qcc, 0) < 3) { TRACE_ERROR("peer flow-control limit does not allow control stream creation", H3_EV_H3C_NEW, qcc->conn); - qcc_set_error(qcc, H3_ERR_GENERAL_PROTOCOL_ERROR, 1); + qcc_set_error(qcc, H3_ERR_GENERAL_PROTOCOL_ERROR, 1, + muxc_tevt_type_other_err); qcc_report_glitch(qcc, 1); goto err; } @@ -3318,7 +3328,7 @@ static int h3_finalize(void *ctx) * send data. */ if (h3_control_send(qcs, h3c) < 0) { - qcc_set_error(qcc, H3_ERR_INTERNAL_ERROR, 1); + qcc_set_error(qcc, H3_ERR_INTERNAL_ERROR, 1, muxc_tevt_type_internal_err); goto err; } diff --git a/src/mux_quic.c b/src/mux_quic.c index 7757ce76f..de21f8c13 100644 --- a/src/mux_quic.c +++ b/src/mux_quic.c @@ -769,9 +769,10 @@ void qcc_notify_buf(struct qcc *qcc, uint64_t free_size) /* A fatal error is detected locally for connection. It should be closed * with a CONNECTION_CLOSE using code. Set to true to indicate that * the code must be considered as an application level error. This function - * must not be called more than once by connection. + * must not be called more than once by connection. If is non null, it + * is used as a connection level termination event code. */ -void qcc_set_error(struct qcc *qcc, int err, int app) +void qcc_set_error(struct qcc *qcc, int err, int app, int tevt) { /* This must not be called multiple times per connection. */ BUG_ON(qcc->flags & QC_CF_ERRL); @@ -781,6 +782,9 @@ void qcc_set_error(struct qcc *qcc, int err, int app) qcc->flags |= QC_CF_ERRL; qcc->err = app ? quic_err_app(err) : quic_err_transport(err); + if (tevt) + qcc_report_term_evt(qcc, tevt); + /* TODO * Ensure qcc_io_send() will be conducted to convert QC_CF_ERRL in * QC_CF_ERRL_DONE with CONNECTION_CLOSE frame emission. This may be @@ -791,6 +795,15 @@ void qcc_set_error(struct qcc *qcc, int err, int app) tasklet_wakeup(qcc->wait_event.tasklet); } +void qcc_report_term_evt(struct qcc *qcc, enum muxc_term_event_type type) +{ + enum term_event_loc loc = tevt_loc_muxc; + + if (qcc->flags & QC_CF_IS_BACK) + loc += 8; + qcc->term_evts_log = tevt_report_event(qcc->term_evts_log, loc, type); +} + /* Increment glitch counter for connection by steps. If configured * threshold reached, close the connection with an error code. */ @@ -803,10 +816,12 @@ int _qcc_report_glitch(struct qcc *qcc, int inc) (th_ctx->idle_pct <= global.tune.glitch_kill_maxidle)) { if (qcc->app_ops->report_susp) { qcc->app_ops->report_susp(qcc->ctx); - qcc_set_error(qcc, qcc->err.code, 1); + qcc_set_error(qcc, qcc->err.code, 1, + muxc_tevt_type_graceful_shut); } else { - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); } return 1; } @@ -869,7 +884,8 @@ struct qcs *qcc_init_stream_local(struct qcc *qcc, int bidi) qcs = qcs_new(qcc, *next, type); if (!qcs) { - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); TRACE_DEVEL("leaving on error", QMUX_EV_QCS_NEW, qcc->conn); return NULL; } @@ -919,7 +935,8 @@ static struct qcs *qcc_init_stream_remote(struct qcc *qcc, uint64_t id) qcc->lfctl.ms_uni * 4; if (id >= max_id) { TRACE_ERROR("flow control error", QMUX_EV_QCS_NEW|QMUX_EV_PROTO_ERR, qcc->conn); - qcc_set_error(qcc, QC_ERR_STREAM_LIMIT_ERROR, 0); + qcc_set_error(qcc, QC_ERR_STREAM_LIMIT_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } @@ -936,7 +953,8 @@ static struct qcs *qcc_init_stream_remote(struct qcc *qcc, uint64_t id) qcs = qcs_new(qcc, *largest, type); if (!qcs) { TRACE_ERROR("stream fallocation failure", QMUX_EV_QCS_NEW, qcc->conn); - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); goto err; } @@ -1113,13 +1131,15 @@ int qcc_get_qcs(struct qcc *qcc, uint64_t id, int receive_only, int send_only, if (!receive_only && quic_stream_is_uni(id) && quic_stream_is_remote(qcc, id)) { TRACE_ERROR("receive-only stream not allowed", QMUX_EV_QCC_RECV|QMUX_EV_QCC_NQCS|QMUX_EV_PROTO_ERR, qcc->conn, NULL, &id); - qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0); + qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } if (!send_only && quic_stream_is_uni(id) && quic_stream_is_local(qcc, id)) { TRACE_ERROR("send-only stream not allowed", QMUX_EV_QCC_RECV|QMUX_EV_QCC_NQCS|QMUX_EV_PROTO_ERR, qcc->conn, NULL, &id); - qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0); + qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } @@ -1151,7 +1171,8 @@ int qcc_get_qcs(struct qcc *qcc, uint64_t id, int receive_only, int send_only, * stream. */ TRACE_ERROR("locally initiated stream not yet created", QMUX_EV_QCC_RECV|QMUX_EV_QCC_NQCS|QMUX_EV_PROTO_ERR, qcc->conn, NULL, &id); - qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0); + qcc_set_error(qcc, QC_ERR_STREAM_STATE_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } else { @@ -1330,7 +1351,8 @@ static void qcs_consume(struct qcs *qcs, uint64_t bytes, struct qc_stream_rxbuf if (!frm) { frm = qc_frm_alloc(QUIC_FT_MAX_STREAM_DATA); if (!frm) { - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); return; } @@ -1354,7 +1376,8 @@ static void qcs_consume(struct qcs *qcs, uint64_t bytes, struct qc_stream_rxbuf TRACE_DATA("increase conn credit via MAX_DATA", QMUX_EV_QCS_RECV, qcc->conn, qcs); frm = qc_frm_alloc(QUIC_FT_MAX_DATA); if (!frm) { - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); return; } @@ -1922,7 +1945,8 @@ int qcc_recv(struct qcc *qcc, uint64_t id, uint64_t len, uint64_t offset, if (qcs->flags & QC_SF_SIZE_KNOWN && (offset + len > qcs->rx.offset_max || (fin && offset + len < qcs->rx.offset_max))) { TRACE_ERROR("final size error", QMUX_EV_QCC_RECV|QMUX_EV_QCS_RECV|QMUX_EV_PROTO_ERR, qcc->conn, qcs); - qcc_set_error(qcc, QC_ERR_FINAL_SIZE_ERROR, 0); + qcc_set_error(qcc, QC_ERR_FINAL_SIZE_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } @@ -1955,7 +1979,8 @@ int qcc_recv(struct qcc *qcc, uint64_t id, uint64_t len, uint64_t offset, */ TRACE_ERROR("flow control error", QMUX_EV_QCC_RECV|QMUX_EV_QCS_RECV|QMUX_EV_PROTO_ERR, qcc->conn, qcs); - qcc_set_error(qcc, QC_ERR_FLOW_CONTROL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_FLOW_CONTROL_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } } @@ -1987,7 +2012,8 @@ int qcc_recv(struct qcc *qcc, uint64_t id, uint64_t len, uint64_t offset, buf = qcs_get_rxbuf(qcs, offset, &len); if (!buf) { TRACE_ERROR("rxbuf alloc failure", QMUX_EV_QCC_RECV|QMUX_EV_QCS_RECV, qcc->conn, qcs); - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); goto err; } @@ -2012,7 +2038,8 @@ int qcc_recv(struct qcc *qcc, uint64_t id, uint64_t len, uint64_t offset, */ TRACE_ERROR("overlapping data rejected", QMUX_EV_QCC_RECV|QMUX_EV_QCS_RECV|QMUX_EV_PROTO_ERR, qcc->conn, qcs); - qcc_set_error(qcc, QC_ERR_PROTOCOL_VIOLATION, 0); + qcc_set_error(qcc, QC_ERR_PROTOCOL_VIOLATION, 0, + muxc_tevt_type_proto_err); return 1; case NCB_RET_GAP_SIZE: @@ -2192,7 +2219,8 @@ int qcc_recv_max_streams(struct qcc *qcc, uint64_t max, int bidi) */ if (max > QUIC_VARINT_8_BYTE_MAX) { TRACE_ERROR("invalid MAX_STREAMS value", QMUX_EV_QCC_RECV, qcc->conn); - qcc_set_error(qcc, QC_ERR_FRAME_ENCODING_ERROR, 0); + qcc_set_error(qcc, QC_ERR_FRAME_ENCODING_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } @@ -2271,7 +2299,8 @@ int qcc_recv_reset_stream(struct qcc *qcc, uint64_t id, uint64_t err, uint64_t f if (qcs->rx.offset_max > final_size || ((qcs->flags & QC_SF_SIZE_KNOWN) && qcs->rx.offset_max != final_size)) { TRACE_ERROR("final size error on RESET_STREAM", QMUX_EV_QCC_RECV|QMUX_EV_QCS_RECV, qcc->conn, qcs); - qcc_set_error(qcc, QC_ERR_FINAL_SIZE_ERROR, 0); + qcc_set_error(qcc, QC_ERR_FINAL_SIZE_ERROR, 0, + muxc_tevt_type_proto_err); goto err; } @@ -2437,7 +2466,8 @@ static int qcc_release_remote_stream(struct qcc *qcc, uint64_t id) TRACE_DATA("increase max stream limit with MAX_STREAMS_BIDI", QMUX_EV_QCC_SEND, qcc->conn); frm = qc_frm_alloc(QUIC_FT_MAX_STREAMS_BIDI); if (!frm) { - qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0); + qcc_set_error(qcc, QC_ERR_INTERNAL_ERROR, 0, + muxc_tevt_type_internal_err); goto err; } @@ -3434,6 +3464,7 @@ static void qcc_app_shutdown(struct qcc *qcc) } TRACE_STATE("perform graceful shutdown", QMUX_EV_QCC_END, qcc->conn); + qcc_report_term_evt(qcc, muxc_tevt_type_graceful_shut); if (qcc->app_ops && qcc->app_ops->shutdown) { qcc->app_ops->shutdown(qcc->ctx); qcc_io_send(qcc); @@ -3504,10 +3535,13 @@ static void qcc_release(struct qcc *qcc) } tasklet_free(qcc->wait_event.tasklet); - if (conn && qcc->wait_event.events) { - conn->xprt->unsubscribe(conn, conn->xprt_ctx, - qcc->wait_event.events, - &qcc->wait_event); + if (conn) { + qcc_report_term_evt(qcc, muxc_tevt_type_shutw); + if (qcc->wait_event.events) { + conn->xprt->unsubscribe(conn, conn->xprt_ctx, + qcc->wait_event.events, + &qcc->wait_event); + } } while (!LIST_ISEMPTY(&qcc->lfctl.frms)) { @@ -3782,6 +3816,7 @@ static int qmux_init(struct connection *conn, struct proxy *prx, qcc->flags = conn_is_back(conn) ? QC_CF_IS_BACK : 0; qcc->app_st = QCC_APP_ST_NULL; qcc->glitches = 0; + qcc->term_evts_log = 0; qcc->err = quic_err_transport(QC_ERR_NO_ERROR); if (conn_is_quic(conn)) { @@ -4593,6 +4628,9 @@ static int qmux_ctl(struct connection *conn, enum mux_ctl_type mux_ctl, void *ou case MUX_CTL_GET_MAXSTRM: return qcc->lfctl.ms_bidi_init; + case MUX_CTL_TEVTS: + return qcc->term_evts_log; + default: return -1; } @@ -4624,8 +4662,9 @@ static int qmux_sctl(struct stconn *sc, enum mux_sctl_type mux_sctl, void *outpu qmux_dump_qcc_info(buf, qcc); if (dbg_ctx->arg.debug_flags & MUX_SCTL_DBG_STR_L_CONN) { - chunk_appendf(buf, " conn.flg=%#08x conn.err_code=%u", - conn->flags, conn->err_code); + chunk_appendf(buf, " conn.flg=%#08x conn.err_code=%u conn.evts=%s", + conn->flags, conn->err_code, + tevt_evts2str(conn->term_evts_log)); } if (dbg_ctx->arg.debug_flags & MUX_SCTL_DBG_STR_L_XPRT) diff --git a/src/qmux_trace.c b/src/qmux_trace.c index 812a4881b..41016d13a 100644 --- a/src/qmux_trace.c +++ b/src/qmux_trace.c @@ -149,9 +149,9 @@ void qmux_dump_qcc_info(struct buffer *msg, const struct qcc *qcc) chunk_appendf(msg, " qcc=%p(%c)", qcc, (qcc->flags & QC_CF_IS_BACK) ? 'B' : 'F'); if (qc) chunk_appendf(msg, " qc=%p", qcc->conn->handle.qc); - chunk_appendf(msg, " .st=%s .sc=%llu .hreq=%llu .flg=0x%04x", + chunk_appendf(msg, " .st=%s .sc=%llu .hreq=%llu .flg=0x%04x .evts=%s", qcc_app_st_to_str(qcc->app_st), (ullong)qcc->nb_sc, - (ullong)qcc->nb_hreq, qcc->flags); + (ullong)qcc->nb_hreq, qcc->flags, tevt_evts2str(qcc->term_evts_log)); chunk_appendf(msg, " .tx=%llu %llu/%llu", (ullong)qcc->tx.fc.off_soft, (ullong)qcc->tx.fc.off_real, (ullong)qcc->tx.fc.limit); diff --git a/src/qpack-dec.c b/src/qpack-dec.c index e36eb75f3..e6ecb6dbb 100644 --- a/src/qpack-dec.c +++ b/src/qpack-dec.c @@ -119,7 +119,8 @@ int qpack_decode_enc(struct buffer *buf, int fin, void *ctx) * connection error of type H3_CLOSED_CRITICAL_STREAM. */ if (fin) { - qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1); + qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1, + muxc_tevt_type_proto_err); return -1; } @@ -152,7 +153,8 @@ int qpack_decode_enc(struct buffer *buf, int fin, void *ctx) * QPACK_ENCODER_STREAM_ERROR. */ if (capacity) { - qcc_set_error(qcs->qcc, QPACK_ERR_ENCODER_STREAM_ERROR, 1); + qcc_set_error(qcs->qcc, QPACK_ERR_ENCODER_STREAM_ERROR, 1, + muxc_tevt_type_proto_err); return -1; } @@ -179,7 +181,8 @@ int qpack_decode_dec(struct buffer *buf, int fin, void *ctx) * connection error of type H3_CLOSED_CRITICAL_STREAM. */ if (fin) { - qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1); + qcc_set_error(qcs->qcc, H3_ERR_CLOSED_CRITICAL_STREAM, 1, + muxc_tevt_type_proto_err); return -1; } @@ -204,7 +207,8 @@ int qpack_decode_dec(struct buffer *buf, int fin, void *ctx) */ /* For the moment haproxy does not emit dynamic table insertion. */ - qcc_set_error(qcs->qcc, QPACK_ERR_DECODER_STREAM_ERROR, 1); + qcc_set_error(qcs->qcc, QPACK_ERR_DECODER_STREAM_ERROR, 1, + muxc_tevt_type_proto_err); return -1; } else if (inst & QPACK_DEC_INST_SACK) {