CLEANUP: conn_stream: rename the conn_stream's endp to sedesc

Just like for the appctx, this is a pointer to a stream endpoint descriptor,
so let's make this explicit and not confuse it with the full endpoint. There
are very few changes thanks to the preliminary refactoring of the flags
manipulation.

diff --git a/include/haproxy/conn_stream-t.h b/include/haproxy/conn_stream-t.h
index 3e072ae..c60303d 100644 (file)
--- a/include/haproxy/conn_stream-t.h
+++ b/include/haproxy/conn_stream-t.h
@@ -192,7 +192,7 @@ struct conn_stream {
        unsigned int flags;                  /* CS_FL_* */
        unsigned int hcto;                   /* half-closed timeout (0 = unset) */
        struct wait_event wait_event;        /* We're in a wait list */
-       struct sedesc *endp;                 /* points to the end point (MUX stream or appctx) */
+       struct sedesc *sedesc;               /* points to the stream endpoint descriptor */
        enum obj_type *app;                  /* points to the applicative point (stream or check) */
        const struct data_cb *data_cb;       /* data layer callbacks. Must be set before xprt->init() */
        struct cs_app_ops *ops;              /* general operations used at the app layer */

diff --git a/include/haproxy/conn_stream.h b/include/haproxy/conn_stream.h
index 8db8f68..dae46dd 100644 (file)
--- a/include/haproxy/conn_stream.h
+++ b/include/haproxy/conn_stream.h
@@ -95,39 +95,39 @@ static forceinline uint se_fl_get(const struct sedesc *se)
 /* stream connector version */
 static forceinline void sc_ep_zero(struct conn_stream *sc)
 {
-       se_fl_zero(sc->endp);
+       se_fl_zero(sc->sedesc);
 }
 
 static forceinline void sc_ep_setall(struct conn_stream *sc, uint all)
 {
-       se_fl_setall(sc->endp, all);
+       se_fl_setall(sc->sedesc, all);
 }
 
 static forceinline void sc_ep_set(struct conn_stream *sc, uint on)
 {
-       se_fl_set(sc->endp, on);
+       se_fl_set(sc->sedesc, on);
 }
 
 static forceinline void sc_ep_clr(struct conn_stream *sc, uint off)
 {
-       se_fl_clr(sc->endp, off);
+       se_fl_clr(sc->sedesc, off);
 }
 
 static forceinline uint sc_ep_test(const struct conn_stream *sc, uint test)
 {
-       return se_fl_test(sc->endp, test);
+       return se_fl_test(sc->sedesc, test);
 }
 
 static forceinline uint sc_ep_get(const struct conn_stream *sc)
 {
-       return se_fl_get(sc->endp);
+       return se_fl_get(sc->sedesc);
 }
 
 
 /* Returns the endpoint target without any control */
 static inline void *__cs_endp_target(const struct conn_stream *cs)
 {
-       return cs->endp->se;
+       return cs->sedesc->se;
 }
 
 /* Returns the connection from a cs if the endpoint is a mux stream. Otherwise
@@ -136,7 +136,7 @@ static inline void *__cs_endp_target(const struct conn_stream *cs)
  */
 static inline struct connection *__cs_conn(const struct conn_stream *cs)
 {
-       return cs->endp->conn;
+       return cs->sedesc->conn;
 }
 static inline struct connection *cs_conn(const struct conn_stream *cs)
 {

diff --git a/src/backend.c b/src/backend.c
index eb4ad7d..55773ac 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -1574,7 +1574,7 @@ static int connect_server(struct stream *s)
                        }
 
                        if (avail >= 1) {
-                               if (srv_conn->mux->attach(srv_conn, s->csb->endp, s->sess) == -1) {
+                               if (srv_conn->mux->attach(srv_conn, s->csb->sedesc, s->sess) == -1) {
                                        srv_conn = NULL;
                                        if (cs_reset_endp(s->csb) < 0)
                                                return SF_ERR_INTERNAL;

diff --git a/src/cli.c b/src/cli.c
index 9d17df9..fe29583 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -2782,7 +2782,7 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                                        s->srv_error(s, s->csb);
                                return 1;
                        }
-                       se_fl_clr(s->csb->endp, ~SE_FL_DETACHED);
+                       se_fl_clr(s->csb->sedesc, ~SE_FL_DETACHED);
                }
 
                sockaddr_free(&s->csb->dst);

diff --git a/src/conn_stream.c b/src/conn_stream.c
index da81d27..e84021f 100644 (file)
--- a/src/conn_stream.c
+++ b/src/conn_stream.c
@@ -142,7 +142,7 @@ static struct conn_stream *cs_new(struct sedesc *sedesc)
                if (unlikely(!sedesc))
                        goto alloc_error;
        }
-       cs->endp = sedesc;
+       cs->sedesc = sedesc;
        sedesc->cs = cs;
 
        return cs;
@@ -215,9 +215,9 @@ void cs_free(struct conn_stream *cs)
 {
        sockaddr_free(&cs->src);
        sockaddr_free(&cs->dst);
-       if (cs->endp) {
+       if (cs->sedesc) {
                BUG_ON(!sc_ep_test(cs, SE_FL_DETACHED));
-               sedesc_free(cs->endp);
+               sedesc_free(cs->sedesc);
        }
        if (cs->wait_event.tasklet)
                tasklet_free(cs->wait_event.tasklet);
@@ -232,7 +232,7 @@ static void cs_free_cond(struct conn_stream **csp)
 {
        struct conn_stream *cs = *csp;
 
-       if (!cs->app && (!cs->endp || sc_ep_test(cs, SE_FL_DETACHED))) {
+       if (!cs->app && (!cs->sedesc || sc_ep_test(cs, SE_FL_DETACHED))) {
                cs_free(cs);
                *csp = NULL;
        }
@@ -246,11 +246,12 @@ static void cs_free_cond(struct conn_stream **csp)
 int cs_attach_mux(struct conn_stream *cs, void *endp, void *ctx)
 {
        struct connection *conn = ctx;
+       struct sedesc *sedesc = cs->sedesc;
 
-       cs->endp->se     = endp;
-       cs->endp->conn   = ctx;
-       sc_ep_set(cs, SE_FL_T_MUX);
-       sc_ep_clr(cs, SE_FL_DETACHED);
+       sedesc->se = endp;
+       sedesc->conn = ctx;
+       se_fl_set(sedesc, SE_FL_T_MUX);
+       se_fl_clr(sedesc, SE_FL_DETACHED);
        if (!conn->ctx)
                conn->ctx = cs;
        if (cs_strm(cs)) {
@@ -288,7 +289,7 @@ int cs_attach_mux(struct conn_stream *cs, void *endp, void *ctx)
  */
 static void cs_attach_applet(struct conn_stream *cs, void *endp)
 {
-       cs->endp->se = endp;
+       cs->sedesc->se = endp;
        sc_ep_set(cs, SE_FL_T_APPLET);
        sc_ep_clr(cs, SE_FL_DETACHED);
        if (cs_strm(cs)) {
@@ -342,20 +343,20 @@ static void cs_detach_endp(struct conn_stream **csp)
        if (!cs)
                return;
 
-       if (!cs->endp)
+       if (!cs->sedesc)
                goto reset_cs;
 
        if (sc_ep_test(cs, SE_FL_T_MUX)) {
                struct connection *conn = __cs_conn(cs);
-               struct sedesc *endp = cs->endp;
+               struct sedesc *sedesc = cs->sedesc;
 
                if (conn->mux) {
                        if (cs->wait_event.events != 0)
                                conn->mux->unsubscribe(cs, cs->wait_event.events, &cs->wait_event);
-                       se_fl_set(endp, SE_FL_ORPHAN);
-                       endp->cs = NULL;
-                       cs->endp = NULL;
-                       conn->mux->detach(endp);
+                       se_fl_set(sedesc, SE_FL_ORPHAN);
+                       sedesc->cs = NULL;
+                       cs->sedesc = NULL;
+                       conn->mux->detach(sedesc);
                }
                else {
                        /* It's too early to have a mux, let's just destroy
@@ -372,16 +373,16 @@ static void cs_detach_endp(struct conn_stream **csp)
                struct appctx *appctx = __cs_appctx(cs);
 
                sc_ep_set(cs, SE_FL_ORPHAN);
-               cs->endp->cs = NULL;
-               cs->endp = NULL;
+               cs->sedesc->cs = NULL;
+               cs->sedesc = NULL;
                appctx_shut(appctx);
                appctx_free(appctx);
        }
 
-       if (cs->endp) {
+       if (cs->sedesc) {
                /* the cs is the only one one the endpoint */
-               cs->endp->se     = NULL;
-               cs->endp->conn   = NULL;
+               cs->sedesc->se     = NULL;
+               cs->sedesc->conn   = NULL;
                sc_ep_clr(cs, ~SE_FL_APP_MASK);
                sc_ep_set(cs, SE_FL_DETACHED);
        }
@@ -464,9 +465,9 @@ int cs_reset_endp(struct conn_stream *cs)
 
        /* The app is still attached, the cs will not be released */
        cs_detach_endp(&cs);
-       BUG_ON(cs->endp);
-       cs->endp = new_endp;
-       cs->endp->cs = cs;
+       BUG_ON(cs->sedesc);
+       cs->sedesc = new_endp;
+       cs->sedesc->cs = cs;
        sc_ep_set(cs, SE_FL_DETACHED);
        return 0;
 }
@@ -484,7 +485,7 @@ struct appctx *cs_applet_create(struct conn_stream *cs, struct applet *app)
 
        DPRINTF(stderr, "registering handler %p for cs %p (was %p)\n", app, cs, cs_strm_task(cs));
 
-       appctx = appctx_new_here(app, cs->endp);
+       appctx = appctx_new_here(app, cs->sedesc);
        if (!appctx)
                return NULL;
        cs_attach_applet(cs, appctx);

diff --git a/src/mux_fcgi.c b/src/mux_fcgi.c
index 62d4a61..ffaa81b 100644 (file)
--- a/src/mux_fcgi.c
+++ b/src/mux_fcgi.c
@@ -1131,7 +1131,7 @@ static struct fcgi_strm *fcgi_conn_stream_new(struct fcgi_conn *fconn, struct co
        }
        if (cs_attach_mux(cs, fstrm, fconn->conn) < 0)
                goto out;
-       fstrm->endp = cs->endp;
+       fstrm->endp = cs->sedesc;
        fstrm->sess = sess;
        fconn->nb_cs++;
 

diff --git a/src/mux_h1.c b/src/mux_h1.c
index f4a62e3..b00e63c 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -815,7 +815,7 @@ static struct h1s *h1c_frt_stream_new(struct h1c *h1c, struct conn_stream *cs, s
        if (cs) {
                if (cs_attach_mux(cs, h1s, h1c->conn) < 0)
                        goto fail;
-               h1s->endp = cs->endp;
+               h1s->endp = cs->sedesc;
        }
        else {
                h1s->endp = sedesc_new();
@@ -856,7 +856,7 @@ static struct h1s *h1c_bck_stream_new(struct h1c *h1c, struct conn_stream *cs, s
                goto fail;
 
        h1s->flags |= H1S_F_RX_BLK;
-       h1s->endp = cs->endp;
+       h1s->endp = cs->sedesc;
        h1s->sess = sess;
 
        h1c->flags = (h1c->flags & ~H1C_F_ST_EMBRYONIC) | H1C_F_ST_ATTACHED | H1C_F_ST_READY;

diff --git a/src/mux_h2.c b/src/mux_h2.c
index 1b4c16f..4f83cab 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -1693,7 +1693,7 @@ static struct h2s *h2c_bck_stream_new(struct h2c *h2c, struct conn_stream *cs, s
                h2s = NULL;
                goto out;
        }
-       h2s->endp = cs->endp;
+       h2s->endp = cs->sedesc;
        h2s->sess = sess;
        h2c->nb_cs++;
 

diff --git a/src/mux_pt.c b/src/mux_pt.c
index 42dadf9..54ccca7 100644 (file)
--- a/src/mux_pt.c
+++ b/src/mux_pt.c
@@ -312,7 +312,7 @@ static int mux_pt_init(struct connection *conn, struct proxy *prx, struct sessio
        else {
                if (cs_attach_mux(cs, ctx, conn) < 0)
                        goto fail_free_ctx;
-               ctx->endp = cs->endp;
+               ctx->endp = cs->sedesc;
        }
        conn->ctx = ctx;
        se_fl_set(ctx->endp, SE_FL_RCV_MORE);

diff --git a/src/stream.c b/src/stream.c
index 91ceeb4..7c348cd 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -3308,7 +3308,7 @@ static int stats_dump_full_strm_to_buffer(struct conn_stream *cs, struct stream
                chunk_appendf(&trash, "  csf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
                              csf, csf->flags, cs_state_str(csf->state),
                              (sc_ep_test(csf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
-                             csf->endp->se, sc_ep_get(csf), csf->wait_event.events);
+                             csf->sedesc->se, sc_ep_get(csf), csf->wait_event.events);
 
                if ((conn = cs_conn(csf)) != NULL) {
                        chunk_appendf(&trash,
@@ -3347,7 +3347,7 @@ static int stats_dump_full_strm_to_buffer(struct conn_stream *cs, struct stream
                chunk_appendf(&trash, "  csb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
                              csb, csb->flags, cs_state_str(csb->state),
                              (sc_ep_test(csb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(csb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
-                             csb->endp->se, sc_ep_get(csb), csb->wait_event.events);
+                             csb->sedesc->se, sc_ep_get(csb), csb->wait_event.events);
 
                if ((conn = cs_conn(csb)) != NULL) {
                        chunk_appendf(&trash,