blob: 2380bb8118dde245d2eb668271eae1e16aab2f9e [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 Tarreauf2943dc2012-10-26 20:10:28 +020026#include <common/memory.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020027#include <types/connection.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020028#include <types/listener.h>
Willy Tarreau2b199c92012-11-23 17:32:21 +010029#include <proto/fd.h>
Willy Tarreau3fdb3662012-11-12 00:42:33 +010030#include <proto/obj_type.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020031
Willy Tarreauf2943dc2012-10-26 20:10:28 +020032extern struct pool_head *pool2_connection;
Willy Tarreau13e14102016-12-22 20:25:26 +010033extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
Willy Tarreauf2943dc2012-10-26 20:10:28 +020034
35/* perform minimal intializations, report 0 in case of error, 1 if OK. */
36int init_connection();
37
Willy Tarreau59f98392012-07-06 14:13:49 +020038/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020039 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020040 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020041void conn_fd_handler(int fd);
Willy Tarreau59f98392012-07-06 14:13:49 +020042
Willy Tarreau22cda212012-08-31 17:43:29 +020043/* receive a PROXY protocol header over a connection */
44int conn_recv_proxy(struct connection *conn, int flag);
David Safb76832014-05-08 23:42:08 -040045int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote);
46int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
47int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
Willy Tarreau22cda212012-08-31 17:43:29 +020048
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010049/* receive a NetScaler Client IP insertion header over a connection */
50int conn_recv_netscaler_cip(struct connection *conn, int flag);
51
Willy Tarreauff3e6482015-03-12 23:56:52 +010052/* raw send() directly on the socket */
53int conn_sock_send(struct connection *conn, const void *buf, int len, int flags);
54
Willy Tarreaud85c4852015-03-13 00:40:28 +010055/* drains any pending bytes from the socket */
56int conn_sock_drain(struct connection *conn);
57
Willy Tarreaud02cdd22013-12-15 10:23:20 +010058/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010059static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010060{
Willy Tarreauaad69382014-01-23 14:21:42 +010061 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010062}
63
64/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010065static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010066{
67 return (conn->flags & CO_FL_CTRL_READY);
68}
69
Willy Tarreauf79c8172013-10-21 16:30:56 +020070/* Calls the init() function of the transport layer if any and if not done yet,
71 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020072 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020073 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020074static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020075{
Willy Tarreauf79c8172013-10-21 16:30:56 +020076 int ret = 0;
77
Willy Tarreauaad69382014-01-23 14:21:42 +010078 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Willy Tarreauf79c8172013-10-21 16:30:56 +020079 ret = conn->xprt->init(conn);
80
81 if (ret >= 0)
82 conn->flags |= CO_FL_XPRT_READY;
83
84 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020085}
86
Willy Tarreauf79c8172013-10-21 16:30:56 +020087/* Calls the close() function of the transport layer if any and if not done
88 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
89 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
90 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +020091 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020092static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +020093{
Willy Tarreauf79c8172013-10-21 16:30:56 +020094 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +010095 if (conn->xprt->close)
Willy Tarreau6c03a642012-10-12 17:00:05 +020096 conn->xprt->close(conn);
Willy Tarreauf79c8172013-10-21 16:30:56 +020097 conn->flags &= ~CO_FL_XPRT_READY;
98 }
99}
100
101/* Initializes the connection's control layer which essentially consists in
102 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +0100103 * flag. The caller is responsible for ensuring that the control layer is
104 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200105 */
106static inline void conn_ctrl_init(struct connection *conn)
107{
Willy Tarreau3c728722014-01-23 13:50:42 +0100108 if (!conn_ctrl_ready(conn)) {
Willy Tarreauf79c8172013-10-21 16:30:56 +0200109 int fd = conn->t.sock.fd;
110
111 fd_insert(fd);
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100112 /* mark the fd as ready so as not to needlessly poll at the beginning */
113 fd_may_recv(fd);
114 fd_may_send(fd);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200115 fdtab[fd].owner = conn;
116 fdtab[fd].iocb = conn_fd_handler;
117 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200118 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200119}
120
Willy Tarreauf79c8172013-10-21 16:30:56 +0200121/* Deletes the FD if the transport layer is already gone. Once done,
122 * it then removes the CO_FL_CTRL_READY flag.
123 */
124static inline void conn_ctrl_close(struct connection *conn)
125{
126 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
127 fd_delete(conn->t.sock.fd);
128 conn->flags &= ~CO_FL_CTRL_READY;
129 }
130}
131
Willy Tarreau2b199c92012-11-23 17:32:21 +0100132/* If the connection still has a transport layer, then call its close() function
133 * if any, and delete the file descriptor if a control layer is set. This is
134 * used to close everything at once and atomically. However this is not done if
135 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
136 * transport layer very late if needed.
137 */
138static inline void conn_full_close(struct connection *conn)
139{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200140 conn_xprt_close(conn);
141 conn_ctrl_close(conn);
142}
143
144/* Force to close the connection whatever the tracking state. This is mainly
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100145 * used on the error path where the tracking does not make sense, or to kill
146 * an idle connection we want to abort immediately.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200147 */
148static inline void conn_force_close(struct connection *conn)
149{
Willy Tarreauaad69382014-01-23 14:21:42 +0100150 if (conn_xprt_ready(conn) && conn->xprt->close)
Willy Tarreauf79c8172013-10-21 16:30:56 +0200151 conn->xprt->close(conn);
152
Willy Tarreau3c728722014-01-23 13:50:42 +0100153 if (conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200154 fd_delete(conn->t.sock.fd);
155
Willy Tarreau733b1322016-11-17 14:22:52 +0100156 conn->t.sock.fd = DEAD_FD_MAGIC;
Willy Tarreauf79c8172013-10-21 16:30:56 +0200157 conn->flags &= ~(CO_FL_XPRT_READY|CO_FL_CTRL_READY);
Willy Tarreau2b199c92012-11-23 17:32:21 +0100158}
159
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200160/* Update polling on connection <c>'s file descriptor depending on its current
161 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
162 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
163 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200164 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200165 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200166void conn_update_sock_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200167
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200168/* Update polling on connection <c>'s file descriptor depending on its current
169 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
170 * in CO_FL_WAIT_*, and the data layer expectations indicated by CO_FL_DATA_*.
171 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200172 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200173 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200174void conn_update_data_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200175
Willy Tarreau7d281492012-12-16 19:19:13 +0100176/* Refresh the connection's polling flags from its file descriptor status.
177 * This should be called at the beginning of a connection handler.
178 */
179static inline void conn_refresh_polling_flags(struct connection *conn)
180{
Willy Tarreau310987a2014-01-22 19:46:33 +0100181 conn->flags &= ~(CO_FL_WAIT_ROOM | CO_FL_WAIT_DATA);
Willy Tarreau7d281492012-12-16 19:19:13 +0100182
Willy Tarreau3c728722014-01-23 13:50:42 +0100183 if (conn_ctrl_ready(conn)) {
Willy Tarreau7d281492012-12-16 19:19:13 +0100184 unsigned int flags = conn->flags & ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA);
185
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100186 if (fd_recv_active(conn->t.sock.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100187 flags |= CO_FL_CURR_RD_ENA;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100188 if (fd_send_active(conn->t.sock.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100189 flags |= CO_FL_CURR_WR_ENA;
190 conn->flags = flags;
191 }
192}
193
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200194/* inspects c->flags and returns non-zero if DATA ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100195 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200196 * non-zero is also returned if an error was reported on the connection. This
197 * function is used quite often and is inlined. In order to proceed optimally
198 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100199 * can be detected by a few left shifts, a xor, and a mask. These operations
200 * detect when W&D are both enabled for either direction, when C&D differ for
201 * either direction and when Error is set. The trick consists in first keeping
202 * only the bits we're interested in, since they don't collide when shifted,
203 * and to perform the AND at the end. In practice, the compiler is able to
204 * replace the last AND with a TEST in boolean conditions. This results in
205 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200206 */
207static inline unsigned int conn_data_polling_changes(const struct connection *c)
208{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100209 unsigned int f = c->flags;
210 f &= CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100211 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100212
Willy Tarreau310987a2014-01-22 19:46:33 +0100213 f = (f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ D */
214 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200215}
216
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200217/* inspects c->flags and returns non-zero if SOCK ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100218 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200219 * non-zero is also returned if an error was reported on the connection. This
220 * function is used quite often and is inlined. In order to proceed optimally
221 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100222 * can be detected by a few left shifts, a xor, and a mask. These operations
223 * detect when W&S are both enabled for either direction, when C&S differ for
224 * either direction and when Error is set. The trick consists in first keeping
225 * only the bits we're interested in, since they don't collide when shifted,
226 * and to perform the AND at the end. In practice, the compiler is able to
227 * replace the last AND with a TEST in boolean conditions. This results in
228 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200229 */
230static inline unsigned int conn_sock_polling_changes(const struct connection *c)
231{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100232 unsigned int f = c->flags;
233 f &= CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100234 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100235
Willy Tarreau310987a2014-01-22 19:46:33 +0100236 f = (f ^ (f << 2)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ S */
237 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200238}
239
240/* Automatically updates polling on connection <c> depending on the DATA flags
241 * if no handshake is in progress.
242 */
243static inline void conn_cond_update_data_polling(struct connection *c)
244{
245 if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
246 conn_update_data_polling(c);
247}
248
249/* Automatically updates polling on connection <c> depending on the SOCK flags
250 * if a handshake is in progress.
251 */
252static inline void conn_cond_update_sock_polling(struct connection *c)
253{
254 if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
255 conn_update_sock_polling(c);
256}
257
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100258/* Stop all polling on the fd. This might be used when an error is encountered
259 * for example.
260 */
261static inline void conn_stop_polling(struct connection *c)
262{
263 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
264 CO_FL_SOCK_RD_ENA | CO_FL_SOCK_WR_ENA |
265 CO_FL_DATA_RD_ENA | CO_FL_DATA_WR_ENA);
Willy Tarreau350135c2016-11-17 12:05:13 +0100266 if (conn_ctrl_ready(c))
267 fd_stop_both(c->t.sock.fd);
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100268}
269
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200270/* Automatically update polling on connection <c> depending on the DATA and
271 * SOCK flags, and on whether a handshake is in progress or not. This may be
272 * called at any moment when there is a doubt about the effectiveness of the
273 * polling state, for instance when entering or leaving the handshake state.
274 */
275static inline void conn_cond_update_polling(struct connection *c)
276{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100277 if (unlikely(c->flags & CO_FL_ERROR))
278 conn_stop_polling(c);
279 else if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200280 conn_update_data_polling(c);
281 else if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
282 conn_update_sock_polling(c);
283}
284
285/***** Event manipulation primitives for use by DATA I/O callbacks *****/
286/* The __conn_* versions do not propagate to lower layers and are only meant
287 * to be used by handlers called by the connection handler. The other ones
288 * may be used anywhere.
289 */
290static inline void __conn_data_want_recv(struct connection *c)
291{
292 c->flags |= CO_FL_DATA_RD_ENA;
293}
294
295static inline void __conn_data_stop_recv(struct connection *c)
296{
297 c->flags &= ~CO_FL_DATA_RD_ENA;
298}
299
Willy Tarreau796c5b72016-11-29 21:47:02 +0100300/* this one is used only to stop speculative recv(). It doesn't stop it if the
301 * fd is already polled in order to avoid expensive polling status changes.
302 * Since it might require the upper layer to re-enable reading, we'll return 1
303 * if we've really stopped something otherwise zero.
304 */
305static inline int __conn_data_done_recv(struct connection *c)
306{
307 if (!conn_ctrl_ready(c) || !fd_recv_polled(c->t.sock.fd)) {
308 c->flags &= ~CO_FL_DATA_RD_ENA;
309 return 1;
310 }
311 return 0;
312}
313
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200314static inline void __conn_data_want_send(struct connection *c)
315{
316 c->flags |= CO_FL_DATA_WR_ENA;
317}
318
319static inline void __conn_data_stop_send(struct connection *c)
320{
321 c->flags &= ~CO_FL_DATA_WR_ENA;
322}
323
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200324static inline void __conn_data_stop_both(struct connection *c)
325{
326 c->flags &= ~(CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA);
327}
328
329static inline void conn_data_want_recv(struct connection *c)
330{
331 __conn_data_want_recv(c);
332 conn_cond_update_data_polling(c);
333}
334
335static inline void conn_data_stop_recv(struct connection *c)
336{
337 __conn_data_stop_recv(c);
338 conn_cond_update_data_polling(c);
339}
340
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200341static inline void conn_data_want_send(struct connection *c)
342{
343 __conn_data_want_send(c);
344 conn_cond_update_data_polling(c);
345}
346
347static inline void conn_data_stop_send(struct connection *c)
348{
349 __conn_data_stop_send(c);
350 conn_cond_update_data_polling(c);
351}
352
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200353static inline void conn_data_stop_both(struct connection *c)
354{
355 __conn_data_stop_both(c);
356 conn_cond_update_data_polling(c);
357}
358
359/***** Event manipulation primitives for use by handshake I/O callbacks *****/
360/* The __conn_* versions do not propagate to lower layers and are only meant
361 * to be used by handlers called by the connection handler. The other ones
362 * may be used anywhere.
363 */
364static inline void __conn_sock_want_recv(struct connection *c)
365{
366 c->flags |= CO_FL_SOCK_RD_ENA;
367}
368
369static inline void __conn_sock_stop_recv(struct connection *c)
370{
371 c->flags &= ~CO_FL_SOCK_RD_ENA;
372}
373
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200374static inline void __conn_sock_want_send(struct connection *c)
375{
376 c->flags |= CO_FL_SOCK_WR_ENA;
377}
378
379static inline void __conn_sock_stop_send(struct connection *c)
380{
381 c->flags &= ~CO_FL_SOCK_WR_ENA;
382}
383
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200384static inline void __conn_sock_stop_both(struct connection *c)
385{
386 c->flags &= ~(CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA);
387}
388
389static inline void conn_sock_want_recv(struct connection *c)
390{
391 __conn_sock_want_recv(c);
392 conn_cond_update_sock_polling(c);
393}
394
395static inline void conn_sock_stop_recv(struct connection *c)
396{
397 __conn_sock_stop_recv(c);
398 conn_cond_update_sock_polling(c);
399}
400
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200401static inline void conn_sock_want_send(struct connection *c)
402{
403 __conn_sock_want_send(c);
404 conn_cond_update_sock_polling(c);
405}
406
407static inline void conn_sock_stop_send(struct connection *c)
408{
409 __conn_sock_stop_send(c);
410 conn_cond_update_sock_polling(c);
411}
412
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200413static inline void conn_sock_stop_both(struct connection *c)
414{
415 __conn_sock_stop_both(c);
416 conn_cond_update_sock_polling(c);
417}
Willy Tarreau8b117082012-08-06 15:06:49 +0200418
Willy Tarreau3af56a92012-08-20 16:55:48 +0200419/* shutdown management */
420static inline void conn_sock_read0(struct connection *c)
421{
422 c->flags |= CO_FL_SOCK_RD_SH;
423 __conn_sock_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100424 /* we don't risk keeping ports unusable if we found the
425 * zero from the other side.
426 */
Willy Tarreau3c728722014-01-23 13:50:42 +0100427 if (conn_ctrl_ready(c))
Willy Tarreauad38ace2013-12-15 14:19:38 +0100428 fdtab[c->t.sock.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200429}
430
431static inline void conn_data_read0(struct connection *c)
432{
433 c->flags |= CO_FL_DATA_RD_SH;
434 __conn_data_stop_recv(c);
435}
436
437static inline void conn_sock_shutw(struct connection *c)
438{
439 c->flags |= CO_FL_SOCK_WR_SH;
440 __conn_sock_stop_send(c);
Willy Tarreaua02e8c92015-03-12 22:42:29 +0100441 if (conn_ctrl_ready(c))
442 shutdown(c->t.sock.fd, SHUT_WR);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200443}
444
445static inline void conn_data_shutw(struct connection *c)
446{
447 c->flags |= CO_FL_DATA_WR_SH;
448 __conn_data_stop_send(c);
Willy Tarreau729c69f2015-03-12 22:51:10 +0100449
450 /* clean data-layer shutdown */
451 if (c->xprt && c->xprt->shutw)
452 c->xprt->shutw(c, 1);
453}
454
455static inline void conn_data_shutw_hard(struct connection *c)
456{
457 c->flags |= CO_FL_DATA_WR_SH;
458 __conn_data_stop_send(c);
459
460 /* unclean data-layer shutdown */
461 if (c->xprt && c->xprt->shutw)
462 c->xprt->shutw(c, 0);
Willy Tarreau3af56a92012-08-20 16:55:48 +0200463}
464
465/* detect sock->data read0 transition */
466static inline int conn_data_read0_pending(struct connection *c)
467{
468 return (c->flags & (CO_FL_DATA_RD_SH | CO_FL_SOCK_RD_SH)) == CO_FL_SOCK_RD_SH;
469}
470
471/* detect data->sock shutw transition */
472static inline int conn_sock_shutw_pending(struct connection *c)
473{
474 return (c->flags & (CO_FL_DATA_WR_SH | CO_FL_SOCK_WR_SH)) == CO_FL_DATA_WR_SH;
475}
476
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200477/* prepares a connection to work with protocol <proto> and transport <xprt>.
478 * The transport's context is initialized as well.
479 */
480static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
481{
482 conn->ctrl = proto;
483 conn->xprt = xprt;
484 conn->xprt_st = 0;
485 conn->xprt_ctx = NULL;
486}
487
Willy Tarreaud0155772013-10-14 17:10:08 +0200488/* Initializes all required fields for a new connection. Note that it does the
489 * minimum acceptable initialization for a connection that already exists and
490 * is about to be reused. It also leaves the addresses untouched, which makes
491 * it usable across connection retries to reset a connection to a known state.
492 */
493static inline void conn_init(struct connection *conn)
494{
495 conn->obj_type = OBJ_TYPE_CONN;
496 conn->flags = CO_FL_NONE;
Willy Tarreaud0155772013-10-14 17:10:08 +0200497 conn->data = NULL;
498 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200499 conn->send_proxy_ofs = 0;
Willy Tarreau733b1322016-11-17 14:22:52 +0100500 conn->t.sock.fd = DEAD_FD_MAGIC;
Willy Tarreaud0155772013-10-14 17:10:08 +0200501 conn->err_code = CO_ER_NONE;
502 conn->target = NULL;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100503 conn->proxy_netns = NULL;
Willy Tarreaud75d40e2015-08-04 17:25:58 +0200504 LIST_INIT(&conn->list);
Willy Tarreaud0155772013-10-14 17:10:08 +0200505}
506
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200507/* Tries to allocate a new connection and initialized its main fields. The
508 * connection is returned on success, NULL on failure. The connection must
509 * be released using pool_free2() or conn_free().
510 */
511static inline struct connection *conn_new()
512{
513 struct connection *conn;
514
515 conn = pool_alloc2(pool2_connection);
516 if (likely(conn != NULL))
517 conn_init(conn);
518 return conn;
519}
520
521/* Releases a connection previously allocated by conn_new() */
522static inline void conn_free(struct connection *conn)
523{
524 pool_free2(pool2_connection, conn);
525}
526
527
Willy Tarreau986a9d22012-08-30 21:11:38 +0200528/* Retrieves the connection's source address */
529static inline void conn_get_from_addr(struct connection *conn)
530{
531 if (conn->flags & CO_FL_ADDR_FROM_SET)
532 return;
533
Willy Tarreau3c728722014-01-23 13:50:42 +0100534 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200535 return;
536
537 if (conn->ctrl->get_src(conn->t.sock.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100538 sizeof(conn->addr.from),
539 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200540 return;
541 conn->flags |= CO_FL_ADDR_FROM_SET;
542}
543
544/* Retrieves the connection's original destination address */
545static inline void conn_get_to_addr(struct connection *conn)
546{
547 if (conn->flags & CO_FL_ADDR_TO_SET)
548 return;
549
Willy Tarreau3c728722014-01-23 13:50:42 +0100550 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200551 return;
552
553 if (conn->ctrl->get_dst(conn->t.sock.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100554 sizeof(conn->addr.to),
555 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200556 return;
557 conn->flags |= CO_FL_ADDR_TO_SET;
558}
559
Willy Tarreau7abddb52013-10-24 15:31:04 +0200560/* Attaches a connection to an owner and assigns a data layer */
561static inline void conn_attach(struct connection *conn, void *owner, const struct data_cb *data)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200562{
Willy Tarreau74beec32012-10-03 00:41:04 +0200563 conn->data = data;
Willy Tarreaucd379952012-09-27 22:14:33 +0200564 conn->owner = owner;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200565}
566
Willy Tarreau0af29122012-12-03 15:35:00 +0100567/* returns a human-readable error code for conn->err_code, or NULL if the code
568 * is unknown.
569 */
570static inline const char *conn_err_code_str(struct connection *c)
571{
572 switch (c->err_code) {
573 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100574
575 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
576 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
577 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
578 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
579 case CO_ER_NOPROTO: return "Protocol or address family not supported";
580 case CO_ER_SOCK_ERR: return "General socket error";
581 case CO_ER_PORT_RANGE: return "Source port range exhausted";
582 case CO_ER_CANT_BIND: return "Can't bind to source address";
583 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
584 case CO_ER_ADDR_INUSE: return "Local source address already in use";
585
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100586 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
587 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100588 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100589 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
590 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
591 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
592 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100593
594 case CO_ER_CIP_EMPTY: return "Connection closed while waiting for NetScaler Client IP header";
595 case CO_ER_CIP_ABORT: return "Connection error while waiting for NetScaler Client IP header";
596 case CO_ER_CIP_TRUNCATED: return "Truncated NetScaler Client IP header received";
597 case CO_ER_CIP_BAD_MAGIC: return "Received an invalid NetScaler Client IP magic number";
598 case CO_ER_CIP_BAD_PROTO: return "Received an unhandled protocol in the NetScaler Client IP header";
599
Willy Tarreau20879a02012-12-03 16:32:10 +0100600 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
601 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100602 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100603 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
604 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
605 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
606 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
607 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
608 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200609 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200610 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100611 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Willy Tarreau0af29122012-12-03 15:35:00 +0100612 }
613 return NULL;
614}
615
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100616static inline const char *conn_get_ctrl_name(const struct connection *conn)
617{
618 if (!conn_ctrl_ready(conn))
619 return "NONE";
620 return conn->ctrl->name;
621}
622
623static inline const char *conn_get_xprt_name(const struct connection *conn)
624{
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100625 if (!conn_xprt_ready(conn))
626 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100627 return conn->xprt->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100628}
629
630static inline const char *conn_get_data_name(const struct connection *conn)
631{
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100632 if (!conn->data)
633 return "NONE";
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +0100634 return conn->data->name;
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100635}
636
Willy Tarreau13e14102016-12-22 20:25:26 +0100637/* registers pointer to transport layer <id> (XPRT_*) */
638static inline void xprt_register(int id, struct xprt_ops *xprt)
639{
640 if (id >= XPRT_ENTRIES)
641 return;
642 registered_xprt[id] = xprt;
643}
644
645/* returns pointer to transport layer <id> (XPRT_*) or NULL if not registered */
646static inline struct xprt_ops *xprt_get(int id)
647{
648 if (id >= XPRT_ENTRIES)
649 return NULL;
650 return registered_xprt[id];
651}
Willy Tarreau2dc770c2016-11-23 18:00:08 +0100652
Willy Tarreau59f98392012-07-06 14:13:49 +0200653#endif /* _PROTO_CONNECTION_H */
654
655/*
656 * Local variables:
657 * c-indent-level: 8
658 * c-basic-offset: 8
659 * End:
660 */