blob: b957ed6322667f8b6df4ee244dca8032ed794b63 [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
13#include <common/config.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010014#include <common/initcall.h>
Willy Tarreau53a47662017-08-28 10:53:00 +020015#include <proto/connection.h>
16#include <proto/stream.h>
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010017#include <proto/task.h>
18
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 Faulet61840e72019-04-15 09:33:32 +020029 /* The connection must be aattached to this mux to be released */
30 if (ctx && ctx->conn && ctx->conn->ctx == ctx) {
31 struct connection *conn = ctx->conn;
Christopher Faulet39a96ee2019-04-08 10:52:21 +020032
Christopher Faulet39a96ee2019-04-08 10:52:21 +020033 conn_stop_tracking(conn);
34 conn_full_close(conn);
Willy Tarreau3c39a7d2019-06-14 14:42:29 +020035 tasklet_free(ctx->wait_event.tasklet);
Christopher Faulet39a96ee2019-04-08 10:52:21 +020036 conn->mux = NULL;
37 conn->ctx = NULL;
38 if (conn->destroy_cb)
39 conn->destroy_cb(conn);
40 /* We don't bother unsubscribing here, as we're about to destroy
41 * both the connection and the mux_pt_ctx
42 */
43 conn_free(conn);
44 }
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010045 pool_free(pool_head_pt_ctx, ctx);
46}
47
48/* Callback, used when we get I/Os while in idle mode */
49static struct task *mux_pt_io_cb(struct task *t, void *tctx, unsigned short status)
50{
51 struct mux_pt_ctx *ctx = tctx;
52
53 conn_sock_drain(ctx->conn);
Olivier Houcharde8826de2019-10-17 18:02:53 +020054 if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH)) {
55 if (!ctx->cs)
56 mux_pt_destroy(ctx);
57 } else
Olivier Houcharde179d0e2019-03-21 18:27:17 +010058 ctx->conn->xprt->subscribe(ctx->conn, ctx->conn->xprt_ctx, SUB_RETRY_RECV,
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010059 &ctx->wait_event);
60
61 return NULL;
62}
Willy Tarreau53a47662017-08-28 10:53:00 +020063
Willy Tarreau3d2ee552018-12-19 14:12:10 +010064/* Initialize the mux once it's attached. It is expected that conn->ctx
Olivier Houchard9aaf7782017-09-13 18:30:23 +020065 * points to the existing conn_stream (for outgoing connections) or NULL (for
66 * incoming ones, in which case one will be allocated and a new stream will be
67 * instanciated). Returns < 0 on error.
Willy Tarreau53a47662017-08-28 10:53:00 +020068 */
Christopher Faulet51f73eb2019-04-08 11:22:47 +020069static int mux_pt_init(struct connection *conn, struct proxy *prx, struct session *sess,
70 struct buffer *input)
Willy Tarreau53a47662017-08-28 10:53:00 +020071{
Willy Tarreau3d2ee552018-12-19 14:12:10 +010072 struct conn_stream *cs = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010073 struct mux_pt_ctx *ctx = pool_alloc(pool_head_pt_ctx);
74
75 if (!ctx)
76 goto fail;
77
Willy Tarreau3c39a7d2019-06-14 14:42:29 +020078 ctx->wait_event.tasklet = tasklet_new();
79 if (!ctx->wait_event.tasklet)
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010080 goto fail_free_ctx;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +020081 ctx->wait_event.tasklet->context = ctx;
82 ctx->wait_event.tasklet->process = mux_pt_io_cb;
Willy Tarreau4f6516d2018-12-19 13:59:17 +010083 ctx->wait_event.events = 0;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010084 ctx->conn = conn;
Olivier Houchard9aaf7782017-09-13 18:30:23 +020085
86 if (!cs) {
87 cs = cs_new(conn);
88 if (!cs)
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010089 goto fail_free_ctx;
Olivier Houchard9aaf7782017-09-13 18:30:23 +020090
91 if (stream_create_from_cs(cs) < 0)
92 goto fail_free;
93
Olivier Houchard9aaf7782017-09-13 18:30:23 +020094 }
Willy Tarreau3d2ee552018-12-19 14:12:10 +010095 conn->ctx = ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +010096 ctx->cs = cs;
Olivier Houchard8706c812018-12-04 19:17:25 +010097 cs->flags |= CS_FL_RCV_MORE;
Willy Tarreau53a47662017-08-28 10:53:00 +020098 return 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +020099
100 fail_free:
101 cs_free(cs);
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100102fail_free_ctx:
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200103 if (ctx->wait_event.tasklet)
104 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100105 pool_free(pool_head_pt_ctx, ctx);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200106 fail:
107 return -1;
Willy Tarreau53a47662017-08-28 10:53:00 +0200108}
109
110/* callback to be used by default for the pass-through mux. It calls the data
111 * layer wake() callback if it is set otherwise returns 0.
112 */
113static int mux_pt_wake(struct connection *conn)
114{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100115 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100116 struct conn_stream *cs = ctx->cs;
117 int ret = 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200118
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100119 if (cs) {
120 ret = cs->data_cb->wake ? cs->data_cb->wake(cs) : 0;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200121
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100122 if (ret < 0)
123 return ret;
124 } else {
125 conn_sock_drain(conn);
126 if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) {
127 mux_pt_destroy(ctx);
128 return -1;
129 }
130 }
Willy Tarreauad7f0ad2018-08-24 15:48:59 +0200131
Olivier Houchard7fc96d52017-11-23 18:25:47 +0100132 /* If we had early data, and we're done with the handshake
133 * then whe know the data are safe, and we can remove the flag.
134 */
135 if ((conn->flags & (CO_FL_EARLY_DATA | CO_FL_EARLY_SSL_HS | CO_FL_HANDSHAKE)) ==
136 CO_FL_EARLY_DATA)
137 conn->flags &= ~CO_FL_EARLY_DATA;
Willy Tarreaued339a32017-11-03 15:55:24 +0100138 return ret;
Willy Tarreau53a47662017-08-28 10:53:00 +0200139}
140
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200141/*
142 * Attach a new stream to a connection
143 * (Used for outgoing connections)
144 */
Olivier Houchardf502aca2018-12-14 19:42:40 +0100145static struct conn_stream *mux_pt_attach(struct connection *conn, struct session *sess)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200146{
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100147 struct conn_stream *cs;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100148 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100149
Olivier Houchardea32b0f2019-08-10 23:56:16 +0200150 if (ctx->wait_event.events)
151 conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100152 cs = cs_new(conn);
153 if (!cs)
154 goto fail;
155
156 ctx->cs = cs;
Olivier Houchard8706c812018-12-04 19:17:25 +0100157 cs->flags |= CS_FL_RCV_MORE;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100158 return (cs);
159fail:
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200160 return NULL;
161}
162
Willy Tarreaufafd3982018-11-18 21:29:20 +0100163/* Retrieves a valid conn_stream from this connection, or returns NULL. For
164 * this mux, it's easy as we can only store a single conn_stream.
165 */
166static const struct conn_stream *mux_pt_get_first_cs(const struct connection *conn)
167{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100168 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100169 struct conn_stream *cs = ctx->cs;
Willy Tarreaufafd3982018-11-18 21:29:20 +0100170
171 return cs;
172}
173
Christopher Faulet73c12072019-04-08 11:23:22 +0200174/* Destroy the mux and the associated connection if still attached to this mux
175 * and no longer used */
176static void mux_pt_destroy_meth(void *ctx)
Olivier Houchard060ed432018-11-06 16:32:42 +0100177{
Christopher Faulet73c12072019-04-08 11:23:22 +0200178 struct mux_pt_ctx *pt = ctx;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100179
Christopher Faulet39a96ee2019-04-08 10:52:21 +0200180 if (!(pt->cs) || !(pt->conn) || pt->conn->ctx != pt)
Christopher Faulet73c12072019-04-08 11:23:22 +0200181 mux_pt_destroy(pt);
Olivier Houchard060ed432018-11-06 16:32:42 +0100182}
183
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200184/*
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200185 * Detach the stream from the connection and possibly release the connection.
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200186 */
187static void mux_pt_detach(struct conn_stream *cs)
188{
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200189 struct connection *conn = cs->conn;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100190 struct mux_pt_ctx *ctx = cs->conn->ctx;
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200191
Olivier Houchardb6c32ee2018-11-05 18:28:43 +0100192 /* Subscribe, to know if we got disconnected */
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100193 if (conn->owner != NULL &&
194 !(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))) {
195 ctx->cs = NULL;
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100196 conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Olivier Houcharde8826de2019-10-17 18:02:53 +0200197 } else if (!ctx->cs)
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100198 /* There's no session attached to that connection, destroy it */
199 mux_pt_destroy(ctx);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200200}
201
Willy Tarreau00f18a32019-01-26 12:19:01 +0100202/* returns the number of streams in use on a connection */
203static int mux_pt_used_streams(struct connection *conn)
Olivier Houchardd540b362018-11-05 18:37:53 +0100204{
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100205 struct mux_pt_ctx *ctx = conn->ctx;
Olivier Houchardd540b362018-11-05 18:37:53 +0100206
Willy Tarreau00f18a32019-01-26 12:19:01 +0100207 return ctx->cs ? 1 : 0;
Olivier Houchardd540b362018-11-05 18:37:53 +0100208}
209
Willy Tarreau00f18a32019-01-26 12:19:01 +0100210/* returns the number of streams still available on a connection */
211static int mux_pt_avail_streams(struct connection *conn)
Olivier Houchard8defe4b2018-12-02 01:31:17 +0100212{
Willy Tarreau00f18a32019-01-26 12:19:01 +0100213 return 1 - mux_pt_used_streams(conn);
Olivier Houchard8defe4b2018-12-02 01:31:17 +0100214}
215
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200216static void mux_pt_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200217{
Willy Tarreau4b795242017-10-05 18:47:38 +0200218 if (cs->flags & CS_FL_SHR)
219 return;
Christopher Fauletd94f8772018-12-17 13:21:02 +0100220 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200221 if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100222 cs->conn->xprt->shutr(cs->conn, cs->conn->xprt_ctx,
223 (mode == CS_SHR_DRAIN));
Willy Tarreau4b795242017-10-05 18:47:38 +0200224 if (cs->flags & CS_FL_SHW)
225 conn_full_close(cs->conn);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100226 /* Maybe we've been put in the list of available idle connections,
227 * get ouf of here
228 */
229 LIST_DEL(&cs->conn->list);
230 LIST_INIT(&cs->conn->list);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200231}
232
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200233static void mux_pt_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200234{
Willy Tarreau4b795242017-10-05 18:47:38 +0200235 if (cs->flags & CS_FL_SHW)
236 return;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200237 if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100238 cs->conn->xprt->shutw(cs->conn, cs->conn->xprt_ctx,
239 (mode == CS_SHW_NORMAL));
Willy Tarreau4b795242017-10-05 18:47:38 +0200240 if (!(cs->flags & CS_FL_SHR))
Willy Tarreaua48c1412017-12-22 18:46:33 +0100241 conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL));
Willy Tarreau4b795242017-10-05 18:47:38 +0200242 else
243 conn_full_close(cs->conn);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100244 /* Maybe we've been put in the list of available idle connections,
245 * get ouf of here
246 */
247 LIST_DEL(&cs->conn->list);
248 LIST_INIT(&cs->conn->list);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200249}
250
251/*
252 * Called from the upper layer, to get more data
253 */
Willy Tarreau7f3225f2018-06-19 06:15:17 +0200254static 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 +0200255{
Willy Tarreaud9cf5402018-07-18 11:29:06 +0200256 size_t ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200257
Christopher Faulet4eb7d742018-10-11 15:29:21 +0200258 if (!count) {
Christopher Fauletd94f8772018-12-17 13:21:02 +0100259 cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Christopher Faulet4eb7d742018-10-11 15:29:21 +0200260 return 0;
261 }
Willy Tarreaue0f24ee2018-12-14 10:51:23 +0100262 b_realign_if_empty(buf);
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100263 ret = cs->conn->xprt->rcv_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
Olivier Houchard8706c812018-12-04 19:17:25 +0100264 if (conn_xprt_read0_pending(cs->conn)) {
Willy Tarreau9cca8df2019-07-15 06:47:54 +0200265 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Christopher Faulet87a8f352019-03-22 14:51:36 +0100266 cs->flags |= CS_FL_EOS;
Olivier Houchard8706c812018-12-04 19:17:25 +0100267 }
268 if (cs->conn->flags & CO_FL_ERROR) {
Willy Tarreau9cca8df2019-07-15 06:47:54 +0200269 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200270 cs->flags |= CS_FL_ERROR;
Olivier Houchard8706c812018-12-04 19:17:25 +0100271 }
Willy Tarreaud9cf5402018-07-18 11:29:06 +0200272 return ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200273}
274
275/* Called from the upper layer, to send data */
Christopher Fauletd44a9b32018-07-27 11:59:41 +0200276static 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 +0200277{
Olivier Houchardb72d98a2018-11-30 13:17:48 +0100278 size_t ret;
279
280 if (cs->conn->flags & CO_FL_HANDSHAKE)
281 return 0;
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100282 ret = cs->conn->xprt->snd_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags);
Christopher Fauletd44a9b32018-07-27 11:59:41 +0200283
284 if (ret > 0)
285 b_del(buf, ret);
286 return ret;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200287}
288
Olivier Houchard6ff20392018-07-17 18:46:31 +0200289/* Called from the upper layer, to subscribe to events */
290static int mux_pt_subscribe(struct conn_stream *cs, int event_type, void *param)
291{
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100292 return (cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, event_type, param));
Olivier Houchard6ff20392018-07-17 18:46:31 +0200293}
294
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200295static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, void *param)
296{
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100297 return (cs->conn->xprt->unsubscribe(cs->conn, cs->conn->xprt_ctx, event_type, param));
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200298}
299
Willy Tarreaue5733232019-05-22 19:24:06 +0200300#if defined(USE_LINUX_SPLICE)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200301/* Send and get, using splicing */
302static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int count)
303{
304 int ret;
305
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100306 ret = cs->conn->xprt->rcv_pipe(cs->conn, cs->conn->xprt_ctx, pipe, count);
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200307 if (conn_xprt_read0_pending(cs->conn))
Christopher Faulet87a8f352019-03-22 14:51:36 +0100308 cs->flags |= CS_FL_EOS;
Willy Tarreau4ff3b892017-10-16 15:17:17 +0200309 if (cs->conn->flags & CO_FL_ERROR)
310 cs->flags |= CS_FL_ERROR;
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200311 return (ret);
312}
313
314static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
315{
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100316 return (cs->conn->xprt->snd_pipe(cs->conn, cs->conn->xprt_ctx, pipe));
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200317}
Olivier Houchard7da120b2017-11-01 13:55:10 +0100318#endif
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200319
Willy Tarreau53a47662017-08-28 10:53:00 +0200320/* The mux operations */
321const struct mux_ops mux_pt_ops = {
322 .init = mux_pt_init,
Willy Tarreau53a47662017-08-28 10:53:00 +0200323 .wake = mux_pt_wake,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200324 .rcv_buf = mux_pt_rcv_buf,
325 .snd_buf = mux_pt_snd_buf,
Olivier Houchard6ff20392018-07-17 18:46:31 +0200326 .subscribe = mux_pt_subscribe,
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200327 .unsubscribe = mux_pt_unsubscribe,
Willy Tarreaue5733232019-05-22 19:24:06 +0200328#if defined(USE_LINUX_SPLICE)
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200329 .rcv_pipe = mux_pt_rcv_pipe,
330 .snd_pipe = mux_pt_snd_pipe,
331#endif
332 .attach = mux_pt_attach,
Willy Tarreaufafd3982018-11-18 21:29:20 +0100333 .get_first_cs = mux_pt_get_first_cs,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200334 .detach = mux_pt_detach,
Olivier Houchardd540b362018-11-05 18:37:53 +0100335 .avail_streams = mux_pt_avail_streams,
Willy Tarreau00f18a32019-01-26 12:19:01 +0100336 .used_streams = mux_pt_used_streams,
Olivier Houchard060ed432018-11-06 16:32:42 +0100337 .destroy = mux_pt_destroy_meth,
Olivier Houchard7a3f0df2017-09-13 18:30:23 +0200338 .shutr = mux_pt_shutr,
339 .shutw = mux_pt_shutw,
Willy Tarreau28f1cb92017-12-20 16:14:44 +0100340 .flags = MX_FL_NONE,
Willy Tarreau53a47662017-08-28 10:53:00 +0200341 .name = "PASS",
342};
Willy Tarreauf6490822017-09-21 19:43:21 +0200343
Christopher Faulet32f61c02018-04-10 14:33:41 +0200344/* PROT selection : default mux has empty name */
345static struct mux_proto_list mux_proto_pt =
Christopher Faulet31930372019-07-15 10:16:58 +0200346 { .token = IST(""), .mode = PROTO_MODE_TCP, .side = PROTO_SIDE_BOTH, .mux = &mux_pt_ops };
Willy Tarreauf6490822017-09-21 19:43:21 +0200347
Willy Tarreau0108d902018-11-25 19:14:37 +0100348INITCALL1(STG_REGISTER, register_mux_proto, &mux_proto_pt);