Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 1 | /* |
| 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> |
| 14 | #include <proto/connection.h> |
| 15 | #include <proto/stream.h> |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 16 | #include <proto/task.h> |
| 17 | |
| 18 | static struct pool_head *pool_head_pt_ctx; |
| 19 | |
| 20 | struct mux_pt_ctx { |
| 21 | struct conn_stream *cs; |
| 22 | struct connection *conn; |
| 23 | struct wait_event wait_event; |
| 24 | }; |
| 25 | |
| 26 | static void mux_pt_destroy(struct mux_pt_ctx *ctx) |
| 27 | { |
| 28 | struct connection *conn = ctx->conn; |
| 29 | |
| 30 | LIST_DEL(&conn->list); |
| 31 | conn_stop_tracking(conn); |
| 32 | conn_full_close(conn); |
| 33 | if (conn->destroy_cb) |
| 34 | conn->destroy_cb(conn); |
| 35 | /* We don't bother unsubscribing here, as we're about to destroy |
| 36 | * both the connection and the mux_pt_ctx |
| 37 | */ |
| 38 | conn_free(conn); |
| 39 | pool_free(pool_head_pt_ctx, ctx); |
| 40 | } |
| 41 | |
| 42 | /* Callback, used when we get I/Os while in idle mode */ |
| 43 | static struct task *mux_pt_io_cb(struct task *t, void *tctx, unsigned short status) |
| 44 | { |
| 45 | struct mux_pt_ctx *ctx = tctx; |
| 46 | |
| 47 | conn_sock_drain(ctx->conn); |
| 48 | if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) |
| 49 | mux_pt_destroy(ctx); |
| 50 | else |
| 51 | ctx->conn->xprt->subscribe(ctx->conn, SUB_CAN_RECV, |
| 52 | &ctx->wait_event); |
| 53 | |
| 54 | return NULL; |
| 55 | } |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 56 | |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 57 | /* Initialize the mux once it's attached. It is expected that conn->mux_ctx |
| 58 | * points to the existing conn_stream (for outgoing connections) or NULL (for |
| 59 | * incoming ones, in which case one will be allocated and a new stream will be |
| 60 | * instanciated). Returns < 0 on error. |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 61 | */ |
Willy Tarreau | 175a2bb | 2018-09-12 12:02:05 +0200 | [diff] [blame] | 62 | static int mux_pt_init(struct connection *conn, struct proxy *prx) |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 63 | { |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 64 | struct conn_stream *cs = conn->mux_ctx; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 65 | struct mux_pt_ctx *ctx = pool_alloc(pool_head_pt_ctx); |
| 66 | |
| 67 | if (!ctx) |
| 68 | goto fail; |
| 69 | |
| 70 | ctx->wait_event.task = tasklet_new(); |
| 71 | if (!ctx->wait_event.task) |
| 72 | goto fail_free_ctx; |
| 73 | ctx->wait_event.task->context = ctx; |
| 74 | ctx->wait_event.task->process = mux_pt_io_cb; |
| 75 | ctx->wait_event.wait_reason = 0; |
| 76 | ctx->conn = conn; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 77 | |
| 78 | if (!cs) { |
| 79 | cs = cs_new(conn); |
| 80 | if (!cs) |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 81 | goto fail_free_ctx; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 82 | |
| 83 | if (stream_create_from_cs(cs) < 0) |
| 84 | goto fail_free; |
| 85 | |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 86 | } |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 87 | conn->mux_ctx = ctx; |
| 88 | ctx->cs = cs; |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 89 | return 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 90 | |
| 91 | fail_free: |
| 92 | cs_free(cs); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 93 | fail_free_ctx: |
| 94 | if (ctx->wait_event.task) |
| 95 | tasklet_free(ctx->wait_event.task); |
| 96 | pool_free(pool_head_pt_ctx, ctx); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 97 | fail: |
| 98 | return -1; |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | /* callback to be used by default for the pass-through mux. It calls the data |
| 102 | * layer wake() callback if it is set otherwise returns 0. |
| 103 | */ |
| 104 | static int mux_pt_wake(struct connection *conn) |
| 105 | { |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 106 | struct mux_pt_ctx *ctx = conn->mux_ctx; |
| 107 | struct conn_stream *cs = ctx->cs; |
| 108 | int ret = 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 109 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 110 | if (cs) { |
| 111 | ret = cs->data_cb->wake ? cs->data_cb->wake(cs) : 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 112 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 113 | if (ret < 0) |
| 114 | return ret; |
| 115 | } else { |
| 116 | conn_sock_drain(conn); |
| 117 | if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) { |
| 118 | mux_pt_destroy(ctx); |
| 119 | return -1; |
| 120 | } |
| 121 | } |
Willy Tarreau | ad7f0ad | 2018-08-24 15:48:59 +0200 | [diff] [blame] | 122 | |
Olivier Houchard | 7fc96d5 | 2017-11-23 18:25:47 +0100 | [diff] [blame] | 123 | /* If we had early data, and we're done with the handshake |
| 124 | * then whe know the data are safe, and we can remove the flag. |
| 125 | */ |
| 126 | if ((conn->flags & (CO_FL_EARLY_DATA | CO_FL_EARLY_SSL_HS | CO_FL_HANDSHAKE)) == |
| 127 | CO_FL_EARLY_DATA) |
| 128 | conn->flags &= ~CO_FL_EARLY_DATA; |
Willy Tarreau | ed339a3 | 2017-11-03 15:55:24 +0100 | [diff] [blame] | 129 | return ret; |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 130 | } |
| 131 | |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 132 | /* |
| 133 | * Attach a new stream to a connection |
| 134 | * (Used for outgoing connections) |
| 135 | */ |
| 136 | static struct conn_stream *mux_pt_attach(struct connection *conn) |
| 137 | { |
| 138 | return NULL; |
| 139 | } |
| 140 | |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 141 | /* Retrieves a valid conn_stream from this connection, or returns NULL. For |
| 142 | * this mux, it's easy as we can only store a single conn_stream. |
| 143 | */ |
| 144 | static const struct conn_stream *mux_pt_get_first_cs(const struct connection *conn) |
| 145 | { |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 146 | struct mux_pt_ctx *ctx = conn->mux_ctx; |
| 147 | struct conn_stream *cs = ctx->cs; |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 148 | |
| 149 | return cs; |
| 150 | } |
| 151 | |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 152 | /* |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 153 | * Detach the stream from the connection and possibly release the connection. |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 154 | */ |
| 155 | static void mux_pt_detach(struct conn_stream *cs) |
| 156 | { |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 157 | struct connection *conn = cs->conn; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 158 | struct mux_pt_ctx *ctx = cs->conn->mux_ctx; |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 159 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 160 | /* Subscribe, to know if we got disconnected */ |
| 161 | conn->xprt->subscribe(conn, SUB_CAN_RECV, &ctx->wait_event); |
| 162 | ctx->cs = NULL; |
| 163 | mux_pt_destroy(ctx); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 164 | } |
| 165 | |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 166 | static void mux_pt_shutr(struct conn_stream *cs, enum cs_shr_mode mode) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 167 | { |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 168 | if (cs->flags & CS_FL_SHR) |
| 169 | return; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 170 | if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr) |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 171 | cs->conn->xprt->shutr(cs->conn, (mode == CS_SHR_DRAIN)); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 172 | if (cs->flags & CS_FL_SHW) |
| 173 | conn_full_close(cs->conn); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 174 | } |
| 175 | |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 176 | static void mux_pt_shutw(struct conn_stream *cs, enum cs_shw_mode mode) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 177 | { |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 178 | if (cs->flags & CS_FL_SHW) |
| 179 | return; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 180 | if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw) |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 181 | cs->conn->xprt->shutw(cs->conn, (mode == CS_SHW_NORMAL)); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 182 | if (!(cs->flags & CS_FL_SHR)) |
Willy Tarreau | a48c141 | 2017-12-22 18:46:33 +0100 | [diff] [blame] | 183 | conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL)); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 184 | else |
| 185 | conn_full_close(cs->conn); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | /* |
| 189 | * Called from the upper layer, to get more data |
| 190 | */ |
Willy Tarreau | 7f3225f | 2018-06-19 06:15:17 +0200 | [diff] [blame] | 191 | static size_t mux_pt_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 192 | { |
Willy Tarreau | d9cf540 | 2018-07-18 11:29:06 +0200 | [diff] [blame] | 193 | size_t ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 194 | |
Christopher Faulet | 4eb7d74 | 2018-10-11 15:29:21 +0200 | [diff] [blame] | 195 | if (!count) { |
| 196 | cs->flags |= CS_FL_RCV_MORE; |
| 197 | return 0; |
| 198 | } |
| 199 | cs->flags &= ~CS_FL_RCV_MORE; |
Willy Tarreau | 7f3225f | 2018-06-19 06:15:17 +0200 | [diff] [blame] | 200 | ret = cs->conn->xprt->rcv_buf(cs->conn, buf, count, flags); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 201 | if (conn_xprt_read0_pending(cs->conn)) |
| 202 | cs->flags |= CS_FL_EOS; |
Willy Tarreau | 4ff3b89 | 2017-10-16 15:17:17 +0200 | [diff] [blame] | 203 | if (cs->conn->flags & CO_FL_ERROR) |
| 204 | cs->flags |= CS_FL_ERROR; |
Willy Tarreau | d9cf540 | 2018-07-18 11:29:06 +0200 | [diff] [blame] | 205 | return ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | /* Called from the upper layer, to send data */ |
Christopher Faulet | d44a9b3 | 2018-07-27 11:59:41 +0200 | [diff] [blame] | 209 | static size_t mux_pt_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 210 | { |
Christopher Faulet | d44a9b3 | 2018-07-27 11:59:41 +0200 | [diff] [blame] | 211 | size_t ret = cs->conn->xprt->snd_buf(cs->conn, buf, count, flags); |
| 212 | |
| 213 | if (ret > 0) |
| 214 | b_del(buf, ret); |
| 215 | return ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 216 | } |
| 217 | |
Olivier Houchard | 6ff2039 | 2018-07-17 18:46:31 +0200 | [diff] [blame] | 218 | /* Called from the upper layer, to subscribe to events */ |
| 219 | static int mux_pt_subscribe(struct conn_stream *cs, int event_type, void *param) |
| 220 | { |
| 221 | return (cs->conn->xprt->subscribe(cs->conn, event_type, param)); |
| 222 | } |
| 223 | |
Olivier Houchard | 83a0cd8 | 2018-09-28 17:57:58 +0200 | [diff] [blame] | 224 | static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, void *param) |
| 225 | { |
| 226 | return (cs->conn->xprt->unsubscribe(cs->conn, event_type, param)); |
| 227 | } |
| 228 | |
Olivier Houchard | 7da120b | 2017-11-01 13:55:10 +0100 | [diff] [blame] | 229 | #if defined(CONFIG_HAP_LINUX_SPLICE) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 230 | /* Send and get, using splicing */ |
| 231 | static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int count) |
| 232 | { |
| 233 | int ret; |
| 234 | |
| 235 | ret = cs->conn->xprt->rcv_pipe(cs->conn, pipe, count); |
| 236 | if (conn_xprt_read0_pending(cs->conn)) |
| 237 | cs->flags |= CS_FL_EOS; |
Willy Tarreau | 4ff3b89 | 2017-10-16 15:17:17 +0200 | [diff] [blame] | 238 | if (cs->conn->flags & CO_FL_ERROR) |
| 239 | cs->flags |= CS_FL_ERROR; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 240 | return (ret); |
| 241 | } |
| 242 | |
| 243 | static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe) |
| 244 | { |
| 245 | return (cs->conn->xprt->snd_pipe(cs->conn, pipe)); |
| 246 | } |
Olivier Houchard | 7da120b | 2017-11-01 13:55:10 +0100 | [diff] [blame] | 247 | #endif |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 248 | |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 249 | /* The mux operations */ |
| 250 | const struct mux_ops mux_pt_ops = { |
| 251 | .init = mux_pt_init, |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 252 | .wake = mux_pt_wake, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 253 | .rcv_buf = mux_pt_rcv_buf, |
| 254 | .snd_buf = mux_pt_snd_buf, |
Olivier Houchard | 6ff2039 | 2018-07-17 18:46:31 +0200 | [diff] [blame] | 255 | .subscribe = mux_pt_subscribe, |
Olivier Houchard | 83a0cd8 | 2018-09-28 17:57:58 +0200 | [diff] [blame] | 256 | .unsubscribe = mux_pt_unsubscribe, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 257 | #if defined(CONFIG_HAP_LINUX_SPLICE) |
| 258 | .rcv_pipe = mux_pt_rcv_pipe, |
| 259 | .snd_pipe = mux_pt_snd_pipe, |
| 260 | #endif |
| 261 | .attach = mux_pt_attach, |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 262 | .get_first_cs = mux_pt_get_first_cs, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 263 | .detach = mux_pt_detach, |
| 264 | .shutr = mux_pt_shutr, |
| 265 | .shutw = mux_pt_shutw, |
Willy Tarreau | 28f1cb9 | 2017-12-20 16:14:44 +0100 | [diff] [blame] | 266 | .flags = MX_FL_NONE, |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 267 | .name = "PASS", |
| 268 | }; |
Willy Tarreau | f649082 | 2017-09-21 19:43:21 +0200 | [diff] [blame] | 269 | |
Christopher Faulet | 32f61c0 | 2018-04-10 14:33:41 +0200 | [diff] [blame] | 270 | /* PROT selection : default mux has empty name */ |
| 271 | static struct mux_proto_list mux_proto_pt = |
| 272 | { .token = IST(""), .mode = PROTO_MODE_ANY, .side = PROTO_SIDE_BOTH, .mux = &mux_pt_ops }; |
Willy Tarreau | f649082 | 2017-09-21 19:43:21 +0200 | [diff] [blame] | 273 | |
| 274 | __attribute__((constructor)) |
| 275 | static void __mux_pt_init(void) |
| 276 | { |
Christopher Faulet | 32f61c0 | 2018-04-10 14:33:41 +0200 | [diff] [blame] | 277 | register_mux_proto(&mux_proto_pt); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame^] | 278 | pool_head_pt_ctx = create_pool("mux_pt", sizeof(struct mux_pt_ctx), |
| 279 | MEM_F_SHARED); |
Willy Tarreau | f649082 | 2017-09-21 19:43:21 +0200 | [diff] [blame] | 280 | } |