blob: 9d73d46d43d221517f36ab631fc54bc4b994755d [file] [log] [blame]
Willy Tarreau53a47662017-08-28 10:53:00 +02001/*
2 * Pass-through mux-demux for connections
3 *
4 * Copyright 2017 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020013#include <haproxy/api.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020014#include <haproxy/buf.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020015#include <haproxy/connection.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020016#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020017#include <haproxy/task.h>
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010018
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010019struct mux_pt_ctx {
20 struct conn_stream *cs;
21 struct connection *conn;
22 struct wait_event wait_event;
23};
24
Willy Tarreau8ceae722018-11-26 11:58:30 +010025DECLARE_STATIC_POOL(pool_head_pt_ctx, "mux_pt", sizeof(struct mux_pt_ctx));
26
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010027static void mux_pt_destroy(struct mux_pt_ctx *ctx)
28{
Christopher Faulet5a7ca292020-11-03 09:11:43 +010029 struct connection *conn = NULL;
Christopher Faulet39a96ee2019-04-08 10:52:21 +020030
Christopher Faulet5a7ca292020-11-03 09:11:43 +010031 if (ctx) {
32 /* The connection must be attached to this mux to be released */
33 if (ctx->conn && ctx->conn->ctx == ctx)
34 conn = ctx->conn;
35
Willy Tarreau3c39a7d2019-06-14 14:42:29 +020036 tasklet_free(ctx->wait_event.tasklet);
Christopher Faulet5a7ca292020-11-03 09:11:43 +010037
38 if (conn && ctx->wait_event.events != 0)
39 conn->xprt->unsubscribe(conn, conn->xprt_ctx, ctx->wait_event.events,
40 &ctx->wait_event);
41 pool_free(pool_head_pt_ctx, ctx);
42 }
43
44 if (conn) {
Christopher Faulet39a96ee2019-04-08 10:52:21 +020045 conn->mux = NULL;
46 conn->ctx = NULL;
Christopher Faulet5a7ca292020-11-03 09:11:43 +010047
48 conn_stop_tracking(conn);
49 conn_full_close(conn);
Christopher Faulet39a96ee2019-04-08 10:52:21 +020050 if (conn->destroy_cb)
51 conn->destroy_cb(conn);
Christopher Faulet39a96ee2019-04-08 10:52:21 +020052 conn_free(conn);
53 }
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010054}
55
Willy Tarreau691d5032021-01-20 14:55:01 +010056/* Callback, used when we get I/Os while in idle mode. This one is exported so
57 * that "show fd" can resolve it.
58 */
Willy Tarreau144f84a2021-03-02 16:09:26 +010059struct task *mux_pt_io_cb(struct task *t, void *tctx, unsigned int status)
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010060{
61 struct mux_pt_ctx *ctx = tctx;
62
Olivier Houchardea510fc2019-10-18 13:56:40 +020063 if (ctx->cs) {
64 /* There's a small race condition.
65 * mux_pt_io_cb() is only supposed to be called if we have no
66 * stream attached. However, maybe the tasklet got woken up,
67 * and this connection was then attached to a new stream.
Olivier Houchard2ed389d2019-10-18 14:18:29 +020068 * If this happened, just wake the tasklet up if anybody
69 * subscribed to receive events, and otherwise call the wake
70 * method, to make sure the event is noticed.
Olivier Houchardea510fc2019-10-18 13:56:40 +020071 */
Willy Tarreau7872d1f2020-01-10 07:06:05 +010072 if (ctx->conn->subs) {
73 ctx->conn->subs->events = 0;
74 tasklet_wakeup(ctx->conn->subs->tasklet);
75 ctx->conn->subs = NULL;
Olivier Houchard2ed389d2019-10-18 14:18:29 +020076 } else if (ctx->cs->data_cb->wake)
Olivier Houchardea510fc2019-10-18 13:56:40 +020077 ctx->cs->data_cb->wake(ctx->cs);
78 return NULL;
79 }
Willy Tarreau2ded48d2020-12-11 16:20:34 +010080 conn_ctrl_drain(ctx->conn);
Olivier Houchard9dce2c52019-10-18 10:59:30 +020081 if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))
82 mux_pt_destroy(ctx);
83 else
Olivier Houcharde179d0e2019-03-21 18:27:17 +010084 ctx->conn->xprt->subscribe(ctx->conn, ctx->conn->xprt_ctx, SUB_RETRY_RECV,
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010085 &ctx->wait_event);
86
87 return NULL;
88}
Willy Tarreau53a47662017-08-28 10:53:00 +020089
Willy Tarreau3d2ee552018-12-19 14:12:10 +010090/* Initialize the mux once it's attached. It is expected that conn->ctx
Olivier Houchard9aaf7782017-09-13 18:30:23 +020091 * points to the existing conn_stream (for outgoing connections) or NULL (for
92 * incoming ones, in which case one will be allocated and a new stream will be
Ilya Shipitsin46a030c2020-07-05 16:36:08 +050093 * instantiated). Returns < 0 on error.
Willy Tarreau53a47662017-08-28 10:53:00 +020094 */
Christopher Faulet51f73eb2019-04-08 11:22:47 +020095static int mux_pt_init(struct connection *conn, struct proxy *prx, struct session *sess,
96 struct buffer *input)
Willy Tarreau53a47662017-08-28 10:53:00 +020097{
Willy Tarreau3d2ee552018-12-19 14:12:10 +010098 struct conn_stream *cs = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010099 struct mux_pt_ctx *ctx = pool_alloc(pool_head_pt_ctx);
100
101 if (!ctx)
102 goto fail;
103
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200104 ctx->wait_event.tasklet = tasklet_new();
105 if (!ctx->wait_event.tasklet)
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100106 goto fail_free_ctx;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200107 ctx->wait_event.tasklet->context = ctx;
108 ctx->wait_event.tasklet->process = mux_pt_io_cb;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100109 ctx->wait_event.events = 0;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100110 ctx->conn = conn;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200111
112 if (!cs) {
Christopher Faulet236c93b2020-07-02 09:19:54 +0200113 cs = cs_new(conn, conn->target);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200114 if (!cs)
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100115 goto fail_free_ctx;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200116
Christopher Faulet26256f82020-09-14 11:40:13 +0200117 if (stream_create_from_cs(cs, &BUF_NULL) < 0)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200118 goto fail_free;
119
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200120 }
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100121 conn->ctx = ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100122 ctx->cs = cs;
Olivier Houchard8706c812018-12-04 19:17:25 +0100123 cs->flags |= CS_FL_RCV_MORE;
Willy Tarreau17ccd1a2020-01-17 16:19:34 +0100124 if (global.tune.options & GTUNE_USE_SPLICE)
125 cs->flags |= CS_FL_MAY_SPLICE;
Willy Tarreau53a47662017-08-28 10:53:00 +0200126 return 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200127
128 fail_free:
129 cs_free(cs);
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100130fail_free_ctx:
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200131 if (ctx->wait_event.tasklet)
132 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100133 pool_free(pool_head_pt_ctx, ctx);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200134 fail:
135 return -1;
Willy Tarreau53a47662017-08-28 10:53:00 +0200136}
137
138/* callback to be used by default for the pass-through mux. It calls the data
139 * layer wake() callback if it is set otherwise returns 0.
140 */
141static int mux_pt_wake(struct connection *conn)
142{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100143 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100144 struct conn_stream *cs = ctx->cs;
145 int ret = 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200146
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100147 if (cs) {
148 ret = cs->data_cb->wake ? cs->data_cb->wake(cs) : 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200149
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100150 if (ret < 0)
151 return ret;
152 } else {
Willy Tarreau2ded48d2020-12-11 16:20:34 +0100153 conn_ctrl_drain(conn);
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100154 if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) {
155 mux_pt_destroy(ctx);
156 return -1;
157 }
158 }
Willy Tarreauad7f0ad2018-08-24 15:48:59 +0200159
Olivier Houchard7fc96d52017-11-23 18:25:47 +0100160 /* If we had early data, and we're done with the handshake
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500161 * then we know the data are safe, and we can remove the flag.
Olivier Houchard7fc96d52017-11-23 18:25:47 +0100162 */
Willy Tarreau911db9b2020-01-23 16:27:54 +0100163 if ((conn->flags & (CO_FL_EARLY_DATA | CO_FL_EARLY_SSL_HS | CO_FL_WAIT_XPRT)) ==
Olivier Houchard7fc96d52017-11-23 18:25:47 +0100164 CO_FL_EARLY_DATA)
165 conn->flags &= ~CO_FL_EARLY_DATA;
Willy Tarreaued339a32017-11-03 15:55:24 +0100166 return ret;
Willy Tarreau53a47662017-08-28 10:53:00 +0200167}
168
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200169/*
170 * Attach a new stream to a connection
171 * (Used for outgoing connections)
172 */
Olivier Houchardf502aca2018-12-14 19:42:40 +0100173static struct conn_stream *mux_pt_attach(struct connection *conn, struct session *sess)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200174{
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100175 struct conn_stream *cs;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100176 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100177
Olivier Houchardea32b0f2019-08-10 23:56:16 +0200178 if (ctx->wait_event.events)
179 conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Christopher Faulet236c93b2020-07-02 09:19:54 +0200180 cs = cs_new(conn, conn->target);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100181 if (!cs)
182 goto fail;
183
184 ctx->cs = cs;
Olivier Houchard8706c812018-12-04 19:17:25 +0100185 cs->flags |= CS_FL_RCV_MORE;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100186 return (cs);
187fail:
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200188 return NULL;
189}
190
Willy Tarreaufafd3982018-11-18 21:29:20 +0100191/* Retrieves a valid conn_stream from this connection, or returns NULL. For
192 * this mux, it's easy as we can only store a single conn_stream.
193 */
194static const struct conn_stream *mux_pt_get_first_cs(const struct connection *conn)
195{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100196 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100197 struct conn_stream *cs = ctx->cs;
Willy Tarreaufafd3982018-11-18 21:29:20 +0100198
199 return cs;
200}
201
Christopher Faulet73c12072019-04-08 11:23:22 +0200202/* Destroy the mux and the associated connection if still attached to this mux
203 * and no longer used */
204static void mux_pt_destroy_meth(void *ctx)
Olivier Houchard060ed432018-11-06 16:32:42 +0100205{
Christopher Faulet73c12072019-04-08 11:23:22 +0200206 struct mux_pt_ctx *pt = ctx;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100207
Christopher Faulet39a96ee2019-04-08 10:52:21 +0200208 if (!(pt->cs) || !(pt->conn) || pt->conn->ctx != pt)
Christopher Faulet73c12072019-04-08 11:23:22 +0200209 mux_pt_destroy(pt);
Olivier Houchard060ed432018-11-06 16:32:42 +0100210}
211
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200212/*
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200213 * Detach the stream from the connection and possibly release the connection.
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200214 */
215static void mux_pt_detach(struct conn_stream *cs)
216{
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200217 struct connection *conn = cs->conn;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100218 struct mux_pt_ctx *ctx = cs->conn->ctx;
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200219
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100220 /* Subscribe, to know if we got disconnected */
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100221 if (conn->owner != NULL &&
222 !(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))) {
223 ctx->cs = NULL;
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100224 conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Olivier Houchard9dce2c52019-10-18 10:59:30 +0200225 } else
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100226 /* There's no session attached to that connection, destroy it */
227 mux_pt_destroy(ctx);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200228}
229
Willy Tarreau00f18a32019-01-26 12:19:01 +0100230/* returns the number of streams in use on a connection */
231static int mux_pt_used_streams(struct connection *conn)
Olivier Houchardd540b362018-11-05 18:37:53 +0100232{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100233 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardd540b362018-11-05 18:37:53 +0100234
Willy Tarreau00f18a32019-01-26 12:19:01 +0100235 return ctx->cs ? 1 : 0;
Olivier Houchardd540b362018-11-05 18:37:53 +0100236}
237
Willy Tarreau00f18a32019-01-26 12:19:01 +0100238/* returns the number of streams still available on a connection */
239static int mux_pt_avail_streams(struct connection *conn)
Olivier Houchard8defe4b2018-12-02 01:31:17 +0100240{
Willy Tarreau00f18a32019-01-26 12:19:01 +0100241 return 1 - mux_pt_used_streams(conn);
Olivier Houchard8defe4b2018-12-02 01:31:17 +0100242}
243
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200244static void mux_pt_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200245{
Willy Tarreau4b795242017-10-05 18:47:38 +0200246 if (cs->flags & CS_FL_SHR)
247 return;
Christopher Fauletd94f8772018-12-17 13:21:02 +0100248 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200249 if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100250 cs->conn->xprt->shutr(cs->conn, cs->conn->xprt_ctx,
251 (mode == CS_SHR_DRAIN));
Willy Tarreau7d7b11c2020-12-11 11:07:19 +0100252 else if (mode == CS_SHR_DRAIN)
Willy Tarreau2ded48d2020-12-11 16:20:34 +0100253 conn_ctrl_drain(cs->conn);
Willy Tarreau4b795242017-10-05 18:47:38 +0200254 if (cs->flags & CS_FL_SHW)
255 conn_full_close(cs->conn);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200256}
257
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200258static void mux_pt_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200259{
Willy Tarreau4b795242017-10-05 18:47:38 +0200260 if (cs->flags & CS_FL_SHW)
261 return;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200262 if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100263 cs->conn->xprt->shutw(cs->conn, cs->conn->xprt_ctx,
264 (mode == CS_SHW_NORMAL));
Willy Tarreau4b795242017-10-05 18:47:38 +0200265 if (!(cs->flags & CS_FL_SHR))
Willy Tarreaua48c1412017-12-22 18:46:33 +0100266 conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL));
Willy Tarreau4b795242017-10-05 18:47:38 +0200267 else
268 conn_full_close(cs->conn);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200269}
270
271/*
272 * Called from the upper layer, to get more data
273 */
Willy Tarreau7f3225f2018-06-19 06:15:17 +0200274static size_t mux_pt_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200275{
Willy Tarreaud9cf5402018-07-18 11:29:06 +0200276 size_t ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200277
Christopher Faulet4eb7d742018-10-11 15:29:21 +0200278 if (!count) {
Christopher Fauletd94f8772018-12-17 13:21:02 +0100279 cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Christopher Faulet4eb7d742018-10-11 15:29:21 +0200280 return 0;
281 }
Willy Tarreaue0f24ee2018-12-14 10:51:23 +0100282 b_realign_if_empty(buf);
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100283 ret = cs->conn->xprt->rcv_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
Olivier Houchard8706c812018-12-04 19:17:25 +0100284 if (conn_xprt_read0_pending(cs->conn)) {
Willy Tarreau9cca8df2019-07-15 06:47:54 +0200285 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Christopher Faulet87a8f352019-03-22 14:51:36 +0100286 cs->flags |= CS_FL_EOS;
Olivier Houchard8706c812018-12-04 19:17:25 +0100287 }
288 if (cs->conn->flags & CO_FL_ERROR) {
Willy Tarreau9cca8df2019-07-15 06:47:54 +0200289 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200290 cs->flags |= CS_FL_ERROR;
Olivier Houchard8706c812018-12-04 19:17:25 +0100291 }
Willy Tarreaud9cf5402018-07-18 11:29:06 +0200292 return ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200293}
294
295/* Called from the upper layer, to send data */
Christopher Fauletd44a9b32018-07-27 11:59:41 +0200296static size_t mux_pt_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200297{
Olivier Houchardb72d98a2018-11-30 13:17:48 +0100298 size_t ret;
299
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100300 ret = cs->conn->xprt->snd_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
Christopher Fauletd44a9b32018-07-27 11:59:41 +0200301
302 if (ret > 0)
303 b_del(buf, ret);
304 return ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200305}
306
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100307/* Called from the upper layer, to subscribe <es> to events <event_type>. The
308 * event subscriber <es> is not allowed to change from a previous call as long
309 * as at least one event is still subscribed. The <event_type> must only be a
310 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0.
311 */
312static int mux_pt_subscribe(struct conn_stream *cs, int event_type, struct wait_event *es)
Olivier Houchard6ff20392018-07-17 18:46:31 +0200313{
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100314 return cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, event_type, es);
Olivier Houchard6ff20392018-07-17 18:46:31 +0200315}
316
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100317/* Called from the upper layer, to unsubscribe <es> from events <event_type>.
318 * The <es> pointer is not allowed to differ from the one passed to the
319 * subscribe() call. It always returns zero.
320 */
321static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, struct wait_event *es)
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200322{
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100323 return cs->conn->xprt->unsubscribe(cs->conn, cs->conn->xprt_ctx, event_type, es);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200324}
325
Willy Tarreaue5733232019-05-22 19:24:06 +0200326#if defined(USE_LINUX_SPLICE)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200327/* Send and get, using splicing */
328static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int count)
329{
330 int ret;
331
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100332 ret = cs->conn->xprt->rcv_pipe(cs->conn, cs->conn->xprt_ctx, pipe, count);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200333 if (conn_xprt_read0_pending(cs->conn))
Christopher Faulet87a8f352019-03-22 14:51:36 +0100334 cs->flags |= CS_FL_EOS;
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200335 if (cs->conn->flags & CO_FL_ERROR)
336 cs->flags |= CS_FL_ERROR;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200337 return (ret);
338}
339
340static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
341{
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100342 return (cs->conn->xprt->snd_pipe(cs->conn, cs->conn->xprt_ctx, pipe));
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200343}
Olivier Houchard7da120b2017-11-01 13:55:10 +0100344#endif
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200345
Olivier Houchard9b8e11e2019-10-25 16:19:26 +0200346static int mux_pt_ctl(struct connection *conn, enum mux_ctl_type mux_ctl, void *output)
347{
348 int ret = 0;
349 switch (mux_ctl) {
350 case MUX_STATUS:
Willy Tarreau911db9b2020-01-23 16:27:54 +0100351 if (!(conn->flags & CO_FL_WAIT_XPRT))
Olivier Houchard9b8e11e2019-10-25 16:19:26 +0200352 ret |= MUX_STATUS_READY;
353 return ret;
Christopher Faulet4c8ad842020-10-06 14:59:17 +0200354 case MUX_EXIT_STATUS:
355 return MUX_ES_UNKNOWN;
Olivier Houchard9b8e11e2019-10-25 16:19:26 +0200356 default:
357 return -1;
358 }
359}
360
Willy Tarreau53a47662017-08-28 10:53:00 +0200361/* The mux operations */
362const struct mux_ops mux_pt_ops = {
363 .init = mux_pt_init,
Willy Tarreau53a47662017-08-28 10:53:00 +0200364 .wake = mux_pt_wake,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200365 .rcv_buf = mux_pt_rcv_buf,
366 .snd_buf = mux_pt_snd_buf,
Olivier Houchard6ff20392018-07-17 18:46:31 +0200367 .subscribe = mux_pt_subscribe,
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200368 .unsubscribe = mux_pt_unsubscribe,
Willy Tarreaue5733232019-05-22 19:24:06 +0200369#if defined(USE_LINUX_SPLICE)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200370 .rcv_pipe = mux_pt_rcv_pipe,
371 .snd_pipe = mux_pt_snd_pipe,
372#endif
373 .attach = mux_pt_attach,
Willy Tarreaufafd3982018-11-18 21:29:20 +0100374 .get_first_cs = mux_pt_get_first_cs,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200375 .detach = mux_pt_detach,
Olivier Houchardd540b362018-11-05 18:37:53 +0100376 .avail_streams = mux_pt_avail_streams,
Willy Tarreau00f18a32019-01-26 12:19:01 +0100377 .used_streams = mux_pt_used_streams,
Olivier Houchard060ed432018-11-06 16:32:42 +0100378 .destroy = mux_pt_destroy_meth,
Olivier Houchard9b8e11e2019-10-25 16:19:26 +0200379 .ctl = mux_pt_ctl,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200380 .shutr = mux_pt_shutr,
381 .shutw = mux_pt_shutw,
Willy Tarreau28f1cb92017-12-20 16:14:44 +0100382 .flags = MX_FL_NONE,
Willy Tarreau53a47662017-08-28 10:53:00 +0200383 .name = "PASS",
384};
Willy Tarreauf6490822017-09-21 19:43:21 +0200385
Christopher Faulet32f61c02018-04-10 14:33:41 +0200386/* PROT selection : default mux has empty name */
387static struct mux_proto_list mux_proto_pt =
Christopher Faulet31930372019-07-15 10:16:58 +0200388 { .token = IST(""), .mode = PROTO_MODE_TCP, .side = PROTO_SIDE_BOTH, .mux = &mux_pt_ops };
Willy Tarreauf6490822017-09-21 19:43:21 +0200389
Willy Tarreau0108d902018-11-25 19:14:37 +0100390INITCALL1(STG_REGISTER, register_mux_proto, &mux_proto_pt);