mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-08-07 15:47:01 +02:00
Code Issues Projects Releases Wiki Activity

MEDIUM: connections: Provide a xprt_ctx for each xprt method.

Browse Source 
For most of the xprt methods, provide a xprt_ctx.  This will be useful later
when we'll want to be able to stack xprts.
The init() method now has to create and provide the said xprt_ctx if needed.
This commit is contained in:
Olivier Houchard 2019-03-21 18:27:17 +01:00 committed by Olivier Houchard
parent df35784600
commit e179d0e88f
8 changed files with 91 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/proto/connection.h
View File

@ -48,8 +48,8 @@ int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connectio
int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst); int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote); int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
int conn_subscribe(struct connection *conn, int event_type, void *param); int conn_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param);
int conn_unsubscribe(struct connection *conn, int event_type, void *param); int conn_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param);
/* receive a NetScaler Client IP insertion header over a connection */ /* receive a NetScaler Client IP insertion header over a connection */
int conn_recv_netscaler_cip(struct connection *conn, int flag); int conn_recv_netscaler_cip(struct connection *conn, int flag);
@ -81,7 +81,7 @@ static inline int conn_xprt_init(struct connection *conn)
int ret = 0; int ret = 0;
if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init) if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
ret = conn->xprt->init(conn); ret = conn->xprt->init(conn, &conn->xprt_ctx);
if (ret >= 0) if (ret >= 0)
conn->flags |= CO_FL_XPRT_READY; conn->flags |= CO_FL_XPRT_READY;
@ -98,7 +98,7 @@ static inline void conn_xprt_close(struct connection *conn)
{ {
if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) { if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
if (conn->xprt->close) if (conn->xprt->close)
conn->xprt->close(conn); conn->xprt->close(conn, conn->xprt_ctx);
conn->flags &= ~CO_FL_XPRT_READY; conn->flags &= ~CO_FL_XPRT_READY;
} }
} }
@ -462,7 +462,7 @@ static inline void conn_xprt_shutw(struct connection *c)
/* clean data-layer shutdown */ /* clean data-layer shutdown */
if (c->xprt && c->xprt->shutw) if (c->xprt && c->xprt->shutw)
c->xprt->shutw(c, 1); c->xprt->shutw(c, c->xprt_ctx, 1);
} }
static inline void conn_xprt_shutw_hard(struct connection *c) static inline void conn_xprt_shutw_hard(struct connection *c)
@ -471,7 +471,7 @@ static inline void conn_xprt_shutw_hard(struct connection *c)
/* unclean data-layer shutdown */ /* unclean data-layer shutdown */
if (c->xprt && c->xprt->shutw) if (c->xprt && c->xprt->shutw)
c->xprt->shutw(c, 0); c->xprt->shutw(c, c->xprt_ctx, 0);
} }
/* shut read */ /* shut read */
@ -940,7 +940,7 @@ static inline int conn_get_alpn(const struct connection *conn, const char **str,
{ {
if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn) if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn)
return 0; return 0;
return conn->xprt->get_alpn(conn, str, len); return conn->xprt->get_alpn(conn, conn->xprt_ctx, str, len);
} }
/* registers proto mux list <list>. Modifies the list element! */ /* registers proto mux list <list>. Modifies the list element! */

22
include/types/connection.h
View File

