blob: 3d03f1cfb8bdf671d022bc9357eeacadca4db840 [file] [log] [blame]
Olivier Houchardfe50bfb2019-05-27 12:09:19 +02001/*
2 * Pseudo-xprt to handle any handshake except the SSL handshake
3 *
4 * Copyright 2019 HAProxy Technologies, Olivier Houchard <ohouchard@haproxy.com>
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 Tarreau7ea393d2020-06-04 18:02:10 +020013#include <haproxy/connection.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020014#include <haproxy/stream_interface.h>
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020015
16struct xprt_handshake_ctx {
17 struct connection *conn;
Willy Tarreauac6febd2020-01-10 09:08:22 +010018 struct wait_event *subs;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020019 struct wait_event wait_event;
20 const struct xprt_ops *xprt;
21 void *xprt_ctx;
22};
23
24DECLARE_STATIC_POOL(xprt_handshake_ctx_pool, "xprt_handshake_ctx_pool", sizeof(struct xprt_handshake_ctx));
25
26/* This XPRT doesn't take care of sending or receiving data, once its handshake
27 * is done, it just removes itself
28 */
29static size_t xprt_handshake_from_buf(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags)
30{
31 return 0;
32}
33
34static size_t xprt_handshake_to_buf(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags)
35{
36 return 0;
37}
38
Willy Tarreau691d5032021-01-20 14:55:01 +010039/* xprt_handshake_io_cb is exported to see it resolved in "show fd" */
Willy Tarreau144f84a2021-03-02 16:09:26 +010040struct task *xprt_handshake_io_cb(struct task *t, void *bctx, unsigned int state)
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020041{
42 struct xprt_handshake_ctx *ctx = bctx;
43 struct connection *conn = ctx->conn;
44
45 if (conn->flags & CO_FL_SOCKS4_SEND)
46 if (!conn_send_socks4_proxy_request(conn)) {
47 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND,
48 &ctx->wait_event);
49
50 goto out;
51 }
52
53 if (conn->flags & CO_FL_SOCKS4_RECV)
54 if (!conn_recv_socks4_proxy_response(conn)) {
55 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV,
56 &ctx->wait_event);
57 goto out;
58 }
59
60 if (conn->flags & CO_FL_ACCEPT_CIP)
61 if (!conn_recv_netscaler_cip(conn, CO_FL_ACCEPT_CIP)) {
62 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV,
63 &ctx->wait_event);
64 goto out;
65 }
66
67 if (conn->flags & CO_FL_ACCEPT_PROXY)
68 if (!conn_recv_proxy(conn, CO_FL_ACCEPT_PROXY)) {
69 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV,
70 &ctx->wait_event);
71 goto out;
72 }
73
74 if (conn->flags & CO_FL_SEND_PROXY)
75 if (!conn_si_send_proxy(conn, CO_FL_SEND_PROXY)) {
76 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND,
77 &ctx->wait_event);
78 goto out;
79 }
80
81out:
82 /* Wake the stream if we're done with the handshake, or we have a
83 * connection error
84 * */
85 if ((conn->flags & CO_FL_ERROR) ||
Willy Tarreau4450b582020-01-23 15:23:13 +010086 !(conn->flags & CO_FL_HANDSHAKE)) {
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020087 int ret = 0;
88 int woke = 0;
89 int was_conn_ctx = 0;
Willy Tarreauac6febd2020-01-10 09:08:22 +010090
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020091 /* On error, wake any waiter */
Willy Tarreauac6febd2020-01-10 09:08:22 +010092 if (ctx->subs) {
93 tasklet_wakeup(ctx->subs->tasklet);
94 ctx->subs->events = 0;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020095 woke = 1;
Willy Tarreauac6febd2020-01-10 09:08:22 +010096 ctx->subs = NULL;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020097 }
Willy Tarreauac6febd2020-01-10 09:08:22 +010098
Olivier Houchardfe50bfb2019-05-27 12:09:19 +020099 /* Remove ourself from the xprt chain */
100 if (ctx->wait_event.events != 0)
101 ctx->xprt->unsubscribe(ctx->conn,
102 ctx->xprt_ctx,
103 ctx->wait_event.events,
104 &ctx->wait_event);
105 if (conn->xprt_ctx == ctx) {
106 conn->xprt_ctx = ctx->xprt_ctx;
107 conn->xprt = ctx->xprt;
108 was_conn_ctx = 1;
109 } else
110 conn->xprt->remove_xprt(conn, conn->xprt_ctx, ctx,
111 ctx->xprt, ctx->xprt_ctx);
112 /* If we're the first xprt for the connection, let the
Olivier Houchard477902b2020-01-22 18:08:48 +0100113 * upper layers know. If no mux was set up yet, then call
114 * conn_create_mux, and if we have a mux, and it has a wake
115 * method, call it too.
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200116 */
117 if (was_conn_ctx) {
Olivier Houchard477902b2020-01-22 18:08:48 +0100118 if (!ctx->conn->mux)
119 ret = conn_create_mux(ctx->conn);
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200120 if (ret >= 0 && !woke && ctx->conn->mux && ctx->conn->mux->wake)
121 ret = ctx->conn->mux->wake(ctx->conn);
122 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200123 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200124 pool_free(xprt_handshake_ctx_pool, ctx);
125 }
126 return NULL;
127}
128
129static int xprt_handshake_init(struct connection *conn, void **xprt_ctx)
130{
131 struct xprt_handshake_ctx *ctx;
132 /* already initialized */
133 if (*xprt_ctx)
134 return 0;
135 if (!conn_ctrl_ready(conn))
136 return 0;
137
138 ctx = pool_alloc(xprt_handshake_ctx_pool);
139 if (!ctx) {
140 conn->err_code = CO_ER_SSL_NO_MEM;
141 return -1;
142 }
143 ctx->conn = conn;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200144 ctx->wait_event.tasklet = tasklet_new();
145 if (!ctx->wait_event.tasklet) {
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200146 conn->err_code = CO_ER_SSL_NO_MEM;
147 pool_free(xprt_handshake_ctx_pool, ctx);
148 return -1;
149 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200150 ctx->wait_event.tasklet->process = xprt_handshake_io_cb;
151 ctx->wait_event.tasklet->context = ctx;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200152 ctx->wait_event.events = 0;
153 /* This XPRT expects the underlying XPRT to be provided later,
154 * with an add_xprt() call, so we start trying to do the handshake
155 * there, when we'll be provided an XPRT.
156 */
157 ctx->xprt = NULL;
158 ctx->xprt_ctx = NULL;
Willy Tarreauac6febd2020-01-10 09:08:22 +0100159 ctx->subs = NULL;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200160 *xprt_ctx = ctx;
161
162 return 0;
163}
164
165static void xprt_handshake_close(struct connection *conn, void *xprt_ctx)
166{
167 struct xprt_handshake_ctx *ctx = xprt_ctx;
168
169 if (ctx) {
170 if (ctx->wait_event.events != 0)
171 ctx->xprt->unsubscribe(ctx->conn, ctx->xprt_ctx,
172 ctx->wait_event.events,
173 &ctx->wait_event);
Willy Tarreauac6febd2020-01-10 09:08:22 +0100174 if (ctx->subs) {
175 ctx->subs->events = 0;
176 tasklet_wakeup(ctx->subs->tasklet);
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200177 }
178
179 if (ctx->xprt && ctx->xprt->close)
180 ctx->xprt->close(conn, ctx->xprt_ctx);
181 /* Remove any handshake flag, and if we were the connection
182 * xprt, get back to XPRT_RAW. If we're here because we
183 * failed an outoging connection, it will be retried using
184 * the same struct connection, and as xprt_handshake is a bit
185 * magic, because it requires a call to add_xprt(), it's better
186 * to fallback to the original XPRT to re-initiate the
187 * connection.
188 */
Willy Tarreau4450b582020-01-23 15:23:13 +0100189 conn->flags &= ~CO_FL_HANDSHAKE;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200190 if (conn->xprt == xprt_get(XPRT_HANDSHAKE))
191 conn->xprt = xprt_get(XPRT_RAW);
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200192 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200193 pool_free(xprt_handshake_ctx_pool, ctx);
194 }
195}
196
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100197/* Called from the upper layer, to subscribe <es> to events <event_type>. The
198 * event subscriber <es> is not allowed to change from a previous call as long
199 * as at least one event is still subscribed. The <event_type> must only be a
200 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0.
201 */
202static int xprt_handshake_subscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200203{
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200204 struct xprt_handshake_ctx *ctx = xprt_ctx;
205
Willy Tarreauac6febd2020-01-10 09:08:22 +0100206 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100207 BUG_ON(ctx->subs && ctx->subs != es);
Willy Tarreauac6febd2020-01-10 09:08:22 +0100208
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100209 ctx->subs = es;
210 es->events |= event_type;
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200211 return 0;
212
213}
214
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100215/* Called from the upper layer, to unsubscribe <es> from events <event_type>.
216 * The <es> pointer is not allowed to differ from the one passed to the
217 * subscribe() call. It always returns zero.
218 */
219static int xprt_handshake_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200220{
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200221 struct xprt_handshake_ctx *ctx = xprt_ctx;
222
Willy Tarreauac6febd2020-01-10 09:08:22 +0100223 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100224 BUG_ON(ctx->subs && ctx->subs != es);
Willy Tarreauac6febd2020-01-10 09:08:22 +0100225
Willy Tarreauee1a6fc2020-01-17 07:52:13 +0100226 es->events &= ~event_type;
227 if (!es->events)
Willy Tarreauac6febd2020-01-10 09:08:22 +0100228 ctx->subs = NULL;
229
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200230 return 0;
231}
232
233/* Use the provided XPRT as an underlying XPRT, and provide the old one.
234 * Returns 0 on success, and non-zero on failure.
235 */
236static int xprt_handshake_add_xprt(struct connection *conn, void *xprt_ctx, void *toadd_ctx, const struct xprt_ops *toadd_ops, void **oldxprt_ctx, const struct xprt_ops **oldxprt_ops)
237{
238 struct xprt_handshake_ctx *ctx = xprt_ctx;
239
240 if (oldxprt_ops)
241 *oldxprt_ops = ctx->xprt;
242 if (oldxprt_ctx)
243 *oldxprt_ctx = ctx->xprt_ctx;
244 ctx->xprt = toadd_ops;
245 ctx->xprt_ctx = toadd_ctx;
246 /* Ok we know have an xprt, so let's try to do the handshake */
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200247 tasklet_wakeup(ctx->wait_event.tasklet);
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200248 return 0;
249}
250
251/* Remove the specified xprt. If if it our underlying XPRT, remove it and
252 * return 0, otherwise just call the remove_xprt method from the underlying
253 * XPRT.
254 */
255static int xprt_handshake_remove_xprt(struct connection *conn, void *xprt_ctx, void *toremove_ctx, const struct xprt_ops *newops, void *newctx)
256{
257 struct xprt_handshake_ctx *ctx = xprt_ctx;
258
259 if (ctx->xprt_ctx == toremove_ctx) {
260 ctx->xprt_ctx = newctx;
261 ctx->xprt = newops;
262 return 0;
263 }
264 return (ctx->xprt->remove_xprt(conn, ctx->xprt_ctx, toremove_ctx, newops, newctx));
265}
266
267struct xprt_ops xprt_handshake = {
268 .snd_buf = xprt_handshake_from_buf,
269 .rcv_buf = xprt_handshake_to_buf,
270 .subscribe = xprt_handshake_subscribe,
271 .unsubscribe = xprt_handshake_unsubscribe,
272 .remove_xprt = xprt_handshake_remove_xprt,
273 .add_xprt = xprt_handshake_add_xprt,
274 .init = xprt_handshake_init,
275 .close= xprt_handshake_close,
276 .rcv_pipe = NULL,
277 .snd_pipe = NULL,
278 .shutr = NULL,
279 .shutw = NULL,
280 .name = "HS",
281};
282
283__attribute__((constructor))
284static void __xprt_handshake_init(void)
285{
286 xprt_register(XPRT_HANDSHAKE, &xprt_handshake);
287}