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 | |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 13 | #include <haproxy/api.h> |
Willy Tarreau | 16f958c | 2020-06-03 08:44:35 +0200 | [diff] [blame] | 14 | #include <haproxy/buf.h> |
Willy Tarreau | 7ea393d | 2020-06-04 18:02:10 +0200 | [diff] [blame] | 15 | #include <haproxy/connection.h> |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 16 | #include <haproxy/pipe-t.h> |
Willy Tarreau | dfd3de8 | 2020-06-04 23:46:14 +0200 | [diff] [blame] | 17 | #include <haproxy/stream.h> |
Willy Tarreau | cea0e1b | 2020-06-04 17:25:40 +0200 | [diff] [blame] | 18 | #include <haproxy/task.h> |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 19 | #include <haproxy/trace.h> |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 20 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 21 | struct mux_pt_ctx { |
| 22 | struct conn_stream *cs; |
| 23 | struct connection *conn; |
| 24 | struct wait_event wait_event; |
| 25 | }; |
| 26 | |
Willy Tarreau | 8ceae72 | 2018-11-26 11:58:30 +0100 | [diff] [blame] | 27 | DECLARE_STATIC_POOL(pool_head_pt_ctx, "mux_pt", sizeof(struct mux_pt_ctx)); |
| 28 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 29 | /* trace source and events */ |
| 30 | static void pt_trace(enum trace_level level, uint64_t mask, |
| 31 | const struct trace_source *src, |
| 32 | const struct ist where, const struct ist func, |
| 33 | const void *a1, const void *a2, const void *a3, const void *a4); |
| 34 | |
| 35 | /* The event representation is split like this : |
| 36 | * pt_ctx - internal PT context |
| 37 | * strm - application layer |
| 38 | */ |
| 39 | static const struct trace_event pt_trace_events[] = { |
| 40 | #define PT_EV_CONN_NEW (1ULL << 0) |
| 41 | { .mask = PT_EV_CONN_NEW, .name = "pt_conn_new", .desc = "new PT connection" }, |
| 42 | #define PT_EV_CONN_WAKE (1ULL << 1) |
| 43 | { .mask = PT_EV_CONN_WAKE, .name = "pt_conn_wake", .desc = "PT connection woken up" }, |
| 44 | #define PT_EV_CONN_END (1ULL << 2) |
| 45 | { .mask = PT_EV_CONN_END, .name = "pt_conn_end", .desc = "PT connection terminated" }, |
| 46 | #define PT_EV_CONN_ERR (1ULL << 3) |
| 47 | { .mask = PT_EV_CONN_ERR, .name = "pt_conn_err", .desc = "error on PT connection" }, |
| 48 | #define PT_EV_STRM_NEW (1ULL << 4) |
| 49 | { .mask = PT_EV_STRM_NEW, .name = "strm_new", .desc = "app-layer stream creation" }, |
| 50 | #define PT_EV_STRM_SHUT (1ULL << 5) |
| 51 | { .mask = PT_EV_STRM_SHUT, .name = "strm_shut", .desc = "stream shutdown" }, |
| 52 | #define PT_EV_STRM_END (1ULL << 6) |
| 53 | { .mask = PT_EV_STRM_END, .name = "strm_end", .desc = "detaching app-layer stream" }, |
| 54 | #define PT_EV_STRM_ERR (1ULL << 7) |
| 55 | { .mask = PT_EV_STRM_ERR, .name = "strm_err", .desc = "stream error" }, |
| 56 | #define PT_EV_RX_DATA (1ULL << 8) |
| 57 | { .mask = PT_EV_RX_DATA, .name = "pt_rx_data", .desc = "Rx on PT connection" }, |
| 58 | #define PT_EV_TX_DATA (1ULL << 9) |
| 59 | { .mask = PT_EV_TX_DATA, .name = "pt_tx_data", .desc = "Tx on PT connection" }, |
| 60 | |
| 61 | {} |
| 62 | }; |
| 63 | |
| 64 | |
| 65 | static const struct name_desc pt_trace_decoding[] = { |
| 66 | #define PT_VERB_CLEAN 1 |
| 67 | { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" }, |
| 68 | #define PT_VERB_MINIMAL 2 |
| 69 | { .name="minimal", .desc="report only h1c/h1s state and flags, no real decoding" }, |
| 70 | #define PT_VERB_SIMPLE 3 |
| 71 | { .name="simple", .desc="add request/response status line or htx info when available" }, |
| 72 | #define PT_VERB_ADVANCED 4 |
| 73 | { .name="advanced", .desc="add header fields or frame decoding when available" }, |
| 74 | #define PT_VERB_COMPLETE 5 |
| 75 | { .name="complete", .desc="add full data dump when available" }, |
| 76 | { /* end */ } |
| 77 | }; |
| 78 | |
Willy Tarreau | 6eb3d37 | 2021-04-10 19:29:26 +0200 | [diff] [blame] | 79 | static struct trace_source trace_pt __read_mostly = { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 80 | .name = IST("pt"), |
| 81 | .desc = "Passthrough multiplexer", |
| 82 | .arg_def = TRC_ARG1_CONN, // TRACE()'s first argument is always a connection |
| 83 | .default_cb = pt_trace, |
| 84 | .known_events = pt_trace_events, |
| 85 | .lockon_args = NULL, |
| 86 | .decoding = pt_trace_decoding, |
| 87 | .report_events = ~0, // report everything by default |
| 88 | }; |
| 89 | |
| 90 | #define TRACE_SOURCE &trace_pt |
| 91 | INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE); |
| 92 | |
| 93 | static inline void pt_trace_buf(const struct buffer *buf, size_t ofs, size_t len) |
| 94 | { |
| 95 | size_t block1, block2; |
| 96 | int line, ptr, newptr; |
| 97 | |
| 98 | block1 = b_contig_data(buf, ofs); |
| 99 | block2 = 0; |
| 100 | if (block1 > len) |
| 101 | block1 = len; |
| 102 | block2 = len - block1; |
| 103 | |
| 104 | ofs = b_peek_ofs(buf, ofs); |
| 105 | |
| 106 | line = 0; |
| 107 | ptr = ofs; |
| 108 | while (ptr < ofs + block1) { |
| 109 | newptr = dump_text_line(&trace_buf, b_orig(buf), b_size(buf), ofs + block1, &line, ptr); |
| 110 | if (newptr == ptr) |
| 111 | break; |
| 112 | ptr = newptr; |
| 113 | } |
| 114 | |
| 115 | line = ptr = 0; |
| 116 | while (ptr < block2) { |
| 117 | newptr = dump_text_line(&trace_buf, b_orig(buf), b_size(buf), block2, &line, ptr); |
| 118 | if (newptr == ptr) |
| 119 | break; |
| 120 | ptr = newptr; |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | /* the PT traces always expect that arg1, if non-null, is of type connection |
| 125 | * (from which we can derive the pt context), that arg2, if non-null, is a |
| 126 | * conn-stream, and that arg3, if non-null, is a buffer. |
| 127 | */ |
| 128 | static void pt_trace(enum trace_level level, uint64_t mask, const struct trace_source *src, |
| 129 | const struct ist where, const struct ist func, |
| 130 | const void *a1, const void *a2, const void *a3, const void *a4) |
| 131 | { |
| 132 | const struct connection *conn = a1; |
| 133 | const struct mux_pt_ctx *ctx = conn ? conn->ctx : NULL; |
| 134 | const struct conn_stream *cs = a2; |
| 135 | const struct buffer *buf = a3; |
| 136 | const size_t *val = a4; |
| 137 | |
| 138 | if (!ctx|| src->verbosity < PT_VERB_CLEAN) |
| 139 | return; |
| 140 | |
| 141 | /* Display frontend/backend info by default */ |
| 142 | chunk_appendf(&trace_buf, " : [%c]", (conn_is_back(conn) ? 'B' : 'F')); |
| 143 | |
| 144 | if (src->verbosity == PT_VERB_CLEAN) |
| 145 | return; |
| 146 | |
| 147 | /* Display the value to the 4th argument (level > STATE) */ |
| 148 | if (src->level > TRACE_LEVEL_STATE && val) |
| 149 | chunk_appendf(&trace_buf, " - VAL=%lu", (long)*val); |
| 150 | |
| 151 | /* Display conn and cs info, if defined (pointer + flags) */ |
| 152 | chunk_appendf(&trace_buf, " - conn=%p(0x%08x)", conn, conn->flags); |
| 153 | if (cs) |
| 154 | chunk_appendf(&trace_buf, " cs=%p(0x%08x)", cs, cs->flags); |
| 155 | |
| 156 | if (src->verbosity == PT_VERB_MINIMAL) |
| 157 | return; |
| 158 | |
| 159 | /* Display buffer info, if defined (level > USER & verbosity > SIMPLE) */ |
| 160 | if (src->level > TRACE_LEVEL_USER && buf) { |
| 161 | int full = 0, max = 3000, chunk = 1024; |
| 162 | |
| 163 | /* Full info (level > STATE && verbosity > SIMPLE) */ |
| 164 | if (src->level > TRACE_LEVEL_STATE) { |
| 165 | if (src->verbosity == PT_VERB_COMPLETE) |
| 166 | full = 1; |
| 167 | else if (src->verbosity == PT_VERB_ADVANCED) { |
| 168 | full = 1; |
| 169 | max = 256; |
| 170 | chunk = 64; |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | chunk_appendf(&trace_buf, " buf=%u@%p+%u/%u", |
| 175 | (unsigned int)b_data(buf), b_orig(buf), |
| 176 | (unsigned int)b_head_ofs(buf), (unsigned int)b_size(buf)); |
| 177 | |
| 178 | if (b_data(buf) && full) { |
| 179 | chunk_memcat(&trace_buf, "\n", 1); |
| 180 | if (b_data(buf) < max) |
| 181 | pt_trace_buf(buf, 0, b_data(buf)); |
| 182 | else { |
| 183 | pt_trace_buf(buf, 0, chunk); |
| 184 | chunk_memcat(&trace_buf, " ...\n", 6); |
| 185 | pt_trace_buf(buf, b_data(buf) - chunk, chunk); |
| 186 | } |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 191 | static void mux_pt_destroy(struct mux_pt_ctx *ctx) |
| 192 | { |
Christopher Faulet | 5a7ca29 | 2020-11-03 09:11:43 +0100 | [diff] [blame] | 193 | struct connection *conn = NULL; |
Christopher Faulet | 39a96ee | 2019-04-08 10:52:21 +0200 | [diff] [blame] | 194 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 195 | TRACE_POINT(PT_EV_CONN_END); |
| 196 | |
Christopher Faulet | 5a7ca29 | 2020-11-03 09:11:43 +0100 | [diff] [blame] | 197 | if (ctx) { |
| 198 | /* The connection must be attached to this mux to be released */ |
| 199 | if (ctx->conn && ctx->conn->ctx == ctx) |
| 200 | conn = ctx->conn; |
| 201 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 202 | TRACE_DEVEL("freeing pt context", PT_EV_CONN_END, conn); |
| 203 | |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 204 | tasklet_free(ctx->wait_event.tasklet); |
Christopher Faulet | 5a7ca29 | 2020-11-03 09:11:43 +0100 | [diff] [blame] | 205 | |
| 206 | if (conn && ctx->wait_event.events != 0) |
| 207 | conn->xprt->unsubscribe(conn, conn->xprt_ctx, ctx->wait_event.events, |
| 208 | &ctx->wait_event); |
| 209 | pool_free(pool_head_pt_ctx, ctx); |
| 210 | } |
| 211 | |
| 212 | if (conn) { |
Christopher Faulet | 39a96ee | 2019-04-08 10:52:21 +0200 | [diff] [blame] | 213 | conn->mux = NULL; |
| 214 | conn->ctx = NULL; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 215 | TRACE_DEVEL("freeing conn", PT_EV_CONN_END, conn); |
Christopher Faulet | 5a7ca29 | 2020-11-03 09:11:43 +0100 | [diff] [blame] | 216 | |
| 217 | conn_stop_tracking(conn); |
| 218 | conn_full_close(conn); |
Christopher Faulet | 39a96ee | 2019-04-08 10:52:21 +0200 | [diff] [blame] | 219 | if (conn->destroy_cb) |
| 220 | conn->destroy_cb(conn); |
Christopher Faulet | 39a96ee | 2019-04-08 10:52:21 +0200 | [diff] [blame] | 221 | conn_free(conn); |
| 222 | } |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 223 | } |
| 224 | |
Willy Tarreau | 691d503 | 2021-01-20 14:55:01 +0100 | [diff] [blame] | 225 | /* Callback, used when we get I/Os while in idle mode. This one is exported so |
| 226 | * that "show fd" can resolve it. |
| 227 | */ |
Willy Tarreau | 144f84a | 2021-03-02 16:09:26 +0100 | [diff] [blame] | 228 | struct task *mux_pt_io_cb(struct task *t, void *tctx, unsigned int status) |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 229 | { |
| 230 | struct mux_pt_ctx *ctx = tctx; |
| 231 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 232 | TRACE_ENTER(PT_EV_CONN_WAKE, ctx->conn, ctx->cs); |
Olivier Houchard | ea510fc | 2019-10-18 13:56:40 +0200 | [diff] [blame] | 233 | if (ctx->cs) { |
| 234 | /* There's a small race condition. |
| 235 | * mux_pt_io_cb() is only supposed to be called if we have no |
| 236 | * stream attached. However, maybe the tasklet got woken up, |
| 237 | * and this connection was then attached to a new stream. |
Olivier Houchard | 2ed389d | 2019-10-18 14:18:29 +0200 | [diff] [blame] | 238 | * If this happened, just wake the tasklet up if anybody |
| 239 | * subscribed to receive events, and otherwise call the wake |
| 240 | * method, to make sure the event is noticed. |
Olivier Houchard | ea510fc | 2019-10-18 13:56:40 +0200 | [diff] [blame] | 241 | */ |
Willy Tarreau | 7872d1f | 2020-01-10 07:06:05 +0100 | [diff] [blame] | 242 | if (ctx->conn->subs) { |
| 243 | ctx->conn->subs->events = 0; |
| 244 | tasklet_wakeup(ctx->conn->subs->tasklet); |
| 245 | ctx->conn->subs = NULL; |
Olivier Houchard | 2ed389d | 2019-10-18 14:18:29 +0200 | [diff] [blame] | 246 | } else if (ctx->cs->data_cb->wake) |
Olivier Houchard | ea510fc | 2019-10-18 13:56:40 +0200 | [diff] [blame] | 247 | ctx->cs->data_cb->wake(ctx->cs); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 248 | TRACE_DEVEL("leaving waking up CS", PT_EV_CONN_WAKE, ctx->conn, ctx->cs); |
Willy Tarreau | 7416314 | 2021-03-13 11:30:19 +0100 | [diff] [blame] | 249 | return t; |
Olivier Houchard | ea510fc | 2019-10-18 13:56:40 +0200 | [diff] [blame] | 250 | } |
Willy Tarreau | 2ded48d | 2020-12-11 16:20:34 +0100 | [diff] [blame] | 251 | conn_ctrl_drain(ctx->conn); |
Willy Tarreau | 7416314 | 2021-03-13 11:30:19 +0100 | [diff] [blame] | 252 | if (ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH)) { |
Christopher Faulet | e2c65ba | 2021-04-10 09:02:32 +0200 | [diff] [blame] | 253 | TRACE_DEVEL("leaving destroying pt context", PT_EV_CONN_WAKE, ctx->conn); |
Olivier Houchard | 9dce2c5 | 2019-10-18 10:59:30 +0200 | [diff] [blame] | 254 | mux_pt_destroy(ctx); |
Willy Tarreau | 7416314 | 2021-03-13 11:30:19 +0100 | [diff] [blame] | 255 | t = NULL; |
| 256 | } |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 257 | else { |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 258 | ctx->conn->xprt->subscribe(ctx->conn, ctx->conn->xprt_ctx, SUB_RETRY_RECV, |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 259 | &ctx->wait_event); |
Christopher Faulet | e2c65ba | 2021-04-10 09:02:32 +0200 | [diff] [blame] | 260 | TRACE_DEVEL("leaving subscribing for reads", PT_EV_CONN_WAKE, ctx->conn); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 261 | } |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 262 | |
Willy Tarreau | 7416314 | 2021-03-13 11:30:19 +0100 | [diff] [blame] | 263 | return t; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 264 | } |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 265 | |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 266 | /* Initialize the mux once it's attached. It is expected that conn->ctx |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 267 | * points to the existing conn_stream (for outgoing connections) or NULL (for |
| 268 | * incoming ones, in which case one will be allocated and a new stream will be |
Ilya Shipitsin | 46a030c | 2020-07-05 16:36:08 +0500 | [diff] [blame] | 269 | * instantiated). Returns < 0 on error. |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 270 | */ |
Christopher Faulet | 51f73eb | 2019-04-08 11:22:47 +0200 | [diff] [blame] | 271 | static int mux_pt_init(struct connection *conn, struct proxy *prx, struct session *sess, |
| 272 | struct buffer *input) |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 273 | { |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 274 | struct conn_stream *cs = conn->ctx; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 275 | struct mux_pt_ctx *ctx = pool_alloc(pool_head_pt_ctx); |
| 276 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 277 | TRACE_ENTER(PT_EV_CONN_NEW); |
| 278 | |
| 279 | if (!ctx) { |
| 280 | TRACE_ERROR("PT context allocation failure", PT_EV_CONN_NEW|PT_EV_CONN_END|PT_EV_CONN_ERR); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 281 | goto fail; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 282 | } |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 283 | |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 284 | ctx->wait_event.tasklet = tasklet_new(); |
| 285 | if (!ctx->wait_event.tasklet) |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 286 | goto fail_free_ctx; |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 287 | ctx->wait_event.tasklet->context = ctx; |
| 288 | ctx->wait_event.tasklet->process = mux_pt_io_cb; |
Willy Tarreau | 4f6516d | 2018-12-19 13:59:17 +0100 | [diff] [blame] | 289 | ctx->wait_event.events = 0; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 290 | ctx->conn = conn; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 291 | |
| 292 | if (!cs) { |
Christopher Faulet | 236c93b | 2020-07-02 09:19:54 +0200 | [diff] [blame] | 293 | cs = cs_new(conn, conn->target); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 294 | if (!cs) { |
| 295 | TRACE_ERROR("CS allocation failure", PT_EV_STRM_NEW|PT_EV_STRM_END|PT_EV_STRM_ERR, conn); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 296 | goto fail_free_ctx; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 297 | } |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 298 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 299 | if (stream_create_from_cs(cs, &BUF_NULL) < 0) { |
| 300 | TRACE_ERROR("stream creation failure", PT_EV_STRM_NEW|PT_EV_STRM_END|PT_EV_STRM_ERR, conn, cs); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 301 | goto fail_free; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 302 | } |
| 303 | TRACE_POINT(PT_EV_STRM_NEW, conn, cs); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 304 | } |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 305 | conn->ctx = ctx; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 306 | ctx->cs = cs; |
Olivier Houchard | 8706c81 | 2018-12-04 19:17:25 +0100 | [diff] [blame] | 307 | cs->flags |= CS_FL_RCV_MORE; |
Willy Tarreau | 17ccd1a | 2020-01-17 16:19:34 +0100 | [diff] [blame] | 308 | if (global.tune.options & GTUNE_USE_SPLICE) |
| 309 | cs->flags |= CS_FL_MAY_SPLICE; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 310 | |
| 311 | TRACE_LEAVE(PT_EV_CONN_NEW, conn, cs); |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 312 | return 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 313 | |
| 314 | fail_free: |
| 315 | cs_free(cs); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 316 | fail_free_ctx: |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 317 | if (ctx->wait_event.tasklet) |
| 318 | tasklet_free(ctx->wait_event.tasklet); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 319 | pool_free(pool_head_pt_ctx, ctx); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 320 | fail: |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 321 | TRACE_DEVEL("leaving in error", PT_EV_CONN_NEW|PT_EV_CONN_END|PT_EV_CONN_ERR); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 322 | return -1; |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 323 | } |
| 324 | |
| 325 | /* callback to be used by default for the pass-through mux. It calls the data |
| 326 | * layer wake() callback if it is set otherwise returns 0. |
| 327 | */ |
| 328 | static int mux_pt_wake(struct connection *conn) |
| 329 | { |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 330 | struct mux_pt_ctx *ctx = conn->ctx; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 331 | struct conn_stream *cs = ctx->cs; |
| 332 | int ret = 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 333 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 334 | TRACE_ENTER(PT_EV_CONN_WAKE, ctx->conn, cs); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 335 | if (cs) { |
| 336 | ret = cs->data_cb->wake ? cs->data_cb->wake(cs) : 0; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 337 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 338 | if (ret < 0) { |
| 339 | TRACE_DEVEL("leaving waking up CS", PT_EV_CONN_WAKE, ctx->conn, cs); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 340 | return ret; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 341 | } |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 342 | } else { |
Willy Tarreau | 2ded48d | 2020-12-11 16:20:34 +0100 | [diff] [blame] | 343 | conn_ctrl_drain(conn); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 344 | if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 345 | TRACE_DEVEL("leaving destroying PT context", PT_EV_CONN_WAKE, ctx->conn); |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 346 | mux_pt_destroy(ctx); |
| 347 | return -1; |
| 348 | } |
| 349 | } |
Willy Tarreau | ad7f0ad | 2018-08-24 15:48:59 +0200 | [diff] [blame] | 350 | |
Olivier Houchard | 7fc96d5 | 2017-11-23 18:25:47 +0100 | [diff] [blame] | 351 | /* If we had early data, and we're done with the handshake |
Ilya Shipitsin | 46a030c | 2020-07-05 16:36:08 +0500 | [diff] [blame] | 352 | * then we know the data are safe, and we can remove the flag. |
Olivier Houchard | 7fc96d5 | 2017-11-23 18:25:47 +0100 | [diff] [blame] | 353 | */ |
Willy Tarreau | 911db9b | 2020-01-23 16:27:54 +0100 | [diff] [blame] | 354 | if ((conn->flags & (CO_FL_EARLY_DATA | CO_FL_EARLY_SSL_HS | CO_FL_WAIT_XPRT)) == |
Olivier Houchard | 7fc96d5 | 2017-11-23 18:25:47 +0100 | [diff] [blame] | 355 | CO_FL_EARLY_DATA) |
| 356 | conn->flags &= ~CO_FL_EARLY_DATA; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 357 | |
| 358 | TRACE_LEAVE(PT_EV_CONN_WAKE, ctx->conn); |
Willy Tarreau | ed339a3 | 2017-11-03 15:55:24 +0100 | [diff] [blame] | 359 | return ret; |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 360 | } |
| 361 | |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 362 | /* |
| 363 | * Attach a new stream to a connection |
| 364 | * (Used for outgoing connections) |
| 365 | */ |
Olivier Houchard | f502aca | 2018-12-14 19:42:40 +0100 | [diff] [blame] | 366 | static struct conn_stream *mux_pt_attach(struct connection *conn, struct session *sess) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 367 | { |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 368 | struct conn_stream *cs; |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 369 | struct mux_pt_ctx *ctx = conn->ctx; |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 370 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 371 | TRACE_ENTER(PT_EV_STRM_NEW, conn); |
Olivier Houchard | ea32b0f | 2019-08-10 23:56:16 +0200 | [diff] [blame] | 372 | if (ctx->wait_event.events) |
| 373 | conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event); |
Christopher Faulet | 236c93b | 2020-07-02 09:19:54 +0200 | [diff] [blame] | 374 | cs = cs_new(conn, conn->target); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 375 | if (!cs) { |
| 376 | TRACE_ERROR("CS allocation failure", PT_EV_STRM_NEW|PT_EV_STRM_END|PT_EV_STRM_ERR, conn); |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 377 | goto fail; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 378 | } |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 379 | |
| 380 | ctx->cs = cs; |
Olivier Houchard | 8706c81 | 2018-12-04 19:17:25 +0100 | [diff] [blame] | 381 | cs->flags |= CS_FL_RCV_MORE; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 382 | |
| 383 | TRACE_LEAVE(PT_EV_STRM_NEW, conn, cs); |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 384 | return (cs); |
| 385 | fail: |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 386 | TRACE_DEVEL("leaving on error", PT_EV_STRM_NEW|PT_EV_STRM_END|PT_EV_STRM_ERR, conn); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 387 | return NULL; |
| 388 | } |
| 389 | |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 390 | /* Retrieves a valid conn_stream from this connection, or returns NULL. For |
| 391 | * this mux, it's easy as we can only store a single conn_stream. |
| 392 | */ |
| 393 | static const struct conn_stream *mux_pt_get_first_cs(const struct connection *conn) |
| 394 | { |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 395 | struct mux_pt_ctx *ctx = conn->ctx; |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 396 | struct conn_stream *cs = ctx->cs; |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 397 | |
| 398 | return cs; |
| 399 | } |
| 400 | |
Christopher Faulet | 73c1207 | 2019-04-08 11:23:22 +0200 | [diff] [blame] | 401 | /* Destroy the mux and the associated connection if still attached to this mux |
| 402 | * and no longer used */ |
| 403 | static void mux_pt_destroy_meth(void *ctx) |
Olivier Houchard | 060ed43 | 2018-11-06 16:32:42 +0100 | [diff] [blame] | 404 | { |
Christopher Faulet | 73c1207 | 2019-04-08 11:23:22 +0200 | [diff] [blame] | 405 | struct mux_pt_ctx *pt = ctx; |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 406 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 407 | TRACE_POINT(PT_EV_CONN_END, pt->conn, pt->cs); |
Christopher Faulet | 39a96ee | 2019-04-08 10:52:21 +0200 | [diff] [blame] | 408 | if (!(pt->cs) || !(pt->conn) || pt->conn->ctx != pt) |
Christopher Faulet | 73c1207 | 2019-04-08 11:23:22 +0200 | [diff] [blame] | 409 | mux_pt_destroy(pt); |
Olivier Houchard | 060ed43 | 2018-11-06 16:32:42 +0100 | [diff] [blame] | 410 | } |
| 411 | |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 412 | /* |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 413 | * Detach the stream from the connection and possibly release the connection. |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 414 | */ |
| 415 | static void mux_pt_detach(struct conn_stream *cs) |
| 416 | { |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 417 | struct connection *conn = cs->conn; |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 418 | struct mux_pt_ctx *ctx = cs->conn->ctx; |
Willy Tarreau | 2c52a2b | 2017-10-08 11:00:17 +0200 | [diff] [blame] | 419 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 420 | TRACE_ENTER(PT_EV_STRM_END, conn, cs); |
| 421 | |
Olivier Houchard | b6c32ee | 2018-11-05 18:28:43 +0100 | [diff] [blame] | 422 | /* Subscribe, to know if we got disconnected */ |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 423 | if (conn->owner != NULL && |
| 424 | !(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH))) { |
| 425 | ctx->cs = NULL; |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 426 | conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 427 | } else { |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 428 | /* There's no session attached to that connection, destroy it */ |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 429 | TRACE_DEVEL("killing dead connection", PT_EV_STRM_END, conn, cs); |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 430 | mux_pt_destroy(ctx); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 431 | } |
| 432 | |
| 433 | TRACE_LEAVE(PT_EV_STRM_END); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 434 | } |
| 435 | |
Willy Tarreau | 00f18a3 | 2019-01-26 12:19:01 +0100 | [diff] [blame] | 436 | /* returns the number of streams in use on a connection */ |
| 437 | static int mux_pt_used_streams(struct connection *conn) |
Olivier Houchard | d540b36 | 2018-11-05 18:37:53 +0100 | [diff] [blame] | 438 | { |
Willy Tarreau | 3d2ee55 | 2018-12-19 14:12:10 +0100 | [diff] [blame] | 439 | struct mux_pt_ctx *ctx = conn->ctx; |
Olivier Houchard | d540b36 | 2018-11-05 18:37:53 +0100 | [diff] [blame] | 440 | |
Willy Tarreau | 00f18a3 | 2019-01-26 12:19:01 +0100 | [diff] [blame] | 441 | return ctx->cs ? 1 : 0; |
Olivier Houchard | d540b36 | 2018-11-05 18:37:53 +0100 | [diff] [blame] | 442 | } |
| 443 | |
Willy Tarreau | 00f18a3 | 2019-01-26 12:19:01 +0100 | [diff] [blame] | 444 | /* returns the number of streams still available on a connection */ |
| 445 | static int mux_pt_avail_streams(struct connection *conn) |
Olivier Houchard | 8defe4b | 2018-12-02 01:31:17 +0100 | [diff] [blame] | 446 | { |
Willy Tarreau | 00f18a3 | 2019-01-26 12:19:01 +0100 | [diff] [blame] | 447 | return 1 - mux_pt_used_streams(conn); |
Olivier Houchard | 8defe4b | 2018-12-02 01:31:17 +0100 | [diff] [blame] | 448 | } |
| 449 | |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 450 | 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] | 451 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 452 | TRACE_ENTER(PT_EV_STRM_SHUT, cs->conn, cs); |
| 453 | |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 454 | if (cs->flags & CS_FL_SHR) |
| 455 | return; |
Christopher Faulet | d94f877 | 2018-12-17 13:21:02 +0100 | [diff] [blame] | 456 | cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 457 | if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutr) |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 458 | cs->conn->xprt->shutr(cs->conn, cs->conn->xprt_ctx, |
| 459 | (mode == CS_SHR_DRAIN)); |
Willy Tarreau | 7d7b11c | 2020-12-11 11:07:19 +0100 | [diff] [blame] | 460 | else if (mode == CS_SHR_DRAIN) |
Willy Tarreau | 2ded48d | 2020-12-11 16:20:34 +0100 | [diff] [blame] | 461 | conn_ctrl_drain(cs->conn); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 462 | if (cs->flags & CS_FL_SHW) |
| 463 | conn_full_close(cs->conn); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 464 | |
| 465 | TRACE_LEAVE(PT_EV_STRM_SHUT, cs->conn, cs); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 466 | } |
| 467 | |
Willy Tarreau | ecdb3fe | 2017-10-05 15:25:48 +0200 | [diff] [blame] | 468 | 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] | 469 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 470 | TRACE_ENTER(PT_EV_STRM_SHUT, cs->conn, cs); |
| 471 | |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 472 | if (cs->flags & CS_FL_SHW) |
| 473 | return; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 474 | if (conn_xprt_ready(cs->conn) && cs->conn->xprt->shutw) |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 475 | cs->conn->xprt->shutw(cs->conn, cs->conn->xprt_ctx, |
| 476 | (mode == CS_SHW_NORMAL)); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 477 | if (!(cs->flags & CS_FL_SHR)) |
Willy Tarreau | a48c141 | 2017-12-22 18:46:33 +0100 | [diff] [blame] | 478 | conn_sock_shutw(cs->conn, (mode == CS_SHW_NORMAL)); |
Willy Tarreau | 4b79524 | 2017-10-05 18:47:38 +0200 | [diff] [blame] | 479 | else |
| 480 | conn_full_close(cs->conn); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 481 | |
| 482 | TRACE_LEAVE(PT_EV_STRM_SHUT, cs->conn, cs); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 483 | } |
| 484 | |
| 485 | /* |
| 486 | * Called from the upper layer, to get more data |
Christopher Faulet | 564e39c | 2021-09-21 15:50:55 +0200 | [diff] [blame] | 487 | * |
| 488 | * The caller is responsible for defragmenting <buf> if necessary. But <flags> |
| 489 | * must be tested to know the calling context. If CO_RFL_BUF_FLUSH is set, it |
| 490 | * means the caller wants to flush input data (from the mux buffer and the |
| 491 | * channel buffer) to be able to use kernel splicing or any kind of mux-to-mux |
| 492 | * xfer. If CO_RFL_KEEP_RECV is set, the mux must always subscribe for read |
| 493 | * events before giving back. CO_RFL_BUF_WET is set if <buf> is congested with |
| 494 | * data scheduled for leaving soon. CO_RFL_BUF_NOT_STUCK is set to instruct the |
| 495 | * mux it may optimize the data copy to <buf> if necessary. Otherwise, it should |
| 496 | * copy as much data as possible. |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 497 | */ |
Willy Tarreau | 7f3225f | 2018-06-19 06:15:17 +0200 | [diff] [blame] | 498 | 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] | 499 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 500 | size_t ret = 0; |
| 501 | |
| 502 | TRACE_ENTER(PT_EV_RX_DATA, cs->conn, cs, buf, (size_t[]){count}); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 503 | |
Christopher Faulet | 4eb7d74 | 2018-10-11 15:29:21 +0200 | [diff] [blame] | 504 | if (!count) { |
Christopher Faulet | d94f877 | 2018-12-17 13:21:02 +0100 | [diff] [blame] | 505 | cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 506 | goto end; |
Christopher Faulet | 4eb7d74 | 2018-10-11 15:29:21 +0200 | [diff] [blame] | 507 | } |
Willy Tarreau | e0f24ee | 2018-12-14 10:51:23 +0100 | [diff] [blame] | 508 | b_realign_if_empty(buf); |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 509 | ret = cs->conn->xprt->rcv_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags); |
Olivier Houchard | 8706c81 | 2018-12-04 19:17:25 +0100 | [diff] [blame] | 510 | if (conn_xprt_read0_pending(cs->conn)) { |
Willy Tarreau | 9cca8df | 2019-07-15 06:47:54 +0200 | [diff] [blame] | 511 | cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM); |
Christopher Faulet | 87a8f35 | 2019-03-22 14:51:36 +0100 | [diff] [blame] | 512 | cs->flags |= CS_FL_EOS; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 513 | TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, cs->conn, cs); |
Olivier Houchard | 8706c81 | 2018-12-04 19:17:25 +0100 | [diff] [blame] | 514 | } |
| 515 | if (cs->conn->flags & CO_FL_ERROR) { |
Willy Tarreau | 9cca8df | 2019-07-15 06:47:54 +0200 | [diff] [blame] | 516 | cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM); |
Willy Tarreau | 4ff3b89 | 2017-10-16 15:17:17 +0200 | [diff] [blame] | 517 | cs->flags |= CS_FL_ERROR; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 518 | TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, cs->conn, cs); |
Olivier Houchard | 8706c81 | 2018-12-04 19:17:25 +0100 | [diff] [blame] | 519 | } |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 520 | end: |
| 521 | TRACE_LEAVE(PT_EV_RX_DATA, cs->conn, cs, buf, (size_t[]){ret}); |
Willy Tarreau | d9cf540 | 2018-07-18 11:29:06 +0200 | [diff] [blame] | 522 | return ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 523 | } |
| 524 | |
| 525 | /* Called from the upper layer, to send data */ |
Christopher Faulet | d44a9b3 | 2018-07-27 11:59:41 +0200 | [diff] [blame] | 526 | 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] | 527 | { |
Olivier Houchard | b72d98a | 2018-11-30 13:17:48 +0100 | [diff] [blame] | 528 | size_t ret; |
| 529 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 530 | TRACE_ENTER(PT_EV_TX_DATA, cs->conn, cs, buf, (size_t[]){count}); |
| 531 | |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 532 | ret = cs->conn->xprt->snd_buf(cs->conn, cs->conn->xprt_ctx, buf, count, flags); |
Christopher Faulet | d44a9b3 | 2018-07-27 11:59:41 +0200 | [diff] [blame] | 533 | |
| 534 | if (ret > 0) |
| 535 | b_del(buf, ret); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 536 | |
| 537 | TRACE_LEAVE(PT_EV_TX_DATA, cs->conn, cs, buf, (size_t[]){ret}); |
Christopher Faulet | d44a9b3 | 2018-07-27 11:59:41 +0200 | [diff] [blame] | 538 | return ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 539 | } |
| 540 | |
Willy Tarreau | ee1a6fc | 2020-01-17 07:52:13 +0100 | [diff] [blame] | 541 | /* Called from the upper layer, to subscribe <es> to events <event_type>. The |
| 542 | * event subscriber <es> is not allowed to change from a previous call as long |
| 543 | * as at least one event is still subscribed. The <event_type> must only be a |
| 544 | * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0. |
| 545 | */ |
| 546 | static int mux_pt_subscribe(struct conn_stream *cs, int event_type, struct wait_event *es) |
Olivier Houchard | 6ff2039 | 2018-07-17 18:46:31 +0200 | [diff] [blame] | 547 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 548 | TRACE_POINT(PT_EV_RX_DATA|PT_EV_TX_DATA, cs->conn, cs, 0, (size_t[]){event_type}); |
Willy Tarreau | ee1a6fc | 2020-01-17 07:52:13 +0100 | [diff] [blame] | 549 | return cs->conn->xprt->subscribe(cs->conn, cs->conn->xprt_ctx, event_type, es); |
Olivier Houchard | 6ff2039 | 2018-07-17 18:46:31 +0200 | [diff] [blame] | 550 | } |
| 551 | |
Willy Tarreau | ee1a6fc | 2020-01-17 07:52:13 +0100 | [diff] [blame] | 552 | /* Called from the upper layer, to unsubscribe <es> from events <event_type>. |
| 553 | * The <es> pointer is not allowed to differ from the one passed to the |
| 554 | * subscribe() call. It always returns zero. |
| 555 | */ |
| 556 | static int mux_pt_unsubscribe(struct conn_stream *cs, int event_type, struct wait_event *es) |
Olivier Houchard | 83a0cd8 | 2018-09-28 17:57:58 +0200 | [diff] [blame] | 557 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 558 | TRACE_POINT(PT_EV_RX_DATA|PT_EV_TX_DATA, cs->conn, cs, 0, (size_t[]){event_type}); |
Willy Tarreau | ee1a6fc | 2020-01-17 07:52:13 +0100 | [diff] [blame] | 559 | return cs->conn->xprt->unsubscribe(cs->conn, cs->conn->xprt_ctx, event_type, es); |
Olivier Houchard | 83a0cd8 | 2018-09-28 17:57:58 +0200 | [diff] [blame] | 560 | } |
| 561 | |
Willy Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 562 | #if defined(USE_LINUX_SPLICE) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 563 | /* Send and get, using splicing */ |
| 564 | static int mux_pt_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int count) |
| 565 | { |
| 566 | int ret; |
| 567 | |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 568 | TRACE_ENTER(PT_EV_RX_DATA, cs->conn, cs, 0, (size_t[]){count}); |
| 569 | |
Olivier Houchard | e179d0e | 2019-03-21 18:27:17 +0100 | [diff] [blame] | 570 | ret = cs->conn->xprt->rcv_pipe(cs->conn, cs->conn->xprt_ctx, pipe, count); |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 571 | if (conn_xprt_read0_pending(cs->conn)) { |
Christopher Faulet | 87a8f35 | 2019-03-22 14:51:36 +0100 | [diff] [blame] | 572 | cs->flags |= CS_FL_EOS; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 573 | TRACE_DEVEL("read0 on connection", PT_EV_RX_DATA, cs->conn, cs); |
| 574 | } |
| 575 | if (cs->conn->flags & CO_FL_ERROR) { |
Willy Tarreau | 4ff3b89 | 2017-10-16 15:17:17 +0200 | [diff] [blame] | 576 | cs->flags |= CS_FL_ERROR; |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 577 | TRACE_DEVEL("error on connection", PT_EV_RX_DATA|PT_EV_CONN_ERR, cs->conn, cs); |
| 578 | } |
| 579 | |
| 580 | TRACE_LEAVE(PT_EV_RX_DATA, cs->conn, cs, 0, (size_t[]){ret}); |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 581 | return (ret); |
| 582 | } |
| 583 | |
| 584 | static int mux_pt_snd_pipe(struct conn_stream *cs, struct pipe *pipe) |
| 585 | { |
Christopher Faulet | c0ae097 | 2021-04-08 16:45:11 +0200 | [diff] [blame] | 586 | int ret; |
| 587 | |
| 588 | TRACE_ENTER(PT_EV_TX_DATA, cs->conn, cs, 0, (size_t[]){pipe->data}); |
| 589 | |
| 590 | ret = cs->conn->xprt->snd_pipe(cs->conn, cs->conn->xprt_ctx, pipe); |
| 591 | |
| 592 | TRACE_LEAVE(PT_EV_TX_DATA, cs->conn, cs, 0, (size_t[]){ret}); |
| 593 | return ret; |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 594 | } |
Olivier Houchard | 7da120b | 2017-11-01 13:55:10 +0100 | [diff] [blame] | 595 | #endif |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 596 | |
Olivier Houchard | 9b8e11e | 2019-10-25 16:19:26 +0200 | [diff] [blame] | 597 | static int mux_pt_ctl(struct connection *conn, enum mux_ctl_type mux_ctl, void *output) |
| 598 | { |
| 599 | int ret = 0; |
| 600 | switch (mux_ctl) { |
| 601 | case MUX_STATUS: |
Willy Tarreau | 911db9b | 2020-01-23 16:27:54 +0100 | [diff] [blame] | 602 | if (!(conn->flags & CO_FL_WAIT_XPRT)) |
Olivier Houchard | 9b8e11e | 2019-10-25 16:19:26 +0200 | [diff] [blame] | 603 | ret |= MUX_STATUS_READY; |
| 604 | return ret; |
Christopher Faulet | 4c8ad84 | 2020-10-06 14:59:17 +0200 | [diff] [blame] | 605 | case MUX_EXIT_STATUS: |
| 606 | return MUX_ES_UNKNOWN; |
Olivier Houchard | 9b8e11e | 2019-10-25 16:19:26 +0200 | [diff] [blame] | 607 | default: |
| 608 | return -1; |
| 609 | } |
| 610 | } |
| 611 | |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 612 | /* The mux operations */ |
Christopher Faulet | 28da3f5 | 2021-02-05 16:44:46 +0100 | [diff] [blame] | 613 | const struct mux_ops mux_tcp_ops = { |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 614 | .init = mux_pt_init, |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 615 | .wake = mux_pt_wake, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 616 | .rcv_buf = mux_pt_rcv_buf, |
| 617 | .snd_buf = mux_pt_snd_buf, |
Olivier Houchard | 6ff2039 | 2018-07-17 18:46:31 +0200 | [diff] [blame] | 618 | .subscribe = mux_pt_subscribe, |
Olivier Houchard | 83a0cd8 | 2018-09-28 17:57:58 +0200 | [diff] [blame] | 619 | .unsubscribe = mux_pt_unsubscribe, |
Willy Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 620 | #if defined(USE_LINUX_SPLICE) |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 621 | .rcv_pipe = mux_pt_rcv_pipe, |
| 622 | .snd_pipe = mux_pt_snd_pipe, |
| 623 | #endif |
| 624 | .attach = mux_pt_attach, |
Willy Tarreau | fafd398 | 2018-11-18 21:29:20 +0100 | [diff] [blame] | 625 | .get_first_cs = mux_pt_get_first_cs, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 626 | .detach = mux_pt_detach, |
Olivier Houchard | d540b36 | 2018-11-05 18:37:53 +0100 | [diff] [blame] | 627 | .avail_streams = mux_pt_avail_streams, |
Willy Tarreau | 00f18a3 | 2019-01-26 12:19:01 +0100 | [diff] [blame] | 628 | .used_streams = mux_pt_used_streams, |
Olivier Houchard | 060ed43 | 2018-11-06 16:32:42 +0100 | [diff] [blame] | 629 | .destroy = mux_pt_destroy_meth, |
Olivier Houchard | 9b8e11e | 2019-10-25 16:19:26 +0200 | [diff] [blame] | 630 | .ctl = mux_pt_ctl, |
Olivier Houchard | 7a3f0df | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 631 | .shutr = mux_pt_shutr, |
| 632 | .shutw = mux_pt_shutw, |
Willy Tarreau | 28f1cb9 | 2017-12-20 16:14:44 +0100 | [diff] [blame] | 633 | .flags = MX_FL_NONE, |
Willy Tarreau | 53a4766 | 2017-08-28 10:53:00 +0200 | [diff] [blame] | 634 | .name = "PASS", |
| 635 | }; |
Willy Tarreau | f649082 | 2017-09-21 19:43:21 +0200 | [diff] [blame] | 636 | |
Christopher Faulet | 28da3f5 | 2021-02-05 16:44:46 +0100 | [diff] [blame] | 637 | |
| 638 | const struct mux_ops mux_pt_ops = { |
| 639 | .init = mux_pt_init, |
| 640 | .wake = mux_pt_wake, |
| 641 | .rcv_buf = mux_pt_rcv_buf, |
| 642 | .snd_buf = mux_pt_snd_buf, |
| 643 | .subscribe = mux_pt_subscribe, |
| 644 | .unsubscribe = mux_pt_unsubscribe, |
| 645 | #if defined(USE_LINUX_SPLICE) |
| 646 | .rcv_pipe = mux_pt_rcv_pipe, |
| 647 | .snd_pipe = mux_pt_snd_pipe, |
| 648 | #endif |
| 649 | .attach = mux_pt_attach, |
| 650 | .get_first_cs = mux_pt_get_first_cs, |
| 651 | .detach = mux_pt_detach, |
| 652 | .avail_streams = mux_pt_avail_streams, |
| 653 | .used_streams = mux_pt_used_streams, |
| 654 | .destroy = mux_pt_destroy_meth, |
| 655 | .ctl = mux_pt_ctl, |
| 656 | .shutr = mux_pt_shutr, |
| 657 | .shutw = mux_pt_shutw, |
| 658 | .flags = MX_FL_NONE|MX_FL_NO_UPG, |
| 659 | .name = "PASS", |
| 660 | }; |
| 661 | |
Christopher Faulet | 32f61c0 | 2018-04-10 14:33:41 +0200 | [diff] [blame] | 662 | /* PROT selection : default mux has empty name */ |
Christopher Faulet | 28da3f5 | 2021-02-05 16:44:46 +0100 | [diff] [blame] | 663 | static struct mux_proto_list mux_proto_none = |
| 664 | { .token = IST("none"), .mode = PROTO_MODE_TCP, .side = PROTO_SIDE_BOTH, .mux = &mux_pt_ops }; |
| 665 | static struct mux_proto_list mux_proto_tcp = |
| 666 | { .token = IST(""), .mode = PROTO_MODE_TCP, .side = PROTO_SIDE_BOTH, .mux = &mux_tcp_ops }; |
Willy Tarreau | f649082 | 2017-09-21 19:43:21 +0200 | [diff] [blame] | 667 | |
Christopher Faulet | 28da3f5 | 2021-02-05 16:44:46 +0100 | [diff] [blame] | 668 | INITCALL1(STG_REGISTER, register_mux_proto, &mux_proto_none); |
| 669 | INITCALL1(STG_REGISTER, register_mux_proto, &mux_proto_tcp); |