mirror of
https://git.haproxy.org/git/haproxy.git/
synced 2026-05-02 03:30:59 +02:00
CLEANUP: tree-wide: address various spelling mistakes in comments from -dev7
These ones were found in recent patches merged since -dev7. There is no user-visible change so no backport is needed.
This commit is contained in:
parent
61e843a0b4
commit
c6600d7835
@ -460,7 +460,7 @@ HAProxy CLI command handlers for runtime filter management.
|
||||
|
||||
flt_otel_cli_parse_logging
|
||||
CLI handler for "otel logging [state]". Gets or sets the logging state
|
||||
(off/on/nolognorm).
|
||||
(off/on/dontlog-normal).
|
||||
|
||||
flt_otel_cli_parse_rate
|
||||
CLI handler for "otel rate [value]". Gets or sets the rate limit
|
||||
|
||||
@ -208,7 +208,7 @@ static int flt_otel_cli_parse_option(char **args, char *payload, struct appctx *
|
||||
*
|
||||
* DESCRIPTION
|
||||
* Handles the "otel logging [state]" CLI command. When a state argument is
|
||||
* provided in <args[2]>, it is matched against "off", "on", or "nolognorm"
|
||||
* provided in <args[2]>, it is matched against "off", "on", or "dontlog-normal"
|
||||
* and the logging field is atomically updated for all OTel filter instances.
|
||||
* Setting a value requires admin access level. When no argument is given,
|
||||
* reports the current logging state for all instances. Invalid values
|
||||
|
||||
@ -304,7 +304,7 @@ struct flt_otel_conf_sample *flt_otel_conf_sample_init_ex(const char **args, int
|
||||
OTELC_RETURN_PTR(retptr);
|
||||
}
|
||||
|
||||
/* The sample key is located at the idx location of the args[] field. */
|
||||
/* The sample key is located at the (idx - 1) location of the args[] field. */
|
||||
retptr = flt_otel_conf_sample_init(args[idx - 1], line, head, err);
|
||||
if (retptr == NULL)
|
||||
OTELC_RETURN_PTR(retptr);
|
||||
@ -439,7 +439,7 @@ FLT_OTEL_CONF_FUNC_FREE(context, id,
|
||||
* err - indirect pointer to error message string
|
||||
*
|
||||
* DESCRIPTION
|
||||
* Allocates and initializes a conf_span structure with empty lists for links,
|
||||
* Allocates and initializes a conf_span structure with empty lists for
|
||||
* attributes, events, baggages, and statuses. The <id> string is duplicated
|
||||
* and stored as the span name. If <head> is non-NULL, the structure is
|
||||
* appended to the list.
|
||||
@ -616,7 +616,7 @@ FLT_OTEL_CONF_FUNC_FREE(log_record, id,
|
||||
*
|
||||
* DESCRIPTION
|
||||
* Allocates and initializes a conf_scope structure with empty lists for ACLs,
|
||||
* contexts, spans, spans_to_finish, and instruments. The <id> string is
|
||||
* contexts, spans, and spans_to_finish. The <id> string is
|
||||
* duplicated and stored as the scope name. If <head> is non-NULL, the
|
||||
* structure is appended to the list.
|
||||
*
|
||||
|
||||
@ -998,7 +998,7 @@ static int flt_otel_ops_init_per_thread(struct proxy *p, struct flt_conf *fconf)
|
||||
* fconf - the filter configuration
|
||||
*
|
||||
* DESCRIPTION
|
||||
* It cleans up what the init_per_thread callback have done. It is called
|
||||
* It cleans up what the init_per_thread callback has done. It is called
|
||||
* in the context of a thread, before exiting it.
|
||||
*
|
||||
* RETURN VALUE
|
||||
|
||||
@ -145,7 +145,7 @@ struct otelc_text_map *flt_otel_http_headers_get(struct channel *chn, const char
|
||||
|
||||
/*
|
||||
* Here, an HTTP header (which is actually part
|
||||
* of the span context is added to the text_map.
|
||||
* of the span context) is added to the text_map.
|
||||
*
|
||||
* Before adding, the prefix is removed from the
|
||||
* HTTP header name.
|
||||
|
||||
@ -519,7 +519,7 @@ static bool flt_otel_parse_check_scope(void)
|
||||
* DESCRIPTION
|
||||
* Section parser for the otel-instrumentation configuration block. Handles
|
||||
* keywords: instrumentation ID, log, config, groups, scopes, acl, rate-limit,
|
||||
* option (disabled/hard-errors/nolognorm), and debug-level.
|
||||
* option (disabled/hard-errors/dontlog-normal), and debug-level.
|
||||
*
|
||||
* RETURN VALUE
|
||||
* Returns ERR_NONE (== 0) in case of success,
|
||||
|
||||
@ -54,7 +54,7 @@ enum acme_st {
|
||||
ACME_NEWACCOUNT,
|
||||
ACME_NEWORDER,
|
||||
ACME_AUTH,
|
||||
ACME_INITIAL_RSLV_TRIGGER, /* opportunistic DNS check avoid cond_ready steps */
|
||||
ACME_INITIAL_RSLV_TRIGGER, /* opportunistic DNS check to avoid cond_ready steps */
|
||||
ACME_INITIAL_RSLV_READY,
|
||||
ACME_CLI_WAIT, /* wait for the ACME_RDY_CLI */
|
||||
ACME_INITIAL_DELAY,
|
||||
|
||||
@ -124,7 +124,7 @@ struct appctx {
|
||||
|
||||
int severity_output; /* used within the cli_io_handler to format severity output of informational feedback */
|
||||
int level; /* the level of CLI which can be lowered dynamically */
|
||||
char *payload_pat; /* Pointer on the payload pattern. NULL if no payload */
|
||||
char *payload_pat; /* Pointer to the payload pattern. NULL if no payload */
|
||||
uint32_t max_payload_sz;/* Max size allowed for dynamic payload. 0 if not allowed */
|
||||
uint32_t anon_key; /* the key to anonymise with the hash in cli */
|
||||
int (*io_handler)(struct appctx *appctx); /* used within the cli_io_handler when st0 = CLI_ST_CALLBACK */
|
||||
|
||||
@ -80,7 +80,7 @@ struct qcc {
|
||||
struct {
|
||||
struct quic_fctl fc; /* stream flow control applied on sending */
|
||||
uint64_t buf_in_flight; /* sum of currently allocated Tx buffer sizes */
|
||||
struct list frms; /* list of STREAM frames ready for sent */
|
||||
struct list frms; /* list of STREAM frames ready for sending */
|
||||
union {
|
||||
struct {
|
||||
/* quic */
|
||||
@ -259,7 +259,7 @@ struct qcc_app_ops {
|
||||
#define QC_CF_ERRL_DONE 0x00000002 /* local error properly handled, connection can be released */
|
||||
#define QC_CF_IS_BACK 0x00000004 /* backend side */
|
||||
#define QC_CF_CONN_FULL 0x00000008 /* no stream buffers available on connection */
|
||||
#define QC_CF_CONN_SHUT 0x00000010 /* peer has initiate app layer shutdown - no new stream should be opened locally */
|
||||
#define QC_CF_CONN_SHUT 0x00000010 /* peer has initiated app layer shutdown - no new stream should be opened locally */
|
||||
#define QC_CF_ERR_CONN 0x00000020 /* fatal error reported by transport layer */
|
||||
#define QC_CF_WAIT_HS 0x00000040 /* MUX init before QUIC handshake completed (0-RTT) */
|
||||
|
||||
|
||||
@ -63,7 +63,7 @@ static inline int qmux_stream_rx_bufsz(void)
|
||||
/* This bit is set for unidirectional streams */
|
||||
#define QCS_ID_DIR_BIT 0x2
|
||||
|
||||
/* Maximum bidirectional stream ID that a client can opened. */
|
||||
/* Maximum bidirectional stream ID that a client can open. */
|
||||
#define QCS_ID_MAX_STRM_CL_BIDI (QUIC_VARINT_8_BYTE_MAX - 3)
|
||||
|
||||
static inline enum qcs_type qcs_id_type(uint64_t id)
|
||||
|
||||
@ -509,7 +509,7 @@ struct proxy {
|
||||
* name is used
|
||||
*/
|
||||
struct list filter_configs; /* list of the filters that are declared on this proxy */
|
||||
struct { /* sequence in which declared filters on the proxy should be execute
|
||||
struct { /* sequence in which declared filters on the proxy should be executed
|
||||
* (list of filter_sequence_elt)
|
||||
*/
|
||||
struct list req; /* during request handling */
|
||||
|
||||
@ -76,7 +76,7 @@ struct ckch_conf {
|
||||
} acme;
|
||||
struct {
|
||||
struct {
|
||||
char *type; /* "RSA" or "ECSDA" */
|
||||
char *type; /* "RSA" or "ECDSA" */
|
||||
int bits; /* bits for RSA */
|
||||
char *curves; /* NID of curves for ECDSA*/
|
||||
} key;
|
||||
|
||||
@ -707,7 +707,7 @@ static inline void tasklet_set_tid(struct tasklet *tl, int tid)
|
||||
|
||||
static inline void _task_schedule(struct task *task, int when, const struct ha_caller *caller)
|
||||
{
|
||||
/* TODO: mthread, check if there is no tisk with this test */
|
||||
/* TODO: mthread, check if there is no task with this test */
|
||||
if (task_in_rq(task))
|
||||
return;
|
||||
|
||||
|
||||
@ -185,7 +185,7 @@ struct acme_cfg *get_acme_cfg(const char *name)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Return an existing section section OR create one and return it */
|
||||
/* Return an existing section or create one and return it */
|
||||
struct acme_cfg *new_acme_cfg(const char *name)
|
||||
{
|
||||
struct acme_cfg *ret = NULL;
|
||||
@ -2670,7 +2670,7 @@ re:
|
||||
}
|
||||
|
||||
/* Check if the next resolution would be triggered too
|
||||
* late according to the dns_timeout and abort is
|
||||
* late according to the dns_timeout and abort if
|
||||
* necessary. */
|
||||
if (ctx->dnsstarttime && ns_to_sec(now_ns) + ctx->cfg->dns_delay > ctx->dnsstarttime + ctx->cfg->dns_timeout) {
|
||||
memprintf(&errmsg, "dns-01: Couldn't resolve the TXT records in %ds.", ctx->cfg->dns_timeout);
|
||||
@ -2778,7 +2778,7 @@ re:
|
||||
goto nextreq;
|
||||
}
|
||||
|
||||
/* if the challenge is not ready, wait to be wakeup */
|
||||
/* if the challenge is not ready, wait to be woken up */
|
||||
if (ctx->next_auth->ready != ctx->cfg->cond_ready)
|
||||
goto wait;
|
||||
|
||||
|
||||
@ -1115,8 +1115,8 @@ int assign_server_and_queue(struct stream *s)
|
||||
* To work around that, when a server is getting idle,
|
||||
* it will set the ready_srv field of the proxy.
|
||||
* Here, if ready_srv is non-NULL, we get that server,
|
||||
* and we attempt to switch its served from 0 to 1.
|
||||
* If it works, then we can just run, otherwise,
|
||||
* and we attempt to increment its served counter up to
|
||||
* maxconn. If it works, then we can just run, otherwise,
|
||||
* it means another stream will be running, and will
|
||||
* dequeue us eventually, so we can just do nothing.
|
||||
*/
|
||||
|
||||
@ -653,7 +653,7 @@ static int cli_parse_global(char **args, int section_type, struct proxy *curpx,
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* This function parses "tune.cli.max-payload-sze" statement in the "global"
|
||||
/* This function parses "tune.cli.max-payload-size" statement in the "global"
|
||||
* section. It returns -1 if there is any error, otherwise zero. If it returns
|
||||
* -1, it will write an error message into the <err> buffer which will be
|
||||
* preallocated. The trailing '\n' must not be written. The function must be
|
||||
@ -1119,11 +1119,11 @@ int cli_parse_cmdline(struct appctx *appctx)
|
||||
if (strncmp(last_arg, PAYLOAD_PATTERN, strlen(PAYLOAD_PATTERN)) == 0) {
|
||||
ssize_t pat_len = strlen(last_arg) - strlen(PAYLOAD_PATTERN);
|
||||
|
||||
/* A customized pattern can't be more than 7 characters
|
||||
/* A customized pattern can't be more than 64 characters
|
||||
* if it's more, don't make it a payload
|
||||
*/
|
||||
if (pat_len <= MAX_PAYLOAD_PATTERN_SIZE) {
|
||||
/* Save the pointer on the payload pattern (skipping PAYLOAD_PATTERN) */
|
||||
/* Save the pointer to the payload pattern (skipping PAYLOAD_PATTERN) */
|
||||
appctx->cli_ctx.payload_pat = last_arg + strlen(PAYLOAD_PATTERN);
|
||||
|
||||
/* The last command finishes before the payload pattern.
|
||||
@ -3354,7 +3354,7 @@ int pcli_parse_request(struct stream *s, struct channel *req, char **errmsg, int
|
||||
size_t pat_len = strlen(args[argl-1] + strlen(PAYLOAD_PATTERN));
|
||||
|
||||
/*
|
||||
* A customized pattern can't be more than 7 characters
|
||||
* A customized pattern can't be more than 64 characters
|
||||
* if it's more, don't make it a payload
|
||||
*/
|
||||
if (pat_len < sizeof(pcli->payload_pat)) {
|
||||
|
||||
@ -105,9 +105,9 @@ void conn_delete_from_tree(struct connection *conn, int thr)
|
||||
/* Installs the MUX layer for <conn> connection. The behavior is slightly
|
||||
* different for frontend and backend sides.
|
||||
*
|
||||
* For frontend connections, MUX is setup via session initialization
|
||||
* For frontend connections, MUX is set up via session initialization
|
||||
* completion. In case of failure, the session and the whole connection stack
|
||||
* is freed. Caller should set <closed_connection> to a non NULL value as it
|
||||
* are freed. Caller should set <closed_connection> to a non NULL value as it
|
||||
* will be set to 1 to report the connection release.
|
||||
*
|
||||
* For backend connections, MUX layer is immediately initialized by selecting
|
||||
|
||||
@ -249,7 +249,7 @@ parse_filter(char **args, int section_type, struct proxy *curpx,
|
||||
cur_arg = 1;
|
||||
kw = flt_find_kw(args[cur_arg]);
|
||||
if (kw) {
|
||||
/* default name is keyword name, unless overriden by parse func */
|
||||
/* default name is keyword name, unless overridden by parse func */
|
||||
fconf->name = kw->kw;
|
||||
if (!kw->parse) {
|
||||
memprintf(err, "parsing [%s:%d] : '%s' : "
|
||||
|
||||
@ -354,7 +354,9 @@ static struct sample_fetch_kw_list smp_kws = {ILH, {
|
||||
|
||||
INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
|
||||
|
||||
/* Note: must not be declared <const> as its list will be overwritten */
|
||||
/* Note: must not be declared <const> as its list will be overwritten.
|
||||
* Please take care of keeping this list alphabetically sorted.
|
||||
*/
|
||||
static struct sample_conv_kw_list sample_conv_kws = {ILH, {
|
||||
{ "fe_exists", sample_conv_fe_exists, 0, NULL, SMP_T_STR, SMP_T_BOOL },
|
||||
{ /* END */ },
|
||||
|
||||
2
src/h3.c
2
src/h3.c
@ -3133,7 +3133,7 @@ static int h3_attach(struct qcs *qcs, void *conn_ctx)
|
||||
*/
|
||||
if (h3c->flags & H3_CF_GOAWAY_SENT && qcs->id >= h3c->id_shut_l &&
|
||||
quic_stream_is_bidi(qcs->id)) {
|
||||
/* Local stack should not attached stream on a closed connection. */
|
||||
/* Local stack should not attach stream to a closed connection. */
|
||||
BUG_ON(quic_stream_is_local(qcs->qcc, qcs->id));
|
||||
|
||||
TRACE_STATE("close stream outside of GOAWAY range", H3_EV_H3S_NEW, qcs->qcc->conn, qcs);
|
||||
|
||||
@ -60,7 +60,7 @@ struct conf_errors {
|
||||
struct list list; /* next conf_errors */
|
||||
};
|
||||
|
||||
/* Returns the next unporocessed start line in the HTX message. It returns NULL
|
||||
/* Returns the next unprocessed start line in the HTX message. It returns NULL
|
||||
* if the start-line is undefined (first == -1). Otherwise, it returns the
|
||||
* pointer on the htx_sl structure.
|
||||
*/
|
||||
|
||||
@ -345,7 +345,6 @@ struct nextdata {
|
||||
|
||||
static int next_cb(int tok, const char *s, int off, int len, void *ud) {
|
||||
struct nextdata *d = (struct nextdata *) ud;
|
||||
// int i;
|
||||
switch (tok) {
|
||||
case '{':
|
||||
case '[':
|
||||
|
||||
@ -2958,7 +2958,7 @@ static size_t h1_make_eoh(struct h1s *h1s, struct h1m *h1m, struct htx *htx, siz
|
||||
}
|
||||
|
||||
/*
|
||||
* All headers was sent, now process EOH
|
||||
* All headers were sent, now process EOH
|
||||
*/
|
||||
if (!(h1m->flags & H1_MF_RESP) && h1s->meth == HTTP_METH_CONNECT) {
|
||||
if (!chunk_memcat(&outbuf, "\r\n", 2))
|
||||
@ -2992,11 +2992,11 @@ static size_t h1_make_eoh(struct h1s *h1s, struct h1m *h1m, struct htx *htx, siz
|
||||
else if (htx_is_unique_blk(htx, blk) &&
|
||||
((htx->flags & HTX_FL_EOM) || ((h1m->flags & H1_MF_CLEN) && !h1m->curr_len))) {
|
||||
/* EOM flag is set and it is the last block or there is no
|
||||
* payload. If cannot be removed now. We must emit the end of
|
||||
* the message first to be sure the output buffer is not full
|
||||
* payload. It cannot be removed now. We must emit the end of
|
||||
* the message first to be sure the output buffer is not full.
|
||||
*/
|
||||
if ((h1m->flags & H1_MF_CHNK) && (!(h1m->flags & H1_MF_RESP) || !(h1s->flags & H1S_F_BODYLESS_RESP))) {
|
||||
/* Send null-chunk except for bodyless reasponses */
|
||||
/* Send null-chunk except for bodyless responses */
|
||||
if (!chunk_memcat(&outbuf, "\r\n0\r\n\r\n", 7))
|
||||
goto full;
|
||||
}
|
||||
|
||||
@ -1075,7 +1075,7 @@ h2c_is_dead(const struct h2c *h2c)
|
||||
/* functions below are for dynamic buffer management */
|
||||
/*****************************************************/
|
||||
|
||||
/* indicates whether or not the we may call the h2_recv() function to attempt
|
||||
/* indicates whether or not we may call the h2_recv() function to attempt
|
||||
* to receive data into the buffer and/or demux pending data. The condition is
|
||||
* a bit complex due to some API limits for now. The rules are the following :
|
||||
* - if an error or a shutdown was detected on the connection, we must not
|
||||
@ -3434,8 +3434,8 @@ static int h2c_handle_priority(struct h2c *h2c)
|
||||
}
|
||||
|
||||
/*
|
||||
* Bit 31 is the "exclusive" bit, it is not part of the stream id,
|
||||
* so ignore it when checking if the stream id is ours.
|
||||
* Bit 31 is the "exclusive" bit, it is not part of the stream ID,
|
||||
* so ignore it when checking if the stream ID is ours.
|
||||
*/
|
||||
if ((h2_get_n32(&h2c->dbuf, 0) & 0x7fffffff) == h2c->dsi) {
|
||||
/* 7540#5.3 : can't depend on itself */
|
||||
@ -3563,7 +3563,7 @@ static struct h2s *h2c_frt_handle_headers(struct h2c *h2c, struct h2s *h2s)
|
||||
}
|
||||
|
||||
if (error < 0) {
|
||||
/* Failed to decode this frame (e.g. too large request)
|
||||
/* Failed to decode this frame (e.g. too large trailers)
|
||||
* but the HPACK decompressor is still synchronized.
|
||||
*/
|
||||
session_inc_http_err_ctr(h2c->conn->owner);
|
||||
|
||||
@ -152,7 +152,7 @@ static struct qcs *qcs_new(struct qcc *qcc, uint64_t id, enum qcs_type type)
|
||||
qcs->ctx = NULL;
|
||||
|
||||
/* App callback attach may register the stream for http-request wait.
|
||||
* These fields must be initialed before.
|
||||
* These fields must be initialized before.
|
||||
*/
|
||||
LIST_INIT(&qcs->el_opening);
|
||||
LIST_INIT(&qcs->el_recv);
|
||||
@ -1545,7 +1545,7 @@ struct buffer *qcc_get_stream_txbuf(struct qcs *qcs, int *err, int small)
|
||||
|
||||
/* Reallocate <qcs> stream buffer to convert a small buffer to a bigger one.
|
||||
* Contrary to standard allocation, this function will never stop due to a full
|
||||
* buffer window. The smaller buffer is released first which guarantee that the
|
||||
* buffer window. The smaller buffer is released first which guarantees that the
|
||||
* buffer window has room left.
|
||||
*
|
||||
* Returns buffer pointer or NULL on allocation failure.
|
||||
@ -3378,7 +3378,7 @@ static int qcc_io_process(struct qcc *qcc)
|
||||
|
||||
/* Conduct I/O operations to finalize <qcc> app layer initialization. Note that
|
||||
* <qcc> app state may remain NULL even on success, if only a transient
|
||||
* blocking was encountered. Finalize operation can be retry later.
|
||||
* blocking was encountered. Finalize operation can be retried later.
|
||||
*
|
||||
* Returns 0 on success else non-zero.
|
||||
*/
|
||||
@ -3414,7 +3414,7 @@ static int qcc_app_init(struct qcc *qcc)
|
||||
|
||||
/* Execute application layer shutdown. If this operation is not defined, a
|
||||
* CONNECTION_CLOSE will be prepared as a fallback. This function is protected
|
||||
* against multiple invocation thanks to <qcc> application state context.
|
||||
* against multiple invocations thanks to <qcc> application state context.
|
||||
*/
|
||||
static void qcc_app_shutdown(struct qcc *qcc)
|
||||
{
|
||||
@ -3479,7 +3479,7 @@ static void qcc_release(struct qcc *qcc)
|
||||
qcc->task = NULL;
|
||||
}
|
||||
|
||||
/* liberate remaining qcs instances */
|
||||
/* free remaining qcs instances */
|
||||
node = eb64_first(&qcc->streams_by_id);
|
||||
while (node) {
|
||||
struct qcs *qcs = eb64_entry(node, struct qcs, by_id);
|
||||
@ -3850,7 +3850,7 @@ static int qmux_init(struct connection *conn, struct proxy *prx,
|
||||
qcc->tx.qstrm_buf = BUF_NULL;
|
||||
qcc->rx.qstrm_buf = BUF_NULL;
|
||||
|
||||
/* Rx buffer is transfered from xprt layer - necessary if too many data where read */
|
||||
/* Rx buffer is transferred from xprt layer - necessary if too many data were read */
|
||||
qcc->rx.rlen = xprt_qstrm_xfer_rxbuf(conn->xprt_ctx, &qcc->rx.qstrm_buf);
|
||||
/* Cannot have a non empty record with an empty buffer. */
|
||||
BUG_ON(qcc->rx.rlen && !b_data(&qcc->rx.qstrm_buf));
|
||||
|
||||
@ -140,7 +140,7 @@ int qcc_qstrm_recv(struct qcc *qcc)
|
||||
}
|
||||
|
||||
/* Try read if record header not yet read and no data available
|
||||
* or hreader cannot be decoded, or either if current record
|
||||
* or header cannot be decoded, or either if current record
|
||||
* is incomplete.
|
||||
*/
|
||||
if ((!qcc->rx.rlen && (!b_data(buf) || !dec)) ||
|
||||
@ -275,7 +275,7 @@ static void qstrm_ctrl_send(struct qcs *qcs, uint64_t data)
|
||||
/* Sends <frms> list of frames for <qcc> connection.
|
||||
*
|
||||
* Returns 0 if all data are emitted or a positive value if sending should be
|
||||
* retry later. A negative error code is used for a fatal failure.
|
||||
* retried later. A negative error code is used for a fatal failure.
|
||||
*/
|
||||
int qcc_qstrm_send_frames(struct qcc *qcc, struct list *frms)
|
||||
{
|
||||
@ -317,7 +317,7 @@ int qcc_qstrm_send_frames(struct qcc *qcc, struct list *frms)
|
||||
loop:
|
||||
split_frm = next_frm = NULL;
|
||||
b_reset(buf);
|
||||
/* Reserve bytes for the record header. */
|
||||
/* Reserve space for the record header. */
|
||||
old = pos = (unsigned char *)b_orig(buf) + lensz;
|
||||
end = (unsigned char *)b_wrap(buf);
|
||||
|
||||
|
||||
@ -1899,9 +1899,9 @@ int peer_treat_updatemsg(struct appctx *appctx, struct peer *p, int updt, int ex
|
||||
* if it is a new entry set_entry inserts at that position in the expire
|
||||
* tree the touch_remote updates this date but the tree's re-order is not
|
||||
* designed to set back in the past, and the entry will be trashed only
|
||||
* after a full table's expire delay regardless the setting.
|
||||
* after a full table's expire delay regardless of the setting.
|
||||
* But setting the expire on newts here allows to set directly new entries
|
||||
* at the right position and to trash the entry in time if it is a new
|
||||
* at the right position and to trash the entry in time if it is a newly
|
||||
* created one from resync process for instance.
|
||||
*/
|
||||
newts->expire = tick_add(now_ms, expire);
|
||||
|
||||
@ -1360,7 +1360,7 @@ int qc_build_frm_pkt(struct quic_frame *frm, struct quic_tx_packet *pkt,
|
||||
TRACE_ENTER(QUIC_EV_CONN_BFRM, qc);
|
||||
|
||||
if (pkt && !(builder->mask & (1U << pkt->type))) {
|
||||
/* XXX This it a bug to send an unauthorized frame with such a packet type XXX */
|
||||
/* XXX This is a bug to send an unauthorized frame with such a packet type XXX */
|
||||
TRACE_ERROR("unauthorized frame", QUIC_EV_CONN_BFRM, qc, frm);
|
||||
BUG_ON(!(builder->mask & (1U << pkt->type)));
|
||||
}
|
||||
|
||||
@ -1841,7 +1841,7 @@ static inline int quic_enc_token(struct quic_conn *qc,
|
||||
* depending on its list of parameters. In most cases, <frms> frame list is
|
||||
* not empty. So, this function first tries to build this list of frames.
|
||||
*
|
||||
* Return 1 if succeeded (enough room to buile this packet), O if not.
|
||||
* Return 1 if succeeded (enough room to build this packet), 0 if not.
|
||||
*/
|
||||
static int qc_do_build_pkt(unsigned char *pos, const unsigned char *end,
|
||||
size_t dglen, struct quic_tx_packet *pkt,
|
||||
@ -1973,7 +1973,7 @@ static int qc_do_build_pkt(unsigned char *pos, const unsigned char *end,
|
||||
if (qel->pktns->tx.pto_probe) {
|
||||
/* If a probing packet was asked and could not be built,
|
||||
* this is not because there was not enough room, but due to
|
||||
* its frames which were already acknowledeged.
|
||||
* its frames which were already acknowledged.
|
||||
* See qc_stream_frm_is_acked()) called by qc_build_frms().
|
||||
* Note that qc_stream_frm_is_acked() logs a trace in this
|
||||
* case mentioning some frames were already acknowledged.
|
||||
|
||||
@ -2554,7 +2554,7 @@ struct task *process_resolvers(struct task *t, void *context, unsigned int state
|
||||
list_for_each_entry_safe(res, resback, &resolvers->resolutions.wait, list) {
|
||||
|
||||
if (unlikely(stopping)) {
|
||||
/* If haproxy is stopping, check if the resolution to know if it must be run or not.
|
||||
/* If haproxy is stopping, check if the resolution must be run or not.
|
||||
* If at least a requester is a stream (because of a do-resolv action) or if there
|
||||
* is a requester attached to a running proxy, the resolution is performed.
|
||||
* Otherwise, it is skipped for now.
|
||||
@ -2593,7 +2593,7 @@ struct task *process_resolvers(struct task *t, void *context, unsigned int state
|
||||
}
|
||||
|
||||
if (!must_run) {
|
||||
/* Skip the reolsution. reset it and wait for the next wakeup */
|
||||
/* Skip the resolution. reset it and wait for the next wakeup */
|
||||
resolv_reset_resolution(res);
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -771,12 +771,12 @@ void process_runnable_tasks()
|
||||
!MT_LIST_ISEMPTY(&tt->shared_tasklet_list))
|
||||
max[TL_URGENT] = default_weights[TL_URGENT];
|
||||
|
||||
/* normal tasklets list gets a default weight of ~37% */
|
||||
/* normal tasklets list gets a default weight of ~47% */
|
||||
if ((tt->tl_class_mask & (1 << TL_NORMAL)) ||
|
||||
!eb_is_empty(&th_ctx->rqueue) || !eb_is_empty(&th_ctx->rqueue_shared))
|
||||
max[TL_NORMAL] = default_weights[TL_NORMAL];
|
||||
|
||||
/* bulk tasklets list gets a default weight of ~13% */
|
||||
/* bulk tasklets list gets a default weight of ~3% */
|
||||
if ((tt->tl_class_mask & (1 << TL_BULK)))
|
||||
max[TL_BULK] = default_weights[TL_BULK];
|
||||
|
||||
|
||||
@ -72,7 +72,7 @@
|
||||
/* Global tree to share all tcp-checks */
|
||||
struct eb_root shared_tcpchecks = EB_ROOT;
|
||||
|
||||
/* Proxy used during parsing of healtcheck sections */
|
||||
/* Proxy used during parsing of healthcheck sections */
|
||||
struct proxy *tcpchecks_proxy = NULL;
|
||||
|
||||
DECLARE_TYPED_POOL(pool_head_tcpcheck_rule, "tcpcheck_rule", struct tcpcheck_rule);
|
||||
|
||||
@ -108,7 +108,7 @@ int conn_recv_qstrm(struct connection *conn, struct xprt_qstrm_ctx *ctx, int fla
|
||||
|
||||
ctx->rparams = frm.qmux_transport_params.params;
|
||||
b_del(buf, pos - old);
|
||||
/* <end> delimiter should guarantee than frame length does not go beyong the record end */
|
||||
/* <end> delimiter should guarantee that frame length does not go beyond the record end */
|
||||
BUG_ON(ctx->rxrlen < pos - old);
|
||||
ctx->rxrlen -= (pos - old);
|
||||
|
||||
@ -210,7 +210,7 @@ struct task *xprt_qstrm_io_cb(struct task *t, void *context, unsigned int state)
|
||||
BUG_ON(ctx->wait_event.events);
|
||||
|
||||
/* MUX will access members from xprt_ctx on init, so create
|
||||
* operation should be called before any members are resetted.
|
||||
* operation should be called before any members are reset.
|
||||
*/
|
||||
ret = conn_create_mux(conn, &free);
|
||||
if (free) {
|
||||
@ -222,7 +222,7 @@ struct task *xprt_qstrm_io_cb(struct task *t, void *context, unsigned int state)
|
||||
conn->xprt = ctx->ops_lower;
|
||||
|
||||
/* MUX layer is responsible to retrieve any remaining data in
|
||||
* the Rx buffer prior to reset it.
|
||||
* the Rx buffer prior to resetting it.
|
||||
*/
|
||||
BUG_ON(b_data(&ctx->rxbuf));
|
||||
b_free(&ctx->rxbuf);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user