MINOR: connection: rename QMux related flags

This is a follow-up on the QUIC MUX renaming process.

The current patch performs renaming of "qstrm" to "qmux" in connection
flags. These flags are only used in linked with the xprt_qmux layer.
This has an impact on every files which manipulates these flags, namely
backend, session and ssl_sock sources.

Also, internal xprt identifier is renamed from XPRT_QSTRM to XPRT_QMUX,

diff --git a/include/haproxy/connection-t.h b/include/haproxy/connection-t.h
index a769ca0f1c4ee9fa9538f697cac7b5a9da95a60b..e0eec3020c05ea878ce264fe1d94fe64a90b36e4 100644 (file)
--- a/include/haproxy/connection-t.h
+++ b/include/haproxy/connection-t.h
@@ -130,8 +130,8 @@ enum {
 
        CO_FL_OPT_TOS       = 0x00000020,  /* connection has a special sockopt tos */
 
-       CO_FL_QSTRM_SEND    = 0x00000040,  /* connection uses QMux protocol, needs to exchange transport parameters before starting mux layer */
-       CO_FL_QSTRM_RECV    = 0x00000080,  /* connection uses QMux protocol, needs to exchange transport parameters before starting mux layer */
+       CO_FL_QMUX_SEND    = 0x00000040,   /* connection uses QMux protocol, needs to exchange transport parameters before starting mux layer */
+       CO_FL_QMUX_RECV    = 0x00000080,   /* connection uses QMux protocol, needs to exchange transport parameters before starting mux layer */
 
        /* These flags indicate whether the Control and Transport layers are initialized */
        CO_FL_CTRL_READY    = 0x00000100, /* FD was registered, fd_delete() needed */
@@ -213,7 +213,7 @@ static forceinline char *conn_show_flags(char *buf, size_t len, const char *deli
        /* flags */
        _(CO_FL_SAFE_LIST, _(CO_FL_IDLE_LIST, _(CO_FL_CTRL_READY,
        _(CO_FL_REVERSED, _(CO_FL_ACT_REVERSING, _(CO_FL_OPT_MARK, _(CO_FL_OPT_TOS,
-       _(CO_FL_QSTRM_SEND, _(CO_FL_QSTRM_RECV,
+       _(CO_FL_QMUX_SEND, _(CO_FL_QMUX_RECV,
        _(CO_FL_XPRT_READY, _(CO_FL_WANT_DRAIN, _(CO_FL_WAIT_ROOM, _(CO_FL_SSL_NO_CACHED_INFO, _(CO_FL_EARLY_SSL_HS,
        _(CO_FL_EARLY_DATA, _(CO_FL_SOCKS4_SEND, _(CO_FL_SOCKS4_RECV, _(CO_FL_SOCK_RD_SH,
        _(CO_FL_SOCK_WR_SH, _(CO_FL_ERROR, _(CO_FL_FDLESS, _(CO_FL_WAIT_L4_CONN,
@@ -285,7 +285,7 @@ enum {
 
        CO_ER_SSL_FATAL,         /* SSL fatal error during a SSL_read or SSL_write */
 
-       CO_ER_QSTRM,             /* QMux transport parameter exchange failure */
+       CO_ER_QMUX,              /* QMux transport parameter exchange failure */
 
        CO_ER_REVERSE,           /* Error during reverse connect */
 
@@ -349,7 +349,7 @@ enum {
        XPRT_SSL = 1,
        XPRT_HANDSHAKE = 2,
        XPRT_QUIC = 3,
-       XPRT_QSTRM = 4,
+       XPRT_QMUX = 4,
        XPRT_ENTRIES /* must be last one */
 };
 

diff --git a/src/backend.c b/src/backend.c
index 84115cb229e7c6729c826c5dfc9ebddb68aa2279..39e304df9e5b6a96636a17e2ebd54525578885e7 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -2131,7 +2131,7 @@ int connect_server(struct stream *s)
                }
 
                if (srv && srv->mux_proto && isteq(srv->mux_proto->token, ist("qmux"))) {
-                       srv_conn->flags |= (CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND);
+                       srv_conn->flags |= (CO_FL_QMUX_RECV|CO_FL_QMUX_SEND);
                        may_start_mux_now = 0;
                }
 

diff --git a/src/connection.c b/src/connection.c
index 905c03cf8871367d912312b243e5c9e010a7c6b5..e503f30a0a6aaca8fa057128e0400bf531cbeb5b 100644 (file)
--- a/src/connection.c
+++ b/src/connection.c
@@ -196,7 +196,7 @@ int conn_notify_mux(struct connection *conn, int old_flags, int forced_wake)
         * information to create one, typically from the ALPN. If we're
         * done with the handshake, attempt to create one.
         */
-       if (unlikely(!conn->mux) && !(conn->flags & (CO_FL_WAIT_XPRT|CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND))) {
+       if (unlikely(!conn->mux) && !(conn->flags & (CO_FL_WAIT_XPRT|CO_FL_QMUX_RECV|CO_FL_QMUX_SEND))) {
                ret = conn_create_mux(conn, NULL);
                if (ret < 0)
                        goto done;
@@ -888,7 +888,7 @@ const char *conn_err_code_str(struct connection *c)
 
        case CO_ER_SSL_FATAL:      return "SSL fatal error";
 
-       case CO_ER_QSTRM:          return "Error during QMux transport parameters initial exchange";
+       case CO_ER_QMUX:           return "Error during QMux transport parameters initial exchange";
 
        case CO_ER_REVERSE:        return "Reverse connect failure";
 

diff --git a/src/session.c b/src/session.c
index 1f2cf219d71bc2b835ad8736978ef97d68d2e9be..0436671c517fe47a486019512fb933e2a7fc10e5 100644 (file)
--- a/src/session.c
+++ b/src/session.c
@@ -242,7 +242,7 @@ int session_accept_fd(struct connection *cli_conn)
                        cli_conn->flags |= CO_FL_ACCEPT_CIP;
 
                if (l->bind_conf->mux_proto && isteq(l->bind_conf->mux_proto->token, ist("qmux")))
-                       cli_conn->flags |= (CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND);
+                       cli_conn->flags |= (CO_FL_QMUX_RECV|CO_FL_QMUX_SEND);
 
                /* Add the handshake pseudo-XPRT */
                if (cli_conn->flags & (CO_FL_ACCEPT_PROXY | CO_FL_ACCEPT_CIP)) {
@@ -503,7 +503,7 @@ static void session_kill_embryonic(struct session *sess, unsigned int state)
                    conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
                    conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
                    conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT ||
-                   conn->err_code == CO_ER_QSTRM)
+                   conn->err_code == CO_ER_QMUX)
                        log = 0;
        }
 
@@ -515,8 +515,8 @@ static void session_kill_embryonic(struct session *sess, unsigned int state)
                                conn->err_code = CO_ER_CIP_TIMEOUT;
                        else if (conn->flags & CO_FL_SSL_WAIT_HS)
                                conn->err_code = CO_ER_SSL_TIMEOUT;
-                       else if (conn->flags & CO_FL_QSTRM_RECV)
-                               conn->err_code = CO_ER_QSTRM;
+                       else if (conn->flags & CO_FL_QMUX_RECV)
+                               conn->err_code = CO_ER_QMUX;
                }
 
                sess_log_embryonic(sess);

diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index 1fd2681cf905310d06ecdf86ccf8f8f093c6f129..d9065d82e4052e86f0dd09dd1aa1275978294734 100644 (file)
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -6965,8 +6965,8 @@ struct task *ssl_sock_io_cb(struct task *t, void *context, unsigned int state)
                        int closed_connection = 0;
 
                        if (!ctx->conn->mux) {
-                               if (ctx->conn->flags & (CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND)) {
-                                       const struct xprt_ops *ops = xprt_get(XPRT_QSTRM);
+                               if (ctx->conn->flags & (CO_FL_QMUX_RECV|CO_FL_QMUX_SEND)) {
+                                       const struct xprt_ops *ops = xprt_get(XPRT_QMUX);
                                        void *xprt_ctx_hs = NULL;
 
                                        ret = ops->init(conn, &xprt_ctx_hs);

diff --git a/src/xprt_qmux.c b/src/xprt_qmux.c
index 42e12c7784aee727ea2f7d01653df182859615f4..9f770d88b0603bef16d732e85d465fcd80d1933a 100644 (file)
--- a/src/xprt_qmux.c
+++ b/src/xprt_qmux.c
@@ -121,7 +121,7 @@ int conn_recv_qstrm(struct connection *conn, struct xprt_qstrm_ctx *ctx, int fla
        return 0;
 
  fail:
-       conn->err_code = CO_ER_QSTRM;
+       conn->err_code = CO_ER_QMUX;
        conn->flags |= CO_FL_ERROR;
        return 0;
 }
@@ -174,7 +174,7 @@ int conn_send_qstrm(struct connection *conn, struct xprt_qstrm_ctx *ctx, int fla
        return 0;
 
  fail:
-       conn->err_code = CO_ER_QSTRM;
+       conn->err_code = CO_ER_QMUX;
        conn->flags |= CO_FL_ERROR;
        return 0;
 }
@@ -185,8 +185,8 @@ struct task *xprt_qstrm_io_cb(struct task *t, void *context, unsigned int state)
        struct connection *conn = ctx->conn;
        int free = 0, ret;
 
-       if (conn->flags & CO_FL_QSTRM_SEND) {
-               if (!conn_send_qstrm(conn, ctx, CO_FL_QSTRM_SEND)) {
+       if (conn->flags & CO_FL_QMUX_SEND) {
+               if (!conn_send_qstrm(conn, ctx, CO_FL_QMUX_SEND)) {
                        if (!(conn->flags & CO_FL_ERROR)) {
                                ctx->ops_lower->subscribe(conn, ctx->ctx_lower,
                                                          SUB_RETRY_SEND, &ctx->wait_event);
@@ -195,8 +195,8 @@ struct task *xprt_qstrm_io_cb(struct task *t, void *context, unsigned int state)
                }
        }
 
-       if (conn->flags & CO_FL_QSTRM_RECV) {
-               if (!conn_recv_qstrm(conn, ctx, CO_FL_QSTRM_RECV)) {
+       if (conn->flags & CO_FL_QMUX_RECV) {
+               if (!conn_recv_qstrm(conn, ctx, CO_FL_QMUX_RECV)) {
                        if (!(conn->flags & CO_FL_ERROR)) {
                                ctx->ops_lower->subscribe(conn, ctx->ctx_lower,
                                                          SUB_RETRY_RECV, &ctx->wait_event);
@@ -207,7 +207,7 @@ struct task *xprt_qstrm_io_cb(struct task *t, void *context, unsigned int state)
 
  out:
        if ((conn->flags & CO_FL_ERROR) ||
-           !(conn->flags & (CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND))) {
+           !(conn->flags & (CO_FL_QMUX_RECV|CO_FL_QMUX_SEND))) {
                /* XPRT should be unsubscribed when transfer done or on error. */
                BUG_ON(ctx->wait_event.events);
 
@@ -327,7 +327,7 @@ static void xprt_qstrm_close(struct connection *conn, void *xprt_ctx)
        if (ctx->ops_lower && ctx->ops_lower->close)
                ctx->ops_lower->close(conn, ctx->ctx_lower);
 
-       conn->flags &= ~(CO_FL_QSTRM_RECV|CO_FL_QSTRM_SEND);
+       conn->flags &= ~(CO_FL_QMUX_RECV|CO_FL_QMUX_SEND);
 
        BUG_ON(conn->xprt_ctx != ctx);
        conn->xprt_ctx = ctx->ctx_lower;
@@ -344,17 +344,17 @@ static int xprt_qstrm_get_alpn(const struct connection *conn, void *xprt_ctx,
        return ctx->ops_lower->get_alpn(conn, ctx->ctx_lower, str, len);
 }
 
-struct xprt_ops xprt_qstrm = {
+struct xprt_ops xprt_qmux = {
        .add_xprt  = xprt_qstrm_add_xprt,
        .init      = xprt_qstrm_init,
        .start     = xprt_qstrm_start,
        .close     = xprt_qstrm_close,
        .get_alpn  = xprt_qstrm_get_alpn,
-       .name      = "qstrm",
+       .name      = "qmux",
 };
 
 static void __xprt_qstrm_init(void)
 {
-       xprt_register(XPRT_QSTRM, &xprt_qstrm);
+       xprt_register(XPRT_QMUX, &xprt_qmux);
 }
 INITCALL0(STG_REGISTER, __xprt_qstrm_init);