blob: 9b4ac51d335a4f48e1ecb231fb3e34efeec58cf5 [file] [log] [blame]
Willy Tarreau59f98392012-07-06 14:13:49 +02001/*
2 * include/proto/connection.h
3 * This file contains connection function prototypes
4 *
5 * Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation, version 2.1
10 * exclusively.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#ifndef _PROTO_CONNECTION_H
23#define _PROTO_CONNECTION_H
24
25#include <common/config.h>
Willy Tarreau2386be62017-09-21 19:40:52 +020026#include <common/ist.h>
Willy Tarreauf2943dc2012-10-26 20:10:28 +020027#include <common/memory.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020028#include <types/connection.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020029#include <types/listener.h>
Willy Tarreau2b199c92012-11-23 17:32:21 +010030#include <proto/fd.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010031#include <proto/obj_type.h>
Olivier Houchard351411f2018-12-27 17:20:54 +010032#include <proto/session.h>
Olivier Houchard6ff20392018-07-17 18:46:31 +020033#include <proto/task.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020034
Willy Tarreaubafbe012017-11-24 17:34:44 +010035extern struct pool_head *pool_head_connection;
36extern struct pool_head *pool_head_connstream;
Willy Tarreau13e14102016-12-22 20:25:26 +010037extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
Christopher Faulet32f61c02018-04-10 14:33:41 +020038extern struct mux_proto_list mux_proto_list;
Willy Tarreauf2943dc2012-10-26 20:10:28 +020039
Willy Tarreau59f98392012-07-06 14:13:49 +020040/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020041 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020042 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020043void conn_fd_handler(int fd);
Willy Tarreau59f98392012-07-06 14:13:49 +020044
Willy Tarreau22cda212012-08-31 17:43:29 +020045/* receive a PROXY protocol header over a connection */
46int conn_recv_proxy(struct connection *conn, int flag);
David Safb76832014-05-08 23:42:08 -040047int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote);
48int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
49int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
Willy Tarreau22cda212012-08-31 17:43:29 +020050
Olivier Houcharde179d0e2019-03-21 18:27:17 +010051int conn_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param);
52int conn_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param);
Olivier Houchard83a0cd82018-09-28 17:57:58 +020053
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010054/* receive a NetScaler Client IP insertion header over a connection */
55int conn_recv_netscaler_cip(struct connection *conn, int flag);
56
Willy Tarreauff3e6482015-03-12 23:56:52 +010057/* raw send() directly on the socket */
58int conn_sock_send(struct connection *conn, const void *buf, int len, int flags);
59
Willy Tarreaud85c4852015-03-13 00:40:28 +010060/* drains any pending bytes from the socket */
61int conn_sock_drain(struct connection *conn);
62
Alexander Liu2a54bb72019-05-22 19:44:48 +080063/* scoks4 proxy handshake */
64int conn_send_socks4_proxy_request(struct connection *conn);
65int conn_recv_socks4_proxy_response(struct connection *conn);
66
Olivier Houchard4be71902019-07-11 15:49:00 +020067__decl_hathreads(extern HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
68
Willy Tarreaud02cdd22013-12-15 10:23:20 +010069/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010070static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010071{
Willy Tarreauaad69382014-01-23 14:21:42 +010072 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010073}
74
75/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010076static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010077{
78 return (conn->flags & CO_FL_CTRL_READY);
79}
80
Willy Tarreauf79c8172013-10-21 16:30:56 +020081/* Calls the init() function of the transport layer if any and if not done yet,
82 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020083 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020084 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020085static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020086{
Willy Tarreauf79c8172013-10-21 16:30:56 +020087 int ret = 0;
88
Willy Tarreauaad69382014-01-23 14:21:42 +010089 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Olivier Houcharde179d0e2019-03-21 18:27:17 +010090 ret = conn->xprt->init(conn, &conn->xprt_ctx);
Willy Tarreauf79c8172013-10-21 16:30:56 +020091
92 if (ret >= 0)
93 conn->flags |= CO_FL_XPRT_READY;
94
95 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020096}
97
Willy Tarreauf79c8172013-10-21 16:30:56 +020098/* Calls the close() function of the transport layer if any and if not done
99 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
100 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
101 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +0200102 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200103static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +0200104{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200105 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +0100106 if (conn->xprt->close)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100107 conn->xprt->close(conn, conn->xprt_ctx);
Olivier Houchard478281f2019-05-13 19:10:46 +0200108 conn->xprt_ctx = NULL;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200109 conn->flags &= ~CO_FL_XPRT_READY;
110 }
111}
112
113/* Initializes the connection's control layer which essentially consists in
114 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +0100115 * flag. The caller is responsible for ensuring that the control layer is
116 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200117 */
118static inline void conn_ctrl_init(struct connection *conn)
119{
Willy Tarreau3c728722014-01-23 13:50:42 +0100120 if (!conn_ctrl_ready(conn)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200121 int fd = conn->handle.fd;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200122
Willy Tarreaua9786b62018-01-25 07:22:13 +0100123 fd_insert(fd, conn, conn_fd_handler, tid_bit);
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100124 /* mark the fd as ready so as not to needlessly poll at the beginning */
125 fd_may_recv(fd);
126 fd_may_send(fd);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200127 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200128 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200129}
130
Willy Tarreauf79c8172013-10-21 16:30:56 +0200131/* Deletes the FD if the transport layer is already gone. Once done,
132 * it then removes the CO_FL_CTRL_READY flag.
133 */
134static inline void conn_ctrl_close(struct connection *conn)
135{
136 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200137 fd_delete(conn->handle.fd);
Willy Tarreau6a0a80a2017-10-05 17:43:39 +0200138 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200139 conn->flags &= ~CO_FL_CTRL_READY;
140 }
141}
142
Willy Tarreau2b199c92012-11-23 17:32:21 +0100143/* If the connection still has a transport layer, then call its close() function
144 * if any, and delete the file descriptor if a control layer is set. This is
145 * used to close everything at once and atomically. However this is not done if
146 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
147 * transport layer very late if needed.
148 */
149static inline void conn_full_close(struct connection *conn)
150{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200151 conn_xprt_close(conn);
152 conn_ctrl_close(conn);
153}
154
Willy Tarreaudc42acd2017-10-05 18:09:20 +0200155/* stop tracking a connection, allowing conn_full_close() to always
156 * succeed.
157 */
158static inline void conn_stop_tracking(struct connection *conn)
159{
160 conn->flags &= ~CO_FL_XPRT_TRACKED;
161}
162
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200163/* Update polling on connection <c>'s file descriptor depending on its current
164 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200165 * in CO_FL_WAIT_*, and the upper layer expectations indicated by CO_FL_XPRT_*.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200166 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200167 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200168 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200169void conn_update_xprt_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200170
Willy Tarreau7d281492012-12-16 19:19:13 +0100171/* Refresh the connection's polling flags from its file descriptor status.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200172 * This should be called at the beginning of a connection handler. It does
173 * nothing if CO_FL_WILL_UPDATE is present, indicating that an upper caller
174 * has already done it.
Willy Tarreau7d281492012-12-16 19:19:13 +0100175 */
176static inline void conn_refresh_polling_flags(struct connection *conn)
177{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200178 if (conn_ctrl_ready(conn) && !(conn->flags & CO_FL_WILL_UPDATE)) {
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200179 unsigned int flags = conn->flags;
Willy Tarreau7d281492012-12-16 19:19:13 +0100180
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200181 flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA | CO_FL_WAIT_ROOM);
Willy Tarreau585744b2017-08-24 14:31:19 +0200182 if (fd_recv_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100183 flags |= CO_FL_CURR_RD_ENA;
Willy Tarreau585744b2017-08-24 14:31:19 +0200184 if (fd_send_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100185 flags |= CO_FL_CURR_WR_ENA;
186 conn->flags = flags;
187 }
188}
189
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200190/* inspects c->flags and returns non-zero if XPRT ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100191 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200192 * non-zero is also returned if an error was reported on the connection. This
193 * function is used quite often and is inlined. In order to proceed optimally
194 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100195 * can be detected by a few left shifts, a xor, and a mask. These operations
196 * detect when W&D are both enabled for either direction, when C&D differ for
197 * either direction and when Error is set. The trick consists in first keeping
198 * only the bits we're interested in, since they don't collide when shifted,
199 * and to perform the AND at the end. In practice, the compiler is able to
200 * replace the last AND with a TEST in boolean conditions. This results in
201 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200202 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200203static inline unsigned int conn_xprt_polling_changes(const struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200204{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100205 unsigned int f = c->flags;
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200206 f &= CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100207 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100208
Willy Tarreau310987a2014-01-22 19:46:33 +0100209 f = (f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ D */
210 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200211}
212
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200213/* Automatically updates polling on connection <c> depending on the XPRT flags.
214 * It does nothing if CO_FL_WILL_UPDATE is present, indicating that an upper
215 * caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200216 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200217static inline void conn_cond_update_xprt_polling(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200218{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200219 if (!(c->flags & CO_FL_WILL_UPDATE))
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200220 if (conn_xprt_polling_changes(c))
Willy Tarreau916e12d2017-10-25 09:22:43 +0200221 conn_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200222}
223
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100224/* Stop all polling on the fd. This might be used when an error is encountered
Willy Tarreau916e12d2017-10-25 09:22:43 +0200225 * for example. It does not propage the change to the fd layer if
226 * CO_FL_WILL_UPDATE is present, indicating that an upper caller is going to do
227 * it later.
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100228 */
229static inline void conn_stop_polling(struct connection *c)
230{
231 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200232 CO_FL_XPRT_RD_ENA | CO_FL_XPRT_WR_ENA);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200233 if (!(c->flags & CO_FL_WILL_UPDATE) && conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200234 fd_stop_both(c->handle.fd);
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100235}
236
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200237/* Automatically update polling on connection <c> depending on the XPRT and
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200238 * SOCK flags, and on whether a handshake is in progress or not. This may be
239 * called at any moment when there is a doubt about the effectiveness of the
240 * polling state, for instance when entering or leaving the handshake state.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200241 * It does nothing if CO_FL_WILL_UPDATE is present, indicating that an upper
242 * caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200243 */
244static inline void conn_cond_update_polling(struct connection *c)
245{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100246 if (unlikely(c->flags & CO_FL_ERROR))
247 conn_stop_polling(c);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200248 else if (!(c->flags & CO_FL_WILL_UPDATE)) {
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200249 if (conn_xprt_polling_changes(c))
Willy Tarreau916e12d2017-10-25 09:22:43 +0200250 conn_update_xprt_polling(c);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200251 }
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200252}
253
254/***** Event manipulation primitives for use by DATA I/O callbacks *****/
255/* The __conn_* versions do not propagate to lower layers and are only meant
256 * to be used by handlers called by the connection handler. The other ones
257 * may be used anywhere.
258 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200259static inline void __conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200260{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200261 c->flags |= CO_FL_XPRT_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200262}
263
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200264static inline void __conn_xprt_stop_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200265{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200266 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200267}
268
Willy Tarreau796c5b72016-11-29 21:47:02 +0100269/* this one is used only to stop speculative recv(). It doesn't stop it if the
270 * fd is already polled in order to avoid expensive polling status changes.
271 * Since it might require the upper layer to re-enable reading, we'll return 1
272 * if we've really stopped something otherwise zero.
273 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200274static inline int __conn_xprt_done_recv(struct connection *c)
Willy Tarreau796c5b72016-11-29 21:47:02 +0100275{
Willy Tarreau585744b2017-08-24 14:31:19 +0200276 if (!conn_ctrl_ready(c) || !fd_recv_polled(c->handle.fd)) {
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200277 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreau796c5b72016-11-29 21:47:02 +0100278 return 1;
279 }
280 return 0;
281}
282
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200283static inline void __conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200284{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200285 c->flags |= CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200286}
287
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200288static inline void __conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200289{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200290 c->flags &= ~CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200291}
292
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200293static inline void __conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200294{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200295 c->flags &= ~(CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200296}
297
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200298static inline void conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200299{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200300 __conn_xprt_want_recv(c);
301 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200302}
303
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200304static inline void conn_xprt_stop_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200305{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200306 __conn_xprt_stop_recv(c);
307 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200308}
309
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200310static inline void conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200311{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200312 __conn_xprt_want_send(c);
313 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200314}
315
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200316static inline void conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200317{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200318 __conn_xprt_stop_send(c);
319 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200320}
321
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200322static inline void conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200323{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200324 __conn_xprt_stop_both(c);
325 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200326}
327
Willy Tarreau7b271b22017-10-25 09:59:22 +0200328/* read shutdown, called from the rcv_buf/rcv_pipe handlers when
329 * detecting an end of connection.
330 */
Willy Tarreau3af56a92012-08-20 16:55:48 +0200331static inline void conn_sock_read0(struct connection *c)
332{
333 c->flags |= CO_FL_SOCK_RD_SH;
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200334 __conn_xprt_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100335 /* we don't risk keeping ports unusable if we found the
336 * zero from the other side.
337 */
Willy Tarreau3c728722014-01-23 13:50:42 +0100338 if (conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200339 fdtab[c->handle.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200340}
341
Willy Tarreau7b271b22017-10-25 09:59:22 +0200342/* write shutdown, indication that the upper layer is not willing to send
Willy Tarreaua48c1412017-12-22 18:46:33 +0100343 * anything anymore and wants to close after pending data are sent. The
344 * <clean> argument will allow not to perform the socket layer shutdown if
345 * equal to 0.
Willy Tarreau7b271b22017-10-25 09:59:22 +0200346 */
Willy Tarreaua48c1412017-12-22 18:46:33 +0100347static inline void conn_sock_shutw(struct connection *c, int clean)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200348{
349 c->flags |= CO_FL_SOCK_WR_SH;
Willy Tarreau7b271b22017-10-25 09:59:22 +0200350 conn_refresh_polling_flags(c);
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200351 __conn_xprt_stop_send(c);
352 conn_cond_update_xprt_polling(c);
Willy Tarreau7b271b22017-10-25 09:59:22 +0200353
Willy Tarreaua48c1412017-12-22 18:46:33 +0100354 /* don't perform a clean shutdown if we're going to reset or
355 * if the shutr was already received.
356 */
Olivier Houchard6c7e96a2019-07-02 16:35:18 +0200357 if (conn_ctrl_ready(c) && !(c->flags & CO_FL_SOCK_RD_SH) && clean)
Willy Tarreau585744b2017-08-24 14:31:19 +0200358 shutdown(c->handle.fd, SHUT_WR);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200359}
360
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200361static inline void conn_xprt_shutw(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200362{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200363 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100364
365 /* clean data-layer shutdown */
366 if (c->xprt && c->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100367 c->xprt->shutw(c, c->xprt_ctx, 1);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100368}
369
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200370static inline void conn_xprt_shutw_hard(struct connection *c)
Willy Tarreau729c69f2015-03-12 22:51:10 +0100371{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200372 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100373
374 /* unclean data-layer shutdown */
375 if (c->xprt && c->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100376 c->xprt->shutw(c, c->xprt_ctx, 0);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200377}
378
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200379/* shut read */
380static inline void cs_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200381{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200382
383 /* clean data-layer shutdown */
384 if (cs->conn->mux && cs->conn->mux->shutr)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200385 cs->conn->mux->shutr(cs, mode);
386 cs->flags |= (mode == CS_SHR_DRAIN) ? CS_FL_SHRD : CS_FL_SHRR;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200387}
388
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200389/* shut write */
390static inline void cs_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200391{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200392
393 /* clean data-layer shutdown */
394 if (cs->conn->mux && cs->conn->mux->shutw)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200395 cs->conn->mux->shutw(cs, mode);
396 cs->flags |= (mode == CS_SHW_NORMAL) ? CS_FL_SHWN : CS_FL_SHWS;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200397}
398
Willy Tarreau6978db32017-10-05 18:19:43 +0200399/* completely close a conn_stream (but do not detach it) */
400static inline void cs_close(struct conn_stream *cs)
401{
402 cs_shutw(cs, CS_SHW_SILENT);
403 cs_shutr(cs, CS_SHR_RESET);
404 cs->flags = CS_FL_NONE;
405}
406
Willy Tarreaue9f43012018-12-19 17:59:30 +0100407/* sets CS_FL_ERROR or CS_FL_ERR_PENDING on the cs */
408static inline void cs_set_error(struct conn_stream *cs)
409{
410 if (cs->flags & CS_FL_EOS)
411 cs->flags |= CS_FL_ERROR;
412 else
Willy Tarreau7bb39d72019-06-03 14:23:33 +0200413 cs->flags |= CS_FL_ERR_PENDING;
Willy Tarreaue9f43012018-12-19 17:59:30 +0100414}
415
Willy Tarreau3af56a92012-08-20 16:55:48 +0200416/* detect sock->data read0 transition */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200417static inline int conn_xprt_read0_pending(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200418{
Willy Tarreau54e917c2017-08-30 07:35:35 +0200419 return (c->flags & CO_FL_SOCK_RD_SH) != 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200420}
421
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200422/* prepares a connection to work with protocol <proto> and transport <xprt>.
Willy Tarreau53a47662017-08-28 10:53:00 +0200423 * The transport's is initialized as well, and the mux and its context are
Willy Tarreaube373152018-09-06 11:45:30 +0200424 * cleared. The target is not reinitialized and it is recommended that it is
425 * set prior to calling this function so that the function may make use of it
426 * in the future to refine the mux choice if needed.
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200427 */
428static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
429{
430 conn->ctrl = proto;
431 conn->xprt = xprt;
Willy Tarreau53a47662017-08-28 10:53:00 +0200432 conn->mux = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200433 conn->xprt_ctx = NULL;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100434 conn->ctx = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200435}
436
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200437/*
438 * Initializes all required fields for a new conn_strema.
439 */
440static inline void cs_init(struct conn_stream *cs, struct connection *conn)
441{
442 cs->obj_type = OBJ_TYPE_CS;
443 cs->flags = CS_FL_NONE;
444 cs->conn = conn;
445}
446
Willy Tarreaud0155772013-10-14 17:10:08 +0200447/* Initializes all required fields for a new connection. Note that it does the
448 * minimum acceptable initialization for a connection that already exists and
449 * is about to be reused. It also leaves the addresses untouched, which makes
450 * it usable across connection retries to reset a connection to a known state.
451 */
452static inline void conn_init(struct connection *conn)
453{
454 conn->obj_type = OBJ_TYPE_CONN;
455 conn->flags = CO_FL_NONE;
Willy Tarreau53a47662017-08-28 10:53:00 +0200456 conn->mux = NULL;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100457 conn->ctx = NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200458 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200459 conn->send_proxy_ofs = 0;
Willy Tarreau585744b2017-08-24 14:31:19 +0200460 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreaud0155772013-10-14 17:10:08 +0200461 conn->err_code = CO_ER_NONE;
462 conn->target = NULL;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200463 conn->xprt_done_cb = NULL;
Willy Tarreau436d3332017-10-08 11:16:46 +0200464 conn->destroy_cb = NULL;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100465 conn->proxy_netns = NULL;
Willy Tarreaud75d40e2015-08-04 17:25:58 +0200466 LIST_INIT(&conn->list);
Olivier Houchard131fd892018-11-13 16:44:31 +0100467 LIST_INIT(&conn->session_list);
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200468 conn->send_wait = NULL;
469 conn->recv_wait = NULL;
Olivier Houchard006e3102018-12-10 18:30:32 +0100470 conn->idle_time = 0;
Willy Tarreaud0155772013-10-14 17:10:08 +0200471}
472
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200473/* sets <owner> as the connection's owner */
Willy Tarreau436d3332017-10-08 11:16:46 +0200474static inline void conn_set_owner(struct connection *conn, void *owner, void (*cb)(struct connection *))
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200475{
476 conn->owner = owner;
Willy Tarreau436d3332017-10-08 11:16:46 +0200477 conn->destroy_cb = cb;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200478}
479
480/* registers <cb> as a callback to notify for transport's readiness or failure */
481static inline void conn_set_xprt_done_cb(struct connection *conn, int (*cb)(struct connection *))
482{
483 conn->xprt_done_cb = cb;
484}
485
486/* unregisters the callback to notify for transport's readiness or failure */
487static inline void conn_clear_xprt_done_cb(struct connection *conn)
488{
489 conn->xprt_done_cb = NULL;
490}
491
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200492/* Tries to allocate a new connection and initialized its main fields. The
493 * connection is returned on success, NULL on failure. The connection must
Willy Tarreaubafbe012017-11-24 17:34:44 +0100494 * be released using pool_free() or conn_free().
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200495 */
496static inline struct connection *conn_new()
497{
498 struct connection *conn;
499
Willy Tarreaubafbe012017-11-24 17:34:44 +0100500 conn = pool_alloc(pool_head_connection);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200501 if (likely(conn != NULL))
502 conn_init(conn);
503 return conn;
504}
505
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100506/* Releases a conn_stream previously allocated by cs_new(), as well as any
507 * buffer it would still hold.
508 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200509static inline void cs_free(struct conn_stream *cs)
510{
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100511
Willy Tarreaubafbe012017-11-24 17:34:44 +0100512 pool_free(pool_head_connstream, cs);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200513}
514
515/* Tries to allocate a new conn_stream and initialize its main fields. If
516 * <conn> is NULL, then a new connection is allocated on the fly, initialized,
517 * and assigned to cs->conn ; this connection will then have to be released
Willy Tarreaubafbe012017-11-24 17:34:44 +0100518 * using pool_free() or conn_free(). The conn_stream is initialized and added
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200519 * to the mux's stream list on success, then returned. On failure, nothing is
520 * allocated and NULL is returned.
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200521 */
522static inline struct conn_stream *cs_new(struct connection *conn)
523{
524 struct conn_stream *cs;
525
Willy Tarreaubafbe012017-11-24 17:34:44 +0100526 cs = pool_alloc(pool_head_connstream);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200527 if (!likely(cs))
528 return NULL;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200529
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200530 if (!conn) {
531 conn = conn_new();
532 if (!likely(conn)) {
533 cs_free(cs);
534 return NULL;
535 }
536 conn_init(conn);
537 }
538
539 cs_init(cs, conn);
540 return cs;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200541}
542
Willy Tarreaufafd3982018-11-18 21:29:20 +0100543/* Retrieves any valid conn_stream from this connection, preferably the first
544 * valid one. The purpose is to be able to figure one other end of a private
545 * connection for purposes like source binding or proxy protocol header
546 * emission. In such cases, any conn_stream is expected to be valid so the
547 * mux is encouraged to return the first one it finds. If the connection has
548 * no mux or the mux has no get_first_cs() method or the mux has no valid
549 * conn_stream, NULL is returned. The output pointer is purposely marked
550 * const to discourage the caller from modifying anything there.
551 */
552static inline const struct conn_stream *cs_get_first(const struct connection *conn)
553{
554 if (!conn || !conn->mux || !conn->mux->get_first_cs)
555 return NULL;
556 return conn->mux->get_first_cs(conn);
557}
558
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200559static inline void conn_force_unsubscribe(struct connection *conn)
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200560{
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200561 if (conn->recv_wait) {
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100562 conn->recv_wait->events &= ~SUB_RETRY_RECV;
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200563 conn->recv_wait = NULL;
564 }
565 if (conn->send_wait) {
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100566 conn->send_wait->events &= ~SUB_RETRY_SEND;
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200567 conn->send_wait = NULL;
568 }
569
570}
571
572/* Releases a connection previously allocated by conn_new() */
573static inline void conn_free(struct connection *conn)
574{
Olivier Houchard00cf70f2018-11-30 17:24:55 +0100575 /* Remove ourself from the session's connections list, if any. */
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100576 if (!LIST_ISEMPTY(&conn->session_list)) {
577 struct session *sess = conn->owner;
Olivier Houcharda2dbeb22018-12-28 18:50:57 +0100578 if (conn->flags & CO_FL_SESS_IDLE)
579 sess->idle_conns--;
Olivier Houchard351411f2018-12-27 17:20:54 +0100580 session_unown_conn(sess, conn);
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100581 }
Willy Tarreau94031d32018-12-19 14:36:29 +0100582
583 /* By convention we always place a NULL where the ctx points to if the
584 * mux is null. It may have been used to store the connection as a
585 * stream_interface's end point for example.
Olivier Houchard201b9f42018-11-21 00:16:29 +0100586 */
Willy Tarreau94031d32018-12-19 14:36:29 +0100587 if (conn->ctx != NULL && conn->mux == NULL)
588 *(void **)conn->ctx = NULL;
Olivier Houchard201b9f42018-11-21 00:16:29 +0100589
Olivier Houchard006e3102018-12-10 18:30:32 +0100590 /* The connection is currently in the server's idle list, so tell it
591 * there's one less connection available in that list.
592 */
593 if (conn->idle_time > 0) {
594 struct server *srv = __objt_server(conn->target);
Olivier Houchard237985b2019-03-13 18:52:21 +0100595 _HA_ATOMIC_SUB(&srv->curr_idle_conns, 1);
Olivier Houchardf1314812019-02-18 16:41:17 +0100596 srv->curr_idle_thr[tid]--;
Olivier Houchard006e3102018-12-10 18:30:32 +0100597 }
Olivier Houchard201b9f42018-11-21 00:16:29 +0100598
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200599 conn_force_unsubscribe(conn);
Olivier Houchard4be71902019-07-11 15:49:00 +0200600 HA_SPIN_LOCK(OTHER_LOCK, &toremove_lock[tid]);
Olivier Houchard7f1bc312019-01-22 16:11:03 +0100601 LIST_DEL_LOCKED(&conn->list);
Olivier Houchard4be71902019-07-11 15:49:00 +0200602 HA_SPIN_UNLOCK(OTHER_LOCK, &toremove_lock[tid]);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100603 pool_free(pool_head_connection, conn);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200604}
605
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100606/* Release a conn_stream */
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200607static inline void cs_destroy(struct conn_stream *cs)
608{
Olivier Houchard302f9ef2018-04-13 15:50:27 +0200609 if (cs->conn->mux)
610 cs->conn->mux->detach(cs);
611 else {
612 /* It's too early to have a mux, let's just destroy
613 * the connection
614 */
615 struct connection *conn = cs->conn;
616
617 conn_stop_tracking(conn);
618 conn_full_close(conn);
619 if (conn->destroy_cb)
620 conn->destroy_cb(conn);
621 conn_free(conn);
622 }
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200623 cs_free(cs);
624}
625
Olivier Houcharde2b40b92017-09-13 18:30:23 +0200626/* Returns the conn from a cs. If cs is NULL, returns NULL */
627static inline struct connection *cs_conn(const struct conn_stream *cs)
628{
629 return cs ? cs->conn : NULL;
630}
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200631
Willy Tarreau986a9d22012-08-30 21:11:38 +0200632/* Retrieves the connection's source address */
633static inline void conn_get_from_addr(struct connection *conn)
634{
635 if (conn->flags & CO_FL_ADDR_FROM_SET)
636 return;
637
Willy Tarreau3c728722014-01-23 13:50:42 +0100638 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200639 return;
640
Willy Tarreau585744b2017-08-24 14:31:19 +0200641 if (conn->ctrl->get_src(conn->handle.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100642 sizeof(conn->addr.from),
643 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200644 return;
645 conn->flags |= CO_FL_ADDR_FROM_SET;
646}
647
648/* Retrieves the connection's original destination address */
649static inline void conn_get_to_addr(struct connection *conn)
650{
651 if (conn->flags & CO_FL_ADDR_TO_SET)
652 return;
653
Willy Tarreau3c728722014-01-23 13:50:42 +0100654 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200655 return;
656
Willy Tarreau585744b2017-08-24 14:31:19 +0200657 if (conn->ctrl->get_dst(conn->handle.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100658 sizeof(conn->addr.to),
659 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200660 return;
661 conn->flags |= CO_FL_ADDR_TO_SET;
662}
663
Willy Tarreau1a18b542018-12-11 16:37:42 +0100664/* Sets the TOS header in IPv4 and the traffic class header in IPv6 packets
665 * (as per RFC3260 #4 and BCP37 #4.2 and #5.2). The connection is tested and if
666 * it is null, nothing is done.
667 */
668static inline void conn_set_tos(const struct connection *conn, int tos)
669{
670 if (!conn || !conn_ctrl_ready(conn))
671 return;
672
673#ifdef IP_TOS
674 if (conn->addr.from.ss_family == AF_INET)
675 setsockopt(conn->handle.fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
676#endif
677#ifdef IPV6_TCLASS
678 if (conn->addr.from.ss_family == AF_INET6) {
679 if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr))
680 /* v4-mapped addresses need IP_TOS */
681 setsockopt(conn->handle.fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
682 else
683 setsockopt(conn->handle.fd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof(tos));
684 }
685#endif
686}
687
688/* Sets the netfilter mark on the connection's socket. The connection is tested
689 * and if it is null, nothing is done.
690 */
691static inline void conn_set_mark(const struct connection *conn, int mark)
692{
693 if (!conn || !conn_ctrl_ready(conn))
694 return;
695
696#ifdef SO_MARK
697 setsockopt(conn->handle.fd, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
698#endif
699}
700
701/* Sets adjust the TCP quick-ack feature on the connection's socket. The
702 * connection is tested and if it is null, nothing is done.
703 */
704static inline void conn_set_quickack(const struct connection *conn, int value)
705{
706 if (!conn || !conn_ctrl_ready(conn))
707 return;
708
709#ifdef TCP_QUICKACK
710 setsockopt(conn->handle.fd, IPPROTO_TCP, TCP_QUICKACK, &value, sizeof(value));
711#endif
712}
713
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200714/* Attaches a conn_stream to a data layer and sets the relevant callbacks */
715static inline void cs_attach(struct conn_stream *cs, void *data, const struct data_cb *data_cb)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200716{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200717 cs->data_cb = data_cb;
718 cs->data = data;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200719}
720
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200721static inline struct wait_event *wl_set_waitcb(struct wait_event *wl, struct task *(*cb)(struct task *, void *, unsigned short), void *ctx)
Willy Tarreau83188852018-07-18 08:18:20 +0200722{
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200723 if (!wl->tasklet->process) {
724 wl->tasklet->process = cb;
725 wl->tasklet->context = ctx;
Willy Tarreau83188852018-07-18 08:18:20 +0200726 }
727 return wl;
728}
729
Willy Tarreau53a47662017-08-28 10:53:00 +0200730/* Installs the connection's mux layer for upper context <ctx>.
731 * Returns < 0 on error.
732 */
Willy Tarreau175a2bb2018-09-12 12:02:05 +0200733static inline int conn_install_mux(struct connection *conn, const struct mux_ops *mux,
Olivier Houchardf502aca2018-12-14 19:42:40 +0100734 void *ctx, struct proxy *prx, struct session *sess)
Willy Tarreau53a47662017-08-28 10:53:00 +0200735{
Willy Tarreau762475e2019-01-10 10:33:32 +0100736 int ret;
737
Willy Tarreau53a47662017-08-28 10:53:00 +0200738 conn->mux = mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100739 conn->ctx = ctx;
Christopher Faulet51f73eb2019-04-08 11:22:47 +0200740 ret = mux->init ? mux->init(conn, prx, sess, &BUF_NULL) : 0;
Willy Tarreau762475e2019-01-10 10:33:32 +0100741 if (ret < 0) {
742 conn->mux = NULL;
743 conn->ctx = NULL;
744 }
745 return ret;
Willy Tarreau53a47662017-08-28 10:53:00 +0200746}
747
Willy Tarreau0af29122012-12-03 15:35:00 +0100748/* returns a human-readable error code for conn->err_code, or NULL if the code
749 * is unknown.
750 */
751static inline const char *conn_err_code_str(struct connection *c)
752{
753 switch (c->err_code) {
754 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100755
756 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
757 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
758 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
759 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
760 case CO_ER_NOPROTO: return "Protocol or address family not supported";
761 case CO_ER_SOCK_ERR: return "General socket error";
762 case CO_ER_PORT_RANGE: return "Source port range exhausted";
763 case CO_ER_CANT_BIND: return "Can't bind to source address";
764 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
765 case CO_ER_ADDR_INUSE: return "Local source address already in use";
766
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100767 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
768 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100769 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100770 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
771 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
772 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
773 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100774
775 case CO_ER_CIP_EMPTY: return "Connection closed while waiting for NetScaler Client IP header";
776 case CO_ER_CIP_ABORT: return "Connection error while waiting for NetScaler Client IP header";
777 case CO_ER_CIP_TRUNCATED: return "Truncated NetScaler Client IP header received";
778 case CO_ER_CIP_BAD_MAGIC: return "Received an invalid NetScaler Client IP magic number";
779 case CO_ER_CIP_BAD_PROTO: return "Received an unhandled protocol in the NetScaler Client IP header";
780
Willy Tarreau20879a02012-12-03 16:32:10 +0100781 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
782 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100783 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100784 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
785 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
786 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
787 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
788 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
Willy Tarreau71d058c2017-07-26 20:09:56 +0200789 case CO_ER_SSL_MISMATCH: return "Server presented an SSL certificate different from the configured one";
790 case CO_ER_SSL_MISMATCH_SNI: return "Server presented an SSL certificate different from the expected one";
Willy Tarreau20879a02012-12-03 16:32:10 +0100791 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200792 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200793 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100794 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Alexander Liu2a54bb72019-05-22 19:44:48 +0800795
796 case CO_ER_SOCKS4_SEND: return "SOCKS4 Proxy write error during handshake";
797 case CO_ER_SOCKS4_RECV: return "SOCKS4 Proxy read error during handshake";
798 case CO_ER_SOCKS4_DENY: return "SOCKS4 Proxy deny the request";
799 case CO_ER_SOCKS4_ABORT: return "SOCKS4 Proxy handshake aborted by server";
Willy Tarreau0af29122012-12-03 15:35:00 +0100800 }
801 return NULL;
802}
803
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100804static inline const char *conn_get_ctrl_name(const struct connection *conn)
805{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200806 if (!conn || !conn_ctrl_ready(conn))
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100807 return "NONE";
808 return conn->ctrl->name;
809}
810
811static inline const char *conn_get_xprt_name(const struct connection *conn)
812{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200813 if (!conn || !conn_xprt_ready(conn))
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100814 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100815 return conn->xprt->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100816}
817
Willy Tarreau53a47662017-08-28 10:53:00 +0200818static inline const char *conn_get_mux_name(const struct connection *conn)
819{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200820 if (!conn || !conn->mux)
Willy Tarreau53a47662017-08-28 10:53:00 +0200821 return "NONE";
822 return conn->mux->name;
823}
824
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200825static inline const char *cs_get_data_name(const struct conn_stream *cs)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100826{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200827 if (!cs || !cs->data_cb)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100828 return "NONE";
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200829 return cs->data_cb->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100830}
831
Willy Tarreau13e14102016-12-22 20:25:26 +0100832/* registers pointer to transport layer <id> (XPRT_*) */
833static inline void xprt_register(int id, struct xprt_ops *xprt)
834{
835 if (id >= XPRT_ENTRIES)
836 return;
837 registered_xprt[id] = xprt;
838}
839
840/* returns pointer to transport layer <id> (XPRT_*) or NULL if not registered */
841static inline struct xprt_ops *xprt_get(int id)
842{
843 if (id >= XPRT_ENTRIES)
844 return NULL;
845 return registered_xprt[id];
846}
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100847
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200848/* Try to add a handshake pseudo-XPRT. If the connection's first XPRT is
849 * raw_sock, then just use the new XPRT as the connection XPRT, otherwise
850 * call the xprt's add_xprt() method.
851 * Returns 0 on success, or non-zero on failure.
852 */
853static inline int xprt_add_hs(struct connection *conn)
854{
855 void *xprt_ctx = NULL;
856 const struct xprt_ops *ops = xprt_get(XPRT_HANDSHAKE);
857 void *nextxprt_ctx = NULL;
858 const struct xprt_ops *nextxprt_ops = NULL;
859
860 if (conn->flags & CO_FL_ERROR)
861 return -1;
862 if (ops->init(conn, &xprt_ctx) < 0)
863 return -1;
864 if (conn->xprt == xprt_get(XPRT_RAW)) {
865 nextxprt_ctx = conn->xprt_ctx;
866 nextxprt_ops = conn->xprt;
867 conn->xprt_ctx = xprt_ctx;
868 conn->xprt = ops;
869 } else {
870 if (conn->xprt->add_xprt(conn, conn->xprt_ctx, xprt_ctx, ops,
871 &nextxprt_ctx, &nextxprt_ops) != 0) {
872 ops->close(conn, xprt_ctx);
873 return -1;
874 }
875 }
876 if (ops->add_xprt(conn, xprt_ctx, nextxprt_ctx, nextxprt_ops, NULL, NULL) != 0) {
877 ops->close(conn, xprt_ctx);
878 return -1;
879 }
880 return 0;
881}
882
Willy Tarreaua9c17412016-12-04 18:42:09 +0100883static inline int conn_get_alpn(const struct connection *conn, const char **str, int *len)
884{
885 if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn)
886 return 0;
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100887 return conn->xprt->get_alpn(conn, conn->xprt_ctx, str, len);
Willy Tarreaua9c17412016-12-04 18:42:09 +0100888}
889
Christopher Faulet32f61c02018-04-10 14:33:41 +0200890/* registers proto mux list <list>. Modifies the list element! */
891static inline void register_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200892{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200893 LIST_ADDQ(&mux_proto_list.list, &list->list);
Willy Tarreau2386be62017-09-21 19:40:52 +0200894}
895
Christopher Faulet32f61c02018-04-10 14:33:41 +0200896/* unregisters proto mux list <list> */
897static inline void unregister_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200898{
899 LIST_DEL(&list->list);
900 LIST_INIT(&list->list);
901}
902
Christopher Faulete15c6c42018-08-08 10:21:56 +0200903static inline struct mux_proto_list *get_mux_proto(const struct ist proto)
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200904{
905 struct mux_proto_list *item;
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200906
907 list_for_each_entry(item, &mux_proto_list.list, list) {
908 if (isteq(proto, item->token))
909 return item;
910 }
911 return NULL;
912}
913
914/* Lists the known proto mux on <out> */
915static inline void list_mux_proto(FILE *out)
916{
917 struct mux_proto_list *item;
918 struct ist proto;
919 char *mode, *side;
920
Christopher Faulet9c9ef032018-08-08 10:25:57 +0200921 fprintf(out, "Available multiplexer protocols :\n"
Willy Tarreaud3c49d12018-11-30 16:52:32 +0100922 "(protocols marked as <default> cannot be specified using 'proto' keyword)\n");
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200923 list_for_each_entry(item, &mux_proto_list.list, list) {
924 proto = item->token;
925
926 if (item->mode == PROTO_MODE_ANY)
927 mode = "TCP|HTTP";
928 else if (item->mode == PROTO_MODE_TCP)
929 mode = "TCP";
930 else if (item->mode == PROTO_MODE_HTTP)
931 mode = "HTTP";
932 else
933 mode = "NONE";
934
935 if (item->side == PROTO_SIDE_BOTH)
936 side = "FE|BE";
937 else if (item->side == PROTO_SIDE_FE)
938 side = "FE";
939 else if (item->side == PROTO_SIDE_BE)
940 side = "BE";
941 else
942 side = "NONE";
943
Willy Tarreauca2a3cc2019-05-22 11:44:03 +0200944 fprintf(out, " %15s : mode=%-10s side=%-8s mux=%s\n",
945 (proto.len ? proto.ptr : "<default>"), mode, side, item->mux->name);
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200946 }
947}
948
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100949/* returns the first mux entry in the list matching the exact same <mux_proto>
950 * and compatible with the <proto_side> (FE or BE) and the <proto_mode> (TCP or
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200951 * HTTP). <mux_proto> can be empty. Will fall back to the first compatible mux
952 * with exactly the same <proto_mode> or with an empty name. May return
953 * null if the code improperly registered the default mux to use as a fallback.
Willy Tarreau2386be62017-09-21 19:40:52 +0200954 */
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100955static inline const struct mux_proto_list *conn_get_best_mux_entry(
956 const struct ist mux_proto,
957 int proto_side, int proto_mode)
Willy Tarreau2386be62017-09-21 19:40:52 +0200958{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200959 struct mux_proto_list *item;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200960 struct mux_proto_list *fallback = NULL;
Willy Tarreau2386be62017-09-21 19:40:52 +0200961
Christopher Faulet32f61c02018-04-10 14:33:41 +0200962 list_for_each_entry(item, &mux_proto_list.list, list) {
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200963 if (!(item->side & proto_side) || !(item->mode & proto_mode))
Willy Tarreau2386be62017-09-21 19:40:52 +0200964 continue;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200965 if (istlen(mux_proto) && isteq(mux_proto, item->token))
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100966 return item;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200967 else if (!istlen(item->token)) {
968 if (!fallback || (item->mode == proto_mode && fallback->mode != proto_mode))
969 fallback = item;
970 }
Willy Tarreau2386be62017-09-21 19:40:52 +0200971 }
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100972 return fallback;
973
974}
975
976/* returns the first mux in the list matching the exact same <mux_proto> and
977 * compatible with the <proto_side> (FE or BE) and the <proto_mode> (TCP or
978 * HTTP). <mux_proto> can be empty. Will fall back to the first compatible mux
979 * with exactly the same <proto_mode> or with an empty name. May return
980 * null if the code improperly registered the default mux to use as a fallback.
981 */
982static inline const struct mux_ops *conn_get_best_mux(struct connection *conn,
983 const struct ist mux_proto,
984 int proto_side, int proto_mode)
985{
986 const struct mux_proto_list *item;
987
988 item = conn_get_best_mux_entry(mux_proto, proto_side, proto_mode);
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200989
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100990 return item ? item->mux : NULL;
Willy Tarreau2386be62017-09-21 19:40:52 +0200991}
992
Willy Tarreau57f81852018-09-06 14:52:21 +0200993/* returns 0 if the connection is valid and is a frontend connection, otherwise
994 * returns 1 indicating it's a backend connection. And uninitialized connection
995 * also returns 1 to better handle the usage in the middle of initialization.
996 */
997static inline int conn_is_back(const struct connection *conn)
998{
999 return !objt_listener(conn->target);
1000}
1001
Willy Tarreau6ac98ac2018-09-06 11:48:44 +02001002/* returns a pointer to the proxy associated with this connection. For a front
1003 * connection it returns a pointer to the frontend ; for a back connection, it
1004 * returns a pointer to the backend.
1005 */
1006static inline struct proxy *conn_get_proxy(const struct connection *conn)
1007{
1008 struct listener *l;
1009 struct server *s;
1010
1011 /* check if it's a frontend connection */
1012 l = objt_listener(conn->target);
1013 if (l)
1014 return l->bind_conf->frontend;
1015
1016 /* check if it's a backend connection */
1017 s = objt_server(conn->target);
1018 if (s)
1019 return s->proxy;
1020
1021 return objt_proxy(conn->target);
1022}
1023
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001024/* installs the best mux for incoming connection <conn> using the upper context
1025 * <ctx>. If the mux protocol is forced, we use it to find the best
1026 * mux. Otherwise we use the ALPN name, if any. Returns < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +02001027 */
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001028static inline int conn_install_mux_fe(struct connection *conn, void *ctx)
Willy Tarreau2386be62017-09-21 19:40:52 +02001029{
Willy Tarreau55e0da62018-09-20 11:26:52 +02001030 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001031 const struct mux_ops *mux_ops;
Willy Tarreau2386be62017-09-21 19:40:52 +02001032
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001033 if (bind_conf->mux_proto)
1034 mux_ops = bind_conf->mux_proto->mux;
1035 else {
1036 struct ist mux_proto;
1037 const char *alpn_str = NULL;
1038 int alpn_len = 0;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001039 int mode;
1040
Christopher Fauletc1918d12019-04-24 15:01:22 +02001041 if (bind_conf->frontend->mode == PR_MODE_HTTP)
Christopher Fauletc985f6c2019-07-15 11:42:52 +02001042 mode = PROTO_MODE_HTTP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001043 else
Christopher Fauletc1918d12019-04-24 15:01:22 +02001044 mode = PROTO_MODE_TCP;
Willy Tarreau2386be62017-09-21 19:40:52 +02001045
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001046 conn_get_alpn(conn, &alpn_str, &alpn_len);
1047 mux_proto = ist2(alpn_str, alpn_len);
1048 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_FE, mode);
1049 if (!mux_ops)
1050 return -1;
1051 }
Olivier Houchardf502aca2018-12-14 19:42:40 +01001052 return conn_install_mux(conn, mux_ops, ctx, bind_conf->frontend, conn->owner);
Willy Tarreau2386be62017-09-21 19:40:52 +02001053}
1054
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001055/* installs the best mux for outgoing connection <conn> using the upper context
1056 * <ctx>. If the mux protocol is forced, we use it to find the best mux. Returns
Willy Tarreau2e0b2b52017-09-15 06:59:55 +02001057 * < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +02001058 */
Olivier Houchardf502aca2018-12-14 19:42:40 +01001059static inline int conn_install_mux_be(struct connection *conn, void *ctx, struct session *sess)
Willy Tarreau2386be62017-09-21 19:40:52 +02001060{
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001061 struct server *srv = objt_server(conn->target);
Willy Tarreau287527a2018-08-08 18:40:44 +02001062 struct proxy *prx = objt_proxy(conn->target);
Willy Tarreau2386be62017-09-21 19:40:52 +02001063 const struct mux_ops *mux_ops;
1064
Willy Tarreau287527a2018-08-08 18:40:44 +02001065 if (srv)
1066 prx = srv->proxy;
1067
1068 if (!prx) // target must be either proxy or server
1069 return -1;
1070
1071 if (srv && srv->mux_proto)
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001072 mux_ops = srv->mux_proto->mux;
1073 else {
Olivier Houchard201b9f42018-11-21 00:16:29 +01001074 struct ist mux_proto;
1075 const char *alpn_str = NULL;
1076 int alpn_len = 0;
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001077 int mode;
1078
Christopher Fauletc1918d12019-04-24 15:01:22 +02001079 if (prx->mode == PR_MODE_HTTP)
Christopher Fauletc985f6c2019-07-15 11:42:52 +02001080 mode = PROTO_MODE_HTTP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001081 else
Christopher Fauletc1918d12019-04-24 15:01:22 +02001082 mode = PROTO_MODE_TCP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001083
Olivier Houchard201b9f42018-11-21 00:16:29 +01001084 conn_get_alpn(conn, &alpn_str, &alpn_len);
1085 mux_proto = ist2(alpn_str, alpn_len);
1086
1087 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_BE, mode);
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001088 if (!mux_ops)
1089 return -1;
1090 }
Olivier Houchardf502aca2018-12-14 19:42:40 +01001091 return conn_install_mux(conn, mux_ops, ctx, prx, sess);
Willy Tarreau2386be62017-09-21 19:40:52 +02001092}
1093
Olivier Houchard2ab3dad2019-07-03 13:08:18 +02001094/* Change the mux for the connection.
1095 * The caller should make sure he's not subscribed to the underlying XPRT.
1096 */
Christopher Fauletc0016d82019-04-08 10:42:41 +02001097static inline int conn_upgrade_mux_fe(struct connection *conn, void *ctx, struct buffer *buf,
1098 struct ist mux_proto, int mode)
1099{
1100 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
1101 const struct mux_ops *old_mux, *new_mux;
1102 void *old_mux_ctx;
1103 const char *alpn_str = NULL;
1104 int alpn_len = 0;
1105
1106 if (!mux_proto.len) {
1107 conn_get_alpn(conn, &alpn_str, &alpn_len);
1108 mux_proto = ist2(alpn_str, alpn_len);
1109 }
1110 new_mux = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_FE, mode);
1111 old_mux = conn->mux;
1112
1113 /* No mux found */
1114 if (!new_mux)
1115 return -1;
1116
1117 /* Same mux, nothing to do */
1118 if (old_mux == new_mux)
1119 return 0;
1120
1121 old_mux_ctx = conn->ctx;
1122 conn->mux = new_mux;
1123 conn->ctx = ctx;
Christopher Fauletc0016d82019-04-08 10:42:41 +02001124 if (new_mux->init(conn, bind_conf->frontend, conn->owner, buf) == -1) {
1125 /* The mux upgrade failed, so restore the old mux */
1126 conn->ctx = old_mux_ctx;
1127 conn->mux = old_mux;
1128 return -1;
1129 }
1130
1131 /* The mux was upgraded, destroy the old one */
1132 *buf = BUF_NULL;
1133 old_mux->destroy(old_mux_ctx);
1134 return 0;
1135}
1136
Willy Tarreau59f98392012-07-06 14:13:49 +02001137#endif /* _PROTO_CONNECTION_H */
1138
1139/*
1140 * Local variables:
1141 * c-indent-level: 8
1142 * c-basic-offset: 8
1143 * End:
1144 */