blob: b970d418923b97fb1e8f85301338a76936d1492f [file] [log] [blame]
Willy Tarreau59f98392012-07-06 14:13:49 +02001/*
2 * Connection management functions
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaue1e4a612012-10-05 00:10:55 +020013#include <errno.h>
14
Willy Tarreau59f98392012-07-06 14:13:49 +020015#include <common/compat.h>
16#include <common/config.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010017#include <common/namespace.h>
Emmanuel Hocdet4399c752018-02-05 15:26:43 +010018#include <common/hash.h>
19#include <common/net_helper.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020020
Willy Tarreauc5788912012-08-24 18:12:41 +020021#include <proto/connection.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020022#include <proto/fd.h>
Willy Tarreau5f1504f2012-10-04 23:55:57 +020023#include <proto/frontend.h>
Willy Tarreau2da156f2012-07-23 15:07:23 +020024#include <proto/proto_tcp.h>
Willy Tarreau2c6be842012-07-06 17:12:34 +020025#include <proto/stream_interface.h>
Emeric Brun4f603012017-01-05 15:11:44 +010026#include <proto/sample.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020027
Emeric Brun46591952012-05-18 15:47:34 +020028#ifdef USE_OPENSSL
29#include <proto/ssl_sock.h>
30#endif
31
Willy Tarreaubafbe012017-11-24 17:34:44 +010032struct pool_head *pool_head_connection;
33struct pool_head *pool_head_connstream;
Willy Tarreau13e14102016-12-22 20:25:26 +010034struct xprt_ops *registered_xprt[XPRT_ENTRIES] = { NULL, };
Willy Tarreauf2943dc2012-10-26 20:10:28 +020035
Christopher Faulet32f61c02018-04-10 14:33:41 +020036/* List head of all known muxes for PROTO */
37struct mux_proto_list mux_proto_list = {
38 .list = LIST_HEAD_INIT(mux_proto_list.list)
Willy Tarreau2386be62017-09-21 19:40:52 +020039};
40
Willy Tarreauf2943dc2012-10-26 20:10:28 +020041/* perform minimal intializations, report 0 in case of error, 1 if OK. */
42int init_connection()
43{
Willy Tarreaubafbe012017-11-24 17:34:44 +010044 pool_head_connection = create_pool("connection", sizeof (struct connection), MEM_F_SHARED);
45 if (!pool_head_connection)
Olivier Houcharde2b40b92017-09-13 18:30:23 +020046 goto fail_conn;
47
Willy Tarreaubafbe012017-11-24 17:34:44 +010048 pool_head_connstream = create_pool("conn_stream", sizeof(struct conn_stream), MEM_F_SHARED);
49 if (!pool_head_connstream)
Olivier Houcharde2b40b92017-09-13 18:30:23 +020050 goto fail_cs;
51
52 return 1;
53 fail_cs:
Willy Tarreaubafbe012017-11-24 17:34:44 +010054 pool_destroy(pool_head_connection);
55 pool_head_connection = NULL;
Olivier Houcharde2b40b92017-09-13 18:30:23 +020056 fail_conn:
57 return 0;
Willy Tarreauf2943dc2012-10-26 20:10:28 +020058}
59
Willy Tarreau59f98392012-07-06 14:13:49 +020060/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020061 * provided by the connection's sock_ops, which must be valid.
Willy Tarreau59f98392012-07-06 14:13:49 +020062 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020063void conn_fd_handler(int fd)
Willy Tarreau59f98392012-07-06 14:13:49 +020064{
Willy Tarreau80184712012-07-06 14:54:49 +020065 struct connection *conn = fdtab[fd].owner;
Willy Tarreau9e272bf2012-10-03 21:04:48 +020066 unsigned int flags;
Olivier Houchardaf4021e2018-08-09 13:06:55 +020067 int io_available = 0;
Willy Tarreau59f98392012-07-06 14:13:49 +020068
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010069 if (unlikely(!conn)) {
70 activity[tid].conn_dead++;
Willy Tarreau7a798e52016-04-14 11:13:20 +020071 return;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010072 }
Willy Tarreau59f98392012-07-06 14:13:49 +020073
Willy Tarreau7d281492012-12-16 19:19:13 +010074 conn_refresh_polling_flags(conn);
Willy Tarreau916e12d2017-10-25 09:22:43 +020075 conn->flags |= CO_FL_WILL_UPDATE;
76
Willy Tarreau7d281492012-12-16 19:19:13 +010077 flags = conn->flags & ~CO_FL_ERROR; /* ensure to call the wake handler upon error */
Willy Tarreaud29a0662012-12-10 16:33:38 +010078
Willy Tarreauc76ae332012-07-12 15:32:13 +020079 process_handshake:
Willy Tarreauf9dabec2012-08-17 17:33:53 +020080 /* The handshake callbacks are called in sequence. If either of them is
81 * missing something, it must enable the required polling at the socket
82 * layer of the connection. Polling state is not guaranteed when entering
83 * these handlers, so any handshake handler which does not complete its
Willy Tarreaud6e999b2013-11-25 08:41:15 +010084 * work must explicitly disable events it's not interested in. Error
85 * handling is also performed here in order to reduce the number of tests
86 * around.
Willy Tarreauf9dabec2012-08-17 17:33:53 +020087 */
Willy Tarreaud6e999b2013-11-25 08:41:15 +010088 while (unlikely(conn->flags & (CO_FL_HANDSHAKE | CO_FL_ERROR))) {
Willy Tarreau310987a2014-01-22 19:46:33 +010089 if (unlikely(conn->flags & CO_FL_ERROR))
Willy Tarreau2c6be842012-07-06 17:12:34 +020090 goto leave;
Willy Tarreau59f98392012-07-06 14:13:49 +020091
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010092 if (conn->flags & CO_FL_ACCEPT_CIP)
93 if (!conn_recv_netscaler_cip(conn, CO_FL_ACCEPT_CIP))
94 goto leave;
95
Willy Tarreau22cda212012-08-31 17:43:29 +020096 if (conn->flags & CO_FL_ACCEPT_PROXY)
97 if (!conn_recv_proxy(conn, CO_FL_ACCEPT_PROXY))
98 goto leave;
99
Willy Tarreau57cd3e42013-10-24 22:01:26 +0200100 if (conn->flags & CO_FL_SEND_PROXY)
101 if (!conn_si_send_proxy(conn, CO_FL_SEND_PROXY))
Willy Tarreau5f1504f2012-10-04 23:55:57 +0200102 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +0200103#ifdef USE_OPENSSL
104 if (conn->flags & CO_FL_SSL_WAIT_HS)
105 if (!ssl_sock_handshake(conn, CO_FL_SSL_WAIT_HS))
106 goto leave;
107#endif
Willy Tarreauc76ae332012-07-12 15:32:13 +0200108 }
109
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200110 /* Once we're purely in the data phase, we disable handshake polling */
111 if (!(conn->flags & CO_FL_POLL_SOCK))
112 __conn_sock_stop_both(conn);
Willy Tarreauc76ae332012-07-12 15:32:13 +0200113
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200114 /* The connection owner might want to be notified about an end of
115 * handshake indicating the connection is ready, before we proceed with
116 * any data exchange. The callback may fail and cause the connection to
117 * be destroyed, thus we must not use it anymore and should immediately
118 * leave instead. The caller must immediately unregister itself once
119 * called.
Willy Tarreau2542b532012-08-31 16:01:23 +0200120 */
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200121 if (conn->xprt_done_cb && conn->xprt_done_cb(conn) < 0)
Willy Tarreau7a798e52016-04-14 11:13:20 +0200122 return;
Willy Tarreau2542b532012-08-31 16:01:23 +0200123
Willy Tarreau57ec32f2017-04-11 19:59:33 +0200124 if (conn->xprt && fd_send_ready(fd) &&
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200125 ((conn->flags & (CO_FL_XPRT_WR_ENA|CO_FL_ERROR|CO_FL_HANDSHAKE)) == CO_FL_XPRT_WR_ENA)) {
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100126 /* force reporting of activity by clearing the previous flags :
127 * we'll have at least ERROR or CONNECTED at the end of an I/O,
128 * both of which will be detected below.
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200129 */
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100130 flags = 0;
Olivier Houchardaf4021e2018-08-09 13:06:55 +0200131 io_available = (LIST_ISEMPTY(&conn->send_wait_list) &&
132 LIST_ISEMPTY(&conn->sendrecv_wait_list));;
Olivier Houchard6ff20392018-07-17 18:46:31 +0200133 while (!LIST_ISEMPTY(&conn->send_wait_list)) {
134 struct wait_list *sw = LIST_ELEM(conn->send_wait_list.n,
135 struct wait_list *, list);
136 LIST_DEL(&sw->list);
137 LIST_INIT(&sw->list);
Olivier Houcharde1c6dbc2018-08-01 17:06:43 +0200138 sw->wait_reason &= ~SUB_CAN_SEND;
Olivier Houchard6ff20392018-07-17 18:46:31 +0200139 tasklet_wakeup(sw->task);
140 }
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200141 while (!(LIST_ISEMPTY(&conn->sendrecv_wait_list))) {
Olivier Houchardaf4021e2018-08-09 13:06:55 +0200142 struct wait_list *sw = LIST_ELEM(conn->sendrecv_wait_list.n,
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200143 struct wait_list *, list);
144 LIST_DEL(&sw->list);
145 LIST_INIT(&sw->list);
146 LIST_ADDQ(&conn->recv_wait_list, &sw->list);
147 sw->wait_reason &= ~SUB_CAN_SEND;
148 tasklet_wakeup(sw->task);
149 }
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200150 }
Willy Tarreau59f98392012-07-06 14:13:49 +0200151
Willy Tarreau57ec32f2017-04-11 19:59:33 +0200152 /* The data transfer starts here and stops on error and handshakes. Note
153 * that we must absolutely test conn->xprt at each step in case it suddenly
154 * changes due to a quick unexpected close().
155 */
156 if (conn->xprt && fd_recv_ready(fd) &&
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200157 ((conn->flags & (CO_FL_XPRT_RD_ENA|CO_FL_WAIT_ROOM|CO_FL_ERROR|CO_FL_HANDSHAKE)) == CO_FL_XPRT_RD_ENA)) {
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100158 /* force reporting of activity by clearing the previous flags :
159 * we'll have at least ERROR or CONNECTED at the end of an I/O,
160 * both of which will be detected below.
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200161 */
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100162 flags = 0;
Olivier Houchardaf4021e2018-08-09 13:06:55 +0200163 io_available |= (LIST_ISEMPTY(&conn->recv_wait_list) &&
164 LIST_ISEMPTY(&conn->sendrecv_wait_list));
165 while (!LIST_ISEMPTY(&conn->recv_wait_list)) {
166 struct wait_list *sw = LIST_ELEM(conn->recv_wait_list.n,
167 struct wait_list *, list);
168 LIST_DEL(&sw->list);
169 LIST_INIT(&sw->list);
170 sw->wait_reason &= ~SUB_CAN_RECV;
171 tasklet_wakeup(sw->task);
172 }
173 while (!(LIST_ISEMPTY(&conn->sendrecv_wait_list))) {
174 struct wait_list *sw = LIST_ELEM(conn->sendrecv_wait_list.n,
175 struct wait_list *, list);
176 LIST_DEL(&sw->list);
177 LIST_INIT(&sw->list);
178 LIST_ADDQ(&conn->send_wait_list, &sw->list);
179 sw->wait_reason &= ~SUB_CAN_RECV;
180 tasklet_wakeup(sw->task);
181 }
182
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200183 }
Willy Tarreau2da156f2012-07-23 15:07:23 +0200184
Willy Tarreauc76ae332012-07-12 15:32:13 +0200185 /* It may happen during the data phase that a handshake is
186 * enabled again (eg: SSL)
187 */
Willy Tarreaud6e999b2013-11-25 08:41:15 +0100188 if (unlikely(conn->flags & (CO_FL_HANDSHAKE | CO_FL_ERROR)))
Willy Tarreauc76ae332012-07-12 15:32:13 +0200189 goto process_handshake;
190
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100191 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreauf8deb0c2012-09-01 17:59:22 +0200192 /* still waiting for a connection to establish and nothing was
193 * attempted yet to probe the connection. Then let's retry the
194 * connect().
Willy Tarreau2da156f2012-07-23 15:07:23 +0200195 */
Willy Tarreau239d7182012-07-23 18:53:03 +0200196 if (!tcp_connect_probe(conn))
Willy Tarreauafad0e02012-08-09 14:45:22 +0200197 goto leave;
Willy Tarreau2da156f2012-07-23 15:07:23 +0200198 }
Willy Tarreau2c6be842012-07-06 17:12:34 +0200199 leave:
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100200 /* Verify if the connection just established. */
Willy Tarreau7bf3fa32017-03-14 20:19:29 +0100201 if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED))))
202 conn->flags |= CO_FL_CONNECTED;
203
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200204 /* The connection owner might want to be notified about failures to
205 * complete the handshake. The callback may fail and cause the
206 * connection to be destroyed, thus we must not use it anymore and
207 * should immediately leave instead. The caller must immediately
208 * unregister itself once called.
209 */
210 if (((conn->flags ^ flags) & CO_FL_NOTIFY_DONE) &&
211 conn->xprt_done_cb && conn->xprt_done_cb(conn) < 0)
212 return;
213
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100214 /* The wake callback is normally used to notify the data layer about
215 * data layer activity (successful send/recv), connection establishment,
216 * shutdown and fatal errors. We need to consider the following
217 * situations to wake up the data layer :
218 * - change among the CO_FL_NOTIFY_DATA flags :
219 * {DATA,SOCK}_{RD,WR}_SH, ERROR,
220 * - absence of any of {L4,L6}_CONN and CONNECTED, indicating the
221 * end of handshake and transition to CONNECTED
222 * - raise of CONNECTED with HANDSHAKE down
223 * - end of HANDSHAKE with CONNECTED set
224 * - regular data layer activity
225 *
226 * Note that the wake callback is allowed to release the connection and
227 * the fd (and return < 0 in this case).
Willy Tarreau2396c1c2012-10-03 21:12:16 +0200228 */
Olivier Houchardaf4021e2018-08-09 13:06:55 +0200229 if ((io_available || (((conn->flags ^ flags) & CO_FL_NOTIFY_DATA) ||
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100230 ((flags & (CO_FL_CONNECTED|CO_FL_HANDSHAKE)) != CO_FL_CONNECTED &&
Olivier Houchard910b2bc2018-07-17 18:49:38 +0200231 (conn->flags & (CO_FL_CONNECTED|CO_FL_HANDSHAKE)) == CO_FL_CONNECTED))) &&
Olivier Houchard7505f942018-08-21 18:10:44 +0200232 conn->mux->wake && conn->mux->wake(conn) < 0)
Willy Tarreau7a798e52016-04-14 11:13:20 +0200233 return;
Willy Tarreaufd31e532012-07-23 18:24:25 +0200234
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200235 /* commit polling changes */
Willy Tarreau916e12d2017-10-25 09:22:43 +0200236 conn->flags &= ~CO_FL_WILL_UPDATE;
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200237 conn_cond_update_polling(conn);
Willy Tarreau7a798e52016-04-14 11:13:20 +0200238 return;
Willy Tarreau59f98392012-07-06 14:13:49 +0200239}
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200240
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200241/* Update polling on connection <c>'s file descriptor depending on its current
242 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200243 * in CO_FL_WAIT_*, and the data layer expectations indicated by CO_FL_XPRT_*.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200244 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200245 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200246 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200247void conn_update_xprt_polling(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200248{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200249 unsigned int f = c->flags;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200250
Willy Tarreau3c728722014-01-23 13:50:42 +0100251 if (!conn_ctrl_ready(c))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200252 return;
253
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200254 /* update read status if needed */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200255 if (unlikely((f & (CO_FL_CURR_RD_ENA|CO_FL_XPRT_RD_ENA)) == CO_FL_XPRT_RD_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200256 fd_want_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100257 f |= CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200258 }
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200259 else if (unlikely((f & (CO_FL_CURR_RD_ENA|CO_FL_XPRT_RD_ENA)) == CO_FL_CURR_RD_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200260 fd_stop_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100261 f &= ~CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200262 }
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200263
264 /* update write status if needed */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200265 if (unlikely((f & (CO_FL_CURR_WR_ENA|CO_FL_XPRT_WR_ENA)) == CO_FL_XPRT_WR_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200266 fd_want_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100267 f |= CO_FL_CURR_WR_ENA;
268 }
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200269 else if (unlikely((f & (CO_FL_CURR_WR_ENA|CO_FL_XPRT_WR_ENA)) == CO_FL_CURR_WR_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200270 fd_stop_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100271 f &= ~CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200272 }
Willy Tarreau310987a2014-01-22 19:46:33 +0100273 c->flags = f;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200274}
275
276/* Update polling on connection <c>'s file descriptor depending on its current
277 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
278 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
279 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200280 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200281 */
282void conn_update_sock_polling(struct connection *c)
283{
284 unsigned int f = c->flags;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200285
Willy Tarreau3c728722014-01-23 13:50:42 +0100286 if (!conn_ctrl_ready(c))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200287 return;
288
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200289 /* update read status if needed */
Willy Tarreau310987a2014-01-22 19:46:33 +0100290 if (unlikely((f & (CO_FL_CURR_RD_ENA|CO_FL_SOCK_RD_ENA)) == CO_FL_SOCK_RD_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200291 fd_want_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100292 f |= CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200293 }
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100294 else if (unlikely((f & (CO_FL_CURR_RD_ENA|CO_FL_SOCK_RD_ENA)) == CO_FL_CURR_RD_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200295 fd_stop_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100296 f &= ~CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200297 }
298
299 /* update write status if needed */
Willy Tarreau310987a2014-01-22 19:46:33 +0100300 if (unlikely((f & (CO_FL_CURR_WR_ENA|CO_FL_SOCK_WR_ENA)) == CO_FL_SOCK_WR_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200301 fd_want_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100302 f |= CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200303 }
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100304 else if (unlikely((f & (CO_FL_CURR_WR_ENA|CO_FL_SOCK_WR_ENA)) == CO_FL_CURR_WR_ENA)) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200305 fd_stop_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100306 f &= ~CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200307 }
Willy Tarreau310987a2014-01-22 19:46:33 +0100308 c->flags = f;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200309}
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200310
Willy Tarreauff3e6482015-03-12 23:56:52 +0100311/* Send a message over an established connection. It makes use of send() and
312 * returns the same return code and errno. If the socket layer is not ready yet
313 * then -1 is returned and ENOTSOCK is set into errno. If the fd is not marked
314 * as ready, or if EAGAIN or ENOTCONN is returned, then we return 0. It returns
315 * EMSGSIZE if called with a zero length message. The purpose is to simplify
316 * some rare attempts to directly write on the socket from above the connection
317 * (typically send_proxy). In case of EAGAIN, the fd is marked as "cant_send".
318 * It automatically retries on EINTR. Other errors cause the connection to be
319 * marked as in error state. It takes similar arguments as send() except the
320 * first one which is the connection instead of the file descriptor. Note,
321 * MSG_DONTWAIT and MSG_NOSIGNAL are forced on the flags.
322 */
323int conn_sock_send(struct connection *conn, const void *buf, int len, int flags)
324{
325 int ret;
326
327 ret = -1;
328 errno = ENOTSOCK;
329
330 if (conn->flags & CO_FL_SOCK_WR_SH)
331 goto fail;
332
333 if (!conn_ctrl_ready(conn))
334 goto fail;
335
336 errno = EMSGSIZE;
337 if (!len)
338 goto fail;
339
Willy Tarreau585744b2017-08-24 14:31:19 +0200340 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauff3e6482015-03-12 23:56:52 +0100341 goto wait;
342
343 do {
Willy Tarreau585744b2017-08-24 14:31:19 +0200344 ret = send(conn->handle.fd, buf, len, flags | MSG_DONTWAIT | MSG_NOSIGNAL);
Willy Tarreauff3e6482015-03-12 23:56:52 +0100345 } while (ret < 0 && errno == EINTR);
346
347
348 if (ret > 0)
349 return ret;
350
351 if (ret == 0 || errno == EAGAIN || errno == ENOTCONN) {
352 wait:
Willy Tarreau585744b2017-08-24 14:31:19 +0200353 fd_cant_send(conn->handle.fd);
Willy Tarreauff3e6482015-03-12 23:56:52 +0100354 return 0;
355 }
356 fail:
357 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH | CO_FL_ERROR;
358 return ret;
359}
360
Olivier Houchard6ff20392018-07-17 18:46:31 +0200361int conn_subscribe(struct connection *conn, int event_type, void *param)
362{
363 struct wait_list *sw;
364
365 switch (event_type) {
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200366 case SUB_CAN_RECV:
367 sw = param;
368 if (!(sw->wait_reason & SUB_CAN_RECV)) {
369 sw->wait_reason |= SUB_CAN_RECV;
370 /* If we're already subscribed for send(), move it
371 * to the send+recv list
372 */
373 if (sw->wait_reason & SUB_CAN_SEND) {
374 LIST_DEL(&sw->list);
375 LIST_INIT(&sw->list);
376 LIST_ADDQ(&conn->sendrecv_wait_list, &sw->list);
377 } else
378 LIST_ADDQ(&conn->recv_wait_list, &sw->list);
379 }
380 return 0;
Olivier Houchard6ff20392018-07-17 18:46:31 +0200381 case SUB_CAN_SEND:
382 sw = param;
Olivier Houcharde1c6dbc2018-08-01 17:06:43 +0200383 if (!(sw->wait_reason & SUB_CAN_SEND)) {
384 sw->wait_reason |= SUB_CAN_SEND;
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200385 /* If we're already subscribed for recv(), move it
386 * to the send+recv list
387 */
388 if (sw->wait_reason & SUB_CAN_RECV) {
389 LIST_DEL(&sw->list);
390 LIST_INIT(&sw->list);
391 LIST_ADDQ(&conn->sendrecv_wait_list, &sw->list);
392 } else
393 LIST_ADDQ(&conn->send_wait_list, &sw->list);
Olivier Houcharde1c6dbc2018-08-01 17:06:43 +0200394 }
Olivier Houchard6ff20392018-07-17 18:46:31 +0200395 return 0;
396 default:
397 break;
398 }
399 return (-1);
400}
401
Willy Tarreaud85c4852015-03-13 00:40:28 +0100402/* Drains possibly pending incoming data on the file descriptor attached to the
403 * connection and update the connection's flags accordingly. This is used to
404 * know whether we need to disable lingering on close. Returns non-zero if it
405 * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH
406 * flag may also be updated if the incoming shutdown was reported by the drain()
407 * function.
408 */
409int conn_sock_drain(struct connection *conn)
410{
Willy Tarreaue215bba2018-08-24 14:31:53 +0200411 int turns = 2;
412 int len;
413
Willy Tarreaud85c4852015-03-13 00:40:28 +0100414 if (!conn_ctrl_ready(conn))
415 return 1;
416
417 if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH))
418 return 1;
419
Willy Tarreaue215bba2018-08-24 14:31:53 +0200420 if (fdtab[conn->handle.fd].ev & (FD_POLL_ERR|FD_POLL_HUP))
421 goto shut;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100422
Willy Tarreaue215bba2018-08-24 14:31:53 +0200423 if (!fd_recv_ready(conn->handle.fd))
424 return 0;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100425
Willy Tarreaue215bba2018-08-24 14:31:53 +0200426 if (conn->ctrl->drain) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200427 if (conn->ctrl->drain(conn->handle.fd) <= 0)
Willy Tarreaud85c4852015-03-13 00:40:28 +0100428 return 0;
Willy Tarreaue215bba2018-08-24 14:31:53 +0200429 goto shut;
430 }
431
432 /* no drain function defined, use the generic one */
433
434 while (turns) {
435#ifdef MSG_TRUNC_CLEARS_INPUT
436 len = recv(conn->handle.fd, NULL, INT_MAX, MSG_DONTWAIT | MSG_NOSIGNAL | MSG_TRUNC);
437 if (len == -1 && errno == EFAULT)
438#endif
439 len = recv(conn->handle.fd, trash.area, trash.size,
440 MSG_DONTWAIT | MSG_NOSIGNAL);
441
442 if (len == 0)
443 goto shut;
444
445 if (len < 0) {
446 if (errno == EAGAIN) {
447 /* connection not closed yet */
448 fd_cant_recv(conn->handle.fd);
449 break;
450 }
451 if (errno == EINTR) /* oops, try again */
452 continue;
453 /* other errors indicate a dead connection, fine. */
454 goto shut;
455 }
456 /* OK we read some data, let's try again once */
457 turns--;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100458 }
459
Willy Tarreaue215bba2018-08-24 14:31:53 +0200460 /* some data are still present, give up */
461 return 0;
462
463 shut:
464 /* we're certain the connection was shut down */
465 fdtab[conn->handle.fd].linger_risk = 0;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100466 conn->flags |= CO_FL_SOCK_RD_SH;
467 return 1;
468}
469
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100470/*
471 * Get data length from tlv
472 */
473static int get_tlv_length(const struct tlv *src)
474{
475 return (src->length_hi << 8) | src->length_lo;
476}
477
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200478/* This handshake handler waits a PROXY protocol header at the beginning of the
479 * raw data stream. The header looks like this :
480 *
481 * "PROXY" <SP> PROTO <SP> SRC3 <SP> DST3 <SP> SRC4 <SP> <DST4> "\r\n"
482 *
483 * There must be exactly one space between each field. Fields are :
484 * - PROTO : layer 4 protocol, which must be "TCP4" or "TCP6".
485 * - SRC3 : layer 3 (eg: IP) source address in standard text form
486 * - DST3 : layer 3 (eg: IP) destination address in standard text form
487 * - SRC4 : layer 4 (eg: TCP port) source address in standard text form
488 * - DST4 : layer 4 (eg: TCP port) destination address in standard text form
489 *
490 * This line MUST be at the beginning of the buffer and MUST NOT wrap.
491 *
492 * The header line is small and in all cases smaller than the smallest normal
493 * TCP MSS. So it MUST always be delivered as one segment, which ensures we
494 * can safely use MSG_PEEK and avoid buffering.
495 *
496 * Once the data is fetched, the values are set in the connection's address
497 * fields, and data are removed from the socket's buffer. The function returns
498 * zero if it needs to wait for more data or if it fails, or 1 if it completed
499 * and removed itself.
500 */
501int conn_recv_proxy(struct connection *conn, int flag)
502{
503 char *line, *end;
Willy Tarreau77992672014-06-14 11:06:17 +0200504 struct proxy_hdr_v2 *hdr_v2;
505 const char v2sig[] = PP2_SIGNATURE;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100506 int tlv_length = 0;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200507 int tlv_offset = 0;
Willy Tarreaub406b872018-08-22 05:20:32 +0200508 int ret;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200509
510 /* we might have been called just after an asynchronous shutr */
511 if (conn->flags & CO_FL_SOCK_RD_SH)
512 goto fail;
513
Willy Tarreau3c728722014-01-23 13:50:42 +0100514 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200515 goto fail;
516
Willy Tarreau585744b2017-08-24 14:31:19 +0200517 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100518 return 0;
519
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200520 do {
Willy Tarreaub406b872018-08-22 05:20:32 +0200521 ret = recv(conn->handle.fd, trash.area, trash.size, MSG_PEEK);
522 if (ret < 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200523 if (errno == EINTR)
524 continue;
525 if (errno == EAGAIN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200526 fd_cant_recv(conn->handle.fd);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200527 return 0;
528 }
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100529 goto recv_abort;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200530 }
Willy Tarreaub406b872018-08-22 05:20:32 +0200531 trash.data = ret;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200532 } while (0);
533
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200534 if (!trash.data) {
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100535 /* client shutdown */
536 conn->err_code = CO_ER_PRX_EMPTY;
537 goto fail;
538 }
539
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200540 if (trash.data < 6)
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200541 goto missing;
542
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200543 line = trash.area;
544 end = trash.area + trash.data;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200545
546 /* Decode a possible proxy request, fail early if it does not match */
Willy Tarreau77992672014-06-14 11:06:17 +0200547 if (strncmp(line, "PROXY ", 6) != 0)
548 goto not_v1;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200549
550 line += 6;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200551 if (trash.data < 9) /* shortest possible line */
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200552 goto missing;
553
David CARLIER42ff05e2016-03-24 09:22:36 +0000554 if (memcmp(line, "TCP4 ", 5) == 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200555 u32 src3, dst3, sport, dport;
556
557 line += 5;
558
559 src3 = inetaddr_host_lim_ret(line, end, &line);
560 if (line == end)
561 goto missing;
562 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100563 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200564
565 dst3 = inetaddr_host_lim_ret(line, end, &line);
566 if (line == end)
567 goto missing;
568 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100569 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200570
571 sport = read_uint((const char **)&line, end);
572 if (line == end)
573 goto missing;
574 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100575 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200576
577 dport = read_uint((const char **)&line, end);
578 if (line > end - 2)
579 goto missing;
580 if (*line++ != '\r')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100581 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200582 if (*line++ != '\n')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100583 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200584
585 /* update the session's addresses and mark them set */
586 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
587 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = htonl(src3);
588 ((struct sockaddr_in *)&conn->addr.from)->sin_port = htons(sport);
589
590 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
591 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = htonl(dst3);
592 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(dport);
593 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
594 }
David CARLIER42ff05e2016-03-24 09:22:36 +0000595 else if (memcmp(line, "TCP6 ", 5) == 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200596 u32 sport, dport;
597 char *src_s;
598 char *dst_s, *sport_s, *dport_s;
599 struct in6_addr src3, dst3;
600
601 line += 5;
602
603 src_s = line;
604 dst_s = sport_s = dport_s = NULL;
605 while (1) {
606 if (line > end - 2) {
607 goto missing;
608 }
609 else if (*line == '\r') {
610 *line = 0;
611 line++;
612 if (*line++ != '\n')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100613 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200614 break;
615 }
616
617 if (*line == ' ') {
618 *line = 0;
619 if (!dst_s)
620 dst_s = line + 1;
621 else if (!sport_s)
622 sport_s = line + 1;
623 else if (!dport_s)
624 dport_s = line + 1;
625 }
626 line++;
627 }
628
629 if (!dst_s || !sport_s || !dport_s)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100630 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200631
632 sport = read_uint((const char **)&sport_s,dport_s - 1);
633 if (*sport_s != 0)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100634 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200635
636 dport = read_uint((const char **)&dport_s,line - 2);
637 if (*dport_s != 0)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100638 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200639
640 if (inet_pton(AF_INET6, src_s, (void *)&src3) != 1)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100641 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200642
643 if (inet_pton(AF_INET6, dst_s, (void *)&dst3) != 1)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100644 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200645
646 /* update the session's addresses and mark them set */
647 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
648 memcpy(&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr, &src3, sizeof(struct in6_addr));
649 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = htons(sport);
650
651 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
652 memcpy(&((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr, &dst3, sizeof(struct in6_addr));
653 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(dport);
654 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
655 }
Willy Tarreau4c20d292014-06-14 11:41:36 +0200656 else if (memcmp(line, "UNKNOWN\r\n", 9) == 0) {
657 /* This can be a UNIX socket forwarded by an haproxy upstream */
658 line += 9;
659 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200660 else {
Willy Tarreau4c20d292014-06-14 11:41:36 +0200661 /* The protocol does not match something known (TCP4/TCP6/UNKNOWN) */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100662 conn->err_code = CO_ER_PRX_BAD_PROTO;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200663 goto fail;
664 }
665
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200666 trash.data = line - trash.area;
Willy Tarreau77992672014-06-14 11:06:17 +0200667 goto eat_header;
668
669 not_v1:
670 /* try PPv2 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200671 if (trash.data < PP2_HEADER_LEN)
Willy Tarreau77992672014-06-14 11:06:17 +0200672 goto missing;
673
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200674 hdr_v2 = (struct proxy_hdr_v2 *) trash.area;
Willy Tarreau77992672014-06-14 11:06:17 +0200675
676 if (memcmp(hdr_v2->sig, v2sig, PP2_SIGNATURE_LEN) != 0 ||
677 (hdr_v2->ver_cmd & PP2_VERSION_MASK) != PP2_VERSION) {
678 conn->err_code = CO_ER_PRX_NOT_HDR;
679 goto fail;
680 }
681
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200682 if (trash.data < PP2_HEADER_LEN + ntohs(hdr_v2->len))
Willy Tarreau77992672014-06-14 11:06:17 +0200683 goto missing;
684
685 switch (hdr_v2->ver_cmd & PP2_CMD_MASK) {
686 case 0x01: /* PROXY command */
687 switch (hdr_v2->fam) {
688 case 0x11: /* TCPv4 */
KOVACS Krisztianefd3aa92014-11-19 10:53:20 +0100689 if (ntohs(hdr_v2->len) < PP2_ADDR_LEN_INET)
690 goto bad_header;
691
Willy Tarreau77992672014-06-14 11:06:17 +0200692 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
693 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = hdr_v2->addr.ip4.src_addr;
694 ((struct sockaddr_in *)&conn->addr.from)->sin_port = hdr_v2->addr.ip4.src_port;
695 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
696 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = hdr_v2->addr.ip4.dst_addr;
697 ((struct sockaddr_in *)&conn->addr.to)->sin_port = hdr_v2->addr.ip4.dst_port;
698 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200699 tlv_offset = PP2_HEADER_LEN + PP2_ADDR_LEN_INET;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100700 tlv_length = ntohs(hdr_v2->len) - PP2_ADDR_LEN_INET;
Willy Tarreau77992672014-06-14 11:06:17 +0200701 break;
702 case 0x21: /* TCPv6 */
KOVACS Krisztianefd3aa92014-11-19 10:53:20 +0100703 if (ntohs(hdr_v2->len) < PP2_ADDR_LEN_INET6)
704 goto bad_header;
705
Willy Tarreau77992672014-06-14 11:06:17 +0200706 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
707 memcpy(&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr, hdr_v2->addr.ip6.src_addr, 16);
708 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = hdr_v2->addr.ip6.src_port;
709 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
710 memcpy(&((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr, hdr_v2->addr.ip6.dst_addr, 16);
711 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = hdr_v2->addr.ip6.dst_port;
712 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200713 tlv_offset = PP2_HEADER_LEN + PP2_ADDR_LEN_INET6;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100714 tlv_length = ntohs(hdr_v2->len) - PP2_ADDR_LEN_INET6;
Willy Tarreau77992672014-06-14 11:06:17 +0200715 break;
716 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100717
718 /* TLV parsing */
719 if (tlv_length > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200720 while (tlv_offset + TLV_HEADER_SIZE <= trash.data) {
721 const struct tlv *tlv_packet = (struct tlv *) &trash.area[tlv_offset];
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100722 const int tlv_len = get_tlv_length(tlv_packet);
723 tlv_offset += tlv_len + TLV_HEADER_SIZE;
724
725 switch (tlv_packet->type) {
Emmanuel Hocdet115df3e2018-02-05 16:23:23 +0100726 case PP2_TYPE_CRC32C: {
727 void *tlv_crc32c_p = (void *)tlv_packet->value;
728 uint32_t n_crc32c = ntohl(read_u32(tlv_crc32c_p));
729 write_u32(tlv_crc32c_p, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200730 if (hash_crc32c(trash.area, PP2_HEADER_LEN + ntohs(hdr_v2->len)) != n_crc32c)
Emmanuel Hocdet115df3e2018-02-05 16:23:23 +0100731 goto bad_header;
732 break;
733 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100734#ifdef CONFIG_HAP_NS
735 case PP2_TYPE_NETNS: {
736 const struct netns_entry *ns;
737 ns = netns_store_lookup((char*)tlv_packet->value, tlv_len);
738 if (ns)
739 conn->proxy_netns = ns;
740 break;
741 }
742#endif
743 default:
744 break;
745 }
746 }
747 }
748
Willy Tarreau77992672014-06-14 11:06:17 +0200749 /* unsupported protocol, keep local connection address */
750 break;
751 case 0x00: /* LOCAL command */
752 /* keep local connection address for LOCAL */
753 break;
754 default:
755 goto bad_header; /* not a supported command */
756 }
757
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200758 trash.data = PP2_HEADER_LEN + ntohs(hdr_v2->len);
Willy Tarreau77992672014-06-14 11:06:17 +0200759 goto eat_header;
760
761 eat_header:
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200762 /* remove the PROXY line from the request. For this we re-read the
763 * exact line at once. If we don't get the exact same result, we
764 * fail.
765 */
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200766 do {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200767 int len2 = recv(conn->handle.fd, trash.area, trash.data, 0);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200768 if (len2 < 0 && errno == EINTR)
769 continue;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200770 if (len2 != trash.data)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100771 goto recv_abort;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200772 } while (0);
773
774 conn->flags &= ~flag;
Emeric Brun4f603012017-01-05 15:11:44 +0100775 conn->flags |= CO_FL_RCVD_PROXY;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200776 return 1;
777
778 missing:
779 /* Missing data. Since we're using MSG_PEEK, we can only poll again if
780 * we have not read anything. Otherwise we need to fail because we won't
781 * be able to poll anymore.
782 */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100783 conn->err_code = CO_ER_PRX_TRUNCATED;
784 goto fail;
785
786 bad_header:
787 /* This is not a valid proxy protocol header */
788 conn->err_code = CO_ER_PRX_BAD_HDR;
789 goto fail;
790
791 recv_abort:
792 conn->err_code = CO_ER_PRX_ABORT;
Willy Tarreau26f4a042013-12-04 23:44:10 +0100793 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100794 goto fail;
795
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200796 fail:
Willy Tarreaud486ef52012-12-10 17:03:52 +0100797 __conn_sock_stop_both(conn);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200798 conn->flags |= CO_FL_ERROR;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200799 return 0;
800}
801
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100802/* This handshake handler waits a NetScaler Client IP insertion header
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000803 * at the beginning of the raw data stream. The header format is
804 * described in doc/netscaler-client-ip-insertion-protocol.txt
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100805 *
806 * This line MUST be at the beginning of the buffer and MUST NOT be
807 * fragmented.
808 *
809 * The header line is small and in all cases smaller than the smallest normal
810 * TCP MSS. So it MUST always be delivered as one segment, which ensures we
811 * can safely use MSG_PEEK and avoid buffering.
812 *
813 * Once the data is fetched, the values are set in the connection's address
814 * fields, and data are removed from the socket's buffer. The function returns
815 * zero if it needs to wait for more data or if it fails, or 1 if it completed
816 * and removed itself.
817 */
818int conn_recv_netscaler_cip(struct connection *conn, int flag)
819{
820 char *line;
Bertrand Jacquin7d668f92017-12-13 01:23:39 +0000821 uint32_t hdr_len;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100822 uint8_t ip_v;
Willy Tarreaub406b872018-08-22 05:20:32 +0200823 int ret;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100824
825 /* we might have been called just after an asynchronous shutr */
826 if (conn->flags & CO_FL_SOCK_RD_SH)
827 goto fail;
828
829 if (!conn_ctrl_ready(conn))
830 goto fail;
831
Willy Tarreau585744b2017-08-24 14:31:19 +0200832 if (!fd_recv_ready(conn->handle.fd))
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100833 return 0;
834
835 do {
Willy Tarreaub406b872018-08-22 05:20:32 +0200836 ret = recv(conn->handle.fd, trash.area, trash.size, MSG_PEEK);
837 if (ret < 0) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100838 if (errno == EINTR)
839 continue;
840 if (errno == EAGAIN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200841 fd_cant_recv(conn->handle.fd);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100842 return 0;
843 }
844 goto recv_abort;
845 }
Willy Tarreaub406b872018-08-22 05:20:32 +0200846 trash.data = ret;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100847 } while (0);
848
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200849 if (!trash.data) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100850 /* client shutdown */
851 conn->err_code = CO_ER_CIP_EMPTY;
852 goto fail;
853 }
854
855 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000856 * CIP magic, header length or
857 * CIP magic, CIP length, CIP type, header length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200858 if (trash.data < 12)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100859 goto missing;
860
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200861 line = trash.area;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100862
863 /* Decode a possible NetScaler Client IP request, fail early if
864 * it does not match */
Bertrand Jacquin4b4c2862017-12-13 01:07:12 +0000865 if (ntohl(*(uint32_t *)line) != objt_listener(conn->target)->bind_conf->ns_cip_magic)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100866 goto bad_magic;
867
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000868 /* Legacy CIP protocol */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200869 if ((trash.area[8] & 0xD0) == 0x40) {
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000870 hdr_len = ntohl(*(uint32_t *)(line+4));
871 line += 8;
872 }
873 /* Standard CIP protocol */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200874 else if (trash.area[8] == 0x00) {
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000875 hdr_len = ntohs(*(uint32_t *)(line+10));
876 line += 12;
877 }
878 /* Unknown CIP protocol */
879 else {
880 conn->err_code = CO_ER_CIP_BAD_PROTO;
881 goto fail;
882 }
883
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100884 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000885 * a minimal IP header */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200886 if (trash.data < 20)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100887 goto missing;
888
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100889 /* Get IP version from the first four bits */
890 ip_v = (*line & 0xf0) >> 4;
891
892 if (ip_v == 4) {
893 struct ip *hdr_ip4;
David Carlier3015a2e2016-07-04 22:51:33 +0100894 struct my_tcphdr *hdr_tcp;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100895
896 hdr_ip4 = (struct ip *)line;
897
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200898 if (trash.data < 40 || trash.data < hdr_len) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100899 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin67de5a22017-12-13 01:15:05 +0000900 * IPv4 header, TCP header */
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100901 goto missing;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000902 }
903 else if (hdr_ip4->ip_p != IPPROTO_TCP) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100904 /* The protocol does not include a TCP header */
905 conn->err_code = CO_ER_CIP_BAD_PROTO;
906 goto fail;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000907 }
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100908
David Carlier3015a2e2016-07-04 22:51:33 +0100909 hdr_tcp = (struct my_tcphdr *)(line + (hdr_ip4->ip_hl * 4));
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100910
911 /* update the session's addresses and mark them set */
912 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
913 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = hdr_ip4->ip_src.s_addr;
914 ((struct sockaddr_in *)&conn->addr.from)->sin_port = hdr_tcp->source;
915
916 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
917 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = hdr_ip4->ip_dst.s_addr;
918 ((struct sockaddr_in *)&conn->addr.to)->sin_port = hdr_tcp->dest;
919
920 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
921 }
922 else if (ip_v == 6) {
923 struct ip6_hdr *hdr_ip6;
David Carlier3015a2e2016-07-04 22:51:33 +0100924 struct my_tcphdr *hdr_tcp;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100925
926 hdr_ip6 = (struct ip6_hdr *)line;
927
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200928 if (trash.data < 60 || trash.data < hdr_len) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100929 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin67de5a22017-12-13 01:15:05 +0000930 * IPv6 header, TCP header */
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100931 goto missing;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000932 }
933 else if (hdr_ip6->ip6_nxt != IPPROTO_TCP) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100934 /* The protocol does not include a TCP header */
935 conn->err_code = CO_ER_CIP_BAD_PROTO;
936 goto fail;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000937 }
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100938
David Carlier3015a2e2016-07-04 22:51:33 +0100939 hdr_tcp = (struct my_tcphdr *)(line + sizeof(struct ip6_hdr));
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100940
941 /* update the session's addresses and mark them set */
942 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
943 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr = hdr_ip6->ip6_src;
944 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = hdr_tcp->source;
945
946 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
947 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr = hdr_ip6->ip6_dst;
948 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = hdr_tcp->dest;
949
950 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
951 }
952 else {
953 /* The protocol does not match something known (IPv4/IPv6) */
954 conn->err_code = CO_ER_CIP_BAD_PROTO;
955 goto fail;
956 }
957
Bertrand Jacquin7d668f92017-12-13 01:23:39 +0000958 line += hdr_len;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200959 trash.data = line - trash.area;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100960
961 /* remove the NetScaler Client IP header from the request. For this
962 * we re-read the exact line at once. If we don't get the exact same
963 * result, we fail.
964 */
965 do {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200966 int len2 = recv(conn->handle.fd, trash.area, trash.data, 0);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100967 if (len2 < 0 && errno == EINTR)
968 continue;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200969 if (len2 != trash.data)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100970 goto recv_abort;
971 } while (0);
972
973 conn->flags &= ~flag;
974 return 1;
975
976 missing:
977 /* Missing data. Since we're using MSG_PEEK, we can only poll again if
978 * we have not read anything. Otherwise we need to fail because we won't
979 * be able to poll anymore.
980 */
981 conn->err_code = CO_ER_CIP_TRUNCATED;
982 goto fail;
983
984 bad_magic:
985 conn->err_code = CO_ER_CIP_BAD_MAGIC;
986 goto fail;
987
988 recv_abort:
989 conn->err_code = CO_ER_CIP_ABORT;
990 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
991 goto fail;
992
993 fail:
994 __conn_sock_stop_both(conn);
995 conn->flags |= CO_FL_ERROR;
996 return 0;
997}
998
David Safb76832014-05-08 23:42:08 -0400999int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote)
1000{
1001 int ret = 0;
1002
1003 if (srv && (srv->pp_opts & SRV_PP_V2)) {
1004 ret = make_proxy_line_v2(buf, buf_len, srv, remote);
1005 }
1006 else {
1007 if (remote)
1008 ret = make_proxy_line_v1(buf, buf_len, &remote->addr.from, &remote->addr.to);
1009 else
1010 ret = make_proxy_line_v1(buf, buf_len, NULL, NULL);
1011 }
1012
1013 return ret;
1014}
1015
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001016/* Makes a PROXY protocol line from the two addresses. The output is sent to
1017 * buffer <buf> for a maximum size of <buf_len> (including the trailing zero).
1018 * It returns the number of bytes composing this line (including the trailing
1019 * LF), or zero in case of failure (eg: not enough space). It supports TCP4,
Willy Tarreau2e1401a2013-10-01 11:41:55 +02001020 * TCP6 and "UNKNOWN" formats. If any of <src> or <dst> is null, UNKNOWN is
1021 * emitted as well.
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001022 */
David Safb76832014-05-08 23:42:08 -04001023int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst)
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001024{
1025 int ret = 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001026 char * protocol;
1027 char src_str[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
1028 char dst_str[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
1029 in_port_t src_port;
1030 in_port_t dst_port;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001031
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001032 if ( !src
1033 || !dst
1034 || (src->ss_family != AF_INET && src->ss_family != AF_INET6)
1035 || (dst->ss_family != AF_INET && dst->ss_family != AF_INET6)) {
1036 /* unknown family combination */
1037 ret = snprintf(buf, buf_len, "PROXY UNKNOWN\r\n");
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001038 if (ret >= buf_len)
1039 return 0;
1040
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001041 return ret;
1042 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001043
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001044 /* IPv4 for both src and dst */
1045 if (src->ss_family == AF_INET && dst->ss_family == AF_INET) {
1046 protocol = "TCP4";
1047 if (!inet_ntop(AF_INET, &((struct sockaddr_in *)src)->sin_addr, src_str, sizeof(src_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001048 return 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001049 src_port = ((struct sockaddr_in *)src)->sin_port;
1050 if (!inet_ntop(AF_INET, &((struct sockaddr_in *)dst)->sin_addr, dst_str, sizeof(dst_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001051 return 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001052 dst_port = ((struct sockaddr_in *)dst)->sin_port;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001053 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001054 /* IPv6 for at least one of src and dst */
1055 else {
1056 struct in6_addr tmp;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001057
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001058 protocol = "TCP6";
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001059
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001060 if (src->ss_family == AF_INET) {
1061 /* Convert src to IPv6 */
1062 v4tov6(&tmp, &((struct sockaddr_in *)src)->sin_addr);
1063 src_port = ((struct sockaddr_in *)src)->sin_port;
1064 }
1065 else {
1066 tmp = ((struct sockaddr_in6 *)src)->sin6_addr;
1067 src_port = ((struct sockaddr_in6 *)src)->sin6_port;
1068 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001069
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001070 if (!inet_ntop(AF_INET6, &tmp, src_str, sizeof(src_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001071 return 0;
1072
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001073 if (dst->ss_family == AF_INET) {
1074 /* Convert dst to IPv6 */
1075 v4tov6(&tmp, &((struct sockaddr_in *)dst)->sin_addr);
1076 dst_port = ((struct sockaddr_in *)dst)->sin_port;
1077 }
1078 else {
1079 tmp = ((struct sockaddr_in6 *)dst)->sin6_addr;
1080 dst_port = ((struct sockaddr_in6 *)dst)->sin6_port;
1081 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001082
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001083 if (!inet_ntop(AF_INET6, &tmp, dst_str, sizeof(dst_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001084 return 0;
1085 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001086
1087 ret = snprintf(buf, buf_len, "PROXY %s %s %s %u %u\r\n", protocol, src_str, dst_str, ntohs(src_port), ntohs(dst_port));
1088 if (ret >= buf_len)
1089 return 0;
1090
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001091 return ret;
1092}
David Safb76832014-05-08 23:42:08 -04001093
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001094static int make_tlv(char *dest, int dest_len, char type, uint16_t length, const char *value)
David Safb76832014-05-08 23:42:08 -04001095{
1096 struct tlv *tlv;
1097
1098 if (!dest || (length + sizeof(*tlv) > dest_len))
1099 return 0;
1100
1101 tlv = (struct tlv *)dest;
1102
1103 tlv->type = type;
1104 tlv->length_hi = length >> 8;
1105 tlv->length_lo = length & 0x00ff;
1106 memcpy(tlv->value, value, length);
1107 return length + sizeof(*tlv);
1108}
David Safb76832014-05-08 23:42:08 -04001109
1110int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote)
1111{
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001112 const char pp2_signature[] = PP2_SIGNATURE;
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001113 void *tlv_crc32c_p = NULL;
David Safb76832014-05-08 23:42:08 -04001114 int ret = 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001115 struct proxy_hdr_v2 *hdr = (struct proxy_hdr_v2 *)buf;
Vincent Bernat6e615892016-05-18 16:17:44 +02001116 struct sockaddr_storage null_addr = { .ss_family = 0 };
David Safb76832014-05-08 23:42:08 -04001117 struct sockaddr_storage *src = &null_addr;
1118 struct sockaddr_storage *dst = &null_addr;
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001119 const char *value;
1120 int value_len;
David Safb76832014-05-08 23:42:08 -04001121
1122 if (buf_len < PP2_HEADER_LEN)
1123 return 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001124 memcpy(hdr->sig, pp2_signature, PP2_SIGNATURE_LEN);
David Safb76832014-05-08 23:42:08 -04001125
1126 if (remote) {
1127 src = &remote->addr.from;
1128 dst = &remote->addr.to;
1129 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001130
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001131 /* At least one of src or dst is not of AF_INET or AF_INET6 */
1132 if ( !src
1133 || !dst
1134 || (src->ss_family != AF_INET && src->ss_family != AF_INET6)
1135 || (dst->ss_family != AF_INET && dst->ss_family != AF_INET6)) {
David Safb76832014-05-08 23:42:08 -04001136 if (buf_len < PP2_HDR_LEN_UNSPEC)
1137 return 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001138 hdr->ver_cmd = PP2_VERSION | PP2_CMD_LOCAL;
1139 hdr->fam = PP2_FAM_UNSPEC | PP2_TRANS_UNSPEC;
David Safb76832014-05-08 23:42:08 -04001140 ret = PP2_HDR_LEN_UNSPEC;
1141 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001142 else {
1143 /* IPv4 for both src and dst */
1144 if (src->ss_family == AF_INET && dst->ss_family == AF_INET) {
1145 if (buf_len < PP2_HDR_LEN_INET)
1146 return 0;
1147 hdr->ver_cmd = PP2_VERSION | PP2_CMD_PROXY;
1148 hdr->fam = PP2_FAM_INET | PP2_TRANS_STREAM;
1149 hdr->addr.ip4.src_addr = ((struct sockaddr_in *)src)->sin_addr.s_addr;
1150 hdr->addr.ip4.src_port = ((struct sockaddr_in *)src)->sin_port;
1151 hdr->addr.ip4.dst_addr = ((struct sockaddr_in *)dst)->sin_addr.s_addr;
1152 hdr->addr.ip4.dst_port = ((struct sockaddr_in *)dst)->sin_port;
1153 ret = PP2_HDR_LEN_INET;
1154 }
1155 /* IPv6 for at least one of src and dst */
1156 else {
1157 struct in6_addr tmp;
1158
1159 if (buf_len < PP2_HDR_LEN_INET6)
1160 return 0;
1161 hdr->ver_cmd = PP2_VERSION | PP2_CMD_PROXY;
1162 hdr->fam = PP2_FAM_INET6 | PP2_TRANS_STREAM;
1163 if (src->ss_family == AF_INET) {
1164 v4tov6(&tmp, &((struct sockaddr_in *)src)->sin_addr);
1165 memcpy(hdr->addr.ip6.src_addr, &tmp, 16);
1166 hdr->addr.ip6.src_port = ((struct sockaddr_in *)src)->sin_port;
1167 }
1168 else {
1169 memcpy(hdr->addr.ip6.src_addr, &((struct sockaddr_in6 *)src)->sin6_addr, 16);
1170 hdr->addr.ip6.src_port = ((struct sockaddr_in6 *)src)->sin6_port;
1171 }
1172 if (dst->ss_family == AF_INET) {
1173 v4tov6(&tmp, &((struct sockaddr_in *)dst)->sin_addr);
1174 memcpy(hdr->addr.ip6.dst_addr, &tmp, 16);
1175 hdr->addr.ip6.src_port = ((struct sockaddr_in *)src)->sin_port;
1176 }
1177 else {
1178 memcpy(hdr->addr.ip6.dst_addr, &((struct sockaddr_in6 *)dst)->sin6_addr, 16);
1179 hdr->addr.ip6.dst_port = ((struct sockaddr_in6 *)dst)->sin6_port;
1180 }
1181
1182 ret = PP2_HDR_LEN_INET6;
1183 }
1184 }
David Safb76832014-05-08 23:42:08 -04001185
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001186 if (srv->pp_opts & SRV_PP_V2_CRC32C) {
1187 uint32_t zero_crc32c = 0;
1188 if ((buf_len - ret) < sizeof(struct tlv))
1189 return 0;
1190 tlv_crc32c_p = (void *)((struct tlv *)&buf[ret])->value;
1191 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_CRC32C, sizeof(zero_crc32c), (const char *)&zero_crc32c);
1192 }
1193
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001194 if (conn_get_alpn(remote, &value, &value_len)) {
1195 if ((buf_len - ret) < sizeof(struct tlv))
1196 return 0;
Emmanuel Hocdet571c7ac2017-10-31 18:24:05 +01001197 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_ALPN, value_len, value);
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001198 }
1199
David Safb76832014-05-08 23:42:08 -04001200#ifdef USE_OPENSSL
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01001201 if (srv->pp_opts & SRV_PP_V2_AUTHORITY) {
1202 value = ssl_sock_get_sni(remote);
1203 if (value) {
1204 if ((buf_len - ret) < sizeof(struct tlv))
1205 return 0;
1206 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_AUTHORITY, strlen(value), value);
1207 }
1208 }
1209
David Safb76832014-05-08 23:42:08 -04001210 if (srv->pp_opts & SRV_PP_V2_SSL) {
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001211 struct tlv_ssl *tlv;
1212 int ssl_tlv_len = 0;
David Safb76832014-05-08 23:42:08 -04001213 if ((buf_len - ret) < sizeof(struct tlv_ssl))
1214 return 0;
1215 tlv = (struct tlv_ssl *)&buf[ret];
1216 memset(tlv, 0, sizeof(struct tlv_ssl));
1217 ssl_tlv_len += sizeof(struct tlv_ssl);
1218 tlv->tlv.type = PP2_TYPE_SSL;
1219 if (ssl_sock_is_ssl(remote)) {
1220 tlv->client |= PP2_CLIENT_SSL;
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02001221 value = ssl_sock_get_proto_version(remote);
David Safb76832014-05-08 23:42:08 -04001222 if (value) {
Emmanuel Hocdet8c0c34b2018-02-28 12:02:14 +01001223 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len-ret-ssl_tlv_len), PP2_SUBTYPE_SSL_VERSION, strlen(value), value);
David Safb76832014-05-08 23:42:08 -04001224 }
Dave McCowan328fb582014-07-30 10:39:13 -04001225 if (ssl_sock_get_cert_used_sess(remote)) {
1226 tlv->client |= PP2_CLIENT_CERT_SESS;
David Safb76832014-05-08 23:42:08 -04001227 tlv->verify = htonl(ssl_sock_get_verify_result(remote));
Dave McCowan328fb582014-07-30 10:39:13 -04001228 if (ssl_sock_get_cert_used_conn(remote))
1229 tlv->client |= PP2_CLIENT_CERT_CONN;
David Safb76832014-05-08 23:42:08 -04001230 }
1231 if (srv->pp_opts & SRV_PP_V2_SSL_CN) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001232 struct buffer *cn_trash = get_trash_chunk();
Willy Tarreau3b9a0c92014-07-19 06:37:33 +02001233 if (ssl_sock_get_remote_common_name(remote, cn_trash) > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001234 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_CN,
1235 cn_trash->data,
1236 cn_trash->area);
David Safb76832014-05-08 23:42:08 -04001237 }
1238 }
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001239 if (srv->pp_opts & SRV_PP_V2_SSL_KEY_ALG) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001240 struct buffer *pkey_trash = get_trash_chunk();
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001241 if (ssl_sock_get_pkey_algo(remote, pkey_trash) > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001242 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_KEY_ALG,
1243 pkey_trash->data,
1244 pkey_trash->area);
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001245 }
1246 }
1247 if (srv->pp_opts & SRV_PP_V2_SSL_SIG_ALG) {
1248 value = ssl_sock_get_cert_sig(remote);
1249 if (value) {
1250 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_SIG_ALG, strlen(value), value);
1251 }
1252 }
1253 if (srv->pp_opts & SRV_PP_V2_SSL_CIPHER) {
1254 value = ssl_sock_get_cipher_name(remote);
1255 if (value) {
1256 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_CIPHER, strlen(value), value);
1257 }
1258 }
David Safb76832014-05-08 23:42:08 -04001259 }
1260 tlv->tlv.length_hi = (uint16_t)(ssl_tlv_len - sizeof(struct tlv)) >> 8;
1261 tlv->tlv.length_lo = (uint16_t)(ssl_tlv_len - sizeof(struct tlv)) & 0x00ff;
1262 ret += ssl_tlv_len;
1263 }
1264#endif
1265
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001266#ifdef CONFIG_HAP_NS
1267 if (remote && (remote->proxy_netns)) {
1268 if ((buf_len - ret) < sizeof(struct tlv))
1269 return 0;
Emmanuel Hocdet571c7ac2017-10-31 18:24:05 +01001270 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_NETNS, remote->proxy_netns->name_len, remote->proxy_netns->node.key);
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001271 }
1272#endif
1273
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001274 hdr->len = htons((uint16_t)(ret - PP2_HEADER_LEN));
David Safb76832014-05-08 23:42:08 -04001275
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001276 if (tlv_crc32c_p) {
1277 write_u32(tlv_crc32c_p, htonl(hash_crc32c(buf, ret)));
1278 }
1279
David Safb76832014-05-08 23:42:08 -04001280 return ret;
1281}
Emeric Brun4f603012017-01-05 15:11:44 +01001282
Willy Tarreau60ca10a2017-08-18 15:26:54 +02001283/* return the major HTTP version as 1 or 2 depending on how the request arrived
1284 * before being processed.
1285 */
1286static int
1287smp_fetch_fc_http_major(const struct arg *args, struct sample *smp, const char *kw, void *private)
1288{
1289 struct connection *conn = objt_conn(smp->sess->origin);
1290
1291 smp->data.type = SMP_T_SINT;
1292 smp->data.u.sint = (conn && strcmp(conn_get_mux_name(conn), "H2") == 0) ? 2 : 1;
1293 return 1;
1294}
1295
Emeric Brun4f603012017-01-05 15:11:44 +01001296/* fetch if the received connection used a PROXY protocol header */
1297int smp_fetch_fc_rcvd_proxy(const struct arg *args, struct sample *smp, const char *kw, void *private)
1298{
1299 struct connection *conn;
1300
1301 conn = objt_conn(smp->sess->origin);
1302 if (!conn)
1303 return 0;
1304
1305 if (!(conn->flags & CO_FL_CONNECTED)) {
1306 smp->flags |= SMP_F_MAY_CHANGE;
1307 return 0;
1308 }
1309
1310 smp->flags = 0;
1311 smp->data.type = SMP_T_BOOL;
1312 smp->data.u.sint = (conn->flags & CO_FL_RCVD_PROXY) ? 1 : 0;
1313
1314 return 1;
1315}
1316
1317/* Note: must not be declared <const> as its list will be overwritten.
1318 * Note: fetches that may return multiple types must be declared as the lowest
1319 * common denominator, the type that can be casted into all other ones. For
1320 * instance v4/v6 must be declared v4.
1321 */
1322static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
Willy Tarreau60ca10a2017-08-18 15:26:54 +02001323 { "fc_http_major", smp_fetch_fc_http_major, 0, NULL, SMP_T_SINT, SMP_USE_L4CLI },
Emeric Brun4f603012017-01-05 15:11:44 +01001324 { "fc_rcvd_proxy", smp_fetch_fc_rcvd_proxy, 0, NULL, SMP_T_BOOL, SMP_USE_L4CLI },
1325 { /* END */ },
1326}};
1327
1328
1329__attribute__((constructor))
1330static void __connection_init(void)
1331{
1332 sample_register_fetches(&sample_fetch_keywords);
1333}