if (!value)
break;
- /* skip common leading delimitors that slip from copy-paste */
+ /* skip common leading delimiters that slip from copy-paste */
while (*value == ' ' || *value == '\t' || *value == ':' || *value == '=')
value++;
expr->kw, file, line);
trash.area[trash.size - 1] = '\0';
- /* Create new patern reference. */
+ /* Create new pattern reference. */
ref = pat_ref_newid(unique_id, trash.area, PAT_REF_ACL);
if (!ref) {
memprintf(err, "memory error");
/* Compatibility layer. Each pattern can parse only one string per pattern,
* but the pat_parser_int() and pat_parse_dotted_ver() parsers were need
- * optionnaly two operators. The first operator is the match method: eq,
+ * optionally two operators. The first operator is the match method: eq,
* le, lt, ge and gt. pat_parse_int() and pat_parse_dotted_ver() functions
* can have a compatibility syntax based on ranges:
*
}
/*
- * This fonction will store the headers of the response in a buffer and then
+ * This function will store the headers of the response in a buffer and then
* register a filter to store the data
*/
enum act_return http_action_store_cache(struct act_rule *rule, struct proxy *px,
goto add_data_blk;
}
- /* Get info of the next HTX block. May be splitted on 2 shblk */
+ /* Get info of the next HTX block. May be split on 2 shblk */
sz = MIN(4, shctx->block_size - offset);
memcpy((char *)&info, (const char *)shblk->data + offset, sz);
offset += sz;
if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO))
goto out;
- /* Check if the input buffer is avalaible. */
+ /* Check if the input buffer is available. */
if (!b_size(&res->buf)) {
si_rx_room_blk(si);
goto out;
* Check RFC 2246 (TLSv1.0) sections A.3 and A.4 for details.
*/
const char sslv3_client_hello_pkt[] = {
- "\x16" /* ContentType : 0x16 = Hanshake */
+ "\x16" /* ContentType : 0x16 = Handshake */
"\x03\x00" /* ProtocolVersion : 0x0300 = SSLv3 */
"\x00\x79" /* ContentLength : 0x79 bytes after this one */
"\x01" /* HanshakeType : 0x01 = CLIENT HELLO */
* maximize the work at once, but in multi-process we want to keep
* some fairness between processes, so we target half of the max
* number of events to be balanced over all the processes the proxy
- * is bound to. Rememeber that maxaccept = -1 must be kept as it is
+ * is bound to. Remember that maxaccept = -1 must be kept as it is
* used to disable the limit.
*/
if (listener->maxaccept > 0 && nbproc > 1) {
#endif
/* Used to generates a unique id for an engine. On success, it returns a
- * allocated string. So it is the caller's reponsibility to release it. If the
+ * allocated string. So it is the caller's responsibility to release it. If the
* allocation failed, it returns NULL. */
static char *
generate_pseudo_uuid()
if (spoe_encode_buffer(chk->area, chk->data, &p, end) == -1)
goto too_big;
- /* (optionnal) "engine-id" K/V item, if present */
+ /* (optional) "engine-id" K/V item, if present */
if (agent != NULL && agent->rt[tid].engine_id != NULL) {
sz = SLEN(ENGINE_ID_KEY);
if (spoe_encode_buffer(ENGINE_ID_KEY, sz, &p, end) == -1)
}
/* Send a SPOE frame to an agent. It returns -1 when an error occurred, 0 when
- * the frame can be ignored, 1 to retry later, and the frame legnth on
+ * the frame can be ignored, 1 to retry later, and the frame length on
* success. */
static int
spoe_send_frame(struct appctx *appctx, char *buf, size_t framesz)
return 0;
}
-/* Free ressources allocated by the SPOE filter. */
+/* Free resources allocated by the SPOE filter. */
static void
spoe_deinit(struct proxy *px, struct flt_conf *fconf)
{
e = value->ptr + value->len;
while (++word.ptr < e) {
- /* skip leading delimitor and blanks */
+ /* skip leading delimiter and blanks */
if (unlikely(HTTP_IS_LWS(*word.ptr)))
continue;
/* now send the end of headers marker */
htx_add_endof(htx, HTX_BLK_EOH);
- /* Set bytes used in the HTX mesage for the headers now */
+ /* Set bytes used in the HTX message for the headers now */
sl->hdrs_bytes = htx_used_space(htx) - used;
ret = 1;
/* now send the end of headers marker */
htx_add_endof(htx, HTX_BLK_EOH);
- /* Set bytes used in the HTX mesage for the headers now */
+ /* Set bytes used in the HTX message for the headers now */
sl->hdrs_bytes = htx_used_space(htx) - used;
ret = 1;
* points will have set, if any.
*/
req->analyse_exp = TICK_ETERNITY;
- done_without_exp: /* done with this analyser, but dont reset the analyse_exp. */
+ done_without_exp: /* done with this analyser, but don't reset the analyse_exp. */
req->analysers &= ~an_bit;
DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA, s, txn);
return 1;
(!conn || conn->err_code != CO_ER_SSL_EARLY_FAILED)) {
/* If we arrive here, then CF_READ_ERROR was
* set by si_cs_recv() because we matched a
- * status, overwise it would have removed
+ * status, otherwise it would have removed
* the SI_FL_L7_RETRY flag, so it's ok not
* to check s->be->retry_type.
*/
*
* Maybe we are in resume condiion. In this case I choose the
* "struct proxy" which contains the rule list matching the resume
- * pointer. If none of theses "struct proxy" match, I initialise
+ * pointer. If none of these "struct proxy" match, I initialise
* the process with the first one.
*
- * In fact, I check only correspondance betwwen the current list
+ * In fact, I check only correspondence between the current list
* pointer and the ->fe rule list. If it doesn't match, I initialize
* the loop with the ->be.
*/
* implementations trying to do that. So let's do what servers do.
* Latest ietf draft forbids spaces all around. Also, earlier RFCs
* allowed quoted strings in values, with any possible character
- * after a backslash, including control chars and delimitors, which
+ * after a backslash, including control chars and delimiters, which
* causes parsing to become ambiguous. Browsers also allow spaces
* within values even without quotes.
*
att_end = equal;
}
- /* here, <equal> points to '=', a delimit
or or the end. <att_end>
+ /* here, <equal> points to '=', a delimit
er or the end. <att_end>
* is between <att_beg> and <equal>, both may be identical.
*/
/* look for end of cookie if there is an equal sign */
/* find the end of the value, respecting quotes */
next = http_find_cookie_value_end(val_beg, hdr_end);
- /* make val_end point to the first white space or delimitor after the value */
+ /* make val_end point to the first white space or delimiter after the value */
val_end = next;
while (val_end > val_beg && HTTP_IS_SPHT(*(val_end - 1)))
val_end--;
struct server *srv = s->be->srv;
char *delim;
- /* if we're in cookie prefix mode, we'll search the delimitor so that we
+ /* if we're in cookie prefix mode, we'll search the delimiter so that we
* have the server ID between val_beg and delim, and the original cookie between
* delim+1 and val_end. Otherwise, delim==val_end :
*
att_end = equal;
}
- /* here, <equal> points to '=', a delimit
or or the end. <att_end>
+ /* here, <equal> points to '=', a delimit
er or the end. <att_end>
* is between <att_beg> and <equal>, both may be identical.
*/
/* find the end of the value, respecting quotes */
next = http_find_cookie_value_end(val_beg, hdr_end);
- /* make val_end point to the first white space or delimitor after the value */
+ /* make val_end point to the first white space or delimiter after the value */
val_end = next;
while (val_end > val_beg && HTTP_IS_SPHT(*(val_end - 1)))
val_end--;
channel_htx_truncate(res, htx);
}
-/* This function terminates the request because it was completly analyzed or
+/* This function terminates the request because it was completely analyzed or
* because an error was triggered during the body forwarding.
*/
static void http_end_request(struct stream *s)
}
-/* This function terminates the response because it was completly analyzed or
+/* This function terminates the response because it was completely analyzed or
* because an error was triggered during the body forwarding.
*/
static void http_end_response(struct stream *s)
/* this algorithm gives priority to the first server, which means that
* it will respect the declaration order for equivalent weights, and
* that whatever the weights, the first server called will always be
- * the first declared. This is an important asumption for the backup
+ * the first declared. This is an important assumption for the backup
* case, where we want the first server only.
*/
for (cur = px->srv; cur; cur = cur->next)
struct xfer_sock_list *xfer_sock_list = NULL;
/* there is one listener queue per thread so that a thread unblocking the
- * global queue can wake up listeners bound only to foreing threads by
+ * global queue can wake up listeners bound only to foreign threads by
* moving them to the remote queues and waking up the associated tasklet.
*/
static struct work_list *local_listener_queue;
/* This function adds the specified listener's file descriptor to the polling
* lists if it is in the LI_LISTEN state. The listener enters LI_READY or
- * LI_FULL state depending on its number of connections. In deamon mode, we
+ * LI_FULL state depending on its number of connections. In daemon mode, we
* also support binding only the relevant processes to their respective
* listeners. We don't do that in debug mode however.
*/
fconn->flags = FCGI_CF_NONE;
- /* Retrieve usefull info from the FCGI app */
+ /* Retrieve useful info from the FCGI app */
if (app->flags & FCGI_APP_FL_KEEP_CONN)
fconn->flags |= FCGI_CF_KEEP_CONN;
if (app->flags & FCGI_APP_FL_GET_VALUES)
}
-/* Retruns true if the FCGI connection must be release */
+/* Returns true if the FCGI connection must be release */
static inline int fcgi_conn_is_dead(struct fcgi_conn *fconn)
{
if (eb_is_empty(&fconn->streams_by_id) && /* don't close if streams exist */
/* If some special characters are found in the decoded path (\n
* or \0), the PATH_INFO regex cannot match. This is theorically
* valid, but probably unexpected, to have such characters. So,
- * to avoid any suprises, an error is triggered in this
+ * to avoid any surprises, an error is triggered in this
* case.
*/
if (istchr(path, '\n') || istchr(path, '\0'))
/* Processes an empty STDOUT. Returns > 0 on success, 0 if it couldn't do
* anything. It only skip the padding in fact, there is no payload for such
- * records. It makrs the end of the response.
+ * records. It marks the end of the response.
*/
static int fcgi_strm_handle_empty_stdout(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
{
}
/****************************************/
-/* MUX initialization and instanciation */
+/* MUX initialization and instantiation */
/****************************************/
/* The mux operations */
cs->flags |= CS_FL_KILL_CONN;
if (si->flags & SI_FL_ERR) {
- /* quick close, the socket is alredy shut anyway */
+ /* quick close, the socket is already shut anyway */
}
else if (si->flags & SI_FL_NOLINGER) {
/* unclean data-layer shutdown, typically an aborted request
projects / thirdparty / haproxy.git / commitdiff
