blob: 11d4aa47d374a346fe99fd746f43e6e20928a10d [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 Houchard6ff20392018-07-17 18:46:31 +020032#include <proto/task.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020033
Willy Tarreaubafbe012017-11-24 17:34:44 +010034extern struct pool_head *pool_head_connection;
35extern struct pool_head *pool_head_connstream;
Willy Tarreau13e14102016-12-22 20:25:26 +010036extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
Christopher Faulet32f61c02018-04-10 14:33:41 +020037extern struct mux_proto_list mux_proto_list;
Willy Tarreauf2943dc2012-10-26 20:10:28 +020038
39/* perform minimal intializations, report 0 in case of error, 1 if OK. */
40int init_connection();
41
Willy Tarreau59f98392012-07-06 14:13:49 +020042/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020043 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020044 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020045void conn_fd_handler(int fd);
Willy Tarreau59f98392012-07-06 14:13:49 +020046
Willy Tarreau22cda212012-08-31 17:43:29 +020047/* receive a PROXY protocol header over a connection */
48int conn_recv_proxy(struct connection *conn, int flag);
David Safb76832014-05-08 23:42:08 -040049int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote);
50int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
51int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
Willy Tarreau22cda212012-08-31 17:43:29 +020052
Olivier Houchard6ff20392018-07-17 18:46:31 +020053int conn_subscribe(struct connection *conn, int event_type, void *param);
Olivier Houchard83a0cd82018-09-28 17:57:58 +020054int conn_unsubscribe(struct connection *conn, int event_type, void *param);
55
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010056/* receive a NetScaler Client IP insertion header over a connection */
57int conn_recv_netscaler_cip(struct connection *conn, int flag);
58
Willy Tarreauff3e6482015-03-12 23:56:52 +010059/* raw send() directly on the socket */
60int conn_sock_send(struct connection *conn, const void *buf, int len, int flags);
61
Willy Tarreaud85c4852015-03-13 00:40:28 +010062/* drains any pending bytes from the socket */
63int conn_sock_drain(struct connection *conn);
64
Willy Tarreaud02cdd22013-12-15 10:23:20 +010065/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010066static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010067{
Willy Tarreauaad69382014-01-23 14:21:42 +010068 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010069}
70
71/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010072static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010073{
74 return (conn->flags & CO_FL_CTRL_READY);
75}
76
Willy Tarreauf79c8172013-10-21 16:30:56 +020077/* Calls the init() function of the transport layer if any and if not done yet,
78 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020079 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020080 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020081static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020082{
Willy Tarreauf79c8172013-10-21 16:30:56 +020083 int ret = 0;
84
Willy Tarreauaad69382014-01-23 14:21:42 +010085 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Willy Tarreauf79c8172013-10-21 16:30:56 +020086 ret = conn->xprt->init(conn);
87
88 if (ret >= 0)
89 conn->flags |= CO_FL_XPRT_READY;
90
91 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020092}
93
Willy Tarreauf79c8172013-10-21 16:30:56 +020094/* Calls the close() function of the transport layer if any and if not done
95 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
96 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
97 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +020098 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020099static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +0200100{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200101 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +0100102 if (conn->xprt->close)
Willy Tarreau6c03a642012-10-12 17:00:05 +0200103 conn->xprt->close(conn);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200104 conn->flags &= ~CO_FL_XPRT_READY;
105 }
106}
107
108/* Initializes the connection's control layer which essentially consists in
109 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +0100110 * flag. The caller is responsible for ensuring that the control layer is
111 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200112 */
113static inline void conn_ctrl_init(struct connection *conn)
114{
Willy Tarreau3c728722014-01-23 13:50:42 +0100115 if (!conn_ctrl_ready(conn)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200116 int fd = conn->handle.fd;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200117
Willy Tarreaua9786b62018-01-25 07:22:13 +0100118 fd_insert(fd, conn, conn_fd_handler, tid_bit);
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100119 /* mark the fd as ready so as not to needlessly poll at the beginning */
120 fd_may_recv(fd);
121 fd_may_send(fd);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200122 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200123 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200124}
125
Willy Tarreauf79c8172013-10-21 16:30:56 +0200126/* Deletes the FD if the transport layer is already gone. Once done,
127 * it then removes the CO_FL_CTRL_READY flag.
128 */
129static inline void conn_ctrl_close(struct connection *conn)
130{
131 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200132 fd_delete(conn->handle.fd);
Willy Tarreau6a0a80a2017-10-05 17:43:39 +0200133 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200134 conn->flags &= ~CO_FL_CTRL_READY;
135 }
136}
137
Willy Tarreau2b199c92012-11-23 17:32:21 +0100138/* If the connection still has a transport layer, then call its close() function
139 * if any, and delete the file descriptor if a control layer is set. This is
140 * used to close everything at once and atomically. However this is not done if
141 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
142 * transport layer very late if needed.
143 */
144static inline void conn_full_close(struct connection *conn)
145{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200146 conn_xprt_close(conn);
147 conn_ctrl_close(conn);
148}
149
Willy Tarreaudc42acd2017-10-05 18:09:20 +0200150/* stop tracking a connection, allowing conn_full_close() to always
151 * succeed.
152 */
153static inline void conn_stop_tracking(struct connection *conn)
154{
155 conn->flags &= ~CO_FL_XPRT_TRACKED;
156}
157
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200158/* Update polling on connection <c>'s file descriptor depending on its current
159 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
160 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
161 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200162 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200163 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200164void conn_update_sock_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200165
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200166/* Update polling on connection <c>'s file descriptor depending on its current
167 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200168 * in CO_FL_WAIT_*, and the upper layer expectations indicated by CO_FL_XPRT_*.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200169 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200170 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200171 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200172void conn_update_xprt_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200173
Willy Tarreau7d281492012-12-16 19:19:13 +0100174/* Refresh the connection's polling flags from its file descriptor status.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200175 * This should be called at the beginning of a connection handler. It does
176 * nothing if CO_FL_WILL_UPDATE is present, indicating that an upper caller
177 * has already done it.
Willy Tarreau7d281492012-12-16 19:19:13 +0100178 */
179static inline void conn_refresh_polling_flags(struct connection *conn)
180{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200181 if (conn_ctrl_ready(conn) && !(conn->flags & CO_FL_WILL_UPDATE)) {
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200182 unsigned int flags = conn->flags;
Willy Tarreau7d281492012-12-16 19:19:13 +0100183
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200184 flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA | CO_FL_WAIT_ROOM);
Willy Tarreau585744b2017-08-24 14:31:19 +0200185 if (fd_recv_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100186 flags |= CO_FL_CURR_RD_ENA;
Willy Tarreau585744b2017-08-24 14:31:19 +0200187 if (fd_send_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100188 flags |= CO_FL_CURR_WR_ENA;
189 conn->flags = flags;
190 }
191}
192
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200193/* inspects c->flags and returns non-zero if XPRT ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100194 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200195 * non-zero is also returned if an error was reported on the connection. This
196 * function is used quite often and is inlined. In order to proceed optimally
197 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100198 * can be detected by a few left shifts, a xor, and a mask. These operations
199 * detect when W&D are both enabled for either direction, when C&D differ for
200 * either direction and when Error is set. The trick consists in first keeping
201 * only the bits we're interested in, since they don't collide when shifted,
202 * and to perform the AND at the end. In practice, the compiler is able to
203 * replace the last AND with a TEST in boolean conditions. This results in
204 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200205 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200206static inline unsigned int conn_xprt_polling_changes(const struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200207{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100208 unsigned int f = c->flags;
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200209 f &= CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100210 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100211
Willy Tarreau310987a2014-01-22 19:46:33 +0100212 f = (f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ D */
213 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200214}
215
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200216/* inspects c->flags and returns non-zero if SOCK ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100217 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200218 * non-zero is also returned if an error was reported on the connection. This
219 * function is used quite often and is inlined. In order to proceed optimally
220 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100221 * can be detected by a few left shifts, a xor, and a mask. These operations
222 * detect when W&S are both enabled for either direction, when C&S differ for
223 * either direction and when Error is set. The trick consists in first keeping
224 * only the bits we're interested in, since they don't collide when shifted,
225 * and to perform the AND at the end. In practice, the compiler is able to
226 * replace the last AND with a TEST in boolean conditions. This results in
227 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200228 */
229static inline unsigned int conn_sock_polling_changes(const struct connection *c)
230{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100231 unsigned int f = c->flags;
232 f &= CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100233 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100234
Willy Tarreau310987a2014-01-22 19:46:33 +0100235 f = (f ^ (f << 2)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ S */
236 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200237}
238
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200239/* Automatically updates polling on connection <c> depending on the XPRT flags
Willy Tarreau916e12d2017-10-25 09:22:43 +0200240 * if no handshake is in progress. It does nothing if CO_FL_WILL_UPDATE is
241 * present, indicating that an upper caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200242 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200243static inline void conn_cond_update_xprt_polling(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200244{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200245 if (!(c->flags & CO_FL_WILL_UPDATE))
246 if (!(c->flags & CO_FL_POLL_SOCK) && conn_xprt_polling_changes(c))
247 conn_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200248}
249
250/* Automatically updates polling on connection <c> depending on the SOCK flags
Willy Tarreau916e12d2017-10-25 09:22:43 +0200251 * if a handshake is in progress. It does nothing if CO_FL_WILL_UPDATE is
252 * present, indicating that an upper caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200253 */
254static inline void conn_cond_update_sock_polling(struct connection *c)
255{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200256 if (!(c->flags & CO_FL_WILL_UPDATE))
257 if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
258 conn_update_sock_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200259}
260
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100261/* Stop all polling on the fd. This might be used when an error is encountered
Willy Tarreau916e12d2017-10-25 09:22:43 +0200262 * for example. It does not propage the change to the fd layer if
263 * CO_FL_WILL_UPDATE is present, indicating that an upper caller is going to do
264 * it later.
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100265 */
266static inline void conn_stop_polling(struct connection *c)
267{
268 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
269 CO_FL_SOCK_RD_ENA | CO_FL_SOCK_WR_ENA |
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200270 CO_FL_XPRT_RD_ENA | CO_FL_XPRT_WR_ENA);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200271 if (!(c->flags & CO_FL_WILL_UPDATE) && conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200272 fd_stop_both(c->handle.fd);
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100273}
274
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200275/* Automatically update polling on connection <c> depending on the XPRT and
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200276 * SOCK flags, and on whether a handshake is in progress or not. This may be
277 * called at any moment when there is a doubt about the effectiveness of the
278 * polling state, for instance when entering or leaving the handshake state.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200279 * It does nothing if CO_FL_WILL_UPDATE is present, indicating that an upper
280 * caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200281 */
282static inline void conn_cond_update_polling(struct connection *c)
283{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100284 if (unlikely(c->flags & CO_FL_ERROR))
285 conn_stop_polling(c);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200286 else if (!(c->flags & CO_FL_WILL_UPDATE)) {
287 if (!(c->flags & CO_FL_POLL_SOCK) && conn_xprt_polling_changes(c))
288 conn_update_xprt_polling(c);
289 else if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
290 conn_update_sock_polling(c);
291 }
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200292}
293
294/***** Event manipulation primitives for use by DATA I/O callbacks *****/
295/* The __conn_* versions do not propagate to lower layers and are only meant
296 * to be used by handlers called by the connection handler. The other ones
297 * may be used anywhere.
298 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200299static inline void __conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200300{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200301 c->flags |= CO_FL_XPRT_RD_ENA;
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 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200307}
308
Willy Tarreau796c5b72016-11-29 21:47:02 +0100309/* this one is used only to stop speculative recv(). It doesn't stop it if the
310 * fd is already polled in order to avoid expensive polling status changes.
311 * Since it might require the upper layer to re-enable reading, we'll return 1
312 * if we've really stopped something otherwise zero.
313 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200314static inline int __conn_xprt_done_recv(struct connection *c)
Willy Tarreau796c5b72016-11-29 21:47:02 +0100315{
Willy Tarreau585744b2017-08-24 14:31:19 +0200316 if (!conn_ctrl_ready(c) || !fd_recv_polled(c->handle.fd)) {
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200317 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreau796c5b72016-11-29 21:47:02 +0100318 return 1;
319 }
320 return 0;
321}
322
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200323static inline void __conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200324{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200325 c->flags |= CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200326}
327
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200328static inline void __conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200329{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200330 c->flags &= ~CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200331}
332
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200333static inline void __conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200334{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200335 c->flags &= ~(CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200336}
337
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200338static inline void conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200339{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200340 __conn_xprt_want_recv(c);
341 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200342}
343
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200344static inline void conn_xprt_stop_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200345{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200346 __conn_xprt_stop_recv(c);
347 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200348}
349
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200350static inline void conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200351{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200352 __conn_xprt_want_send(c);
353 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200354}
355
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200356static inline void conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200357{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200358 __conn_xprt_stop_send(c);
359 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200360}
361
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200362static inline void conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200363{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200364 __conn_xprt_stop_both(c);
365 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200366}
367
368/***** Event manipulation primitives for use by handshake I/O callbacks *****/
369/* The __conn_* versions do not propagate to lower layers and are only meant
370 * to be used by handlers called by the connection handler. The other ones
371 * may be used anywhere.
372 */
373static inline void __conn_sock_want_recv(struct connection *c)
374{
375 c->flags |= CO_FL_SOCK_RD_ENA;
376}
377
378static inline void __conn_sock_stop_recv(struct connection *c)
379{
380 c->flags &= ~CO_FL_SOCK_RD_ENA;
381}
382
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200383static inline void __conn_sock_want_send(struct connection *c)
384{
385 c->flags |= CO_FL_SOCK_WR_ENA;
386}
387
388static inline void __conn_sock_stop_send(struct connection *c)
389{
390 c->flags &= ~CO_FL_SOCK_WR_ENA;
391}
392
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200393static inline void __conn_sock_stop_both(struct connection *c)
394{
395 c->flags &= ~(CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA);
396}
397
398static inline void conn_sock_want_recv(struct connection *c)
399{
400 __conn_sock_want_recv(c);
401 conn_cond_update_sock_polling(c);
402}
403
404static inline void conn_sock_stop_recv(struct connection *c)
405{
406 __conn_sock_stop_recv(c);
407 conn_cond_update_sock_polling(c);
408}
409
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200410static inline void conn_sock_want_send(struct connection *c)
411{
412 __conn_sock_want_send(c);
413 conn_cond_update_sock_polling(c);
414}
415
416static inline void conn_sock_stop_send(struct connection *c)
417{
418 __conn_sock_stop_send(c);
419 conn_cond_update_sock_polling(c);
420}
421
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200422static inline void conn_sock_stop_both(struct connection *c)
423{
424 __conn_sock_stop_both(c);
425 conn_cond_update_sock_polling(c);
426}
Willy Tarreau8b117082012-08-06 15:06:49 +0200427
Willy Tarreau7b271b22017-10-25 09:59:22 +0200428/* read shutdown, called from the rcv_buf/rcv_pipe handlers when
429 * detecting an end of connection.
430 */
Willy Tarreau3af56a92012-08-20 16:55:48 +0200431static inline void conn_sock_read0(struct connection *c)
432{
433 c->flags |= CO_FL_SOCK_RD_SH;
434 __conn_sock_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100435 /* we don't risk keeping ports unusable if we found the
436 * zero from the other side.
437 */
Willy Tarreau3c728722014-01-23 13:50:42 +0100438 if (conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200439 fdtab[c->handle.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200440}
441
Willy Tarreau7b271b22017-10-25 09:59:22 +0200442/* write shutdown, indication that the upper layer is not willing to send
Willy Tarreaua48c1412017-12-22 18:46:33 +0100443 * anything anymore and wants to close after pending data are sent. The
444 * <clean> argument will allow not to perform the socket layer shutdown if
445 * equal to 0.
Willy Tarreau7b271b22017-10-25 09:59:22 +0200446 */
Willy Tarreaua48c1412017-12-22 18:46:33 +0100447static inline void conn_sock_shutw(struct connection *c, int clean)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200448{
449 c->flags |= CO_FL_SOCK_WR_SH;
Willy Tarreau7b271b22017-10-25 09:59:22 +0200450 conn_refresh_polling_flags(c);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200451 __conn_sock_stop_send(c);
Willy Tarreau7b271b22017-10-25 09:59:22 +0200452 conn_cond_update_sock_polling(c);
453
Willy Tarreaua48c1412017-12-22 18:46:33 +0100454 /* don't perform a clean shutdown if we're going to reset or
455 * if the shutr was already received.
456 */
457 if (conn_ctrl_ready(c) && !(c->flags & CO_FL_SOCK_RD_SH) && clean)
Willy Tarreau585744b2017-08-24 14:31:19 +0200458 shutdown(c->handle.fd, SHUT_WR);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200459}
460
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200461static inline void conn_xprt_shutw(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200462{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200463 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100464
465 /* clean data-layer shutdown */
466 if (c->xprt && c->xprt->shutw)
467 c->xprt->shutw(c, 1);
468}
469
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200470static inline void conn_xprt_shutw_hard(struct connection *c)
Willy Tarreau729c69f2015-03-12 22:51:10 +0100471{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200472 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100473
474 /* unclean data-layer shutdown */
475 if (c->xprt && c->xprt->shutw)
476 c->xprt->shutw(c, 0);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200477}
478
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200479/* shut read */
480static inline void cs_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200481{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200482
483 /* clean data-layer shutdown */
484 if (cs->conn->mux && cs->conn->mux->shutr)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200485 cs->conn->mux->shutr(cs, mode);
486 cs->flags |= (mode == CS_SHR_DRAIN) ? CS_FL_SHRD : CS_FL_SHRR;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200487}
488
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200489/* shut write */
490static inline void cs_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200491{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200492
493 /* clean data-layer shutdown */
494 if (cs->conn->mux && cs->conn->mux->shutw)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200495 cs->conn->mux->shutw(cs, mode);
496 cs->flags |= (mode == CS_SHW_NORMAL) ? CS_FL_SHWN : CS_FL_SHWS;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200497}
498
Willy Tarreau6978db32017-10-05 18:19:43 +0200499/* completely close a conn_stream (but do not detach it) */
500static inline void cs_close(struct conn_stream *cs)
501{
502 cs_shutw(cs, CS_SHW_SILENT);
503 cs_shutr(cs, CS_SHR_RESET);
504 cs->flags = CS_FL_NONE;
505}
506
Willy Tarreau3af56a92012-08-20 16:55:48 +0200507/* detect sock->data read0 transition */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200508static inline int conn_xprt_read0_pending(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200509{
Willy Tarreau54e917c2017-08-30 07:35:35 +0200510 return (c->flags & CO_FL_SOCK_RD_SH) != 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200511}
512
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200513/* prepares a connection to work with protocol <proto> and transport <xprt>.
Willy Tarreau53a47662017-08-28 10:53:00 +0200514 * The transport's is initialized as well, and the mux and its context are
Willy Tarreaube373152018-09-06 11:45:30 +0200515 * cleared. The target is not reinitialized and it is recommended that it is
516 * set prior to calling this function so that the function may make use of it
517 * in the future to refine the mux choice if needed.
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200518 */
519static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
520{
521 conn->ctrl = proto;
522 conn->xprt = xprt;
Willy Tarreau53a47662017-08-28 10:53:00 +0200523 conn->mux = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200524 conn->xprt_st = 0;
525 conn->xprt_ctx = NULL;
Willy Tarreau53a47662017-08-28 10:53:00 +0200526 conn->mux_ctx = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200527}
528
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200529/*
530 * Initializes all required fields for a new conn_strema.
531 */
532static inline void cs_init(struct conn_stream *cs, struct connection *conn)
533{
534 cs->obj_type = OBJ_TYPE_CS;
535 cs->flags = CS_FL_NONE;
536 cs->conn = conn;
537}
538
Willy Tarreaud0155772013-10-14 17:10:08 +0200539/* Initializes all required fields for a new connection. Note that it does the
540 * minimum acceptable initialization for a connection that already exists and
541 * is about to be reused. It also leaves the addresses untouched, which makes
542 * it usable across connection retries to reset a connection to a known state.
543 */
544static inline void conn_init(struct connection *conn)
545{
546 conn->obj_type = OBJ_TYPE_CONN;
547 conn->flags = CO_FL_NONE;
Olivier Houchardc2aae742017-09-22 18:26:28 +0200548 conn->tmp_early_data = -1;
Olivier Houchard90084a12017-11-23 18:21:29 +0100549 conn->sent_early_data = 0;
Willy Tarreau53a47662017-08-28 10:53:00 +0200550 conn->mux = NULL;
551 conn->mux_ctx = NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200552 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200553 conn->send_proxy_ofs = 0;
Willy Tarreau585744b2017-08-24 14:31:19 +0200554 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreaud0155772013-10-14 17:10:08 +0200555 conn->err_code = CO_ER_NONE;
556 conn->target = NULL;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200557 conn->xprt_done_cb = NULL;
Willy Tarreau436d3332017-10-08 11:16:46 +0200558 conn->destroy_cb = NULL;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100559 conn->proxy_netns = NULL;
Willy Tarreaud75d40e2015-08-04 17:25:58 +0200560 LIST_INIT(&conn->list);
Olivier Houchard131fd892018-11-13 16:44:31 +0100561 LIST_INIT(&conn->session_list);
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200562 conn->send_wait = NULL;
563 conn->recv_wait = NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200564}
565
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200566/* sets <owner> as the connection's owner */
Willy Tarreau436d3332017-10-08 11:16:46 +0200567static inline void conn_set_owner(struct connection *conn, void *owner, void (*cb)(struct connection *))
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200568{
569 conn->owner = owner;
Willy Tarreau436d3332017-10-08 11:16:46 +0200570 conn->destroy_cb = cb;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200571}
572
573/* registers <cb> as a callback to notify for transport's readiness or failure */
574static inline void conn_set_xprt_done_cb(struct connection *conn, int (*cb)(struct connection *))
575{
576 conn->xprt_done_cb = cb;
577}
578
579/* unregisters the callback to notify for transport's readiness or failure */
580static inline void conn_clear_xprt_done_cb(struct connection *conn)
581{
582 conn->xprt_done_cb = NULL;
583}
584
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200585/* Tries to allocate a new connection and initialized its main fields. The
586 * connection is returned on success, NULL on failure. The connection must
Willy Tarreaubafbe012017-11-24 17:34:44 +0100587 * be released using pool_free() or conn_free().
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200588 */
589static inline struct connection *conn_new()
590{
591 struct connection *conn;
592
Willy Tarreaubafbe012017-11-24 17:34:44 +0100593 conn = pool_alloc(pool_head_connection);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200594 if (likely(conn != NULL))
595 conn_init(conn);
596 return conn;
597}
598
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100599/* Releases a conn_stream previously allocated by cs_new(), as well as any
600 * buffer it would still hold.
601 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200602static inline void cs_free(struct conn_stream *cs)
603{
Willy Tarreau5e1cc5e2018-03-02 10:43:58 +0100604
Willy Tarreaubafbe012017-11-24 17:34:44 +0100605 pool_free(pool_head_connstream, cs);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200606}
607
608/* Tries to allocate a new conn_stream and initialize its main fields. If
609 * <conn> is NULL, then a new connection is allocated on the fly, initialized,
610 * and assigned to cs->conn ; this connection will then have to be released
Willy Tarreaubafbe012017-11-24 17:34:44 +0100611 * using pool_free() or conn_free(). The conn_stream is initialized and added
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200612 * to the mux's stream list on success, then returned. On failure, nothing is
613 * allocated and NULL is returned.
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200614 */
615static inline struct conn_stream *cs_new(struct connection *conn)
616{
617 struct conn_stream *cs;
618
Willy Tarreaubafbe012017-11-24 17:34:44 +0100619 cs = pool_alloc(pool_head_connstream);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200620 if (!likely(cs))
621 return NULL;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200622
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200623 if (!conn) {
624 conn = conn_new();
625 if (!likely(conn)) {
626 cs_free(cs);
627 return NULL;
628 }
629 conn_init(conn);
630 }
631
632 cs_init(cs, conn);
633 return cs;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200634}
635
Willy Tarreaufafd3982018-11-18 21:29:20 +0100636/* Retrieves any valid conn_stream from this connection, preferably the first
637 * valid one. The purpose is to be able to figure one other end of a private
638 * connection for purposes like source binding or proxy protocol header
639 * emission. In such cases, any conn_stream is expected to be valid so the
640 * mux is encouraged to return the first one it finds. If the connection has
641 * no mux or the mux has no get_first_cs() method or the mux has no valid
642 * conn_stream, NULL is returned. The output pointer is purposely marked
643 * const to discourage the caller from modifying anything there.
644 */
645static inline const struct conn_stream *cs_get_first(const struct connection *conn)
646{
647 if (!conn || !conn->mux || !conn->mux->get_first_cs)
648 return NULL;
649 return conn->mux->get_first_cs(conn);
650}
651
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200652static inline void conn_force_unsubscribe(struct connection *conn)
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200653{
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200654 if (conn->recv_wait) {
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200655 conn->recv_wait->wait_reason &= ~SUB_CAN_RECV;
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200656 conn->recv_wait = NULL;
657 }
658 if (conn->send_wait) {
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200659 conn->send_wait->wait_reason &= ~SUB_CAN_SEND;
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200660 conn->send_wait = NULL;
661 }
662
663}
664
665/* Releases a connection previously allocated by conn_new() */
666static inline void conn_free(struct connection *conn)
667{
Olivier Houchard131fd892018-11-13 16:44:31 +0100668 struct session *sess, *sess_back;
669
670 list_for_each_entry_safe(sess, sess_back, &conn->session_list, conn_list) {
671 sess->srv_conn = NULL;
672 LIST_DEL(&sess->conn_list);
673 LIST_INIT(&sess->conn_list);
674 }
Olivier Houchard201b9f42018-11-21 00:16:29 +0100675 /* If we temporarily stored the connection as the stream_interface's
676 * end point, remove it.
677 */
678 if (conn->mux_ctx != NULL && conn->mux == NULL) {
679 struct stream *s = conn->mux_ctx;
680
681 if (objt_conn(s->si[1].end) == conn)
682 s->si[1].end = NULL;
683 }
684
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200685 conn_force_unsubscribe(conn);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100686 LIST_DEL(&conn->list);
687 LIST_INIT(&conn->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100688 pool_free(pool_head_connection, conn);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200689}
690
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100691/* Release a conn_stream */
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200692static inline void cs_destroy(struct conn_stream *cs)
693{
Olivier Houchard302f9ef2018-04-13 15:50:27 +0200694 if (cs->conn->mux)
695 cs->conn->mux->detach(cs);
696 else {
697 /* It's too early to have a mux, let's just destroy
698 * the connection
699 */
700 struct connection *conn = cs->conn;
701
702 conn_stop_tracking(conn);
703 conn_full_close(conn);
704 if (conn->destroy_cb)
705 conn->destroy_cb(conn);
706 conn_free(conn);
707 }
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200708 cs_free(cs);
709}
710
Olivier Houcharde2b40b92017-09-13 18:30:23 +0200711/* Returns the conn from a cs. If cs is NULL, returns NULL */
712static inline struct connection *cs_conn(const struct conn_stream *cs)
713{
714 return cs ? cs->conn : NULL;
715}
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200716
Willy Tarreau986a9d22012-08-30 21:11:38 +0200717/* Retrieves the connection's source address */
718static inline void conn_get_from_addr(struct connection *conn)
719{
720 if (conn->flags & CO_FL_ADDR_FROM_SET)
721 return;
722
Willy Tarreau3c728722014-01-23 13:50:42 +0100723 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200724 return;
725
Willy Tarreau585744b2017-08-24 14:31:19 +0200726 if (conn->ctrl->get_src(conn->handle.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100727 sizeof(conn->addr.from),
728 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200729 return;
730 conn->flags |= CO_FL_ADDR_FROM_SET;
731}
732
733/* Retrieves the connection's original destination address */
734static inline void conn_get_to_addr(struct connection *conn)
735{
736 if (conn->flags & CO_FL_ADDR_TO_SET)
737 return;
738
Willy Tarreau3c728722014-01-23 13:50:42 +0100739 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200740 return;
741
Willy Tarreau585744b2017-08-24 14:31:19 +0200742 if (conn->ctrl->get_dst(conn->handle.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100743 sizeof(conn->addr.to),
744 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200745 return;
746 conn->flags |= CO_FL_ADDR_TO_SET;
747}
748
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200749/* Attaches a conn_stream to a data layer and sets the relevant callbacks */
750static inline void cs_attach(struct conn_stream *cs, void *data, const struct data_cb *data_cb)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200751{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200752 cs->data_cb = data_cb;
753 cs->data = data;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200754}
755
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200756static 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 +0200757{
758 if (!wl->task->process) {
759 wl->task->process = cb;
760 wl->task->context = ctx;
761 }
762 return wl;
763}
764
Willy Tarreau53a47662017-08-28 10:53:00 +0200765/* Installs the connection's mux layer for upper context <ctx>.
766 * Returns < 0 on error.
767 */
Willy Tarreau175a2bb2018-09-12 12:02:05 +0200768static inline int conn_install_mux(struct connection *conn, const struct mux_ops *mux,
769 void *ctx, struct proxy *prx)
Willy Tarreau53a47662017-08-28 10:53:00 +0200770{
771 conn->mux = mux;
772 conn->mux_ctx = ctx;
Willy Tarreau175a2bb2018-09-12 12:02:05 +0200773 return mux->init ? mux->init(conn, prx) : 0;
Willy Tarreau53a47662017-08-28 10:53:00 +0200774}
775
Willy Tarreau0af29122012-12-03 15:35:00 +0100776/* returns a human-readable error code for conn->err_code, or NULL if the code
777 * is unknown.
778 */
779static inline const char *conn_err_code_str(struct connection *c)
780{
781 switch (c->err_code) {
782 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100783
784 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
785 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
786 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
787 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
788 case CO_ER_NOPROTO: return "Protocol or address family not supported";
789 case CO_ER_SOCK_ERR: return "General socket error";
790 case CO_ER_PORT_RANGE: return "Source port range exhausted";
791 case CO_ER_CANT_BIND: return "Can't bind to source address";
792 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
793 case CO_ER_ADDR_INUSE: return "Local source address already in use";
794
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100795 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
796 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100797 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100798 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
799 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
800 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
801 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100802
803 case CO_ER_CIP_EMPTY: return "Connection closed while waiting for NetScaler Client IP header";
804 case CO_ER_CIP_ABORT: return "Connection error while waiting for NetScaler Client IP header";
805 case CO_ER_CIP_TRUNCATED: return "Truncated NetScaler Client IP header received";
806 case CO_ER_CIP_BAD_MAGIC: return "Received an invalid NetScaler Client IP magic number";
807 case CO_ER_CIP_BAD_PROTO: return "Received an unhandled protocol in the NetScaler Client IP header";
808
Willy Tarreau20879a02012-12-03 16:32:10 +0100809 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
810 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100811 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100812 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
813 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
814 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
815 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
816 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
Willy Tarreau71d058c2017-07-26 20:09:56 +0200817 case CO_ER_SSL_MISMATCH: return "Server presented an SSL certificate different from the configured one";
818 case CO_ER_SSL_MISMATCH_SNI: return "Server presented an SSL certificate different from the expected one";
Willy Tarreau20879a02012-12-03 16:32:10 +0100819 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200820 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200821 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100822 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Willy Tarreau0af29122012-12-03 15:35:00 +0100823 }
824 return NULL;
825}
826
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100827static inline const char *conn_get_ctrl_name(const struct connection *conn)
828{
829 if (!conn_ctrl_ready(conn))
830 return "NONE";
831 return conn->ctrl->name;
832}
833
834static inline const char *conn_get_xprt_name(const struct connection *conn)
835{
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100836 if (!conn_xprt_ready(conn))
837 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100838 return conn->xprt->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100839}
840
Willy Tarreau53a47662017-08-28 10:53:00 +0200841static inline const char *conn_get_mux_name(const struct connection *conn)
842{
843 if (!conn->mux)
844 return "NONE";
845 return conn->mux->name;
846}
847
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200848static inline const char *cs_get_data_name(const struct conn_stream *cs)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100849{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200850 if (!cs->data_cb)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100851 return "NONE";
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200852 return cs->data_cb->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100853}
854
Willy Tarreau13e14102016-12-22 20:25:26 +0100855/* registers pointer to transport layer <id> (XPRT_*) */
856static inline void xprt_register(int id, struct xprt_ops *xprt)
857{
858 if (id >= XPRT_ENTRIES)
859 return;
860 registered_xprt[id] = xprt;
861}
862
863/* returns pointer to transport layer <id> (XPRT_*) or NULL if not registered */
864static inline struct xprt_ops *xprt_get(int id)
865{
866 if (id >= XPRT_ENTRIES)
867 return NULL;
868 return registered_xprt[id];
869}
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100870
Willy Tarreaua9c17412016-12-04 18:42:09 +0100871static inline int conn_get_alpn(const struct connection *conn, const char **str, int *len)
872{
873 if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn)
874 return 0;
875 return conn->xprt->get_alpn(conn, str, len);
876}
877
Christopher Faulet32f61c02018-04-10 14:33:41 +0200878/* registers proto mux list <list>. Modifies the list element! */
879static inline void register_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200880{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200881 LIST_ADDQ(&mux_proto_list.list, &list->list);
Willy Tarreau2386be62017-09-21 19:40:52 +0200882}
883
Christopher Faulet32f61c02018-04-10 14:33:41 +0200884/* unregisters proto mux list <list> */
885static inline void unregister_mux_proto(struct mux_proto_list *list)
Willy Tarreau2386be62017-09-21 19:40:52 +0200886{
887 LIST_DEL(&list->list);
888 LIST_INIT(&list->list);
889}
890
Christopher Faulete15c6c42018-08-08 10:21:56 +0200891static inline struct mux_proto_list *get_mux_proto(const struct ist proto)
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200892{
893 struct mux_proto_list *item;
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200894
895 list_for_each_entry(item, &mux_proto_list.list, list) {
896 if (isteq(proto, item->token))
897 return item;
898 }
899 return NULL;
900}
901
902/* Lists the known proto mux on <out> */
903static inline void list_mux_proto(FILE *out)
904{
905 struct mux_proto_list *item;
906 struct ist proto;
907 char *mode, *side;
908
Christopher Faulet9c9ef032018-08-08 10:25:57 +0200909 fprintf(out, "Available multiplexer protocols :\n"
910 "(protocols markes as <default> cannot be specified using 'proto' keyword)\n");
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200911 list_for_each_entry(item, &mux_proto_list.list, list) {
912 proto = item->token;
913
914 if (item->mode == PROTO_MODE_ANY)
915 mode = "TCP|HTTP";
916 else if (item->mode == PROTO_MODE_TCP)
917 mode = "TCP";
918 else if (item->mode == PROTO_MODE_HTTP)
919 mode = "HTTP";
920 else
921 mode = "NONE";
922
923 if (item->side == PROTO_SIDE_BOTH)
924 side = "FE|BE";
925 else if (item->side == PROTO_SIDE_FE)
926 side = "FE";
927 else if (item->side == PROTO_SIDE_BE)
928 side = "BE";
929 else
930 side = "NONE";
931
932 fprintf(out, " %15s : mode=%-10s side=%s\n",
Christopher Faulet9c9ef032018-08-08 10:25:57 +0200933 (proto.len ? proto.ptr : "<default>"), mode, side);
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200934 }
935}
936
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200937/* returns the first mux in the list matching the exact same <mux_proto> and
938 * compatible with the <proto_side> (FE or BE) and the <proto_mode> (TCP or
939 * HTTP). <mux_proto> can be empty. Will fall back to the first compatible mux
940 * with exactly the same <proto_mode> or with an empty name. May return
941 * null if the code improperly registered the default mux to use as a fallback.
Willy Tarreau2386be62017-09-21 19:40:52 +0200942 */
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200943static inline const struct mux_ops *conn_get_best_mux(struct connection *conn,
944 const struct ist mux_proto,
945 int proto_side, int proto_mode)
Willy Tarreau2386be62017-09-21 19:40:52 +0200946{
Christopher Faulet32f61c02018-04-10 14:33:41 +0200947 struct mux_proto_list *item;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200948 struct mux_proto_list *fallback = NULL;
Willy Tarreau2386be62017-09-21 19:40:52 +0200949
Christopher Faulet32f61c02018-04-10 14:33:41 +0200950 list_for_each_entry(item, &mux_proto_list.list, list) {
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200951 if (!(item->side & proto_side) || !(item->mode & proto_mode))
Willy Tarreau2386be62017-09-21 19:40:52 +0200952 continue;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200953 if (istlen(mux_proto) && isteq(mux_proto, item->token))
Willy Tarreau2386be62017-09-21 19:40:52 +0200954 return item->mux;
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200955 else if (!istlen(item->token)) {
956 if (!fallback || (item->mode == proto_mode && fallback->mode != proto_mode))
957 fallback = item;
958 }
Willy Tarreau2386be62017-09-21 19:40:52 +0200959 }
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200960 return (fallback ? fallback->mux : NULL);
961
Willy Tarreau2386be62017-09-21 19:40:52 +0200962}
963
Willy Tarreau57f81852018-09-06 14:52:21 +0200964/* returns 0 if the connection is valid and is a frontend connection, otherwise
965 * returns 1 indicating it's a backend connection. And uninitialized connection
966 * also returns 1 to better handle the usage in the middle of initialization.
967 */
968static inline int conn_is_back(const struct connection *conn)
969{
970 return !objt_listener(conn->target);
971}
972
Willy Tarreau6ac98ac2018-09-06 11:48:44 +0200973/* returns a pointer to the proxy associated with this connection. For a front
974 * connection it returns a pointer to the frontend ; for a back connection, it
975 * returns a pointer to the backend.
976 */
977static inline struct proxy *conn_get_proxy(const struct connection *conn)
978{
979 struct listener *l;
980 struct server *s;
981
982 /* check if it's a frontend connection */
983 l = objt_listener(conn->target);
984 if (l)
985 return l->bind_conf->frontend;
986
987 /* check if it's a backend connection */
988 s = objt_server(conn->target);
989 if (s)
990 return s->proxy;
991
992 return objt_proxy(conn->target);
993}
994
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200995/* installs the best mux for incoming connection <conn> using the upper context
996 * <ctx>. If the mux protocol is forced, we use it to find the best
997 * mux. Otherwise we use the ALPN name, if any. Returns < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +0200998 */
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200999static inline int conn_install_mux_fe(struct connection *conn, void *ctx)
Willy Tarreau2386be62017-09-21 19:40:52 +02001000{
Willy Tarreau55e0da62018-09-20 11:26:52 +02001001 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001002 const struct mux_ops *mux_ops;
Willy Tarreau2386be62017-09-21 19:40:52 +02001003
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001004 if (bind_conf->mux_proto)
1005 mux_ops = bind_conf->mux_proto->mux;
1006 else {
1007 struct ist mux_proto;
1008 const char *alpn_str = NULL;
1009 int alpn_len = 0;
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001010 int mode;
1011
1012 if (bind_conf->frontend->mode == PR_MODE_TCP)
1013 mode = PROTO_MODE_TCP;
1014 else if (bind_conf->frontend->options2 & PR_O2_USE_HTX)
1015 mode = PROTO_MODE_HTX;
1016 else
1017 mode = PROTO_MODE_HTTP;
Willy Tarreau2386be62017-09-21 19:40:52 +02001018
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001019 conn_get_alpn(conn, &alpn_str, &alpn_len);
1020 mux_proto = ist2(alpn_str, alpn_len);
1021 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_FE, mode);
1022 if (!mux_ops)
1023 return -1;
1024 }
Willy Tarreau175a2bb2018-09-12 12:02:05 +02001025 return conn_install_mux(conn, mux_ops, ctx, bind_conf->frontend);
Willy Tarreau2386be62017-09-21 19:40:52 +02001026}
1027
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001028/* installs the best mux for outgoing connection <conn> using the upper context
1029 * <ctx>. If the mux protocol is forced, we use it to find the best mux. Returns
Willy Tarreau2e0b2b52017-09-15 06:59:55 +02001030 * < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +02001031 */
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001032static inline int conn_install_mux_be(struct connection *conn, void *ctx)
Willy Tarreau2386be62017-09-21 19:40:52 +02001033{
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001034 struct server *srv = objt_server(conn->target);
Willy Tarreau287527a2018-08-08 18:40:44 +02001035 struct proxy *prx = objt_proxy(conn->target);
Willy Tarreau2386be62017-09-21 19:40:52 +02001036 const struct mux_ops *mux_ops;
1037
Willy Tarreau287527a2018-08-08 18:40:44 +02001038 if (srv)
1039 prx = srv->proxy;
1040
1041 if (!prx) // target must be either proxy or server
1042 return -1;
1043
1044 if (srv && srv->mux_proto)
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001045 mux_ops = srv->mux_proto->mux;
1046 else {
Olivier Houchard201b9f42018-11-21 00:16:29 +01001047 struct ist mux_proto;
1048 const char *alpn_str = NULL;
1049 int alpn_len = 0;
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001050 int mode;
1051
Willy Tarreau68ad3a42018-10-22 11:49:15 +02001052 if (prx->mode == PR_MODE_TCP)
1053 mode = PROTO_MODE_TCP;
1054 else if (prx->options2 & PR_O2_USE_HTX)
1055 mode = PROTO_MODE_HTX;
1056 else
1057 mode = PROTO_MODE_HTTP;
1058
Olivier Houchard201b9f42018-11-21 00:16:29 +01001059 conn_get_alpn(conn, &alpn_str, &alpn_len);
1060 mux_proto = ist2(alpn_str, alpn_len);
1061
1062 mux_ops = conn_get_best_mux(conn, mux_proto, PROTO_SIDE_BE, mode);
Christopher Faulet7ce0c892018-04-10 15:01:45 +02001063 if (!mux_ops)
1064 return -1;
1065 }
Willy Tarreau175a2bb2018-09-12 12:02:05 +02001066 return conn_install_mux(conn, mux_ops, ctx, prx);
Willy Tarreau2386be62017-09-21 19:40:52 +02001067}
1068
Willy Tarreau59f98392012-07-06 14:13:49 +02001069#endif /* _PROTO_CONNECTION_H */
1070
1071/*
1072 * Local variables:
1073 * c-indent-level: 8
1074 * c-basic-offset: 8
1075 * End:
1076 */