blob: 93fdf5248cbdbd6666c64cd46838b5034f5b366c [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>
25#include <proto/proto_tcp.h>
26#include <proto/proxy.h>
27#include <proto/raw_sock.h>
Willy Tarreaubb2ef122015-04-04 16:31:16 +020028#include <proto/session.h>
Willy Tarreau9903f0e2015-04-04 18:50:31 +020029#include <proto/stream.h>
Willy Tarreauebcd4842015-06-19 11:59:02 +020030#include <proto/vars.h>
Willy Tarreaubb2ef122015-04-04 16:31:16 +020031
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020032struct pool_head *pool2_session;
33
Willy Tarreau9903f0e2015-04-04 18:50:31 +020034static int conn_complete_session(struct connection *conn);
35static int conn_update_session(struct connection *conn);
36static struct task *session_expire_embryonic(struct task *t);
37
38/* data layer callbacks for an embryonic stream */
39struct data_cb sess_conn_cb = {
40 .recv = NULL,
41 .send = NULL,
42 .wake = conn_update_session,
43 .init = conn_complete_session,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +010044 .name = "SESS",
Willy Tarreau9903f0e2015-04-04 18:50:31 +020045};
46
Willy Tarreauc38f71c2015-04-05 00:38:48 +020047/* Create a a new session and assign it to frontend <fe>, listener <li>,
48 * origin <origin>, set the current date and clear the stick counters pointers.
49 * Returns the session upon success or NULL. The session may be released using
50 * session_free().
51 */
52struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin)
53{
54 struct session *sess;
55
56 sess = pool_alloc2(pool2_session);
57 if (sess) {
58 sess->listener = li;
59 sess->fe = fe;
60 sess->origin = origin;
61 sess->accept_date = date; /* user-visible date for logging */
62 sess->tv_accept = now; /* corrected date for internal use */
63 memset(sess->stkctr, 0, sizeof(sess->stkctr));
Willy Tarreauebcd4842015-06-19 11:59:02 +020064 vars_init(&sess->vars, SCOPE_SESS);
Willy Tarreauc38f71c2015-04-05 00:38:48 +020065 }
66 return sess;
67}
68
Willy Tarreau11c36242015-04-04 15:54:03 +020069void session_free(struct session *sess)
70{
Willy Tarreaubb2ef122015-04-04 16:31:16 +020071 session_store_counters(sess);
Willy Tarreauebcd4842015-06-19 11:59:02 +020072 vars_prune_per_sess(&sess->vars);
Willy Tarreau11c36242015-04-04 15:54:03 +020073 pool_free2(pool2_session, sess);
74}
75
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020076/* perform minimal intializations, report 0 in case of error, 1 if OK. */
77int init_session()
78{
79 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
80 return pool2_session != NULL;
81}
82
Willy Tarreau042cd752015-04-08 18:10:49 +020083/* count a new session to keep frontend, listener and track stats up to date */
84static void session_count_new(struct session *sess)
85{
86 struct stkctr *stkctr;
87 void *ptr;
88 int i;
89
90 proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
91
92 for (i = 0; i < MAX_SESS_STKCTR; i++) {
93 stkctr = &sess->stkctr[i];
94 if (!stkctr_entry(stkctr))
95 continue;
96
97 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
98 if (ptr)
99 stktable_data_cast(ptr, sess_cnt)++;
100
101 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
102 if (ptr)
103 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
104 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
105 }
106}
107
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200108/* This function is called from the protocol layer accept() in order to
109 * instanciate a new session on behalf of a given listener and frontend. It
110 * returns a positive value upon success, 0 if the connection can be ignored,
111 * or a negative value upon critical failure. The accepted file descriptor is
112 * closed if we return <= 0. If no handshake is needed, it immediately tries
113 * to instanciate a new stream.
114 */
115int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr)
116{
117 struct connection *cli_conn;
118 struct proxy *p = l->frontend;
119 struct session *sess;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200120 struct stream *strm;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200121 struct task *t;
122 int ret;
123
124
125 ret = -1; /* assume unrecoverable error by default */
126
127 if (unlikely((cli_conn = conn_new()) == NULL))
128 goto out_close;
129
130 conn_prepare(cli_conn, l->proto, l->xprt);
131
132 cli_conn->t.sock.fd = cfd;
133 cli_conn->addr.from = *addr;
134 cli_conn->flags |= CO_FL_ADDR_FROM_SET;
135 cli_conn->target = &l->obj_type;
136 cli_conn->proxy_netns = l->netns;
137
138 conn_ctrl_init(cli_conn);
139
140 /* wait for a PROXY protocol header */
141 if (l->options & LI_O_ACC_PROXY) {
142 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
143 conn_sock_want_recv(cli_conn);
144 }
145
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100146 /* wait for a NetScaler client IP insertion protocol header */
147 if (l->options & LI_O_ACC_CIP) {
148 cli_conn->flags |= CO_FL_ACCEPT_CIP;
149 conn_sock_want_recv(cli_conn);
150 }
151
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200152 conn_data_want_recv(cli_conn);
153 if (conn_xprt_init(cli_conn) < 0)
154 goto out_free_conn;
155
Willy Tarreau64beab22015-04-05 00:39:16 +0200156 sess = session_new(p, l, &cli_conn->obj_type);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200157 if (!sess)
158 goto out_free_conn;
159
160 p->feconn++;
161 /* This session was accepted, count it now */
162 if (p->feconn > p->fe_counters.conn_max)
163 p->fe_counters.conn_max = p->feconn;
164
165 proxy_inc_fe_conn_ctr(l, p);
166
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200167 /* now evaluate the tcp-request layer4 rules. We only need a session
168 * and no stream for these rules.
169 */
Willy Tarreau7d9736f2016-10-21 16:34:21 +0200170 if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200171 /* let's do a no-linger now to close with a single RST. */
172 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
173 ret = 0; /* successful termination */
174 goto out_free_sess;
175 }
176
177 /* monitor-net and health mode are processed immediately after TCP
178 * connection rules. This way it's possible to block them, but they
179 * never use the lower data layers, they send directly over the socket,
180 * as they were designed for. We first flush the socket receive buffer
181 * in order to avoid emission of an RST by the system. We ignore any
182 * error.
183 */
184 if (unlikely((p->mode == PR_MODE_HEALTH) ||
185 ((l->options & LI_O_CHK_MONNET) &&
186 addr->ss_family == AF_INET &&
187 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
188 /* we have 4 possibilities here :
189 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
190 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
191 * - HEALTH mode without HTTP check => just send "OK"
192 * - TCP mode from monitoring address => just close
193 */
194 if (l->proto->drain)
195 l->proto->drain(cfd);
196 if (p->mode == PR_MODE_HTTP ||
197 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
198 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
199 else if (p->mode == PR_MODE_HEALTH)
200 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
201 ret = 0;
202 goto out_free_sess;
203 }
204
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200205 /* Adjust some socket options */
206 if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) {
207 setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
208
209 if (p->options & PR_O_TCP_CLI_KA)
210 setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
211
212 if (p->options & PR_O_TCP_NOLING)
213 fdtab[cfd].linger_risk = 1;
214
215#if defined(TCP_MAXSEG)
216 if (l->maxseg < 0) {
217 /* we just want to reduce the current MSS by that value */
218 int mss;
219 socklen_t mss_len = sizeof(mss);
220 if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) {
221 mss += l->maxseg; /* remember, it's < 0 */
222 setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
223 }
224 }
225#endif
226 }
227
228 if (global.tune.client_sndbuf)
229 setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));
230
231 if (global.tune.client_rcvbuf)
232 setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));
233
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200234 if (unlikely((t = task_new()) == NULL))
235 goto out_free_sess;
236
237 t->context = sess;
238 t->nice = l->nice;
239
240 /* OK, now either we have a pending handshake to execute with and
241 * then we must return to the I/O layer, or we can proceed with the
242 * end of the stream initialization. In case of handshake, we also
243 * set the I/O timeout to the frontend's client timeout.
244 *
245 * At this point we set the relation between sess/task/conn this way :
246 *
247 * orig -- sess <-- context
248 * | |
249 * v |
250 * conn -- owner ---> task
251 */
252 if (cli_conn->flags & CO_FL_HANDSHAKE) {
253 conn_attach(cli_conn, t, &sess_conn_cb);
254 t->process = session_expire_embryonic;
255 t->expire = tick_add_ifset(now_ms, p->timeout.client);
256 task_queue(t);
257 cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
258 return 1;
259 }
260
Willy Tarreau18b95a42015-04-05 01:04:01 +0200261 /* OK let's complete stream initialization since there is no handshake */
262 cli_conn->flags |= CO_FL_CONNECTED;
Willy Tarreau042cd752015-04-08 18:10:49 +0200263
Willy Tarreau678be622015-04-08 18:18:15 +0200264 /* we want the connection handler to notify the stream interface about updates. */
265 cli_conn->flags |= CO_FL_WAKE_DATA;
266
267 /* if logs require transport layer information, note it on the connection */
268 if (sess->fe->to_log & LW_XPRT)
269 cli_conn->flags |= CO_FL_XPRT_TRACKED;
270
Willy Tarreau620408f2016-10-21 16:37:51 +0200271 /* we may have some tcp-request-session rules */
272 if ((l->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
273 goto out_free_sess;
274
Willy Tarreau042cd752015-04-08 18:10:49 +0200275 session_count_new(sess);
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200276 strm = stream_new(sess, t, &cli_conn->obj_type);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200277 if (!strm)
278 goto out_free_task;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200279
Christopher Fauletd7c91962015-04-30 11:48:27 +0200280 strm->target = sess->listener->default_target;
281 strm->req.analysers |= sess->listener->analysers;
282
Willy Tarreaud1769b82015-04-06 00:25:48 +0200283 return 1;
284
285 out_free_task:
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200286 task_free(t);
287 out_free_sess:
288 p->feconn--;
289 session_free(sess);
290 out_free_conn:
291 cli_conn->flags &= ~CO_FL_XPRT_TRACKED;
292 conn_xprt_close(cli_conn);
293 conn_free(cli_conn);
294 out_close:
295 if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
296 /* critical error, no more memory, try to emit a 500 response */
297 struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
298 if (!err_msg->str)
299 err_msg = &http_err_chunks[HTTP_ERR_500];
300 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
301 }
302
303 if (fdtab[cfd].owner)
304 fd_delete(cfd);
305 else
306 close(cfd);
307 return ret;
308}
309
310
311/* prepare the trash with a log prefix for session <sess>. It only works with
312 * embryonic sessions based on a real connection. This function requires that
313 * at sess->origin points to the incoming connection.
314 */
315static void session_prepare_log_prefix(struct session *sess)
316{
317 struct tm tm;
318 char pn[INET6_ADDRSTRLEN];
319 int ret;
320 char *end;
321 struct connection *cli_conn = __objt_conn(sess->origin);
322
323 ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
324 if (ret <= 0)
325 chunk_printf(&trash, "unknown [");
326 else if (ret == AF_UNIX)
327 chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
328 else
329 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
330
331 get_localtime(sess->accept_date.tv_sec, &tm);
332 end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len);
333 trash.len = end - trash.str;
334 if (sess->listener->name)
335 chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
336 else
337 chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
338}
339
340/* This function kills an existing embryonic session. It stops the connection's
341 * transport layer, releases assigned resources, resumes the listener if it was
342 * disabled and finally kills the file descriptor. This function requires that
343 * sess->origin points to the incoming connection.
344 */
345static void session_kill_embryonic(struct session *sess)
346{
347 int level = LOG_INFO;
348 struct connection *conn = __objt_conn(sess->origin);
349 struct task *task = conn->owner;
350 unsigned int log = sess->fe->to_log;
351 const char *err_msg;
352
353 if (sess->fe->options2 & PR_O2_LOGERRORS)
354 level = LOG_ERR;
355
356 if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
357 /* with "option dontlognull", we don't log connections with no transfer */
358 if (!conn->err_code ||
359 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100360 conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200361 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
362 log = 0;
363 }
364
365 if (log) {
366 if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {
367 if (conn->flags & CO_FL_ACCEPT_PROXY)
368 conn->err_code = CO_ER_PRX_TIMEOUT;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100369 else if (conn->flags & CO_FL_ACCEPT_CIP)
370 conn->err_code = CO_ER_CIP_TIMEOUT;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200371 else if (conn->flags & CO_FL_SSL_WAIT_HS)
372 conn->err_code = CO_ER_SSL_TIMEOUT;
373 }
374
375 session_prepare_log_prefix(sess);
376 err_msg = conn_err_code_str(conn);
377 if (err_msg)
378 send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg);
379 else
380 send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
381 trash.str, conn->err_code, conn->flags);
382 }
383
384 /* kill the connection now */
385 conn_force_close(conn);
386 conn_free(conn);
387
388 sess->fe->feconn--;
389
390 if (!(sess->listener->options & LI_O_UNLIMITED))
391 actconn--;
392 jobs--;
393 sess->listener->nbconn--;
394 if (sess->listener->state == LI_FULL)
395 resume_listener(sess->listener);
396
397 /* Dequeues all of the listeners waiting for a resource */
398 if (!LIST_ISEMPTY(&global_listener_queue))
399 dequeue_all_listeners(&global_listener_queue);
400
401 if (!LIST_ISEMPTY(&sess->fe->listener_queue) &&
402 (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0))
403 dequeue_all_listeners(&sess->fe->listener_queue);
404
405 task_delete(task);
406 task_free(task);
407 session_free(sess);
408}
409
410/* Manages the embryonic session timeout. It is only called when the timeout
411 * strikes and performs the required cleanup.
412 */
413static struct task *session_expire_embryonic(struct task *t)
414{
415 struct session *sess = t->context;
416
417 if (!(t->state & TASK_WOKEN_TIMER))
418 return t;
419
420 session_kill_embryonic(sess);
421 return NULL;
422}
423
424/* Finish initializing a session from a connection, or kills it if the
425 * connection shows and error. Returns <0 if the connection was killed.
426 */
427static int conn_complete_session(struct connection *conn)
428{
429 struct task *task = conn->owner;
430 struct session *sess = task->context;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200431 struct stream *strm;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200432
Willy Tarreaud1769b82015-04-06 00:25:48 +0200433 if (conn->flags & CO_FL_ERROR)
434 goto fail;
435
Willy Tarreau678be622015-04-08 18:18:15 +0200436 /* we want the connection handler to notify the stream interface about updates. */
437 conn->flags |= CO_FL_WAKE_DATA;
438
439 /* if logs require transport layer information, note it on the connection */
440 if (sess->fe->to_log & LW_XPRT)
441 conn->flags |= CO_FL_XPRT_TRACKED;
442
Willy Tarreau620408f2016-10-21 16:37:51 +0200443 /* we may have some tcp-request-session rules */
444 if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
445 goto fail;
446
Willy Tarreau042cd752015-04-08 18:10:49 +0200447 session_count_new(sess);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200448 task->process = sess->listener->handler;
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200449 strm = stream_new(sess, task, &conn->obj_type);
Willy Tarreaud1769b82015-04-06 00:25:48 +0200450 if (!strm)
451 goto fail;
452
Christopher Fauletd7c91962015-04-30 11:48:27 +0200453 strm->target = sess->listener->default_target;
454 strm->req.analysers |= sess->listener->analysers;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200455 conn->flags &= ~CO_FL_INIT_DATA;
Willy Tarreau678be622015-04-08 18:18:15 +0200456
Willy Tarreaud1769b82015-04-06 00:25:48 +0200457 return 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200458
Willy Tarreaud1769b82015-04-06 00:25:48 +0200459 fail:
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200460 session_kill_embryonic(sess);
461 return -1;
462}
463
464/* Update a session status. The connection is killed in case of
465 * error, and <0 will be returned. Otherwise it does nothing.
466 */
467static int conn_update_session(struct connection *conn)
468{
469 struct task *task = conn->owner;
470 struct session *sess = task->context;
471
472 if (conn->flags & CO_FL_ERROR) {
473 session_kill_embryonic(sess);
474 return -1;
475 }
476 return 0;
477}
478
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200479/*
480 * Local variables:
481 * c-indent-level: 8
482 * c-basic-offset: 8
483 * End:
484 */