From: Willy Tarreau <w@1wt.eu>
Date: Fri, 27 May 2022 08:04:04 +0000 (+0200)
Subject: CLEANUP: check: rename all occurrences of stconn "cs" to "sc"
X-Git-Tag: v2.6-dev12~40
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=bde14ad4992575add4c5585e4ff6c9c9d5f0ff80;p=thirdparty%2Fhaproxy.git

CLEANUP: check: rename all occurrences of stconn "cs" to "sc"

The check struct had a "cs" field renamed to "sc", which also required
a tiny update to a few functions using it to distinguish a check from
a stream (log.c, payload.c, ssl_sample.c, tcp_sample.c, tcpcheck.c,
connection.c).

Function arguments and local variables called "cs" were renamed to "sc".
The presence of one "cs=" in the debugging traces was also turned to
"sc=" for consistency.
---

diff --git a/include/haproxy/check-t.h b/include/haproxy/check-t.h
index 4ad6ec8a1b..7ce087f3ad 100644
--- a/include/haproxy/check-t.h
+++ b/include/haproxy/check-t.h
@@ -150,7 +150,7 @@ struct check {
 	struct session *sess;			/* Health check session. */
 	struct vars vars;			/* Health check dynamic variables. */
 	struct xprt_ops *xprt;			/* transport layer operations for health checks */
-	struct stconn *cs;			/* stream connector used by health checks */
+	struct stconn *sc;			/* stream connector used by health checks */
 	struct buffer bi, bo;			/* input and output buffers to send/recv check */
 	struct buffer_wait buf_wait;            /* Wait list for buffer allocation */
 	struct task *task;			/* the task associated to the health check processing, NULL if disabled */
diff --git a/include/haproxy/check.h b/include/haproxy/check.h
index eb899512da..485c494935 100644
--- a/include/haproxy/check.h
+++ b/include/haproxy/check.h
@@ -82,7 +82,7 @@ void check_release_buf(struct check *check, struct buffer *bptr);
 const char *init_check(struct check *check, int type);
 void free_check(struct check *check);
 void check_purge(struct check *check);
-int wake_srv_chk(struct stconn *cs);
+int wake_srv_chk(struct stconn *sc);
 
 int init_srv_check(struct server *srv);
 int init_srv_agent_check(struct server *srv);
diff --git a/src/check.c b/src/check.c
index a7a7c517d9..f33e572fa4 100644
--- a/src/check.c
+++ b/src/check.c
@@ -223,11 +223,11 @@ static void check_trace(enum trace_level level, uint64_t mask,
 		return;
 
 
-	if (check->cs) {
-		struct connection *conn = sc_conn(check->cs);
+	if (check->sc) {
+		struct connection *conn = sc_conn(check->sc);
 
 		chunk_appendf(&trace_buf, " - conn=%p(0x%08x)", conn, conn ? conn->flags : 0);
-		chunk_appendf(&trace_buf, " cs=%p(0x%08x)", check->cs, check->cs->flags);
+		chunk_appendf(&trace_buf, " sc=%p(0x%08x)", check->sc, check->sc->flags);
 	}
 
 	if (mask & CHK_EV_TCPCHK) {
@@ -771,8 +771,8 @@ static int retrieve_errno_from_socket(struct connection *conn)
  */
 void chk_report_conn_err(struct check *check, int errno_bck, int expired)
 {
-	struct stconn *cs = check->cs;
-	struct connection *conn = sc_conn(cs);
+	struct stconn *sc = check->sc;
+	struct connection *conn = sc_conn(sc);
 	const char *err_msg;
 	struct buffer *chk;
 	int step;
@@ -786,7 +786,7 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
 		retrieve_errno_from_socket(conn);
 
 	if (conn && !(conn->flags & CO_FL_ERROR) &&
-	    cs && !sc_ep_test(cs, SE_FL_ERROR) && !expired)
+	    sc && !sc_ep_test(sc, SE_FL_ERROR) && !expired)
 		return;
 
 	TRACE_ENTER(CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check, 0, 0, (size_t[]){expired});
@@ -899,13 +899,13 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
 		set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
 	}
 
-	if (!cs || !conn || !conn->ctrl) {
+	if (!sc || !conn || !conn->ctrl) {
 		/* error before any connection attempt (connection allocation error or no control layer) */
 		set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
 	}
 	else if (conn->flags & CO_FL_WAIT_L4_CONN) {
 		/* L4 not established (yet) */
-		if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR))
+		if (conn->flags & CO_FL_ERROR || sc_ep_test(sc, SE_FL_ERROR))
 			set_server_check_status(check, HCHK_STATUS_L4CON, err_msg);
 		else if (expired)
 			set_server_check_status(check, HCHK_STATUS_L4TOUT, err_msg);
@@ -920,12 +920,12 @@ void chk_report_conn_err(struct check *check, int errno_bck, int expired)
 	}
 	else if (conn->flags & CO_FL_WAIT_L6_CONN) {
 		/* L6 not established (yet) */
-		if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR))
+		if (conn->flags & CO_FL_ERROR || sc_ep_test(sc, SE_FL_ERROR))
 			set_server_check_status(check, HCHK_STATUS_L6RSP, err_msg);
 		else if (expired)
 			set_server_check_status(check, HCHK_STATUS_L6TOUT, err_msg);
 	}
