blob: 1038a369e674edf3f1c01068f0b3ec41558979ed [file] [log] [blame]
Willy Tarreaub1ec8c42015-04-03 13:53:24 +02001/*
Willy Tarreau9903f0e2015-04-04 18:50:31 +02002 * Session management functions.
Willy Tarreaub1ec8c42015-04-03 13:53:24 +02003 *
Willy Tarreau9903f0e2015-04-04 18:50:31 +02004 * Copyright 2000-2015 Willy Tarreau <w@1wt.eu>
Willy Tarreaub1ec8c42015-04-03 13:53:24 +02005 *
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 Tarreau4c7e4b72020-05-27 12:58:42 +020013#include <haproxy/api.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020014#include <haproxy/connection.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020015#include <haproxy/global.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020016#include <haproxy/http.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020017#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020018#include <haproxy/log.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020019#include <haproxy/pool.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020020#include <haproxy/proxy.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020021#include <haproxy/session.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020022#include <haproxy/tcp_rules.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020023#include <haproxy/vars.h>
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020024
Willy Tarreaubb2ef122015-04-04 16:31:16 +020025
Willy Tarreau8ceae722018-11-26 11:58:30 +010026DECLARE_POOL(pool_head_session, "session", sizeof(struct session));
Olivier Houchard351411f2018-12-27 17:20:54 +010027DECLARE_POOL(pool_head_sess_srv_list, "session server list",
28 sizeof(struct sess_srv_list));
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020029
Olivier Houchard477902b2020-01-22 18:08:48 +010030int conn_complete_session(struct connection *conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +020031
Willy Tarreauc38f71c2015-04-05 00:38:48 +020032/* Create a a new session and assign it to frontend <fe>, listener <li>,
33 * origin <origin>, set the current date and clear the stick counters pointers.
34 * Returns the session upon success or NULL. The session may be released using
Willy Tarreau0bf6fa52017-09-15 10:25:14 +020035 * session_free(). Note: <li> may be NULL.
Willy Tarreauc38f71c2015-04-05 00:38:48 +020036 */
37struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin)
38{
39 struct session *sess;
40
Willy Tarreaubafbe012017-11-24 17:34:44 +010041 sess = pool_alloc(pool_head_session);
Willy Tarreauc38f71c2015-04-05 00:38:48 +020042 if (sess) {
43 sess->listener = li;
44 sess->fe = fe;
45 sess->origin = origin;
46 sess->accept_date = date; /* user-visible date for logging */
47 sess->tv_accept = now; /* corrected date for internal use */
48 memset(sess->stkctr, 0, sizeof(sess->stkctr));
Willy Tarreauebcd4842015-06-19 11:59:02 +020049 vars_init(&sess->vars, SCOPE_SESS);
Willy Tarreau0b74eae2017-08-28 19:02:51 +020050 sess->task = NULL;
Willy Tarreau590a0512018-09-05 11:56:48 +020051 sess->t_handshake = -1; /* handshake not done yet */
Christopher Fauletd5173962020-09-30 10:28:02 +020052 sess->t_idle = -1;
Willy Tarreau4781b152021-04-06 13:53:36 +020053 _HA_ATOMIC_INC(&totalconn);
54 _HA_ATOMIC_INC(&jobs);
Olivier Houchard351411f2018-12-27 17:20:54 +010055 LIST_INIT(&sess->srv_list);
Olivier Houcharda2dbeb22018-12-28 18:50:57 +010056 sess->idle_conns = 0;
Olivier Houchard250031e2019-05-29 15:01:50 +020057 sess->flags = SESS_FL_NONE;
Willy Tarreauc38f71c2015-04-05 00:38:48 +020058 }
59 return sess;
60}
61
Willy Tarreau11c36242015-04-04 15:54:03 +020062void session_free(struct session *sess)
63{
Olivier Houchard00cf70f2018-11-30 17:24:55 +010064 struct connection *conn, *conn_back;
Olivier Houchard351411f2018-12-27 17:20:54 +010065 struct sess_srv_list *srv_list, *srv_list_back;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +010066
Willy Tarreau4f0c64c2017-10-18 15:01:14 +020067 if (sess->listener)
68 listener_release(sess->listener);
Willy Tarreaubb2ef122015-04-04 16:31:16 +020069 session_store_counters(sess);
Willy Tarreauebcd4842015-06-19 11:59:02 +020070 vars_prune_per_sess(&sess->vars);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +010071 conn = objt_conn(sess->origin);
72 if (conn != NULL && conn->mux)
Christopher Faulet73c12072019-04-08 11:23:22 +020073 conn->mux->destroy(conn->ctx);
Olivier Houchard351411f2018-12-27 17:20:54 +010074 list_for_each_entry_safe(srv_list, srv_list_back, &sess->srv_list, srv_list) {
75 list_for_each_entry_safe(conn, conn_back, &srv_list->conn_list, session_list) {
Willy Tarreau5de78172019-11-15 07:04:24 +010076 LIST_DEL_INIT(&conn->session_list);
Olivier Houchard00cf70f2018-11-30 17:24:55 +010077 if (conn->mux) {
Olivier Houchard00cf70f2018-11-30 17:24:55 +010078 conn->owner = NULL;
Olivier Houchard8788b412019-01-31 19:31:19 +010079 conn->flags &= ~CO_FL_SESS_IDLE;
Olivier Houchard2444aa52020-01-20 13:56:01 +010080 conn->mux->destroy(conn->ctx);
Olivier Houchard00cf70f2018-11-30 17:24:55 +010081 } else {
82 /* We have a connection, but not yet an associated mux.
83 * So destroy it now.
84 */
85 conn_stop_tracking(conn);
86 conn_full_close(conn);
87 conn_free(conn);
88 }
89 }
Olivier Houchard351411f2018-12-27 17:20:54 +010090 pool_free(pool_head_sess_srv_list, srv_list);
Olivier Houchard201b9f42018-11-21 00:16:29 +010091 }
Willy Tarreaubafbe012017-11-24 17:34:44 +010092 pool_free(pool_head_session, sess);
Willy Tarreau4781b152021-04-06 13:53:36 +020093 _HA_ATOMIC_DEC(&jobs);
Willy Tarreau11c36242015-04-04 15:54:03 +020094}
95
Willy Tarreau3e13cba2017-10-08 11:26:30 +020096/* callback used from the connection/mux layer to notify that a connection is
Joseph Herlantd091bfb2018-11-25 11:22:10 -080097 * going to be released.
Willy Tarreau3e13cba2017-10-08 11:26:30 +020098 */
99void conn_session_free(struct connection *conn)
100{
101 session_free(conn->owner);
Willy Tarreau3aab17b2020-11-20 17:22:44 +0100102 conn->owner = NULL;
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200103}
104
Willy Tarreau042cd752015-04-08 18:10:49 +0200105/* count a new session to keep frontend, listener and track stats up to date */
106static void session_count_new(struct session *sess)
107{
108 struct stkctr *stkctr;
109 void *ptr;
110 int i;
111
112 proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
113
114 for (i = 0; i < MAX_SESS_STKCTR; i++) {
115 stkctr = &sess->stkctr[i];
116 if (!stkctr_entry(stkctr))
117 continue;
118
119 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
120 if (ptr)
Willy Tarreau4781b152021-04-06 13:53:36 +0200121 HA_ATOMIC_INC(&stktable_data_cast(ptr, sess_cnt));
Willy Tarreau042cd752015-04-08 18:10:49 +0200122
123 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
124 if (ptr)
125 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
126 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
127 }
128}
129
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200130/* This function is called from the protocol layer accept() in order to
Dave Chiluk8618a6a2018-06-21 11:03:20 -0500131 * instantiate a new session on behalf of a given listener and frontend. It
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200132 * returns a positive value upon success, 0 if the connection can be ignored,
Willy Tarreau83efc322020-10-14 17:37:17 +0200133 * or a negative value upon critical failure. The accepted connection is
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200134 * closed if we return <= 0. If no handshake is needed, it immediately tries
Willy Tarreau83efc322020-10-14 17:37:17 +0200135 * to instantiate a new stream. The connection must already have been filled
136 * with the incoming connection handle (a fd), a target (the listener) and a
137 * source address.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200138 */
Willy Tarreau83efc322020-10-14 17:37:17 +0200139int session_accept_fd(struct connection *cli_conn)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200140{
Willy Tarreau83efc322020-10-14 17:37:17 +0200141 struct listener *l = __objt_listener(cli_conn->target);
Willy Tarreauc95bad52016-12-22 00:13:31 +0100142 struct proxy *p = l->bind_conf->frontend;
Willy Tarreau83efc322020-10-14 17:37:17 +0200143 int cfd = cli_conn->handle.fd;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200144 struct session *sess;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200145 int ret;
146
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200147 ret = -1; /* assume unrecoverable error by default */
148
Willy Tarreau818a92e2020-09-03 07:50:19 +0200149 cli_conn->proxy_netns = l->rx.settings->netns;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200150
Olivier Houchard1b3c9312021-03-05 23:37:48 +0100151 if (conn_prepare(cli_conn, l->rx.proto, l->bind_conf->xprt) < 0)
152 goto out_free_conn;
153
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200154 conn_ctrl_init(cli_conn);
155
156 /* wait for a PROXY protocol header */
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200157 if (l->options & LI_O_ACC_PROXY)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200158 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200159
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100160 /* wait for a NetScaler client IP insertion protocol header */
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200161 if (l->options & LI_O_ACC_CIP)
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100162 cli_conn->flags |= CO_FL_ACCEPT_CIP;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100163
Olivier Houchardfe50bfb2019-05-27 12:09:19 +0200164 /* Add the handshake pseudo-XPRT */
165 if (cli_conn->flags & (CO_FL_ACCEPT_PROXY | CO_FL_ACCEPT_CIP)) {
166 if (xprt_add_hs(cli_conn) != 0)
167 goto out_free_conn;
168 }
Willy Tarreau64beab22015-04-05 00:39:16 +0200169 sess = session_new(p, l, &cli_conn->obj_type);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200170 if (!sess)
171 goto out_free_conn;
172
Willy Tarreau436d3332017-10-08 11:16:46 +0200173 conn_set_owner(cli_conn, sess, NULL);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200174
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200175 /* now evaluate the tcp-request layer4 rules. We only need a session
176 * and no stream for these rules.
177 */
Willy Tarreau7d9736f2016-10-21 16:34:21 +0200178 if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200179 /* let's do a no-linger now to close with a single RST. */
180 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
181 ret = 0; /* successful termination */
182 goto out_free_sess;
183 }
Olivier Houchard1b3c9312021-03-05 23:37:48 +0100184 /* TCP rules may flag the connection as needing proxy protocol, now that it's done we can start ourxprt */
185 if (conn_xprt_start(cli_conn) < 0)
186 goto out_free_conn;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200187
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200188 /* Adjust some socket options */
Willy Tarreau37159062020-08-27 07:48:42 +0200189 if (l->rx.addr.ss_family == AF_INET || l->rx.addr.ss_family == AF_INET6) {
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200190 setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
191
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900192 if (p->options & PR_O_TCP_CLI_KA) {
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200193 setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
194
Willy Tarreau52543212020-07-09 05:58:51 +0200195#ifdef TCP_KEEPCNT
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900196 if (p->clitcpka_cnt)
197 setsockopt(cfd, IPPROTO_TCP, TCP_KEEPCNT, &p->clitcpka_cnt, sizeof(p->clitcpka_cnt));
Willy Tarreau52543212020-07-09 05:58:51 +0200198#endif
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900199
Willy Tarreau52543212020-07-09 05:58:51 +0200200#ifdef TCP_KEEPIDLE
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900201 if (p->clitcpka_idle)
202 setsockopt(cfd, IPPROTO_TCP, TCP_KEEPIDLE, &p->clitcpka_idle, sizeof(p->clitcpka_idle));
Willy Tarreau52543212020-07-09 05:58:51 +0200203#endif
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900204
Willy Tarreau52543212020-07-09 05:58:51 +0200205#ifdef TCP_KEEPINTVL
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900206 if (p->clitcpka_intvl)
207 setsockopt(cfd, IPPROTO_TCP, TCP_KEEPINTVL, &p->clitcpka_intvl, sizeof(p->clitcpka_intvl));
Willy Tarreau52543212020-07-09 05:58:51 +0200208#endif
MIZUTA Takeshib24bc0d2020-07-09 11:13:20 +0900209 }
210
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200211 if (p->options & PR_O_TCP_NOLING)
Willy Tarreaub41a6e92021-04-06 17:49:19 +0200212 HA_ATOMIC_OR(&fdtab[cfd].state, FD_LINGER_RISK);
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200213
214#if defined(TCP_MAXSEG)
215 if (l->maxseg < 0) {
216 /* we just want to reduce the current MSS by that value */
217 int mss;
218 socklen_t mss_len = sizeof(mss);
219 if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) {
220 mss += l->maxseg; /* remember, it's < 0 */
221 setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
222 }
223 }
224#endif
225 }
226
227 if (global.tune.client_sndbuf)
228 setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));
229
230 if (global.tune.client_rcvbuf)
231 setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));
232
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200233 /* OK, now either we have a pending handshake to execute with and then
234 * we must return to the I/O layer, or we can proceed with the end of
235 * the stream initialization. In case of handshake, we also set the I/O
236 * timeout to the frontend's client timeout and register a task in the
237 * session for this purpose. The connection's owner is left to the
238 * session during this period.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200239 *
240 * At this point we set the relation between sess/task/conn this way :
241 *
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200242 * +----------------- task
243 * | |
244 * orig -- sess <-- context |
245 * | ^ | |
246 * v | | |
247 * conn -- owner ---> task <-----+
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200248 */
Willy Tarreau911db9b2020-01-23 16:27:54 +0100249 if (cli_conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS)) {
Emeric Brunc60def82017-09-27 14:59:38 +0200250 if (unlikely((sess->task = task_new(tid_bit)) == NULL))
Willy Tarreau87787ac2017-08-28 16:22:54 +0200251 goto out_free_sess;
252
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200253 sess->task->context = sess;
254 sess->task->nice = l->nice;
255 sess->task->process = session_expire_embryonic;
256 sess->task->expire = tick_add_ifset(now_ms, p->timeout.client);
257 task_queue(sess->task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200258 return 1;
259 }
260
Willy Tarreau18b95a42015-04-05 01:04:01 +0200261 /* OK let's complete stream initialization since there is no handshake */
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200262 if (conn_complete_session(cli_conn) >= 0)
263 return 1;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200264
Willy Tarreaue5891ca2020-01-07 18:03:09 +0100265 /* if we reach here we have deliberately decided not to keep this
266 * session (e.g. tcp-request rule), so that's not an error we should
267 * try to protect against.
268 */
269 ret = 0;
270
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200271 /* error unrolling */
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200272 out_free_sess:
Christopher Fauletfe234282018-03-23 15:11:55 +0100273 /* prevent call to listener_release during session_free. It will be
274 * done below, for all errors. */
275 sess->listener = NULL;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200276 session_free(sess);
Willy Tarreau01ca1492020-10-15 07:11:14 +0200277
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200278 out_free_conn:
Christopher Faulet76f4c372019-07-17 16:53:19 +0200279 if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) &&
280 p->mode == PR_MODE_HTTP && l->bind_conf->mux_proto == NULL) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200281 /* critical error, no more memory, try to emit a 500 response */
Christopher Faulet39566d12019-07-17 21:36:33 +0200282 send(cfd, http_err_msgs[HTTP_ERR_500], strlen(http_err_msgs[HTTP_ERR_500]),
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200283 MSG_DONTWAIT|MSG_NOSIGNAL);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200284 }
285
Willy Tarreau01ca1492020-10-15 07:11:14 +0200286 conn_stop_tracking(cli_conn);
287 conn_full_close(cli_conn);
288 conn_free(cli_conn);
289 listener_release(l);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200290 return ret;
291}
292
293
294/* prepare the trash with a log prefix for session <sess>. It only works with
295 * embryonic sessions based on a real connection. This function requires that
296 * at sess->origin points to the incoming connection.
297 */
298static void session_prepare_log_prefix(struct session *sess)
299{
300 struct tm tm;
301 char pn[INET6_ADDRSTRLEN];
302 int ret;
303 char *end;
304 struct connection *cli_conn = __objt_conn(sess->origin);
305
Willy Tarreau4d3c60a2019-07-17 15:23:20 +0200306 ret = conn_get_src(cli_conn) ? addr_to_str(cli_conn->src, pn, sizeof(pn)) : 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200307 if (ret <= 0)
308 chunk_printf(&trash, "unknown [");
309 else if (ret == AF_UNIX)
310 chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
311 else
Willy Tarreau4d3c60a2019-07-17 15:23:20 +0200312 chunk_printf(&trash, "%s:%d [", pn, get_host_port(cli_conn->src));
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200313
314 get_localtime(sess->accept_date.tv_sec, &tm);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200315 end = date2str_log(trash.area + trash.data, &tm, &(sess->accept_date),
316 trash.size - trash.data);
317 trash.data = end - trash.area;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200318 if (sess->listener->name)
319 chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
320 else
321 chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
322}
323
324/* This function kills an existing embryonic session. It stops the connection's
325 * transport layer, releases assigned resources, resumes the listener if it was
326 * disabled and finally kills the file descriptor. This function requires that
327 * sess->origin points to the incoming connection.
328 */
Willy Tarreau144f84a2021-03-02 16:09:26 +0100329static void session_kill_embryonic(struct session *sess, unsigned int state)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200330{
331 int level = LOG_INFO;
332 struct connection *conn = __objt_conn(sess->origin);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200333 struct task *task = sess->task;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200334 unsigned int log = sess->fe->to_log;
335 const char *err_msg;
336
337 if (sess->fe->options2 & PR_O2_LOGERRORS)
338 level = LOG_ERR;
339
340 if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
341 /* with "option dontlognull", we don't log connections with no transfer */
342 if (!conn->err_code ||
343 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100344 conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200345 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
346 log = 0;
347 }
348
349 if (log) {
Willy Tarreau086735a2018-11-05 15:09:47 +0100350 if (!conn->err_code && (state & TASK_WOKEN_TIMER)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200351 if (conn->flags & CO_FL_ACCEPT_PROXY)
352 conn->err_code = CO_ER_PRX_TIMEOUT;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100353 else if (conn->flags & CO_FL_ACCEPT_CIP)
354 conn->err_code = CO_ER_CIP_TIMEOUT;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200355 else if (conn->flags & CO_FL_SSL_WAIT_HS)
356 conn->err_code = CO_ER_SSL_TIMEOUT;
357 }
358
359 session_prepare_log_prefix(sess);
360 err_msg = conn_err_code_str(conn);
361 if (err_msg)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200362 send_log(sess->fe, level, "%s: %s\n", trash.area,
363 err_msg);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200364 else
365 send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200366 trash.area, conn->err_code, conn->flags);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200367 }
368
369 /* kill the connection now */
Willy Tarreau5b78a9d2017-10-05 18:12:51 +0200370 conn_stop_tracking(conn);
371 conn_full_close(conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200372 conn_free(conn);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100373 sess->origin = NULL;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200374
Olivier Houchard3f795f72019-04-17 22:51:06 +0200375 task_destroy(task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200376 session_free(sess);
377}
378
379/* Manages the embryonic session timeout. It is only called when the timeout
Willy Tarreau02922e12021-01-29 12:27:57 +0100380 * strikes and performs the required cleanup. It's only exported to make it
381 * resolve in "show tasks".
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200382 */
Willy Tarreau144f84a2021-03-02 16:09:26 +0100383struct task *session_expire_embryonic(struct task *t, void *context, unsigned int state)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200384{
Olivier Houchard9f6af332018-05-25 14:04:04 +0200385 struct session *sess = context;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200386
Olivier Houchardfde2a092018-08-16 19:03:50 +0200387 if (!(state & TASK_WOKEN_TIMER))
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200388 return t;
389
Willy Tarreau086735a2018-11-05 15:09:47 +0100390 session_kill_embryonic(sess, state);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200391 return NULL;
392}
393
394/* Finish initializing a session from a connection, or kills it if the
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200395 * connection shows and error. Returns <0 if the connection was killed. It may
Olivier Houchard477902b2020-01-22 18:08:48 +0100396 * be called either asynchronously when ssl handshake is done with an embryonic
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200397 * session, or synchronously to finalize the session. The distinction is made
398 * on sess->task which is only set in the embryonic session case.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200399 */
Olivier Houchard477902b2020-01-22 18:08:48 +0100400int conn_complete_session(struct connection *conn)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200401{
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200402 struct session *sess = conn->owner;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200403
Willy Tarreau590a0512018-09-05 11:56:48 +0200404 sess->t_handshake = tv_ms_elapsed(&sess->tv_accept, &now);
405
Willy Tarreaud1769b82015-04-06 00:25:48 +0200406 if (conn->flags & CO_FL_ERROR)
407 goto fail;
408
Willy Tarreau678be622015-04-08 18:18:15 +0200409 /* if logs require transport layer information, note it on the connection */
410 if (sess->fe->to_log & LW_XPRT)
411 conn->flags |= CO_FL_XPRT_TRACKED;
412
Willy Tarreau620408f2016-10-21 16:37:51 +0200413 /* we may have some tcp-request-session rules */
414 if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
415 goto fail;
416
Willy Tarreau042cd752015-04-08 18:10:49 +0200417 session_count_new(sess);
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200418 if (conn_install_mux_fe(conn, NULL) < 0)
Willy Tarreaud1769b82015-04-06 00:25:48 +0200419 goto fail;
420
Willy Tarreau87787ac2017-08-28 16:22:54 +0200421 /* the embryonic session's task is not needed anymore */
Willy Tarreauf6562792019-05-07 19:05:35 +0200422 task_destroy(sess->task);
423 sess->task = NULL;
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200424 conn_set_owner(conn, sess, conn_session_free);
425
Willy Tarreaud1769b82015-04-06 00:25:48 +0200426 return 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200427
Willy Tarreaud1769b82015-04-06 00:25:48 +0200428 fail:
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200429 if (sess->task)
Willy Tarreau086735a2018-11-05 15:09:47 +0100430 session_kill_embryonic(sess, 0);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200431 return -1;
432}
433
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200434/*
435 * Local variables:
436 * c-indent-level: 8
437 * c-basic-offset: 8
438 * End:
439 */