blob: 37e48c528c1d3e0eb6353c0c3ee3458ced0b5afe [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>
Willy Tarreau0108d902018-11-25 19:14:37 +010017#include <common/initcall.h>
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010018#include <common/namespace.h>
Emmanuel Hocdet4399c752018-02-05 15:26:43 +010019#include <common/hash.h>
20#include <common/net_helper.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020021
Willy Tarreauc5788912012-08-24 18:12:41 +020022#include <proto/connection.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020023#include <proto/fd.h>
Willy Tarreau5f1504f2012-10-04 23:55:57 +020024#include <proto/frontend.h>
Willy Tarreau2da156f2012-07-23 15:07:23 +020025#include <proto/proto_tcp.h>
Willy Tarreau2c6be842012-07-06 17:12:34 +020026#include <proto/stream_interface.h>
Emeric Brun4f603012017-01-05 15:11:44 +010027#include <proto/sample.h>
Willy Tarreau59f98392012-07-06 14:13:49 +020028
Emeric Brun46591952012-05-18 15:47:34 +020029#ifdef USE_OPENSSL
30#include <proto/ssl_sock.h>
31#endif
32
Willy Tarreau8ceae722018-11-26 11:58:30 +010033DECLARE_POOL(pool_head_connection, "connection", sizeof(struct connection));
34DECLARE_POOL(pool_head_connstream, "conn_stream", sizeof(struct conn_stream));
35
Willy Tarreau13e14102016-12-22 20:25:26 +010036struct xprt_ops *registered_xprt[XPRT_ENTRIES] = { NULL, };
Willy Tarreauf2943dc2012-10-26 20:10:28 +020037
Christopher Faulet32f61c02018-04-10 14:33:41 +020038/* List head of all known muxes for PROTO */
39struct mux_proto_list mux_proto_list = {
40 .list = LIST_HEAD_INIT(mux_proto_list.list)
Willy Tarreau2386be62017-09-21 19:40:52 +020041};
42
Willy Tarreau59f98392012-07-06 14:13:49 +020043/* I/O callback for fd-based connections. It calls the read/write handlers
Willy Tarreau7a798e52016-04-14 11:13:20 +020044 * provided by the connection's sock_ops, which must be valid.
Willy Tarreau59f98392012-07-06 14:13:49 +020045 */
Willy Tarreau7a798e52016-04-14 11:13:20 +020046void conn_fd_handler(int fd)
Willy Tarreau59f98392012-07-06 14:13:49 +020047{
Willy Tarreau80184712012-07-06 14:54:49 +020048 struct connection *conn = fdtab[fd].owner;
Willy Tarreau9e272bf2012-10-03 21:04:48 +020049 unsigned int flags;
Olivier Houchardaf4021e2018-08-09 13:06:55 +020050 int io_available = 0;
Willy Tarreau59f98392012-07-06 14:13:49 +020051
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010052 if (unlikely(!conn)) {
53 activity[tid].conn_dead++;
Willy Tarreau7a798e52016-04-14 11:13:20 +020054 return;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010055 }
Willy Tarreau59f98392012-07-06 14:13:49 +020056
Willy Tarreau7d281492012-12-16 19:19:13 +010057 conn_refresh_polling_flags(conn);
Willy Tarreau916e12d2017-10-25 09:22:43 +020058 conn->flags |= CO_FL_WILL_UPDATE;
59
Willy Tarreau7d281492012-12-16 19:19:13 +010060 flags = conn->flags & ~CO_FL_ERROR; /* ensure to call the wake handler upon error */
Willy Tarreaud29a0662012-12-10 16:33:38 +010061
Willy Tarreauc76ae332012-07-12 15:32:13 +020062 process_handshake:
Willy Tarreauf9dabec2012-08-17 17:33:53 +020063 /* The handshake callbacks are called in sequence. If either of them is
64 * missing something, it must enable the required polling at the socket
65 * layer of the connection. Polling state is not guaranteed when entering
66 * these handlers, so any handshake handler which does not complete its
Willy Tarreaud6e999b2013-11-25 08:41:15 +010067 * work must explicitly disable events it's not interested in. Error
68 * handling is also performed here in order to reduce the number of tests
69 * around.
Willy Tarreauf9dabec2012-08-17 17:33:53 +020070 */
Willy Tarreaud6e999b2013-11-25 08:41:15 +010071 while (unlikely(conn->flags & (CO_FL_HANDSHAKE | CO_FL_ERROR))) {
Willy Tarreau310987a2014-01-22 19:46:33 +010072 if (unlikely(conn->flags & CO_FL_ERROR))
Willy Tarreau2c6be842012-07-06 17:12:34 +020073 goto leave;
Willy Tarreau59f98392012-07-06 14:13:49 +020074
Bertrand Jacquin93b227d2016-06-04 15:11:10 +010075 if (conn->flags & CO_FL_ACCEPT_CIP)
76 if (!conn_recv_netscaler_cip(conn, CO_FL_ACCEPT_CIP))
77 goto leave;
78
Willy Tarreau22cda212012-08-31 17:43:29 +020079 if (conn->flags & CO_FL_ACCEPT_PROXY)
80 if (!conn_recv_proxy(conn, CO_FL_ACCEPT_PROXY))
81 goto leave;
82
Willy Tarreau57cd3e42013-10-24 22:01:26 +020083 if (conn->flags & CO_FL_SEND_PROXY)
84 if (!conn_si_send_proxy(conn, CO_FL_SEND_PROXY))
Willy Tarreau5f1504f2012-10-04 23:55:57 +020085 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +020086#ifdef USE_OPENSSL
87 if (conn->flags & CO_FL_SSL_WAIT_HS)
88 if (!ssl_sock_handshake(conn, CO_FL_SSL_WAIT_HS))
89 goto leave;
90#endif
Willy Tarreauc76ae332012-07-12 15:32:13 +020091 }
92
Willy Tarreauf9dabec2012-08-17 17:33:53 +020093 /* Once we're purely in the data phase, we disable handshake polling */
94 if (!(conn->flags & CO_FL_POLL_SOCK))
95 __conn_sock_stop_both(conn);
Willy Tarreauc76ae332012-07-12 15:32:13 +020096
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +020097 /* The connection owner might want to be notified about an end of
98 * handshake indicating the connection is ready, before we proceed with
99 * any data exchange. The callback may fail and cause the connection to
100 * be destroyed, thus we must not use it anymore and should immediately
101 * leave instead. The caller must immediately unregister itself once
102 * called.
Willy Tarreau2542b532012-08-31 16:01:23 +0200103 */
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200104 if (conn->xprt_done_cb && conn->xprt_done_cb(conn) < 0)
Willy Tarreau7a798e52016-04-14 11:13:20 +0200105 return;
Willy Tarreau2542b532012-08-31 16:01:23 +0200106
Willy Tarreau57ec32f2017-04-11 19:59:33 +0200107 if (conn->xprt && fd_send_ready(fd) &&
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200108 ((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 +0100109 /* force reporting of activity by clearing the previous flags :
110 * we'll have at least ERROR or CONNECTED at the end of an I/O,
111 * both of which will be detected below.
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200112 */
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100113 flags = 0;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200114 if (conn->send_wait != NULL) {
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100115 conn->send_wait->events &= ~SUB_RETRY_SEND;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200116 tasklet_wakeup(conn->send_wait->task);
117 conn->send_wait = NULL;
118 } else
119 io_available = 1;
Olivier Houchard53216e72018-10-10 15:46:36 +0200120 __conn_xprt_stop_send(conn);
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200121 }
Willy Tarreau59f98392012-07-06 14:13:49 +0200122
Willy Tarreau57ec32f2017-04-11 19:59:33 +0200123 /* The data transfer starts here and stops on error and handshakes. Note
124 * that we must absolutely test conn->xprt at each step in case it suddenly
125 * changes due to a quick unexpected close().
126 */
127 if (conn->xprt && fd_recv_ready(fd) &&
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200128 ((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 +0100129 /* force reporting of activity by clearing the previous flags :
130 * we'll have at least ERROR or CONNECTED at the end of an I/O,
131 * both of which will be detected below.
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200132 */
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100133 flags = 0;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200134 if (conn->recv_wait) {
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100135 conn->recv_wait->events &= ~SUB_RETRY_RECV;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200136 tasklet_wakeup(conn->recv_wait->task);
137 conn->recv_wait = NULL;
138 } else
139 io_available = 1;
Olivier Houchard53216e72018-10-10 15:46:36 +0200140 __conn_xprt_stop_recv(conn);
Willy Tarreau9e272bf2012-10-03 21:04:48 +0200141 }
Willy Tarreau2da156f2012-07-23 15:07:23 +0200142
Willy Tarreauc76ae332012-07-12 15:32:13 +0200143 /* It may happen during the data phase that a handshake is
144 * enabled again (eg: SSL)
145 */
Willy Tarreaud6e999b2013-11-25 08:41:15 +0100146 if (unlikely(conn->flags & (CO_FL_HANDSHAKE | CO_FL_ERROR)))
Willy Tarreauc76ae332012-07-12 15:32:13 +0200147 goto process_handshake;
148
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100149 if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN)) {
Willy Tarreauf8deb0c2012-09-01 17:59:22 +0200150 /* still waiting for a connection to establish and nothing was
151 * attempted yet to probe the connection. Then let's retry the
152 * connect().
Willy Tarreau2da156f2012-07-23 15:07:23 +0200153 */
Willy Tarreau239d7182012-07-23 18:53:03 +0200154 if (!tcp_connect_probe(conn))
Willy Tarreauafad0e02012-08-09 14:45:22 +0200155 goto leave;
Willy Tarreau2da156f2012-07-23 15:07:23 +0200156 }
Willy Tarreau2c6be842012-07-06 17:12:34 +0200157 leave:
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100158 /* Verify if the connection just established. */
Willy Tarreau7bf3fa32017-03-14 20:19:29 +0100159 if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED))))
160 conn->flags |= CO_FL_CONNECTED;
161
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200162 /* The connection owner might want to be notified about failures to
163 * complete the handshake. The callback may fail and cause the
164 * connection to be destroyed, thus we must not use it anymore and
165 * should immediately leave instead. The caller must immediately
166 * unregister itself once called.
167 */
168 if (((conn->flags ^ flags) & CO_FL_NOTIFY_DONE) &&
169 conn->xprt_done_cb && conn->xprt_done_cb(conn) < 0)
170 return;
171
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100172 /* The wake callback is normally used to notify the data layer about
173 * data layer activity (successful send/recv), connection establishment,
174 * shutdown and fatal errors. We need to consider the following
175 * situations to wake up the data layer :
176 * - change among the CO_FL_NOTIFY_DATA flags :
177 * {DATA,SOCK}_{RD,WR}_SH, ERROR,
178 * - absence of any of {L4,L6}_CONN and CONNECTED, indicating the
179 * end of handshake and transition to CONNECTED
180 * - raise of CONNECTED with HANDSHAKE down
181 * - end of HANDSHAKE with CONNECTED set
182 * - regular data layer activity
183 *
184 * Note that the wake callback is allowed to release the connection and
185 * the fd (and return < 0 in this case).
Willy Tarreau2396c1c2012-10-03 21:12:16 +0200186 */
Olivier Houchardaf4021e2018-08-09 13:06:55 +0200187 if ((io_available || (((conn->flags ^ flags) & CO_FL_NOTIFY_DATA) ||
Willy Tarreau3c0cc492017-03-19 07:54:28 +0100188 ((flags & (CO_FL_CONNECTED|CO_FL_HANDSHAKE)) != CO_FL_CONNECTED &&
Olivier Houchard910b2bc2018-07-17 18:49:38 +0200189 (conn->flags & (CO_FL_CONNECTED|CO_FL_HANDSHAKE)) == CO_FL_CONNECTED))) &&
Olivier Houchard7505f942018-08-21 18:10:44 +0200190 conn->mux->wake && conn->mux->wake(conn) < 0)
Willy Tarreau7a798e52016-04-14 11:13:20 +0200191 return;
Willy Tarreaufd31e532012-07-23 18:24:25 +0200192
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200193 /* commit polling changes */
Willy Tarreau916e12d2017-10-25 09:22:43 +0200194 conn->flags &= ~CO_FL_WILL_UPDATE;
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200195 conn_cond_update_polling(conn);
Willy Tarreau7a798e52016-04-14 11:13:20 +0200196 return;
Willy Tarreau59f98392012-07-06 14:13:49 +0200197}
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200198
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200199/* Update polling on connection <c>'s file descriptor depending on its current
200 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200201 * in CO_FL_WAIT_*, and the data layer expectations indicated by CO_FL_XPRT_*.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200202 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200203 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200204 */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200205void conn_update_xprt_polling(struct connection *c)
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200206{
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200207 unsigned int f = c->flags;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200208
Willy Tarreau3c728722014-01-23 13:50:42 +0100209 if (!conn_ctrl_ready(c))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200210 return;
211
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200212 /* update read status if needed */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200213 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 +0200214 fd_want_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100215 f |= CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200216 }
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200217 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 +0200218 fd_stop_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100219 f &= ~CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200220 }
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200221
222 /* update write status if needed */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200223 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 +0200224 fd_want_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100225 f |= CO_FL_CURR_WR_ENA;
226 }
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200227 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 +0200228 fd_stop_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100229 f &= ~CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200230 }
Willy Tarreau310987a2014-01-22 19:46:33 +0100231 c->flags = f;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200232}
233
234/* Update polling on connection <c>'s file descriptor depending on its current
235 * state as reported in the connection's CO_FL_CURR_* flags, reports of EAGAIN
236 * in CO_FL_WAIT_*, and the sock layer expectations indicated by CO_FL_SOCK_*.
237 * The connection flags are updated with the new flags at the end of the
Willy Tarreau0ffde2c2012-10-04 22:21:15 +0200238 * operation. Polling is totally disabled if an error was reported.
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200239 */
240void conn_update_sock_polling(struct connection *c)
241{
242 unsigned int f = c->flags;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200243
Willy Tarreau3c728722014-01-23 13:50:42 +0100244 if (!conn_ctrl_ready(c))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200245 return;
246
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200247 /* update read status if needed */
Willy Tarreau310987a2014-01-22 19:46:33 +0100248 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 +0200249 fd_want_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100250 f |= CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200251 }
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100252 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 +0200253 fd_stop_recv(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100254 f &= ~CO_FL_CURR_RD_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200255 }
256
257 /* update write status if needed */
Willy Tarreau310987a2014-01-22 19:46:33 +0100258 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 +0200259 fd_want_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100260 f |= CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200261 }
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100262 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 +0200263 fd_stop_send(c->handle.fd);
Willy Tarreauc8dd77f2012-11-05 17:52:26 +0100264 f &= ~CO_FL_CURR_WR_ENA;
Willy Tarreaue9dfa792012-09-01 17:26:16 +0200265 }
Willy Tarreau310987a2014-01-22 19:46:33 +0100266 c->flags = f;
Willy Tarreaub5e2cbd2012-08-17 11:55:04 +0200267}
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200268
Willy Tarreauff3e6482015-03-12 23:56:52 +0100269/* Send a message over an established connection. It makes use of send() and
270 * returns the same return code and errno. If the socket layer is not ready yet
271 * then -1 is returned and ENOTSOCK is set into errno. If the fd is not marked
272 * as ready, or if EAGAIN or ENOTCONN is returned, then we return 0. It returns
273 * EMSGSIZE if called with a zero length message. The purpose is to simplify
274 * some rare attempts to directly write on the socket from above the connection
275 * (typically send_proxy). In case of EAGAIN, the fd is marked as "cant_send".
276 * It automatically retries on EINTR. Other errors cause the connection to be
277 * marked as in error state. It takes similar arguments as send() except the
278 * first one which is the connection instead of the file descriptor. Note,
279 * MSG_DONTWAIT and MSG_NOSIGNAL are forced on the flags.
280 */
281int conn_sock_send(struct connection *conn, const void *buf, int len, int flags)
282{
283 int ret;
284
285 ret = -1;
286 errno = ENOTSOCK;
287
288 if (conn->flags & CO_FL_SOCK_WR_SH)
289 goto fail;
290
291 if (!conn_ctrl_ready(conn))
292 goto fail;
293
294 errno = EMSGSIZE;
295 if (!len)
296 goto fail;
297
Willy Tarreau585744b2017-08-24 14:31:19 +0200298 if (!fd_send_ready(conn->handle.fd))
Willy Tarreauff3e6482015-03-12 23:56:52 +0100299 goto wait;
300
301 do {
Willy Tarreau585744b2017-08-24 14:31:19 +0200302 ret = send(conn->handle.fd, buf, len, flags | MSG_DONTWAIT | MSG_NOSIGNAL);
Willy Tarreauff3e6482015-03-12 23:56:52 +0100303 } while (ret < 0 && errno == EINTR);
304
305
306 if (ret > 0)
307 return ret;
308
309 if (ret == 0 || errno == EAGAIN || errno == ENOTCONN) {
310 wait:
Willy Tarreau585744b2017-08-24 14:31:19 +0200311 fd_cant_send(conn->handle.fd);
Willy Tarreauff3e6482015-03-12 23:56:52 +0100312 return 0;
313 }
314 fail:
315 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH | CO_FL_ERROR;
316 return ret;
317}
318
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200319int conn_unsubscribe(struct connection *conn, int event_type, void *param)
320{
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200321 struct wait_event *sw;
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200322
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100323 if (event_type & SUB_RETRY_RECV) {
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200324 sw = param;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100325 if (sw->events & SUB_RETRY_RECV) {
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200326 conn->recv_wait = NULL;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100327 sw->events &= ~SUB_RETRY_RECV;
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200328 }
Olivier Houchard53216e72018-10-10 15:46:36 +0200329 __conn_xprt_stop_recv(conn);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200330 }
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100331 if (event_type & SUB_RETRY_SEND) {
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200332 sw = param;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100333 if (sw->events & SUB_RETRY_SEND) {
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200334 conn->send_wait = NULL;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100335 sw->events &= ~SUB_RETRY_SEND;
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200336 }
Olivier Houchard53216e72018-10-10 15:46:36 +0200337 __conn_xprt_stop_send(conn);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200338 }
Olivier Houchard53216e72018-10-10 15:46:36 +0200339 conn_update_xprt_polling(conn);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200340 return 0;
341}
342
Olivier Houchard6ff20392018-07-17 18:46:31 +0200343int conn_subscribe(struct connection *conn, int event_type, void *param)
344{
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200345 struct wait_event *sw;
Olivier Houchard6ff20392018-07-17 18:46:31 +0200346
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100347 if (event_type & SUB_RETRY_RECV) {
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200348 sw = param;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100349 if (!(sw->events & SUB_RETRY_RECV)) {
350 sw->events |= SUB_RETRY_RECV;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200351 conn->recv_wait = sw;
Olivier Houchard4cf7fb12018-08-02 19:23:05 +0200352 }
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100353 event_type &= ~SUB_RETRY_RECV;
Olivier Houchard53216e72018-10-10 15:46:36 +0200354 __conn_xprt_want_recv(conn);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200355 }
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100356 if (event_type & SUB_RETRY_SEND) {
Olivier Houchard6ff20392018-07-17 18:46:31 +0200357 sw = param;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100358 if (!(sw->events & SUB_RETRY_SEND)) {
359 sw->events |= SUB_RETRY_SEND;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200360 conn->send_wait = sw;
Olivier Houcharde1c6dbc2018-08-01 17:06:43 +0200361 }
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100362 event_type &= ~SUB_RETRY_SEND;
Olivier Houchard53216e72018-10-10 15:46:36 +0200363 __conn_xprt_want_send(conn);
Olivier Houchard6ff20392018-07-17 18:46:31 +0200364 }
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200365 if (event_type != 0)
366 return (-1);
Olivier Houchard53216e72018-10-10 15:46:36 +0200367 conn_update_xprt_polling(conn);
Olivier Houchard83a0cd82018-09-28 17:57:58 +0200368 return 0;
Olivier Houchard6ff20392018-07-17 18:46:31 +0200369}
370
Willy Tarreaud85c4852015-03-13 00:40:28 +0100371/* Drains possibly pending incoming data on the file descriptor attached to the
372 * connection and update the connection's flags accordingly. This is used to
373 * know whether we need to disable lingering on close. Returns non-zero if it
374 * is safe to close without disabling lingering, otherwise zero. The SOCK_RD_SH
375 * flag may also be updated if the incoming shutdown was reported by the drain()
376 * function.
377 */
378int conn_sock_drain(struct connection *conn)
379{
Willy Tarreaue215bba2018-08-24 14:31:53 +0200380 int turns = 2;
381 int len;
382
Willy Tarreaud85c4852015-03-13 00:40:28 +0100383 if (!conn_ctrl_ready(conn))
384 return 1;
385
386 if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH))
387 return 1;
388
Willy Tarreaue215bba2018-08-24 14:31:53 +0200389 if (fdtab[conn->handle.fd].ev & (FD_POLL_ERR|FD_POLL_HUP))
390 goto shut;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100391
Willy Tarreaue215bba2018-08-24 14:31:53 +0200392 if (!fd_recv_ready(conn->handle.fd))
393 return 0;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100394
Willy Tarreaue215bba2018-08-24 14:31:53 +0200395 if (conn->ctrl->drain) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200396 if (conn->ctrl->drain(conn->handle.fd) <= 0)
Willy Tarreaud85c4852015-03-13 00:40:28 +0100397 return 0;
Willy Tarreaue215bba2018-08-24 14:31:53 +0200398 goto shut;
399 }
400
401 /* no drain function defined, use the generic one */
402
403 while (turns) {
404#ifdef MSG_TRUNC_CLEARS_INPUT
405 len = recv(conn->handle.fd, NULL, INT_MAX, MSG_DONTWAIT | MSG_NOSIGNAL | MSG_TRUNC);
406 if (len == -1 && errno == EFAULT)
407#endif
408 len = recv(conn->handle.fd, trash.area, trash.size,
409 MSG_DONTWAIT | MSG_NOSIGNAL);
410
411 if (len == 0)
412 goto shut;
413
414 if (len < 0) {
415 if (errno == EAGAIN) {
416 /* connection not closed yet */
417 fd_cant_recv(conn->handle.fd);
418 break;
419 }
420 if (errno == EINTR) /* oops, try again */
421 continue;
422 /* other errors indicate a dead connection, fine. */
423 goto shut;
424 }
425 /* OK we read some data, let's try again once */
426 turns--;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100427 }
428
Willy Tarreaue215bba2018-08-24 14:31:53 +0200429 /* some data are still present, give up */
430 return 0;
431
432 shut:
433 /* we're certain the connection was shut down */
434 fdtab[conn->handle.fd].linger_risk = 0;
Willy Tarreaud85c4852015-03-13 00:40:28 +0100435 conn->flags |= CO_FL_SOCK_RD_SH;
436 return 1;
437}
438
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100439/*
440 * Get data length from tlv
441 */
442static int get_tlv_length(const struct tlv *src)
443{
444 return (src->length_hi << 8) | src->length_lo;
445}
446
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200447/* This handshake handler waits a PROXY protocol header at the beginning of the
448 * raw data stream. The header looks like this :
449 *
450 * "PROXY" <SP> PROTO <SP> SRC3 <SP> DST3 <SP> SRC4 <SP> <DST4> "\r\n"
451 *
452 * There must be exactly one space between each field. Fields are :
453 * - PROTO : layer 4 protocol, which must be "TCP4" or "TCP6".
454 * - SRC3 : layer 3 (eg: IP) source address in standard text form
455 * - DST3 : layer 3 (eg: IP) destination address in standard text form
456 * - SRC4 : layer 4 (eg: TCP port) source address in standard text form
457 * - DST4 : layer 4 (eg: TCP port) destination address in standard text form
458 *
459 * This line MUST be at the beginning of the buffer and MUST NOT wrap.
460 *
461 * The header line is small and in all cases smaller than the smallest normal
462 * TCP MSS. So it MUST always be delivered as one segment, which ensures we
463 * can safely use MSG_PEEK and avoid buffering.
464 *
465 * Once the data is fetched, the values are set in the connection's address
466 * fields, and data are removed from the socket's buffer. The function returns
467 * zero if it needs to wait for more data or if it fails, or 1 if it completed
468 * and removed itself.
469 */
470int conn_recv_proxy(struct connection *conn, int flag)
471{
472 char *line, *end;
Willy Tarreau77992672014-06-14 11:06:17 +0200473 struct proxy_hdr_v2 *hdr_v2;
474 const char v2sig[] = PP2_SIGNATURE;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100475 int tlv_length = 0;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200476 int tlv_offset = 0;
Willy Tarreaub406b872018-08-22 05:20:32 +0200477 int ret;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200478
479 /* we might have been called just after an asynchronous shutr */
480 if (conn->flags & CO_FL_SOCK_RD_SH)
481 goto fail;
482
Willy Tarreau3c728722014-01-23 13:50:42 +0100483 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +0200484 goto fail;
485
Willy Tarreau585744b2017-08-24 14:31:19 +0200486 if (!fd_recv_ready(conn->handle.fd))
Willy Tarreaufd803bb2014-01-20 15:13:07 +0100487 return 0;
488
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200489 do {
Willy Tarreaub406b872018-08-22 05:20:32 +0200490 ret = recv(conn->handle.fd, trash.area, trash.size, MSG_PEEK);
491 if (ret < 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200492 if (errno == EINTR)
493 continue;
494 if (errno == EAGAIN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200495 fd_cant_recv(conn->handle.fd);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200496 return 0;
497 }
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100498 goto recv_abort;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200499 }
Willy Tarreaub406b872018-08-22 05:20:32 +0200500 trash.data = ret;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200501 } while (0);
502
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200503 if (!trash.data) {
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100504 /* client shutdown */
505 conn->err_code = CO_ER_PRX_EMPTY;
506 goto fail;
507 }
508
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200509 if (trash.data < 6)
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200510 goto missing;
511
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200512 line = trash.area;
513 end = trash.area + trash.data;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200514
515 /* Decode a possible proxy request, fail early if it does not match */
Willy Tarreau77992672014-06-14 11:06:17 +0200516 if (strncmp(line, "PROXY ", 6) != 0)
517 goto not_v1;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200518
519 line += 6;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200520 if (trash.data < 9) /* shortest possible line */
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200521 goto missing;
522
David CARLIER42ff05e2016-03-24 09:22:36 +0000523 if (memcmp(line, "TCP4 ", 5) == 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200524 u32 src3, dst3, sport, dport;
525
526 line += 5;
527
528 src3 = inetaddr_host_lim_ret(line, end, &line);
529 if (line == end)
530 goto missing;
531 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100532 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200533
534 dst3 = inetaddr_host_lim_ret(line, end, &line);
535 if (line == end)
536 goto missing;
537 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100538 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200539
540 sport = read_uint((const char **)&line, end);
541 if (line == end)
542 goto missing;
543 if (*line++ != ' ')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100544 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200545
546 dport = read_uint((const char **)&line, end);
547 if (line > end - 2)
548 goto missing;
549 if (*line++ != '\r')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100550 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200551 if (*line++ != '\n')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100552 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200553
554 /* update the session's addresses and mark them set */
555 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
556 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = htonl(src3);
557 ((struct sockaddr_in *)&conn->addr.from)->sin_port = htons(sport);
558
559 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
560 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = htonl(dst3);
561 ((struct sockaddr_in *)&conn->addr.to)->sin_port = htons(dport);
562 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
563 }
David CARLIER42ff05e2016-03-24 09:22:36 +0000564 else if (memcmp(line, "TCP6 ", 5) == 0) {
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200565 u32 sport, dport;
566 char *src_s;
567 char *dst_s, *sport_s, *dport_s;
568 struct in6_addr src3, dst3;
569
570 line += 5;
571
572 src_s = line;
573 dst_s = sport_s = dport_s = NULL;
574 while (1) {
575 if (line > end - 2) {
576 goto missing;
577 }
578 else if (*line == '\r') {
579 *line = 0;
580 line++;
581 if (*line++ != '\n')
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100582 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200583 break;
584 }
585
586 if (*line == ' ') {
587 *line = 0;
588 if (!dst_s)
589 dst_s = line + 1;
590 else if (!sport_s)
591 sport_s = line + 1;
592 else if (!dport_s)
593 dport_s = line + 1;
594 }
595 line++;
596 }
Olivier Houchard53216e72018-10-10 15:46:36 +0200597 __conn_xprt_stop_recv(conn);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200598
599 if (!dst_s || !sport_s || !dport_s)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100600 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200601
602 sport = read_uint((const char **)&sport_s,dport_s - 1);
603 if (*sport_s != 0)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100604 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200605
606 dport = read_uint((const char **)&dport_s,line - 2);
607 if (*dport_s != 0)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100608 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200609
610 if (inet_pton(AF_INET6, src_s, (void *)&src3) != 1)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100611 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200612
613 if (inet_pton(AF_INET6, dst_s, (void *)&dst3) != 1)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100614 goto bad_header;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200615
616 /* update the session's addresses and mark them set */
617 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
618 memcpy(&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr, &src3, sizeof(struct in6_addr));
619 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = htons(sport);
620
621 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
622 memcpy(&((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr, &dst3, sizeof(struct in6_addr));
623 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = htons(dport);
624 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
625 }
Willy Tarreau4c20d292014-06-14 11:41:36 +0200626 else if (memcmp(line, "UNKNOWN\r\n", 9) == 0) {
627 /* This can be a UNIX socket forwarded by an haproxy upstream */
628 line += 9;
629 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200630 else {
Willy Tarreau4c20d292014-06-14 11:41:36 +0200631 /* The protocol does not match something known (TCP4/TCP6/UNKNOWN) */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100632 conn->err_code = CO_ER_PRX_BAD_PROTO;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200633 goto fail;
634 }
635
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200636 trash.data = line - trash.area;
Willy Tarreau77992672014-06-14 11:06:17 +0200637 goto eat_header;
638
639 not_v1:
640 /* try PPv2 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200641 if (trash.data < PP2_HEADER_LEN)
Willy Tarreau77992672014-06-14 11:06:17 +0200642 goto missing;
643
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200644 hdr_v2 = (struct proxy_hdr_v2 *) trash.area;
Willy Tarreau77992672014-06-14 11:06:17 +0200645
646 if (memcmp(hdr_v2->sig, v2sig, PP2_SIGNATURE_LEN) != 0 ||
647 (hdr_v2->ver_cmd & PP2_VERSION_MASK) != PP2_VERSION) {
648 conn->err_code = CO_ER_PRX_NOT_HDR;
649 goto fail;
650 }
651
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200652 if (trash.data < PP2_HEADER_LEN + ntohs(hdr_v2->len))
Willy Tarreau77992672014-06-14 11:06:17 +0200653 goto missing;
654
655 switch (hdr_v2->ver_cmd & PP2_CMD_MASK) {
656 case 0x01: /* PROXY command */
657 switch (hdr_v2->fam) {
658 case 0x11: /* TCPv4 */
KOVACS Krisztianefd3aa92014-11-19 10:53:20 +0100659 if (ntohs(hdr_v2->len) < PP2_ADDR_LEN_INET)
660 goto bad_header;
661
Willy Tarreau77992672014-06-14 11:06:17 +0200662 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
663 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = hdr_v2->addr.ip4.src_addr;
664 ((struct sockaddr_in *)&conn->addr.from)->sin_port = hdr_v2->addr.ip4.src_port;
665 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
666 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = hdr_v2->addr.ip4.dst_addr;
667 ((struct sockaddr_in *)&conn->addr.to)->sin_port = hdr_v2->addr.ip4.dst_port;
668 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200669 tlv_offset = PP2_HEADER_LEN + PP2_ADDR_LEN_INET;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100670 tlv_length = ntohs(hdr_v2->len) - PP2_ADDR_LEN_INET;
Willy Tarreau77992672014-06-14 11:06:17 +0200671 break;
672 case 0x21: /* TCPv6 */
KOVACS Krisztianefd3aa92014-11-19 10:53:20 +0100673 if (ntohs(hdr_v2->len) < PP2_ADDR_LEN_INET6)
674 goto bad_header;
675
Willy Tarreau77992672014-06-14 11:06:17 +0200676 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
677 memcpy(&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr, hdr_v2->addr.ip6.src_addr, 16);
678 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = hdr_v2->addr.ip6.src_port;
679 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
680 memcpy(&((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr, hdr_v2->addr.ip6.dst_addr, 16);
681 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = hdr_v2->addr.ip6.dst_port;
682 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
KOVACS Krisztian7209c202015-07-03 14:09:10 +0200683 tlv_offset = PP2_HEADER_LEN + PP2_ADDR_LEN_INET6;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100684 tlv_length = ntohs(hdr_v2->len) - PP2_ADDR_LEN_INET6;
Willy Tarreau77992672014-06-14 11:06:17 +0200685 break;
686 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100687
688 /* TLV parsing */
689 if (tlv_length > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200690 while (tlv_offset + TLV_HEADER_SIZE <= trash.data) {
691 const struct tlv *tlv_packet = (struct tlv *) &trash.area[tlv_offset];
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100692 const int tlv_len = get_tlv_length(tlv_packet);
693 tlv_offset += tlv_len + TLV_HEADER_SIZE;
694
695 switch (tlv_packet->type) {
Emmanuel Hocdet115df3e2018-02-05 16:23:23 +0100696 case PP2_TYPE_CRC32C: {
697 void *tlv_crc32c_p = (void *)tlv_packet->value;
698 uint32_t n_crc32c = ntohl(read_u32(tlv_crc32c_p));
699 write_u32(tlv_crc32c_p, 0);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200700 if (hash_crc32c(trash.area, PP2_HEADER_LEN + ntohs(hdr_v2->len)) != n_crc32c)
Emmanuel Hocdet115df3e2018-02-05 16:23:23 +0100701 goto bad_header;
702 break;
703 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +0100704#ifdef CONFIG_HAP_NS
705 case PP2_TYPE_NETNS: {
706 const struct netns_entry *ns;
707 ns = netns_store_lookup((char*)tlv_packet->value, tlv_len);
708 if (ns)
709 conn->proxy_netns = ns;
710 break;
711 }
712#endif
713 default:
714 break;
715 }
716 }
717 }
718
Willy Tarreau77992672014-06-14 11:06:17 +0200719 /* unsupported protocol, keep local connection address */
720 break;
721 case 0x00: /* LOCAL command */
722 /* keep local connection address for LOCAL */
723 break;
724 default:
725 goto bad_header; /* not a supported command */
726 }
727
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200728 trash.data = PP2_HEADER_LEN + ntohs(hdr_v2->len);
Willy Tarreau77992672014-06-14 11:06:17 +0200729 goto eat_header;
730
731 eat_header:
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200732 /* remove the PROXY line from the request. For this we re-read the
733 * exact line at once. If we don't get the exact same result, we
734 * fail.
735 */
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200736 do {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 int len2 = recv(conn->handle.fd, trash.area, trash.data, 0);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200738 if (len2 < 0 && errno == EINTR)
739 continue;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200740 if (len2 != trash.data)
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100741 goto recv_abort;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200742 } while (0);
743
744 conn->flags &= ~flag;
Emeric Brun4f603012017-01-05 15:11:44 +0100745 conn->flags |= CO_FL_RCVD_PROXY;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200746 return 1;
747
748 missing:
749 /* Missing data. Since we're using MSG_PEEK, we can only poll again if
750 * we have not read anything. Otherwise we need to fail because we won't
751 * be able to poll anymore.
752 */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100753 conn->err_code = CO_ER_PRX_TRUNCATED;
754 goto fail;
755
756 bad_header:
757 /* This is not a valid proxy protocol header */
758 conn->err_code = CO_ER_PRX_BAD_HDR;
759 goto fail;
760
761 recv_abort:
762 conn->err_code = CO_ER_PRX_ABORT;
Willy Tarreau26f4a042013-12-04 23:44:10 +0100763 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100764 goto fail;
765
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200766 fail:
Willy Tarreaud486ef52012-12-10 17:03:52 +0100767 __conn_sock_stop_both(conn);
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200768 conn->flags |= CO_FL_ERROR;
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200769 return 0;
770}
771
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100772/* This handshake handler waits a NetScaler Client IP insertion header
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000773 * at the beginning of the raw data stream. The header format is
774 * described in doc/netscaler-client-ip-insertion-protocol.txt
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100775 *
776 * This line MUST be at the beginning of the buffer and MUST NOT be
777 * fragmented.
778 *
779 * The header line is small and in all cases smaller than the smallest normal
780 * TCP MSS. So it MUST always be delivered as one segment, which ensures we
781 * can safely use MSG_PEEK and avoid buffering.
782 *
783 * Once the data is fetched, the values are set in the connection's address
784 * fields, and data are removed from the socket's buffer. The function returns
785 * zero if it needs to wait for more data or if it fails, or 1 if it completed
786 * and removed itself.
787 */
788int conn_recv_netscaler_cip(struct connection *conn, int flag)
789{
790 char *line;
Bertrand Jacquin7d668f92017-12-13 01:23:39 +0000791 uint32_t hdr_len;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100792 uint8_t ip_v;
Willy Tarreaub406b872018-08-22 05:20:32 +0200793 int ret;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100794
795 /* we might have been called just after an asynchronous shutr */
796 if (conn->flags & CO_FL_SOCK_RD_SH)
797 goto fail;
798
799 if (!conn_ctrl_ready(conn))
800 goto fail;
801
Willy Tarreau585744b2017-08-24 14:31:19 +0200802 if (!fd_recv_ready(conn->handle.fd))
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100803 return 0;
804
805 do {
Willy Tarreaub406b872018-08-22 05:20:32 +0200806 ret = recv(conn->handle.fd, trash.area, trash.size, MSG_PEEK);
807 if (ret < 0) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100808 if (errno == EINTR)
809 continue;
810 if (errno == EAGAIN) {
Willy Tarreau585744b2017-08-24 14:31:19 +0200811 fd_cant_recv(conn->handle.fd);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100812 return 0;
813 }
814 goto recv_abort;
815 }
Willy Tarreaub406b872018-08-22 05:20:32 +0200816 trash.data = ret;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100817 } while (0);
818
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200819 if (!trash.data) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100820 /* client shutdown */
821 conn->err_code = CO_ER_CIP_EMPTY;
822 goto fail;
823 }
824
825 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000826 * CIP magic, header length or
827 * CIP magic, CIP length, CIP type, header length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200828 if (trash.data < 12)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100829 goto missing;
830
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200831 line = trash.area;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100832
833 /* Decode a possible NetScaler Client IP request, fail early if
834 * it does not match */
Willy Tarreau55e0da62018-09-20 11:26:52 +0200835 if (ntohl(*(uint32_t *)line) != __objt_listener(conn->target)->bind_conf->ns_cip_magic)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100836 goto bad_magic;
837
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000838 /* Legacy CIP protocol */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200839 if ((trash.area[8] & 0xD0) == 0x40) {
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000840 hdr_len = ntohl(*(uint32_t *)(line+4));
841 line += 8;
842 }
843 /* Standard CIP protocol */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200844 else if (trash.area[8] == 0x00) {
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000845 hdr_len = ntohs(*(uint32_t *)(line+10));
846 line += 12;
847 }
848 /* Unknown CIP protocol */
849 else {
850 conn->err_code = CO_ER_CIP_BAD_PROTO;
851 goto fail;
852 }
853
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100854 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin72fa1ec2017-12-12 01:17:23 +0000855 * a minimal IP header */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200856 if (trash.data < 20)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100857 goto missing;
858
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100859 /* Get IP version from the first four bits */
860 ip_v = (*line & 0xf0) >> 4;
861
862 if (ip_v == 4) {
863 struct ip *hdr_ip4;
David Carlier3015a2e2016-07-04 22:51:33 +0100864 struct my_tcphdr *hdr_tcp;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100865
866 hdr_ip4 = (struct ip *)line;
867
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200868 if (trash.data < 40 || trash.data < hdr_len) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100869 /* Fail if buffer length is not large enough to contain
Bertrand Jacquin67de5a22017-12-13 01:15:05 +0000870 * IPv4 header, TCP header */
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100871 goto missing;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000872 }
873 else if (hdr_ip4->ip_p != IPPROTO_TCP) {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100874 /* The protocol does not include a TCP header */
875 conn->err_code = CO_ER_CIP_BAD_PROTO;
876 goto fail;
Bertrand Jacquinb3875912017-12-13 00:58:51 +0000877 }
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100878
David Carlier3015a2e2016-07-04 22:51:33 +0100879 hdr_tcp = (struct my_tcphdr *)(line + (hdr_ip4->ip_hl * 4));
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100880
881 /* update the session's addresses and mark them set */
882 ((struct sockaddr_in *)&conn->addr.from)->sin_family = AF_INET;
883 ((struct sockaddr_in *)&conn->addr.from)->sin_addr.s_addr = hdr_ip4->ip_src.s_addr;
884 ((struct sockaddr_in *)&conn->addr.from)->sin_port = hdr_tcp->source;
885
886 ((struct sockaddr_in *)&conn->addr.to)->sin_family = AF_INET;
887 ((struct sockaddr_in *)&conn->addr.to)->sin_addr.s_addr = hdr_ip4->ip_dst.s_addr;
888 ((struct sockaddr_in *)&conn->addr.to)->sin_port = hdr_tcp->dest;
889
890 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
891 }
892 else if (ip_v == 6) {
893 struct ip6_hdr *hdr_ip6;
David Carlier3015a2e2016-07-04 22:51:33 +0100894 struct my_tcphdr *hdr_tcp;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100895
896 hdr_ip6 = (struct ip6_hdr *)line;
897
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200898 if (trash.data < 60 || 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 * IPv6 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_ip6->ip6_nxt != 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 + sizeof(struct ip6_hdr));
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100910
911 /* update the session's addresses and mark them set */
912 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_family = AF_INET6;
913 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr = hdr_ip6->ip6_src;
914 ((struct sockaddr_in6 *)&conn->addr.from)->sin6_port = hdr_tcp->source;
915
916 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_family = AF_INET6;
917 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_addr = hdr_ip6->ip6_dst;
918 ((struct sockaddr_in6 *)&conn->addr.to)->sin6_port = hdr_tcp->dest;
919
920 conn->flags |= CO_FL_ADDR_FROM_SET | CO_FL_ADDR_TO_SET;
921 }
922 else {
923 /* The protocol does not match something known (IPv4/IPv6) */
924 conn->err_code = CO_ER_CIP_BAD_PROTO;
925 goto fail;
926 }
927
Bertrand Jacquin7d668f92017-12-13 01:23:39 +0000928 line += hdr_len;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200929 trash.data = line - trash.area;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100930
931 /* remove the NetScaler Client IP header from the request. For this
932 * we re-read the exact line at once. If we don't get the exact same
933 * result, we fail.
934 */
935 do {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200936 int len2 = recv(conn->handle.fd, trash.area, trash.data, 0);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100937 if (len2 < 0 && errno == EINTR)
938 continue;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200939 if (len2 != trash.data)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100940 goto recv_abort;
941 } while (0);
942
943 conn->flags &= ~flag;
944 return 1;
945
946 missing:
947 /* Missing data. Since we're using MSG_PEEK, we can only poll again if
948 * we have not read anything. Otherwise we need to fail because we won't
949 * be able to poll anymore.
950 */
951 conn->err_code = CO_ER_CIP_TRUNCATED;
952 goto fail;
953
954 bad_magic:
955 conn->err_code = CO_ER_CIP_BAD_MAGIC;
956 goto fail;
957
958 recv_abort:
959 conn->err_code = CO_ER_CIP_ABORT;
960 conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
961 goto fail;
962
963 fail:
964 __conn_sock_stop_both(conn);
965 conn->flags |= CO_FL_ERROR;
966 return 0;
967}
968
Ilya Shipitsinca56fce2018-09-15 00:50:05 +0500969/* Note: <remote> is explicitly allowed to be NULL */
David Safb76832014-05-08 23:42:08 -0400970int make_proxy_line(char *buf, int buf_len, struct server *srv, struct connection *remote)
971{
972 int ret = 0;
973
974 if (srv && (srv->pp_opts & SRV_PP_V2)) {
975 ret = make_proxy_line_v2(buf, buf_len, srv, remote);
976 }
977 else {
978 if (remote)
979 ret = make_proxy_line_v1(buf, buf_len, &remote->addr.from, &remote->addr.to);
980 else
981 ret = make_proxy_line_v1(buf, buf_len, NULL, NULL);
982 }
983
984 return ret;
985}
986
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200987/* Makes a PROXY protocol line from the two addresses. The output is sent to
988 * buffer <buf> for a maximum size of <buf_len> (including the trailing zero).
989 * It returns the number of bytes composing this line (including the trailing
990 * LF), or zero in case of failure (eg: not enough space). It supports TCP4,
Willy Tarreau2e1401a2013-10-01 11:41:55 +0200991 * TCP6 and "UNKNOWN" formats. If any of <src> or <dst> is null, UNKNOWN is
992 * emitted as well.
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200993 */
David Safb76832014-05-08 23:42:08 -0400994int make_proxy_line_v1(char *buf, int buf_len, struct sockaddr_storage *src, struct sockaddr_storage *dst)
Willy Tarreaue1e4a612012-10-05 00:10:55 +0200995{
996 int ret = 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +0200997 char * protocol;
998 char src_str[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
999 char dst_str[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
1000 in_port_t src_port;
1001 in_port_t dst_port;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001002
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001003 if ( !src
1004 || !dst
1005 || (src->ss_family != AF_INET && src->ss_family != AF_INET6)
1006 || (dst->ss_family != AF_INET && dst->ss_family != AF_INET6)) {
1007 /* unknown family combination */
1008 ret = snprintf(buf, buf_len, "PROXY UNKNOWN\r\n");
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001009 if (ret >= buf_len)
1010 return 0;
1011
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001012 return ret;
1013 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001014
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001015 /* IPv4 for both src and dst */
1016 if (src->ss_family == AF_INET && dst->ss_family == AF_INET) {
1017 protocol = "TCP4";
1018 if (!inet_ntop(AF_INET, &((struct sockaddr_in *)src)->sin_addr, src_str, sizeof(src_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001019 return 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001020 src_port = ((struct sockaddr_in *)src)->sin_port;
1021 if (!inet_ntop(AF_INET, &((struct sockaddr_in *)dst)->sin_addr, dst_str, sizeof(dst_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001022 return 0;
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001023 dst_port = ((struct sockaddr_in *)dst)->sin_port;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001024 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001025 /* IPv6 for at least one of src and dst */
1026 else {
1027 struct in6_addr tmp;
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001028
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001029 protocol = "TCP6";
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001030
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001031 if (src->ss_family == AF_INET) {
1032 /* Convert src to IPv6 */
1033 v4tov6(&tmp, &((struct sockaddr_in *)src)->sin_addr);
1034 src_port = ((struct sockaddr_in *)src)->sin_port;
1035 }
1036 else {
1037 tmp = ((struct sockaddr_in6 *)src)->sin6_addr;
1038 src_port = ((struct sockaddr_in6 *)src)->sin6_port;
1039 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001040
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001041 if (!inet_ntop(AF_INET6, &tmp, src_str, sizeof(src_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001042 return 0;
1043
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001044 if (dst->ss_family == AF_INET) {
1045 /* Convert dst to IPv6 */
1046 v4tov6(&tmp, &((struct sockaddr_in *)dst)->sin_addr);
1047 dst_port = ((struct sockaddr_in *)dst)->sin_port;
1048 }
1049 else {
1050 tmp = ((struct sockaddr_in6 *)dst)->sin6_addr;
1051 dst_port = ((struct sockaddr_in6 *)dst)->sin6_port;
1052 }
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001053
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001054 if (!inet_ntop(AF_INET6, &tmp, dst_str, sizeof(dst_str)))
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001055 return 0;
1056 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001057
1058 ret = snprintf(buf, buf_len, "PROXY %s %s %s %u %u\r\n", protocol, src_str, dst_str, ntohs(src_port), ntohs(dst_port));
1059 if (ret >= buf_len)
1060 return 0;
1061
Willy Tarreaue1e4a612012-10-05 00:10:55 +02001062 return ret;
1063}
David Safb76832014-05-08 23:42:08 -04001064
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001065static int make_tlv(char *dest, int dest_len, char type, uint16_t length, const char *value)
David Safb76832014-05-08 23:42:08 -04001066{
1067 struct tlv *tlv;
1068
1069 if (!dest || (length + sizeof(*tlv) > dest_len))
1070 return 0;
1071
1072 tlv = (struct tlv *)dest;
1073
1074 tlv->type = type;
1075 tlv->length_hi = length >> 8;
1076 tlv->length_lo = length & 0x00ff;
1077 memcpy(tlv->value, value, length);
1078 return length + sizeof(*tlv);
1079}
David Safb76832014-05-08 23:42:08 -04001080
Ilya Shipitsinca56fce2018-09-15 00:50:05 +05001081/* Note: <remote> is explicitly allowed to be NULL */
David Safb76832014-05-08 23:42:08 -04001082int make_proxy_line_v2(char *buf, int buf_len, struct server *srv, struct connection *remote)
1083{
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001084 const char pp2_signature[] = PP2_SIGNATURE;
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001085 void *tlv_crc32c_p = NULL;
David Safb76832014-05-08 23:42:08 -04001086 int ret = 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001087 struct proxy_hdr_v2 *hdr = (struct proxy_hdr_v2 *)buf;
Vincent Bernat6e615892016-05-18 16:17:44 +02001088 struct sockaddr_storage null_addr = { .ss_family = 0 };
David Safb76832014-05-08 23:42:08 -04001089 struct sockaddr_storage *src = &null_addr;
1090 struct sockaddr_storage *dst = &null_addr;
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001091 const char *value;
1092 int value_len;
David Safb76832014-05-08 23:42:08 -04001093
1094 if (buf_len < PP2_HEADER_LEN)
1095 return 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001096 memcpy(hdr->sig, pp2_signature, PP2_SIGNATURE_LEN);
David Safb76832014-05-08 23:42:08 -04001097
1098 if (remote) {
1099 src = &remote->addr.from;
1100 dst = &remote->addr.to;
1101 }
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001102
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001103 /* At least one of src or dst is not of AF_INET or AF_INET6 */
1104 if ( !src
1105 || !dst
1106 || (src->ss_family != AF_INET && src->ss_family != AF_INET6)
1107 || (dst->ss_family != AF_INET && dst->ss_family != AF_INET6)) {
David Safb76832014-05-08 23:42:08 -04001108 if (buf_len < PP2_HDR_LEN_UNSPEC)
1109 return 0;
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001110 hdr->ver_cmd = PP2_VERSION | PP2_CMD_LOCAL;
1111 hdr->fam = PP2_FAM_UNSPEC | PP2_TRANS_UNSPEC;
David Safb76832014-05-08 23:42:08 -04001112 ret = PP2_HDR_LEN_UNSPEC;
1113 }
Tim Duesterhus7fec0212018-07-27 18:46:13 +02001114 else {
1115 /* IPv4 for both src and dst */
1116 if (src->ss_family == AF_INET && dst->ss_family == AF_INET) {
1117 if (buf_len < PP2_HDR_LEN_INET)
1118 return 0;
1119 hdr->ver_cmd = PP2_VERSION | PP2_CMD_PROXY;
1120 hdr->fam = PP2_FAM_INET | PP2_TRANS_STREAM;
1121 hdr->addr.ip4.src_addr = ((struct sockaddr_in *)src)->sin_addr.s_addr;
1122 hdr->addr.ip4.src_port = ((struct sockaddr_in *)src)->sin_port;
1123 hdr->addr.ip4.dst_addr = ((struct sockaddr_in *)dst)->sin_addr.s_addr;
1124 hdr->addr.ip4.dst_port = ((struct sockaddr_in *)dst)->sin_port;
1125 ret = PP2_HDR_LEN_INET;
1126 }
1127 /* IPv6 for at least one of src and dst */
1128 else {
1129 struct in6_addr tmp;
1130
1131 if (buf_len < PP2_HDR_LEN_INET6)
1132 return 0;
1133 hdr->ver_cmd = PP2_VERSION | PP2_CMD_PROXY;
1134 hdr->fam = PP2_FAM_INET6 | PP2_TRANS_STREAM;
1135 if (src->ss_family == AF_INET) {
1136 v4tov6(&tmp, &((struct sockaddr_in *)src)->sin_addr);
1137 memcpy(hdr->addr.ip6.src_addr, &tmp, 16);
1138 hdr->addr.ip6.src_port = ((struct sockaddr_in *)src)->sin_port;
1139 }
1140 else {
1141 memcpy(hdr->addr.ip6.src_addr, &((struct sockaddr_in6 *)src)->sin6_addr, 16);
1142 hdr->addr.ip6.src_port = ((struct sockaddr_in6 *)src)->sin6_port;
1143 }
1144 if (dst->ss_family == AF_INET) {
1145 v4tov6(&tmp, &((struct sockaddr_in *)dst)->sin_addr);
1146 memcpy(hdr->addr.ip6.dst_addr, &tmp, 16);
1147 hdr->addr.ip6.src_port = ((struct sockaddr_in *)src)->sin_port;
1148 }
1149 else {
1150 memcpy(hdr->addr.ip6.dst_addr, &((struct sockaddr_in6 *)dst)->sin6_addr, 16);
1151 hdr->addr.ip6.dst_port = ((struct sockaddr_in6 *)dst)->sin6_port;
1152 }
1153
1154 ret = PP2_HDR_LEN_INET6;
1155 }
1156 }
David Safb76832014-05-08 23:42:08 -04001157
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001158 if (srv->pp_opts & SRV_PP_V2_CRC32C) {
1159 uint32_t zero_crc32c = 0;
1160 if ((buf_len - ret) < sizeof(struct tlv))
1161 return 0;
1162 tlv_crc32c_p = (void *)((struct tlv *)&buf[ret])->value;
1163 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_CRC32C, sizeof(zero_crc32c), (const char *)&zero_crc32c);
1164 }
1165
Ilya Shipitsinca56fce2018-09-15 00:50:05 +05001166 if (remote && conn_get_alpn(remote, &value, &value_len)) {
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001167 if ((buf_len - ret) < sizeof(struct tlv))
1168 return 0;
Emmanuel Hocdet571c7ac2017-10-31 18:24:05 +01001169 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_ALPN, value_len, value);
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001170 }
1171
David Safb76832014-05-08 23:42:08 -04001172#ifdef USE_OPENSSL
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01001173 if (srv->pp_opts & SRV_PP_V2_AUTHORITY) {
1174 value = ssl_sock_get_sni(remote);
1175 if (value) {
1176 if ((buf_len - ret) < sizeof(struct tlv))
1177 return 0;
1178 ret += make_tlv(&buf[ret], (buf_len - ret), PP2_TYPE_AUTHORITY, strlen(value), value);
1179 }
1180 }
1181
David Safb76832014-05-08 23:42:08 -04001182 if (srv->pp_opts & SRV_PP_V2_SSL) {
Emmanuel Hocdet404d9782017-10-24 10:55:14 +02001183 struct tlv_ssl *tlv;
1184 int ssl_tlv_len = 0;
David Safb76832014-05-08 23:42:08 -04001185 if ((buf_len - ret) < sizeof(struct tlv_ssl))
1186 return 0;
1187 tlv = (struct tlv_ssl *)&buf[ret];
1188 memset(tlv, 0, sizeof(struct tlv_ssl));
1189 ssl_tlv_len += sizeof(struct tlv_ssl);
1190 tlv->tlv.type = PP2_TYPE_SSL;
1191 if (ssl_sock_is_ssl(remote)) {
1192 tlv->client |= PP2_CLIENT_SSL;
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02001193 value = ssl_sock_get_proto_version(remote);
David Safb76832014-05-08 23:42:08 -04001194 if (value) {
Emmanuel Hocdet8c0c34b2018-02-28 12:02:14 +01001195 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 -04001196 }
Dave McCowan328fb582014-07-30 10:39:13 -04001197 if (ssl_sock_get_cert_used_sess(remote)) {
1198 tlv->client |= PP2_CLIENT_CERT_SESS;
David Safb76832014-05-08 23:42:08 -04001199 tlv->verify = htonl(ssl_sock_get_verify_result(remote));
Dave McCowan328fb582014-07-30 10:39:13 -04001200 if (ssl_sock_get_cert_used_conn(remote))
1201 tlv->client |= PP2_CLIENT_CERT_CONN;
David Safb76832014-05-08 23:42:08 -04001202 }
1203 if (srv->pp_opts & SRV_PP_V2_SSL_CN) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001204 struct buffer *cn_trash = get_trash_chunk();
Willy Tarreau3b9a0c92014-07-19 06:37:33 +02001205 if (ssl_sock_get_remote_common_name(remote, cn_trash) > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001206 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_CN,
1207 cn_trash->data,
1208 cn_trash->area);
David Safb76832014-05-08 23:42:08 -04001209 }
1210 }
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001211 if (srv->pp_opts & SRV_PP_V2_SSL_KEY_ALG) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001212 struct buffer *pkey_trash = get_trash_chunk();
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001213 if (ssl_sock_get_pkey_algo(remote, pkey_trash) > 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001214 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_KEY_ALG,
1215 pkey_trash->data,
1216 pkey_trash->area);
Emmanuel Hocdetfa8d0f12018-02-01 15:53:52 +01001217 }
1218 }
1219 if (srv->pp_opts & SRV_PP_V2_SSL_SIG_ALG) {
1220 value = ssl_sock_get_cert_sig(remote);
1221 if (value) {
1222 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_SIG_ALG, strlen(value), value);
1223 }
1224 }
1225 if (srv->pp_opts & SRV_PP_V2_SSL_CIPHER) {
1226 value = ssl_sock_get_cipher_name(remote);
1227 if (value) {
1228 ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_CIPHER, strlen(value), value);
1229 }
1230 }
David Safb76832014-05-08 23:42:08 -04001231 }
1232 tlv->tlv.length_hi = (uint16_t)(ssl_tlv_len - sizeof(struct tlv)) >> 8;
1233 tlv->tlv.length_lo = (uint16_t)(ssl_tlv_len - sizeof(struct tlv)) & 0x00ff;
1234 ret += ssl_tlv_len;
1235 }
1236#endif
1237
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01001238#ifdef CONFIG_HAP_NS
1239 if (remote && (remote->proxy_netns)) {
1240 if ((buf_len - ret) < sizeof(struct tlv))
1241 return 0;
Emmanuel Hocdet571c7ac2017-10-31 18:24:05 +01001242 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 +01001243 }
1244#endif
1245
Willy Tarreau8fccfa22014-06-14 08:28:06 +02001246 hdr->len = htons((uint16_t)(ret - PP2_HEADER_LEN));
David Safb76832014-05-08 23:42:08 -04001247
Emmanuel Hocdet4399c752018-02-05 15:26:43 +01001248 if (tlv_crc32c_p) {
1249 write_u32(tlv_crc32c_p, htonl(hash_crc32c(buf, ret)));
1250 }
1251
David Safb76832014-05-08 23:42:08 -04001252 return ret;
1253}
Emeric Brun4f603012017-01-05 15:11:44 +01001254
Willy Tarreau60ca10a2017-08-18 15:26:54 +02001255/* return the major HTTP version as 1 or 2 depending on how the request arrived
1256 * before being processed.
1257 */
1258static int
1259smp_fetch_fc_http_major(const struct arg *args, struct sample *smp, const char *kw, void *private)
1260{
Jérôme Magnin86577422018-12-07 09:03:11 +01001261 struct connection *conn = (kw[0] != 'b') ? objt_conn(smp->sess->origin) :
1262 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreau60ca10a2017-08-18 15:26:54 +02001263
1264 smp->data.type = SMP_T_SINT;
1265 smp->data.u.sint = (conn && strcmp(conn_get_mux_name(conn), "H2") == 0) ? 2 : 1;
1266 return 1;
1267}
1268
Emeric Brun4f603012017-01-05 15:11:44 +01001269/* fetch if the received connection used a PROXY protocol header */
1270int smp_fetch_fc_rcvd_proxy(const struct arg *args, struct sample *smp, const char *kw, void *private)
1271{
1272 struct connection *conn;
1273
1274 conn = objt_conn(smp->sess->origin);
1275 if (!conn)
1276 return 0;
1277
1278 if (!(conn->flags & CO_FL_CONNECTED)) {
1279 smp->flags |= SMP_F_MAY_CHANGE;
1280 return 0;
1281 }
1282
1283 smp->flags = 0;
1284 smp->data.type = SMP_T_BOOL;
1285 smp->data.u.sint = (conn->flags & CO_FL_RCVD_PROXY) ? 1 : 0;
1286
1287 return 1;
1288}
1289
1290/* Note: must not be declared <const> as its list will be overwritten.
1291 * Note: fetches that may return multiple types must be declared as the lowest
1292 * common denominator, the type that can be casted into all other ones. For
1293 * instance v4/v6 must be declared v4.
1294 */
1295static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
Willy Tarreau60ca10a2017-08-18 15:26:54 +02001296 { "fc_http_major", smp_fetch_fc_http_major, 0, NULL, SMP_T_SINT, SMP_USE_L4CLI },
Jérôme Magnin86577422018-12-07 09:03:11 +01001297 { "bc_http_major", smp_fetch_fc_http_major, 0, NULL, SMP_T_SINT, SMP_USE_L4SRV },
Emeric Brun4f603012017-01-05 15:11:44 +01001298 { "fc_rcvd_proxy", smp_fetch_fc_rcvd_proxy, 0, NULL, SMP_T_BOOL, SMP_USE_L4CLI },
1299 { /* END */ },
1300}};
1301
Willy Tarreau0108d902018-11-25 19:14:37 +01001302INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);