blob: 46b9f67e3c9c58e754f6fa70dba03e5c7c0dc895 [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>
16#include <common/memory.h>
17
18#include <types/global.h>
19#include <types/session.h>
20
Willy Tarreau9903f0e2015-04-04 18:50:31 +020021#include <proto/connection.h>
22#include <proto/listener.h>
23#include <proto/log.h>
24#include <proto/proto_http.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 Tarreaub1ec8c42015-04-03 13:53:24 +020031struct pool_head *pool2_session;
32
Willy Tarreau9903f0e2015-04-04 18:50:31 +020033static int conn_complete_session(struct connection *conn);
34static int conn_update_session(struct connection *conn);
35static struct task *session_expire_embryonic(struct task *t);
36
37/* data layer callbacks for an embryonic stream */
38struct data_cb sess_conn_cb = {
39 .recv = NULL,
40 .send = NULL,
41 .wake = conn_update_session,
42 .init = conn_complete_session,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +010043 .name = "SESS",
Willy Tarreau9903f0e2015-04-04 18:50:31 +020044};
45
Willy Tarreauc38f71c2015-04-05 00:38:48 +020046/* Create a a new session and assign it to frontend <fe>, listener <li>,
47 * origin <origin>, set the current date and clear the stick counters pointers.
48 * Returns the session upon success or NULL. The session may be released using
49 * session_free().
50 */
51struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin)
52{
53 struct session *sess;
54
55 sess = pool_alloc2(pool2_session);
56 if (sess) {
57 sess->listener = li;
58 sess->fe = fe;
59 sess->origin = origin;
60 sess->accept_date = date; /* user-visible date for logging */
61 sess->tv_accept = now; /* corrected date for internal use */
62 memset(sess->stkctr, 0, sizeof(sess->stkctr));
Willy Tarreauebcd4842015-06-19 11:59:02 +020063 vars_init(&sess->vars, SCOPE_SESS);
Willy Tarreauc38f71c2015-04-05 00:38:48 +020064 }
65 return sess;
66}
67
Willy Tarreau11c36242015-04-04 15:54:03 +020068void session_free(struct session *sess)
69{
Willy Tarreaubb2ef122015-04-04 16:31:16 +020070 session_store_counters(sess);
Willy Tarreauebcd4842015-06-19 11:59:02 +020071 vars_prune_per_sess(&sess->vars);
Willy Tarreau11c36242015-04-04 15:54:03 +020072 pool_free2(pool2_session, sess);
73}
74
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020075/* perform minimal intializations, report 0 in case of error, 1 if OK. */
76int init_session()
77{
78 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
79 return pool2_session != NULL;
80}
81
Willy Tarreau042cd752015-04-08 18:10:49 +020082/* count a new session to keep frontend, listener and track stats up to date */
83static void session_count_new(struct session *sess)
84{
85 struct stkctr *stkctr;
86 void *ptr;
87 int i;
88
89 proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
90
91 for (i = 0; i < MAX_SESS_STKCTR; i++) {
92 stkctr = &sess->stkctr[i];
93 if (!stkctr_entry(stkctr))
94 continue;
95
96 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
97 if (ptr)
98 stktable_data_cast(ptr, sess_cnt)++;
99
100 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
101 if (ptr)
102 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
103 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
104 }
105}
106
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200107/* This function is called from the protocol layer accept() in order to
108 * instanciate a new session on behalf of a given listener and frontend. It
109 * returns a positive value upon success, 0 if the connection can be ignored,
110 * or a negative value upon critical failure. The accepted file descriptor is
111 * closed if we return <= 0. If no handshake is needed, it immediately tries
112 * to instanciate a new stream.
113 */
114int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr)
115{
116 struct connection *cli_conn;
Willy Tarreauc95bad52016-12-22 00:13:31 +0100117 struct proxy *p = l->bind_conf->frontend;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200118 struct session *sess;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200119 struct stream *strm;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200120 struct task *t;
121 int ret;
122
123
124 ret = -1; /* assume unrecoverable error by default */
125
126 if (unlikely((cli_conn = conn_new()) == NULL))
127 goto out_close;
128
Willy Tarreau71a8c7c2016-12-21 22:04:54 +0100129 conn_prepare(cli_conn, l->proto, l->bind_conf->xprt);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200130
131 cli_conn->t.sock.fd = cfd;
132 cli_conn->addr.from = *addr;
133 cli_conn->flags |= CO_FL_ADDR_FROM_SET;
134 cli_conn->target = &l->obj_type;
135 cli_conn->proxy_netns = l->netns;
136
137 conn_ctrl_init(cli_conn);
138
139 /* wait for a PROXY protocol header */
140 if (l->options & LI_O_ACC_PROXY) {
141 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
142 conn_sock_want_recv(cli_conn);
143 }
144
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100145 /* wait for a NetScaler client IP insertion protocol header */
146 if (l->options & LI_O_ACC_CIP) {
147 cli_conn->flags |= CO_FL_ACCEPT_CIP;
148 conn_sock_want_recv(cli_conn);
149 }
150
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200151 conn_data_want_recv(cli_conn);
152 if (conn_xprt_init(cli_conn) < 0)
153 goto out_free_conn;
154
Willy Tarreau64beab22015-04-05 00:39:16 +0200155 sess = session_new(p, l, &cli_conn->obj_type);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200156 if (!sess)
157 goto out_free_conn;
158
159 p->feconn++;
160 /* This session was accepted, count it now */
161 if (p->feconn > p->fe_counters.conn_max)
162 p->fe_counters.conn_max = p->feconn;
163
164 proxy_inc_fe_conn_ctr(l, p);
165
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200166 /* now evaluate the tcp-request layer4 rules. We only need a session
167 * and no stream for these rules.
168 */
Willy Tarreau7d9736f2016-10-21 16:34:21 +0200169 if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200170 /* let's do a no-linger now to close with a single RST. */
171 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
172 ret = 0; /* successful termination */
173 goto out_free_sess;
174 }
175
176 /* monitor-net and health mode are processed immediately after TCP
177 * connection rules. This way it's possible to block them, but they
178 * never use the lower data layers, they send directly over the socket,
179 * as they were designed for. We first flush the socket receive buffer
180 * in order to avoid emission of an RST by the system. We ignore any
181 * error.
182 */
183 if (unlikely((p->mode == PR_MODE_HEALTH) ||
184 ((l->options & LI_O_CHK_MONNET) &&
185 addr->ss_family == AF_INET &&
186 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
187 /* we have 4 possibilities here :
188 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
189 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
190 * - HEALTH mode without HTTP check => just send "OK"
191 * - TCP mode from monitoring address => just close
192 */
193 if (l->proto->drain)
194 l->proto->drain(cfd);
195 if (p->mode == PR_MODE_HTTP ||
196 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
197 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
198 else if (p->mode == PR_MODE_HEALTH)
199 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
200 ret = 0;
201 goto out_free_sess;
202 }
203
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200204 /* Adjust some socket options */
205 if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) {
206 setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
207
208 if (p->options & PR_O_TCP_CLI_KA)
209 setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
210
211 if (p->options & PR_O_TCP_NOLING)
212 fdtab[cfd].linger_risk = 1;
213
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 Tarreau9903f0e2015-04-04 18:50:31 +0200233 if (unlikely((t = task_new()) == NULL))
234 goto out_free_sess;
235
236 t->context = sess;
237 t->nice = l->nice;
238
239 /* OK, now either we have a pending handshake to execute with and
240 * then we must return to the I/O layer, or we can proceed with the
241 * end of the stream initialization. In case of handshake, we also
242 * set the I/O timeout to the frontend's client timeout.
243 *
244 * At this point we set the relation between sess/task/conn this way :
245 *
246 * orig -- sess <-- context
247 * | |
248 * v |
249 * conn -- owner ---> task
250 */
251 if (cli_conn->flags & CO_FL_HANDSHAKE) {
252 conn_attach(cli_conn, t, &sess_conn_cb);
253 t->process = session_expire_embryonic;
254 t->expire = tick_add_ifset(now_ms, p->timeout.client);
255 task_queue(t);
Willy Tarreaude40d792017-03-18 17:40:22 +0100256 cli_conn->flags |= CO_FL_INIT_DATA;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200257 return 1;
258 }
259
Willy Tarreau18b95a42015-04-05 01:04:01 +0200260 /* OK let's complete stream initialization since there is no handshake */
261 cli_conn->flags |= CO_FL_CONNECTED;
Willy Tarreau042cd752015-04-08 18:10:49 +0200262
Willy Tarreau678be622015-04-08 18:18:15 +0200263 /* if logs require transport layer information, note it on the connection */
264 if (sess->fe->to_log & LW_XPRT)
265 cli_conn->flags |= CO_FL_XPRT_TRACKED;
266
Willy Tarreau620408f2016-10-21 16:37:51 +0200267 /* we may have some tcp-request-session rules */
268 if ((l->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
269 goto out_free_sess;
270
Willy Tarreau042cd752015-04-08 18:10:49 +0200271 session_count_new(sess);
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200272 strm = stream_new(sess, t, &cli_conn->obj_type);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200273 if (!strm)
274 goto out_free_task;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200275
Christopher Fauletd7c91962015-04-30 11:48:27 +0200276 strm->target = sess->listener->default_target;
277 strm->req.analysers |= sess->listener->analysers;
278
Emeric Brun5f77fef2017-05-29 15:26:51 +0200279 task_wakeup(t, TASK_WOKEN_INIT);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200280 return 1;
281
282 out_free_task:
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200283 task_free(t);
284 out_free_sess:
285 p->feconn--;
286 session_free(sess);
287 out_free_conn:
288 cli_conn->flags &= ~CO_FL_XPRT_TRACKED;
289 conn_xprt_close(cli_conn);
290 conn_free(cli_conn);
291 out_close:
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100292 if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) && p->mode == PR_MODE_HTTP) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200293 /* critical error, no more memory, try to emit a 500 response */
294 struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
295 if (!err_msg->str)
296 err_msg = &http_err_chunks[HTTP_ERR_500];
297 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
298 }
299
300 if (fdtab[cfd].owner)
301 fd_delete(cfd);
302 else
303 close(cfd);
304 return ret;
305}
306
307
308/* prepare the trash with a log prefix for session <sess>. It only works with
309 * embryonic sessions based on a real connection. This function requires that
310 * at sess->origin points to the incoming connection.
311 */
312static void session_prepare_log_prefix(struct session *sess)
313{
314 struct tm tm;
315 char pn[INET6_ADDRSTRLEN];
316 int ret;
317 char *end;
318 struct connection *cli_conn = __objt_conn(sess->origin);
319
320 ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
321 if (ret <= 0)
322 chunk_printf(&trash, "unknown [");
323 else if (ret == AF_UNIX)
324 chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
325 else
326 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
327
328 get_localtime(sess->accept_date.tv_sec, &tm);
329 end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len);
330 trash.len = end - trash.str;
331 if (sess->listener->name)
332 chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
333 else
334 chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
335}
336
337/* This function kills an existing embryonic session. It stops the connection's
338 * transport layer, releases assigned resources, resumes the listener if it was
339 * disabled and finally kills the file descriptor. This function requires that
340 * sess->origin points to the incoming connection.
341 */
Willy Tarreau92b10c92016-12-04 20:05:16 +0100342static void session_kill_embryonic(struct session *sess, struct task *task)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200343{
344 int level = LOG_INFO;
345 struct connection *conn = __objt_conn(sess->origin);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200346 unsigned int log = sess->fe->to_log;
347 const char *err_msg;
348
349 if (sess->fe->options2 & PR_O2_LOGERRORS)
350 level = LOG_ERR;
351
352 if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
353 /* with "option dontlognull", we don't log connections with no transfer */
354 if (!conn->err_code ||
355 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100356 conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200357 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
358 log = 0;
359 }
360
361 if (log) {
362 if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {
363 if (conn->flags & CO_FL_ACCEPT_PROXY)
364 conn->err_code = CO_ER_PRX_TIMEOUT;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100365 else if (conn->flags & CO_FL_ACCEPT_CIP)
366 conn->err_code = CO_ER_CIP_TIMEOUT;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200367 else if (conn->flags & CO_FL_SSL_WAIT_HS)
368 conn->err_code = CO_ER_SSL_TIMEOUT;
369 }
370
371 session_prepare_log_prefix(sess);
372 err_msg = conn_err_code_str(conn);
373 if (err_msg)
374 send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg);
375 else
376 send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
377 trash.str, conn->err_code, conn->flags);
378 }
379
380 /* kill the connection now */
381 conn_force_close(conn);
382 conn_free(conn);
383
384 sess->fe->feconn--;
385
386 if (!(sess->listener->options & LI_O_UNLIMITED))
387 actconn--;
388 jobs--;
389 sess->listener->nbconn--;
390 if (sess->listener->state == LI_FULL)
391 resume_listener(sess->listener);
392
393 /* Dequeues all of the listeners waiting for a resource */
394 if (!LIST_ISEMPTY(&global_listener_queue))
395 dequeue_all_listeners(&global_listener_queue);
396
397 if (!LIST_ISEMPTY(&sess->fe->listener_queue) &&
398 (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0))
399 dequeue_all_listeners(&sess->fe->listener_queue);
400
401 task_delete(task);
402 task_free(task);
403 session_free(sess);
404}
405
406/* Manages the embryonic session timeout. It is only called when the timeout
407 * strikes and performs the required cleanup.
408 */
409static struct task *session_expire_embryonic(struct task *t)
410{
411 struct session *sess = t->context;
412
413 if (!(t->state & TASK_WOKEN_TIMER))
414 return t;
415
Willy Tarreau92b10c92016-12-04 20:05:16 +0100416 session_kill_embryonic(sess, t);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200417 return NULL;
418}
419
420/* Finish initializing a session from a connection, or kills it if the
421 * connection shows and error. Returns <0 if the connection was killed.
422 */
423static int conn_complete_session(struct connection *conn)
424{
425 struct task *task = conn->owner;
426 struct session *sess = task->context;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200427 struct stream *strm;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200428
Willy Tarreaud1769b82015-04-06 00:25:48 +0200429 if (conn->flags & CO_FL_ERROR)
430 goto fail;
431
Willy Tarreau678be622015-04-08 18:18:15 +0200432 /* if logs require transport layer information, note it on the connection */
433 if (sess->fe->to_log & LW_XPRT)
434 conn->flags |= CO_FL_XPRT_TRACKED;
435
Willy Tarreau620408f2016-10-21 16:37:51 +0200436 /* we may have some tcp-request-session rules */
437 if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
438 goto fail;
439
Willy Tarreau042cd752015-04-08 18:10:49 +0200440 session_count_new(sess);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200441 task->process = sess->listener->handler;
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200442 strm = stream_new(sess, task, &conn->obj_type);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200443 if (!strm)
444 goto fail;
445
Christopher Fauletd7c91962015-04-30 11:48:27 +0200446 strm->target = sess->listener->default_target;
447 strm->req.analysers |= sess->listener->analysers;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200448 conn->flags &= ~CO_FL_INIT_DATA;
Willy Tarreau678be622015-04-08 18:18:15 +0200449
Emeric Brun5f77fef2017-05-29 15:26:51 +0200450 task_wakeup(task, TASK_WOKEN_INIT);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200451 return 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200452
Willy Tarreaud1769b82015-04-06 00:25:48 +0200453 fail:
Willy Tarreau92b10c92016-12-04 20:05:16 +0100454 session_kill_embryonic(sess, task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200455 return -1;
456}
457
458/* Update a session status. The connection is killed in case of
459 * error, and <0 will be returned. Otherwise it does nothing.
460 */
461static int conn_update_session(struct connection *conn)
462{
463 struct task *task = conn->owner;
464 struct session *sess = task->context;
465
466 if (conn->flags & CO_FL_ERROR) {
Willy Tarreau92b10c92016-12-04 20:05:16 +0100467 session_kill_embryonic(sess, task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200468 return -1;
469 }
470 return 0;
471}
472
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200473/*
474 * Local variables:
475 * c-indent-level: 8
476 * c-basic-offset: 8
477 * End:
478 */