blob: af995cd1566695e240b9c60b6d39a23543c669e1 [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 Tarreauafad0e02012-08-09 14:45:22 +020038 * provided by the connection's sock_ops. Returns 0.
Willy Tarreau59f98392012-07-06 14:13:49 +020039 */
40int conn_fd_handler(int fd);
41
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);
Willy Tarreaue1e4a612012-10-05 00:10:55 +020044int make_proxy_line(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst);
Willy Tarreau22cda212012-08-31 17:43:29 +020045
Willy Tarreaud02cdd22013-12-15 10:23:20 +010046/* returns true is the transport layer is ready */
47static inline int conn_xprt_ready(struct connection *conn)
48{
49 return (conn->flags & CO_FL_XPRT_READY) && conn->xprt;
50}
51
52/* returns true is the control layer is ready */
53static inline int conn_ctrl_ready(struct connection *conn)
54{
55 return (conn->flags & CO_FL_CTRL_READY);
56}
57
Willy Tarreauf79c8172013-10-21 16:30:56 +020058/* Calls the init() function of the transport layer if any and if not done yet,
59 * and sets the CO_FL_XPRT_READY flag to indicate it was properly initialized.
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020060 * Returns <0 in case of error.
Willy Tarreau15678ef2012-08-31 13:54:11 +020061 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020062static inline int conn_xprt_init(struct connection *conn)
Willy Tarreau15678ef2012-08-31 13:54:11 +020063{
Willy Tarreauf79c8172013-10-21 16:30:56 +020064 int ret = 0;
65
66 if (!(conn->flags & CO_FL_XPRT_READY) && conn->xprt && conn->xprt->init)
67 ret = conn->xprt->init(conn);
68
69 if (ret >= 0)
70 conn->flags |= CO_FL_XPRT_READY;
71
72 return ret;
Willy Tarreau15678ef2012-08-31 13:54:11 +020073}
74
Willy Tarreauf79c8172013-10-21 16:30:56 +020075/* Calls the close() function of the transport layer if any and if not done
76 * yet, and clears the CO_FL_XPRT_READY flag. However this is not done if the
77 * CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
78 * transport layer very late if needed.
Willy Tarreau6c03a642012-10-12 17:00:05 +020079 */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020080static inline void conn_xprt_close(struct connection *conn)
Willy Tarreau8b117082012-08-06 15:06:49 +020081{
Willy Tarreauf79c8172013-10-21 16:30:56 +020082 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_XPRT_TRACKED)) == CO_FL_XPRT_READY) {
83 if (conn->xprt && conn->xprt->close)
Willy Tarreau6c03a642012-10-12 17:00:05 +020084 conn->xprt->close(conn);
Willy Tarreauf79c8172013-10-21 16:30:56 +020085 conn->flags &= ~CO_FL_XPRT_READY;
86 }
87}
88
89/* Initializes the connection's control layer which essentially consists in
90 * registering the file descriptor for polling and setting the CO_FL_CTRL_READY
91 * flag.
92 */
93static inline void conn_ctrl_init(struct connection *conn)
94{
95 if (!(conn->flags & CO_FL_CTRL_READY)) {
96 int fd = conn->t.sock.fd;
97
98 fd_insert(fd);
99 fdtab[fd].owner = conn;
100 fdtab[fd].iocb = conn_fd_handler;
101 conn->flags |= CO_FL_CTRL_READY;
Willy Tarreau6c03a642012-10-12 17:00:05 +0200102 }
Willy Tarreau8b117082012-08-06 15:06:49 +0200103}
104
Willy Tarreauf79c8172013-10-21 16:30:56 +0200105/* Deletes the FD if the transport layer is already gone. Once done,
106 * it then removes the CO_FL_CTRL_READY flag.
107 */
108static inline void conn_ctrl_close(struct connection *conn)
109{
110 if ((conn->flags & (CO_FL_XPRT_READY|CO_FL_CTRL_READY)) == CO_FL_CTRL_READY) {
111 fd_delete(conn->t.sock.fd);
112 conn->flags &= ~CO_FL_CTRL_READY;
113 }
114}
115
Willy Tarreau2b199c92012-11-23 17:32:21 +0100116/* If the connection still has a transport layer, then call its close() function
117 * if any, and delete the file descriptor if a control layer is set. This is
118 * used to close everything at once and atomically. However this is not done if
119 * the CO_FL_XPRT_TRACKED flag is set, which allows logs to take data from the
120 * transport layer very late if needed.
121 */
122static inline void conn_full_close(struct connection *conn)
123{
Willy Tarreauf79c8172013-10-21 16:30:56 +0200124 conn_xprt_close(conn);
125 conn_ctrl_close(conn);
126}
127
128/* Force to close the connection whatever the tracking state. This is mainly
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100129 * used on the error path where the tracking does not make sense, or to kill
130 * an idle connection we want to abort immediately.
Willy Tarreauf79c8172013-10-21 16:30:56 +0200131 */
132static inline void conn_force_close(struct connection *conn)
133{
134 if ((conn->flags & CO_FL_XPRT_READY) && conn->xprt && conn->xprt->close)
135 conn->xprt->close(conn);
136
137 if (conn->flags & CO_FL_CTRL_READY)
138 fd_delete(conn->t.sock.fd);
139
140 conn->flags &= ~(CO_FL_XPRT_READY|CO_FL_CTRL_READY);
Willy Tarreau2b199c92012-11-23 17:32:21 +0100141}
142
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200143/* Update polling on connection <c>'s file descriptor depending on its current
144 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
145 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
146 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200147 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200148 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200149void conn_update_sock_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200150
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200151/* Update polling on connection <c>'s file descriptor depending on its current
152 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
153 * in CO_FL_WAIT_*, and the data layer expectations indicated by CO_FL_DATA_*.
154 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200155 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200156 */
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200157void conn_update_data_polling(struct connection *c);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200158
Willy Tarreau7d281492012-12-16 19:19:13 +0100159/* Refresh the connection's polling flags from its file descriptor status.
160 * This should be called at the beginning of a connection handler.
161 */
162static inline void conn_refresh_polling_flags(struct connection *conn)
163{
164 conn->flags &= ~(CO_FL_WAIT_ROOM | CO_FL_WAIT_RD | CO_FL_WAIT_DATA | CO_FL_WAIT_WR);
165
Willy Tarreauf79c8172013-10-21 16:30:56 +0200166 if ((conn->flags & CO_FL_CTRL_READY) && conn->ctrl) {
Willy Tarreau7d281492012-12-16 19:19:13 +0100167 unsigned int flags = conn->flags & ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA);
168
169 if (fd_ev_is_set(conn->t.sock.fd, DIR_RD))
170 flags |= CO_FL_CURR_RD_ENA;
171 if (fd_ev_is_set(conn->t.sock.fd, DIR_WR))
172 flags |= CO_FL_CURR_WR_ENA;
173 conn->flags = flags;
174 }
175}
176
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200177/* inspects c->flags and returns non-zero if DATA ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100178 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200179 * non-zero is also returned if an error was reported on the connection. This
180 * function is used quite often and is inlined. In order to proceed optimally
181 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100182 * can be detected by a few left shifts, a xor, and a mask. These operations
183 * detect when W&D are both enabled for either direction, when C&D differ for
184 * either direction and when Error is set. The trick consists in first keeping
185 * only the bits we're interested in, since they don't collide when shifted,
186 * and to perform the AND at the end. In practice, the compiler is able to
187 * replace the last AND with a TEST in boolean conditions. This results in
188 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200189 */
190static inline unsigned int conn_data_polling_changes(const struct connection *c)
191{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100192 unsigned int f = c->flags;
193 f &= CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA | CO_FL_CURR_WR_ENA |
194 CO_FL_CURR_RD_ENA | CO_FL_ERROR | CO_FL_WAIT_WR | CO_FL_WAIT_RD;
195
196 f = (f & (f << 2)) | /* test W & D */
197 ((f ^ (f << 1)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA)); /* test C ^ D */
198 return f & (CO_FL_WAIT_WR | CO_FL_WAIT_RD | CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200199}
200
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200201/* inspects c->flags and returns non-zero if SOCK ENA changes from the CURR ENA
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100202 * or if the WAIT flags are set with their respective ENA flags. Additionally,
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200203 * non-zero is also returned if an error was reported on the connection. This
204 * function is used quite often and is inlined. In order to proceed optimally
205 * with very little code and CPU cycles, the bits are arranged so that a change
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100206 * can be detected by a few left shifts, a xor, and a mask. These operations
207 * detect when W&S are both enabled for either direction, when C&S differ for
208 * either direction and when Error is set. The trick consists in first keeping
209 * only the bits we're interested in, since they don't collide when shifted,
210 * and to perform the AND at the end. In practice, the compiler is able to
211 * replace the last AND with a TEST in boolean conditions. This results in
212 * checks that are done in 4-6 cycles and less than 30 bytes.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200213 */
214static inline unsigned int conn_sock_polling_changes(const struct connection *c)
215{
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100216 unsigned int f = c->flags;
217 f &= CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA | CO_FL_CURR_WR_ENA |
218 CO_FL_CURR_RD_ENA | CO_FL_ERROR | CO_FL_WAIT_WR | CO_FL_WAIT_RD;
219
220 f = (f & (f << 3)) | /* test W & S */
221 ((f ^ (f << 2)) & (CO_FL_CURR_WR_ENA|CO_FL_CURR_RD_ENA)); /* test C ^ S */
222 return f & (CO_FL_WAIT_WR | CO_FL_WAIT_RD | CO_FL_CURR_WR_ENA | CO_FL_CURR_RD_ENA | CO_FL_ERROR);
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200223}
224
225/* Automatically updates polling on connection <c> depending on the DATA flags
226 * if no handshake is in progress.
227 */
228static inline void conn_cond_update_data_polling(struct connection *c)
229{
230 if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
231 conn_update_data_polling(c);
232}
233
234/* Automatically updates polling on connection <c> depending on the SOCK flags
235 * if a handshake is in progress.
236 */
237static inline void conn_cond_update_sock_polling(struct connection *c)
238{
239 if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
240 conn_update_sock_polling(c);
241}
242
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100243/* Stop all polling on the fd. This might be used when an error is encountered
244 * for example.
245 */
246static inline void conn_stop_polling(struct connection *c)
247{
248 c->flags &= ~(CO_FL_CURR_RD_ENA | CO_FL_CURR_WR_ENA |
249 CO_FL_SOCK_RD_ENA | CO_FL_SOCK_WR_ENA |
250 CO_FL_DATA_RD_ENA | CO_FL_DATA_WR_ENA);
251 fd_stop_both(c->t.sock.fd);
252}
253
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200254/* Automatically update polling on connection <c> depending on the DATA and
255 * SOCK flags, and on whether a handshake is in progress or not. This may be
256 * called at any moment when there is a doubt about the effectiveness of the
257 * polling state, for instance when entering or leaving the handshake state.
258 */
259static inline void conn_cond_update_polling(struct connection *c)
260{
Willy Tarreau36fb02c2012-11-24 11:09:07 +0100261 if (unlikely(c->flags & CO_FL_ERROR))
262 conn_stop_polling(c);
263 else if (!(c->flags & CO_FL_POLL_SOCK) && conn_data_polling_changes(c))
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200264 conn_update_data_polling(c);
265 else if ((c->flags & CO_FL_POLL_SOCK) && conn_sock_polling_changes(c))
266 conn_update_sock_polling(c);
267}
268
269/***** Event manipulation primitives for use by DATA I/O callbacks *****/
270/* The __conn_* versions do not propagate to lower layers and are only meant
271 * to be used by handlers called by the connection handler. The other ones
272 * may be used anywhere.
273 */
274static inline void __conn_data_want_recv(struct connection *c)
275{
276 c->flags |= CO_FL_DATA_RD_ENA;
277}
278
279static inline void __conn_data_stop_recv(struct connection *c)
280{
281 c->flags &= ~CO_FL_DATA_RD_ENA;
282}
283
284static inline void __conn_data_poll_recv(struct connection *c)
285{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200286 c->flags |= CO_FL_WAIT_RD | CO_FL_DATA_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200287}
288
289static inline void __conn_data_want_send(struct connection *c)
290{
291 c->flags |= CO_FL_DATA_WR_ENA;
292}
293
294static inline void __conn_data_stop_send(struct connection *c)
295{
296 c->flags &= ~CO_FL_DATA_WR_ENA;
297}
298
299static inline void __conn_data_poll_send(struct connection *c)
300{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200301 c->flags |= CO_FL_WAIT_WR | CO_FL_DATA_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200302}
303
304static inline void __conn_data_stop_both(struct connection *c)
305{
306 c->flags &= ~(CO_FL_DATA_WR_ENA | CO_FL_DATA_RD_ENA);
307}
308
309static inline void conn_data_want_recv(struct connection *c)
310{
311 __conn_data_want_recv(c);
312 conn_cond_update_data_polling(c);
313}
314
315static inline void conn_data_stop_recv(struct connection *c)
316{
317 __conn_data_stop_recv(c);
318 conn_cond_update_data_polling(c);
319}
320
321static inline void conn_data_poll_recv(struct connection *c)
322{
323 __conn_data_poll_recv(c);
324 conn_cond_update_data_polling(c);
325}
326
327static inline void conn_data_want_send(struct connection *c)
328{
329 __conn_data_want_send(c);
330 conn_cond_update_data_polling(c);
331}
332
333static inline void conn_data_stop_send(struct connection *c)
334{
335 __conn_data_stop_send(c);
336 conn_cond_update_data_polling(c);
337}
338
339static inline void conn_data_poll_send(struct connection *c)
340{
341 __conn_data_poll_send(c);
342 conn_cond_update_data_polling(c);
343}
344
345static inline void conn_data_stop_both(struct connection *c)
346{
347 __conn_data_stop_both(c);
348 conn_cond_update_data_polling(c);
349}
350
351/***** Event manipulation primitives for use by handshake I/O callbacks *****/
352/* The __conn_* versions do not propagate to lower layers and are only meant
353 * to be used by handlers called by the connection handler. The other ones
354 * may be used anywhere.
355 */
356static inline void __conn_sock_want_recv(struct connection *c)
357{
358 c->flags |= CO_FL_SOCK_RD_ENA;
359}
360
361static inline void __conn_sock_stop_recv(struct connection *c)
362{
363 c->flags &= ~CO_FL_SOCK_RD_ENA;
364}
365
366static inline void __conn_sock_poll_recv(struct connection *c)
367{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200368 c->flags |= CO_FL_WAIT_RD | CO_FL_SOCK_RD_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200369}
370
371static inline void __conn_sock_want_send(struct connection *c)
372{
373 c->flags |= CO_FL_SOCK_WR_ENA;
374}
375
376static inline void __conn_sock_stop_send(struct connection *c)
377{
378 c->flags &= ~CO_FL_SOCK_WR_ENA;
379}
380
381static inline void __conn_sock_poll_send(struct connection *c)
382{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200383 c->flags |= CO_FL_WAIT_WR | CO_FL_SOCK_WR_ENA;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200384}
385
386static inline void __conn_sock_stop_both(struct connection *c)
387{
388 c->flags &= ~(CO_FL_SOCK_WR_ENA | CO_FL_SOCK_RD_ENA);
389}
390
391static inline void conn_sock_want_recv(struct connection *c)
392{
393 __conn_sock_want_recv(c);
394 conn_cond_update_sock_polling(c);
395}
396
397static inline void conn_sock_stop_recv(struct connection *c)
398{
399 __conn_sock_stop_recv(c);
400 conn_cond_update_sock_polling(c);
401}
402
403static inline void conn_sock_poll_recv(struct connection *c)
404{
405 __conn_sock_poll_recv(c);
406 conn_cond_update_sock_polling(c);
407}
408
409static inline void conn_sock_want_send(struct connection *c)
410{
411 __conn_sock_want_send(c);
412 conn_cond_update_sock_polling(c);
413}
414
415static inline void conn_sock_stop_send(struct connection *c)
416{
417 __conn_sock_stop_send(c);
418 conn_cond_update_sock_polling(c);
419}
420
421static inline void conn_sock_poll_send(struct connection *c)
422{
423 __conn_sock_poll_send(c);
424 conn_cond_update_sock_polling(c);
425}
426
427static inline void conn_sock_stop_both(struct connection *c)
428{
429 __conn_sock_stop_both(c);
430 conn_cond_update_sock_polling(c);
431}
Willy Tarreau8b117082012-08-06 15:06:49 +0200432
Willy Tarreau3af56a92012-08-20 16:55:48 +0200433/* shutdown management */
434static inline void conn_sock_read0(struct connection *c)
435{
436 c->flags |= CO_FL_SOCK_RD_SH;
437 __conn_sock_stop_recv(c);
Willy Tarreauad38ace2013-12-15 14:19:38 +0100438 /* we don't risk keeping ports unusable if we found the
439 * zero from the other side.
440 */
441 if (c->flags & CO_FL_CTRL_READY)
442 fdtab[c->t.sock.fd].linger_risk = 0;
Willy Tarreau3af56a92012-08-20 16:55:48 +0200443}
444
445static inline void conn_data_read0(struct connection *c)
446{
447 c->flags |= CO_FL_DATA_RD_SH;
448 __conn_data_stop_recv(c);
449}
450
451static inline void conn_sock_shutw(struct connection *c)
452{
453 c->flags |= CO_FL_SOCK_WR_SH;
454 __conn_sock_stop_send(c);
455}
456
457static inline void conn_data_shutw(struct connection *c)
458{
459 c->flags |= CO_FL_DATA_WR_SH;
460 __conn_data_stop_send(c);
461}
462
463/* detect sock->data read0 transition */
464static inline int conn_data_read0_pending(struct connection *c)
465{
466 return (c->flags & (CO_FL_DATA_RD_SH | CO_FL_SOCK_RD_SH)) == CO_FL_SOCK_RD_SH;
467}
468
469/* detect data->sock shutw transition */
470static inline int conn_sock_shutw_pending(struct connection *c)
471{
472 return (c->flags & (CO_FL_DATA_WR_SH | CO_FL_SOCK_WR_SH)) == CO_FL_DATA_WR_SH;
473}
474
Willy Tarreau910c6aa2013-10-24 15:08:37 +0200475/* prepares a connection to work with protocol <proto> and transport <xprt>.
476 * The transport's context is initialized as well.
477 */
478static inline void conn_prepare(struct connection *conn, const struct protocol *proto, const struct xprt_ops *xprt)
479{
480 conn->ctrl = proto;
481 conn->xprt = xprt;
482 conn->xprt_st = 0;
483 conn->xprt_ctx = NULL;
484}
485
Willy Tarreaud0155772013-10-14 17:10:08 +0200486/* Initializes all required fields for a new connection. Note that it does the
487 * minimum acceptable initialization for a connection that already exists and
488 * is about to be reused. It also leaves the addresses untouched, which makes
489 * it usable across connection retries to reset a connection to a known state.
490 */
491static inline void conn_init(struct connection *conn)
492{
493 conn->obj_type = OBJ_TYPE_CONN;
494 conn->flags = CO_FL_NONE;
Willy Tarreaud0155772013-10-14 17:10:08 +0200495 conn->data = NULL;
496 conn->owner = NULL;
Willy Tarreaub8020ce2013-10-24 21:10:08 +0200497 conn->send_proxy_ofs = 0;
Willy Tarreaud0155772013-10-14 17:10:08 +0200498 conn->t.sock.fd = -1; /* just to help with debugging */
499 conn->err_code = CO_ER_NONE;
500 conn->target = NULL;
501}
502
Willy Tarreaub97f3b12013-10-20 22:56:45 +0200503/* Tries to allocate a new connection and initialized its main fields. The
504 * connection is returned on success, NULL on failure. The connection must
505 * be released using pool_free2() or conn_free().
506 */
507static inline struct connection *conn_new()
508{
509 struct connection *conn;
510
511 conn = pool_alloc2(pool2_connection);
512 if (likely(conn != NULL))
513 conn_init(conn);
514 return conn;
515}
516
517/* Releases a connection previously allocated by conn_new() */
518static inline void conn_free(struct connection *conn)
519{
520 pool_free2(pool2_connection, conn);
521}
522
523
Willy Tarreau986a9d22012-08-30 21:11:38 +0200524/* Retrieves the connection's source address */
525static inline void conn_get_from_addr(struct connection *conn)
526{
527 if (conn->flags & CO_FL_ADDR_FROM_SET)
528 return;
529
Willy Tarreauf79c8172013-10-21 16:30:56 +0200530 if (!(conn->flags & CO_FL_CTRL_READY) || !conn->ctrl || !conn->ctrl->get_src)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200531 return;
532
533 if (conn->ctrl->get_src(conn->t.sock.fd, (struct sockaddr *)&conn->addr.from,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100534 sizeof(conn->addr.from),
535 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200536 return;
537 conn->flags |= CO_FL_ADDR_FROM_SET;
538}
539
540/* Retrieves the connection's original destination address */
541static inline void conn_get_to_addr(struct connection *conn)
542{
543 if (conn->flags & CO_FL_ADDR_TO_SET)
544 return;
545
Willy Tarreauf79c8172013-10-21 16:30:56 +0200546 if (!(conn->flags & CO_FL_CTRL_READY) || !conn->ctrl || !conn->ctrl->get_dst)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200547 return;
548
549 if (conn->ctrl->get_dst(conn->t.sock.fd, (struct sockaddr *)&conn->addr.to,
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100550 sizeof(conn->addr.to),
551 obj_type(conn->target) != OBJ_TYPE_LISTENER) == -1)
Willy Tarreau986a9d22012-08-30 21:11:38 +0200552 return;
553 conn->flags |= CO_FL_ADDR_TO_SET;
554}
555
Willy Tarreau7abddb52013-10-24 15:31:04 +0200556/* Attaches a connection to an owner and assigns a data layer */
557static inline void conn_attach(struct connection *conn, void *owner, const struct data_cb *data)
Willy Tarreaudda5e7c2012-09-24 17:15:42 +0200558{
Willy Tarreau74beec32012-10-03 00:41:04 +0200559 conn->data = data;
Willy Tarreaucd379952012-09-27 22:14:33 +0200560 conn->owner = owner;
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200561}
562
Willy Tarreau2aefad52014-01-20 11:41:52 +0100563/* Drains possibly pending incoming data on the file descriptor attached to the
564 * connection and update the connection's flags accordingly. This is used to
565 * know whether we need to disable lingering on close. Returns non-zero if it
566 * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH
567 * flag may also be updated if the incoming shutdown was reported by the drain()
568 * function.
569 */
570static inline int conn_drain(struct connection *conn)
571{
572 int ret;
573
574 if (!conn_ctrl_ready(conn))
575 return 1;
576
577 if (conn->flags & CO_FL_SOCK_RD_SH)
578 return 1;
579
580 if (conn->flags & CO_FL_WAIT_RD)
581 return 0;
582
583 if (!conn->ctrl->drain)
584 return 0;
585
586 ret = conn->ctrl->drain(conn->t.sock.fd);
587 if (ret < 0)
588 __conn_data_poll_recv(conn);
589
590 if (ret <= 0)
591 return 0;
592
593 conn->flags |= CO_FL_SOCK_RD_SH;
594 return 1;
595}
596
Willy Tarreau0af29122012-12-03 15:35:00 +0100597/* returns a human-readable error code for conn->err_code, or NULL if the code
598 * is unknown.
599 */
600static inline const char *conn_err_code_str(struct connection *c)
601{
602 switch (c->err_code) {
603 case CO_ER_NONE: return "Success";
Willy Tarreau45b34e82014-01-24 16:06:50 +0100604
605 case CO_ER_CONF_FDLIM: return "Reached configured maxconn value";
606 case CO_ER_PROC_FDLIM: return "Too many sockets on the process";
607 case CO_ER_SYS_FDLIM: return "Too many sockets on the system";
608 case CO_ER_SYS_MEMLIM: return "Out of system buffers";
609 case CO_ER_NOPROTO: return "Protocol or address family not supported";
610 case CO_ER_SOCK_ERR: return "General socket error";
611 case CO_ER_PORT_RANGE: return "Source port range exhausted";
612 case CO_ER_CANT_BIND: return "Can't bind to source address";
613 case CO_ER_FREE_PORTS: return "Out of local source ports on the system";
614 case CO_ER_ADDR_INUSE: return "Local source address already in use";
615
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100616 case CO_ER_PRX_EMPTY: return "Connection closed while waiting for PROXY protocol header";
617 case CO_ER_PRX_ABORT: return "Connection error while waiting for PROXY protocol header";
Willy Tarreau0af29122012-12-03 15:35:00 +0100618 case CO_ER_PRX_TIMEOUT: return "Timeout while waiting for PROXY protocol header";
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100619 case CO_ER_PRX_TRUNCATED: return "Truncated PROXY protocol header received";
620 case CO_ER_PRX_NOT_HDR: return "Received something which does not look like a PROXY protocol header";
621 case CO_ER_PRX_BAD_HDR: return "Received an invalid PROXY protocol header";
622 case CO_ER_PRX_BAD_PROTO: return "Received an unhandled protocol in the PROXY protocol header";
Willy Tarreau20879a02012-12-03 16:32:10 +0100623 case CO_ER_SSL_EMPTY: return "Connection closed during SSL handshake";
624 case CO_ER_SSL_ABORT: return "Connection error during SSL handshake";
Willy Tarreau0af29122012-12-03 15:35:00 +0100625 case CO_ER_SSL_TIMEOUT: return "Timeout during SSL handshake";
Willy Tarreau20879a02012-12-03 16:32:10 +0100626 case CO_ER_SSL_TOO_MANY: return "Too many SSL connections";
627 case CO_ER_SSL_NO_MEM: return "Out of memory when initializing an SSL connection";
628 case CO_ER_SSL_RENEG: return "Rejected a client-initiated SSL renegociation attempt";
629 case CO_ER_SSL_CA_FAIL: return "SSL client CA chain cannot be verified";
630 case CO_ER_SSL_CRT_FAIL: return "SSL client certificate not trusted";
631 case CO_ER_SSL_HANDSHAKE: return "SSL handshake failure";
Willy Tarreau830bf612013-12-01 20:29:58 +0100632 case CO_ER_SSL_NO_TARGET: return "Attempt to use SSL on an unknown target (internal error)";
Willy Tarreau0af29122012-12-03 15:35:00 +0100633 }
634 return NULL;
635}
636
Willy Tarreau59f98392012-07-06 14:13:49 +0200637#endif /* _PROTO_CONNECTION_H */
638
639/*
640 * Local variables:
641 * c-indent-level: 8
642 * c-basic-offset: 8
643 * End:
644 */