This is in order to keep things consistent.
}
/* Shutdown all connections of a server. The caller must pass a termination
- * code in <why>, which must be one of SN_ERR_* indicating the reason for the
+ * code in <why>, which must be one of SF_ERR_* indicating the reason for the
* shutdown.
*/
void srv_shutdown_sessions(struct server *srv, int why);
/* Shutdown all connections of all backup servers of a proxy. The caller must
- * pass a termination code in <why>, which must be one of SN_ERR_* indicating
+ * pass a termination code in <why>, which must be one of SF_ERR_* indicating
* the reason for the shutdown.
*/
void srv_shutdown_backup_sessions(struct proxy *px, int why);
/* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_stream();
-/* kill a stream and set the termination flags to <why> (one of SN_ERR_*) */
+/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
void stream_shutdown(struct stream *stream, int why);
void stream_process_counters(struct stream *s);
static inline int si_connect(struct stream_interface *si)
{
struct connection *conn = objt_conn(si->end);
- int ret = SN_ERR_NONE;
+ int ret = SF_ERR_NONE;
if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect))
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) {
ret = conn->ctrl->connect(conn, !channel_is_empty(si_oc(si)), 0);
- if (ret != SN_ERR_NONE)
+ if (ret != SF_ERR_NONE)
return ret;
/* we need to be notified about connection establishment */
#include <types/stick_table.h>
-/* various stream flags, bits values 0x01 to 0x100 (shift 0) */
-#define SN_DIRECT 0x00000001 /* connection made on the server matching the client cookie */
-#define SN_ASSIGNED 0x00000002 /* no need to assign a server to this stream */
-#define SN_ADDR_SET 0x00000004 /* this stream's server address has been set */
-#define SN_BE_ASSIGNED 0x00000008 /* a backend was assigned. Conns are accounted. */
-
-#define SN_FORCE_PRST 0x00000010 /* force persistence here, even if server is down */
-#define SN_MONITOR 0x00000020 /* this stream comes from a monitoring system */
-#define SN_CURR_SESS 0x00000040 /* a connection is currently being counted on the server */
-#define SN_INITIALIZED 0x00000080 /* the stream was fully initialized */
-#define SN_REDISP 0x00000100 /* set if this stream was redispatched from one server to another */
-#define SN_CONN_TAR 0x00000200 /* set if this stream is turning around before reconnecting */
-#define SN_REDIRECTABLE 0x00000400 /* set if this stream is redirectable (GET or HEAD) */
-#define SN_TUNNEL 0x00000800 /* tunnel-mode stream, nothing to catch after data */
+/* Various Stream Flags, bits values 0x01 to 0x100 (shift 0) */
+#define SF_DIRECT 0x00000001 /* connection made on the server matching the client cookie */
+#define SF_ASSIGNED 0x00000002 /* no need to assign a server to this stream */
+#define SF_ADDR_SET 0x00000004 /* this stream's server address has been set */
+#define SF_BE_ASSIGNED 0x00000008 /* a backend was assigned. Conns are accounted. */
+
+#define SF_FORCE_PRST 0x00000010 /* force persistence here, even if server is down */
+#define SF_MONITOR 0x00000020 /* this stream comes from a monitoring system */
+#define SF_CURR_SESS 0x00000040 /* a connection is currently being counted on the server */
+#define SF_INITIALIZED 0x00000080 /* the stream was fully initialized */
+#define SF_REDISP 0x00000100 /* set if this stream was redispatched from one server to another */
+#define SF_CONN_TAR 0x00000200 /* set if this stream is turning around before reconnecting */
+#define SF_REDIRECTABLE 0x00000400 /* set if this stream is redirectable (GET or HEAD) */
+#define SF_TUNNEL 0x00000800 /* tunnel-mode stream, nothing to catch after data */
/* stream termination conditions, bits values 0x1000 to 0x7000 (0-9 shift 12) */
-#define SN_ERR_NONE 0x00000000 /* normal end of request */
-#define SN_ERR_LOCAL 0x00001000 /* the proxy locally processed this request => not an error */
-#define SN_ERR_CLITO 0x00002000 /* client time-out */
-#define SN_ERR_CLICL 0x00003000 /* client closed (read/write error) */
-#define SN_ERR_SRVTO 0x00004000 /* server time-out, connect time-out */
-#define SN_ERR_SRVCL 0x00005000 /* server closed (connect/read/write error) */
-#define SN_ERR_PRXCOND 0x00006000 /* the proxy decided to close (deny...) */
-#define SN_ERR_RESOURCE 0x00007000 /* the proxy encountered a lack of a local resources (fd, mem, ...) */
-#define SN_ERR_INTERNAL 0x00008000 /* the proxy encountered an internal error */
-#define SN_ERR_DOWN 0x00009000 /* the proxy killed a stream because the backend became unavailable */
-#define SN_ERR_KILLED 0x0000a000 /* the proxy killed a stream because it was asked to do so */
-#define SN_ERR_UP 0x0000b000 /* the proxy killed a stream because a preferred backend became available */
-#define SN_ERR_MASK 0x0000f000 /* mask to get only stream error flags */
-#define SN_ERR_SHIFT 12 /* bit shift */
+#define SF_ERR_NONE 0x00000000 /* normal end of request */
+#define SF_ERR_LOCAL 0x00001000 /* the proxy locally processed this request => not an error */
+#define SF_ERR_CLITO 0x00002000 /* client time-out */
+#define SF_ERR_CLICL 0x00003000 /* client closed (read/write error) */
+#define SF_ERR_SRVTO 0x00004000 /* server time-out, connect time-out */
+#define SF_ERR_SRVCL 0x00005000 /* server closed (connect/read/write error) */
+#define SF_ERR_PRXCOND 0x00006000 /* the proxy decided to close (deny...) */
+#define SF_ERR_RESOURCE 0x00007000 /* the proxy encountered a lack of a local resources (fd, mem, ...) */
+#define SF_ERR_INTERNAL 0x00008000 /* the proxy encountered an internal error */
+#define SF_ERR_DOWN 0x00009000 /* the proxy killed a stream because the backend became unavailable */
+#define SF_ERR_KILLED 0x0000a000 /* the proxy killed a stream because it was asked to do so */
+#define SF_ERR_UP 0x0000b000 /* the proxy killed a stream because a preferred backend became available */
+#define SF_ERR_MASK 0x0000f000 /* mask to get only stream error flags */
+#define SF_ERR_SHIFT 12 /* bit shift */
/* stream state at termination, bits values 0x10000 to 0x70000 (0-7 shift 16) */
-#define SN_FINST_R 0x00010000 /* stream ended during client request */
-#define SN_FINST_C 0x00020000 /* stream ended during server connect */
-#define SN_FINST_H 0x00030000 /* stream ended during server headers */
-#define SN_FINST_D 0x00040000 /* stream ended during data phase */
-#define SN_FINST_L 0x00050000 /* stream ended while pushing last data to client */
-#define SN_FINST_Q 0x00060000 /* stream ended while waiting in queue for a server slot */
-#define SN_FINST_T 0x00070000 /* stream ended tarpitted */
-#define SN_FINST_MASK 0x00070000 /* mask to get only final stream state flags */
-#define SN_FINST_SHIFT 16 /* bit shift */
-
-#define SN_IGNORE_PRST 0x00080000 /* ignore persistence */
-
-#define SN_COMP_READY 0x00100000 /* the compression is initialized */
-#define SN_SRV_REUSED 0x00200000 /* the server-side connection was reused */
+#define SF_FINST_R 0x00010000 /* stream ended during client request */
+#define SF_FINST_C 0x00020000 /* stream ended during server connect */
+#define SF_FINST_H 0x00030000 /* stream ended during server headers */
+#define SF_FINST_D 0x00040000 /* stream ended during data phase */
+#define SF_FINST_L 0x00050000 /* stream ended while pushing last data to client */
+#define SF_FINST_Q 0x00060000 /* stream ended while waiting in queue for a server slot */
+#define SF_FINST_T 0x00070000 /* stream ended tarpitted */
+#define SF_FINST_MASK 0x00070000 /* mask to get only final stream state flags */
+#define SF_FINST_SHIFT 16 /* bit shift */
+
+#define SF_IGNORE_PRST 0x00080000 /* ignore persistence */
+
+#define SF_COMP_READY 0x00100000 /* the compression is initialized */
+#define SF_SRV_REUSED 0x00200000 /* the server-side connection was reused */
/* some external definitions */
struct strm_logs {
* defined by the backend it is assigned to. The stream is then marked as
* 'assigned'.
*
- * This function MAY NOT be called with SN_ASSIGNED already set. If the stream
+ * This function MAY NOT be called with SF_ASSIGNED already set. If the stream
* had a server previously assigned, it is rebalanced, trying to avoid the same
* server, which should still be present in target_srv(&s->target) before the call.
* The function tries to keep the original connection slot if it reconnects to
* SRV_STATUS_FULL if all servers are saturated. Stream is not ASSIGNED
* SRV_STATUS_INTERNAL for other unrecoverable errors.
*
- * Upon successful return, the stream flag SN_ASSIGNED is set to indicate that
+ * Upon successful return, the stream flag SF_ASSIGNED is set to indicate that
* it does not need to be called anymore. This means that target_srv(&s->target)
* can be trusted in balance and direct modes.
*
DPRINTF(stderr,"assign_server : s=%p\n",s);
err = SRV_STATUS_INTERNAL;
- if (unlikely(s->pend_pos || s->flags & SN_ASSIGNED))
+ if (unlikely(s->pend_pos || s->flags & SF_ASSIGNED))
goto out_err;
prev_srv = objt_server(s->target);
goto out;
}
- s->flags |= SN_ASSIGNED;
+ s->flags |= SF_ASSIGNED;
err = SRV_STATUS_OK;
out:
}
/*
- * This function assigns a server address to a stream, and sets SN_ADDR_SET.
+ * This function assigns a server address to a stream, and sets SF_ADDR_SET.
* The address is taken from the currently assigned server, or from the
* dispatch or transparent address.
*
* SRV_STATUS_OK if everything is OK.
* SRV_STATUS_INTERNAL for other unrecoverable errors.
*
- * Upon successful return, the stream flag SN_ADDR_SET is set. This flag is
+ * Upon successful return, the stream flag SF_ADDR_SET is set. This flag is
* not cleared, so it's to the caller to clear it if required.
*
* The caller is responsible for having already assigned a connection
fprintf(stderr,"assign_server_address : s=%p\n",s);
#endif
- if ((s->flags & SN_DIRECT) || (s->be->lbprm.algo & BE_LB_KIND)) {
+ if ((s->flags & SF_DIRECT) || (s->be->lbprm.algo & BE_LB_KIND)) {
/* A server is necessarily known for this stream */
- if (!(s->flags & SN_ASSIGNED))
+ if (!(s->flags & SF_ASSIGNED))
return SRV_STATUS_INTERNAL;
srv_conn->addr.to = objt_server(s->target)->addr;
/* Copy network namespace from client connection */
srv_conn->proxy_netns = cli_conn ? cli_conn->proxy_netns : NULL;
- s->flags |= SN_ADDR_SET;
+ s->flags |= SF_ADDR_SET;
return SRV_STATUS_OK;
}
/* This function assigns a server to stream <s> if required, and can add the
* connection to either the assigned server's queue or to the proxy's queue.
* If ->srv_conn is set, the stream is first released from the server.
- * It may also be called with SN_DIRECT and/or SN_ASSIGNED though. It will
+ * It may also be called with SF_DIRECT and/or SF_ASSIGNED though. It will
* be called before any connection and after any retry or redispatch occurs.
*
* It is not allowed to call this function with a stream in a queue.
return SRV_STATUS_INTERNAL;
err = SRV_STATUS_OK;
- if (!(s->flags & SN_ASSIGNED)) {
+ if (!(s->flags & SF_ASSIGNED)) {
struct server *prev_srv = objt_server(s->target);
err = assign_server(s);
* update the stream's and the server's stats :
* - if the server changed :
* - set TX_CK_DOWN if txn.flags was TX_CK_VALID
- * - set SN_REDISP if it was successfully redispatched
+ * - set SF_REDISP if it was successfully redispatched
* - increment srv->redispatches and be->redispatches
* - if the server remained the same : update retries.
*/
s->txn.flags &= ~TX_CK_MASK;
s->txn.flags |= TX_CK_DOWN;
}
- s->flags |= SN_REDISP;
+ s->flags |= SF_REDISP;
prev_srv->counters.redispatches++;
s->be->be_counters.redispatches++;
} else {
switch (err) {
case SRV_STATUS_OK:
- /* we have SN_ASSIGNED set */
+ /* we have SF_ASSIGNED set */
srv = objt_server(s->target);
if (!srv)
return SRV_STATUS_OK; /* dispatch or proxy mode */
* connection slot yet. Either it is a redispatch, or it was
* assigned from persistence information (direct mode).
*/
- if ((s->flags & SN_REDIRECTABLE) && srv->rdr_len) {
+ if ((s->flags & SF_REDIRECTABLE) && srv->rdr_len) {
/* server scheduled for redirection, and already assigned. We
* don't want to go further nor check the queue.
*/
* (s->target, s->si[1].addr.to). It will assign a server if none
* is assigned yet.
* It can return one of :
- * - SN_ERR_NONE if everything's OK
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
* The server-facing stream interface is expected to hold a pre-allocated connection
* in s->si[1].conn.
*/
srv_conn = si_alloc_conn(&s->si[1], reuse);
if (!srv_conn)
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
- if (!(s->flags & SN_ADDR_SET)) {
+ if (!(s->flags & SF_ADDR_SET)) {
err = assign_server_address(s);
if (err != SRV_STATUS_OK)
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
if (!conn_xprt_ready(srv_conn)) {
/* proxies exclusively run on raw_sock right now */
conn_prepare(srv_conn, protocol_by_family(srv_conn->addr.to.ss_family), &raw_sock);
if (!objt_conn(s->si[1].end) || !objt_conn(s->si[1].end)->ctrl)
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
else
- return SN_ERR_INTERNAL; /* how did we get there ? */
+ return SF_ERR_INTERNAL; /* how did we get there ? */
/* process the case where the server requires the PROXY protocol to be sent */
srv_conn->send_proxy_ofs = 0;
else {
/* the connection is being reused, just re-attach it */
si_attach_conn(&s->si[1], srv_conn);
- s->flags |= SN_SRV_REUSED;
+ s->flags |= SF_SRV_REUSED;
}
/* flag for logging source ip/port */
err = si_connect(&s->si[1]);
- if (err != SN_ERR_NONE)
+ if (err != SF_ERR_NONE)
return err;
/* set connect timeout */
srv = objt_server(s->target);
if (srv) {
- s->flags |= SN_CURR_SESS;
+ s->flags |= SF_CURR_SESS;
srv->cur_sess++;
if (srv->cur_sess > srv->counters.cur_sess_max)
srv->counters.cur_sess_max = srv->cur_sess;
s->be->lbprm.server_take_conn(srv);
}
- return SN_ERR_NONE; /* connection is OK */
+ return SF_ERR_NONE; /* connection is OK */
}
* would bring us on the same server again. Note that s->target is set
* in this case.
*/
- if (((s->flags & (SN_DIRECT|SN_FORCE_PRST)) == SN_DIRECT) &&
+ if (((s->flags & (SF_DIRECT|SF_FORCE_PRST)) == SF_DIRECT) &&
(s->be->options & PR_O_REDISP)) {
- s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
+ s->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
goto redispatch;
}
req->buf->i,
req->analysers);
- if (s->flags & SN_ASSIGNED)
+ if (s->flags & SF_ASSIGNED)
goto no_cookie;
memset(&smp, 0, sizeof(smp));
memcmp(&addr, &(srv->addr), sizeof(addr)) == 0) {
if ((srv->state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST)) {
/* we found the server and it is usable */
- s->flags |= SN_DIRECT | SN_ASSIGNED;
+ s->flags |= SF_DIRECT | SF_ASSIGNED;
s->target = &srv->obj_type;
break;
}
* establish a server health-check that makes use of a connection.
*
* It can return one of :
- * - SN_ERR_NONE if everything's OK and tcpcheck_main() was not called
- * - SN_ERR_UP if if everything's OK and tcpcheck_main() was called
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK and tcpcheck_main() was not called
+ * - SF_ERR_UP if if everything's OK and tcpcheck_main() was called
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
* Note that we try to prevent the network stack from sending the ACK during the
* connect() when a pure TCP check is used (without PROXY protocol).
*/
/* if first step is a 'connect', then tcpcheck_main must run it */
if (r->action == TCPCHK_ACT_CONNECT) {
tcpcheck_main(conn);
- return SN_ERR_UP;
+ return SF_ERR_UP;
}
if (r->action == TCPCHK_ACT_EXPECT)
quickack = 0;
}
- ret = SN_ERR_INTERNAL;
+ ret = SF_ERR_INTERNAL;
if (proto->connect)
ret = proto->connect(conn, check->type, quickack ? 2 : 0);
conn->flags |= CO_FL_WAKE_DATA;
* establish a server health-check that makes use of a process.
*
* It can return one of :
- * - SN_ERR_NONE if everything's OK
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
*
* Blocks and then unblocks SIGCHLD
*/
int status;
pid_t pid;
- status = SN_ERR_RESOURCE;
+ status = SF_ERR_RESOURCE;
block_sigchld();
int t_con = tick_add(now_ms, px->timeout.connect);
t->expire = tick_first(t->expire, t_con);
}
- status = SN_ERR_NONE;
+ status = SF_ERR_NONE;
goto out;
}
else {
ret = connect_proc_chk(t);
switch (ret) {
- case SN_ERR_UP:
+ case SF_ERR_UP:
return t;
- case SN_ERR_NONE:
+ case SF_ERR_NONE:
/* we allow up to min(inter, timeout.connect) for a connection
* to establish but only when timeout.check is set
* as it may be to short for a full check otherwise
goto reschedule;
- case SN_ERR_SRVTO: /* ETIMEDOUT */
- case SN_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
+ case SF_ERR_SRVTO: /* ETIMEDOUT */
+ case SF_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
conn->flags |= CO_FL_ERROR;
chk_report_conn_err(conn, errno, 0);
break;
- case SN_ERR_PRXCOND:
- case SN_ERR_RESOURCE:
- case SN_ERR_INTERNAL:
+ case SF_ERR_PRXCOND:
+ case SF_ERR_RESOURCE:
+ case SF_ERR_INTERNAL:
conn->flags |= CO_FL_ERROR;
chk_report_conn_err(conn, 0, 0);
break;
ret = connect_conn_chk(t);
switch (ret) {
- case SN_ERR_UP:
+ case SF_ERR_UP:
return t;
- case SN_ERR_NONE:
+ case SF_ERR_NONE:
/* we allow up to min(inter, timeout.connect) for a connection
* to establish but only when timeout.check is set
* as it may be to short for a full check otherwise
goto reschedule;
- case SN_ERR_SRVTO: /* ETIMEDOUT */
- case SN_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
+ case SF_ERR_SRVTO: /* ETIMEDOUT */
+ case SF_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
conn->flags |= CO_FL_ERROR;
chk_report_conn_err(conn, errno, 0);
break;
- case SN_ERR_PRXCOND:
- case SN_ERR_RESOURCE:
- case SN_ERR_INTERNAL:
+ case SF_ERR_PRXCOND:
+ case SF_ERR_RESOURCE:
+ case SF_ERR_INTERNAL:
conn->flags |= CO_FL_ERROR;
chk_report_conn_err(conn, 0, 0);
break;
#endif /* USE_OPENSSL */
conn_prepare(conn, proto, xprt);
- ret = SN_ERR_INTERNAL;
+ ret = SF_ERR_INTERNAL;
if (proto->connect)
ret = proto->connect(conn,
1 /* I/O polling is always needed */,
}
/* It can return one of :
- * - SN_ERR_NONE if everything's OK
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
* Note that we try to prevent the network stack from sending the ACK during the
* connect() when a pure TCP check is used (without PROXY protocol).
*/
switch (ret) {
- case SN_ERR_NONE:
+ case SF_ERR_NONE:
/* we allow up to min(inter, timeout.connect) for a connection
* to establish but only when timeout.check is set
* as it may be to short for a full check otherwise
t->expire = tick_first(t->expire, t_con);
}
break;
- case SN_ERR_SRVTO: /* ETIMEDOUT */
- case SN_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
+ case SF_ERR_SRVTO: /* ETIMEDOUT */
+ case SF_ERR_SRVCL: /* ECONNREFUSED, ENETUNREACH, ... */
chunk_printf(&trash, "TCPCHK error establishing connection at step %d: %s",
tcpcheck_get_step_id(check), strerror(errno));
set_server_check_status(check, HCHK_STATUS_L4CON, trash.str);
goto out_end_tcpcheck;
- case SN_ERR_PRXCOND:
- case SN_ERR_RESOURCE:
- case SN_ERR_INTERNAL:
+ case SF_ERR_PRXCOND:
+ case SF_ERR_RESOURCE:
+ case SF_ERR_INTERNAL:
chunk_printf(&trash, "TCPCHK error establishing connection at step %d",
tcpcheck_get_step_id(check));
set_server_check_status(check, HCHK_STATUS_SOCKERR, trash.str);
return 1;
}
- stream_shutdown(sess, SN_ERR_KILLED);
+ stream_shutdown(sess, SF_ERR_KILLED);
return 1;
}
else if (strcmp(args[1], "sessions") == 0) {
/* kill all the stream that are on this server */
list_for_each_entry_safe(sess, sess_bck, &sv->actconns, by_srv)
if (sess->srv_conn == sv)
- stream_shutdown(sess, SN_ERR_KILLED);
+ stream_shutdown(sess, SF_ERR_KILLED);
return 1;
}
list_for_each_entry_safe(sess, sess_bck, &sv->actconns, by_srv)
if (sess->srv_conn == sv)
- stream_shutdown(sess, SN_ERR_KILLED);
+ stream_shutdown(sess, SF_ERR_KILLED);
altered_servers++;
total_servers++;
/* Remove all reference between the Lua stack and the coroutine stream. */
appctx = objt_appctx(socket->s->si[0].end);
- stream_shutdown(socket->s, SN_ERR_KILLED);
+ stream_shutdown(socket->s, SF_ERR_KILLED);
socket->s = NULL;
appctx->ctx.hlua.socket = NULL;
return 0;
/* Close the stream and remove the associated stop task. */
- stream_shutdown(socket->s, SN_ERR_KILLED);
+ stream_shutdown(socket->s, SF_ERR_KILLED);
appctx = objt_appctx(socket->s->si[0].end);
appctx->ctx.hlua.socket = NULL;
socket->s = NULL;
socket->s->si[1].conn_retries = socket_proxy.conn_retries;
/* Force destination server. */
- socket->s->flags |= SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET | SN_BE_ASSIGNED;
+ socket->s->flags |= SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET | SF_BE_ASSIGNED;
socket->s->target = &socket_tcp.obj_type;
/* This stream is added to te lists of alive streams. */
break;
case LOG_FMT_TERMSTATE: // %ts
- LOGCHAR(sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT]);
- LOGCHAR(sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT]);
+ LOGCHAR(sess_term_cond[(s->flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
+ LOGCHAR(sess_fin_state[(s->flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
*tmplog = '\0';
last_isspace = 0;
break;
case LOG_FMT_TERMSTATE_CK: // %tsc, same as TS with cookie state (for mode HTTP)
- LOGCHAR(sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT]);
- LOGCHAR(sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT]);
+ LOGCHAR(sess_term_cond[(s->flags & SF_ERR_MASK) >> SF_ERR_SHIFT]);
+ LOGCHAR(sess_fin_state[(s->flags & SF_FINST_MASK) >> SF_FINST_SHIFT]);
LOGCHAR((be->ck_opts & PR_CK_ANY) ? sess_cookie[(txn->flags & TX_CK_MASK) >> TX_CK_SHIFT] : '-');
LOGCHAR((be->ck_opts & PR_CK_ANY) ? sess_set_cookie[(txn->flags & TX_SCK_MASK) >> TX_SCK_SHIFT] : '-');
last_isspace = 0;
break;
case LOG_FMT_RETRIES: // %rq
- if (s->flags & SN_REDISP)
+ if (s->flags & SF_REDISP)
LOGCHAR('+');
ret = ltoa_o((s->si[1].conn_retries>0) ?
(be->conn_retries - s->si[1].conn_retries) :
int size, err, level;
/* if we don't want to log normal traffic, return now */
- err = (s->flags & SN_REDISP) ||
- ((s->flags & SN_ERR_MASK) > SN_ERR_LOCAL) ||
- (((s->flags & SN_ERR_MASK) == SN_ERR_NONE) &&
+ err = (s->flags & SF_REDISP) ||
+ ((s->flags & SF_ERR_MASK) > SF_ERR_LOCAL) ||
+ (((s->flags & SF_ERR_MASK) == SF_ERR_NONE) &&
(s->si[1].conn_retries != s->be->conn_retries)) ||
((s->fe->mode == PR_MODE_HTTP) && s->txn.status >= 500);
LIST_INIT(&s->back_refs);
LIST_INIT(&s->buffer_wait);
- s->flags = SN_ASSIGNED|SN_ADDR_SET;
+ s->flags = SF_ASSIGNED|SF_ADDR_SET;
/* if this session comes from a known monitoring system, we want to ignore
* it as soon as possible, which means closing it immediately for TCP.
s->txn.status = status;
bo_inject(si_ic(si), msg->str, msg->len);
}
- if (!(s->flags & SN_ERR_MASK))
+ if (!(s->flags & SF_ERR_MASK))
s->flags |= err;
- if (!(s->flags & SN_FINST_MASK))
+ if (!(s->flags & SF_FINST_MASK))
s->flags |= finst;
}
si->state = SI_ST_CLO;
/* send the message */
- http_server_error(s, si, SN_ERR_LOCAL, SN_FINST_C, 302, &trash);
+ http_server_error(s, si, SF_ERR_LOCAL, SF_FINST_C, 302, &trash);
/* FIXME: we should increase a counter of redirects per server and per backend. */
srv_inc_sess_ctr(srv);
int err_type = si->err_type;
if (err_type & SI_ET_QUEUE_ABRT)
- http_server_error(s, si, SN_ERR_CLICL, SN_FINST_Q,
+ http_server_error(s, si, SF_ERR_CLICL, SF_FINST_Q,
503, http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_CONN_ABRT)
- http_server_error(s, si, SN_ERR_CLICL, SN_FINST_C,
+ http_server_error(s, si, SF_ERR_CLICL, SF_FINST_C,
503, (s->txn.flags & TX_NOT_FIRST) ? NULL :
http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_QUEUE_TO)
- http_server_error(s, si, SN_ERR_SRVTO, SN_FINST_Q,
+ http_server_error(s, si, SF_ERR_SRVTO, SF_FINST_Q,
503, http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_QUEUE_ERR)
- http_server_error(s, si, SN_ERR_SRVCL, SN_FINST_Q,
+ http_server_error(s, si, SF_ERR_SRVCL, SF_FINST_Q,
503, http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_CONN_TO)
- http_server_error(s, si, SN_ERR_SRVTO, SN_FINST_C,
+ http_server_error(s, si, SF_ERR_SRVTO, SF_FINST_C,
503, (s->txn.flags & TX_NOT_FIRST) ? NULL :
http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_CONN_ERR)
- http_server_error(s, si, SN_ERR_SRVCL, SN_FINST_C,
- 503, (s->flags & SN_SRV_REUSED) ? NULL :
+ http_server_error(s, si, SF_ERR_SRVCL, SF_FINST_C,
+ 503, (s->flags & SF_SRV_REUSED) ? NULL :
http_error_message(s, HTTP_ERR_503));
else if (err_type & SI_ET_CONN_RES)
- http_server_error(s, si, SN_ERR_RESOURCE, SN_FINST_C,
+ http_server_error(s, si, SF_ERR_RESOURCE, SF_FINST_C,
503, (s->txn.flags & TX_NOT_FIRST) ? NULL :
http_error_message(s, HTTP_ERR_503));
else /* SI_ET_CONN_OTHER and others */
- http_server_error(s, si, SN_ERR_INTERNAL, SN_FINST_C,
+ http_server_error(s, si, SF_ERR_INTERNAL, SF_FINST_C,
500, http_error_message(s, HTTP_ERR_500));
}
if (s->comp_algo->init(&s->comp_ctx, global.tune.comp_maxlevel) < 0)
goto fail;
- s->flags |= SN_COMP_READY;
+ s->flags |= SF_COMP_READY;
/* remove Content-Length header */
ctx.idx = 0;
* msg->next = first non-visited byte
*
* At end of parsing, we may perform a capture of the error (if any), and
- * we will set a few fields (txn->meth, sn->flags/SN_REDIRECTABLE).
+ * we will set a few fields (txn->meth, sn->flags/SF_REDIRECTABLE).
* We also check for monitor-uri, logging, HTTP/0.9 to 1.0 conversion, and
* finally headers capture.
*/
/* 2: have we encountered a read error ? */
else if (req->flags & CF_READ_ERROR) {
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
if (txn->flags & TX_WAIT_NEXT_RQ)
goto failed_keep_alive;
if (s->listener->counters)
s->listener->counters->failed_req++;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
/* 3: has the read timeout expired ? */
else if (req->flags & CF_READ_TIMEOUT || tick_is_expired(req->analyse_exp, now_ms)) {
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLITO;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLITO;
if (txn->flags & TX_WAIT_NEXT_RQ)
goto failed_keep_alive;
if (s->listener->counters)
s->listener->counters->failed_req++;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
/* 4: have we encountered a close ? */
else if (req->flags & CF_SHUTR) {
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
if (txn->flags & TX_WAIT_NEXT_RQ)
goto failed_keep_alive;
if (s->listener->counters)
s->listener->counters->failed_req++;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
/* we can make use of server redirect on GET and HEAD */
if (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)
- s->flags |= SN_REDIRECTABLE;
+ s->flags |= SF_REDIRECTABLE;
/*
* 2: check if the URI matches the monitor_uri.
*/
struct acl_cond *cond;
- s->flags |= SN_MONITOR;
+ s->flags |= SF_MONITOR;
s->fe->fe_counters.intercepted_req++;
/* Check if we want to fail this monitor request or not */
/* we fail this request, let's return 503 service unavail */
txn->status = 503;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_503));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_LOCAL; /* we don't want a real error here */
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_LOCAL; /* we don't want a real error here */
goto return_prx_cond;
}
}
/* nothing to fail, let's reply normaly */
txn->status = 200;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_200));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_LOCAL; /* we don't want a real error here */
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_LOCAL; /* we don't want a real error here */
goto return_prx_cond;
}
s->listener->counters->failed_req++;
return_prx_cond:
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
req->analysers = 0;
req->analyse_exp = TICK_ETERNITY;
txn->req.chn->analysers = 0;
}
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_LOCAL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_LOCAL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 1;
}
s->logs.tv_request = now;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_500));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_RESOURCE;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_RESOURCE;
goto return_prx_cond;
}
if (s->fe == s->be) /* report it if the request was intercepted by the frontend */
s->fe->fe_counters.intercepted_req++;
- if (!(s->flags & SN_ERR_MASK)) // this is not really an error but it is
- s->flags |= SN_ERR_LOCAL; // to mark that it comes from the proxy
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK)) // this is not really an error but it is
+ s->flags |= SF_ERR_LOCAL; // to mark that it comes from the proxy
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
/* we may want to compress the stats page */
if (s->fe->comp || s->be->comp)
s->listener->counters->failed_req++;
return_prx_cond:
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
req->analysers = 0;
req->analyse_exp = TICK_ETERNITY;
* incoming request. Note that this requires that a connection is
* allocated on the server side.
*/
- if ((s->be->options & PR_O_HTTP_PROXY) && !(s->flags & SN_ADDR_SET)) {
+ if ((s->be->options & PR_O_HTTP_PROXY) && !(s->flags & SF_ADDR_SET)) {
struct connection *conn;
char *path;
req->analysers = 0;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_500));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_RESOURCE;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_RESOURCE;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
*/
/* It needs to look into the URI unless persistence must be ignored */
- if ((txn->sessid == NULL) && s->be->appsession_name && !(s->flags & SN_IGNORE_PRST)) {
+ if ((txn->sessid == NULL) && s->be->appsession_name && !(s->flags & SF_IGNORE_PRST)) {
get_srv_from_appsession(s, req->buf->p + msg->sl.rq.u, msg->sl.rq.u_l);
}
* with a POST request, we may be interested in checking the body for
* that parameter. This will be done in another analyser.
*/
- if (!(s->flags & (SN_ASSIGNED|SN_DIRECT)) &&
+ if (!(s->flags & (SF_ASSIGNED|SF_DIRECT)) &&
s->txn.meth == HTTP_METH_POST && s->be->url_param_name != NULL &&
(msg->flags & (HTTP_MSGF_CNT_LEN|HTTP_MSGF_TE_CHNK))) {
channel_dont_connect(req);
if (s->listener->counters)
s->listener->counters->failed_req++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
req->analysers = 0;
req->analyse_exp = TICK_ETERNITY;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_T;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_T;
return 0;
}
txn->status = 408;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_408));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLITO;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLITO;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
goto return_err_msg;
}
txn->status = 400;
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_400));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return_err_msg:
req->analysers = 0;
si_shutw(&s->si[1]);
}
- if (s->flags & SN_BE_ASSIGNED) {
+ if (s->flags & SF_BE_ASSIGNED) {
s->be->beconn--;
if (unlikely(s->srv_conn))
sess_change_server(s, NULL);
if (s->fe->mode == PR_MODE_HTTP) {
s->fe->fe_counters.p.http.rsp[n]++;
- if (s->comp_algo && (s->flags & SN_COMP_READY))
+ if (s->comp_algo && (s->flags & SF_COMP_READY))
s->fe->fe_counters.p.http.comp_rsp++;
}
- if ((s->flags & SN_BE_ASSIGNED) &&
+ if ((s->flags & SF_BE_ASSIGNED) &&
(s->be->mode == PR_MODE_HTTP)) {
s->be->be_counters.p.http.rsp[n]++;
s->be->be_counters.p.http.cum_req++;
- if (s->comp_algo && (s->flags & SN_COMP_READY))
+ if (s->comp_algo && (s->flags & SF_COMP_READY))
s->be->be_counters.p.http.comp_rsp++;
}
}
/* let's do a final log if we need it */
if (!LIST_ISEMPTY(&s->fe->logformat) && s->logs.logwait &&
- !(s->flags & SN_MONITOR) &&
+ !(s->flags & SF_MONITOR) &&
(!(s->fe->options & PR_O_NULLNOLOG) || s->req.total)) {
s->do_log(s);
}
pendconn_free(s->pend_pos);
if (objt_server(s->target)) {
- if (s->flags & SN_CURR_SESS) {
- s->flags &= ~SN_CURR_SESS;
+ if (s->flags & SF_CURR_SESS) {
+ s->flags &= ~SF_CURR_SESS;
objt_server(s->target)->cur_sess--;
}
if (may_dequeue_tasks(objt_server(s->target), s->be))
s->si[1].flags &= SI_FL_ISBACK | SI_FL_DONT_WAKE; /* we're in the context of process_stream */
s->req.flags &= ~(CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CONNECT|CF_WRITE_ERROR|CF_STREAMER|CF_STREAMER_FAST|CF_NEVER_WAIT|CF_WAKE_CONNECT|CF_WROTE_DATA);
s->res.flags &= ~(CF_SHUTR|CF_SHUTR_NOW|CF_READ_ATTACHED|CF_READ_ERROR|CF_READ_NOEXP|CF_STREAMER|CF_STREAMER_FAST|CF_WRITE_PARTIAL|CF_NEVER_WAIT|CF_WROTE_DATA);
- s->flags &= ~(SN_DIRECT|SN_ASSIGNED|SN_ADDR_SET|SN_BE_ASSIGNED|SN_FORCE_PRST|SN_IGNORE_PRST);
- s->flags &= ~(SN_CURR_SESS|SN_REDIRECTABLE|SN_SRV_REUSED);
- s->flags &= ~(SN_ERR_MASK|SN_FINST_MASK|SN_REDISP);
+ s->flags &= ~(SF_DIRECT|SF_ASSIGNED|SF_ADDR_SET|SF_BE_ASSIGNED|SF_FORCE_PRST|SF_IGNORE_PRST);
+ s->flags &= ~(SF_CURR_SESS|SF_REDIRECTABLE|SF_SRV_REUSED);
+ s->flags &= ~(SF_ERR_MASK|SF_FINST_MASK|SF_REDISP);
s->txn.meth = 0;
http_reset_txn(s);
/* stop waiting for data if the input is closed before the end */
if (req->flags & CF_SHUTR) {
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
- if (!(s->flags & SN_FINST_MASK)) {
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
+ if (!(s->flags & SF_FINST_MASK)) {
if (txn->rsp.msg_state < HTTP_MSG_ERROR)
- s->flags |= SN_FINST_H;
+ s->flags |= SF_FINST_H;
else
- s->flags |= SN_FINST_D;
+ s->flags |= SF_FINST_D;
}
s->fe->fe_counters.cli_aborts++;
req->analysers = 0;
s->res.analysers = 0; /* we're in data phase, we want to abort both directions */
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK)) {
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK)) {
if (txn->rsp.msg_state < HTTP_MSG_ERROR)
- s->flags |= SN_FINST_H;
+ s->flags |= SF_FINST_H;
else
- s->flags |= SN_FINST_D;
+ s->flags |= SF_FINST_D;
}
return 0;
if (objt_server(s->target))
objt_server(s->target)->counters.srv_aborts++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVCL;
- if (!(s->flags & SN_FINST_MASK)) {
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVCL;
+ if (!(s->flags & SF_FINST_MASK)) {
if (txn->rsp.msg_state < HTTP_MSG_ERROR)
- s->flags |= SN_FINST_H;
+ s->flags |= SF_FINST_H;
else
- s->flags |= SN_FINST_D;
+ s->flags |= SF_FINST_D;
}
return 0;
}
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_502));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
return 0;
}
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_502));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVCL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVCL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
return 0;
}
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_504));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVTO;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVTO;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
return 0;
}
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_400));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
/* process_stream() will take care of the error */
return 0;
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_502));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVCL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVCL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
return 0;
}
rep->analysers = 0;
channel_auto_close(rep);
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
/* process_stream() will take care of the error */
return 0;
s->si[1].flags |= SI_FL_NOLINGER;
channel_truncate(rep);
stream_int_retnclose(&s->si[0], http_error_message(s, HTTP_ERR_502));
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_H;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_H;
return 0;
}
}
*/
if (objt_server(s->target) && (s->be->ck_opts & PR_CK_INS) &&
!((txn->flags & TX_SCK_FOUND) && (s->be->ck_opts & PR_CK_PSV)) &&
- (!(s->flags & SN_DIRECT) ||
+ (!(s->flags & SF_DIRECT) ||
((s->be->cookie_maxidle || txn->cookie_last_date) &&
(!txn->cookie_last_date || (txn->cookie_last_date - date.tv_sec) < 0)) ||
(s->be->cookie_maxlife && !txn->cookie_first_date) || // set the first_date
(!s->be->cookie_maxlife && txn->cookie_first_date)) && // remove the first_date
(!(s->be->ck_opts & PR_CK_POST) || (txn->meth == HTTP_METH_POST)) &&
- !(s->flags & SN_IGNORE_PRST)) {
+ !(s->flags & SF_IGNORE_PRST)) {
/* the server is known, it's not the one the client requested, or the
* cookie's last seen date needs to be refreshed. We have to
* insert a set-cookie here, except if we want to insert only on POST
goto return_bad_resp;
txn->flags &= ~TX_SCK_MASK;
- if (objt_server(s->target)->cookie && (s->flags & SN_DIRECT))
+ if (objt_server(s->target)->cookie && (s->flags & SF_DIRECT))
/* the server did not change, only the date was updated */
txn->flags |= TX_SCK_UPDATED;
else
if (res->flags & CF_SHUTR) {
if ((s->req.flags & (CF_SHUTR|CF_SHUTW)) == (CF_SHUTR|CF_SHUTW))
goto aborted_xfer;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVCL;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVCL;
s->be->be_counters.srv_aborts++;
if (objt_server(s->target))
objt_server(s->target)->counters.srv_aborts++;
if (objt_server(s->target))
health_adjust(objt_server(s->target), HANA_STATUS_HTTP_HDRRSP);
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
return 0;
aborted_xfer:
if (objt_server(s->target))
objt_server(s->target)->counters.cli_aborts++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
return 0;
}
if (strcmp(srv->id, asession->serverid) == 0) {
if ((srv->state != SRV_ST_STOPPED) ||
(s->be->options & PR_O_PERSIST) ||
- (s->flags & SN_FORCE_PRST)) {
+ (s->flags & SF_FORCE_PRST)) {
/* we found the server and it's usable */
txn->flags &= ~TX_CK_MASK;
txn->flags |= (srv->state != SRV_ST_STOPPED) ? TX_CK_VALID : TX_CK_DOWN;
- s->flags |= SN_DIRECT | SN_ASSIGNED;
+ s->flags |= SF_DIRECT | SF_ASSIGNED;
s->target = &srv->obj_type;
break;
* empty cookies and mark them as invalid.
* The same behaviour is applied when persistence must be ignored.
*/
- if ((delim == val_beg) || (s->flags & (SN_IGNORE_PRST | SN_ASSIGNED)))
+ if ((delim == val_beg) || (s->flags & (SF_IGNORE_PRST | SF_ASSIGNED)))
srv = NULL;
while (srv) {
!memcmp(val_beg, srv->cookie, delim - val_beg)) {
if ((srv->state != SRV_ST_STOPPED) ||
(s->be->options & PR_O_PERSIST) ||
- (s->flags & SN_FORCE_PRST)) {
+ (s->flags & SF_FORCE_PRST)) {
/* we found the server and we can use it */
txn->flags &= ~TX_CK_MASK;
txn->flags |= (srv->state != SRV_ST_STOPPED) ? TX_CK_VALID : TX_CK_DOWN;
- s->flags |= SN_DIRECT | SN_ASSIGNED;
+ s->flags |= SF_DIRECT | SF_ASSIGNED;
s->target = &srv->obj_type;
break;
} else {
if (!srv && !(txn->flags & (TX_CK_DOWN|TX_CK_EXPIRED|TX_CK_OLD))) {
/* no server matched this cookie or we deliberately skipped it */
txn->flags &= ~TX_CK_MASK;
- if ((s->flags & (SN_IGNORE_PRST | SN_ASSIGNED)))
+ if ((s->flags & (SF_IGNORE_PRST | SF_ASSIGNED)))
txn->flags |= TX_CK_UNUSED;
else
txn->flags |= TX_CK_INVALID;
}
/* Look for the appsession cookie unless persistence must be ignored */
- if (!(s->flags & SN_IGNORE_PRST) && (s->be->appsession_name != NULL)) {
+ if (!(s->flags & SF_IGNORE_PRST) && (s->be->appsession_name != NULL)) {
int cmp_len, value_len;
char *value_begin;
srv = objt_server(s->target);
/* now check if we need to process it for persistence */
- if (!(s->flags & SN_IGNORE_PRST) &&
+ if (!(s->flags & SF_IGNORE_PRST) &&
(att_end - att_beg == s->be->cookie_len) && (s->be->cookie_name != NULL) &&
(memcmp(att_beg, s->be->cookie_name, att_end - att_beg) == 0)) {
/* assume passive cookie by default */
*/
}
else if ((srv && (s->be->ck_opts & PR_CK_INS)) ||
- ((s->flags & SN_DIRECT) && (s->be->ck_opts & PR_CK_IND))) {
+ ((s->flags & SF_DIRECT) && (s->be->ck_opts & PR_CK_IND))) {
/* this cookie must be deleted */
if (*prev == ':' && next == hdr_end) {
/* whole header */
}
}
/* next, let's see if the cookie is our appcookie, unless persistence must be ignored */
- else if (!(s->flags & SN_IGNORE_PRST) && (s->be->appsession_name != NULL)) {
+ else if (!(s->flags & SF_IGNORE_PRST) && (s->be->appsession_name != NULL)) {
int cmp_len, value_len;
char *value_begin;
struct http_txn *txn = &s->txn;
/* release any possible compression context */
- if (s->flags & SN_COMP_READY)
+ if (s->flags & SF_COMP_READY)
s->comp_algo->end(&s->comp_ctx);
s->comp_algo = NULL;
- s->flags &= ~SN_COMP_READY;
+ s->flags &= ~SF_COMP_READY;
/* these ones will have been dynamically allocated */
pool_free2(pool2_requri, txn->uri);
txn->meth = find_http_meth(msg->chn->buf->p, msg->sl.rq.m_l);
if (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)
- s->flags |= SN_REDIRECTABLE;
+ s->flags |= SF_REDIRECTABLE;
if (unlikely(msg->sl.rq.v_l == 0) && !http_upgrade_v09_to_v10(txn))
return 0;
* Note that a pending send_proxy message accounts for data.
*
* It can return one of :
- * - SN_ERR_NONE if everything's OK
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
*
- * The connection's fd is inserted only when SN_ERR_NONE is returned, otherwise
+ * The connection's fd is inserted only when SF_ERR_NONE is returned, otherwise
* it's invalid and the caller has nothing to do.
*/
break;
default:
conn->flags |= CO_FL_ERROR;
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
fd = conn->t.sock.fd = create_server_socket(conn);
/* this is a resource error */
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
if (fd >= global.maxsock) {
close(fd);
conn->err_code = CO_ER_CONF_FDLIM;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_PRXCOND; /* it is a configuration limit */
+ return SF_ERR_PRXCOND; /* it is a configuration limit */
}
if ((fcntl(fd, F_SETFL, O_NONBLOCK)==-1) ||
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
if (be->options & PR_O_TCP_SRV_KA)
be->id);
}
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
}
close(fd);
send_log(be, LOG_ERR, "Connect() failed for backend %s: %s.\n", be->id, msg);
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
} else if (errno == ETIMEDOUT) {
//qfprintf(stderr,"Connect(): ETIMEDOUT");
port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_SRVTO;
+ return SF_ERR_SRVTO;
} else {
// (errno == ECONNREFUSED || errno == ENETUNREACH || errno == EACCES || errno == EPERM)
//qfprintf(stderr,"Connect(): %d", errno);
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_SRVCL;
+ return SF_ERR_SRVCL;
}
}
if (conn_xprt_init(conn) < 0) {
conn_force_close(conn);
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
if (data)
conn_data_want_send(conn); /* prepare to send data if any */
- return SN_ERR_NONE; /* connection is OK */
+ return SF_ERR_NONE; /* connection is OK */
}
if (s->listener->counters)
s->listener->counters->denied_req++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
return 0;
}
else if (rule->action >= TCP_ACT_TRK_SC0 && rule->action <= TCP_ACT_TRK_SCMAX) {
if (s->listener->counters)
s->listener->counters->denied_resp++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
return 0;
}
else if (rule->action == TCP_ACT_CLOSE) {
if (s->listener->counters)
s->listener->counters->denied_conn++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_PRXCOND;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_PRXCOND;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
result = 0;
break;
}
* Note that a pending send_proxy message accounts for data.
*
* It can return one of :
- * - SN_ERR_NONE if everything's OK
- * - SN_ERR_SRVTO if there are no more servers
- * - SN_ERR_SRVCL if the connection was refused by the server
- * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
- * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
- * - SN_ERR_INTERNAL for any other purely internal errors
- * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ * - SF_ERR_NONE if everything's OK
+ * - SF_ERR_SRVTO if there are no more servers
+ * - SF_ERR_SRVCL if the connection was refused by the server
+ * - SF_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SF_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SF_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SF_ERR_RESOURCE, an emergency log will be emitted.
*
- * The connection's fd is inserted only when SN_ERR_NONE is returned, otherwise
+ * The connection's fd is inserted only when SF_ERR_NONE is returned, otherwise
* it's invalid and the caller has nothing to do.
*/
int uxst_connect_server(struct connection *conn, int data, int delack)
break;
default:
conn->flags |= CO_FL_ERROR;
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
if ((fd = conn->t.sock.fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
/* this is a resource error */
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
if (fd >= global.maxsock) {
close(fd);
conn->err_code = CO_ER_CONF_FDLIM;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_PRXCOND; /* it is a configuration limit */
+ return SF_ERR_PRXCOND; /* it is a configuration limit */
}
if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_INTERNAL;
+ return SF_ERR_INTERNAL;
}
/* if a send_proxy is there, there are data */
close(fd);
send_log(be, LOG_ERR, "Connect() failed for backend %s: %s.\n", be->id, msg);
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
else if (errno == ETIMEDOUT) {
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_SRVTO;
+ return SF_ERR_SRVTO;
}
else { // (errno == ECONNREFUSED || errno == ENETUNREACH || errno == EACCES || errno == EPERM)
close(fd);
conn->err_code = CO_ER_SOCK_ERR;
conn->flags |= CO_FL_ERROR;
- return SN_ERR_SRVCL;
+ return SF_ERR_SRVCL;
}
}
else {
if (conn_xprt_init(conn) < 0) {
conn_force_close(conn);
conn->flags |= CO_FL_ERROR;
- return SN_ERR_RESOURCE;
+ return SF_ERR_RESOURCE;
}
if (data)
conn_data_want_send(conn); /* prepare to send data if any */
- return SN_ERR_NONE; /* connection is OK */
+ return SF_ERR_NONE; /* connection is OK */
}
/* Set current stream's backend to <be>. Nothing is done if the
* stream already had a backend assigned, which is indicated by
- * s->flags & SN_BE_ASSIGNED.
+ * s->flags & SF_BE_ASSIGNED.
* All flags, stats and counters which need be updated are updated.
* Returns 1 if done, 0 in case of internal error, eg: lack of resource.
*/
int stream_set_backend(struct stream *s, struct proxy *be)
{
- if (s->flags & SN_BE_ASSIGNED)
+ if (s->flags & SF_BE_ASSIGNED)
return 1;
s->be = be;
be->beconn++;
if (be->options2 & PR_O2_RSPBUG_OK)
s->txn.rsp.err_pos = -1; /* let buggy responses pass */
- s->flags |= SN_BE_ASSIGNED;
+ s->flags |= SF_BE_ASSIGNED;
/* If the target backend requires HTTP processing, we have to allocate
* a struct hdr_idx for it if we did not have one.
pendconn_free(ps);
/* we want to note that the stream has now been assigned a server */
- strm->flags |= SN_ASSIGNED;
+ strm->flags |= SF_ASSIGNED;
strm->target = &srv->obj_type;
stream_add_srv_conn(strm, srv);
srv->served++;
p->strm = strm;
p->srv = srv = objt_server(strm->target);
- if (strm->flags & SN_ASSIGNED && srv) {
+ if (strm->flags & SF_ASSIGNED && srv) {
LIST_ADDQ(&srv->pendconns, &p->list);
srv->nbpend++;
strm->logs.srv_queue_size += srv->nbpend;
struct stream *strm = pc->strm;
if ((strm->be->options & (PR_O_REDISP|PR_O_PERSIST)) == PR_O_REDISP &&
- !(strm->flags & SN_FORCE_PRST)) {
+ !(strm->flags & SF_FORCE_PRST)) {
/* The REDISP option was specified. We will ignore
* cookie and force to balance or use the dispatcher.
*/
/* it's left to the dispatcher to choose a server */
- strm->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
+ strm->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
pendconn_free(pc);
task_wakeup(strm->task, TASK_WOKEN_RES);
}
/* Shutdown all connections of a server. The caller must pass a termination
- * code in <why>, which must be one of SN_ERR_* indicating the reason for the
+ * code in <why>, which must be one of SF_ERR_* indicating the reason for the
* shutdown.
*/
void srv_shutdown_streams(struct server *srv, int why)
}
/* Shutdown all connections of all backup servers of a proxy. The caller must
- * pass a termination code in <why>, which must be one of SN_ERR_* indicating
+ * pass a termination code in <why>, which must be one of SF_ERR_* indicating
* the reason for the shutdown.
*/
void srv_shutdown_backup_streams(struct proxy *px, int why)
s->proxy->lbprm.set_server_status_down(s);
if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
- srv_shutdown_streams(s, SN_ERR_DOWN);
+ srv_shutdown_streams(s, SF_ERR_DOWN);
/* we might have streams queued on this server and waiting for
* a connection. Those which are redispatchable will be queued
*/
if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
!(s->flags & SRV_F_BACKUP) && s->eweight)
- srv_shutdown_backup_streams(s->proxy, SN_ERR_UP);
+ srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
/* check if we can handle some connections queued at the proxy. We
* will take as many as we can handle.
s->proxy->lbprm.set_server_status_down(s);
if (s->onmarkeddown & HANA_ONMARKEDDOWN_SHUTDOWNSESSIONS)
- srv_shutdown_streams(s, SN_ERR_DOWN);
+ srv_shutdown_streams(s, SF_ERR_DOWN);
/* we might have streams queued on this server and waiting for
* a connection. Those which are redispatchable will be queued
*/
if ((s->onmarkedup & HANA_ONMARKEDUP_SHUTDOWNBACKUPSESSIONS) &&
!(s->flags & SRV_F_BACKUP) && s->eweight)
- srv_shutdown_backup_streams(s->proxy, SN_ERR_UP);
+ srv_shutdown_backup_streams(s->proxy, SF_ERR_UP);
/* check if we can handle some connections queued at the proxy. We
* will take as many as we can handle.
LIST_INIT(&s->back_refs);
LIST_INIT(&s->buffer_wait);
- s->flags |= SN_INITIALIZED;
+ s->flags |= SF_INITIALIZED;
s->unique_id = NULL;
t->process = l->handler;
pendconn_free(s->pend_pos);
if (objt_server(s->target)) { /* there may be requests left pending in queue */
- if (s->flags & SN_CURR_SESS) {
- s->flags &= ~SN_CURR_SESS;
+ if (s->flags & SF_CURR_SESS) {
+ s->flags &= ~SF_CURR_SESS;
objt_server(s->target)->cur_sess--;
}
if (may_dequeue_tasks(objt_server(s->target), s->be))
if (objt_server(s->target)) {
health_adjust(objt_server(s->target), HANA_STATUS_L4_ERR);
- if (s->flags & SN_CURR_SESS) {
- s->flags &= ~SN_CURR_SESS;
+ if (s->flags & SF_CURR_SESS) {
+ s->flags &= ~SF_CURR_SESS;
objt_server(s->target)->cur_sess--;
}
}
*/
if (objt_server(s->target) &&
(si->conn_retries == 0 ||
- (!(s->flags & SN_DIRECT) && s->be->srv_act > 1 &&
+ (!(s->flags & SF_DIRECT) && s->be->srv_act > 1 &&
((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR))) &&
- s->be->options & PR_O_REDISP && !(s->flags & SN_FORCE_PRST)) {
+ s->be->options & PR_O_REDISP && !(s->flags & SF_FORCE_PRST)) {
sess_change_server(s, NULL);
if (may_dequeue_tasks(objt_server(s->target), s->be))
process_srv_queue(objt_server(s->target));
- s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
+ s->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
si->state = SI_ST_REQ;
} else {
if (objt_server(s->target))
conn_err = connect_server(s);
srv = objt_server(s->target);
- if (conn_err == SN_ERR_NONE) {
+ if (conn_err == SF_ERR_NONE) {
/* state = SI_ST_CON or SI_ST_EST now */
if (srv)
srv_inc_sess_ctr(srv);
/* We have received a synchronous error. We might have to
* abort, retry immediately or redispatch.
*/
- if (conn_err == SN_ERR_INTERNAL) {
+ if (conn_err == SF_ERR_INTERNAL) {
if (!si->err_type) {
si->err_type = SI_ET_CONN_OTHER;
}
* load-balance first and go to the INI state.
*/
si->exp = TICK_ETERNITY;
- if (unlikely(!(s->flags & SN_ASSIGNED)))
+ if (unlikely(!(s->flags & SF_ASSIGNED)))
si->state = SI_ST_REQ;
else {
s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
* marked "assigned".
* FIXME: Should we force a redispatch attempt when the server is down ?
*/
- if (s->flags & SN_ASSIGNED)
+ if (s->flags & SF_ASSIGNED)
si->state = SI_ST_ASS;
else
si->state = SI_ST_REQ;
*/
static void sess_set_term_flags(struct stream *s)
{
- if (!(s->flags & SN_FINST_MASK)) {
+ if (!(s->flags & SF_FINST_MASK)) {
if (s->si[1].state < SI_ST_REQ) {
s->fe->fe_counters.failed_req++;
if (s->listener->counters)
s->listener->counters->failed_req++;
- s->flags |= SN_FINST_R;
+ s->flags |= SF_FINST_R;
}
else if (s->si[1].state == SI_ST_QUE)
- s->flags |= SN_FINST_Q;
+ s->flags |= SF_FINST_Q;
else if (s->si[1].state < SI_ST_EST)
- s->flags |= SN_FINST_C;
+ s->flags |= SF_FINST_C;
else if (s->si[1].state == SI_ST_EST || s->si[1].prev_state == SI_ST_EST)
- s->flags |= SN_FINST_D;
+ s->flags |= SF_FINST_D;
else
- s->flags |= SN_FINST_L;
+ s->flags |= SF_FINST_L;
}
}
* error code to ignore the ERR_LOCAL which is not a
* real error.
*/
- s->flags &= ~(SN_ERR_MASK | SN_FINST_MASK);
+ s->flags &= ~(SF_ERR_MASK | SF_FINST_MASK);
si_shutr(si);
si_shutw(si);
req->analysers);
/* now check whether we have some switching rules for this request */
- if (!(s->flags & SN_BE_ASSIGNED)) {
+ if (!(s->flags & SF_BE_ASSIGNED)) {
struct switching_rule *rule;
list_for_each_entry(rule, &s->fe->switching_rules, list) {
* measure also takes care of correctly setting the default
* backend if any.
*/
- if (!(s->flags & SN_BE_ASSIGNED))
+ if (!(s->flags & SF_BE_ASSIGNED))
if (!stream_set_backend(s, s->fe->defbe.be ? s->fe->defbe.be : s->be))
goto sw_failed;
}
if (ret) {
/* no rule, or the rule matches */
if (prst_rule->type == PERSIST_TYPE_FORCE) {
- s->flags |= SN_FORCE_PRST;
+ s->flags |= SF_FORCE_PRST;
} else {
- s->flags |= SN_IGNORE_PRST;
+ s->flags |= SF_IGNORE_PRST;
}
break;
}
channel_abort(&s->req);
channel_abort(&s->res);
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_RESOURCE;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_R;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_RESOURCE;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_R;
s->txn.status = 500;
s->req.analysers = 0;
req->buf->i + req->buf->o,
req->analysers);
- if (!(s->flags & SN_ASSIGNED)) {
+ if (!(s->flags & SF_ASSIGNED)) {
list_for_each_entry(rule, &px->server_rules, list) {
int ret;
if ((srv->state != SRV_ST_STOPPED) ||
(px->options & PR_O_PERSIST) ||
- (s->flags & SN_FORCE_PRST)) {
- s->flags |= SN_DIRECT | SN_ASSIGNED;
+ (s->flags & SF_FORCE_PRST)) {
+ s->flags |= SF_DIRECT | SF_ASSIGNED;
s->target = &srv->obj_type;
break;
}
struct stksess *ts;
if ((ts = stktable_lookup_key(rule->table.t, key)) != NULL) {
- if (!(s->flags & SN_ASSIGNED)) {
+ if (!(s->flags & SF_ASSIGNED)) {
struct eb32_node *node;
void *ptr;
srv = container_of(node, struct server, conf.id);
if ((srv->state != SRV_ST_STOPPED) ||
(px->options & PR_O_PERSIST) ||
- (s->flags & SN_FORCE_PRST)) {
- s->flags |= SN_DIRECT | SN_ASSIGNED;
+ (s->flags & SF_FORCE_PRST)) {
+ s->flags |= SF_DIRECT | SF_ASSIGNED;
s->target = &srv->obj_type;
}
}
s->fe->fe_counters.cli_aborts++;
if (srv)
srv->counters.cli_aborts++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_CLICL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_CLICL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
}
}
}
s->fe->fe_counters.srv_aborts++;
if (srv)
srv->counters.srv_aborts++;
- if (!(s->flags & SN_ERR_MASK))
- s->flags |= SN_ERR_SRVCL;
- if (!(s->flags & SN_FINST_MASK))
- s->flags |= SN_FINST_D;
+ if (!(s->flags & SF_ERR_MASK))
+ s->flags |= SF_ERR_SRVCL;
+ if (!(s->flags & SF_FINST_MASK))
+ s->flags |= SF_FINST_D;
}
}
/* note: maybe we should process connection errors here ? */
si_b->state = SI_ST_CLO;
srv = objt_server(s->target);
if (srv) {
- if (s->flags & SN_CURR_SESS) {
- s->flags &= ~SN_CURR_SESS;
+ if (s->flags & SF_CURR_SESS) {
+ s->flags &= ~SF_CURR_SESS;
srv->cur_sess--;
}
sess_change_server(s, NULL);
* seen any analyser who could set an error status.
*/
srv = objt_server(s->target);
- if (unlikely(!(s->flags & SN_ERR_MASK))) {
+ if (unlikely(!(s->flags & SF_ERR_MASK))) {
if (req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
/* Report it if the client got an error or a read timeout expired */
req->analysers = 0;
s->fe->fe_counters.cli_aborts++;
if (srv)
srv->counters.cli_aborts++;
- s->flags |= SN_ERR_CLICL;
+ s->flags |= SF_ERR_CLICL;
}
else if (req->flags & CF_READ_TIMEOUT) {
s->be->be_counters.cli_aborts++;
s->fe->fe_counters.cli_aborts++;
if (srv)
srv->counters.cli_aborts++;
- s->flags |= SN_ERR_CLITO;
+ s->flags |= SF_ERR_CLITO;
}
else if (req->flags & CF_WRITE_ERROR) {
s->be->be_counters.srv_aborts++;
s->fe->fe_counters.srv_aborts++;
if (srv)
srv->counters.srv_aborts++;
- s->flags |= SN_ERR_SRVCL;
+ s->flags |= SF_ERR_SRVCL;
}
else {
s->be->be_counters.srv_aborts++;
s->fe->fe_counters.srv_aborts++;
if (srv)
srv->counters.srv_aborts++;
- s->flags |= SN_ERR_SRVTO;
+ s->flags |= SF_ERR_SRVTO;
}
sess_set_term_flags(s);
}
s->fe->fe_counters.srv_aborts++;
if (srv)
srv->counters.srv_aborts++;
- s->flags |= SN_ERR_SRVCL;
+ s->flags |= SF_ERR_SRVCL;
}
else if (res->flags & CF_READ_TIMEOUT) {
s->be->be_counters.srv_aborts++;
s->fe->fe_counters.srv_aborts++;
if (srv)
srv->counters.srv_aborts++;
- s->flags |= SN_ERR_SRVTO;
+ s->flags |= SF_ERR_SRVTO;
}
else if (res->flags & CF_WRITE_ERROR) {
s->be->be_counters.cli_aborts++;
s->fe->fe_counters.cli_aborts++;
if (srv)
srv->counters.cli_aborts++;
- s->flags |= SN_ERR_CLICL;
+ s->flags |= SF_ERR_CLICL;
}
else {
s->be->be_counters.cli_aborts++;
s->fe->fe_counters.cli_aborts++;
if (srv)
srv->counters.cli_aborts++;
- s->flags |= SN_ERR_CLITO;
+ s->flags |= SF_ERR_CLITO;
}
sess_set_term_flags(s);
}
}
srv = objt_server(s->target);
- if (si_b->state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
+ if (si_b->state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
http_perform_server_redirect(s, si_b);
} while (si_b->state == SI_ST_ASS);
}
if (likely((si_f->state != SI_ST_CLO) ||
(si_b->state > SI_ST_INI && si_b->state < SI_ST_CLO))) {
- if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
+ if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED))
stream_process_counters(s);
if (si_f->state == SI_ST_EST && obj_type(si_f->end) != OBJ_TYPE_APPCTX)
}
s->fe->feconn--;
- if (s->flags & SN_BE_ASSIGNED)
+ if (s->flags & SF_BE_ASSIGNED)
s->be->beconn--;
jobs--;
if (s->listener) {
if (s->fe->mode == PR_MODE_HTTP) {
s->fe->fe_counters.p.http.rsp[n]++;
- if (s->comp_algo && (s->flags & SN_COMP_READY))
+ if (s->comp_algo && (s->flags & SF_COMP_READY))
s->fe->fe_counters.p.http.comp_rsp++;
}
- if ((s->flags & SN_BE_ASSIGNED) &&
+ if ((s->flags & SF_BE_ASSIGNED) &&
(s->be->mode == PR_MODE_HTTP)) {
s->be->be_counters.p.http.rsp[n]++;
s->be->be_counters.p.http.cum_req++;
- if (s->comp_algo && (s->flags & SN_COMP_READY))
+ if (s->comp_algo && (s->flags & SF_COMP_READY))
s->be->be_counters.p.http.comp_rsp++;
}
}
/* let's do a final log if we need it */
if (!LIST_ISEMPTY(&s->fe->logformat) && s->logs.logwait &&
- !(s->flags & SN_MONITOR) &&
+ !(s->flags & SF_MONITOR) &&
(!(s->fe->options & PR_O_NULLNOLOG) || req->total)) {
s->do_log(s);
}
int err = 0, fin = 0;
if (err_type & SI_ET_QUEUE_ABRT) {
- err = SN_ERR_CLICL;
- fin = SN_FINST_Q;
+ err = SF_ERR_CLICL;
+ fin = SF_FINST_Q;
}
else if (err_type & SI_ET_CONN_ABRT) {
- err = SN_ERR_CLICL;
- fin = SN_FINST_C;
+ err = SF_ERR_CLICL;
+ fin = SF_FINST_C;
}
else if (err_type & SI_ET_QUEUE_TO) {
- err = SN_ERR_SRVTO;
- fin = SN_FINST_Q;
+ err = SF_ERR_SRVTO;
+ fin = SF_FINST_Q;
}
else if (err_type & SI_ET_QUEUE_ERR) {
- err = SN_ERR_SRVCL;
- fin = SN_FINST_Q;
+ err = SF_ERR_SRVCL;
+ fin = SF_FINST_Q;
}
else if (err_type & SI_ET_CONN_TO) {
- err = SN_ERR_SRVTO;
- fin = SN_FINST_C;
+ err = SF_ERR_SRVTO;
+ fin = SF_FINST_C;
}
else if (err_type & SI_ET_CONN_ERR) {
- err = SN_ERR_SRVCL;
- fin = SN_FINST_C;
+ err = SF_ERR_SRVCL;
+ fin = SF_FINST_C;
}
else if (err_type & SI_ET_CONN_RES) {
- err = SN_ERR_RESOURCE;
- fin = SN_FINST_C;
+ err = SF_ERR_RESOURCE;
+ fin = SF_FINST_C;
}
else /* SI_ET_CONN_OTHER and others */ {
- err = SN_ERR_INTERNAL;
- fin = SN_FINST_C;
+ err = SF_ERR_INTERNAL;
+ fin = SF_FINST_C;
}
- if (!(s->flags & SN_ERR_MASK))
+ if (!(s->flags & SF_ERR_MASK))
s->flags |= err;
- if (!(s->flags & SN_FINST_MASK))
+ if (!(s->flags & SF_FINST_MASK))
s->flags |= fin;
}
-/* kill a stream and set the termination flags to <why> (one of SN_ERR_*) */
+/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
void stream_shutdown(struct stream *stream, int why)
{
if (stream->req.flags & (CF_SHUTW|CF_SHUTW_NOW))
channel_shutw_now(&stream->req);
channel_shutr_now(&stream->res);
stream->task->nice = 1024;
- if (!(stream->flags & SN_ERR_MASK))
+ if (!(stream->flags & SF_ERR_MASK))
stream->flags |= why;
task_wakeup(stream->task, TASK_WOKEN_OTHER);
}
projects / thirdparty / haproxy.git / commitdiff