-	else if (conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR)) {
+	else if (conn->flags & CO_FL_ERROR || sc_ep_test(sc, SE_FL_ERROR)) {
 		/* I/O error after connection was established and before we could diagnose */
 		set_server_check_status(check, HCHK_STATUS_SOCKERR, err_msg);
 	}
@@ -1009,10 +1009,10 @@ int httpchk_build_status_header(struct server *s, struct buffer *buf)
  * It returns 0 on normal cases, <0 if at least one close() has happened on the
  * connection (eg: reconnect). It relies on tcpcheck_main().
  */
-int wake_srv_chk(struct stconn *cs)
+int wake_srv_chk(struct stconn *sc)
 {
 	struct connection *conn;
-	struct check *check = __sc_check(cs);
+	struct check *check = __sc_check(sc);
 	struct email_alertq *q = container_of(check, typeof(*q), check);
 	int ret = 0;
 
@@ -1028,10 +1028,10 @@ int wake_srv_chk(struct stconn *cs)
 	/* we may have to make progress on the TCP checks */
 	ret = tcpcheck_main(check);
 
-	cs = check->cs;
-	conn = sc_conn(cs);
+	sc = check->sc;
+	conn = sc_conn(sc);
 
-	if (unlikely(!conn || !cs || conn->flags & CO_FL_ERROR || sc_ep_test(cs, SE_FL_ERROR))) {
+	if (unlikely(!conn || !sc || conn->flags & CO_FL_ERROR || sc_ep_test(sc, SE_FL_ERROR))) {
 		/* We may get error reports bypassing the I/O handlers, typically
 		 * the case when sending a pure TCP check which fails, then the I/O
 		 * handlers above are not called. This is completely handled by the
@@ -1063,9 +1063,9 @@ int wake_srv_chk(struct stconn *cs)
 /* This function checks if any I/O is wanted, and if so, attempts to do so */
 struct task *srv_chk_io_cb(struct task *t, void *ctx, unsigned int state)
 {
-	struct stconn *cs = ctx;
+	struct stconn *sc = ctx;
 
-	wake_srv_chk(cs);
+	wake_srv_chk(sc);
 	return NULL;
 }
 
@@ -1079,7 +1079,7 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 {
 	struct check *check = context;
 	struct proxy *proxy = check->proxy;
-	struct stconn *cs;
+	struct stconn *sc;
 	struct connection *conn;
 	int rv;
 	int expired = tick_is_expired(t->expire, now_ms);
@@ -1119,8 +1119,8 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 
 		check->current_step = NULL;
 
-		check->cs = sc_new_from_check(check, SC_FL_NONE);
-		if (!check->cs) {
+		check->sc = sc_new_from_check(check, SC_FL_NONE);
+		if (!check->sc) {
 			set_server_check_status(check, HCHK_STATUS_SOCKERR, NULL);
 			goto end;
 		}
@@ -1133,13 +1133,13 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 	 * which can happen on connect timeout or error.
 	 */
 	if (check->result == CHK_RES_UNKNOWN && likely(!(check->state & CHK_ST_PURGE))) {
-		cs = check->cs;
-		conn = (cs ? sc_conn(cs) : NULL);
+		sc = check->sc;
+		conn = (sc ? sc_conn(sc) : NULL);
 
 		/* Here the connection must be defined. Otherwise the
 		 * error would have already been detected
 		 */
-		if ((conn && ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR))) || expired) {
+		if ((conn && ((conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR))) || expired) {
 			TRACE_ERROR("report connection error", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END|CHK_EV_HCHK_ERR, check);
 			chk_report_conn_err(check, 0, expired);
 		}
@@ -1148,11 +1148,11 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 				TRACE_DEVEL("closing current connection", CHK_EV_TASK_WAKE|CHK_EV_HCHK_RUN, check);
 				check->state &= ~CHK_ST_CLOSE_CONN;
 				conn = NULL;
-				if (!sc_reset_endp(check->cs)) {
+				if (!sc_reset_endp(check->sc)) {
 					/* error will be handled by tcpcheck_main().
 					 * On success, remove all flags except SE_FL_DETACHED
 					 */
-					sc_ep_clr(check->cs, ~SE_FL_DETACHED);
+					sc_ep_clr(check->sc, ~SE_FL_DETACHED);
 				}
 				tcpcheck_main(check);
 			}
@@ -1167,8 +1167,8 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 	TRACE_STATE("health-check complete or aborted", CHK_EV_TASK_WAKE|CHK_EV_HCHK_END, check);
 
 	check->current_step = NULL;
-	cs = check->cs;
-	conn = (cs ? sc_conn(cs) : NULL);
+	sc = check->sc;
+	conn = (sc ? sc_conn(sc) : NULL);
 
 	if (conn && conn->xprt) {
 		/* The check was aborted and the connection was not yet closed.
@@ -1176,12 +1176,12 @@ struct task *process_chk_conn(struct task *t, void *context, unsigned int state)
 		 * as a failed response coupled with "observe layer7" caused the
 		 * server state to be suddenly changed.
 		 */
-		sc_conn_drain_and_shut(cs);
+		sc_conn_drain_and_shut(sc);
 	}
 
-	if (cs) {
-		sc_destroy(cs);
-		cs = check->cs = NULL;
+	if (sc) {
+		sc_destroy(sc);
+		sc = check->sc = NULL;
 		conn = NULL;
 	}
 
@@ -1265,18 +1265,18 @@ int check_buf_available(void *target)
 {
 	struct check *check = target;
 
-	BUG_ON(!check->cs);
+	BUG_ON(!check->sc);
 
 	if ((check->state & CHK_ST_IN_ALLOC) && b_alloc(&check->bi)) {
 		TRACE_STATE("unblocking check, input buffer allocated", CHK_EV_TCPCHK_EXP|CHK_EV_RX_BLK, check);
 		check->state &= ~CHK_ST_IN_ALLOC;
-		tasklet_wakeup(check->cs->wait_event.tasklet);
+		tasklet_wakeup(check->sc->wait_event.tasklet);
 		return 1;
 	}
 	if ((check->state & CHK_ST_OUT_ALLOC) && b_alloc(&check->bo)) {
 		TRACE_STATE("unblocking check, output buffer allocated", CHK_EV_TCPCHK_SND|CHK_EV_TX_BLK, check);
 		check->state &= ~CHK_ST_OUT_ALLOC;
-		tasklet_wakeup(check->cs->wait_event.tasklet);
+		tasklet_wakeup(check->sc->wait_event.tasklet);
 		return 1;
 	}
 
@@ -1340,9 +1340,9 @@ void free_check(struct check *check)
 
 	check_release_buf(check, &check->bi);
 	check_release_buf(check, &check->bo);
-	if (check->cs) {
-		sc_destroy(check->cs);
-		check->cs = NULL;
+	if (check->sc) {
+		sc_destroy(check->sc);
+		check->sc = NULL;
 	}
 }
 
diff --git a/src/connection.c b/src/connection.c
index a9bbc74ca7..6bd238a63b 100644
--- a/src/connection.c
+++ b/src/connection.c
@@ -2103,7 +2103,7 @@ smp_fetch_fc_http_major(const struct arg *args, struct sample *smp, const char *
 	struct connection *conn = NULL;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
         else
                 conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -2200,7 +2200,7 @@ int smp_fetch_fc_err(const struct arg *args, struct sample *smp, const char *kw,
 	struct connection *conn;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
         else
                 conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -2227,7 +2227,7 @@ int smp_fetch_fc_err_str(const struct arg *args, struct sample *smp, const char
 	const char *err_code_str;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+                conn = (kw[0] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
         else
                 conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
diff --git a/src/log.c b/src/log.c
index 287d8a0ce7..a5cf7b14a4 100644
--- a/src/log.c
+++ b/src/log.c
@@ -1998,7 +1998,7 @@ int sess_build_logline(struct session *sess, struct stream *s, char *dst, size_t
 		be = ((obj_type(sess->origin) == OBJ_TYPE_CHECK) ? __objt_check(sess->origin)->proxy : fe);
 		txn = NULL;
 		fe_conn = objt_conn(sess->origin);
-		be_conn = ((obj_type(sess->origin) == OBJ_TYPE_CHECK) ? sc_conn(__objt_check(sess->origin)->cs) : NULL);
+		be_conn = ((obj_type(sess->origin) == OBJ_TYPE_CHECK) ? sc_conn(__objt_check(sess->origin)->sc) : NULL);
 		status = 0;
 		s_flags = SF_ERR_PRXCOND | SF_FINST_R;
 		uniq_id = _HA_ATOMIC_FETCH_ADD(&global.req_count, 1);
diff --git a/src/payload.c b/src/payload.c
index 354ef5c2f8..04d3a57f2e 100644
--- a/src/payload.c
+++ b/src/payload.c
@@ -65,7 +65,7 @@ smp_fetch_len(const struct arg *args, struct sample *smp, const char *kw, void *
 		struct check *check = __objt_check(smp->sess->origin);
 
 		/* Not accurate but kept for backward compatibility purpose */
-		smp->data.u.sint = ((check->cs && IS_HTX_SC(check->cs)) ? (htxbuf(&check->bi))->data: b_data(&check->bi));
+		smp->data.u.sint = ((check->sc && IS_HTX_SC(check->sc)) ? (htxbuf(&check->bi))->data: b_data(&check->bi));
 	}
 	else
 		return 0;
@@ -1020,7 +1020,7 @@ smp_fetch_payload_lv(const struct arg *arg_p, struct sample *smp, const char *kw
 		struct check *check = __objt_check(smp->sess->origin);
 
 		/* meaningless for HTX buffers */
-		if (check->cs && IS_HTX_SC(check->cs))
+		if (check->sc && IS_HTX_SC(check->sc))
 			return 0;
 		head = b_head(&check->bi);
 		data = b_data(&check->bi);
@@ -1089,7 +1089,7 @@ smp_fetch_payload(const struct arg *arg_p, struct sample *smp, const char *kw, v
 		struct check *check = __objt_check(smp->sess->origin);
 
 		/* meaningless for HTX buffers */
-		if (check->cs && IS_HTX_SC(check->cs))
+		if (check->sc && IS_HTX_SC(check->sc))
 			return 0;
 		head = b_head(&check->bi);
 		data = b_data(&check->bi);
diff --git a/src/ssl_sample.c b/src/ssl_sample.c
index 6b5f794d90..35fcec3b92 100644
--- a/src/ssl_sample.c
+++ b/src/ssl_sample.c
@@ -1168,7 +1168,7 @@ smp_fetch_ssl_fc(const struct arg *args, struct sample *smp, const char *kw, voi
 	struct connection *conn;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1205,7 +1205,7 @@ smp_fetch_ssl_fc_is_resumed(const struct arg *args, struct sample *smp, const ch
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1228,7 +1228,7 @@ smp_fetch_ssl_fc_cipher(const struct arg *args, struct sample *smp, const char *
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1262,7 +1262,7 @@ smp_fetch_ssl_fc_alg_keysize(const struct arg *args, struct sample *smp, const c
 	int sint;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1293,7 +1293,7 @@ smp_fetch_ssl_fc_use_keysize(const struct arg *args, struct sample *smp, const c
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1325,7 +1325,7 @@ smp_fetch_ssl_fc_npn(const struct arg *args, struct sample *smp, const char *kw,
 	smp->data.type = SMP_T_STR;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1360,7 +1360,7 @@ smp_fetch_ssl_fc_alpn(const struct arg *args, struct sample *smp, const char *kw
 	smp->data.type = SMP_T_STR;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1393,7 +1393,7 @@ smp_fetch_ssl_fc_protocol(const struct arg *args, struct sample *smp, const char
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1431,7 +1431,7 @@ smp_fetch_ssl_fc_session_id(const struct arg *args, struct sample *smp, const ch
 	smp->data.type = SMP_T_BIN;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1463,7 +1463,7 @@ smp_fetch_ssl_fc_random(const struct arg *args, struct sample *smp, const char *
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1500,7 +1500,7 @@ smp_fetch_ssl_fc_session_key(const struct arg *args, struct sample *smp, const c
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1649,7 +1649,7 @@ smp_fetch_ssl_fc_err(const struct arg *args, struct sample *smp, const char *kw,
 	struct ssl_sock_ctx *ctx;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1702,7 +1702,7 @@ smp_fetch_ssl_fc_err_str(const struct arg *args, struct sample *smp, const char
 	const char *err_code_str;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
@@ -1932,7 +1932,7 @@ smp_fetch_ssl_fc_unique_id(const struct arg *args, struct sample *smp, const cha
 	SSL *ssl;
 
 	if (obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->cs) : NULL;
+		conn = (kw[4] == 'b') ? sc_conn(__objt_check(smp->sess->origin)->sc) : NULL;
 	else
 		conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
 			smp->strm ? sc_conn(smp->strm->scb) : NULL;
diff --git a/src/tcp_sample.c b/src/tcp_sample.c
index 99bb514020..2e8a621739 100644
--- a/src/tcp_sample.c
+++ b/src/tcp_sample.c
@@ -52,7 +52,7 @@ smp_fetch_src(const struct arg *args, struct sample *smp, const char *kw, void *
 
 	if (kw[0] == 'b') { /* bc_src */
 		struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-					   ? sc_conn(__objt_check(smp->sess->origin)->cs)
+					   ? sc_conn(__objt_check(smp->sess->origin)->sc)
 					   : (smp->strm ? sc_conn(smp->strm->scb): NULL));
 		if (conn && conn_get_src(conn))
 			src = conn_src(conn);
@@ -96,7 +96,7 @@ smp_fetch_sport(const struct arg *args, struct sample *smp, const char *kw, void
 
 	if (kw[0] == 'b') { /* bc_src_port */
 		struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-					   ? sc_conn(__objt_check(smp->sess->origin)->cs)
+					   ? sc_conn(__objt_check(smp->sess->origin)->sc)
 					   : (smp->strm ? sc_conn(smp->strm->scb): NULL));
 		if (conn && conn_get_src(conn))
 			src = conn_src(conn);
@@ -131,7 +131,7 @@ smp_fetch_dst(const struct arg *args, struct sample *smp, const char *kw, void *
 
 	if (kw[0] == 'b') { /* bc_dst */
 		struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-					   ? sc_conn(__objt_check(smp->sess->origin)->cs)
+					   ? sc_conn(__objt_check(smp->sess->origin)->sc)
 					   : (smp->strm ? sc_conn(smp->strm->scb): NULL));
 		if (conn && conn_get_dst(conn))
 			dst = conn_dst(conn);
@@ -227,7 +227,7 @@ smp_fetch_dport(const struct arg *args, struct sample *smp, const char *kw, void
 
 	if (kw[0] == 'b') { /* bc_dst_port */
 		struct connection *conn = ((obj_type(smp->sess->origin) == OBJ_TYPE_CHECK)
-					   ? sc_conn(__objt_check(smp->sess->origin)->cs)
+					   ? sc_conn(__objt_check(smp->sess->origin)->sc)
 					   : (smp->strm ? sc_conn(smp->strm->scb): NULL));
 		if (conn && conn_get_dst(conn))
 			dst = conn_dst(conn);
diff --git a/src/tcpcheck.c b/src/tcpcheck.c
index 62e28e2f0b..da3d21f53a 100644
--- a/src/tcpcheck.c
+++ b/src/tcpcheck.c
@@ -821,7 +821,7 @@ enum tcpcheck_eval_ret tcpcheck_agent_expect_reply(struct check *check, struct t
 	const char *hs = NULL; /* health status      */
 	const char *as = NULL; /* admin status */
 	const char *ps = NULL; /* performance status */
-	const char *cs = NULL; /* maxconn */
+	const char *sc = NULL; /* maxconn */
 	const char *err = NULL; /* first error to report */
 	const char *wrn = NULL; /* first warning to report */
 	char *cmd, *p;
@@ -931,7 +931,7 @@ enum tcpcheck_eval_ret tcpcheck_agent_expect_reply(struct check *check, struct t
 		}
 		/* try to parse a maxconn here */
 		else if (strncasecmp(cmd, "maxconn:", strlen("maxconn:")) == 0) {
-			cs = cmd;
+			sc = cmd;
 		}
 		else {
 			/* keep a copy of the first error */
@@ -976,16 +976,16 @@ enum tcpcheck_eval_ret tcpcheck_agent_expect_reply(struct check *check, struct t
 			wrn = msg;
 	}
 
-	if (cs) {
+	if (sc) {
 		const char *msg;
 
-		cs += strlen("maxconn:");
+		sc += strlen("maxconn:");
 
 		TRACE_DEVEL("change server maxconn", CHK_EV_TCPCHK_EXP, check);
 		/* This is safe to call server_parse_maxconn_change_request
 		 * because the server lock is held during the check.
 		 */
-		msg = server_parse_maxconn_change_request(check->server, cs);
+		msg = server_parse_maxconn_change_request(check->server, sc);
 		if (!wrn || !*wrn)
 			wrn = msg;
 	}
@@ -1056,7 +1056,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 	struct proxy *proxy = check->proxy;
 	struct server *s = check->server;
 	struct task *t = check->task;
-	struct connection *conn = sc_conn(check->cs);
+	struct connection *conn = sc_conn(check->sc);
 	struct protocol *proto;
 	struct xprt_ops *xprt;
 	struct tcpcheck_rule *next;
@@ -1071,8 +1071,8 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 		if (conn->flags & CO_FL_WAIT_XPRT) {
 			/* We are still waiting for the connection establishment */
 			if (next && next->action == TCPCHK_ACT_SEND) {
-				if (!(check->cs->wait_event.events & SUB_RETRY_SEND))
-					conn->mux->subscribe(check->cs, SUB_RETRY_SEND, &check->cs->wait_event);
+				if (!(check->sc->wait_event.events & SUB_RETRY_SEND))
+					conn->mux->subscribe(check->sc, SUB_RETRY_SEND, &check->sc->wait_event);
 				ret = TCPCHK_EVAL_WAIT;
 				TRACE_DEVEL("not connected yet", CHK_EV_TCPCHK_CONN, check);
 			}
@@ -1082,7 +1082,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 		goto out;
 	}
 
-	/* Note: here check->cs = cs = conn = NULL */
+	/* Note: here check->sc = sc = conn = NULL */
 
 	/* Always release input and output buffer when a new connect is evaluated */
 	check_release_buf(check, &check->bi);
@@ -1100,14 +1100,14 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 		TRACE_ERROR("stconn allocation error", CHK_EV_TCPCHK_CONN|CHK_EV_TCPCHK_ERR, check);
 		goto out;
 	}
-	if (sc_attach_mux(check->cs, NULL, conn) < 0) {
+	if (sc_attach_mux(check->sc, NULL, conn) < 0) {
 		TRACE_ERROR("mux attach error", CHK_EV_TCPCHK_CONN|CHK_EV_TCPCHK_ERR, check);
 		conn_free(conn);
 		conn = NULL;
 		status = SF_ERR_RESOURCE;
 		goto fail_check;
 	}
-	conn->ctx = check->cs;
+	conn->ctx = check->sc;
 	conn_set_owner(conn, check->sess, NULL);
 
 	/* no client address */
@@ -1198,7 +1198,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 		goto fail_check;
 
 	conn_set_private(conn);
-	conn->ctx = check->cs;
+	conn->ctx = check->sc;
 
 #ifdef USE_OPENSSL
 	if (connect->sni)
@@ -1247,7 +1247,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 
 			mux_ops = conn_get_best_mux(conn, IST_NULL, PROTO_SIDE_BE, mode);
 		}
-		if (mux_ops && conn_install_mux(conn, mux_ops, check->cs, proxy, check->sess) < 0) {
+		if (mux_ops && conn_install_mux(conn, mux_ops, check->sc, proxy, check->sess) < 0) {
 			TRACE_ERROR("failed to install mux", CHK_EV_TCPCHK_CONN|CHK_EV_TCPCHK_ERR, check);
 			status = SF_ERR_INTERNAL;
 			goto fail_check;
@@ -1294,9 +1294,9 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
 	if (conn->flags & CO_FL_WAIT_XPRT) {
 		if (conn->mux) {
 			if (next && next->action == TCPCHK_ACT_SEND)
-				conn->mux->subscribe(check->cs, SUB_RETRY_SEND, &check->cs->wait_event);
+				conn->mux->subscribe(check->sc, SUB_RETRY_SEND, &check->sc->wait_event);
 			else
-				conn->mux->subscribe(check->cs, SUB_RETRY_RECV, &check->cs->wait_event);
+				conn->mux->subscribe(check->sc, SUB_RETRY_RECV, &check->sc->wait_event);
 		}
 		ret = TCPCHK_EVAL_WAIT;
 		TRACE_DEVEL("not connected yet", CHK_EV_TCPCHK_CONN, check);
@@ -1324,8 +1324,8 @@ enum tcpcheck_eval_ret tcpcheck_eval_send(struct check *check, struct tcpcheck_r
 {
 	enum tcpcheck_eval_ret ret = TCPCHK_EVAL_CONTINUE;
 	struct tcpcheck_send *send = &rule->send;
-	struct stconn *cs = check->cs;
-	struct connection *conn = __sc_conn(cs);
+	struct stconn *sc = check->sc;
+	struct connection *conn = __sc_conn(sc);
 	struct buffer *tmp = NULL;
 	struct htx *htx = NULL;
 	int connection_hdr = 0;
@@ -1482,16 +1482,16 @@ enum tcpcheck_eval_ret tcpcheck_eval_send(struct check *check, struct tcpcheck_r
 
   do_send:
 	TRACE_DATA("send data", CHK_EV_TCPCHK_SND|CHK_EV_TX_DATA, check);
-	if (conn->mux->snd_buf(cs, &check->bo,
+	if (conn->mux->snd_buf(sc, &check->bo,
 			       (IS_HTX_CONN(conn) ? (htxbuf(&check->bo))->data: b_data(&check->bo)), 0) <= 0) {
-		if ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR)) {
+		if ((conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR)) {
 			ret = TCPCHK_EVAL_STOP;
 			TRACE_DEVEL("connection error during send", CHK_EV_TCPCHK_SND|CHK_EV_TX_DATA|CHK_EV_TX_ERR, check);
 			goto out;
 		}
 	}
 	if ((IS_HTX_CONN(conn) && !htx_is_empty(htxbuf(&check->bo))) || (!IS_HTX_CONN(conn) && b_data(&check->bo))) {
-		conn->mux->subscribe(cs, SUB_RETRY_SEND, &cs->wait_event);
+		conn->mux->subscribe(sc, SUB_RETRY_SEND, &sc->wait_event);
 		ret = TCPCHK_EVAL_WAIT;
 		TRACE_DEVEL("data not fully sent, wait", CHK_EV_TCPCHK_SND|CHK_EV_TX_DATA, check);
 		goto out;
@@ -1534,8 +1534,8 @@ enum tcpcheck_eval_ret tcpcheck_eval_send(struct check *check, struct tcpcheck_r
  */
 enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_rule *rule)
 {
-	struct stconn *cs = check->cs;
-	struct connection *conn = __sc_conn(cs);
+	struct stconn *sc = check->sc;
+	struct connection *conn = __sc_conn(sc);
 	enum tcpcheck_eval_ret ret = TCPCHK_EVAL_CONTINUE;
 	size_t max, read, cur_read = 0;
 	int is_empty;
@@ -1543,12 +1543,12 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
 
 	TRACE_ENTER(CHK_EV_RX_DATA, check);
 
-	if (cs->wait_event.events & SUB_RETRY_RECV) {
+	if (sc->wait_event.events & SUB_RETRY_RECV) {
 		TRACE_DEVEL("waiting for response", CHK_EV_RX_DATA, check);
 		goto wait_more_data;
 	}
 
-	if (sc_ep_test(cs, SE_FL_EOS))
+	if (sc_ep_test(sc, SE_FL_EOS))
 		goto end_recv;
 
 	if (check->state & CHK_ST_IN_ALLOC) {
@@ -1565,23 +1565,23 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
 	/* errors on the connection and the stream connector were already checked */
 
 	/* prepare to detect if the mux needs more room */
-	sc_ep_clr(cs, SE_FL_WANT_ROOM);
+	sc_ep_clr(sc, SE_FL_WANT_ROOM);
 
-	while (sc_ep_test(cs, SE_FL_RCV_MORE) ||
-	       (!(conn->flags & CO_FL_ERROR) && !sc_ep_test(cs, SE_FL_ERROR | SE_FL_EOS))) {
-		max = (IS_HTX_SC(cs) ?  htx_free_space(htxbuf(&check->bi)) : b_room(&check->bi));
-		read = conn->mux->rcv_buf(cs, &check->bi, max, 0);
+	while (sc_ep_test(sc, SE_FL_RCV_MORE) ||
+	       (!(conn->flags & CO_FL_ERROR) && !sc_ep_test(sc, SE_FL_ERROR | SE_FL_EOS))) {
+		max = (IS_HTX_SC(sc) ?  htx_free_space(htxbuf(&check->bi)) : b_room(&check->bi));
+		read = conn->mux->rcv_buf(sc, &check->bi, max, 0);
 		cur_read += read;
 		if (!read ||
-		    sc_ep_test(cs, SE_FL_WANT_ROOM) ||
+		    sc_ep_test(sc, SE_FL_WANT_ROOM) ||
 		    (--read_poll <= 0) ||
 		    (read < max && read >= global.tune.recv_enough))
 			break;
 	}
 
   end_recv:
-	is_empty = (IS_HTX_SC(cs) ? htx_is_empty(htxbuf(&check->bi)) : !b_data(&check->bi));
-	if (is_empty && ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR))) {
+	is_empty = (IS_HTX_SC(sc) ? htx_is_empty(htxbuf(&check->bi)) : !b_data(&check->bi));
+	if (is_empty && ((conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR))) {
 		/* Report network errors only if we got no other data. Otherwise
 		 * we'll let the upper layers decide whether the response is OK
 		 * or not. It is very common that an RST sent by the server is
@@ -1591,13 +1591,13 @@ enum tcpcheck_eval_ret tcpcheck_eval_recv(struct check *check, struct tcpcheck_r
 		goto stop;
 	}
 	if (!cur_read) {
-		if (sc_ep_test(cs, SE_FL_EOI)) {
+		if (sc_ep_test(sc, SE_FL_EOI)) {
 			/* If EOI is set, it means there is a response or an error */
 			goto out;
 		}
 
-		if (!sc_ep_test(cs, SE_FL_WANT_ROOM | SE_FL_ERROR | SE_FL_EOS)) {
-			conn->mux->subscribe(cs, SUB_RETRY_RECV, &cs->wait_event);
+		if (!sc_ep_test(sc, SE_FL_WANT_ROOM | SE_FL_ERROR | SE_FL_EOS)) {
+			conn->mux->subscribe(sc, SUB_RETRY_RECV, &sc->wait_event);
 			TRACE_DEVEL("waiting for response", CHK_EV_RX_DATA, check);
 			goto wait_more_data;
 		}
@@ -2125,8 +2125,8 @@ enum tcpcheck_eval_ret tcpcheck_eval_action_kw(struct check *check, struct tcpch
 int tcpcheck_main(struct check *check)
 {
 	struct tcpcheck_rule *rule;
-	struct stconn *cs = check->cs;
-	struct connection *conn = sc_conn(cs);
+	struct stconn *sc = check->sc;
+	struct connection *conn = sc_conn(sc);
 	int must_read = 1, last_read = 0;
 	int retcode = 0;
 	enum tcpcheck_eval_ret eval_ret;
@@ -2139,11 +2139,11 @@ int tcpcheck_main(struct check *check)
 
 	/* Note: the stream connector and the connection may only be undefined before
 	 * the first rule evaluation (it is always a connect rule) or when the
-	 * stream connector allocation failed on a connect rule, during cs allocation.
+	 * stream connector allocation failed on a connect rule, during sc allocation.
 	 */
 
 	/* 1- check for connection error, if any */
-	if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR))
+	if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR))
 		goto out_end_tcpcheck;
 
 	/* 2- check if a rule must be resume. It happens if check->current_step
@@ -2188,7 +2188,7 @@ int tcpcheck_main(struct check *check)
 		switch (rule->action) {
 		case TCPCHK_ACT_CONNECT:
 			/* Not the first connection, release it first */
-			if (sc_conn(cs) && check->current_step != rule) {
+			if (sc_conn(sc) && check->current_step != rule) {
 				check->state |= CHK_ST_CLOSE_CONN;
 				retcode = -1;
 			}
@@ -2196,7 +2196,7 @@ int tcpcheck_main(struct check *check)
 			check->current_step = rule;
 
 			/* We are still waiting the connection gets closed */
-			if (cs && (check->state & CHK_ST_CLOSE_CONN)) {
+			if (sc && (check->state & CHK_ST_CLOSE_CONN)) {
 				TRACE_DEVEL("wait previous connection closure", CHK_EV_TCPCHK_EVAL|CHK_EV_TCPCHK_CONN, check);
 				eval_ret = TCPCHK_EVAL_WAIT;
 				break;
@@ -2206,9 +2206,9 @@ int tcpcheck_main(struct check *check)
 			eval_ret = tcpcheck_eval_connect(check, rule);
 
 			/* Refresh connection */
-			conn = sc_conn(cs);
+			conn = sc_conn(sc);
 			last_read = 0;
-			must_read = (IS_HTX_SC(cs) ? htx_is_empty(htxbuf(&check->bi)) : !b_data(&check->bi));
+			must_read = (IS_HTX_SC(sc) ? htx_is_empty(htxbuf(&check->bi)) : !b_data(&check->bi));
 			break;
 		case TCPCHK_ACT_SEND:
 			check->current_step = rule;
@@ -2225,7 +2225,7 @@ int tcpcheck_main(struct check *check)
 					goto out_end_tcpcheck;
 				else if (eval_ret == TCPCHK_EVAL_WAIT)
 					goto out;
-				last_read = ((conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR | SE_FL_EOS));
+				last_read = ((conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR | SE_FL_EOS));
 				must_read = 0;
 			}
 
@@ -2235,8 +2235,8 @@ int tcpcheck_main(struct check *check)
 
 			if (eval_ret == TCPCHK_EVAL_WAIT) {
 				check->current_step = rule->expect.head;
-				if (!(cs->wait_event.events & SUB_RETRY_RECV))
-					conn->mux->subscribe(cs, SUB_RETRY_RECV, &cs->wait_event);
+				if (!(sc->wait_event.events & SUB_RETRY_RECV))
+					conn->mux->subscribe(sc, SUB_RETRY_RECV, &sc->wait_event);
 			}
 			break;
 		case TCPCHK_ACT_ACTION_KW:
@@ -2306,7 +2306,7 @@ int tcpcheck_main(struct check *check)
 	TRACE_PROTO("tcp-check passed", CHK_EV_TCPCHK_EVAL, check);
 
   out_end_tcpcheck:
-	if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(cs, SE_FL_ERROR)) {
+	if ((conn && conn->flags & CO_FL_ERROR) || sc_ep_test(sc, SE_FL_ERROR)) {
 		TRACE_ERROR("report connection error", CHK_EV_TCPCHK_EVAL|CHK_EV_TCPCHK_ERR, check);
 		chk_report_conn_err(check, errno, 0);
 	}