struct dns_resolvers *resolvers; /* pointer to the resolvers structure used by this server */
char *lastaddr; /* the address string provided by the server-state file */
struct dns_options dns_opts;
- int hostname_dn_len; /* sting length of the server hostname in Domain Name format */
+ int hostname_dn_len; /* string length of the server hostname in Domain Name format */
char *hostname_dn; /* server hostname in Domain Name format */
char *hostname; /* server hostname */
struct sockaddr_storage init_addr; /* plain IP address specified on the init-addr line */
unsigned int init_addr_methods; /* initial address setting, 3-bit per method, ends at 0, enough to store 10 entries */
- enum srv_log_proto log_proto; /* used proto to emmit messages on server lines from ring section */
+ enum srv_log_proto log_proto; /* used proto to emit messages on server lines from ring section */
#ifdef USE_OPENSSL
char *sni_expr; /* Temporary variable to store a sample expression for SNI */
memprintf(err_msg, "expected ')' before '%s'", word);
if (len > 0)
free(word);
- /* when we're missing a right paren, the empty part preceeding
+ /* when we're missing a right paren, the empty part preceding
* already created an empty arg, adding one to the position, so
* let's fix the reporting to avoid being confusing.
*/
/* Check for preferred network. */
for (j = 0; j < dns_opts->pref_net_nb; j++) {
- /* Compare only the same adresses class. */
+ /* Compare only the same addresses class. */
if (dns_opts->pref_net[j].family != ip_type)
continue;
return -1;
}
-/* Removes a requester from a DNS resoltion. It takes takes care of all the
+/* Removes a requester from a DNS resolution. It takes takes care of all the
* consequences. It also cleans up some parameters from the requester.
*/
void dns_unlink_resolution(struct dns_requester *requester)
struct sink *sink = sink_find(logsrv->ring_name);
if (!sink || sink->type != SINK_TYPE_BUFFER) {
- ha_alert("config : fcgi-app '%s' : log server uses unkown ring named '%s'.\n",
+ ha_alert("config : fcgi-app '%s' : log server uses unknown ring named '%s'.\n",
curapp->name, logsrv->ring_name);
err_code |= ERR_ALERT | ERR_FATAL;
}
}
/*
- * Selects a comression algorithm depending of the server response.
+ * Selects a compression algorithm depending of the server response.
*/
static int
select_compression_response_header(struct comp_state *st, struct stream *s, struct http_msg *msg)
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
- * Please refer to RFC7230 - RFC7235 informations about HTTP protocol, and
- * RFC6265 for informations about cookies usage. More generally, the IETF HTTP
+ * Please refer to RFC7230 - RFC7235 information about HTTP protocol, and
+ * RFC6265 for information about cookies usage. More generally, the IETF HTTP
* Working Group's web site should be consulted for protocol related changes :
*
* http://ftp.ics.uci.edu/pub/ietf/http/
int active_peers = 0; /* number of active peers (connection attempts and connected) */
int connected_peers = 0; /* number of connected peers (verified ones) */
-/* Here we store informations about the pids of the processes we may pause
+/* Here we store information about the pids of the processes we may pause
* or kill. We will send them a signal every 10 ms until we can bind to all
* our ports. With 200 retries, that's about 2 seconds.
*/
}
/*
* Be paranoid and use memcpy() to avoid any
- * potential alignement issue.
+ * potential alignment issue.
*/
memcpy(&tmpfd[got_fd], CMSG_DATA(cmsg), totlen);
got_fd += totlen / sizeof(int);
* - The converters wrapper function
* - The sample-fetch wrapper functions
*
- * It is tolerated that the initilisation function returns an abort.
+ * It is tolerated that the initialisation function returns an abort.
* Before each Lua abort, an error message is written on stderr.
*
* The macro SET_SAFE_LJMP initialise the longjmp. The Macro
/* Copy data between the coroutines. */
lua_rawgeti(lua->T, LUA_REGISTRYINDEX, lua->Mref);
lua_xmove(lua->T, T, 1);
- new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Valur poped. */
+ new_ref = luaL_ref(T, LUA_REGISTRYINDEX); /* Value popped. */
/* Destroy old data. */
luaL_unref(lua->T, LUA_REGISTRYINDEX, lua->Mref);
"Cache-Control: no-cache\r\n"
"Content-Type: text/html\r\n"
"\r\n"
- "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occured.\n</body></html>\n",
+ "<html><body><h1>500 Internal Server Error</h1>\nAn internal server error occurred.\n</body></html>\n",
[HTTP_ERR_502] =
"HTTP/1.1 502 Bad Gateway\r\n"
case 503: return "Service Unavailable";
case 504: return "Gateway Time-out";
case 505: return "HTTP Version not supported";
- case 506: return "Variant also negociate";
+ case 506: return "Variant also negotiate";
case 507: return "Insufficient storage";
case 508: return "Loop detected";
case 509: return "Bandwidth Limit Exceeded";
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--;
/* Skip spaces between p2 and p3 */
for (; p < end && HTTP_IS_SPHT(*p); p++);
- /* The remaing is the third value */
+ /* The remaining is the third value */
p3->ptr = p;
p3->len = end - p;
* uri.ptr and path.ptr (excluded). If it was not found, we need
* to replace from all the uri by a single "/".
*
- * Instead of rewritting the whole start line, we just update
+ * Instead of rewriting the whole start line, we just update
* the star-line URI. Some space will be lost but it should be
* insignificant.
*/
if (al >= end)
break;
- /* Start of the fisrt word. */
+ /* Start of the first word. */
token = al;
/* Look for separator: isspace(), ',' or ';'. Next value if 0 length word. */
return NULL;
}
- /* OK we just got a valid HTTP mesage. We have to convert it
+ /* OK we just got a valid HTTP message. We have to convert it
* into an HTX message.
*/
if (unlikely(h1sl.rq.v.len == 0)) {
/************************************************************************/
/* This scans a URL-encoded query string. It takes an optionally wrapping
- * string whose first contigous chunk has its beginning in ctx->a[0] and end
+ * string whose first contiguous chunk has its beginning in ctx->a[0] and end
* in ctx->a[1], and the optional second part in (ctx->a[2]..ctx->a[3]). The
* pointers are updated for next iteration before leaving.
*/
/* This function iterates over each parameter of the body. This requires
* that the body has been waited for using http-buffer-request. It uses
* ctx->a[0] and ctx->a[1] to store the beginning and end of the first
- * contigous part of the body, and optionally ctx->a[2..3] to reference the
+ * contiguous part of the body, and optionally ctx->a[2..3] to reference the
* optional second part if the body wraps at the end of the buffer. An optional
* parameter name is passed in args[0], otherwise any parameter is considered.
*/
ret = 1;
}
else if (delta > htx_free_space(htx)) {
- /* There is not enought space to handle the expansion */
+ /* There is not enough space to handle the expansion */
ret = 0;
}
else if (blk->addr+sz == htx->tail_addr) {
return ret;
}
-/* wake a specific stream and assign its conn_stream som CS_FL_* flags among
+/* wake a specific stream and assign its conn_stream some CS_FL_* flags among
* CS_FL_ERR_PENDING and CS_FL_ERROR if needed. The stream's state
* is automatically updated accordingly. If the stream is orphaned, it is
* destroyed.
* sending RST_STREAM (aborted stream).
*
* In addition, since our CLOSED streams always carry the
- * RST_RCVD bit, we don't want to accidently catch valid
+ * RST_RCVD bit, we don't want to accidentally catch valid
* frames for a closed stream, i.e. RST/PRIO/WU.
*/
h2s_error(h2s, H2_ERR_STREAM_CLOSED);
break;
case H2_FT_CONTINUATION:
- /* RFC7540#6.10: CONTINUATION may only be preceeded by
+ /* RFC7540#6.10: CONTINUATION may only be preceded by
* a HEADERS/PUSH_PROMISE/CONTINUATION frame. These
* frames' parsers consume all following CONTINUATION
* frames so this one is out of sequence.
/****************************************/
-/* MUX initialization and instanciation */
+/* MUX initialization and instantiation */
/***************************************/
/* The mux operations */
/* Initialize the mux once it's attached. It is expected that conn->ctx
* points to the existing conn_stream (for outgoing connections) or NULL (for
* incoming ones, in which case one will be allocated and a new stream will be
- * instanciated). Returns < 0 on error.
+ * instantiated). Returns < 0 on error.
*/
static int mux_pt_init(struct connection *conn, struct proxy *prx, struct session *sess,
struct buffer *input)
}
/* If we had early data, and we're done with the handshake
- * then whe know the data are safe, and we can remove the flag.
+ * then we know the data are safe, and we can remove the flag.
*/
if ((conn->flags & (CO_FL_EARLY_DATA | CO_FL_EARLY_SSL_HS | CO_FL_WAIT_XPRT)) ==
CO_FL_EARLY_DATA)
/* if current peer is local */
if (peer->local) {
- /* if current host need resyncfrom local and no process assined */
+ /* if current host need resyncfrom local and no process assigned */
if ((peers->flags & PEERS_RESYNC_STATEMASK) == PEERS_RESYNC_FROMLOCAL &&
!(peers->flags & PEERS_F_RESYNC_ASSIGN)) {
/* assign local peer for a lesson, consider lesson already requested */
}
/*
- * IO Handler to handle message exchance with a peer
+ * IO Handler to handle message exchange with a peer
*/
static void peer_io_handler(struct appctx *appctx)
{
return 1;
}
-/* get the retrans counter on a client connexion */
+/* get the retrans counter on a client connection */
static int
smp_fetch_fc_retrans(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
/* Silently limit the number of allowed matches. max
* match i the maximum value for match, in fact this
- * limit is not applyied.
+ * limit is not applied.
*/
enmatch = nmatch;
* <subject> can be modified during the processing. If the function doesn't
* match, it returns false, else it returns true.
* When it is compiled with standard POSIX regex or PCRE, this function add
- * a temporary null chracters at the end of the <subject>. The <subject> must
+ * a temporary null characters at the end of the <subject>. The <subject> must
* have a real length of <length> + 1. Currently the only supported flag is
* REG_NOTBOL.
*/
/* Silently limit the number of allowed matches. max
* match i the maximum value for match, in fact this
- * limit is not applyied.
+ * limit is not applied.
*/
enmatch = nmatch;
if (enmatch > MAX_MATCH)
*
* Note: the fetch functions are required to properly set the return type. The
* conversion functions must do so too. However the cast functions do not need
- * to since they're made to cast mutiple types according to what is required.
+ * to since they're made to cast multiple types according to what is required.
*
* The caller may indicate in <opt> if it considers the result final or not.
* The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
* +------+----------+----------+
*/
if ((a ^ b) >= 0) {
- /* signs are differents. */
+ /* signs are different. */
if (a < 0) {
if (LLONG_MIN - a > b)
return LLONG_MIN;
}
/* The multiply between LLONG_MIN and -1 returns a
- * "floting point exception".
+ * "floating point exception".
*/
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = LLONG_MAX;
if (tmp.data.u.sint) {
/* The divide between LLONG_MIN and -1 returns a
- * "floting point exception".
+ * "floating point exception".
*/
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = LLONG_MAX;
if (tmp.data.u.sint) {
/* The divide between LLONG_MIN and -1 returns a
- * "floting point exception".
+ * "floating point exception".
*/
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = 0;
}
/* tries to send <nmsg> message parts (up to 8, ignored above) from message
- * array <msg> to sink <sink>. Formating according to the sink's preference is
+ * array <msg> to sink <sink>. Formatting according to the sink's preference is
* done here. Lost messages are NOT accounted for. It is preferable to call
* sink_write() instead which will also try to emit the number of dropped
* messages when there are any. It returns >0 if it could write anything,
#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
/*
- * This function load the OCSP Resonse in DER format contained in file at
+ * This function load the OCSP Response in DER format contained in file at
* path 'ocsp_path' or base64 in a buffer <buf>
*
* Returns 0 on success, 1 in error case.
* An offset is used to adjust the current time (date), to have a monotonic time
* (now). It must be global and thread-safe. But a timeval cannot be atomically
* updated. So instead, we store it in a 64-bits integer (offset) whose 32 MSB
- * contain the signed seconds adjustment andthe 32 LSB contain the unsigned
+ * contain the signed seconds adjustment and the 32 LSB contain the unsigned
* microsecond adjustment. We cannot use a timeval for this since it's never
* clearly specified whether a timeval may hold negative values or not.
*/
/*
* Allocate an array of unsigned int with <nums> as address from <str> string
- * made of integer sepereated by dot characters.
+ * made of integer separated by dot characters.
*
* First, initializes the value with <sz> as address to 0 and initializes the
* array with <nums> as address to NULL. Then allocates the array with <nums> as
outpos++; \
} while (0)
-/* Parse <in>, copy it into <out> splitted into isolated words whose pointers
+/* Parse <in>, copy it into <out> split into isolated words whose pointers
* are put in <args>. If more than <outlen> bytes have to be emitted, the
* extraneous ones are not emitted but <outlen> is updated so that the caller
* knows how much to realloc. Similarly, <args> are not updated beyond <nbargs>
_HA_ATOMIC_SUB(&var_global_size, size);
}
-/* This function init a list of variabes. */
+/* This function init a list of variables. */
void vars_init(struct vars *vars, enum vars_scope scope)
{
LIST_INIT(&vars->head);
projects / thirdparty / haproxy.git / commitdiff
