* @brief read from a mapped data which then replace da_atlas_compile call
*
* @param dumppath, anonymous if NULL
- * @param map for anonymous, it is the responsability of the caller to unmap it, ignored otherwise
+ * @param map for anonymous, it is the responsibility of the caller to unmap it, ignored otherwise
* @param maplen for anonymous, it is the size of the mapped data, ignored otherwise
* @param ptr Pointer dynamically allocated if the mapping happened normally
* @param len size of the atlas image
be specified for shared bandwidth limitation filters only.
<time> is the default time period used to evaluate the bandwidth
- limitation rate. It can be speficied for per-stream bandwidth
+ limitation rate. It can be specified for per-stream bandwidth
limitation filters only. It follows the HAProxy time format and
is expressed in milliseconds.
# of 10m/s with all other streams with the same source address.
filter bwlim-out limit-by-src key src table limit-by-src limit 10m
- # If this filter is enalbed, the stream will be limited to download at 1m/s,
+ # If this filter is enabled, the stream will be limited to download at 1m/s,
# independently of all other streams.
filter bwlim-out limit-by-strm default-limit 1m default-period 1s
- in the global update_list. In this case, fd_rm_from_fd_list() already
performs an attachment check, so it's safe to always call it before closing
- (since noone else may be in the process of changing anything).
+ (since no one else may be in the process of changing anything).
###########################################################
- thread_mask (in bind_conf->rx_settings) should become an array of
MAX_TGROUP longs.
- when parsing "thread 123" or "thread 2/37", the proper bit is set,
- assuming the array is either a contigous bitfield or a tgroup array.
+ assuming the array is either a contiguous bitfield or a tgroup array.
An option RX_O_THR_PER_GRP or RX_O_THR_PER_PROC is set depending on
how the thread num was parsed, so that we reject mixes.
- end of parsing: entries translated to the cleanest form (to be determined)
preferred to use their own context definition.
All this resulted in the appctx->ctx to contain a myriad of definitions of
-vairous service contexts, and in some services abusing other services'
+various service contexts, and in some services abusing other services'
definitions by laziness, and others being extended to use their own definition
after having run for a long time on the generic types, some of which were not
noticed and mistakenly used the same storage locations by accident. A massive
require the caller to indicate how large an area it needs, and will return a
pointer to this area after checking that it fits. If it does not, haproxy will
crash. This is purposely done so that it's known during development that if a
-small structure doesn't fit, a differnet approach is required.
+small structure doesn't fit, a different approach is required.
As such, for the vast majority of commands, the process is the following one:
This allows one to define the maximum number of objects that will be
groupped together in an allocation from the shared pool. Values 4 to 8
have experimentally shown good results with 16 threads. On systems with
- more cores or losely coupled caches exhibiting slow atomic operations,
+ more cores or loosely coupled caches exhibiting slow atomic operations,
it could possibly make sense to slightly increase this value.
* store data in a non-linear way with gaps between them. The buffer is
* circular and so data may wrapped.
*
- * The API of <ncbuf> is splitted in two parts. Please refer to the public API
+ * The API of <ncbuf> is split in two parts. Please refer to the public API
* declared in this header file which should cover all the needs.
*
* To minimize the memory footprint, size of data and gaps are inserted in the
#define PR_O2_FAKE_KA 0x00200000 /* pretend we do keep-alive with server even though we close */
-#define PR_O2_RSTRICT_REQ_HDR_NAMES_BLK 0x00400000 /* reject request with header names containing chars ouside of [0-9a-zA-Z-] charset */
+#define PR_O2_RSTRICT_REQ_HDR_NAMES_BLK 0x00400000 /* reject request with header names containing chars outside of [0-9a-zA-Z-] charset */
#define PR_O2_RSTRICT_REQ_HDR_NAMES_DEL 0x00800000 /* remove request header names containing chars outside of [0-9a-zA-Z-] charset */
-#define PR_O2_RSTRICT_REQ_HDR_NAMES_NOOP 0x01000000 /* preserve request header names containing chars ouside of [0-9a-zA-Z-] charset */
+#define PR_O2_RSTRICT_REQ_HDR_NAMES_NOOP 0x01000000 /* preserve request header names containing chars outside of [0-9a-zA-Z-] charset */
#define PR_O2_RSTRICT_REQ_HDR_NAMES_MASK 0x01c00000 /* mask for restrict-http-header-names option */
/* unused : 0x0000000..0x80000000 */
* happened since the flag was set will result in the task being queued (if
* it wasn't already). This is used to safely drop the flag from within the
* scheduler. The flag <f> is combined with existing flags before the test so
- * that it's possible to inconditionally wakeup the task and drop the RUNNING
+ * that it's possible to unconditionally wakeup the task and drop the RUNNING
* flag if needed.
*/
#define task_drop_running(t, f) _task_drop_running(t, f, __FILE__, __LINE__)
#define QUIC_FL_TX_PACKET_PADDING (1UL << 1)
/* Flag a sent packet as being in flight. */
#define QUIC_FL_TX_PACKET_IN_FLIGHT (QUIC_FL_TX_PACKET_ACK_ELICITING | QUIC_FL_TX_PACKET_PADDING)
-/* Flag a sent packet as containg a CONNECTION_CLOSE frame */
+/* Flag a sent packet as containing a CONNECTION_CLOSE frame */
#define QUIC_FL_TX_PACKET_CC (1UL << 2)
-/* Flag a sent packet as containg an ACK frame */
+/* Flag a sent packet as containing an ACK frame */
#define QUIC_FL_TX_PACKET_ACK (1UL << 3)
/* Flag a sent packet as being coalesced to another one in the same datagram */
#define QUIC_FL_TX_PACKET_COALESCED (1UL << 4)
}
/* Copy <saddr> socket address data into <buf> buffer.
- * This is the responsability of the caller to check the output buffer is big
+ * This is the responsibility of the caller to check the output buffer is big
* enough to contain these socket address data.
* Return the number of bytes copied.
*/
if (!bind_conf->mux_proto) {
/* No protocol was specified. If we're using QUIC at the transport
* layer, we'll instantiate it as a mux as well. If QUIC is not
- * compiled in, this wil remain NULL.
+ * compiled in, this will remain NULL.
*/
if (bind_conf->xprt && bind_conf->xprt == xprt_get(XPRT_QUIC))
bind_conf->mux_proto = get_mux_proto(ist("quic"));
}
else {
/* For dynamic servers, check-ssl and check-send-proxy must be
- * explicitely defined even if the check port was not
+ * explicitly defined even if the check port was not
* overridden.
*/
if (srv->check.use_ssl == 1)
else {
/* On per-stream mode, the freq-counter is private to the
* stream. Get it from the filter state. Rely on the custom
- * limit/period if defined or use the defaut ones. In this mode,
+ * limit/period if defined or use the default ones. In this mode,
* there is only one user.
*/
bytes_rate = &st->bytes_rate;
if (tokens < len) {
/* The stream cannot forward all its data. But we will check if
* it can perform a small burst if the global quota is large
- * enought. But, in this case, its waiting time will be
+ * enough. But, in this case, its waiting time will be
* increased accordingly.
*/
ret = tokens;
*
* arg.act.p[0] will be the filter name (mandatory)
* arg.act.p[1] will be an expression for the custom limit (optional, may be NULL)
- * arg.act.p[2] will be an expression for the custom period (optiona, may be NULLl)
+ * arg.act.p[2] will be an expression for the custom period (optional, may be NULL)
*
* It returns ACT_RET_PRS_OK on success, ACT_RET_PRS_ERR on error.
*/
}
/*
- * Return a split
ted URL in <scheme>, <host>, <port>
+ * Return a split URL in <scheme>, <host>, <port>
*/
static void httpclient_spliturl(struct ist url, enum http_scheme *scheme,
struct ist *host, int *port)
if (hc->ops.res_payload)
hc->ops.res_payload(hc);
- /* cannot copy everything, need to processs */
+ /* cannot copy everything, need to process */
if (vlen != blksz)
goto process_data;
} else {
return NULL;
}
-/* shutr() called by the stream conector (mux_ops.shutr) */
+/* shutr() called by the stream connector (mux_ops.shutr) */
static void fcgi_shutr(struct stconn *sc, enum co_shr_mode mode)
{
struct fcgi_strm *fstrm = __sc_mux_strm(sc);
return ncbuf;
}
-/* Notify an eventual subscriber on <qcs> or else wakup up the stconn layer if
+/* Notify an eventual subscriber on <qcs> or else wakeup up the stconn layer if
* initialized.
*/
static void qcs_alert(struct qcs *qcs)
}
/* Create the stream. This is valid only for remote initiated one. A
- * local stream must have already been explicitely created by the
+ * local stream must have already been explicitly created by the
* application protocol layer.
*/
if (quic_stream_is_local(qcc, id)) {
return -1;
}
-/* Check after transfering data from qcs.tx.buf if FIN must be set on the next
+/* Check after transferring data from qcs.tx.buf if FIN must be set on the next
* STREAM frame for <qcs>.
*
* Returns true if FIN must be set else false.
/* out buffer cannot be emptied if qcs offsets differ. */
BUG_ON(!b_data(out) && qcs->tx.sent_offset != qcs->tx.offset);
- /* FIN is set if all incoming data were transfered. */
+ /* FIN is set if all incoming data were transferred. */
fin = qcs_stream_fin(qcs);
/* Build a new STREAM frame with <out> buffer. */
return !ncb_blk_is_last(buf, gap);
}
-/* Returns the number of bytes of data avaiable in <buf> starting at offset
+/* Returns the number of bytes of data available in <buf> starting at offset
* <off> until the next gap or the buffer end. The counted data may wrapped if
* the buffer storage is not aligned.
*/
ncb_sz_t done;
/* retrieve the next block. This is necessary to do this
- * before overwritting a gap.
+ * before overwriting a gap.
*/
next = ncb_blk_next(buf, blk);
max_dgrams = global.tune.maxpollevents;
start:
- /* Try to reuse an existing dgram. Note that there is alway at
+ /* Try to reuse an existing dgram. Note that there is always at
* least one datagram to pick, except the first time we enter
* this function for this <rxbuf> buffer.
*/
HA_ATOMIC_INC(&prx_counters->sendto_err);
}
else if (errno) {
- /* TODO unlisted errno : handle it explicitely. */
+ /* TODO unlisted errno : handle it explicitly. */
ABORT_NOW();
}
/* Attaches a stconn to a mux endpoint and sets the endpoint ctx. Returns
- * -1 on error and 0 on sucess. SE_FL_DETACHED flag is removed. This function is
+ * -1 on error and 0 on success. SE_FL_DETACHED flag is removed. This function is
* called from a mux when it is attached to a stream or a health-check.
*/
int sc_attach_mux(struct stconn *sc, void *sd, void *ctx)
}
/* Attaches a stconn to an applet endpoint and sets the endpoint
- * ctx. Returns -1 on error and 0 on sucess. SE_FL_DETACHED flag is
+ * ctx. Returns -1 on error and 0 on success. SE_FL_DETACHED flag is
* removed. This function is called by a stream when a backend applet is
* registered.
*/
/* Resets the stream connector endpoint. It happens when the app layer want to renew
* its endpoint. For a connection retry for instance. If a mux or an applet is
- * attached, a new endpoint is created. Returns -1 on error and 0 on sucess.
+ * attached, a new endpoint is created. Returns -1 on error and 0 on success.
*
* Only SE_FL_ERROR flag is removed on the endpoint. Orther flags are preserved.
* It is the caller responsibility to remove other flags if needed.
sc_ep_set(sc, SE_FL_DETACHED);
}
-/* Endpoint upgrade failed. Retore the stconn state. */
+/* Endpoint upgrade failed. Restore the stconn state. */
void sc_conn_abort_endp_upgrade(struct stconn *sc)
{
sc_ep_set(sc, SE_FL_T_MUX);
}
/* Free <pkt> TX packet and its attached frames.
- * This is the responsability of the caller to remove this packet of
+ * This is the responsibility of the caller to remove this packet of
* any data structure it was possibly attached to.
*/
static inline void free_quic_tx_packet(struct quic_tx_packet *pkt)
/* Must be called only by a <cbuf> writer (packet builder).
* Return 1 if <cbuf> may be reused to build packets, depending on its <rd> and
* <wr> internal indexes, 0 if not. When this is the case, reset <wr> writer
- * index after having marked the end of written data. This the responsability
+ * index after having marked the end of written data. This the responsibility
* of the caller to ensure there is enough room in <cbuf> to write the end of
* data made of a uint16_t null field.
*
/* QUIC server only function.
* Add AAD to <add> buffer from <cid> connection ID and <addr> socket address.
- * This is the respons
ability of the caller to check <aad> size is big enough
+ * This is the respons
ibility of the caller to check <aad> size is big enough
* to contain these data.
* Return the number of bytes copied to <aad>.
*/
}
/* Check that all the bytes between <buf> included and <end> address
- * excluded are null. This is the responsability of the caller to
+ * excluded are null. This is the responsibility of the caller to
* check that there is at least one byte between <buf> end <end>.
* Return 1 if this all the bytes are null, 0 if not.
*/
* with the information collected from the packet.
* This function sets ->len <pkt> field value to the end of the packet past one
* byte to enable the caller to run this function again to continue to parse
- * the remaing QUIC packets carried by the datagram.
+ * the remaining QUIC packets carried by the datagram.
* Note that this function always sets this ->len value. If a paquet could
* not be correctly found, ->len value will be set to the remaining number
* bytes in the datagram to entirely consume this latter.
return t;
}
-/* Retreive the DCID from a QUIC datagram or packet with <buf> as first octet.
+/* Retrieve the DCID from a QUIC datagram or packet with <buf> as first octet.
* Returns 1 if succeeded, 0 if not.
*/
int quic_get_dgram_dcid(unsigned char *buf, const unsigned char *end,
projects / thirdparty / haproxy.git / commitdiff
