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

Function arguments and local variables called "cs" were renamed to "sc"
in the various keyword handlers.

diff --git a/src/activity.c b/src/activity.c
index 97640f341bdf0cda9ce63c50c3afb0dd039790db..4d55f914ff0ac7265a2255fe946f7b371fc8c691 100644 (file)
--- a/src/activity.c
+++ b/src/activity.c
@@ -621,13 +621,13 @@ static int cli_io_handler_show_profiling(struct appctx *appctx)
        unsigned long long tot_alloc_calls, tot_free_calls;
        unsigned long long tot_alloc_bytes, tot_free_bytes;
 #endif
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct buffer *name_buffer = get_trash_chunk();
        const char *str;
        int max_lines;
        int i, max;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        chunk_reset(&trash);
@@ -840,7 +840,7 @@ static int cli_parse_show_profiling(char **args, char *payload, struct appctx *a
 static int cli_io_handler_show_tasks(struct appctx *appctx)
 {
        struct sched_activity tmp_activity[256] __attribute__((aligned(64)));
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct buffer *name_buffer = get_trash_chunk();
        struct sched_activity *entry;
        const struct tasklet *tl;
@@ -851,7 +851,7 @@ static int cli_io_handler_show_tasks(struct appctx *appctx)
        int thr, queue;
        int i, max;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        /* It's not possible to scan queues in small chunks and yield in the

diff --git a/src/cli.c b/src/cli.c
index 8f21b2e1787af8a75fc7011c08821203a7fcb84e..242ad7acd5ce84cc710939f5ba2b221680439e0f 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -897,14 +897,14 @@ static int cli_output_msg(struct channel *chn, const char *msg, int severity, in
  */
 static void cli_io_handler(struct appctx *appctx)
 {
-       struct stconn *cs = appctx_cs(appctx);
-       struct channel *req = sc_oc(cs);
-       struct channel *res = sc_ic(cs);
-       struct bind_conf *bind_conf = strm_li(__sc_strm(cs))->bind_conf;
+       struct stconn *sc = appctx_cs(appctx);
+       struct channel *req = sc_oc(sc);
+       struct channel *res = sc_ic(sc);
+       struct bind_conf *bind_conf = strm_li(__sc_strm(sc))->bind_conf;
        int reql;
        int len;
 
-       if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
+       if (unlikely(sc->state == SC_ST_DIS || sc->state == SC_ST_CLO))
                goto out;
 
        /* Check if the input buffer is available. */
@@ -928,7 +928,7 @@ static void cli_io_handler(struct appctx *appctx)
                        /* Let's close for real now. We just close the request
                         * side, the conditions below will complete if needed.
                         */
-                       sc_shutw(cs);
+                       sc_shutw(sc);
                        free_trash_chunk(appctx->chunk);
                        appctx->chunk = NULL;
                        break;
@@ -950,8 +950,8 @@ static void cli_io_handler(struct appctx *appctx)
                        /* ensure we have some output room left in the event we
                         * would want to return some info right after parsing.
                         */
-                       if (buffer_almost_full(sc_ib(cs))) {
-                               sc_need_room(cs);
+                       if (buffer_almost_full(sc_ib(sc))) {
+                               sc_need_room(sc);
                                break;
                        }
 
@@ -962,10 +962,10 @@ static void cli_io_handler(struct appctx *appctx)
                         */
 
                        if (appctx->st1 & APPCTX_CLI_ST1_PAYLOAD)
-                               reql = co_getline(sc_oc(cs), str,
+                               reql = co_getline(sc_oc(sc), str,
                                                  appctx->chunk->size - appctx->chunk->data - 1);
                        else
-                               reql = co_getdelim(sc_oc(cs), str,
+                               reql = co_getdelim(sc_oc(sc), str,
                                                   appctx->chunk->size - appctx->chunk->data - 1,
                                                   "\n;", '\\');
 
@@ -1050,7 +1050,7 @@ static void cli_io_handler(struct appctx *appctx)
                        }
 
                        /* re-adjust req buffer */
-                       co_skip(sc_oc(cs), reql);
+                       co_skip(sc_oc(sc), reql);
                        req->flags |= CF_READ_DONTWAIT; /* we plan to read small requests */
                }
                else {  /* output functions */
@@ -1094,7 +1094,7 @@ static void cli_io_handler(struct appctx *appctx)
                                        appctx->st0 = CLI_ST_PROMPT;
                                }
                                else
-                                       sc_need_room(cs);
+                                       sc_need_room(sc);
                                break;
 
                        case CLI_ST_CALLBACK: /* use custom pointer */
@@ -1161,39 +1161,39 @@ static void cli_io_handler(struct appctx *appctx)
                         * refills the buffer with new bytes in non-interactive
                         * mode, avoiding to close on apparently empty commands.
                         */
-                       if (co_data(sc_oc(cs))) {
+                       if (co_data(sc_oc(sc))) {
                                appctx_wakeup(appctx);
                                goto out;
                        }
                }
        }
 
-       if ((res->flags & CF_SHUTR) && (cs->state == SC_ST_EST)) {
-               DPRINTF(stderr, "%s@%d: cs to buf closed. req=%08x, res=%08x, st=%d\n",
-                       __FUNCTION__, __LINE__, req->flags, res->flags, cs->state);
+       if ((res->flags & CF_SHUTR) && (sc->state == SC_ST_EST)) {
+               DPRINTF(stderr, "%s@%d: sc to buf closed. req=%08x, res=%08x, st=%d\n",
+                       __FUNCTION__, __LINE__, req->flags, res->flags, sc->state);
                /* Other side has closed, let's abort if we have no more processing to do
                 * and nothing more to consume. This is comparable to a broken pipe, so
                 * we forward the close to the request side so that it flows upstream to
                 * the client.
                 */
-               sc_shutw(cs);
+               sc_shutw(sc);
        }
 
-       if ((req->flags & CF_SHUTW) && (cs->state == SC_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
-               DPRINTF(stderr, "%s@%d: buf to cs closed. req=%08x, res=%08x, st=%d\n",
-                       __FUNCTION__, __LINE__, req->flags, res->flags, cs->state);
+       if ((req->flags & CF_SHUTW) && (sc->state == SC_ST_EST) && (appctx->st0 < CLI_ST_OUTPUT)) {
+               DPRINTF(stderr, "%s@%d: buf to sc closed. req=%08x, res=%08x, st=%d\n",
+                       __FUNCTION__, __LINE__, req->flags, res->flags, sc->state);
                /* We have no more processing to do, and nothing more to send, and
                 * the client side has closed. So we'll forward this state downstream
                 * on the response buffer.
                 */
-               sc_shutr(cs);
+               sc_shutr(sc);
                res->flags |= CF_READ_NULL;
        }
 
  out:
        DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rqh=%lu, rqs=%lu, rh=%lu, rs=%lu\n",
                __FUNCTION__, __LINE__,
-               cs->state, req->flags, res->flags, ci_data(req), co_data(req), ci_data(res), co_data(res));
+               sc->state, req->flags, res->flags, ci_data(req), co_data(req), ci_data(res), co_data(res));
 }
 
 /* This is called when the stream connector is closed. For instance, upon an
@@ -1224,10 +1224,10 @@ static void cli_release_handler(struct appctx *appctx)
 static int cli_io_handler_show_env(struct appctx *appctx)
 {
        struct show_env_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        char **var = ctx->var;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        chunk_reset(&trash);
@@ -1259,12 +1259,12 @@ static int cli_io_handler_show_env(struct appctx *appctx)
  */
 static int cli_io_handler_show_fd(struct appctx *appctx)
 {
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct show_fd_ctx *fdctx = appctx->svcctx;
        int fd = fdctx->fd;
        int ret = 1;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto end;
 
        chunk_reset(&trash);
@@ -1458,10 +1458,10 @@ static int cli_io_handler_show_fd(struct appctx *appctx)
  */
 static int cli_io_handler_show_activity(struct appctx *appctx)
 {
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        int thr;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        chunk_reset(&trash);
@@ -1969,9 +1969,9 @@ static int _getsocks(char **args, char *payload, struct appctx *appctx, void *pr
        char *cmsgbuf = NULL;
        unsigned char *tmpbuf = NULL;
        struct cmsghdr *cmsg;
-       struct stconn *cs = appctx_cs(appctx);
-       struct stream *s = __sc_strm(cs);
-       struct connection *remote = sc_conn(sc_opposite(cs));
+       struct stconn *sc = appctx_cs(appctx);
+       struct stream *s = __sc_strm(sc);
+       struct connection *remote = sc_conn(sc_opposite(sc));
        struct msghdr msghdr;
        struct iovec iov;
        struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };

diff --git a/src/debug.c b/src/debug.c
index ca102318f0cb2685185a9e19e8987f77d019fccd..72b6720789bd26645d2be4380b78f75a548d0a52 100644 (file)
--- a/src/debug.c
+++ b/src/debug.c
@@ -290,10 +290,10 @@ void ha_task_dump(struct buffer *buf, const struct task *task, const char *pfx)
  */
 static int cli_io_handler_show_threads(struct appctx *appctx)
 {
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        int thr;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        if (appctx->st0)
@@ -1043,7 +1043,7 @@ static int debug_parse_cli_fd(char **args, char *payload, struct appctx *appctx,
 static int debug_iohandler_fd(struct appctx *appctx)
 {
        struct dev_fd_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct sockaddr_storage sa;
        struct stat statbuf;
        socklen_t salen, vlen;
@@ -1052,7 +1052,7 @@ static int debug_iohandler_fd(struct appctx *appctx)
        int ret = 1;
        int i, fd;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto end;
 
        chunk_reset(&trash);
@@ -1237,11 +1237,11 @@ static int debug_parse_cli_memstats(char **args, char *payload, struct appctx *a
 static int debug_iohandler_memstats(struct appctx *appctx)
 {
        struct dev_mem_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct mem_stats *ptr = ctx->start;
        int ret = 1;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto end;
 
        chunk_reset(&trash);

diff --git a/src/hlua.c b/src/hlua.c
index 9304983d0cb8d8c198a3c24b588e3a0026d55dba..6f16c7a5b0b7b0cc1a06255d26d6f4f296ef403e 100644 (file)
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -10143,15 +10143,15 @@ static int hlua_cli_io_handler_fct(struct appctx *appctx)
 {
        struct hlua_cli_ctx *ctx = appctx->svcctx;
        struct hlua *hlua;
-       struct stconn *cs;
+       struct stconn *sc;
        struct hlua_function *fcn;
 
        hlua = ctx->hlua;
-       cs = appctx_cs(appctx);
+       sc = appctx_cs(appctx);
        fcn = ctx->fcn;
 
        /* If the stream is disconnect or closed, ldo nothing. */
-       if (unlikely(cs->state == SC_ST_DIS || cs->state == SC_ST_CLO))
+       if (unlikely(sc->state == SC_ST_DIS || sc->state == SC_ST_CLO))
                return 1;
 
        /* Execute the function. */
@@ -10165,7 +10165,7 @@ static int hlua_cli_io_handler_fct(struct appctx *appctx)
        case HLUA_E_AGAIN:
                /* We want write. */
                if (HLUA_IS_WAKERESWR(hlua))
-                       sc_need_room(cs);
+                       sc_need_room(sc);
                /* Set the timeout. */
                if (hlua->wake_time != TICK_ETERNITY)
                        task_schedule(hlua->task, hlua->wake_time);

diff --git a/src/http_client.c b/src/http_client.c
index 4626d6fad10224d6576212760905d9ab06268b10..59ad17ea380e42c8e9f7db4cb4737621e41ad85a 100644 (file)
--- a/src/http_client.c
+++ b/src/http_client.c
@@ -195,7 +195,7 @@ err:
 static int hc_cli_io_handler(struct appctx *appctx)
 {
        struct hcli_svc_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct buffer *trash = alloc_trash_chunk();
        struct httpclient *hc = ctx->hc;
        struct http_hdr *hdrs, *hdr;
@@ -227,8 +227,8 @@ static int hc_cli_io_handler(struct appctx *appctx)
        if (ctx->flags & HC_CLI_F_RES_BODY) {
                int ret;
 
-               ret = httpclient_res_xfer(hc, sc_ib(cs));
-               channel_add_input(sc_ic(cs), ret); /* forward what we put in the buffer channel */
+               ret = httpclient_res_xfer(hc, sc_ib(sc));
+               channel_add_input(sc_ic(sc), ret); /* forward what we put in the buffer channel */
 
                if (!httpclient_data(hc)) {/* remove the flag if the buffer was emptied */
                        ctx->flags &= ~HC_CLI_F_RES_BODY;
@@ -238,8 +238,8 @@ static int hc_cli_io_handler(struct appctx *appctx)
 
        /* we must close only if F_END is the last flag */
        if (ctx->flags ==  HC_CLI_F_RES_END) {
-               sc_shutw(cs);
-               sc_shutr(cs);
+               sc_shutw(sc);
+               sc_shutr(sc);
                ctx->flags &= ~HC_CLI_F_RES_END;
                goto out;
        }
@@ -247,7 +247,7 @@ static int hc_cli_io_handler(struct appctx *appctx)
 out:
        /* we didn't clear every flags, we should come back to finish things */
        if (ctx->flags)
-               sc_need_room(cs);
+               sc_need_room(sc);
 
        free_trash_chunk(trash);
        return 0;

diff --git a/src/map.c b/src/map.c
index 76becb2823cc8aec26fd471f2b145bb597902e62..8308a7a4fdb716ffab963cb01ec89faf56c58195 100644 (file)
--- a/src/map.c
+++ b/src/map.c
@@ -345,10 +345,10 @@ struct show_map_ctx {
 static int cli_io_handler_pat_list(struct appctx *appctx)
 {
        struct show_map_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct pat_ref_elt *elt;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
                /* If we're forced to shut down, we might have to remove our
                 * reference to the last ref_elt being dumped.
                 */

diff --git a/src/mworker.c b/src/mworker.c
index 73963cd7fa835ec89f3052227c0bd5769a9adc03..e0a5df09af68a7af43c24f4f7b411c322fb88032 100644 (file)
--- a/src/mworker.c
+++ b/src/mworker.c
@@ -509,14 +509,14 @@ void mworker_cleanup_proc()
 /*  Displays workers and processes  */
 static int cli_io_handler_show_proc(struct appctx *appctx)
 {
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct mworker_proc *child;
        int old = 0;
        int up = now.tv_sec - proc_self->timestamp;
        char *uptime = NULL;
        char *reloadtxt = NULL;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        chunk_reset(&trash);

diff --git a/src/peers.c b/src/peers.c
index b0ed81c8cd176c2dd27167fccc9eece017fc32b5..88c397c89d004f48d98e2602ac75a9bc14a7fd83 100644 (file)
--- a/src/peers.c
+++ b/src/peers.c
@@ -3771,7 +3771,7 @@ static int peers_dump_head(struct buffer *msg, struct appctx *appctx, struct pee
  * Returns 0 if the output buffer is full and needs to be called again, non-zero
  * if not. Dedicated to be called by cli_io_handler_show_peers() cli I/O handler.
  */
-static int peers_dump_peer(struct buffer *msg, struct stconn *cs, struct peer *peer, int flags)
+static int peers_dump_peer(struct buffer *msg, struct stconn *sc, struct peer *peer, int flags)
 {
        struct connection *conn;
        char pn[INET6_ADDRSTRLEN];

diff --git a/src/proxy.c b/src/proxy.c
index b5b903715d15f5d83bf9ca9cbe9fe07af27f6756..02fc3ca4fe1170bf2278f89c36c687116549b34c 100644 (file)
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -2706,9 +2706,9 @@ static void dump_server_addr(const struct sockaddr_storage *addr, char *addr_str
  * ->px, the proxy's id ->only_pxid, the server's pointer from ->sv, and the
  * choice of what to dump from ->show_conn.
  */
-static int dump_servers_state(struct stconn *cs)
+static int dump_servers_state(struct stconn *sc)
 {
-       struct appctx *appctx = __sc_appctx(cs);
+       struct appctx *appctx = __sc_appctx(sc);
        struct show_srv_ctx *ctx = appctx->svcctx;
        struct proxy *px = ctx->px;
        struct server *srv;
@@ -2786,7 +2786,7 @@ static int dump_servers_state(struct stconn *cs)
 static int cli_io_handler_servers_state(struct appctx *appctx)
 {
        struct show_srv_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct proxy *curproxy;
 
        if (ctx->state == SHOW_SRV_HEAD) {
@@ -2810,7 +2810,7 @@ static int cli_io_handler_servers_state(struct appctx *appctx)
                curproxy = ctx->px;
                /* servers are only in backends */
                if ((curproxy->cap & PR_CAP_BE) && !(curproxy->cap & PR_CAP_INT)) {
-                       if (!dump_servers_state(cs))
+                       if (!dump_servers_state(sc))
                                return 0;
                }
                /* only the selected proxy is dumped */
@@ -3138,10 +3138,10 @@ static int cli_parse_show_errors(char **args, char *payload, struct appctx *appc
 static int cli_io_handler_show_errors(struct appctx *appctx)
 {
        struct show_errors_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        extern const char *monthname[12];
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        chunk_reset(&trash);
@@ -3296,7 +3296,7 @@ static int cli_io_handler_show_errors(struct appctx *appctx)
  cant_send_unlock:
        HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &ctx->px->lock);
  cant_send:
-       sc_need_room(cs);
+       sc_need_room(sc);
        return 0;
 }
 

diff --git a/src/ring.c b/src/ring.c
index ef8887a4f8529f24ceb1d28f19645f06a816c8c6..3c3dcddec94f76028acffca89b53a78b0d0ad6d4 100644 (file)
--- a/src/ring.c
+++ b/src/ring.c
@@ -290,7 +290,7 @@ int ring_attach_cli(struct ring *ring, struct appctx *appctx, uint flags)
 int cli_io_handler_show_ring(struct appctx *appctx)
 {
        struct show_ring_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct ring *ring = ctx->ring;
        struct buffer *buf = &ring->buf;
        size_t ofs = ctx->ofs;
@@ -298,7 +298,7 @@ int cli_io_handler_show_ring(struct appctx *appctx)
        size_t len, cnt;
        int ret;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                return 1;
 
        HA_RWLOCK_WRLOCK(LOGSRV_LOCK, &ring->lock);
@@ -373,7 +373,7 @@ int cli_io_handler_show_ring(struct appctx *appctx)
                /* we've drained everything and are configured to wait for more
                 * data or an event (keypress, close)
                 */
-               if (!sc_oc(cs)->output && !(sc_oc(cs)->flags & CF_SHUTW)) {
+               if (!sc_oc(sc)->output && !(sc_oc(sc)->flags & CF_SHUTW)) {
                        /* let's be woken up once new data arrive */
                        HA_RWLOCK_WRLOCK(LOGSRV_LOCK, &ring->lock);
                        LIST_APPEND(&ring->waiters, &appctx->wait_entry);
@@ -382,7 +382,7 @@ int cli_io_handler_show_ring(struct appctx *appctx)
                        ret = 0;
                }
                /* always drain all the request */
-               co_skip(sc_oc(cs), sc_oc(cs)->output);
+               co_skip(sc_oc(sc), sc_oc(sc)->output);
        }
        return ret;
 }

diff --git a/src/ssl_ckch.c b/src/ssl_ckch.c
index d658065cd7a9a796b343302cffe87b44e6be0ea9..3ac7ae5147c9aa2222c7596719cdf975f4106dec 100644 (file)
--- a/src/ssl_ckch.c
+++ b/src/ssl_ckch.c
@@ -2044,7 +2044,7 @@ void ckch_store_replace(struct ckch_store *old_ckchs, struct ckch_store *new_ckc
 static int cli_io_handler_commit_cert(struct appctx *appctx)
 {
        struct commit_cert_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        int y = 0;
        char *err = NULL;
        struct ckch_store *old_ckchs, *new_ckchs = NULL;
@@ -2054,7 +2054,7 @@ static int cli_io_handler_commit_cert(struct appctx *appctx)
        if (trash == NULL)
                goto error;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto error;
 
        while (1) {
@@ -2785,7 +2785,7 @@ static inline int __create_new_instance(struct appctx *appctx, struct ckch_inst
 static int cli_io_handler_commit_cafile_crlfile(struct appctx *appctx)
 {
        struct commit_cacrlfile_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        int y = 0;
        char *err = NULL;
        struct cafile_entry *old_cafile_entry = NULL, *new_cafile_entry = NULL;
@@ -2795,7 +2795,7 @@ static int cli_io_handler_commit_cafile_crlfile(struct appctx *appctx)
        if (trash == NULL)
                goto error;
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto error;
 
        while (1) {

diff --git a/src/ssl_crtlist.c b/src/ssl_crtlist.c
index e0651696ec635f5756b51cff6f371a0aae254ed9..ece79f553eecaa4728005b0005ad28ca70cd958c 100644 (file)
--- a/src/ssl_crtlist.c
+++ b/src/ssl_crtlist.c
@@ -1063,7 +1063,7 @@ static int cli_io_handler_add_crtlist(struct appctx *appctx)
 {
        struct add_crtlist_ctx *ctx = appctx->svcctx;
        struct bind_conf_list *bind_conf_node;
-       struct stconn *cs = appctx_cs(appctx);
+       struct stconn *sc = appctx_cs(appctx);
        struct crtlist *crtlist = ctx->crtlist;
        struct crtlist_entry *entry = ctx->entry;
        struct ckch_store *store = entry->node.key;
@@ -1079,7 +1079,7 @@ static int cli_io_handler_add_crtlist(struct appctx *appctx)
        /* for each bind_conf which use the crt-list, a new ckch_inst must be
         * created.
         */
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
                goto error;
 
        switch (ctx->state) {

diff --git a/src/stick_table.c b/src/stick_table.c
index e907ce10eeff9fcdad8e803b6f13dd7529f780ca..3e1f3a535eab391d9c4924b8954c450f773a059f 100644 (file)
--- a/src/stick_table.c
+++ b/src/stick_table.c
@@ -4663,8 +4663,8 @@ err_args:
 static int cli_io_handler_table(struct appctx *appctx)
 {
        struct show_table_ctx *ctx = appctx->svcctx;
-       struct stconn *cs = appctx_cs(appctx);
-       struct stream *s = __sc_strm(cs);
+       struct stconn *sc = appctx_cs(appctx);
+       struct stream *s = __sc_strm(sc);
        struct ebmb_node *eb;
        int skip_entry;
        int show = ctx->action == STK_CLI_ACT_SHOW;
@@ -4680,7 +4680,7 @@ static int cli_io_handler_table(struct appctx *appctx)
         *     data though.
         */
 
-       if (unlikely(sc_ic(cs)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
+       if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
                /* in case of abort, remove any refcount we might have set on an entry */
                if (ctx->state == STATE_DUMP) {
                        stksess_kill_if_expired(ctx->t, ctx->entry, 1);