@ -302,22 +302,22 @@ enum {
* and the other ones are used to setup and release the transport layer. * and the other ones are used to setup and release the transport layer.
*/ */
struct xprt_ops { struct xprt_ops {
size_t (*rcv_buf)(struct connection *conn, struct buffer *buf, size_t count, int flags); /* recv callback */ size_t (*rcv_buf)(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags); /* recv callback */
size_t (*snd_buf)(struct connection *conn, const struct buffer *buf, size_t count, int flags); /* send callback */ size_t (*snd_buf)(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags); /* send callback */
int (*rcv_pipe)(struct connection *conn, struct pipe *pipe, unsigned int count); /* recv-to-pipe callback */ int (*rcv_pipe)(struct connection *conn, void *xprt_ctx, struct pipe *pipe, unsigned int count); /* recv-to-pipe callback */
int (*snd_pipe)(struct connection *conn, struct pipe *pipe); /* send-to-pipe callback */ int (*snd_pipe)(struct connection *conn, void *xprt_ctx, struct pipe *pipe); /* send-to-pipe callback */
void (*shutr)(struct connection *, int); /* shutr function */ void (*shutr)(struct connection *conn, void *xprt_ctx, int); /* shutr function */
void (*shutw)(struct connection *, int); /* shutw function */ void (*shutw)(struct connection *conn, void *xprt_ctx, int); /* shutw function */
void (*close)(struct connection *); /* close the transport layer */ void (*close)(struct connection *conn, void *xprt_ctx); /* close the transport layer */
int (*init)(struct connection *conn); /* initialize the transport layer */ int (*init)(struct connection *conn, void **ctx); /* initialize the transport layer */
int (*prepare_bind_conf)(struct bind_conf *conf); /* prepare a whole bind_conf */ int (*prepare_bind_conf)(struct bind_conf *conf); /* prepare a whole bind_conf */
void (*destroy_bind_conf)(struct bind_conf *conf); /* destroy a whole bind_conf */ void (*destroy_bind_conf)(struct bind_conf *conf); /* destroy a whole bind_conf */
int (*prepare_srv)(struct server *srv); /* prepare a server context */ int (*prepare_srv)(struct server *srv); /* prepare a server context */
void (*destroy_srv)(struct server *srv); /* destroy a server context */ void (*destroy_srv)(struct server *srv); /* destroy a server context */
int (*get_alpn)(const struct connection *conn, const char **str, int *len); /* get application layer name */ int (*get_alpn)(const struct connection *conn, void *xprt_ctx, const char **str, int *len); /* get application layer name */
char name[8]; /* transport layer name, zero-terminated */ char name[8]; /* transport layer name, zero-terminated */
int (*subscribe)(struct connection *conn, int event_type, void *param); /* Subscribe to events, such as "being able to send" */ int (*subscribe)(struct connection *conn, void *xprt_ctx, int event_type, void *param); /* Subscribe to events, such as "being able to send" */
int (*unsubscribe)(struct connection *conn, int event_type, void *param); /* Unsubscribe to events */ int (*unsubscribe)(struct connection *conn, void *xprt_ctx, int event_type, void *param); /* Unsubscribe to events */
}; };
/* mux_ops describes the mux operations, which are to be performed at the /* mux_ops describes the mux operations, which are to be performed at the

4
src/connection.c
View File

@ -316,7 +316,7 @@ int conn_sock_send(struct connection *conn, const void *buf, int len, int flags)
return ret; return ret;
} }
int conn_unsubscribe(struct connection *conn, int event_type, void *param) int conn_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{ {
struct wait_event *sw; struct wait_event *sw;
@ -340,7 +340,7 @@ int conn_unsubscribe(struct connection *conn, int event_type, void *param)
return 0; return 0;
} }
int conn_subscribe(struct connection *conn, int event_type, void *param) int conn_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{ {
struct wait_event *sw; struct wait_event *sw;

23
src/mux_h1.c
View File

@ -484,7 +484,7 @@ static void h1_release(struct h1c *h1c)
h1s_destroy(h1c->h1s); h1s_destroy(h1c->h1s);
if (conn && h1c->wait_event.events != 0) if (conn && h1c->wait_event.events != 0)
conn->xprt->unsubscribe(conn, h1c->wait_event.events, conn->xprt->unsubscribe(conn, conn->xprt_ctx, h1c->wait_event.events,
&h1c->wait_event); &h1c->wait_event);
pool_free(pool_head_h1c, h1c); pool_free(pool_head_h1c, h1c);
} }
@ -1753,7 +1753,7 @@ static int h1_recv(struct h1c *h1c)
*/ */
h1c->ibuf.head = sizeof(struct htx); h1c->ibuf.head = sizeof(struct htx);
} }
ret = conn->xprt->rcv_buf(conn, &h1c->ibuf, max, 0); ret = conn->xprt->rcv_buf(conn, conn->xprt_ctx, &h1c->ibuf, max, 0);
} }
if (ret > 0) { if (ret > 0) {
rcvd = 1; rcvd = 1;
@ -1769,7 +1769,7 @@ static int h1_recv(struct h1c *h1c)
goto end; goto end;
} }
conn->xprt->subscribe(conn, SUB_RETRY_RECV, &h1c->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &h1c->wait_event);
end: end:
if (ret > 0 || (conn->flags & CO_FL_ERROR) || conn_xprt_read0_pending(conn)) if (ret > 0 || (conn->flags & CO_FL_ERROR) || conn_xprt_read0_pending(conn))
@ -1800,7 +1800,7 @@ static int h1_send(struct h1c *h1c)
if (h1c->flags & H1C_F_CS_WAIT_CONN) { if (h1c->flags & H1C_F_CS_WAIT_CONN) {
if (!(h1c->wait_event.events & SUB_RETRY_SEND)) if (!(h1c->wait_event.events & SUB_RETRY_SEND))
conn->xprt->subscribe(conn, SUB_RETRY_SEND, &h1c->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_SEND, &h1c->wait_event);
return 0; return 0;
} }
@ -1810,7 +1810,7 @@ static int h1_send(struct h1c *h1c)
if (h1c->flags & H1C_F_OUT_FULL) if (h1c->flags & H1C_F_OUT_FULL)
flags |= CO_SFL_MSG_MORE; flags |= CO_SFL_MSG_MORE;
ret = conn->xprt->snd_buf(conn, &h1c->obuf, b_data(&h1c->obuf), flags); ret = conn->xprt->snd_buf(conn, conn->xprt_ctx, &h1c->obuf, b_data(&h1c->obuf), flags);
if (ret > 0) { if (ret > 0) {
h1c->flags &= ~H1C_F_OUT_FULL; h1c->flags &= ~H1C_F_OUT_FULL;
b_del(&h1c->obuf, ret); b_del(&h1c->obuf, ret);
@ -1833,7 +1833,7 @@ static int h1_send(struct h1c *h1c)
h1_shutw_conn(conn, CS_SHW_NORMAL); h1_shutw_conn(conn, CS_SHW_NORMAL);
} }
else if (!(h1c->wait_event.events & SUB_RETRY_SEND)) else if (!(h1c->wait_event.events & SUB_RETRY_SEND))
conn->xprt->subscribe(conn, SUB_RETRY_SEND, &h1c->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_SEND, &h1c->wait_event);
return sent; return sent;
} }
@ -2134,7 +2134,8 @@ static void h1_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
if (cs->flags & CS_FL_SHR) if (cs->flags & CS_FL_SHR)
return; return;
if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr) if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr)
cs->conn->xprt->shutr(cs->conn, (mode == CS_SHR_DRAIN)); cs->conn->xprt->shutr(cs->conn, cs->conn->xprt_ctx,
(mode == CS_SHR_DRAIN));
if ((cs->conn->flags & (CO_FL_SOCK_RD_SH|CO_FL_SOCK_WR_SH)) == (CO_FL_SOCK_RD_SH|CO_FL_SOCK_WR_SH)) if ((cs->conn->flags & (CO_FL_SOCK_RD_SH|CO_FL_SOCK_WR_SH)) == (CO_FL_SOCK_RD_SH|CO_FL_SOCK_WR_SH))
h1c->flags = (h1c->flags & ~H1C_F_CS_SHUTW_NOW) | H1C_F_CS_SHUTDOWN; h1c->flags = (h1c->flags & ~H1C_F_CS_SHUTW_NOW) | H1C_F_CS_SHUTDOWN;
} }
@ -2296,7 +2297,7 @@ static int h1_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int c
if ((h1m->state != H1_MSG_DATA && h1m->state != H1_MSG_TUNNEL) || if ((h1m->state != H1_MSG_DATA && h1m->state != H1_MSG_TUNNEL) ||
(h1m->state == H1_MSG_DATA && !h1m->curr_len)) { (h1m->state == H1_MSG_DATA && !h1m->curr_len)) {
h1s->flags &= ~(H1S_F_BUF_FLUSH|H1S_F_SPLICED_DATA); h1s->flags &= ~(H1S_F_BUF_FLUSH|H1S_F_SPLICED_DATA);
cs->conn->xprt->subscribe(cs->conn, SUB_RETRY_RECV, &h1s->h1c->wait_event); cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, SUB_RETRY_RECV, &h1s->h1c->wait_event);
goto end; goto end;
} }
@ -2309,7 +2310,7 @@ static int h1_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int c
h1s->flags |= H1S_F_SPLICED_DATA; h1s->flags |= H1S_F_SPLICED_DATA;
if (h1m->state == H1_MSG_DATA && count > h1m->curr_len) if (h1m->state == H1_MSG_DATA && count > h1m->curr_len)
count = h1m->curr_len; count = h1m->curr_len;
ret = cs->conn->xprt->rcv_pipe(cs->conn, pipe, count); ret = cs->conn->xprt->rcv_pipe(cs->conn, cs->conn->xprt_ctx, pipe, count);
if (h1m->state == H1_MSG_DATA && ret > 0) { if (h1m->state == H1_MSG_DATA && ret > 0) {
h1m->curr_len -= ret; h1m->curr_len -= ret;
if (!h1m->curr_len) if (!h1m->curr_len)
@ -2333,11 +2334,11 @@ static int h1_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
if (b_data(&h1s->h1c->obuf)) if (b_data(&h1s->h1c->obuf))
goto end; goto end;
ret = cs->conn->xprt->snd_pipe(cs->conn, pipe); ret = cs->conn->xprt->snd_pipe(cs->conn, cs->conn->xprt_ctx, pipe);
end: end:
if (pipe->data) { if (pipe->data) {
if (!(h1s->h1c->wait_event.events & SUB_RETRY_SEND)) if (!(h1s->h1c->wait_event.events & SUB_RETRY_SEND))
cs->conn->xprt->subscribe(cs->conn, SUB_RETRY_SEND, &h1s->h1c->wait_event); cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, SUB_RETRY_SEND, &h1s->h1c->wait_event);
} }
return ret; return ret;
} }

