blob: 4b8cbeb968da303500d672b0fcffa6019e6a35dc [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;
33
34/* perform minimal intializations, report 0 in case of error, 1 if OK. */
35int init_connection();
36
Willy Tarreau59f98392012-07-06 14:13:49 +020037/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau0aa1e332016-04-14 11:13:20 +020038 * provided by the connection's sock_ops.
Willy Tarreau59f98392012-07-06 14:13:49 +020039 */
Willy Tarreau0aa1e332016-04-14 11:13:20 +020040void conn_fd_handler(int fd);
Willy Tarreau59f98392012-07-06 14:13:49 +020041
Willy Tarreau22cda212012-08-31 17:43:29 +020042/* receive a PROXY protocol header over a connection */
43int conn_recv_proxy(struct connection *conn, int flag);
David Safb76832014-05-08 23:42:08 -040044int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote);
45int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
46int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote);
Willy Tarreau22cda212012-08-31 17:43:29 +020047
Willy Tarreaud02cdd22013-12-15 10:23:20 +010048/* returns true is the transport layer is ready */
Willy Tarreauaad69382014-01-23 14:21:42 +010049static inline int conn_xprt_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010050{
Willy Tarreauaad69382014-01-23 14:21:42 +010051 return (conn->flags & CO_FL_XPRT_READY);
Willy Tarreaud02cdd22013-12-15 10:23:20 +010052}
53
54/* returns true is the control layer is ready */
Willy Tarreau3c728722014-01-23 13:50:42 +010055static inline int conn_ctrl_ready(const struct connection *conn)
Willy Tarreaud02cdd22013-12-15 10:23:20 +010056{
57 return (conn->flags & CO_FL_CTRL_READY);
58}
59
Willy Tarreauf79c8172013-10-21 16:30:56 +020060/* Calls the init() function of the transport layer if any and if not done yet,
61 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020062 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020063 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020064static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020065{
Willy Tarreauf79c8172013-10-21 16:30:56 +020066 int ret = 0;
67
Willy Tarreauaad69382014-01-23 14:21:42 +010068 if (!conn_xprt_ready(conn) && conn->xprt && conn->xprt->init)
Willy Tarreauf79c8172013-10-21 16:30:56 +020069 ret = conn->xprt->init(conn);
70
71 if (ret >= 0)
72 conn->flags |= CO_FL_XPRT_READY;
73
74 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020075}
76
Willy Tarreauf79c8172013-10-21 16:30:56 +020077/* Calls the close() function of the transport layer if any and if not done
78 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
79 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
80 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +020081 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020082static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +020083{
Willy Tarreauf79c8172013-10-21 16:30:56 +020084 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
Willy Tarreauaad69382014-01-23 14:21:42 +010085 if (conn->xprt->close)
Willy Tarreau6c03a642012-10-12 17:00:05 +020086 conn->xprt->close(conn);
Willy Tarreauf79c8172013-10-21 16:30:56 +020087 conn->flags &= ~CO_FL_XPRT_READY;
88 }
89}
90
91/* Initializes the connection's control layer which essentially consists in
92 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
Willy Tarreau3c728722014-01-23 13:50:42 +010093 * flag. The caller is responsible for ensuring that the control layer is
94 * already assigned to the connection prior to the call.
Willy Tarreauf79c8172013-10-21 16:30:56 +020095 */
96static inline void conn_ctrl_init(struct connection *conn)
97{
Willy Tarreau3c728722014-01-23 13:50:42 +010098 if (!conn_ctrl_ready(conn)) {
Willy Tarreauf79c8172013-10-21 16:30:56 +020099 int fd = conn->t.sock.fd;
100
101 fd_insert(fd);
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100102 /* mark the fd as ready so as not to needlessly poll at the beginning */
103 fd_may_recv(fd);
104 fd_may_send(fd);
Willy Tarreauf79c8172013-10-21 16:30:56 +0200105 fdtab[fd].owner = conn;
106 fdtab[fd].iocb = conn_fd_handler;
107 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200108 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200109}
110
Willy Tarreauf79c8172013-10-21 16:30:56 +0200111/* Deletes the FD if the transport layer is already gone. Once done,
112 * it then removes the CO_FL_CTRL_READY flag.
113 */
114static inline void conn_ctrl_close(struct connection *conn)
115{
116 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
117 fd_delete(conn->t.sock.fd);
118 conn->flags &= ~CO_FL_CTRL_READY;
119 }
120}
121
Willy Tarreau2b199c92012-11-23 17:32:21 +0100122/* If the connection still has a transport layer, then call its close() function
123 * if any, and delete the file descriptor if a control layer is set. This is
124 * used to close everything at once and atomically. However this is not done if
125 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
126 * transport layer very late if needed.
127 */
128static inline void conn_full_close(struct connection *conn)
129{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200130 conn_xprt_close(conn);
131 conn_ctrl_close(conn);
132}
133
134/* Force to close the connection whatever the tracking state. This is mainly
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100135 * used on the error path where the tracking does not make sense, or to kill
136 * an idle connection we want to abort immediately.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200137 */
138static inline void conn_force_close(struct connection *conn)
139{
Willy Tarreauaad69382014-01-23 14:21:42 +0100140 if (conn_xprt_ready(conn) && conn->xprt->close)
Willy Tarreauf79c8172013-10-21 16:30:56 +0200141 conn->xprt->close(conn);
142
Willy Tarreau3c728722014-01-23 13:50:42 +0100143 if (conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200144 fd_delete(conn->t.sock.fd);
145
146 conn->flags &= ~(CO_FL_XPRT_READY|CO_FL_CTRL_READY);
Willy Tarreau2b199c92012-11-23 17:32:21 +0100147}
148
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200149/* Update polling on connection <c>'s file descriptor depending on its current
150 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
151 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
152 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200153 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200154 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200155void conn_update_sock_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200156
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200157/* Update polling on connection <c>'s file descriptor depending on its current
158 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
159 * in CO_FL_WAIT_*, and the data layer expectations indicated by CO_FL_DATA_*.
160 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200161 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200162 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200163void conn_update_data_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200164
Willy Tarreau7d281492012-12-16 19:19:13 +0100165/* Refresh the connection's polling flags from its file descriptor status.
166 * This should be called at the beginning of a connection handler.
167 */
168static inline void conn_refresh_polling_flags(struct connection *conn)
169{
Willy Tarreau310987a2014-01-22 19:46:33 +0100170 conn->flags &= ~(CO_FL_WAIT_ROOM | CO_FL_WAIT_DATA);
Willy Tarreau7d281492012-12-16 19:19:13 +0100171
Willy Tarreau3c728722014-01-23 13:50:42 +0100172 if (conn_ctrl_ready(conn)) {
Willy Tarreau7d281492012-12-16 19:19:13 +0100173 unsigned int flags = conn->flags & ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA);
174
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100175 if (fd_recv_active(conn->t.sock.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100176 flags |= CO_FL_CURR_RD_ENA;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100177 if (fd_send_active(conn->t.sock.fd))
Willy Tarreau7d281492012-12-16 19:19:13 +0100178 flags |= CO_FL_CURR_WR_ENA;
179 conn->flags = flags;
180 }
181}
182
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200183/* inspects c->flags and returns non-zero if DATA ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100184 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200185 * non-zero is also returned if an error was reported on the connection. This
186 * function is used quite often and is inlined. In order to proceed optimally
187 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100188 * can be detected by a few left shifts, a xor, and a mask. These operations
189 * detect when W&D are both enabled for either direction, when C&D differ for
190 * either direction and when Error is set. The trick consists in first keeping
191 * only the bits we're interested in, since they don't collide when shifted,
192 * and to perform the AND at the end. In practice, the compiler is able to
193 * replace the last AND with a TEST in boolean conditions. This results in
194 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200195 */
196static inline unsigned int conn_data_polling_changes(const struct connection *c)
197{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100198 unsigned int f = c->flags;
199 f &= CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100200 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100201
Willy Tarreau310987a2014-01-22 19:46:33 +0100202 f = (f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ D */
203 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200204}
205
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200206/* inspects c->flags and returns non-zero if SOCK ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100207 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200208 * non-zero is also returned if an error was reported on the connection. This
209 * function is used quite often and is inlined. In order to proceed optimally
210 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100211 * can be detected by a few left shifts, a xor, and a mask. These operations
212 * detect when W&S are both enabled for either direction, when C&S differ for
213 * either direction and when Error is set. The trick consists in first keeping
214 * only the bits we're interested in, since they don't collide when shifted,
215 * and to perform the AND at the end. In practice, the compiler is able to
216 * replace the last AND with a TEST in boolean conditions. This results in
217 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200218 */
219static inline unsigned int conn_sock_polling_changes(const struct connection *c)
220{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100221 unsigned int f = c->flags;
222 f &= CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA | CO_FL_CURR_WR_ENA |
Willy Tarreau310987a2014-01-22 19:46:33 +0100223 CO_FL_CURR_RD_ENA | CO_FL_ERROR;
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100224
Willy Tarreau310987a2014-01-22 19:46:33 +0100225 f = (f ^ (f << 2)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA); /* test C ^ S */
226 return f & (CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200227}
228
229/* Automatically updates polling on connection <c> depending on the DATA flags
230 * if no handshake is in progress.
231 */
232static inline void conn_cond_update_data_polling(struct connection *c)
233{
234 if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
235 conn_update_data_polling(c);
236}
237
238/* Automatically updates polling on connection <c> depending on the SOCK flags
239 * if a handshake is in progress.
240 */
241static inline void conn_cond_update_sock_polling(struct connection *c)
242{
243 if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
244 conn_update_sock_polling(c);
245}
246
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100247/* Stop all polling on the fd. This might be used when an error is encountered
248 * for example.
249 */
250static inline void conn_stop_polling(struct connection *c)
251{
252 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
253 CO_FL_SOCK_RD_ENA | CO_FL_SOCK_WR_ENA |
254 CO_FL_DATA_RD_ENA | CO_FL_DATA_WR_ENA);
255 fd_stop_both(c->t.sock.fd);
256}
257
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200258/* Automatically update polling on connection <c> depending on the DATA and
259 * SOCK flags, and on whether a handshake is in progress or not. This may be
260 * called at any moment when there is a doubt about the effectiveness of the
261 * polling state, for instance when entering or leaving the handshake state.
262 */
263static inline void conn_cond_update_polling(struct connection *c)
264{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100265 if (unlikely(c->flags & CO_FL_ERROR))
266 conn_stop_polling(c);
267 else if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200268 conn_update_data_polling(c);
269 else if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
270 conn_update_sock_polling(c);
271}
272
273/***** Event manipulation primitives for use by DATA I/O callbacks *****/
274/* The __conn_* versions do not propagate to lower layers and are only meant
275 * to be used by handlers called by the connection handler. The other ones
276 * may be used anywhere.
277 */
278static inline void __conn_data_want_recv(struct connection *c)
279{
280 c->flags |= CO_FL_DATA_RD_ENA;
281}
282
283static inline void __conn_data_stop_recv(struct connection *c)
284{
285 c->flags &= ~CO_FL_DATA_RD_ENA;
286}
287
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200288static inline void __conn_data_want_send(struct connection *c)
289{
290 c->flags |= CO_FL_DATA_WR_ENA;
291}
292
293static inline void __conn_data_stop_send(struct connection *c)
294{
295 c->flags &= ~CO_FL_DATA_WR_ENA;
296}
297
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200298static inline void __conn_data_stop_both(struct connection *c)
299{
300 c->flags &= ~(CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA);
301}
302
303static inline void conn_data_want_recv(struct connection *c)
304{
305 __conn_data_want_recv(c);
306 conn_cond_update_data_polling(c);
307}
308
309static inline void conn_data_stop_recv(struct connection *c)
310{
311 __conn_data_stop_recv(c);
312 conn_cond_update_data_polling(c);
313}
314
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200315static inline void conn_data_want_send(struct connection *c)
316{
317 __conn_data_want_send(c);
318 conn_cond_update_data_polling(c);
319}
320
321static inline void conn_data_stop_send(struct connection *c)
322{
323 __conn_data_stop_send(c);
324 conn_cond_update_data_polling(c);
325}
326
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200327static inline void conn_data_stop_both(struct connection *c)
328{
329 __conn_data_stop_both(c);
330 conn_cond_update_data_polling(c);
331}
332
333/***** Event manipulation primitives for use by handshake I/O callbacks *****/
334/* The __conn_* versions do not propagate to lower layers and are only meant
335 * to be used by handlers called by the connection handler. The other ones
336 * may be used anywhere.
337 */
338static inline void __conn_sock_want_recv(struct connection *c)
339{
340 c->flags |= CO_FL_SOCK_RD_ENA;
341}
342
343static inline void __conn_sock_stop_recv(struct connection *c)
344{
345 c->flags &= ~CO_FL_SOCK_RD_ENA;
346}
347
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200348static inline void __conn_sock_want_send(struct connection *c)
349{
350 c->flags |= CO_FL_SOCK_WR_ENA;
351}
352
353static inline void __conn_sock_stop_send(struct connection *c)
354{
355 c->flags &= ~CO_FL_SOCK_WR_ENA;
356}
357
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200358static inline void __conn_sock_stop_both(struct connection *c)
359{
360 c->flags &= ~(CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA);
361}
362
363static inline void conn_sock_want_recv(struct connection *c)
364{
365 __conn_sock_want_recv(c);
366 conn_cond_update_sock_polling(c);
367}
368
369static inline void conn_sock_stop_recv(struct connection *c)
370{
371 __conn_sock_stop_recv(c);
372 conn_cond_update_sock_polling(c);
373}
374
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200375static inline void conn_sock_want_send(struct connection *c)
376{
377 __conn_sock_want_send(c);
378 conn_cond_update_sock_polling(c);
379}
380
381static inline void conn_sock_stop_send(struct connection *c)
382{
383 __conn_sock_stop_send(c);
384 conn_cond_update_sock_polling(c);
385}
386
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200387static inline void conn_sock_stop_both(struct connection *c)
388{
389 __conn_sock_stop_both(c);
390 conn_cond_update_sock_polling(c);
391}
Willy Tarreau8b117082012-08-06 15:06:49 +0200392
Willy Tarreau3af56a92012-08-20 16:55:48 +0200393/* shutdown management */
394static inline void conn_sock_read0(struct connection *c)
395{
396 c->flags |= CO_FL_SOCK_RD_SH;
397 __conn_sock_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100398 /* we don't risk keeping ports unusable if we found the
399 * zero from the other side.
400 */
Willy Tarreau3c728722014-01-23 13:50:42 +0100401 if (conn_ctrl_ready(c))
Willy Tarreauad38ace2013-12-15 14:19:38 +0100402 fdtab[c->t.sock.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200403}
404
405static inline void conn_data_read0(struct connection *c)
406{
407 c->flags |= CO_FL_DATA_RD_SH;
408 __conn_data_stop_recv(c);
409}
410
411static inline void conn_sock_shutw(struct connection *c)
412{
413 c->flags |= CO_FL_SOCK_WR_SH;
414 __conn_sock_stop_send(c);
415}
416
417static inline void conn_data_shutw(struct connection *c)
418{
419 c->flags |= CO_FL_DATA_WR_SH;
420 __conn_data_stop_send(c);
421}
422
423/* detect sock->data read0 transition */
424static inline int conn_data_read0_pending(struct connection *c)
425{
426 return (c->flags & (CO_FL_DATA_RD_SH | CO_FL_SOCK_RD_SH)) == CO_FL_SOCK_RD_SH;
427}
428
429/* detect data->sock shutw transition */
430static inline int conn_sock_shutw_pending(struct connection *c)
431{
432 return (c->flags & (CO_FL_DATA_WR_SH | CO_FL_SOCK_WR_SH)) == CO_FL_DATA_WR_SH;
433}
434
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200435/* prepares a connection to work with protocol <proto> and transport <xprt>.
436 * The transport's context is initialized as well.
437 */
438static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
439{
440 conn->ctrl = proto;
441 conn->xprt = xprt;
442 conn->xprt_st = 0;
443 conn->xprt_ctx = NULL;
444}
445
Willy Tarreaud0155772013-10-14 17:10:08 +0200446/* Initializes all required fields for a new connection. Note that it does the
447 * minimum acceptable initialization for a connection that already exists and
448 * is about to be reused. It also leaves the addresses untouched, which makes
449 * it usable across connection retries to reset a connection to a known state.
450 */
451static inline void conn_init(struct connection *conn)
452{
453 conn->obj_type = OBJ_TYPE_CONN;
454 conn->flags = CO_FL_NONE;
Willy Tarreaud0155772013-10-14 17:10:08 +0200455 conn->data = NULL;
456 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200457 conn->send_proxy_ofs = 0;
Willy Tarreaud0155772013-10-14 17:10:08 +0200458 conn->t.sock.fd = -1; /* just to help with debugging */
459 conn->err_code = CO_ER_NONE;
460 conn->target = NULL;
461}
462
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200463/* Tries to allocate a new connection and initialized its main fields. The
464 * connection is returned on success, NULL on failure. The connection must
465 * be released using pool_free2() or conn_free().
466 */
467static inline struct connection *conn_new()
468{
469 struct connection *conn;
470
471 conn = pool_alloc2(pool2_connection);
472 if (likely(conn != NULL))
473 conn_init(conn);
474 return conn;
475}
476
477/* Releases a connection previously allocated by conn_new() */
478static inline void conn_free(struct connection *conn)
479{
480 pool_free2(pool2_connection, conn);
481}
482
483
Willy Tarreau986a9d22012-08-30 21:11:38 +0200484/* Retrieves the connection's source address */
485static inline void conn_get_from_addr(struct connection *conn)
486{
487 if (conn->flags & CO_FL_ADDR_FROM_SET)
488 return;
489
Willy Tarreau3c728722014-01-23 13:50:42 +0100490 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200491 return;
492
493 if (conn->ctrl->get_src(conn->t.sock.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100494 sizeof(conn->addr.from),
495 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200496 return;
497 conn->flags |= CO_FL_ADDR_FROM_SET;
498}
499
500/* Retrieves the connection's original destination address */
501static inline void conn_get_to_addr(struct connection *conn)
502{
503 if (conn->flags & CO_FL_ADDR_TO_SET)
504 return;
505
Willy Tarreau3c728722014-01-23 13:50:42 +0100506 if (!conn_ctrl_ready(conn) || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200507 return;
508
509 if (conn->ctrl->get_dst(conn->t.sock.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100510 sizeof(conn->addr.to),
511 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200512 return;
513 conn->flags |= CO_FL_ADDR_TO_SET;
514}
515
Willy Tarreau7abddb52013-10-24 15:31:04 +0200516/* Attaches a connection to an owner and assigns a data layer */
517static inline void conn_attach(struct connection *conn, void *owner, const struct data_cb *data)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200518{
Willy Tarreau74beec32012-10-03 00:41:04 +0200519 conn->data = data;
Willy Tarreaucd379952012-09-27 22:14:33 +0200520 conn->owner = owner;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200521}
522
Willy Tarreau2aefad52014-01-20 11:41:52 +0100523/* Drains possibly pending incoming data on the file descriptor attached to the
524 * connection and update the connection's flags accordingly. This is used to
525 * know whether we need to disable lingering on close. Returns non-zero if it
526 * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH
527 * flag may also be updated if the incoming shutdown was reported by the drain()
528 * function.
529 */
530static inline int conn_drain(struct connection *conn)
531{
Willy Tarreau2aefad52014-01-20 11:41:52 +0100532 if (!conn_ctrl_ready(conn))
533 return 1;
534
535 if (conn->flags & CO_FL_SOCK_RD_SH)
536 return 1;
537
Willy Tarreau310987a2014-01-22 19:46:33 +0100538 if (!fd_recv_ready(conn->t.sock.fd))
Willy Tarreau2aefad52014-01-20 11:41:52 +0100539 return 0;
540
541 if (!conn->ctrl->drain)
542 return 0;
543
Willy Tarreaue1f50c42014-01-22 20:02:06 +0100544 if (conn->ctrl->drain(conn->t.sock.fd) <= 0)
Willy Tarreau2aefad52014-01-20 11:41:52 +0100545 return 0;
546
547 conn->flags |= CO_FL_SOCK_RD_SH;
548 return 1;
549}
550
Willy Tarreau0af29122012-12-03 15:35:00 +0100551/* returns a human-readable error code for conn->err_code, or NULL if the code
552 * is unknown.
553 */
554static inline const char *conn_err_code_str(struct connection *c)
555{
556 switch (c->err_code) {
557 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100558
559 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
560 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
561 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
562 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
563 case CO_ER_NOPROTO: return "Protocol or address family not supported";
564 case CO_ER_SOCK_ERR: return "General socket error";
565 case CO_ER_PORT_RANGE: return "Source port range exhausted";
566 case CO_ER_CANT_BIND: return "Can't bind to source address";
567 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
568 case CO_ER_ADDR_INUSE: return "Local source address already in use";
569
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100570 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
571 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100572 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100573 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
574 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
575 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
576 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Willy Tarreau20879a02012-12-03 16:32:10 +0100577 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
578 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100579 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100580 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
581 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
582 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
583 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
584 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
585 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreaub3966372014-04-25 18:54:29 +0200586 case CO_ER_SSL_HANDSHAKE_HB: return "SSL handshake failure after heartbeat";
Willy Tarreauf51c6982014-04-25 20:02:39 +0200587 case CO_ER_SSL_KILLED_HB: return "Stopped a TLSv1 heartbeat attack (CVE-2014-0160)";
Willy Tarreau830bf612013-12-01 20:29:58 +0100588 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Willy Tarreau0af29122012-12-03 15:35:00 +0100589 }
590 return NULL;
591}
592
Willy Tarreau59f98392012-07-06 14:13:49 +0200593#endif /* _PROTO_CONNECTION_H */
594
595/*
596 * Local variables:
597 * c-indent-level: 8
598 * c-basic-offset: 8
599 * End:
600 */