blob: 0efce993b2e2ac3a1bbd3a06e54f51c09c22b4cd [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>
Willy Tarreau59f98392012-07-06 14:13:49 +020032
Willy Tarreaubafbe012017-11-24 17:34:44 +010033extern struct pool_head *pool_head_connection;
34extern struct pool_head *pool_head_connstream;
Willy Tarreau13e14102016-12-22 20:25:26 +010035extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
Willy Tarreau2386be62017-09-21 19:40:52 +020036extern struct alpn_mux_list alpn_mux_list;
Willy Tarreauf2943dc2012-10-26 20:10:28 +020037
38/* perform minimal intializations, report 0 in case of error, 1 if OK. */
39int init_connection();
40
Willy Tarreau59f98392012-07-06 14:13:49 +020041/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020042 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020043 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020044void conn_fd_handler(int fd);
Willy Tarreau59f98392012-07-06 14:13:49 +020045
Willy Tarreau22cda212012-08-31 17:43:29 +020046/* receive a PROXY protocol header over a connection */
47int conn_recv_proxy(struct connection *conn, int flag);
David Safb76832014-05-08 23:42:08 -040048int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote);
49int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
50int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
Willy Tarreau22cda212012-08-31 17:43:29 +020051
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010052/* receive a NetScaler Client IP insertion header over a connection */
53int conn_recv_netscaler_cip(struct connection *conn, int flag);
54
Willy Tarreauff3e6482015-03-12 23:56:52 +010055/* raw send() directly on the socket */
56int conn_sock_send(struct connection *conn, const void *buf, int len, int flags);
57
Willy Tarreaud85c4852015-03-13 00:40:28 +010058/* drains any pending bytes from the socket */
59int conn_sock_drain(struct connection *conn);
60
Willy Tarreaud02cdd22013-12-15 10:23:20 +010061/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010062static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010063{
Willy Tarreauaad69382014-01-23 14:21:42 +010064 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010065}
66
67/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010068static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010069{
70 return (conn->flags & CO_FL_CTRL_READY);
71}
72
Willy Tarreauf79c8172013-10-21 16:30:56 +020073/* Calls the init() function of the transport layer if any and if not done yet,
74 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020075 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020076 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020077static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020078{
Willy Tarreauf79c8172013-10-21 16:30:56 +020079 int ret = 0;
80
Willy Tarreauaad69382014-01-23 14:21:42 +010081 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Willy Tarreauf79c8172013-10-21 16:30:56 +020082 ret = conn->xprt->init(conn);
83
84 if (ret >= 0)
85 conn->flags |= CO_FL_XPRT_READY;
86
87 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020088}
89
Willy Tarreauf79c8172013-10-21 16:30:56 +020090/* Calls the close() function of the transport layer if any and if not done
91 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
92 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
93 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +020094 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020095static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +020096{
Willy Tarreauf79c8172013-10-21 16:30:56 +020097 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +010098 if (conn->xprt->close)
Willy Tarreau6c03a642012-10-12 17:00:05 +020099 conn->xprt->close(conn);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200100 conn->flags &= ~CO_FL_XPRT_READY;
101 }
102}
103
104/* Initializes the connection's control layer which essentially consists in
105 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +0100106 * flag. The caller is responsible for ensuring that the control layer is
107 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200108 */
109static inline void conn_ctrl_init(struct connection *conn)
110{
Willy Tarreau3c728722014-01-23 13:50:42 +0100111 if (!conn_ctrl_ready(conn)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200112 int fd = conn->handle.fd;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200113
Christopher Faulet576c5aa2017-09-05 09:51:57 +0200114 fdtab[fd].owner = conn;
115 fdtab[fd].iocb = conn_fd_handler;
Christopher Faulet36716a72017-05-30 11:07:16 +0200116 fd_insert(fd, tid_bit);
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100117 /* mark the fd as ready so as not to needlessly poll at the beginning */
118 fd_may_recv(fd);
119 fd_may_send(fd);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200120 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200121 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200122}
123
Willy Tarreauf79c8172013-10-21 16:30:56 +0200124/* Deletes the FD if the transport layer is already gone. Once done,
125 * it then removes the CO_FL_CTRL_READY flag.
126 */
127static inline void conn_ctrl_close(struct connection *conn)
128{
129 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200130 fd_delete(conn->handle.fd);
Willy Tarreau6a0a80a2017-10-05 17:43:39 +0200131 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200132 conn->flags &= ~CO_FL_CTRL_READY;
133 }
134}
135
Willy Tarreau2b199c92012-11-23 17:32:21 +0100136/* If the connection still has a transport layer, then call its close() function
137 * if any, and delete the file descriptor if a control layer is set. This is
138 * used to close everything at once and atomically. However this is not done if
139 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
140 * transport layer very late if needed.
141 */
142static inline void conn_full_close(struct connection *conn)
143{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200144 conn_xprt_close(conn);
145 conn_ctrl_close(conn);
146}
147
Willy Tarreaudc42acd2017-10-05 18:09:20 +0200148/* stop tracking a connection, allowing conn_full_close() to always
149 * succeed.
150 */
151static inline void conn_stop_tracking(struct connection *conn)
152{
153 conn->flags &= ~CO_FL_XPRT_TRACKED;
154}
155
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200156/* Update polling on connection <c>'s file descriptor depending on its current
157 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
158 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
159 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200160 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200161 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200162void conn_update_sock_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200163
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200164/* Update polling on connection <c>'s file descriptor depending on its current
165 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200166 * in CO_FL_WAIT_*, and the upper layer expectations indicated by CO_FL_XPRT_*.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200167 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200168 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200169 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200170void conn_update_xprt_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200171
Willy Tarreau7d281492012-12-16 19:19:13 +0100172/* Refresh the connection's polling flags from its file descriptor status.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200173 * This should be called at the beginning of a connection handler. It does
174 * nothing if CO_FL_WILL_UPDATE is present, indicating that an upper caller
175 * has already done it.
Willy Tarreau7d281492012-12-16 19:19:13 +0100176 */
177static inline void conn_refresh_polling_flags(struct connection *conn)
178{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200179 if (conn_ctrl_ready(conn) && !(conn->flags & CO_FL_WILL_UPDATE)) {
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200180 unsigned int flags = conn->flags;
Willy Tarreau7d281492012-12-16 19:19:13 +0100181
Willy Tarreaubc97cc42017-10-25 10:28:45 +0200182 flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA | CO_FL_WAIT_ROOM);
Willy Tarreau585744b2017-08-24 14:31:19 +0200183 if (fd_recv_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100184 flags |= CO_FL_CURR_RD_ENA;
Willy Tarreau585744b2017-08-24 14:31:19 +0200185 if (fd_send_active(conn->handle.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100186 flags |= CO_FL_CURR_WR_ENA;
187 conn->flags = flags;
188 }
189}
190
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200191/* inspects c->flags and returns non-zero if XPRT ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100192 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200193 * non-zero is also returned if an error was reported on the connection. This
194 * function is used quite often and is inlined. In order to proceed optimally
195 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100196 * can be detected by a few left shifts, a xor, and a mask. These operations
197 * detect when W&D are both enabled for either direction, when C&D differ for
198 * either direction and when Error is set. The trick consists in first keeping
199 * only the bits we're interested in, since they don't collide when shifted,
200 * and to perform the AND at the end. In practice, the compiler is able to
201 * replace the last AND with a TEST in boolean conditions. This results in
202 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200203 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200204static inline unsigned int conn_xprt_polling_changes(const struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200205{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100206 unsigned int f = c->flags;
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200207 f &= CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100208 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100209
Willy Tarreau310987a2014-01-22 19:46:33 +0100210 f = (f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ D */
211 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200212}
213
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200214/* inspects c->flags and returns non-zero if SOCK ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100215 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200216 * non-zero is also returned if an error was reported on the connection. This
217 * function is used quite often and is inlined. In order to proceed optimally
218 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100219 * can be detected by a few left shifts, a xor, and a mask. These operations
220 * detect when W&S are both enabled for either direction, when C&S differ for
221 * either direction and when Error is set. The trick consists in first keeping
222 * only the bits we're interested in, since they don't collide when shifted,
223 * and to perform the AND at the end. In practice, the compiler is able to
224 * replace the last AND with a TEST in boolean conditions. This results in
225 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200226 */
227static inline unsigned int conn_sock_polling_changes(const struct connection *c)
228{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100229 unsigned int f = c->flags;
230 f &= CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100231 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100232
Willy Tarreau310987a2014-01-22 19:46:33 +0100233 f = (f ^ (f << 2)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ S */
234 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200235}
236
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200237/* Automatically updates polling on connection <c> depending on the XPRT flags
Willy Tarreau916e12d2017-10-25 09:22:43 +0200238 * if no handshake is in progress. It does nothing if CO_FL_WILL_UPDATE is
239 * present, indicating that an upper caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200240 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200241static inline void conn_cond_update_xprt_polling(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200242{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200243 if (!(c->flags & CO_FL_WILL_UPDATE))
244 if (!(c->flags & CO_FL_POLL_SOCK) && conn_xprt_polling_changes(c))
245 conn_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200246}
247
248/* Automatically updates polling on connection <c> depending on the SOCK flags
Willy Tarreau916e12d2017-10-25 09:22:43 +0200249 * if a handshake is in progress. It does nothing if CO_FL_WILL_UPDATE is
250 * present, indicating that an upper caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200251 */
252static inline void conn_cond_update_sock_polling(struct connection *c)
253{
Willy Tarreau916e12d2017-10-25 09:22:43 +0200254 if (!(c->flags & CO_FL_WILL_UPDATE))
255 if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
256 conn_update_sock_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200257}
258
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100259/* Stop all polling on the fd. This might be used when an error is encountered
Willy Tarreau916e12d2017-10-25 09:22:43 +0200260 * for example. It does not propage the change to the fd layer if
261 * CO_FL_WILL_UPDATE is present, indicating that an upper caller is going to do
262 * it later.
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100263 */
264static inline void conn_stop_polling(struct connection *c)
265{
266 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
267 CO_FL_SOCK_RD_ENA | CO_FL_SOCK_WR_ENA |
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200268 CO_FL_XPRT_RD_ENA | CO_FL_XPRT_WR_ENA);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200269 if (!(c->flags & CO_FL_WILL_UPDATE) && conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200270 fd_stop_both(c->handle.fd);
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100271}
272
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200273/* Automatically update polling on connection <c> depending on the XPRT and
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200274 * SOCK flags, and on whether a handshake is in progress or not. This may be
275 * called at any moment when there is a doubt about the effectiveness of the
276 * polling state, for instance when entering or leaving the handshake state.
Willy Tarreau916e12d2017-10-25 09:22:43 +0200277 * It does nothing if CO_FL_WILL_UPDATE is present, indicating that an upper
278 * caller is going to do it again later.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200279 */
280static inline void conn_cond_update_polling(struct connection *c)
281{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100282 if (unlikely(c->flags & CO_FL_ERROR))
283 conn_stop_polling(c);
Willy Tarreau916e12d2017-10-25 09:22:43 +0200284 else if (!(c->flags & CO_FL_WILL_UPDATE)) {
285 if (!(c->flags & CO_FL_POLL_SOCK) && conn_xprt_polling_changes(c))
286 conn_update_xprt_polling(c);
287 else if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
288 conn_update_sock_polling(c);
289 }
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200290}
291
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200292/* recompute the mux polling flags after updating the current conn_stream and
293 * propagate the result down the transport layer.
294 */
295static inline void cs_update_mux_polling(struct conn_stream *cs)
296{
297 struct connection *conn = cs->conn;
298
299 if (conn->mux && conn->mux->update_poll)
300 conn->mux->update_poll(cs);
301}
302
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200303/***** Event manipulation primitives for use by DATA I/O callbacks *****/
304/* The __conn_* versions do not propagate to lower layers and are only meant
305 * to be used by handlers called by the connection handler. The other ones
306 * may be used anywhere.
307 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200308static inline void __conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200309{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200310 c->flags |= CO_FL_XPRT_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200311}
312
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200313static inline void __conn_xprt_stop_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200314{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200315 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200316}
317
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200318static inline void __cs_want_recv(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200319{
320 cs->flags |= CS_FL_DATA_RD_ENA;
321}
322
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200323static inline void __cs_stop_recv(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200324{
325 cs->flags &= ~CS_FL_DATA_RD_ENA;
326}
327
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200328static inline void cs_want_recv(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200329{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200330 __cs_want_recv(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200331 cs_update_mux_polling(cs);
332}
333
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200334static inline void cs_stop_recv(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200335{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200336 __cs_stop_recv(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200337 cs_update_mux_polling(cs);
338}
339
Willy Tarreau796c5b72016-11-29 21:47:02 +0100340/* this one is used only to stop speculative recv(). It doesn't stop it if the
341 * fd is already polled in order to avoid expensive polling status changes.
342 * Since it might require the upper layer to re-enable reading, we'll return 1
343 * if we've really stopped something otherwise zero.
344 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200345static inline int __conn_xprt_done_recv(struct connection *c)
Willy Tarreau796c5b72016-11-29 21:47:02 +0100346{
Willy Tarreau585744b2017-08-24 14:31:19 +0200347 if (!conn_ctrl_ready(c) || !fd_recv_polled(c->handle.fd)) {
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200348 c->flags &= ~CO_FL_XPRT_RD_ENA;
Willy Tarreau796c5b72016-11-29 21:47:02 +0100349 return 1;
350 }
351 return 0;
352}
353
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200354static inline void __conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200355{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200356 c->flags |= CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200357}
358
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200359static inline void __conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200360{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200361 c->flags &= ~CO_FL_XPRT_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200362}
363
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200364static inline void __conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200365{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200366 c->flags &= ~(CO_FL_XPRT_WR_ENA | CO_FL_XPRT_RD_ENA);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200367}
368
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200369static inline void __cs_want_send(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200370{
371 cs->flags |= CS_FL_DATA_WR_ENA;
372}
373
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200374static inline void __cs_stop_send(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200375{
376 cs->flags &= ~CS_FL_DATA_WR_ENA;
377}
378
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200379static inline void cs_stop_send(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200380{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200381 __cs_stop_send(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200382 cs_update_mux_polling(cs);
383}
384
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200385static inline void cs_want_send(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200386{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200387 __cs_want_send(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200388 cs_update_mux_polling(cs);
389}
390
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200391static inline void __cs_stop_both(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200392{
393 cs->flags &= ~(CS_FL_DATA_WR_ENA | CS_FL_DATA_RD_ENA);
394}
395
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200396static inline void cs_stop_both(struct conn_stream *cs)
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200397{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200398 __cs_stop_both(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200399 cs_update_mux_polling(cs);
400}
401
402
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200403static inline void conn_xprt_want_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200404{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200405 __conn_xprt_want_recv(c);
406 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200407}
408
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200409static inline void conn_xprt_stop_recv(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200410{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200411 __conn_xprt_stop_recv(c);
412 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200413}
414
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200415static inline void conn_xprt_want_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200416{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200417 __conn_xprt_want_send(c);
418 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200419}
420
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200421static inline void conn_xprt_stop_send(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200422{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200423 __conn_xprt_stop_send(c);
424 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200425}
426
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200427static inline void conn_xprt_stop_both(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200428{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200429 __conn_xprt_stop_both(c);
430 conn_cond_update_xprt_polling(c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200431}
432
433/***** Event manipulation primitives for use by handshake I/O callbacks *****/
434/* The __conn_* versions do not propagate to lower layers and are only meant
435 * to be used by handlers called by the connection handler. The other ones
436 * may be used anywhere.
437 */
438static inline void __conn_sock_want_recv(struct connection *c)
439{
440 c->flags |= CO_FL_SOCK_RD_ENA;
441}
442
443static inline void __conn_sock_stop_recv(struct connection *c)
444{
445 c->flags &= ~CO_FL_SOCK_RD_ENA;
446}
447
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200448static inline void __conn_sock_want_send(struct connection *c)
449{
450 c->flags |= CO_FL_SOCK_WR_ENA;
451}
452
453static inline void __conn_sock_stop_send(struct connection *c)
454{
455 c->flags &= ~CO_FL_SOCK_WR_ENA;
456}
457
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200458static inline void __conn_sock_stop_both(struct connection *c)
459{
460 c->flags &= ~(CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA);
461}
462
463static inline void conn_sock_want_recv(struct connection *c)
464{
465 __conn_sock_want_recv(c);
466 conn_cond_update_sock_polling(c);
467}
468
469static inline void conn_sock_stop_recv(struct connection *c)
470{
471 __conn_sock_stop_recv(c);
472 conn_cond_update_sock_polling(c);
473}
474
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200475static inline void conn_sock_want_send(struct connection *c)
476{
477 __conn_sock_want_send(c);
478 conn_cond_update_sock_polling(c);
479}
480
481static inline void conn_sock_stop_send(struct connection *c)
482{
483 __conn_sock_stop_send(c);
484 conn_cond_update_sock_polling(c);
485}
486
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200487static inline void conn_sock_stop_both(struct connection *c)
488{
489 __conn_sock_stop_both(c);
490 conn_cond_update_sock_polling(c);
491}
Willy Tarreau8b117082012-08-06 15:06:49 +0200492
Willy Tarreau7b271b22017-10-25 09:59:22 +0200493/* read shutdown, called from the rcv_buf/rcv_pipe handlers when
494 * detecting an end of connection.
495 */
Willy Tarreau3af56a92012-08-20 16:55:48 +0200496static inline void conn_sock_read0(struct connection *c)
497{
498 c->flags |= CO_FL_SOCK_RD_SH;
499 __conn_sock_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100500 /* we don't risk keeping ports unusable if we found the
501 * zero from the other side.
502 */
Willy Tarreau3c728722014-01-23 13:50:42 +0100503 if (conn_ctrl_ready(c))
Willy Tarreau585744b2017-08-24 14:31:19 +0200504 fdtab[c->handle.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200505}
506
Willy Tarreau7b271b22017-10-25 09:59:22 +0200507/* write shutdown, indication that the upper layer is not willing to send
508 * anything anymore and wants to close after pending data are sent.
509 */
Willy Tarreau3af56a92012-08-20 16:55:48 +0200510static inline void conn_sock_shutw(struct connection *c)
511{
512 c->flags |= CO_FL_SOCK_WR_SH;
Willy Tarreau7b271b22017-10-25 09:59:22 +0200513 conn_refresh_polling_flags(c);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200514 __conn_sock_stop_send(c);
Willy Tarreau7b271b22017-10-25 09:59:22 +0200515 conn_cond_update_sock_polling(c);
516
Willy Tarreauf9ce57e2017-10-05 17:24:42 +0200517 /* don't perform a clean shutdown if we're going to reset */
518 if (conn_ctrl_ready(c) && !fdtab[c->handle.fd].linger_risk)
Willy Tarreau585744b2017-08-24 14:31:19 +0200519 shutdown(c->handle.fd, SHUT_WR);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200520}
521
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200522static inline void conn_xprt_shutw(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200523{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200524 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100525
526 /* clean data-layer shutdown */
527 if (c->xprt && c->xprt->shutw)
528 c->xprt->shutw(c, 1);
529}
530
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200531static inline void conn_xprt_shutw_hard(struct connection *c)
Willy Tarreau729c69f2015-03-12 22:51:10 +0100532{
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200533 __conn_xprt_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100534
535 /* unclean data-layer shutdown */
536 if (c->xprt && c->xprt->shutw)
537 c->xprt->shutw(c, 0);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200538}
539
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200540/* shut read */
541static inline void cs_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200542{
543 __cs_stop_recv(cs);
544
545 /* clean data-layer shutdown */
546 if (cs->conn->mux && cs->conn->mux->shutr)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200547 cs->conn->mux->shutr(cs, mode);
548 cs->flags |= (mode == CS_SHR_DRAIN) ? CS_FL_SHRD : CS_FL_SHRR;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200549}
550
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200551/* shut write */
552static inline void cs_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200553{
554 __cs_stop_send(cs);
555
556 /* clean data-layer shutdown */
557 if (cs->conn->mux && cs->conn->mux->shutw)
Willy Tarreauecdb3fe2017-10-05 15:25:48 +0200558 cs->conn->mux->shutw(cs, mode);
559 cs->flags |= (mode == CS_SHW_NORMAL) ? CS_FL_SHWN : CS_FL_SHWS;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200560}
561
Willy Tarreau6978db32017-10-05 18:19:43 +0200562/* completely close a conn_stream (but do not detach it) */
563static inline void cs_close(struct conn_stream *cs)
564{
565 cs_shutw(cs, CS_SHW_SILENT);
566 cs_shutr(cs, CS_SHR_RESET);
567 cs->flags = CS_FL_NONE;
568}
569
Willy Tarreau3af56a92012-08-20 16:55:48 +0200570/* detect sock->data read0 transition */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200571static inline int conn_xprt_read0_pending(struct connection *c)
Willy Tarreau3af56a92012-08-20 16:55:48 +0200572{
Willy Tarreau54e917c2017-08-30 07:35:35 +0200573 return (c->flags & CO_FL_SOCK_RD_SH) != 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200574}
575
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200576/* prepares a connection to work with protocol <proto> and transport <xprt>.
Willy Tarreau53a47662017-08-28 10:53:00 +0200577 * The transport's is initialized as well, and the mux and its context are
578 * cleared.
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200579 */
580static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
581{
582 conn->ctrl = proto;
583 conn->xprt = xprt;
Willy Tarreau53a47662017-08-28 10:53:00 +0200584 conn->mux = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200585 conn->xprt_st = 0;
586 conn->xprt_ctx = NULL;
Willy Tarreau53a47662017-08-28 10:53:00 +0200587 conn->mux_ctx = NULL;
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200588}
589
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200590/*
591 * Initializes all required fields for a new conn_strema.
592 */
593static inline void cs_init(struct conn_stream *cs, struct connection *conn)
594{
595 cs->obj_type = OBJ_TYPE_CS;
596 cs->flags = CS_FL_NONE;
597 cs->conn = conn;
598}
599
Willy Tarreaud0155772013-10-14 17:10:08 +0200600/* Initializes all required fields for a new connection. Note that it does the
601 * minimum acceptable initialization for a connection that already exists and
602 * is about to be reused. It also leaves the addresses untouched, which makes
603 * it usable across connection retries to reset a connection to a known state.
604 */
605static inline void conn_init(struct connection *conn)
606{
607 conn->obj_type = OBJ_TYPE_CONN;
608 conn->flags = CO_FL_NONE;
Olivier Houchardc2aae742017-09-22 18:26:28 +0200609 conn->tmp_early_data = -1;
Olivier Houchard90084a12017-11-23 18:21:29 +0100610 conn->sent_early_data = 0;
Willy Tarreau53a47662017-08-28 10:53:00 +0200611 conn->mux = NULL;
612 conn->mux_ctx = NULL;
Willy Tarreaud0155772013-10-14 17:10:08 +0200613 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200614 conn->send_proxy_ofs = 0;
Willy Tarreau585744b2017-08-24 14:31:19 +0200615 conn->handle.fd = DEAD_FD_MAGIC;
Willy Tarreaud0155772013-10-14 17:10:08 +0200616 conn->err_code = CO_ER_NONE;
617 conn->target = NULL;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200618 conn->xprt_done_cb = NULL;
Willy Tarreau436d3332017-10-08 11:16:46 +0200619 conn->destroy_cb = NULL;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100620 conn->proxy_netns = NULL;
Willy Tarreaud75d40e2015-08-04 17:25:58 +0200621 LIST_INIT(&conn->list);
Willy Tarreaud0155772013-10-14 17:10:08 +0200622}
623
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200624/* sets <owner> as the connection's owner */
Willy Tarreau436d3332017-10-08 11:16:46 +0200625static inline void conn_set_owner(struct connection *conn, void *owner, void (*cb)(struct connection *))
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200626{
627 conn->owner = owner;
Willy Tarreau436d3332017-10-08 11:16:46 +0200628 conn->destroy_cb = cb;
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200629}
630
631/* registers <cb> as a callback to notify for transport's readiness or failure */
632static inline void conn_set_xprt_done_cb(struct connection *conn, int (*cb)(struct connection *))
633{
634 conn->xprt_done_cb = cb;
635}
636
637/* unregisters the callback to notify for transport's readiness or failure */
638static inline void conn_clear_xprt_done_cb(struct connection *conn)
639{
640 conn->xprt_done_cb = NULL;
641}
642
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200643/* Tries to allocate a new connection and initialized its main fields. The
644 * connection is returned on success, NULL on failure. The connection must
Willy Tarreaubafbe012017-11-24 17:34:44 +0100645 * be released using pool_free() or conn_free().
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200646 */
647static inline struct connection *conn_new()
648{
649 struct connection *conn;
650
Willy Tarreaubafbe012017-11-24 17:34:44 +0100651 conn = pool_alloc(pool_head_connection);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200652 if (likely(conn != NULL))
653 conn_init(conn);
654 return conn;
655}
656
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200657/* Releases a conn_stream previously allocated by cs_new() */
658static inline void cs_free(struct conn_stream *cs)
659{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100660 pool_free(pool_head_connstream, cs);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200661}
662
663/* Tries to allocate a new conn_stream and initialize its main fields. If
664 * <conn> is NULL, then a new connection is allocated on the fly, initialized,
665 * and assigned to cs->conn ; this connection will then have to be released
Willy Tarreaubafbe012017-11-24 17:34:44 +0100666 * using pool_free() or conn_free(). The conn_stream is initialized and added
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200667 * to the mux's stream list on success, then returned. On failure, nothing is
668 * allocated and NULL is returned.
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200669 */
670static inline struct conn_stream *cs_new(struct connection *conn)
671{
672 struct conn_stream *cs;
673
Willy Tarreaubafbe012017-11-24 17:34:44 +0100674 cs = pool_alloc(pool_head_connstream);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200675 if (!likely(cs))
676 return NULL;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200677
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200678 if (!conn) {
679 conn = conn_new();
680 if (!likely(conn)) {
681 cs_free(cs);
682 return NULL;
683 }
684 conn_init(conn);
685 }
686
687 cs_init(cs, conn);
688 return cs;
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200689}
690
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200691/* Releases a connection previously allocated by conn_new() */
692static inline void conn_free(struct connection *conn)
693{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100694 pool_free(pool_head_connection, conn);
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200695}
696
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200697/* Release a conn_stream, and kill the connection if it was the last one */
698static inline void cs_destroy(struct conn_stream *cs)
699{
Willy Tarreau2c52a2b2017-10-08 11:00:17 +0200700 cs->conn->mux->detach(cs);
Willy Tarreau63dd75d2017-10-08 15:16:00 +0200701 cs_free(cs);
702}
703
Olivier Houcharde2b40b92017-09-13 18:30:23 +0200704/* Returns the conn from a cs. If cs is NULL, returns NULL */
705static inline struct connection *cs_conn(const struct conn_stream *cs)
706{
707 return cs ? cs->conn : NULL;
708}
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200709
Willy Tarreau986a9d22012-08-30 21:11:38 +0200710/* Retrieves the connection's source address */
711static inline void conn_get_from_addr(struct connection *conn)
712{
713 if (conn->flags & CO_FL_ADDR_FROM_SET)
714 return;
715
Willy Tarreau3c728722014-01-23 13:50:42 +0100716 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200717 return;
718
Willy Tarreau585744b2017-08-24 14:31:19 +0200719 if (conn->ctrl->get_src(conn->handle.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100720 sizeof(conn->addr.from),
721 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200722 return;
723 conn->flags |= CO_FL_ADDR_FROM_SET;
724}
725
726/* Retrieves the connection's original destination address */
727static inline void conn_get_to_addr(struct connection *conn)
728{
729 if (conn->flags & CO_FL_ADDR_TO_SET)
730 return;
731
Willy Tarreau3c728722014-01-23 13:50:42 +0100732 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200733 return;
734
Willy Tarreau585744b2017-08-24 14:31:19 +0200735 if (conn->ctrl->get_dst(conn->handle.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100736 sizeof(conn->addr.to),
737 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200738 return;
739 conn->flags |= CO_FL_ADDR_TO_SET;
740}
741
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200742/* Attaches a conn_stream to a data layer and sets the relevant callbacks */
743static inline void cs_attach(struct conn_stream *cs, void *data, const struct data_cb *data_cb)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200744{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200745 cs->data_cb = data_cb;
746 cs->data = data;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200747}
748
Willy Tarreau53a47662017-08-28 10:53:00 +0200749/* Installs the connection's mux layer for upper context <ctx>.
750 * Returns < 0 on error.
751 */
752static inline int conn_install_mux(struct connection *conn, const struct mux_ops *mux, void *ctx)
753{
754 conn->mux = mux;
755 conn->mux_ctx = ctx;
756 return mux->init ? mux->init(conn) : 0;
757}
758
Willy Tarreau0af29122012-12-03 15:35:00 +0100759/* returns a human-readable error code for conn->err_code, or NULL if the code
760 * is unknown.
761 */
762static inline const char *conn_err_code_str(struct connection *c)
763{
764 switch (c->err_code) {
765 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100766
767 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
768 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
769 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
770 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
771 case CO_ER_NOPROTO: return "Protocol or address family not supported";
772 case CO_ER_SOCK_ERR: return "General socket error";
773 case CO_ER_PORT_RANGE: return "Source port range exhausted";
774 case CO_ER_CANT_BIND: return "Can't bind to source address";
775 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
776 case CO_ER_ADDR_INUSE: return "Local source address already in use";
777
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100778 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
779 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100780 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100781 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
782 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
783 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
784 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100785
786 case CO_ER_CIP_EMPTY: return "Connection closed while waiting for NetScaler Client IP header";
787 case CO_ER_CIP_ABORT: return "Connection error while waiting for NetScaler Client IP header";
788 case CO_ER_CIP_TRUNCATED: return "Truncated NetScaler Client IP header received";
789 case CO_ER_CIP_BAD_MAGIC: return "Received an invalid NetScaler Client IP magic number";
790 case CO_ER_CIP_BAD_PROTO: return "Received an unhandled protocol in the NetScaler Client IP header";
791
Willy Tarreau20879a02012-12-03 16:32:10 +0100792 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
793 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100794 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100795 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
796 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
797 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
798 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
799 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
Willy Tarreau71d058c2017-07-26 20:09:56 +0200800 case CO_ER_SSL_MISMATCH: return "Server presented an SSL certificate different from the configured one";
801 case CO_ER_SSL_MISMATCH_SNI: return "Server presented an SSL certificate different from the expected one";
Willy Tarreau20879a02012-12-03 16:32:10 +0100802 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200803 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200804 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100805 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Willy Tarreau0af29122012-12-03 15:35:00 +0100806 }
807 return NULL;
808}
809
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100810static inline const char *conn_get_ctrl_name(const struct connection *conn)
811{
812 if (!conn_ctrl_ready(conn))
813 return "NONE";
814 return conn->ctrl->name;
815}
816
817static inline const char *conn_get_xprt_name(const struct connection *conn)
818{
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100819 if (!conn_xprt_ready(conn))
820 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100821 return conn->xprt->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100822}
823
Willy Tarreau53a47662017-08-28 10:53:00 +0200824static inline const char *conn_get_mux_name(const struct connection *conn)
825{
826 if (!conn->mux)
827 return "NONE";
828 return conn->mux->name;
829}
830
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200831static inline const char *cs_get_data_name(const struct conn_stream *cs)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100832{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200833 if (!cs->data_cb)
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100834 return "NONE";
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200835 return cs->data_cb->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100836}
837
Willy Tarreau13e14102016-12-22 20:25:26 +0100838/* registers pointer to transport layer <id> (XPRT_*) */
839static inline void xprt_register(int id, struct xprt_ops *xprt)
840{
841 if (id >= XPRT_ENTRIES)
842 return;
843 registered_xprt[id] = xprt;
844}
845
846/* returns pointer to transport layer <id> (XPRT_*) or NULL if not registered */
847static inline struct xprt_ops *xprt_get(int id)
848{
849 if (id >= XPRT_ENTRIES)
850 return NULL;
851 return registered_xprt[id];
852}
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100853
Willy Tarreaua9c17412016-12-04 18:42:09 +0100854static inline int conn_get_alpn(const struct connection *conn, const char **str, int *len)
855{
856 if (!conn_xprt_ready(conn) || !conn->xprt->get_alpn)
857 return 0;
858 return conn->xprt->get_alpn(conn, str, len);
859}
860
Willy Tarreau2386be62017-09-21 19:40:52 +0200861/* registers alpn mux list <list>. Modifies the list element! */
862static inline void alpn_register_mux(struct alpn_mux_list *list)
863{
864 LIST_ADDQ(&alpn_mux_list.list, &list->list);
865}
866
867/* unregisters alpn mux list <list> */
868static inline void alpn_unregister_mux(struct alpn_mux_list *list)
869{
870 LIST_DEL(&list->list);
871 LIST_INIT(&list->list);
872}
873
874/* returns the first mux in the list matching the exact same token and
875 * compatible with the proxy's mode (http or tcp). Mode "health" has to be
876 * considered as TCP here. Ie passing "px->mode == PR_MODE_HTTP" is fine. Will
877 * fall back to the first compatible mux with empty ALPN name. May return null
878 * if the code improperly registered the default mux to use as a fallback.
879 */
880static inline const struct mux_ops *alpn_get_mux(const struct ist token, int http_mode)
881{
882 struct alpn_mux_list *item;
883 const struct mux_ops *fallback = NULL;
884
885 http_mode = 1 << !!http_mode;
886
887 list_for_each_entry(item, &alpn_mux_list.list, list) {
888 if (!(item->mode & http_mode))
889 continue;
890 if (isteq(token, item->token))
891 return item->mux;
892 if (!istlen(item->token))
893 fallback = item->mux;
894 }
895 return fallback;
896}
897
898/* finds the best mux for incoming connection <conn> and mode <http_mode> for
899 * the proxy. Null cannot be returned unless there's a serious bug somewhere
900 * else (no fallback mux registered).
901 */
902static inline const struct mux_ops *conn_find_best_mux(struct connection *conn, int http_mode)
903{
904 const char *alpn_str;
905 int alpn_len;
906
907 if (!conn_get_alpn(conn, &alpn_str, &alpn_len))
908 alpn_len = 0;
909
910 return alpn_get_mux(ist2(alpn_str, alpn_len), http_mode);
911}
912
913/* finds the best mux for incoming connection <conn>, a proxy in and http mode
Willy Tarreau2e0b2b52017-09-15 06:59:55 +0200914 * <mode>, and installs it on the connection for upper context <ctx>. Returns
915 * < 0 on error.
Willy Tarreau2386be62017-09-21 19:40:52 +0200916 */
Willy Tarreau2e0b2b52017-09-15 06:59:55 +0200917static inline int conn_install_best_mux(struct connection *conn, int mode, void *ctx)
Willy Tarreau2386be62017-09-21 19:40:52 +0200918{
919 const struct mux_ops *mux_ops;
920
921 mux_ops = conn_find_best_mux(conn, mode);
922 if (!mux_ops)
923 return -1;
Willy Tarreau2e0b2b52017-09-15 06:59:55 +0200924 return conn_install_mux(conn, mux_ops, ctx);
Willy Tarreau2386be62017-09-21 19:40:52 +0200925}
926
Willy Tarreau59f98392012-07-06 14:13:49 +0200927#endif /* _PROTO_CONNECTION_H */
928
929/*
930 * Local variables:
931 * c-indent-level: 8
932 * c-basic-offset: 8
933 * End:
934 */