12
src/mux_h2.c
View File

@ -643,7 +643,7 @@ static void h2_release(struct h2c *h2c)
if (h2c->wait_event.task) if (h2c->wait_event.task)
tasklet_free(h2c->wait_event.task); tasklet_free(h2c->wait_event.task);
if (h2c->wait_event.events != 0) if (h2c->wait_event.events != 0)
conn->xprt->unsubscribe(conn, h2c->wait_event.events, conn->xprt->unsubscribe(conn, conn->xprt_ctx, h2c->wait_event.events,
&h2c->wait_event); &h2c->wait_event);
pool_free(pool_head_h2c, h2c); pool_free(pool_head_h2c, h2c);
@ -2676,13 +2676,13 @@ static int h2_recv(struct h2c *h2c)
max = b_room(buf); max = b_room(buf);
if (max) if (max)
ret = conn->xprt->rcv_buf(conn, buf, max, 0); ret = conn->xprt->rcv_buf(conn, conn->xprt_ctx, buf, max, 0);
else else
ret = 0; ret = 0;
} while (ret > 0); } while (ret > 0);
if (h2_recv_allowed(h2c) && (b_data(buf) < buf->size)) if (h2_recv_allowed(h2c) && (b_data(buf) < buf->size))
conn->xprt->subscribe(conn, SUB_RETRY_RECV, &h2c->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &h2c->wait_event);
if (!b_data(buf)) { if (!b_data(buf)) {
h2_release_buf(h2c, &h2c->dbuf); h2_release_buf(h2c, &h2c->dbuf);
@ -2749,7 +2749,7 @@ static int h2_send(struct h2c *h2c)
flags |= CO_SFL_MSG_MORE; flags |= CO_SFL_MSG_MORE;
if (b_data(&h2c->mbuf)) { if (b_data(&h2c->mbuf)) {
int ret = conn->xprt->snd_buf(conn, &h2c->mbuf, b_data(&h2c->mbuf), flags); int ret = conn->xprt->snd_buf(conn, conn->xprt_ctx, &h2c->mbuf, b_data(&h2c->mbuf), flags);
if (!ret) if (!ret)
break; break;
sent = 1; sent = 1;
@ -2796,7 +2796,7 @@ static int h2_send(struct h2c *h2c)
return sent; return sent;
schedule: schedule:
if (!(h2c->wait_event.events & SUB_RETRY_SEND)) if (!(h2c->wait_event.events & SUB_RETRY_SEND))
conn->xprt->subscribe(conn, SUB_RETRY_SEND, &h2c->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_SEND, &h2c->wait_event);
return sent; return sent;
} }
@ -2947,7 +2947,7 @@ static struct task *h2_timeout_task(struct task *t, void *context, unsigned shor
h2c->flags |= H2_CF_GOAWAY_FAILED; h2c->flags |= H2_CF_GOAWAY_FAILED;
if (b_data(&h2c->mbuf) && !(h2c->flags & H2_CF_GOAWAY_FAILED) && conn_xprt_ready(h2c->conn)) { if (b_data(&h2c->mbuf) && !(h2c->flags & H2_CF_GOAWAY_FAILED) && conn_xprt_ready(h2c->conn)) {
int ret = h2c->conn->xprt->snd_buf(h2c->conn, &h2c->mbuf, b_data(&h2c->mbuf), 0); int ret = h2c->conn->xprt->snd_buf(h2c->conn, h2c->conn->xprt_ctx, &h2c->mbuf, b_data(&h2c->mbuf), 0);
if (ret > 0) { if (ret > 0) {
b_del(&h2c->mbuf, ret); b_del(&h2c->mbuf, ret);
b_realign_if_empty(&h2c->mbuf); b_realign_if_empty(&h2c->mbuf);

24
src/mux_pt.c
View File

@ -54,7 +54,7 @@ static struct task *mux_pt_io_cb(struct task *t, void *tctx, unsigned short stat
if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH)) if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))
mux_pt_destroy(ctx); mux_pt_destroy(ctx);
else else
ctx->conn->xprt->subscribe(ctx->conn, SUB_RETRY_RECV, ctx->conn->xprt->subscribe(ctx->conn, ctx->conn->xprt_ctx, SUB_RETRY_RECV,
&ctx->wait_event); &ctx->wait_event);
return NULL; return NULL;
@ -146,7 +146,7 @@ static struct conn_stream *mux_pt_attach(struct connection *conn, struct session
struct conn_stream *cs; struct conn_stream *cs;
struct mux_pt_ctx *ctx = conn->ctx; struct mux_pt_ctx *ctx = conn->ctx;
conn->xprt->unsubscribe(conn, SUB_RETRY_RECV, &ctx->wait_event); conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
cs = cs_new(conn); cs = cs_new(conn);
if (!cs) if (!cs)
goto fail; goto fail;
@ -191,7 +191,7 @@ static void mux_pt_detach(struct conn_stream *cs)
if (conn->owner != NULL && if (conn->owner != NULL &&
!(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))) { !(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))) {
ctx->cs = NULL; ctx->cs = NULL;
conn->xprt->subscribe(conn, SUB_RETRY_RECV, &ctx->wait_event); conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
} else } else
/* There's no session attached to that connection, destroy it */ /* There's no session attached to that connection, destroy it */
mux_pt_destroy(ctx); mux_pt_destroy(ctx);
@ -217,7 +217,8 @@ static void mux_pt_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
return; return;
cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM); cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr) if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr)
cs->conn->xprt->shutr(cs->conn, (mode == CS_SHR_DRAIN)); cs->conn->xprt->shutr(cs->conn, cs->conn->xprt_ctx,
(mode == CS_SHR_DRAIN));
if (cs->flags & CS_FL_SHW) if (cs->flags & CS_FL_SHW)
conn_full_close(cs->conn); conn_full_close(cs->conn);
/* Maybe we've been put in the list of available idle connections, /* Maybe we've been put in the list of available idle connections,
@ -232,7 +233,8 @@ static void mux_pt_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
if (cs->flags & CS_FL_SHW) if (cs->flags & CS_FL_SHW)
return; return;
if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw) if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw)
cs->conn->xprt->shutw(cs->conn, (mode == CS_SHW_NORMAL)); cs->conn->xprt->shutw(cs->conn, cs->conn->xprt_ctx,
(mode == CS_SHW_NORMAL));
if (!(cs->flags & CS_FL_SHR)) if (!(cs->flags & CS_FL_SHR))
conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL)); conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL));
else else
@ -256,7 +258,7 @@ static size_t mux_pt_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t
return 0; return 0;
} }
b_realign_if_empty(buf); b_realign_if_empty(buf);
ret = cs->conn->xprt->rcv_buf(cs->conn, buf, count, flags); ret = cs->conn->xprt->rcv_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
if (conn_xprt_read0_pending(cs->conn)) { if (conn_xprt_read0_pending(cs->conn)) {
if (ret == 0) if (ret == 0)
cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM); cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
@ -277,7 +279,7 @@ static size_t mux_pt_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t
if (cs->conn->flags & CO_FL_HANDSHAKE) if (cs->conn->flags & CO_FL_HANDSHAKE)
return 0; return 0;
ret = cs->conn->xprt->snd_buf(cs->conn, buf, count, flags); ret = cs->conn->xprt->snd_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
if (ret > 0) if (ret > 0)
b_del(buf, ret); b_del(buf, ret);
@ -287,12 +289,12 @@ static size_t mux_pt_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t
/* Called from the upper layer, to subscribe to events */ /* Called from the upper layer, to subscribe to events */
static int mux_pt_subscribe(struct conn_stream *cs, int event_type, void *param) static int mux_pt_subscribe(struct conn_stream *cs, int event_type, void *param)
{ {
return (cs->conn->xprt->subscribe(cs->conn, event_type, param)); return (cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, event_type, param));
} }
static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, void *param) static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, void *param)
{ {
return (cs->conn->xprt->unsubscribe(cs->conn, event_type, param)); return (cs->conn->xprt->unsubscribe(cs->conn, cs->conn->xprt_ctx, event_type, param));
} }
#if defined(CONFIG_HAP_LINUX_SPLICE) #if defined(CONFIG_HAP_LINUX_SPLICE)
@ -301,7 +303,7 @@ static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned i
{ {
int ret; int ret;
ret = cs->conn->xprt->rcv_pipe(cs->conn, pipe, count); ret = cs->conn->xprt->rcv_pipe(cs->conn, cs->conn->xprt_ctx, pipe, count);
if (conn_xprt_read0_pending(cs->conn)) if (conn_xprt_read0_pending(cs->conn))
cs->flags |= CS_FL_EOS; cs->flags |= CS_FL_EOS;
if (cs->conn->flags & CO_FL_ERROR) if (cs->conn->flags & CO_FL_ERROR)
@ -311,7 +313,7 @@ static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned i
static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe) static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
{ {
return (cs->conn->xprt->snd_pipe(cs->conn, pipe)); return (cs->conn->xprt->snd_pipe(cs->conn, cs->conn->xprt_ctx, pipe));
} }
#endif #endif

21
src/raw_sock.c
View File

@ -66,7 +66,7 @@
* connection flags are updated (error, read0, wait_room, wait_data). * connection flags are updated (error, read0, wait_room, wait_data).
* The caller must have previously allocated the pipe. * The caller must have previously allocated the pipe.
*/ */
int raw_sock_to_pipe(struct connection *conn, struct pipe *pipe, unsigned int count) int raw_sock_to_pipe(struct connection *conn, void *xprt_ctx, struct pipe *pipe, unsigned int count)
{ {
#ifndef ASSUME_SPLICE_WORKS #ifndef ASSUME_SPLICE_WORKS
static THREAD_LOCAL int splice_detects_close; static THREAD_LOCAL int splice_detects_close;
@ -198,7 +198,7 @@ int raw_sock_to_pipe(struct connection *conn, struct pipe *pipe, unsigned int co
/* Send as many bytes as possible from the pipe to the connection's socket. /* Send as many bytes as possible from the pipe to the connection's socket.
*/ */
int raw_sock_from_pipe(struct connection *conn, struct pipe *pipe) int raw_sock_from_pipe(struct connection *conn, void *xprt_ctx, struct pipe *pipe)
{ {
int ret, done; int ret, done;
@ -250,7 +250,7 @@ int raw_sock_from_pipe(struct connection *conn, struct pipe *pipe)
* errno is cleared before starting so that the caller knows that if it spots an * errno is cleared before starting so that the caller knows that if it spots an
* error without errno, it's pending and can be retrieved via getsockopt(SO_ERROR). * error without errno, it's pending and can be retrieved via getsockopt(SO_ERROR).
*/ */
static size_t raw_sock_to_buf(struct connection *conn, struct buffer *buf, size_t count, int flags) static size_t raw_sock_to_buf(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags)
{ {
ssize_t ret; ssize_t ret;
size_t try, done = 0; size_t try, done = 0;
@ -363,7 +363,7 @@ static size_t raw_sock_to_buf(struct connection *conn, struct buffer *buf, size_
* is responsible for this. It's up to the caller to update the buffer's contents * is responsible for this. It's up to the caller to update the buffer's contents
* based on the return value. * based on the return value.
*/ */
static size_t raw_sock_from_buf(struct connection *conn, const struct buffer *buf, size_t count, int flags) static size_t raw_sock_from_buf(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags)
{ {
ssize_t ret; ssize_t ret;
size_t try, done; size_t try, done;
@ -419,13 +419,22 @@ static size_t raw_sock_from_buf(struct connection *conn, const struct buffer *bu
return done; return done;
} }
static int raw_sock_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{
return conn_subscribe(conn, xprt_ctx, event_type, param);
}
static int raw_sock_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{
return conn_unsubscribe(conn, xprt_ctx, event_type, param);
}
/* transport-layer operations for RAW sockets */ /* transport-layer operations for RAW sockets */
static struct xprt_ops raw_sock = { static struct xprt_ops raw_sock = {
.snd_buf = raw_sock_from_buf, .snd_buf = raw_sock_from_buf,
.rcv_buf = raw_sock_to_buf, .rcv_buf = raw_sock_to_buf,
.subscribe = conn_subscribe, .subscribe = raw_sock_subscribe,
.unsubscribe = conn_unsubscribe, .unsubscribe = raw_sock_unsubscribe,
#if defined(CONFIG_HAP_LINUX_SPLICE) #if defined(CONFIG_HAP_LINUX_SPLICE)
.rcv_pipe = raw_sock_to_pipe, .rcv_pipe = raw_sock_to_pipe,
.snd_pipe = raw_sock_from_pipe, .snd_pipe = raw_sock_from_pipe,

51
src/ssl_sock.c
View File

@ -5094,11 +5094,11 @@ ssl_sock_free_ca(struct bind_conf *bind_conf)
* handshake flag on the connection. It is safe to call it multiple times. * handshake flag on the connection. It is safe to call it multiple times.
* It returns 0 on success and -1 in error case. * It returns 0 on success and -1 in error case.
*/ */
static int ssl_sock_init(struct connection *conn) static int ssl_sock_init(struct connection *conn, void **xprt_ctx)
{ {
struct ssl_sock_ctx *ctx; struct ssl_sock_ctx *ctx;
/* already initialized */ /* already initialized */
if (conn->xprt_ctx) if (*xprt_ctx)
return 0; return 0;
if (!conn_ctrl_ready(conn)) if (!conn_ctrl_ready(conn))
@ -5174,10 +5174,10 @@ static int ssl_sock_init(struct connection *conn)
/* leave init state and start handshake */ /* leave init state and start handshake */
conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN; conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
conn->xprt_ctx = ctx;
_HA_ATOMIC_ADD(&sslconns, 1); _HA_ATOMIC_ADD(&sslconns, 1);
_HA_ATOMIC_ADD(&totalsslconns, 1); _HA_ATOMIC_ADD(&totalsslconns, 1);
*xprt_ctx = ctx;
return 0; return 0;
} }
else if (objt_listener(conn->target)) { else if (objt_listener(conn->target)) {
@ -5229,7 +5229,7 @@ static int ssl_sock_init(struct connection *conn)
_HA_ATOMIC_ADD(&sslconns, 1); _HA_ATOMIC_ADD(&sslconns, 1);
_HA_ATOMIC_ADD(&totalsslconns, 1); _HA_ATOMIC_ADD(&totalsslconns, 1);
conn->xprt_ctx = ctx; *xprt_ctx = ctx;
return 0; return 0;
} }
/* don't know how to handle such a target */ /* don't know how to handle such a target */
@ -5524,14 +5524,16 @@ int ssl_sock_handshake(struct connection *conn, unsigned int flag)
return 0; return 0;
} }
static int ssl_subscribe(struct connection *conn, int event_type, void *param) static int ssl_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{ {
return conn_subscribe(conn, event_type, param);
return conn_subscribe(conn, NULL, event_type, param);
} }
static int ssl_unsubscribe(struct connection *conn, int event_type, void *param) static int ssl_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
{ {
return conn_unsubscribe(conn, event_type, param);
return conn_unsubscribe(conn, NULL, event_type, param);
} }
/* Receive up to <count> bytes from connection <conn>'s socket and store them /* Receive up to <count> bytes from connection <conn>'s socket and store them
@ -5542,15 +5544,15 @@ static int ssl_unsubscribe(struct connection *conn, int event_type, void *param)
* avoiding the call if inappropriate. The function does not call the * avoiding the call if inappropriate. The function does not call the
* connection's polling update function, so the caller is responsible for this. * connection's polling update function, so the caller is responsible for this.
*/ */
static size_t ssl_sock_to_buf(struct connection *conn, struct buffer *buf, size_t count, int flags) static size_t ssl_sock_to_buf(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags)
{ {
struct ssl_sock_ctx *ctx = conn->xprt_ctx; struct ssl_sock_ctx *ctx = xprt_ctx;
ssize_t ret; ssize_t ret;
size_t try, done = 0; size_t try, done = 0;
conn_refresh_polling_flags(conn); conn_refresh_polling_flags(conn);
if (!conn->xprt_ctx) if (!ctx)
goto out_error; goto out_error;
if (conn->flags & CO_FL_HANDSHAKE) if (conn->flags & CO_FL_HANDSHAKE)
@ -5703,16 +5705,16 @@ static size_t ssl_sock_to_buf(struct connection *conn, struct buffer *buf, size_
* caller to take care of this. It's up to the caller to update the buffer's * caller to take care of this. It's up to the caller to update the buffer's
* contents based on the return value. * contents based on the return value.
*/ */
static size_t ssl_sock_from_buf(struct connection *conn, const struct buffer *buf, size_t count, int flags) static size_t ssl_sock_from_buf(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags)
{ {
struct ssl_sock_ctx *ctx = conn->xprt_ctx; struct ssl_sock_ctx *ctx = xprt_ctx;
ssize_t ret; ssize_t ret;
size_t try, done; size_t try, done;
done = 0; done = 0;
conn_refresh_polling_flags(conn); conn_refresh_polling_flags(conn);
if (!conn->xprt_ctx) if (!ctx)
goto out_error; goto out_error;
if (conn->flags & CO_FL_HANDSHAKE) if (conn->flags & CO_FL_HANDSHAKE)
@ -5838,11 +5840,11 @@ static size_t ssl_sock_from_buf(struct connection *conn, const struct buffer *bu
goto leave; goto leave;
} }
static void ssl_sock_close(struct connection *conn) { static void ssl_sock_close(struct connection *conn, void *xprt_ctx) {
struct ssl_sock_ctx *ctx = conn->xprt_ctx; struct ssl_sock_ctx *ctx = xprt_ctx;
if (conn->xprt_ctx) { if (ctx) {
#if (OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC) #if (OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
if (global_ssl.async) { if (global_ssl.async) {
OSSL_ASYNC_FD all_fd[32], afd; OSSL_ASYNC_FD all_fd[32], afd;
@ -5875,7 +5877,6 @@ static void ssl_sock_close(struct connection *conn) {
fd_cant_recv(afd); fd_cant_recv(afd);
} }
pool_free(ssl_sock_ctx_pool, ctx); pool_free(ssl_sock_ctx_pool, ctx);
conn->xprt_ctx = NULL;
_HA_ATOMIC_ADD(&jobs, 1); _HA_ATOMIC_ADD(&jobs, 1);
return; return;
} }
@ -5891,7 +5892,6 @@ static void ssl_sock_close(struct connection *conn) {
#endif #endif
SSL_free(ctx->ssl); SSL_free(ctx->ssl);
pool_free(ssl_sock_ctx_pool, ctx); pool_free(ssl_sock_ctx_pool, ctx);
conn->xprt_ctx = NULL;
_HA_ATOMIC_SUB(&sslconns, 1); _HA_ATOMIC_SUB(&sslconns, 1);
} }
} }
@ -5899,9 +5899,9 @@ static void ssl_sock_close(struct connection *conn) {
/* This function tries to perform a clean shutdown on an SSL connection, and in /* This function tries to perform a clean shutdown on an SSL connection, and in
* any case, flags the connection as reusable if no handshake was in progress. * any case, flags the connection as reusable if no handshake was in progress.
*/ */
static void ssl_sock_shutw(struct connection *conn, int clean) static void ssl_sock_shutw(struct connection *conn, void *xprt_ctx, int clean)
{ {
struct ssl_sock_ctx *ctx = conn->xprt_ctx; struct ssl_sock_ctx *ctx = xprt_ctx;
if (conn->flags & CO_FL_HANDSHAKE) if (conn->flags & CO_FL_HANDSHAKE)
return; return;
@ -6348,14 +6348,12 @@ unsigned int ssl_sock_get_verify_result(struct connection *conn)
* freed by the caller. NPN is also checked if available since older versions * freed by the caller. NPN is also checked if available since older versions
* of openssl (1.0.1) which are more common in field only support this one. * of openssl (1.0.1) which are more common in field only support this one.
*/ */
static int ssl_sock_get_alpn(const struct connection *conn, const char **str, int *len) static int ssl_sock_get_alpn(const struct connection *conn, void *xprt_ctx, const char **str, int *len)
{ {
#if defined(TLSEXT_TYPE_application_layer_protocol_negotiation) || \ #if defined(TLSEXT_TYPE_application_layer_protocol_negotiation) || \
defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG) defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
struct ssl_sock_ctx *ctx = conn->xprt_ctx; struct ssl_sock_ctx *ctx = xprt_ctx;
#endif if (!ctx)
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0; return 0;
*str = NULL; *str = NULL;
@ -6369,6 +6367,7 @@ struct ssl_sock_ctx *ctx = conn->xprt_ctx;
SSL_get0_next_proto_negotiated(ctx->ssl, (const unsigned char **)str, (unsigned *)len); SSL_get0_next_proto_negotiated(ctx->ssl, (const unsigned char **)str, (unsigned *)len);
if (*str) if (*str)
return 1; return 1;
#endif
#endif #endif
return 0; return 0;
} }