blob: dc9754454684024f3c3b8a454a37889c257f799a [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);
Willy Tarreau9903f0e2015-04-04 18:50:31 +020034static struct task *session_expire_embryonic(struct task *t);
35
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;
44
45 sess = pool_alloc2(pool2_session);
46 if (sess) {
47 sess->listener = li;
48 sess->fe = fe;
49 sess->origin = origin;
50 sess->accept_date = date; /* user-visible date for logging */
51 sess->tv_accept = now; /* corrected date for internal use */
52 memset(sess->stkctr, 0, sizeof(sess->stkctr));
Willy Tarreauebcd4842015-06-19 11:59:02 +020053 vars_init(&sess->vars, SCOPE_SESS);
Willy Tarreau0b74eae2017-08-28 19:02:51 +020054 sess->task = NULL;
Christopher Fauletff8abcd2017-06-02 15:33:24 +020055 HA_ATOMIC_UPDATE_MAX(&fe->fe_counters.conn_max,
56 HA_ATOMIC_ADD(&fe->feconn, 1));
Willy Tarreau0bf6fa52017-09-15 10:25:14 +020057 if (li)
58 proxy_inc_fe_conn_ctr(li, fe);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +020059 HA_ATOMIC_ADD(&totalconn, 1);
60 HA_ATOMIC_ADD(&jobs, 1);
Willy Tarreauc38f71c2015-04-05 00:38:48 +020061 }
62 return sess;
63}
64
Willy Tarreau11c36242015-04-04 15:54:03 +020065void session_free(struct session *sess)
66{
Christopher Fauletff8abcd2017-06-02 15:33:24 +020067 HA_ATOMIC_SUB(&sess->fe->feconn, 1);
Willy Tarreau4f0c64c2017-10-18 15:01:14 +020068 if (sess->listener)
69 listener_release(sess->listener);
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);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +020073 HA_ATOMIC_SUB(&jobs, 1);
Willy Tarreau11c36242015-04-04 15:54:03 +020074}
75
Willy Tarreau3e13cba2017-10-08 11:26:30 +020076/* callback used from the connection/mux layer to notify that a connection is
77 * gonig to be released.
78 */
79void conn_session_free(struct connection *conn)
80{
81 session_free(conn->owner);
82}
83
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020084/* perform minimal intializations, report 0 in case of error, 1 if OK. */
85int init_session()
86{
87 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
88 return pool2_session != NULL;
89}
90
Willy Tarreau042cd752015-04-08 18:10:49 +020091/* count a new session to keep frontend, listener and track stats up to date */
92static void session_count_new(struct session *sess)
93{
94 struct stkctr *stkctr;
95 void *ptr;
96 int i;
97
98 proxy_inc_fe_sess_ctr(sess->listener, sess->fe);
99
100 for (i = 0; i < MAX_SESS_STKCTR; i++) {
101 stkctr = &sess->stkctr[i];
102 if (!stkctr_entry(stkctr))
103 continue;
104
105 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
106 if (ptr)
107 stktable_data_cast(ptr, sess_cnt)++;
108
109 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
110 if (ptr)
111 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
112 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
113 }
114}
115
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200116/* This function is called from the protocol layer accept() in order to
117 * instanciate a new session on behalf of a given listener and frontend. It
118 * returns a positive value upon success, 0 if the connection can be ignored,
119 * or a negative value upon critical failure. The accepted file descriptor is
120 * closed if we return <= 0. If no handshake is needed, it immediately tries
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200121 * to instanciate a new stream. The created connection's owner points to the
122 * new session until the upper layers are created.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200123 */
124int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr)
125{
126 struct connection *cli_conn;
Willy Tarreauc95bad52016-12-22 00:13:31 +0100127 struct proxy *p = l->bind_conf->frontend;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200128 struct session *sess;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200129 int ret;
130
131
132 ret = -1; /* assume unrecoverable error by default */
133
134 if (unlikely((cli_conn = conn_new()) == NULL))
135 goto out_close;
136
Willy Tarreau71a8c7c2016-12-21 22:04:54 +0100137 conn_prepare(cli_conn, l->proto, l->bind_conf->xprt);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200138
Willy Tarreau585744b2017-08-24 14:31:19 +0200139 cli_conn->handle.fd = cfd;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200140 cli_conn->addr.from = *addr;
141 cli_conn->flags |= CO_FL_ADDR_FROM_SET;
142 cli_conn->target = &l->obj_type;
143 cli_conn->proxy_netns = l->netns;
144
145 conn_ctrl_init(cli_conn);
146
147 /* wait for a PROXY protocol header */
148 if (l->options & LI_O_ACC_PROXY) {
149 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
150 conn_sock_want_recv(cli_conn);
151 }
152
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100153 /* wait for a NetScaler client IP insertion protocol header */
154 if (l->options & LI_O_ACC_CIP) {
155 cli_conn->flags |= CO_FL_ACCEPT_CIP;
156 conn_sock_want_recv(cli_conn);
157 }
158
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200159 conn_xprt_want_recv(cli_conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200160 if (conn_xprt_init(cli_conn) < 0)
161 goto out_free_conn;
162
Willy Tarreau64beab22015-04-05 00:39:16 +0200163 sess = session_new(p, l, &cli_conn->obj_type);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200164 if (!sess)
165 goto out_free_conn;
166
Willy Tarreau436d3332017-10-08 11:16:46 +0200167 conn_set_owner(cli_conn, sess, NULL);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200168
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200169 /* now evaluate the tcp-request layer4 rules. We only need a session
170 * and no stream for these rules.
171 */
Willy Tarreau7d9736f2016-10-21 16:34:21 +0200172 if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200173 /* let's do a no-linger now to close with a single RST. */
174 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
175 ret = 0; /* successful termination */
176 goto out_free_sess;
177 }
178
179 /* monitor-net and health mode are processed immediately after TCP
180 * connection rules. This way it's possible to block them, but they
181 * never use the lower data layers, they send directly over the socket,
182 * as they were designed for. We first flush the socket receive buffer
183 * in order to avoid emission of an RST by the system. We ignore any
184 * error.
185 */
186 if (unlikely((p->mode == PR_MODE_HEALTH) ||
187 ((l->options & LI_O_CHK_MONNET) &&
188 addr->ss_family == AF_INET &&
189 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
190 /* we have 4 possibilities here :
191 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
192 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
193 * - HEALTH mode without HTTP check => just send "OK"
194 * - TCP mode from monitoring address => just close
195 */
196 if (l->proto->drain)
197 l->proto->drain(cfd);
198 if (p->mode == PR_MODE_HTTP ||
199 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
200 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
201 else if (p->mode == PR_MODE_HEALTH)
202 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
203 ret = 0;
204 goto out_free_sess;
205 }
206
Willy Tarreauf9d1bc62015-04-05 17:56:47 +0200207 /* Adjust some socket options */
208 if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) {
209 setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one));
210
211 if (p->options & PR_O_TCP_CLI_KA)
212 setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
213
214 if (p->options & PR_O_TCP_NOLING)
215 fdtab[cfd].linger_risk = 1;
216
217#if defined(TCP_MAXSEG)
218 if (l->maxseg < 0) {
219 /* we just want to reduce the current MSS by that value */
220 int mss;
221 socklen_t mss_len = sizeof(mss);
222 if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) {
223 mss += l->maxseg; /* remember, it's < 0 */
224 setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss));
225 }
226 }
227#endif
228 }
229
230 if (global.tune.client_sndbuf)
231 setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf));
232
233 if (global.tune.client_rcvbuf)
234 setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf));
235
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200236 /* OK, now either we have a pending handshake to execute with and then
237 * we must return to the I/O layer, or we can proceed with the end of
238 * the stream initialization. In case of handshake, we also set the I/O
239 * timeout to the frontend's client timeout and register a task in the
240 * session for this purpose. The connection's owner is left to the
241 * session during this period.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200242 *
243 * At this point we set the relation between sess/task/conn this way :
244 *
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200245 * +----------------- task
246 * | |
247 * orig -- sess <-- context |
248 * | ^ | |
249 * v | | |
250 * conn -- owner ---> task <-----+
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200251 */
Olivier Houchardc2aae742017-09-22 18:26:28 +0200252 if (cli_conn->flags & (CO_FL_HANDSHAKE | CO_FL_EARLY_SSL_HS)) {
Emeric Brunc60def82017-09-27 14:59:38 +0200253 if (unlikely((sess->task = task_new(tid_bit)) == NULL))
Willy Tarreau87787ac2017-08-28 16:22:54 +0200254 goto out_free_sess;
255
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200256 conn_set_xprt_done_cb(cli_conn, conn_complete_session);
Willy Tarreau87787ac2017-08-28 16:22:54 +0200257
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200258 sess->task->context = sess;
259 sess->task->nice = l->nice;
260 sess->task->process = session_expire_embryonic;
261 sess->task->expire = tick_add_ifset(now_ms, p->timeout.client);
262 task_queue(sess->task);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200263 return 1;
264 }
265
Willy Tarreau18b95a42015-04-05 01:04:01 +0200266 /* OK let's complete stream initialization since there is no handshake */
267 cli_conn->flags |= CO_FL_CONNECTED;
Willy Tarreau042cd752015-04-08 18:10:49 +0200268
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200269 if (conn_complete_session(cli_conn) >= 0)
270 return 1;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200271
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200272 /* error unrolling */
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200273 out_free_sess:
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200274 session_free(sess);
275 out_free_conn:
Willy Tarreau5b78a9d2017-10-05 18:12:51 +0200276 conn_stop_tracking(cli_conn);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200277 conn_xprt_close(cli_conn);
278 conn_free(cli_conn);
279 out_close:
Willy Tarreaua261e9b2016-12-22 20:44:00 +0100280 if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) && p->mode == PR_MODE_HTTP) {
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200281 /* critical error, no more memory, try to emit a 500 response */
282 struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
283 if (!err_msg->str)
284 err_msg = &http_err_chunks[HTTP_ERR_500];
285 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
286 }
287
288 if (fdtab[cfd].owner)
289 fd_delete(cfd);
290 else
291 close(cfd);
292 return ret;
293}
294
295
296/* prepare the trash with a log prefix for session <sess>. It only works with
297 * embryonic sessions based on a real connection. This function requires that
298 * at sess->origin points to the incoming connection.
299 */
300static void session_prepare_log_prefix(struct session *sess)
301{
302 struct tm tm;
303 char pn[INET6_ADDRSTRLEN];
304 int ret;
305 char *end;
306 struct connection *cli_conn = __objt_conn(sess->origin);
307
308 ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
309 if (ret <= 0)
310 chunk_printf(&trash, "unknown [");
311 else if (ret == AF_UNIX)
312 chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
313 else
314 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
315
316 get_localtime(sess->accept_date.tv_sec, &tm);
317 end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len);
318 trash.len = end - trash.str;
319 if (sess->listener->name)
320 chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
321 else
322 chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
323}
324
325/* This function kills an existing embryonic session. It stops the connection's
326 * transport layer, releases assigned resources, resumes the listener if it was
327 * disabled and finally kills the file descriptor. This function requires that
328 * sess->origin points to the incoming connection.
329 */
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200330static void session_kill_embryonic(struct session *sess)
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200331{
332 int level = LOG_INFO;
333 struct connection *conn = __objt_conn(sess->origin);
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200334 struct task *task = sess->task;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200335 unsigned int log = sess->fe->to_log;
336 const char *err_msg;
337
338 if (sess->fe->options2 & PR_O2_LOGERRORS)
339 level = LOG_ERR;
340
341 if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
342 /* with "option dontlognull", we don't log connections with no transfer */
343 if (!conn->err_code ||
344 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100345 conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT ||
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200346 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
347 log = 0;
348 }
349
350 if (log) {
351 if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {
352 if (conn->flags & CO_FL_ACCEPT_PROXY)
353 conn->err_code = CO_ER_PRX_TIMEOUT;
Bertrand Jacquin93b227d2016-06-04 15:11:10 +0100354 else if (conn->flags & CO_FL_ACCEPT_CIP)
355 conn->err_code = CO_ER_CIP_TIMEOUT;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200356 else if (conn->flags & CO_FL_SSL_WAIT_HS)
357 conn->err_code = CO_ER_SSL_TIMEOUT;
358 }
359
360 session_prepare_log_prefix(sess);
361 err_msg = conn_err_code_str(conn);
362 if (err_msg)
363 send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg);
364 else
365 send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
366 trash.str, conn->err_code, conn->flags);
367 }
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);
373
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200374 task_delete(task);
375 task_free(task);
376 session_free(sess);
377}
378
379/* Manages the embryonic session timeout. It is only called when the timeout
380 * strikes and performs the required cleanup.
381 */
382static struct task *session_expire_embryonic(struct task *t)
383{
384 struct session *sess = t->context;
385
386 if (!(t->state & TASK_WOKEN_TIMER))
387 return t;
388
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200389 session_kill_embryonic(sess);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200390 return NULL;
391}
392
393/* Finish initializing a session from a connection, or kills it if the
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200394 * connection shows and error. Returns <0 if the connection was killed. It may
395 * be called either asynchronously as an xprt_done callback with an embryonic
396 * session, or synchronously to finalize the session. The distinction is made
397 * on sess->task which is only set in the embryonic session case.
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200398 */
399static int conn_complete_session(struct connection *conn)
400{
Willy Tarreau0b74eae2017-08-28 19:02:51 +0200401 struct session *sess = conn->owner;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200402
Willy Tarreau8e3c6ce2017-08-28 15:46:01 +0200403 conn_clear_xprt_done_cb(conn);
404
Willy Tarreaud1769b82015-04-06 00:25:48 +0200405 if (conn->flags & CO_FL_ERROR)
406 goto fail;
407
Willy Tarreau678be622015-04-08 18:18:15 +0200408 /* if logs require transport layer information, note it on the connection */
409 if (sess->fe->to_log & LW_XPRT)
410 conn->flags |= CO_FL_XPRT_TRACKED;
411
Willy Tarreau620408f2016-10-21 16:37:51 +0200412 /* we may have some tcp-request-session rules */
413 if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess))
414 goto fail;
415
Willy Tarreau042cd752015-04-08 18:10:49 +0200416 session_count_new(sess);
Willy Tarreau2e0b2b52017-09-15 06:59:55 +0200417 if (conn_install_best_mux(conn, sess->fe->mode == PR_MODE_HTTP, NULL) < 0)
Willy Tarreaud1769b82015-04-06 00:25:48 +0200418 goto fail;
419
Willy Tarreau87787ac2017-08-28 16:22:54 +0200420 /* the embryonic session's task is not needed anymore */
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200421 if (sess->task) {
422 task_delete(sess->task);
423 task_free(sess->task);
424 sess->task = NULL;
425 }
Willy Tarreau3e13cba2017-10-08 11:26:30 +0200426
427 conn_set_owner(conn, sess, conn_session_free);
428
Willy Tarreaud1769b82015-04-06 00:25:48 +0200429 return 0;
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200430
Willy Tarreaud1769b82015-04-06 00:25:48 +0200431 fail:
Willy Tarreau0c4ed352017-09-15 10:06:28 +0200432 if (sess->task)
433 session_kill_embryonic(sess);
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200434 return -1;
435}
436
Willy Tarreaub1ec8c42015-04-03 13:53:24 +0200437/*
438 * Local variables:
439 * c-indent-level: 8
440 * c-basic-offset: 8
441 * End:
442 */