blob: 9cf1aaaad4f26dc8655ce154a1192c1764b26164 [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
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020025#include <haproxy/api.h>
Willy Tarreaueb6f7012020-05-27 16:21:26 +020026#include <import/ist.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020027#include <haproxy/pool.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 Tarreau0f6ffd62020-06-03 19:33:00 +020030#include <haproxy/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 Tarreauff5d57b2019-07-17 18:37:02 +020037extern struct pool_head *pool_head_sockaddr;
Geoff Simmons7185b782019-08-27 18:31:16 +020038extern struct pool_head *pool_head_authority;
Willy Tarreau13e14102016-12-22 20:25:26 +010039extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
Christopher Faulet32f61c02018-04-10 14:33:41 +020040extern struct mux_proto_list mux_proto_list;
Willy Tarreauf2943dc2012-10-26 20:10:28 +020041
Christopher Faulete60abd12020-04-16 10:03:58 +020042#define IS_HTX_CONN(conn) ((conn)->mux && ((conn)->mux->flags & MX_FL_HTX))
43#define IS_HTX_CS(cs) (IS_HTX_CONN((cs)->conn))
44
Willy Tarreau59f98392012-07-06 14:13:49 +020045/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020046 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020047 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020048void conn_fd_handler(int fd);
Willy Tarreau4970e5a2019-12-27 10:40:21 +010049int conn_fd_check(struct connection *conn);
Willy Tarreau59f98392012-07-06 14:13:49 +020050
Willy Tarreau22cda212012-08-31 17:43:29 +020051/* receive a PROXY protocol header over a connection */
52int conn_recv_proxy(struct connection *conn, int flag);
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +010053int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote, struct stream *strm);
David Safb76832014-05-08 23:42:08 -040054int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
Tim Duesterhuscf6e0c82020-03-13 12:34:24 +010055int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote, struct stream *strm);
Willy Tarreau22cda212012-08-31 17:43:29 +020056
Willy Tarreauee1a6fc2020-01-17 07:52:13 +010057int conn_subscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es);
58int conn_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es);
Olivier Houchard83a0cd82018-09-28 17:57:58 +020059
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010060/* receive a NetScaler Client IP insertion header over a connection */
61int conn_recv_netscaler_cip(struct connection *conn, int flag);
62
Willy Tarreauff3e6482015-03-12 23:56:52 +010063/* raw send() directly on the socket */
64int conn_sock_send(struct connection *conn, const void *buf, int len, int flags);
65
Willy Tarreaud85c4852015-03-13 00:40:28 +010066/* drains any pending bytes from the socket */
67int conn_sock_drain(struct connection *conn);
68
Alexander Liu2a54bb72019-05-22 19:44:48 +080069/* scoks4 proxy handshake */
70int conn_send_socks4_proxy_request(struct connection *conn);
71int conn_recv_socks4_proxy_response(struct connection *conn);
72
Olivier Houchard477902b2020-01-22 18:08:48 +010073/* If we delayed the mux creation because we were waiting for the handshake, do it now */
74int conn_create_mux(struct connection *conn);
75
Willy Tarreauaf613e82020-06-05 08:40:51 +020076__decl_thread(extern HA_SPINLOCK_T toremove_lock[MAX_THREADS]);
Olivier Houchard4be71902019-07-11 15:49:00 +020077
Willy Tarreaud02cdd22013-12-15 10:23:20 +010078/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010079static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010080{
Willy Tarreauaad69382014-01-23 14:21:42 +010081 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010082}
83
84/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010085static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010086{
87 return (conn->flags & CO_FL_CTRL_READY);
88}
89
Willy Tarreauf79c8172013-10-21 16:30:56 +020090/* Calls the init() function of the transport layer if any and if not done yet,
91 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020092 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020093 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020094static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020095{
Willy Tarreauf79c8172013-10-21 16:30:56 +020096 int ret = 0;
97
Willy Tarreauaad69382014-01-23 14:21:42 +010098 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Olivier Houcharde179d0e2019-03-21 18:27:17 +010099 ret = conn->xprt->init(conn, &conn->xprt_ctx);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200100
101 if (ret >= 0)
102 conn->flags |= CO_FL_XPRT_READY;
103
104 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +0200105}
106
Willy Tarreauf79c8172013-10-21 16:30:56 +0200107/* Calls the close() function of the transport layer if any and if not done
108 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
109 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
110 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +0200111 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200112static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +0200113{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200114 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +0100115 if (conn->xprt->close)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100116 conn->xprt->close(conn, conn->xprt_ctx);
Olivier Houchard478281f2019-05-13 19:10:46 +0200117 conn->xprt_ctx = NULL;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200118 conn->flags &= ~CO_FL_XPRT_READY;
119 }
120}
121
122/* Initializes the connection's control layer which essentially consists in
123 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +0100124 * flag. The caller is responsible for ensuring that the control layer is
125 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200126 */
127static inline void conn_ctrl_init(struct connection *conn)
128{
Willy Tarreau3c728722014-01-23 13:50:42 +0100129 if (!conn_ctrl_ready(conn)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200130 int fd = conn->handle.fd;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200131
Willy Tarreaua9786b62018-01-25 07:22:13 +0100132 fd_insert(fd, conn, conn_fd_handler, tid_bit);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200133 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200134 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200135}
136
Willy Tarreauf79c8172013-10-21 16:30:56 +0200137/* Deletes the FD if the transport layer is already gone. Once done,
138 * it then removes the CO_FL_CTRL_READY flag.
139 */
140static inline void conn_ctrl_close(struct connection *conn)
141{
142 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200143 fd_delete(conn->handle.fd);
Willy Tarreau6a0a80a2017-10-05 17:43:39 +0200144 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200145 conn->flags &= ~CO_FL_CTRL_READY;
146 }
147}
148
Willy Tarreau2b199c92012-11-23 17:32:21 +0100149/* If the connection still has a transport layer, then call its close() function
150 * if any, and delete the file descriptor if a control layer is set. This is
151 * used to close everything at once and atomically. However this is not done if
152 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
153 * transport layer very late if needed.
154 */
155static inline void conn_full_close(struct connection *conn)
156{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200157 conn_xprt_close(conn);
158 conn_ctrl_close(conn);
159}
160
Willy Tarreaudc42acd2017-10-05 18:09:20 +0200161/* stop tracking a connection, allowing conn_full_close() to always
162 * succeed.
163 */
164static inline void conn_stop_tracking(struct connection *conn)
165{
166 conn->flags &= ~CO_FL_XPRT_TRACKED;
167}
168
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100169/* Stop all polling on the fd. This might be used when an error is encountered
Willy Tarreau19bc2012020-02-21 08:46:19 +0100170 * for example.
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100171 */
172static inline void conn_stop_polling(struct connection *c)
173{
Willy Tarreau19bc2012020-02-21 08:46:19 +0100174 if (conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200175 fd_stop_both(c->handle.fd);
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100176}
177
Willy Tarreau19bc2012020-02-21 08:46:19 +0100178/* Stops polling in case of error on the connection. */
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200179static inline void conn_cond_update_polling(struct connection *c)
180{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100181 if (unlikely(c->flags & CO_FL_ERROR))
182 conn_stop_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200183}
184
Willy Tarreau7b271b22017-10-25 09:59:22 +0200185/* read shutdown, called from the rcv_buf/rcv_pipe handlers when
186 * detecting an end of connection.
187 */
Willy Tarreau3af56a92012-08-20 16:55:48 +0200188static inline void conn_sock_read0(struct connection *c)
189{
190 c->flags |= CO_FL_SOCK_RD_SH;
Willy Tarreaud1d14c32020-02-21 10:34:19 +0100191 if (conn_ctrl_ready(c)) {
192 fd_stop_recv(c->handle.fd);
193 /* we don't risk keeping ports unusable if we found the
194 * zero from the other side.
195 */
Willy Tarreau585744b2017-08-24 14:31:19 +0200196 fdtab[c->handle.fd].linger_risk = 0;
Willy Tarreaud1d14c32020-02-21 10:34:19 +0100197 }
Willy Tarreau3af56a92012-08-20 16:55:48 +0200198}
199
Willy Tarreau7b271b22017-10-25 09:59:22 +0200200/* write shutdown, indication that the upper layer is not willing to send
Willy Tarreaua48c1412017-12-22 18:46:33 +0100201 * anything anymore and wants to close after pending data are sent. The
202 * <clean> argument will allow not to perform the socket layer shutdown if
203 * equal to 0.
Willy Tarreau7b271b22017-10-25 09:59:22 +0200204 */
Willy Tarreaua48c1412017-12-22 18:46:33 +0100205static inline void conn_sock_shutw(struct connection *c, int clean)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200206{
207 c->flags |= CO_FL_SOCK_WR_SH;
Willy Tarreaud1d14c32020-02-21 10:34:19 +0100208 if (conn_ctrl_ready(c)) {
209 fd_stop_send(c->handle.fd);
210 /* don't perform a clean shutdown if we're going to reset or
211 * if the shutr was already received.
212 */
213 if (!(c->flags & CO_FL_SOCK_RD_SH) && clean)
214 shutdown(c->handle.fd, SHUT_WR);
215 }
Willy Tarreau3af56a92012-08-20 16:55:48 +0200216}
217
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200218static inline void conn_xprt_shutw(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200219{
Willy Tarreaud1d14c32020-02-21 10:34:19 +0100220 if (conn_ctrl_ready(c))
221 fd_stop_send(c->handle.fd);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100222
223 /* clean data-layer shutdown */
224 if (c->xprt && c->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100225 c->xprt->shutw(c, c->xprt_ctx, 1);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100226}
227
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200228static inline void conn_xprt_shutw_hard(struct connection *c)
Willy Tarreau729c69f2015-03-12 22:51:10 +0100229{
Willy Tarreaud1d14c32020-02-21 10:34:19 +0100230 if (conn_ctrl_ready(c))
231 fd_stop_send(c->handle.fd);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100232
233 /* unclean data-layer shutdown */
234 if (c->xprt && c->xprt->shutw)
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100235 c->xprt->shutw(c, c->xprt_ctx, 0);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200236}
237
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200238/* shut read */
239static inline void cs_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200240{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200241
242 /* clean data-layer shutdown */
243 if (cs->conn->mux && cs->conn->mux->shutr)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200244 cs->conn->mux->shutr(cs, mode);
245 cs->flags |= (mode == CS_SHR_DRAIN) ? CS_FL_SHRD : CS_FL_SHRR;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200246}
247
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200248/* shut write */
249static inline void cs_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200250{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200251
252 /* clean data-layer shutdown */
253 if (cs->conn->mux && cs->conn->mux->shutw)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200254 cs->conn->mux->shutw(cs, mode);
255 cs->flags |= (mode == CS_SHW_NORMAL) ? CS_FL_SHWN : CS_FL_SHWS;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200256}
257
Willy Tarreau6978db32017-10-05 18:19:43 +0200258/* completely close a conn_stream (but do not detach it) */
259static inline void cs_close(struct conn_stream *cs)
260{
261 cs_shutw(cs, CS_SHW_SILENT);
262 cs_shutr(cs, CS_SHR_RESET);
263 cs->flags = CS_FL_NONE;
264}
265
Willy Tarreaue9f43012018-12-19 17:59:30 +0100266/* sets CS_FL_ERROR or CS_FL_ERR_PENDING on the cs */
267static inline void cs_set_error(struct conn_stream *cs)
268{
269 if (cs->flags & CS_FL_EOS)
270 cs->flags |= CS_FL_ERROR;
271 else
Willy Tarreau7bb39d72019-06-03 14:23:33 +0200272 cs->flags |= CS_FL_ERR_PENDING;
Willy Tarreaue9f43012018-12-19 17:59:30 +0100273}
274
Willy Tarreau3af56a92012-08-20 16:55:48 +0200275/* detect sock->data read0 transition */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200276static inline int conn_xprt_read0_pending(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200277{
Willy Tarreau54e917c2017-08-30 07:35:35 +0200278 return (c->flags & CO_FL_SOCK_RD_SH) != 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200279}
280
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200281/* prepares a connection to work with protocol <proto> and transport <xprt>.
Willy Tarreau53a47662017-08-28 10:53:00 +0200282 * The transport's is initialized as well, and the mux and its context are
Willy Tarreaube373152018-09-06 11:45:30 +0200283 * cleared. The target is not reinitialized and it is recommended that it is
284 * set prior to calling this function so that the function may make use of it
285 * in the future to refine the mux choice if needed.
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200286 */
287static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
288{
289 conn->ctrl = proto;
290 conn->xprt = xprt;
Willy Tarreau53a47662017-08-28 10:53:00 +0200291 conn->mux = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200292 conn->xprt_ctx = NULL;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100293 conn->ctx = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200294}
295
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200296/*
297 * Initializes all required fields for a new conn_strema.
298 */
299static inline void cs_init(struct conn_stream *cs, struct connection *conn)
300{
301 cs->obj_type = OBJ_TYPE_CS;
302 cs->flags = CS_FL_NONE;
303 cs->conn = conn;
304}
305
Willy Tarreaud0155772013-10-14 17:10:08 +0200306/* Initializes all required fields for a new connection. Note that it does the
307 * minimum acceptable initialization for a connection that already exists and
308 * is about to be reused. It also leaves the addresses untouched, which makes
309 * it usable across connection retries to reset a connection to a known state.
310 */
311static inline void conn_init(struct connection *conn)
312{
313 conn->obj_type = OBJ_TYPE_CONN;
314 conn->flags = CO_FL_NONE;
Willy Tarreau53a47662017-08-28 10:53:00 +0200315 conn->mux = NULL;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100316 conn->ctx = NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200317 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200318 conn->send_proxy_ofs = 0;
Willy Tarreau585744b2017-08-24 14:31:19 +0200319 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreaud0155772013-10-14 17:10:08 +0200320 conn->err_code = CO_ER_NONE;
321 conn->target = NULL;
Willy Tarreau436d3332017-10-08 11:16:46 +0200322 conn->destroy_cb = NULL;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100323 conn->proxy_netns = NULL;
Olivier Houchardf0d4dff2020-03-06 18:12:03 +0100324 MT_LIST_INIT(&conn->list);
Olivier Houchard131fd892018-11-13 16:44:31 +0100325 LIST_INIT(&conn->session_list);
Willy Tarreau7872d1f2020-01-10 07:06:05 +0100326 conn->subs = NULL;
Olivier Houchard006e3102018-12-10 18:30:32 +0100327 conn->idle_time = 0;
Willy Tarreaue71fca82019-07-17 19:06:58 +0200328 conn->src = NULL;
329 conn->dst = NULL;
Geoff Simmons7185b782019-08-27 18:31:16 +0200330 conn->proxy_authority = NULL;
Tim Duesterhusd1b15b62020-03-13 12:34:23 +0100331 conn->proxy_unique_id = IST_NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200332}
333
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200334/* sets <owner> as the connection's owner */
Willy Tarreau436d3332017-10-08 11:16:46 +0200335static inline void conn_set_owner(struct connection *conn, void *owner, void (*cb)(struct connection *))
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200336{
337 conn->owner = owner;
Willy Tarreau436d3332017-10-08 11:16:46 +0200338 conn->destroy_cb = cb;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200339}
340
Willy Tarreauff5d57b2019-07-17 18:37:02 +0200341/* Allocates a struct sockaddr from the pool if needed, assigns it to *sap and
342 * returns it. If <sap> is NULL, the address is always allocated and returned.
343 * if <sap> is non-null, an address will only be allocated if it points to a
344 * non-null pointer. In this case the allocated address will be assigned there.
345 * In both situations the new pointer is returned.
346 */
347static inline struct sockaddr_storage *sockaddr_alloc(struct sockaddr_storage **sap)
348{
349 struct sockaddr_storage *sa;
350
351 if (sap && *sap)
352 return *sap;
353
354 sa = pool_alloc(pool_head_sockaddr);
355 if (sap)
356 *sap = sa;
357 return sa;
358}
359
360/* Releases the struct sockaddr potentially pointed to by <sap> to the pool. It
361 * may be NULL or may point to NULL. If <sap> is not NULL, a NULL is placed
362 * there.
363 */
364static inline void sockaddr_free(struct sockaddr_storage **sap)
365{
366 if (!sap)
367 return;
368 pool_free(pool_head_sockaddr, *sap);
369 *sap = NULL;
370}
371
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200372/* Tries to allocate a new connection and initialized its main fields. The
373 * connection is returned on success, NULL on failure. The connection must
Willy Tarreaubafbe012017-11-24 17:34:44 +0100374 * be released using pool_free() or conn_free().
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200375 */
376static inline struct connection *conn_new()
377{
378 struct connection *conn;
379
Willy Tarreaubafbe012017-11-24 17:34:44 +0100380 conn = pool_alloc(pool_head_connection);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200381 if (likely(conn != NULL))
382 conn_init(conn);
383 return conn;
384}
385
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100386/* Releases a conn_stream previously allocated by cs_new(), as well as any
387 * buffer it would still hold.
388 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200389static inline void cs_free(struct conn_stream *cs)
390{
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100391
Willy Tarreaubafbe012017-11-24 17:34:44 +0100392 pool_free(pool_head_connstream, cs);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200393}
394
395/* Tries to allocate a new conn_stream and initialize its main fields. If
396 * <conn> is NULL, then a new connection is allocated on the fly, initialized,
397 * and assigned to cs->conn ; this connection will then have to be released
Willy Tarreaubafbe012017-11-24 17:34:44 +0100398 * using pool_free() or conn_free(). The conn_stream is initialized and added
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200399 * to the mux's stream list on success, then returned. On failure, nothing is
400 * allocated and NULL is returned.
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200401 */
402static inline struct conn_stream *cs_new(struct connection *conn)
403{
404 struct conn_stream *cs;
405
Willy Tarreaubafbe012017-11-24 17:34:44 +0100406 cs = pool_alloc(pool_head_connstream);
Tim Duesterhus927063b2020-02-21 13:02:03 +0100407 if (unlikely(!cs))
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200408 return NULL;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200409
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200410 if (!conn) {
411 conn = conn_new();
Tim Duesterhus927063b2020-02-21 13:02:03 +0100412 if (unlikely(!conn)) {
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200413 cs_free(cs);
414 return NULL;
415 }
416 conn_init(conn);
417 }
418
419 cs_init(cs, conn);
420 return cs;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200421}
422
Willy Tarreaufafd3982018-11-18 21:29:20 +0100423/* Retrieves any valid conn_stream from this connection, preferably the first
424 * valid one. The purpose is to be able to figure one other end of a private
425 * connection for purposes like source binding or proxy protocol header
426 * emission. In such cases, any conn_stream is expected to be valid so the
427 * mux is encouraged to return the first one it finds. If the connection has
428 * no mux or the mux has no get_first_cs() method or the mux has no valid
429 * conn_stream, NULL is returned. The output pointer is purposely marked
430 * const to discourage the caller from modifying anything there.
431 */
432static inline const struct conn_stream *cs_get_first(const struct connection *conn)
433{
434 if (!conn || !conn->mux || !conn->mux->get_first_cs)
435 return NULL;
436 return conn->mux->get_first_cs(conn);
437}
438
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200439static inline void conn_force_unsubscribe(struct connection *conn)
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200440{
Willy Tarreau7872d1f2020-01-10 07:06:05 +0100441 if (!conn->subs)
442 return;
443 conn->subs->events = 0;
444 conn->subs = NULL;
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200445}
446
447/* Releases a connection previously allocated by conn_new() */
448static inline void conn_free(struct connection *conn)
449{
Olivier Houchard00cf70f2018-11-30 17:24:55 +0100450 /* Remove ourself from the session's connections list, if any. */
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100451 if (!LIST_ISEMPTY(&conn->session_list)) {
452 struct session *sess = conn->owner;
Olivier Houcharda2dbeb22018-12-28 18:50:57 +0100453 if (conn->flags & CO_FL_SESS_IDLE)
454 sess->idle_conns--;
Olivier Houchard351411f2018-12-27 17:20:54 +0100455 session_unown_conn(sess, conn);
Olivier Houcharda4d4fdf2018-12-14 19:27:06 +0100456 }
Willy Tarreau94031d32018-12-19 14:36:29 +0100457
Willy Tarreaue71fca82019-07-17 19:06:58 +0200458 sockaddr_free(&conn->src);
459 sockaddr_free(&conn->dst);
460
Geoff Simmons7185b782019-08-27 18:31:16 +0200461 if (conn->proxy_authority != NULL) {
462 pool_free(pool_head_authority, conn->proxy_authority);
463 conn->proxy_authority = NULL;
464 }
Tim Duesterhusd1b15b62020-03-13 12:34:23 +0100465 if (isttest(conn->proxy_unique_id)) {
466 pool_free(pool_head_uniqueid, conn->proxy_unique_id.ptr);
467 conn->proxy_unique_id = IST_NULL;
468 }
Geoff Simmons7185b782019-08-27 18:31:16 +0200469
Willy Tarreau94031d32018-12-19 14:36:29 +0100470 /* By convention we always place a NULL where the ctx points to if the
471 * mux is null. It may have been used to store the connection as a
472 * stream_interface's end point for example.
Olivier Houchard201b9f42018-11-21 00:16:29 +0100473 */
Willy Tarreau94031d32018-12-19 14:36:29 +0100474 if (conn->ctx != NULL && conn->mux == NULL)
475 *(void **)conn->ctx = NULL;
Olivier Houchard201b9f42018-11-21 00:16:29 +0100476
Olivier Houchard006e3102018-12-10 18:30:32 +0100477 /* The connection is currently in the server's idle list, so tell it
478 * there's one less connection available in that list.
479 */
480 if (conn->idle_time > 0) {
481 struct server *srv = __objt_server(conn->target);
Olivier Houchard237985b2019-03-13 18:52:21 +0100482 _HA_ATOMIC_SUB(&srv->curr_idle_conns, 1);
Olivier Houchard566df302020-03-06 18:18:56 +0100483 _HA_ATOMIC_SUB(conn->flags & CO_FL_SAFE_LIST ? &srv->curr_safe_nb : &srv->curr_idle_nb, 1);
484 _HA_ATOMIC_SUB(&srv->curr_idle_thr[tid], 1);
Olivier Houchardcf612a02020-03-25 19:41:03 +0100485 } else {
486 struct server *srv = objt_server(conn->target);
487
488 if (srv)
489 _HA_ATOMIC_SUB(&srv->curr_used_conns, 1);
Olivier Houchard006e3102018-12-10 18:30:32 +0100490 }
Olivier Houchard201b9f42018-11-21 00:16:29 +0100491
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200492 conn_force_unsubscribe(conn);
Olivier Houchard4be71902019-07-11 15:49:00 +0200493 HA_SPIN_LOCK(OTHER_LOCK, &toremove_lock[tid]);
Olivier Houchard859dc802019-08-08 15:47:21 +0200494 MT_LIST_DEL((struct mt_list *)&conn->list);
Olivier Houchard4be71902019-07-11 15:49:00 +0200495 HA_SPIN_UNLOCK(OTHER_LOCK, &toremove_lock[tid]);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100496 pool_free(pool_head_connection, conn);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200497}
498
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100499/* Release a conn_stream */
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200500static inline void cs_destroy(struct conn_stream *cs)
501{
Olivier Houchard302f9ef2018-04-13 15:50:27 +0200502 if (cs->conn->mux)
503 cs->conn->mux->detach(cs);
504 else {
505 /* It's too early to have a mux, let's just destroy
506 * the connection
507 */
508 struct connection *conn = cs->conn;
509
510 conn_stop_tracking(conn);
511 conn_full_close(conn);
512 if (conn->destroy_cb)
513 conn->destroy_cb(conn);
514 conn_free(conn);
515 }
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200516 cs_free(cs);
517}
518
Olivier Houcharde2b40b92017-09-13 18:30:23 +0200519/* Returns the conn from a cs. If cs is NULL, returns NULL */
520static inline struct connection *cs_conn(const struct conn_stream *cs)
521{
522 return cs ? cs->conn : NULL;
523}
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200524
Willy Tarreau2e34c112019-07-17 10:48:33 +0200525/* Retrieves the connection's original source address. Returns non-zero on
526 * success or zero on failure. The operation is only performed once and the
527 * address is stored in the connection for future use.
528 */
529static inline int conn_get_src(struct connection *conn)
530{
531 if (conn->flags & CO_FL_ADDR_FROM_SET)
532 return 1;
533
534 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
535 return 0;
536
Willy Tarreauca79f592019-07-17 19:04:47 +0200537 if (!sockaddr_alloc(&conn->src))
538 return 0;
539
Willy Tarreau226572f2019-07-17 14:46:00 +0200540 if (conn->ctrl->get_src(conn->handle.fd, (struct sockaddr *)conn->src,
541 sizeof(*conn->src),
Willy Tarreau2e34c112019-07-17 10:48:33 +0200542 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
543 return 0;
544 conn->flags |= CO_FL_ADDR_FROM_SET;
545 return 1;
546}
547
548/* Retrieves the connection's original destination address. Returns non-zero on
549 * success or zero on failure. The operation is only performed once and the
550 * address is stored in the connection for future use.
551 */
552static inline int conn_get_dst(struct connection *conn)
553{
554 if (conn->flags & CO_FL_ADDR_TO_SET)
555 return 1;
556
557 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
558 return 0;
559
Willy Tarreauca79f592019-07-17 19:04:47 +0200560 if (!sockaddr_alloc(&conn->dst))
561 return 0;
562
Willy Tarreau226572f2019-07-17 14:46:00 +0200563 if (conn->ctrl->get_dst(conn->handle.fd, (struct sockaddr *)conn->dst,
564 sizeof(*conn->dst),
Willy Tarreau2e34c112019-07-17 10:48:33 +0200565 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
566 return 0;
567 conn->flags |= CO_FL_ADDR_TO_SET;
568 return 1;
569}
570
Willy Tarreau1a18b542018-12-11 16:37:42 +0100571/* Sets the TOS header in IPv4 and the traffic class header in IPv6 packets
572 * (as per RFC3260 #4 and BCP37 #4.2 and #5.2). The connection is tested and if
573 * it is null, nothing is done.
574 */
575static inline void conn_set_tos(const struct connection *conn, int tos)
576{
577 if (!conn || !conn_ctrl_ready(conn))
578 return;
579
580#ifdef IP_TOS
Willy Tarreau226572f2019-07-17 14:46:00 +0200581 if (conn->src->ss_family == AF_INET)
Willy Tarreau1a18b542018-12-11 16:37:42 +0100582 setsockopt(conn->handle.fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
583#endif
584#ifdef IPV6_TCLASS
Willy Tarreau226572f2019-07-17 14:46:00 +0200585 if (conn->src->ss_family == AF_INET6) {
586 if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)conn->src)->sin6_addr))
Willy Tarreau1a18b542018-12-11 16:37:42 +0100587 /* v4-mapped addresses need IP_TOS */
588 setsockopt(conn->handle.fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
589 else
590 setsockopt(conn->handle.fd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof(tos));
591 }
592#endif
593}
594
595/* Sets the netfilter mark on the connection's socket. The connection is tested
596 * and if it is null, nothing is done.
597 */
598static inline void conn_set_mark(const struct connection *conn, int mark)
599{
600 if (!conn || !conn_ctrl_ready(conn))
601 return;
602
603#ifdef SO_MARK
604 setsockopt(conn->handle.fd, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
605#endif
606}
607
608/* Sets adjust the TCP quick-ack feature on the connection's socket. The
609 * connection is tested and if it is null, nothing is done.
610 */
611static inline void conn_set_quickack(const struct connection *conn, int value)
612{
613 if (!conn || !conn_ctrl_ready(conn))
614 return;
615
616#ifdef TCP_QUICKACK
617 setsockopt(conn->handle.fd, IPPROTO_TCP, TCP_QUICKACK, &value, sizeof(value));
618#endif
619}
620
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200621/* Attaches a conn_stream to a data layer and sets the relevant callbacks */
622static inline void cs_attach(struct conn_stream *cs, void *data, const struct data_cb *data_cb)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200623{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200624 cs->data_cb = data_cb;
625 cs->data = data;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200626}
627
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200628static 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 +0200629{
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200630 if (!wl->tasklet->process) {
631 wl->tasklet->process = cb;
632 wl->tasklet->context = ctx;
Willy Tarreau83188852018-07-18 08:18:20 +0200633 }
634 return wl;
635}
636
Willy Tarreau53a47662017-08-28 10:53:00 +0200637/* Installs the connection's mux layer for upper context <ctx>.
638 * Returns < 0 on error.
639 */
Willy Tarreau175a2bb2018-09-12 12:02:05 +0200640static inline int conn_install_mux(struct connection *conn, const struct mux_ops *mux,
Olivier Houchardf502aca2018-12-14 19:42:40 +0100641 void *ctx, struct proxy *prx, struct session *sess)
Willy Tarreau53a47662017-08-28 10:53:00 +0200642{
Willy Tarreau762475e2019-01-10 10:33:32 +0100643 int ret;
644
Willy Tarreau53a47662017-08-28 10:53:00 +0200645 conn->mux = mux;
Willy Tarreau3d2ee552018-12-19 14:12:10 +0100646 conn->ctx = ctx;
Christopher Faulet51f73eb2019-04-08 11:22:47 +0200647 ret = mux->init ? mux->init(conn, prx, sess, &BUF_NULL) : 0;
Willy Tarreau762475e2019-01-10 10:33:32 +0100648 if (ret < 0) {
649 conn->mux = NULL;
650 conn->ctx = NULL;
651 }
652 return ret;
Willy Tarreau53a47662017-08-28 10:53:00 +0200653}
654
Willy Tarreau0af29122012-12-03 15:35:00 +0100655/* returns a human-readable error code for conn->err_code, or NULL if the code
656 * is unknown.
657 */
658static inline const char *conn_err_code_str(struct connection *c)
659{
660 switch (c->err_code) {
661 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100662
663 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
664 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
665 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
666 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
667 case CO_ER_NOPROTO: return "Protocol or address family not supported";
668 case CO_ER_SOCK_ERR: return "General socket error";
669 case CO_ER_PORT_RANGE: return "Source port range exhausted";
670 case CO_ER_CANT_BIND: return "Can't bind to source address";
671 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
672 case CO_ER_ADDR_INUSE: return "Local source address already in use";
673
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100674 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
675 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100676 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100677 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
678 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
679 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
680 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100681
682 case CO_ER_CIP_EMPTY: return "Connection closed while waiting for NetScaler Client IP header";
683 case CO_ER_CIP_ABORT: return "Connection error while waiting for NetScaler Client IP header";
684 case CO_ER_CIP_TRUNCATED: return "Truncated NetScaler Client IP header received";
685 case CO_ER_CIP_BAD_MAGIC: return "Received an invalid NetScaler Client IP magic number";
686 case CO_ER_CIP_BAD_PROTO: return "Received an unhandled protocol in the NetScaler Client IP header";
687
Willy Tarreau20879a02012-12-03 16:32:10 +0100688 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
689 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100690 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100691 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
692 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500693 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegotiation attempt";
Willy Tarreau20879a02012-12-03 16:32:10 +0100694 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
695 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
Willy Tarreau71d058c2017-07-26 20:09:56 +0200696 case CO_ER_SSL_MISMATCH: return "Server presented an SSL certificate different from the configured one";
697 case CO_ER_SSL_MISMATCH_SNI: return "Server presented an SSL certificate different from the expected one";
Willy Tarreau20879a02012-12-03 16:32:10 +0100698 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200699 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200700 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100701 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Alexander Liu2a54bb72019-05-22 19:44:48 +0800702
703 case CO_ER_SOCKS4_SEND: return "SOCKS4 Proxy write error during handshake";
704 case CO_ER_SOCKS4_RECV: return "SOCKS4 Proxy read error during handshake";
705 case CO_ER_SOCKS4_DENY: return "SOCKS4 Proxy deny the request";
706 case CO_ER_SOCKS4_ABORT: return "SOCKS4 Proxy handshake aborted by server";
Willy Tarreau0af29122012-12-03 15:35:00 +0100707 }
708 return NULL;
709}
710
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100711static inline const char *conn_get_ctrl_name(const struct connection *conn)
712{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200713 if (!conn || !conn_ctrl_ready(conn))
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100714 return "NONE";
715 return conn->ctrl->name;
716}
717
718static inline const char *conn_get_xprt_name(const struct connection *conn)
719{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200720 if (!conn || !conn_xprt_ready(conn))
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100721 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100722 return conn->xprt->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100723}
724
Willy Tarreau53a47662017-08-28 10:53:00 +0200725static inline const char *conn_get_mux_name(const struct connection *conn)
726{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200727 if (!conn || !conn->mux)
Willy Tarreau53a47662017-08-28 10:53:00 +0200728 return "NONE";
729 return conn->mux->name;
730}
731
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200732static inline const char *cs_get_data_name(const struct conn_stream *cs)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100733{
Willy Tarreau5e6a5b32019-04-25 18:35:49 +0200734 if (!cs || !cs->data_cb)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100735 return "NONE";
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200736 return cs->data_cb->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100737}
738
Willy Tarreau13e14102016-12-22 20:25:26 +0100739/* registers pointer to transport layer <id> (XPRT_*) */
740static inline void xprt_register(int id, struct xprt_ops *xprt)
741{
742 if (id >= XPRT_ENTRIES)
743 return;
744 registered_xprt[id] = xprt;
745}
746
747/* returns pointer to transport layer <id> (XPRT_*) or NULL if not registered */
748static inline struct xprt_ops *xprt_get(int id)
749{
750 if (id >= XPRT_ENTRIES)
751 return NULL;
752 return registered_xprt[id];
753}
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100754
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200755/* Try to add a handshake pseudo-XPRT. If the connection's first XPRT is
756 * raw_sock, then just use the new XPRT as the connection XPRT, otherwise
757 * call the xprt's add_xprt() method.
758 * Returns 0 on success, or non-zero on failure.
759 */
760static inline int xprt_add_hs(struct connection *conn)
761{
762 void *xprt_ctx = NULL;
763 const struct xprt_ops *ops = xprt_get(XPRT_HANDSHAKE);
764 void *nextxprt_ctx = NULL;
765 const struct xprt_ops *nextxprt_ops = NULL;
766
767 if (conn->flags & CO_FL_ERROR)
768 return -1;
769 if (ops->init(conn, &xprt_ctx) < 0)
770 return -1;
771 if (conn->xprt == xprt_get(XPRT_RAW)) {
772 nextxprt_ctx = conn->xprt_ctx;
773 nextxprt_ops = conn->xprt;
774 conn->xprt_ctx = xprt_ctx;
775 conn->xprt = ops;
776 } else {
777 if (conn->xprt->add_xprt(conn, conn->xprt_ctx, xprt_ctx, ops,
778 &nextxprt_ctx, &nextxprt_ops) != 0) {
779 ops->close(conn, xprt_ctx);
780 return -1;
781 }
782 }
783 if (ops->add_xprt(conn, xprt_ctx, nextxprt_ctx, nextxprt_ops, NULL, NULL) != 0) {
784 ops->close(conn, xprt_ctx);
785 return -1;
786 }
787 return 0;
788}
789
Willy Tarreaua9c17412016-12-04 18:42:09 +0100790static inline int conn_get_alpn(const struct connection *conn, const char **str, int *len)
791{
792 if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn)
793 return 0;
Olivier Houcharde179d0e2019-03-21 18:27:17 +0100794 return conn->xprt->get_alpn(conn, conn->xprt_ctx, str, len);
Willy Tarreaua9c17412016-12-04 18:42:09 +0100795}
796
Christopher Faulet32f61c02018-04-10 14:33:41 +0200797/* registers proto mux list <list>. Modifies the list element! */
798static inline void register_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200799{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200800 LIST_ADDQ(&mux_proto_list.list, &list->list);
Willy Tarreau2386be62017-09-21 19:40:52 +0200801}
802
Christopher Faulet32f61c02018-04-10 14:33:41 +0200803/* unregisters proto mux list <list> */
804static inline void unregister_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200805{
806 LIST_DEL(&list->list);
807 LIST_INIT(&list->list);
808}
809
Christopher Faulete15c6c42018-08-08 10:21:56 +0200810static inline struct mux_proto_list *get_mux_proto(const struct ist proto)
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200811{
812 struct mux_proto_list *item;
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200813
814 list_for_each_entry(item, &mux_proto_list.list, list) {
815 if (isteq(proto, item->token))
816 return item;
817 }
818 return NULL;
819}
820
821/* Lists the known proto mux on <out> */
822static inline void list_mux_proto(FILE *out)
823{
824 struct mux_proto_list *item;
825 struct ist proto;
826 char *mode, *side;
827
Christopher Faulet9c9ef032018-08-08 10:25:57 +0200828 fprintf(out, "Available multiplexer protocols :\n"
Willy Tarreaud3c49d12018-11-30 16:52:32 +0100829 "(protocols marked as <default> cannot be specified using 'proto' keyword)\n");
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200830 list_for_each_entry(item, &mux_proto_list.list, list) {
831 proto = item->token;
832
833 if (item->mode == PROTO_MODE_ANY)
834 mode = "TCP|HTTP";
835 else if (item->mode == PROTO_MODE_TCP)
836 mode = "TCP";
837 else if (item->mode == PROTO_MODE_HTTP)
838 mode = "HTTP";
839 else
840 mode = "NONE";
841
842 if (item->side == PROTO_SIDE_BOTH)
843 side = "FE|BE";
844 else if (item->side == PROTO_SIDE_FE)
845 side = "FE";
846 else if (item->side == PROTO_SIDE_BE)
847 side = "BE";
848 else
849 side = "NONE";
850
Willy Tarreauca2a3cc2019-05-22 11:44:03 +0200851 fprintf(out, " %15s : mode=%-10s side=%-8s mux=%s\n",
852 (proto.len ? proto.ptr : "<default>"), mode, side, item->mux->name);
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200853 }
854}
855
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100856/* returns the first mux entry in the list matching the exact same <mux_proto>
857 * and compatible with the <proto_side> (FE or BE) and the <proto_mode> (TCP or
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200858 * HTTP). <mux_proto> can be empty. Will fall back to the first compatible mux
859 * with exactly the same <proto_mode> or with an empty name. May return
860 * null if the code improperly registered the default mux to use as a fallback.
Willy Tarreau2386be62017-09-21 19:40:52 +0200861 */
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100862static inline const struct mux_proto_list *conn_get_best_mux_entry(
863 const struct ist mux_proto,
864 int proto_side, int proto_mode)
Willy Tarreau2386be62017-09-21 19:40:52 +0200865{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200866 struct mux_proto_list *item;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200867 struct mux_proto_list *fallback = NULL;
Willy Tarreau2386be62017-09-21 19:40:52 +0200868
Christopher Faulet32f61c02018-04-10 14:33:41 +0200869 list_for_each_entry(item, &mux_proto_list.list, list) {
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200870 if (!(item->side & proto_side) || !(item->mode & proto_mode))
Willy Tarreau2386be62017-09-21 19:40:52 +0200871 continue;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200872 if (istlen(mux_proto) && isteq(mux_proto, item->token))
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100873 return item;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200874 else if (!istlen(item->token)) {
875 if (!fallback || (item->mode == proto_mode && fallback->mode != proto_mode))
876 fallback = item;
877 }
Willy Tarreau2386be62017-09-21 19:40:52 +0200878 }
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100879 return fallback;
880
881}
882
883/* returns the first mux in the list matching the exact same <mux_proto> and
884 * compatible with the <proto_side> (FE or BE) and the <proto_mode> (TCP or
885 * HTTP). <mux_proto> can be empty. Will fall back to the first compatible mux
886 * with exactly the same <proto_mode> or with an empty name. May return
887 * null if the code improperly registered the default mux to use as a fallback.
888 */
889static inline const struct mux_ops *conn_get_best_mux(struct connection *conn,
890 const struct ist mux_proto,
891 int proto_side, int proto_mode)
892{
893 const struct mux_proto_list *item;
894
895 item = conn_get_best_mux_entry(mux_proto, proto_side, proto_mode);
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200896
Willy Tarreau5fc311c2018-12-02 13:04:43 +0100897 return item ? item->mux : NULL;
Willy Tarreau2386be62017-09-21 19:40:52 +0200898}
899
Willy Tarreau57f81852018-09-06 14:52:21 +0200900/* returns 0 if the connection is valid and is a frontend connection, otherwise
901 * returns 1 indicating it's a backend connection. And uninitialized connection
902 * also returns 1 to better handle the usage in the middle of initialization.
903 */
904static inline int conn_is_back(const struct connection *conn)
905{
906 return !objt_listener(conn->target);
907}
908
Willy Tarreau6ac98ac2018-09-06 11:48:44 +0200909/* returns a pointer to the proxy associated with this connection. For a front
910 * connection it returns a pointer to the frontend ; for a back connection, it
911 * returns a pointer to the backend.
912 */
913static inline struct proxy *conn_get_proxy(const struct connection *conn)
914{
915 struct listener *l;
916 struct server *s;
917
918 /* check if it's a frontend connection */
919 l = objt_listener(conn->target);
920 if (l)
921 return l->bind_conf->frontend;
922
923 /* check if it's a backend connection */
924 s = objt_server(conn->target);
925 if (s)
926 return s->proxy;
927
928 return objt_proxy(conn->target);
929}
930
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200931/* installs the best mux for incoming connection <conn> using the upper context
932 * <ctx>. If the mux protocol is forced, we use it to find the best
933 * mux. Otherwise we use the ALPN name, if any. Returns < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +0200934 */
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200935static inline int conn_install_mux_fe(struct connection *conn, void *ctx)
Willy Tarreau2386be62017-09-21 19:40:52 +0200936{
Willy Tarreau55e0da62018-09-20 11:26:52 +0200937 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200938 const struct mux_ops *mux_ops;
Willy Tarreau2386be62017-09-21 19:40:52 +0200939
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200940 if (bind_conf->mux_proto)
941 mux_ops = bind_conf->mux_proto->mux;
942 else {
943 struct ist mux_proto;
944 const char *alpn_str = NULL;
945 int alpn_len = 0;
Willy Tarreau68ad3a42018-10-22 11:49:15 +0200946 int mode;
947
Christopher Fauletc1918d12019-04-24 15:01:22 +0200948 if (bind_conf->frontend->mode == PR_MODE_HTTP)
Christopher Fauletc985f6c2019-07-15 11:42:52 +0200949 mode = PROTO_MODE_HTTP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +0200950 else
Christopher Fauletc1918d12019-04-24 15:01:22 +0200951 mode = PROTO_MODE_TCP;
Willy Tarreau2386be62017-09-21 19:40:52 +0200952
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200953 conn_get_alpn(conn, &alpn_str, &alpn_len);
954 mux_proto = ist2(alpn_str, alpn_len);
955 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_FE, mode);
956 if (!mux_ops)
957 return -1;
958 }
Olivier Houchardf502aca2018-12-14 19:42:40 +0100959 return conn_install_mux(conn, mux_ops, ctx, bind_conf->frontend, conn->owner);
Willy Tarreau2386be62017-09-21 19:40:52 +0200960}
961
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200962/* installs the best mux for outgoing connection <conn> using the upper context
963 * <ctx>. If the mux protocol is forced, we use it to find the best mux. Returns
Willy Tarreau2e0b2b52017-09-15 06:59:55 +0200964 * < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +0200965 */
Olivier Houchardf502aca2018-12-14 19:42:40 +0100966static inline int conn_install_mux_be(struct connection *conn, void *ctx, struct session *sess)
Willy Tarreau2386be62017-09-21 19:40:52 +0200967{
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200968 struct server *srv = objt_server(conn->target);
Willy Tarreau287527a2018-08-08 18:40:44 +0200969 struct proxy *prx = objt_proxy(conn->target);
Willy Tarreau2386be62017-09-21 19:40:52 +0200970 const struct mux_ops *mux_ops;
971
Willy Tarreau287527a2018-08-08 18:40:44 +0200972 if (srv)
973 prx = srv->proxy;
974
975 if (!prx) // target must be either proxy or server
976 return -1;
977
978 if (srv && srv->mux_proto)
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200979 mux_ops = srv->mux_proto->mux;
980 else {
Olivier Houchard201b9f42018-11-21 00:16:29 +0100981 struct ist mux_proto;
982 const char *alpn_str = NULL;
983 int alpn_len = 0;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200984 int mode;
985
Christopher Fauletc1918d12019-04-24 15:01:22 +0200986 if (prx->mode == PR_MODE_HTTP)
Christopher Fauletc985f6c2019-07-15 11:42:52 +0200987 mode = PROTO_MODE_HTTP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +0200988 else
Christopher Fauletc1918d12019-04-24 15:01:22 +0200989 mode = PROTO_MODE_TCP;
Willy Tarreau68ad3a42018-10-22 11:49:15 +0200990
Olivier Houchard201b9f42018-11-21 00:16:29 +0100991 conn_get_alpn(conn, &alpn_str, &alpn_len);
992 mux_proto = ist2(alpn_str, alpn_len);
993
994 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_BE, mode);
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200995 if (!mux_ops)
996 return -1;
997 }
Olivier Houchardf502aca2018-12-14 19:42:40 +0100998 return conn_install_mux(conn, mux_ops, ctx, prx, sess);
Willy Tarreau2386be62017-09-21 19:40:52 +0200999}
1000
Christopher Fauleta9e1c4c2020-04-21 12:18:05 +02001001/* installs the best mux for outgoing connection <conn> for a check using the
1002 * upper context <ctx>. If the mux protocol is forced by the check, we use it to
1003 * find the best mux. Returns < 0 on error.
1004 */
1005static inline int conn_install_mux_chk(struct connection *conn, void *ctx, struct session *sess)
1006{
1007 struct check *check = objt_check(sess->origin);
1008 struct server *srv = objt_server(conn->target);
1009 struct proxy *prx = objt_proxy(conn->target);
1010 const struct mux_ops *mux_ops;
1011
1012 if (!check) // Check must be defined
1013 return -1;
1014
1015 if (srv)
1016 prx = srv->proxy;
1017
1018 if (!prx) // target must be either proxy or server
1019 return -1;
1020
1021 if (check->mux_proto)
1022 mux_ops = check->mux_proto->mux;
1023 else {
1024 struct ist mux_proto;
1025 const char *alpn_str = NULL;
1026 int alpn_len = 0;
1027 int mode;
1028
1029 if ((check->tcpcheck_rules->flags & TCPCHK_RULES_PROTO_CHK) == TCPCHK_RULES_HTTP_CHK)
1030 mode = PROTO_MODE_HTTP;
1031 else
1032 mode = PROTO_MODE_TCP;
1033
1034 conn_get_alpn(conn, &alpn_str, &alpn_len);
1035 mux_proto = ist2(alpn_str, alpn_len);
1036
1037 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_BE, mode);
1038 if (!mux_ops)
1039 return -1;
1040 }
1041 return conn_install_mux(conn, mux_ops, ctx, prx, sess);
1042}
1043
Olivier Houchard2ab3dad2019-07-03 13:08:18 +02001044/* Change the mux for the connection.
1045 * The caller should make sure he's not subscribed to the underlying XPRT.
1046 */
Christopher Fauletc0016d82019-04-08 10:42:41 +02001047static inline int conn_upgrade_mux_fe(struct connection *conn, void *ctx, struct buffer *buf,
1048 struct ist mux_proto, int mode)
1049{
1050 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
1051 const struct mux_ops *old_mux, *new_mux;
1052 void *old_mux_ctx;
1053 const char *alpn_str = NULL;
1054 int alpn_len = 0;
1055
1056 if (!mux_proto.len) {
1057 conn_get_alpn(conn, &alpn_str, &alpn_len);
1058 mux_proto = ist2(alpn_str, alpn_len);
1059 }
1060 new_mux = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_FE, mode);
1061 old_mux = conn->mux;
1062
1063 /* No mux found */
1064 if (!new_mux)
1065 return -1;
1066
1067 /* Same mux, nothing to do */
1068 if (old_mux == new_mux)
1069 return 0;
1070
1071 old_mux_ctx = conn->ctx;
1072 conn->mux = new_mux;
1073 conn->ctx = ctx;
Christopher Fauletc0016d82019-04-08 10:42:41 +02001074 if (new_mux->init(conn, bind_conf->frontend, conn->owner, buf) == -1) {
1075 /* The mux upgrade failed, so restore the old mux */
1076 conn->ctx = old_mux_ctx;
1077 conn->mux = old_mux;
1078 return -1;
1079 }
1080
1081 /* The mux was upgraded, destroy the old one */
1082 *buf = BUF_NULL;
1083 old_mux->destroy(old_mux_ctx);
1084 return 0;
1085}
1086
Willy Tarreau59f98392012-07-06 14:13:49 +02001087#endif /* _PROTO_CONNECTION_H */
1088
1089/*
1090 * Local variables:
1091 * c-indent-level: 8
1092 * c-basic-offset: 8
1093 * End:
1094 */