blob: 2dfd1dea657047c4e4f4f0ad530957fb3466663d [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
13#include <common/config.h>
14#include <common/buffer.h>
15#include <common/debug.h>
Willy Tarreau35b51c62018-09-10 15:38:55 +020016#include <common/http.h>
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020017#include <common/memory.h>
18
19#include <types/global.h>
20#include <types/session.h>
21
Willy Tarreau9903f0e2015-04-04 18:50:31 +020022#include <proto/connection.h>
23#include <proto/listener.h>
24#include <proto/log.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020025#include <proto/proxy.h>
Willy Tarreaubb2ef122015-04-04 16:31:16 +020026#include <proto/session.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020027#include <proto/stream.h>
Willy Tarreau39713102016-11-25 15:49:32 +010028#include <proto/tcp_rules.h>
Willy Tarreauebcd4842015-06-19 11:59:02 +020029#include <proto/vars.h>
Willy Tarreaubb2ef122015-04-04 16:31:16 +020030
Willy Tarreau8ceae722018-11-26 11:58:30 +010031DECLARE_POOL(pool_head_session, "session", sizeof(struct session));
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020032
Willy Tarreau9903f0e2015-04-04 18:50:31 +020033static int conn_complete_session(struct connection *conn);
Olivier Houchard9f6af332018-05-25 14:04:04 +020034static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state);
Willy Tarreau9903f0e2015-04-04 18:50:31 +020035
Willy Tarreauc38f71c2015-04-05 00:38:48 +020036/* Create a a new session and assign it to frontend <fe>, listener <li>,
37 * origin <origin>, set the current date and clear the stick counters pointers.
38 * Returns the session upon success or NULL. The session may be released using
Willy Tarreau0bf6fa52017-09-15 10:25:14 +020039 * session_free(). Note: <li> may be NULL.
Willy Tarreauc38f71c2015-04-05 00:38:48 +020040 */
41struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin)
42{
43 struct session *sess;
Olivier Houchard00cf70f2018-11-30 17:24:55 +010044 int i;
Willy Tarreauc38f71c2015-04-05 00:38:48 +020045
Willy Tarreaubafbe012017-11-24 17:34:44 +010046 sess = pool_alloc(pool_head_session);
Willy Tarreauc38f71c2015-04-05 00:38:48 +020047 if (sess) {
48 sess->listener = li;
49 sess->fe = fe;
50 sess->origin = origin;
51 sess->accept_date = date; /* user-visible date for logging */
52 sess->tv_accept = now; /* corrected date for internal use */
53 memset(sess->stkctr, 0, sizeof(sess->stkctr));
Willy Tarreauebcd4842015-06-19 11:59:02 +020054 vars_init(&sess->vars, SCOPE_SESS);
Willy Tarreau0b74eae2017-08-28 19:02:51 +020055 sess->task = NULL;
Willy Tarreau590a0512018-09-05 11:56:48 +020056 sess->t_handshake = -1; /* handshake not done yet */
Christopher Fauletff8abcd2017-06-02 15:33:24 +020057 HA_ATOMIC_UPDATE_MAX(&fe->fe_counters.conn_max,
58 HA_ATOMIC_ADD(&fe->feconn, 1));
Willy Tarreau0bf6fa52017-09-15 10:25:14 +020059 if (li)
60 proxy_inc_fe_conn_ctr(li, fe);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +020061 HA_ATOMIC_ADD(&totalconn, 1);
62 HA_ATOMIC_ADD(&jobs, 1);
Olivier Houchard00cf70f2018-11-30 17:24:55 +010063 for (i = 0; i < MAX_SRV_LIST; i++) {
64 sess->srv_list[i].target = NULL;
65 LIST_INIT(&sess->srv_list[i].list);
66 }
Willy Tarreauc38f71c2015-04-05 00:38:48 +020067 }
68 return sess;
69}
70
Willy Tarreau11c36242015-04-04 15:54:03 +020071void session_free(struct session *sess)
72{
Olivier Houchard00cf70f2018-11-30 17:24:55 +010073 struct connection *conn, *conn_back;
74 int i;
Olivier Houchard7c6f8b12018-11-13 16:48:36 +010075
Christopher Fauletff8abcd2017-06-02 15:33:24 +020076 HA_ATOMIC_SUB(&sess->fe->feconn, 1);
Willy Tarreau4f0c64c2017-10-18 15:01:14 +020077 if (sess->listener)
78 listener_release(sess->listener);
Willy Tarreaubb2ef122015-04-04 16:31:16 +020079 session_store_counters(sess);
Willy Tarreauebcd4842015-06-19 11:59:02 +020080 vars_prune_per_sess(&sess->vars);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +010081 conn = objt_conn(sess->origin);
82 if (conn != NULL && conn->mux)
83 conn->mux->destroy(conn);
Olivier Houchard00cf70f2018-11-30 17:24:55 +010084 for (i = 0; i < MAX_SRV_LIST; i++) {
85 int count = 0;
86 list_for_each_entry_safe(conn, conn_back, &sess->srv_list[i].list, session_list) {
87 count++;
88 if (conn->mux) {
Olivier Houchard0c18a6f2018-12-02 14:11:41 +010089 struct server *srv;
90
Olivier Houchard00cf70f2018-11-30 17:24:55 +010091 LIST_DEL(&conn->session_list);
92 LIST_INIT(&conn->session_list);
Olivier Houchard0c18a6f2018-12-02 14:11:41 +010093 srv = objt_server(conn->target);
Olivier Houchard00cf70f2018-11-30 17:24:55 +010094 conn->owner = NULL;
Olivier Houchard0c18a6f2018-12-02 14:11:41 +010095 if (srv && srv->idle_timeout > 0 &&
96 !(conn->flags & CO_FL_PRIVATE) &&
97 conn->mux->avail_streams(conn) ==
98 conn->mux->max_streams(conn)) {
99 LIST_DEL(&conn->list);
100
101 LIST_ADDQ(&srv->idle_orphan_conns[tid],
102 &conn->list);
103
104 conn->idle_time = now_ms;
105 if (!(task_in_wq(srv->idle_task[tid])) &&
106 !(task_in_rq(srv->idle_task[tid])))
107 task_schedule(srv->idle_task[tid],
108 tick_add(now_ms, srv->idle_timeout));
109 } else
110 conn->mux->destroy(conn);
Olivier Houchard00cf70f2018-11-30 17:24:55 +0100111 } else {
112 /* We have a connection, but not yet an associated mux.
113 * So destroy it now.
114 */
115 conn_stop_tracking(conn);
116 conn_full_close(conn);
117 conn_free(conn);
118 }
119 }
Olivier Houchard201b9f42018-11-21 00:16:29 +0100120 }
Willy Tarreaubafbe012017-11-24 17:34:44 +0100121 pool_free(pool_head_session, sess);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200122 HA_ATOMIC_SUB(&jobs, 1);
Willy Tarreau11c36242015-04-04 15:54:03 +0200123}
124
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200125/* callback used from the connection/mux layer to notify that a connection is
Joseph Herlantd091bfb2018-11-25 11:22:10 -0800126 * going to be released.
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200127 */
128void conn_session_free(struct connection *conn)
129{
130 session_free(conn->owner);
131}
132
Willy Tarreau042cd752015-04-08 18:10:49 +0200133/* count a new session to keep frontend, listener and track stats up to date */
134static void session_count_new(struct session *sess)
135{
136 struct stkctr *stkctr;
137 void *ptr;
138 int i;
139
140 proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
141
142 for (i = 0; i < MAX_SESS_STKCTR; i++) {
143 stkctr = &sess->stkctr[i];
144 if (!stkctr_entry(stkctr))
145 continue;
146
147 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
148 if (ptr)
149 stktable_data_cast(ptr, sess_cnt)++;
150
151 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
152 if (ptr)
153 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
154 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
155 }
156}
157
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200158/* This function is called from the protocol layer accept() in order to
Dave Chiluk8618a6a2018-06-21 11:03:20 -0500159 * instantiate a new session on behalf of a given listener and frontend. It
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200160 * returns a positive value upon success, 0 if the connection can be ignored,
161 * or a negative value upon critical failure. The accepted file descriptor is
162 * closed if we return <= 0. If no handshake is needed, it immediately tries
Dave Chiluk8618a6a2018-06-21 11:03:20 -0500163 * to instantiate a new stream. The created connection's owner points to the
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200164 * new session until the upper layers are created.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200165 */
166int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr)
167{
168 struct connection *cli_conn;
Willy Tarreauc95bad52016-12-22 00:13:31 +0100169 struct proxy *p = l->bind_conf->frontend;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200170 struct session *sess;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200171 int ret;
172
173
174 ret = -1; /* assume unrecoverable error by default */
175
176 if (unlikely((cli_conn = conn_new()) == NULL))
177 goto out_close;
178
Willy Tarreau585744b2017-08-24 14:31:19 +0200179 cli_conn->handle.fd = cfd;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200180 cli_conn->addr.from = *addr;
181 cli_conn->flags |= CO_FL_ADDR_FROM_SET;
182 cli_conn->target = &l->obj_type;
183 cli_conn->proxy_netns = l->netns;
184
Willy Tarreaube373152018-09-06 11:45:30 +0200185 conn_prepare(cli_conn, l->proto, l->bind_conf->xprt);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200186 conn_ctrl_init(cli_conn);
187
188 /* wait for a PROXY protocol header */
189 if (l->options & LI_O_ACC_PROXY) {
190 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
191 conn_sock_want_recv(cli_conn);
192 }
193
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100194 /* wait for a NetScaler client IP insertion protocol header */
195 if (l->options & LI_O_ACC_CIP) {
196 cli_conn->flags |= CO_FL_ACCEPT_CIP;
197 conn_sock_want_recv(cli_conn);
198 }
199
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200200 conn_xprt_want_recv(cli_conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200201 if (conn_xprt_init(cli_conn) < 0)
202 goto out_free_conn;
203
Willy Tarreau64beab22015-04-05 00:39:16 +0200204 sess = session_new(p, l, &cli_conn->obj_type);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200205 if (!sess)
206 goto out_free_conn;
207
Willy Tarreau436d3332017-10-08 11:16:46 +0200208 conn_set_owner(cli_conn, sess, NULL);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200209
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200210 /* now evaluate the tcp-request layer4 rules. We only need a session
211 * and no stream for these rules.
212 */
Willy Tarreau7d9736f2016-10-21 16:34:21 +0200213 if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200214 /* let's do a no-linger now to close with a single RST. */
215 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
216 ret = 0; /* successful termination */
217 goto out_free_sess;
218 }
219
220 /* monitor-net and health mode are processed immediately after TCP
221 * connection rules. This way it's possible to block them, but they
222 * never use the lower data layers, they send directly over the socket,
223 * as they were designed for. We first flush the socket receive buffer
224 * in order to avoid emission of an RST by the system. We ignore any
225 * error.
226 */
227 if (unlikely((p->mode == PR_MODE_HEALTH) ||
228 ((l->options & LI_O_CHK_MONNET) &&
229 addr->ss_family == AF_INET &&
230 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
231 /* we have 4 possibilities here :
232 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
233 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
234 * - HEALTH mode without HTTP check => just send "OK"
235 * - TCP mode from monitoring address => just close
236 */
237 if (l->proto->drain)
238 l->proto->drain(cfd);
239 if (p->mode == PR_MODE_HTTP ||
240 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
241 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
242 else if (p->mode == PR_MODE_HEALTH)
243 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
244 ret = 0;
245 goto out_free_sess;
246 }
247
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200248 /* Adjust some socket options */
249 if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) {
250 setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
251
252 if (p->options & PR_O_TCP_CLI_KA)
253 setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
254
255 if (p->options & PR_O_TCP_NOLING)
256 fdtab[cfd].linger_risk = 1;
257
258#if defined(TCP_MAXSEG)
259 if (l->maxseg < 0) {
260 /* we just want to reduce the current MSS by that value */
261 int mss;
262 socklen_t mss_len = sizeof(mss);
263 if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) {
264 mss += l->maxseg; /* remember, it's < 0 */
265 setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
266 }
267 }
268#endif
269 }
270
271 if (global.tune.client_sndbuf)
272 setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));
273
274 if (global.tune.client_rcvbuf)
275 setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));
276
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200277 /* OK, now either we have a pending handshake to execute with and then
278 * we must return to the I/O layer, or we can proceed with the end of
279 * the stream initialization. In case of handshake, we also set the I/O
280 * timeout to the frontend's client timeout and register a task in the
281 * session for this purpose. The connection's owner is left to the
282 * session during this period.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200283 *
284 * At this point we set the relation between sess/task/conn this way :
285 *
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200286 * +----------------- task
287 * | |
288 * orig -- sess <-- context |
289 * | ^ | |
290 * v | | |
291 * conn -- owner ---> task <-----+
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200292 */
Olivier Houchardc2aae742017-09-22 18:26:28 +0200293 if (cli_conn->flags & (CO_FL_HANDSHAKE | CO_FL_EARLY_SSL_HS)) {
Emeric Brunc60def82017-09-27 14:59:38 +0200294 if (unlikely((sess->task = task_new(tid_bit)) == NULL))
Willy Tarreau87787ac2017-08-28 16:22:54 +0200295 goto out_free_sess;
296
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200297 conn_set_xprt_done_cb(cli_conn, conn_complete_session);
Willy Tarreau87787ac2017-08-28 16:22:54 +0200298
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200299 sess->task->context = sess;
300 sess->task->nice = l->nice;
301 sess->task->process = session_expire_embryonic;
302 sess->task->expire = tick_add_ifset(now_ms, p->timeout.client);
303 task_queue(sess->task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200304 return 1;
305 }
306
Willy Tarreau18b95a42015-04-05 01:04:01 +0200307 /* OK let's complete stream initialization since there is no handshake */
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200308 if (conn_complete_session(cli_conn) >= 0)
309 return 1;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200310
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200311 /* error unrolling */
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200312 out_free_sess:
Christopher Fauletfe234282018-03-23 15:11:55 +0100313 /* prevent call to listener_release during session_free. It will be
314 * done below, for all errors. */
315 sess->listener = NULL;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200316 session_free(sess);
317 out_free_conn:
Willy Tarreau5b78a9d2017-10-05 18:12:51 +0200318 conn_stop_tracking(cli_conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200319 conn_xprt_close(cli_conn);
320 conn_free(cli_conn);
321 out_close:
Christopher Fauletfe234282018-03-23 15:11:55 +0100322 listener_release(l);
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100323 if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) && p->mode == PR_MODE_HTTP) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200324 /* critical error, no more memory, try to emit a 500 response */
Willy Tarreau83061a82018-07-13 11:56:34 +0200325 struct buffer *err_msg = &p->errmsg[HTTP_ERR_500];
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200326 if (!err_msg->area)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200327 err_msg = &http_err_chunks[HTTP_ERR_500];
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200328 send(cfd, err_msg->area, err_msg->data,
329 MSG_DONTWAIT|MSG_NOSIGNAL);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200330 }
331
332 if (fdtab[cfd].owner)
333 fd_delete(cfd);
334 else
335 close(cfd);
336 return ret;
337}
338
339
340/* prepare the trash with a log prefix for session <sess>. It only works with
341 * embryonic sessions based on a real connection. This function requires that
342 * at sess->origin points to the incoming connection.
343 */
344static void session_prepare_log_prefix(struct session *sess)
345{
346 struct tm tm;
347 char pn[INET6_ADDRSTRLEN];
348 int ret;
349 char *end;
350 struct connection *cli_conn = __objt_conn(sess->origin);
351
352 ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
353 if (ret <= 0)
354 chunk_printf(&trash, "unknown [");
355 else if (ret == AF_UNIX)
356 chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
357 else
358 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
359
360 get_localtime(sess->accept_date.tv_sec, &tm);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200361 end = date2str_log(trash.area + trash.data, &tm, &(sess->accept_date),
362 trash.size - trash.data);
363 trash.data = end - trash.area;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200364 if (sess->listener->name)
365 chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
366 else
367 chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
368}
369
370/* This function kills an existing embryonic session. It stops the connection's
371 * transport layer, releases assigned resources, resumes the listener if it was
372 * disabled and finally kills the file descriptor. This function requires that
373 * sess->origin points to the incoming connection.
374 */
Willy Tarreau086735a2018-11-05 15:09:47 +0100375static void session_kill_embryonic(struct session *sess, unsigned short state)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200376{
377 int level = LOG_INFO;
378 struct connection *conn = __objt_conn(sess->origin);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200379 struct task *task = sess->task;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200380 unsigned int log = sess->fe->to_log;
381 const char *err_msg;
382
383 if (sess->fe->options2 & PR_O2_LOGERRORS)
384 level = LOG_ERR;
385
386 if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
387 /* with "option dontlognull", we don't log connections with no transfer */
388 if (!conn->err_code ||
389 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100390 conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200391 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
392 log = 0;
393 }
394
395 if (log) {
Willy Tarreau086735a2018-11-05 15:09:47 +0100396 if (!conn->err_code && (state & TASK_WOKEN_TIMER)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200397 if (conn->flags & CO_FL_ACCEPT_PROXY)
398 conn->err_code = CO_ER_PRX_TIMEOUT;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100399 else if (conn->flags & CO_FL_ACCEPT_CIP)
400 conn->err_code = CO_ER_CIP_TIMEOUT;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200401 else if (conn->flags & CO_FL_SSL_WAIT_HS)
402 conn->err_code = CO_ER_SSL_TIMEOUT;
403 }
404
405 session_prepare_log_prefix(sess);
406 err_msg = conn_err_code_str(conn);
407 if (err_msg)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200408 send_log(sess->fe, level, "%s: %s\n", trash.area,
409 err_msg);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200410 else
411 send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200412 trash.area, conn->err_code, conn->flags);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200413 }
414
415 /* kill the connection now */
Willy Tarreau5b78a9d2017-10-05 18:12:51 +0200416 conn_stop_tracking(conn);
417 conn_full_close(conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200418 conn_free(conn);
Olivier Houchard7c6f8b12018-11-13 16:48:36 +0100419 sess->origin = NULL;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200420
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200421 task_delete(task);
422 task_free(task);
423 session_free(sess);
424}
425
426/* Manages the embryonic session timeout. It is only called when the timeout
427 * strikes and performs the required cleanup.
428 */
Olivier Houchard9f6af332018-05-25 14:04:04 +0200429static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200430{
Olivier Houchard9f6af332018-05-25 14:04:04 +0200431 struct session *sess = context;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200432
Olivier Houchardfde2a092018-08-16 19:03:50 +0200433 if (!(state & TASK_WOKEN_TIMER))
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200434 return t;
435
Willy Tarreau086735a2018-11-05 15:09:47 +0100436 session_kill_embryonic(sess, state);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200437 return NULL;
438}
439
440/* Finish initializing a session from a connection, or kills it if the
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200441 * connection shows and error. Returns <0 if the connection was killed. It may
442 * be called either asynchronously as an xprt_done callback with an embryonic
443 * session, or synchronously to finalize the session. The distinction is made
444 * on sess->task which is only set in the embryonic session case.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200445 */
446static int conn_complete_session(struct connection *conn)
447{
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200448 struct session *sess = conn->owner;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200449
Willy Tarreau590a0512018-09-05 11:56:48 +0200450 sess->t_handshake = tv_ms_elapsed(&sess->tv_accept, &now);
451
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200452 conn_clear_xprt_done_cb(conn);
453
Emeric Brun1738e862018-03-05 17:46:16 +0100454 /* Verify if the connection just established. */
455 if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED))))
456 conn->flags |= CO_FL_CONNECTED;
457
Willy Tarreaud1769b82015-04-06 00:25:48 +0200458 if (conn->flags & CO_FL_ERROR)
459 goto fail;
460
Willy Tarreau678be622015-04-08 18:18:15 +0200461 /* if logs require transport layer information, note it on the connection */
462 if (sess->fe->to_log & LW_XPRT)
463 conn->flags |= CO_FL_XPRT_TRACKED;
464
Willy Tarreau620408f2016-10-21 16:37:51 +0200465 /* we may have some tcp-request-session rules */
466 if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
467 goto fail;
468
Willy Tarreau042cd752015-04-08 18:10:49 +0200469 session_count_new(sess);
Christopher Faulet7ce0c892018-04-10 15:01:45 +0200470 if (conn_install_mux_fe(conn, NULL) < 0)
Willy Tarreaud1769b82015-04-06 00:25:48 +0200471 goto fail;
472
Willy Tarreau87787ac2017-08-28 16:22:54 +0200473 /* the embryonic session's task is not needed anymore */
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200474 if (sess->task) {
475 task_delete(sess->task);
476 task_free(sess->task);
477 sess->task = NULL;
478 }
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200479
480 conn_set_owner(conn, sess, conn_session_free);
481
Willy Tarreaud1769b82015-04-06 00:25:48 +0200482 return 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200483
Willy Tarreaud1769b82015-04-06 00:25:48 +0200484 fail:
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200485 if (sess->task)
Willy Tarreau086735a2018-11-05 15:09:47 +0100486 session_kill_embryonic(sess, 0);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200487 return -1;
488}
489
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200490/*
491 * Local variables:
492 * c-indent-level: 8
493 * c-basic-offset: 8
494 * End:
495 */