blob: 677d3a1a643851ebe8fda5c766e5962e88a90ca8 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreau81f9aa32010-06-01 17:45:26 +02002 * Session management functions.
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 *
Willy Tarreaud28c3532012-04-19 19:28:33 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +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 <stdlib.h>
Willy Tarreau81f9aa32010-06-01 17:45:26 +020014#include <unistd.h>
15#include <fcntl.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020016
17#include <common/config.h>
Willy Tarreau9b28e032012-10-12 23:49:43 +020018#include <common/buffer.h>
Willy Tarreau7c669d72008-06-20 15:04:11 +020019#include <common/debug.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020020#include <common/memory.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020021
Willy Tarreaubaaee002006-06-26 02:48:02 +020022#include <types/capture.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010023#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreau1d0dfb12009-07-07 15:10:31 +020025#include <proto/acl.h>
Willy Tarreau61612d42012-04-19 18:42:05 +020026#include <proto/arg.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010027#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020028#include <proto/channel.h>
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010029#include <proto/checks.h>
Willy Tarreaud2274c62012-07-06 14:29:45 +020030#include <proto/connection.h>
Willy Tarreau5ca791d2009-08-16 19:06:42 +020031#include <proto/dumpstats.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020032#include <proto/fd.h>
Willy Tarreau91c43d72010-06-20 11:19:22 +020033#include <proto/freq_ctr.h>
Willy Tarreau3041b9f2010-10-15 23:25:20 +020034#include <proto/frontend.h>
Willy Tarreau8d5d7f22007-01-21 19:16:41 +010035#include <proto/hdr_idx.h>
Thierry FOURNIER65f34c62015-02-16 20:11:43 +010036#include <proto/hlua.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020037#include <proto/listener.h>
Willy Tarreau332f8bf2007-05-13 21:36:56 +020038#include <proto/log.h>
Willy Tarreaucbaaec42012-09-06 11:32:07 +020039#include <proto/raw_sock.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040#include <proto/session.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010041#include <proto/pipe.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010042#include <proto/proto_http.h>
43#include <proto/proto_tcp.h>
Willy Tarreau1d0dfb12009-07-07 15:10:31 +020044#include <proto/proxy.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020045#include <proto/queue.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +010046#include <proto/server.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020047#include <proto/sample.h>
Emeric Brun1d33b292010-01-04 15:47:17 +010048#include <proto/stick_table.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010049#include <proto/stream_interface.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010050#include <proto/task.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020051
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020052struct pool_head *pool2_session;
Willy Tarreauf54f8bd2008-11-23 19:53:55 +010053struct list sessions;
Willy Tarreaubaaee002006-06-26 02:48:02 +020054
Willy Tarreaubf883e02014-11-25 21:10:35 +010055/* list of sessions waiting for at least one buffer */
56struct list buffer_wq = LIST_HEAD_INIT(buffer_wq);
57
Willy Tarreau071e1372012-10-03 01:39:48 +020058static int conn_session_complete(struct connection *conn);
Willy Tarreau9683e9a2012-10-03 21:17:23 +020059static int conn_session_update(struct connection *conn);
Willy Tarreau2542b532012-08-31 16:01:23 +020060static struct task *expire_mini_session(struct task *t);
61int session_complete(struct session *s);
62
Willy Tarreau5e75e272012-10-02 21:21:20 +020063/* data layer callbacks for an embryonic session */
64struct data_cb sess_conn_cb = {
65 .recv = NULL,
66 .send = NULL,
Willy Tarreau9683e9a2012-10-03 21:17:23 +020067 .wake = conn_session_update,
Willy Tarreau071e1372012-10-03 01:39:48 +020068 .init = conn_session_complete,
Willy Tarreau5e75e272012-10-02 21:21:20 +020069};
70
Willy Tarreau2542b532012-08-31 16:01:23 +020071/* This function is called from the protocol layer accept() in order to
72 * instanciate a new embryonic session on behalf of a given listener and
73 * frontend. It returns a positive value upon success, 0 if the connection
74 * can be ignored, or a negative value upon critical failure. The accepted
75 * file descriptor is closed if we return <= 0.
Willy Tarreau81f9aa32010-06-01 17:45:26 +020076 */
77int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
78{
Willy Tarreaub363a1f2013-10-01 10:45:07 +020079 struct connection *cli_conn;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020080 struct proxy *p = l->frontend;
81 struct session *s;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020082 struct task *t;
Willy Tarreauabe8ea52010-11-11 10:56:04 +010083 int ret;
84
85
86 ret = -1; /* assume unrecoverable error by default */
Willy Tarreau81f9aa32010-06-01 17:45:26 +020087
Willy Tarreau32e3c6a2013-10-11 19:34:20 +020088 if (unlikely((cli_conn = conn_new()) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +020089 goto out_close;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020090
Willy Tarreau32e3c6a2013-10-11 19:34:20 +020091 conn_prepare(cli_conn, l->proto, l->xprt);
Willy Tarreauf2943dc2012-10-26 20:10:28 +020092
Willy Tarreau32e3c6a2013-10-11 19:34:20 +020093 cli_conn->t.sock.fd = cfd;
94 cli_conn->addr.from = *addr;
95 cli_conn->flags |= CO_FL_ADDR_FROM_SET;
96 cli_conn->target = &l->obj_type;
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +010097 cli_conn->proxy_netns = l->netns;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +020098
99 if (unlikely((s = pool_alloc2(pool2_session)) == NULL))
100 goto out_free_conn;
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200101
Willy Tarreau2542b532012-08-31 16:01:23 +0200102 /* minimum session initialization required for an embryonic session is
103 * fairly low. We need very little to execute L4 ACLs, then we need a
104 * task to make the client-side connection live on its own.
105 * - flags
106 * - stick-entry tracking
107 */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200108 s->flags = 0;
109 s->logs.logwait = p->to_log;
Willy Tarreau9a355ec2013-06-11 17:45:46 +0200110 s->logs.level = 0;
Willy Tarreaud5ca9ab2013-05-28 17:40:25 +0200111
Thierry FOURNIERbc4c1ac2015-02-25 13:36:14 +0100112 /* Initialise the current rule list pointer to NULL. We are sure that
113 * any rulelist match the NULL pointer.
114 */
115 s->current_rule_list = NULL;
116
Willy Tarreaud5ca9ab2013-05-28 17:40:25 +0200117 memset(s->stkctr, 0, sizeof(s->stkctr));
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200118
Willy Tarreau2542b532012-08-31 16:01:23 +0200119 s->listener = l;
120 s->fe = p;
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100121
Willy Tarreaua5f5d8d2014-11-28 11:26:07 +0100122 s->si[0].flags = SI_FL_NONE;
123 s->si[1].flags = SI_FL_ISBACK;
124
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200125 /* On a mini-session, the connection is directly attached to the
126 * session's target so that we don't need to initialize the stream
127 * interfaces. Another benefit is that it's easy to detect a mini-
128 * session in dumps using this : it's the only one which has a
129 * connection in s->target.
130 */
131 s->target = &cli_conn->obj_type;
132
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200133 s->logs.accept_date = date; /* user-visible date for logging */
134 s->logs.tv_accept = now; /* corrected date for internal use */
Willy Tarreau1f0da242014-01-25 11:01:50 +0100135 s->uniq_id = global.req_count++;
Willy Tarreau2542b532012-08-31 16:01:23 +0200136 p->feconn++;
137 /* This session was accepted, count it now */
138 if (p->feconn > p->fe_counters.conn_max)
139 p->fe_counters.conn_max = p->feconn;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200140
Willy Tarreau2542b532012-08-31 16:01:23 +0200141 proxy_inc_fe_conn_ctr(l, p);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200142
Willy Tarreau59e3ff42013-12-16 02:16:50 +0100143 /* Add the minimum callbacks to prepare the connection's control layer.
144 * We need this so that we can safely execute the ACLs used by the
145 * "tcp-request connection" ruleset. We also carefully attach the
146 * connection to the stream interface without initializing the rest,
147 * so that ACLs can use si[0]->end.
148 */
149 si_attach_conn(&s->si[0], cli_conn);
150 conn_attach(cli_conn, s, &sess_conn_cb);
151 conn_ctrl_init(cli_conn);
152
Willy Tarreau2cff2f72013-12-16 10:12:54 +0100153 /* now evaluate the tcp-request layer4 rules. Since we expect to be able
154 * to abort right here as soon as possible, we check the rules before
155 * even initializing the stream interfaces.
156 */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200157 if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(s)) {
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200158 /* let's do a no-linger now to close with a single RST. */
159 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100160 ret = 0; /* successful termination */
Willy Tarreau2542b532012-08-31 16:01:23 +0200161 goto out_free_session;
162 }
163
Willy Tarreau82569f92012-09-27 23:48:56 +0200164 /* monitor-net and health mode are processed immediately after TCP
165 * connection rules. This way it's possible to block them, but they
166 * never use the lower data layers, they send directly over the socket,
167 * as they were designed for. We first flush the socket receive buffer
168 * in order to avoid emission of an RST by the system. We ignore any
169 * error.
170 */
171 if (unlikely((p->mode == PR_MODE_HEALTH) ||
172 ((l->options & LI_O_CHK_MONNET) &&
173 addr->ss_family == AF_INET &&
174 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
175 /* we have 4 possibilities here :
176 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
177 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
178 * - HEALTH mode without HTTP check => just send "OK"
179 * - TCP mode from monitoring address => just close
180 */
Willy Tarreau2b57cb82013-06-10 19:56:38 +0200181 if (l->proto->drain)
182 l->proto->drain(cfd);
Willy Tarreau82569f92012-09-27 23:48:56 +0200183 if (p->mode == PR_MODE_HTTP ||
184 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
185 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
186 else if (p->mode == PR_MODE_HEALTH)
187 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
188 ret = 0;
189 goto out_free_session;
190 }
191
Willy Tarreau22cda212012-08-31 17:43:29 +0200192 /* wait for a PROXY protocol header */
193 if (l->options & LI_O_ACC_PROXY) {
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200194 cli_conn->flags |= CO_FL_ACCEPT_PROXY;
195 conn_sock_want_recv(cli_conn);
Willy Tarreau22cda212012-08-31 17:43:29 +0200196 }
197
Willy Tarreau2542b532012-08-31 16:01:23 +0200198 if (unlikely((t = task_new()) == NULL))
199 goto out_free_session;
200
201 t->context = s;
202 t->nice = l->nice;
203 s->task = t;
204
Willy Tarreau59e3ff42013-12-16 02:16:50 +0100205 /* Finish setting the callbacks. Right now the transport layer is present
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200206 * but not initialized. Also note we need to be careful as the stream
207 * int is not initialized yet.
Willy Tarreau2542b532012-08-31 16:01:23 +0200208 */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200209 conn_data_want_recv(cli_conn);
210 if (conn_xprt_init(cli_conn) < 0)
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100211 goto out_free_task;
Willy Tarreau2542b532012-08-31 16:01:23 +0200212
213 /* OK, now either we have a pending handshake to execute with and
214 * then we must return to the I/O layer, or we can proceed with the
215 * end of the session initialization. In case of handshake, we also
216 * set the I/O timeout to the frontend's client timeout.
217 */
218
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200219 if (cli_conn->flags & CO_FL_HANDSHAKE) {
Willy Tarreau2542b532012-08-31 16:01:23 +0200220 t->process = expire_mini_session;
221 t->expire = tick_add_ifset(now_ms, p->timeout.client);
222 task_queue(t);
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200223 cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200224 return 1;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200225 }
226
Willy Tarreau815f5ec2012-11-06 00:14:25 +0100227 /* OK let's complete session initialization since there is no handshake */
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200228 cli_conn->flags |= CO_FL_CONNECTED;
Willy Tarreau2542b532012-08-31 16:01:23 +0200229 ret = session_complete(s);
230 if (ret > 0)
231 return ret;
232
233 /* Error unrolling */
234 out_free_task:
235 task_free(t);
236 out_free_session:
237 p->feconn--;
Willy Tarreaue9101692014-01-28 22:48:24 +0100238 session_store_counters(s);
Willy Tarreau2542b532012-08-31 16:01:23 +0200239 pool_free2(pool2_session, s);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200240 out_free_conn:
241 cli_conn->flags &= ~CO_FL_XPRT_TRACKED;
242 conn_xprt_close(cli_conn);
243 conn_free(cli_conn);
Willy Tarreau2542b532012-08-31 16:01:23 +0200244 out_close:
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200245 if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
Willy Tarreau2542b532012-08-31 16:01:23 +0200246 /* critical error, no more memory, try to emit a 500 response */
Willy Tarreau05bf5e12013-10-20 23:10:28 +0200247 struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
248 if (!err_msg->str)
249 err_msg = &http_err_chunks[HTTP_ERR_500];
Willy Tarreau2542b532012-08-31 16:01:23 +0200250 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
251 }
252
253 if (fdtab[cfd].owner)
254 fd_delete(cfd);
255 else
256 close(cfd);
257 return ret;
258}
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100259
Willy Tarreau0af29122012-12-03 15:35:00 +0100260
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200261/* prepare the trash with a log prefix for session <s>. It only works with
Willy Tarreaub4f98092014-05-08 21:06:11 +0200262 * embryonic sessions based on a real connection. This function requires that
263 * at s->target still points to the incoming connection.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200264 */
Willy Tarreau0af29122012-12-03 15:35:00 +0100265static void prepare_mini_sess_log_prefix(struct session *s)
266{
267 struct tm tm;
268 char pn[INET6_ADDRSTRLEN];
269 int ret;
270 char *end;
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200271 struct connection *cli_conn = __objt_conn(s->target);
Willy Tarreau0af29122012-12-03 15:35:00 +0100272
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200273 ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
Willy Tarreau0af29122012-12-03 15:35:00 +0100274 if (ret <= 0)
275 chunk_printf(&trash, "unknown [");
276 else if (ret == AF_UNIX)
277 chunk_printf(&trash, "%s:%d [", pn, s->listener->luid);
278 else
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200279 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
Willy Tarreau0af29122012-12-03 15:35:00 +0100280
281 get_localtime(s->logs.accept_date.tv_sec, &tm);
282 end = date2str_log(trash.str + trash.len, &tm, &(s->logs.accept_date), trash.size - trash.len);
283 trash.len = end - trash.str;
284 if (s->listener->name)
285 chunk_appendf(&trash, "] %s/%s", s->fe->id, s->listener->name);
286 else
287 chunk_appendf(&trash, "] %s/%d", s->fe->id, s->listener->luid);
288}
289
Willy Tarreau2542b532012-08-31 16:01:23 +0200290/* This function kills an existing embryonic session. It stops the connection's
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200291 * transport layer, releases assigned resources, resumes the listener if it was
Willy Tarreaub4f98092014-05-08 21:06:11 +0200292 * disabled and finally kills the file descriptor. This function requires that
293 * at s->target still points to the incoming connection.
Willy Tarreau2542b532012-08-31 16:01:23 +0200294 */
295static void kill_mini_session(struct session *s)
296{
Willy Tarreau0af29122012-12-03 15:35:00 +0100297 int level = LOG_INFO;
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200298 struct connection *conn = __objt_conn(s->target);
Willy Tarreau0af29122012-12-03 15:35:00 +0100299 unsigned int log = s->logs.logwait;
300 const char *err_msg;
301
302 if (s->fe->options2 & PR_O2_LOGERRORS)
303 level = LOG_ERR;
304
305 if (log && (s->fe->options & PR_O_NULLNOLOG)) {
306 /* with "option dontlognull", we don't log connections with no transfer */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100307 if (!conn->err_code ||
Willy Tarreau20879a02012-12-03 16:32:10 +0100308 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
309 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
Willy Tarreau0af29122012-12-03 15:35:00 +0100310 log = 0;
311 }
312
313 if (log) {
314 if (!conn->err_code && (s->task->state & TASK_WOKEN_TIMER)) {
315 if (conn->flags & CO_FL_ACCEPT_PROXY)
316 conn->err_code = CO_ER_PRX_TIMEOUT;
317 else if (conn->flags & CO_FL_SSL_WAIT_HS)
318 conn->err_code = CO_ER_SSL_TIMEOUT;
319 }
320
321 prepare_mini_sess_log_prefix(s);
322 err_msg = conn_err_code_str(conn);
323 if (err_msg)
324 send_log(s->fe, level, "%s: %s\n", trash.str, err_msg);
325 else
326 send_log(s->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
327 trash.str, conn->err_code, conn->flags);
328 }
329
Willy Tarreau2542b532012-08-31 16:01:23 +0200330 /* kill the connection now */
Willy Tarreauf79c8172013-10-21 16:30:56 +0200331 conn_force_close(conn);
Willy Tarreaua23ee3a2014-02-05 00:18:47 +0100332 conn_free(conn);
Willy Tarreau2542b532012-08-31 16:01:23 +0200333
334 s->fe->feconn--;
Willy Tarreau7af7d592013-07-01 18:07:03 +0200335 session_store_counters(s);
Willy Tarreau2542b532012-08-31 16:01:23 +0200336
337 if (!(s->listener->options & LI_O_UNLIMITED))
338 actconn--;
339 jobs--;
340 s->listener->nbconn--;
341 if (s->listener->state == LI_FULL)
342 resume_listener(s->listener);
343
344 /* Dequeues all of the listeners waiting for a resource */
345 if (!LIST_ISEMPTY(&global_listener_queue))
346 dequeue_all_listeners(&global_listener_queue);
347
348 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
349 (!s->fe->fe_sps_lim || freq_ctr_remain(&s->fe->fe_sess_per_sec, s->fe->fe_sps_lim, 0) > 0))
350 dequeue_all_listeners(&s->fe->listener_queue);
351
352 task_delete(s->task);
353 task_free(s->task);
Willy Tarreau2542b532012-08-31 16:01:23 +0200354 pool_free2(pool2_session, s);
355}
356
Willy Tarreau22cda212012-08-31 17:43:29 +0200357/* Finish initializing a session from a connection, or kills it if the
358 * connection shows and error. Returns <0 if the connection was killed.
Willy Tarreau2542b532012-08-31 16:01:23 +0200359 */
Willy Tarreau071e1372012-10-03 01:39:48 +0200360static int conn_session_complete(struct connection *conn)
Willy Tarreau2542b532012-08-31 16:01:23 +0200361{
Willy Tarreau5e75e272012-10-02 21:21:20 +0200362 struct session *s = conn->owner;
Willy Tarreau2542b532012-08-31 16:01:23 +0200363
Willy Tarreau22cda212012-08-31 17:43:29 +0200364 if (!(conn->flags & CO_FL_ERROR) && (session_complete(s) > 0)) {
Willy Tarreau071e1372012-10-03 01:39:48 +0200365 conn->flags &= ~CO_FL_INIT_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200366 return 0;
367 }
368
369 /* kill the connection now */
370 kill_mini_session(s);
371 return -1;
372}
373
Willy Tarreau9683e9a2012-10-03 21:17:23 +0200374/* Update an embryonic session status. The connection is killed in case of
375 * error, and <0 will be returned. Otherwise it does nothing.
376 */
377static int conn_session_update(struct connection *conn)
378{
379 if (conn->flags & CO_FL_ERROR) {
380 kill_mini_session(conn->owner);
381 return -1;
382 }
383 return 0;
384}
385
Willy Tarreau2542b532012-08-31 16:01:23 +0200386/* Manages embryonic sessions timeout. It is only called when the timeout
387 * strikes and performs the required cleanup.
388 */
389static struct task *expire_mini_session(struct task *t)
390{
391 struct session *s = t->context;
392
393 if (!(t->state & TASK_WOKEN_TIMER))
394 return t;
395
396 kill_mini_session(s);
397 return NULL;
398}
399
400/* This function is called from the I/O handler which detects the end of
401 * handshake, in order to complete initialization of a valid session. It must
402 * be called with an embryonic session. It returns a positive value upon
403 * success, 0 if the connection can be ignored, or a negative value upon
404 * critical failure. The accepted file descriptor is closed if we return <= 0.
Willy Tarreaub4f98092014-05-08 21:06:11 +0200405 * The client-side end point is assumed to be a connection, whose pointer is
406 * taken from s->target which is assumed to be valid. If the function fails,
407 * it restores s->target.
Willy Tarreau2542b532012-08-31 16:01:23 +0200408 */
409int session_complete(struct session *s)
410{
411 struct listener *l = s->listener;
412 struct proxy *p = s->fe;
413 struct http_txn *txn;
414 struct task *t = s->task;
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200415 struct connection *conn = __objt_conn(s->target);
Willy Tarreau2542b532012-08-31 16:01:23 +0200416 int ret;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100417 int i;
Willy Tarreau2542b532012-08-31 16:01:23 +0200418
419 ret = -1; /* assume unrecoverable error by default */
420
421 /* OK, we're keeping the session, so let's properly initialize the session */
422 LIST_ADDQ(&sessions, &s->list);
423 LIST_INIT(&s->back_refs);
Willy Tarreaubf883e02014-11-25 21:10:35 +0100424 LIST_INIT(&s->buffer_wait);
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200425
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200426 s->flags |= SN_INITIALIZED;
Willy Tarreau2542b532012-08-31 16:01:23 +0200427 s->unique_id = NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200428
429 t->process = l->handler;
430 t->context = s;
431 t->expire = TICK_ETERNITY;
432
433 /* Note: initially, the session's backend points to the frontend.
434 * This changes later when switching rules are executed or
435 * when the default backend is assigned.
436 */
437 s->be = s->fe;
William Lallemand82fe75c2012-10-23 10:25:10 +0200438 s->comp_algo = NULL;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100439 s->req.buf = s->res.buf = NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200440
441 /* Let's count a session now */
Willy Tarreaub36b4242010-06-04 20:59:39 +0200442 proxy_inc_fe_sess_ctr(l, p);
Willy Tarreau91c43d72010-06-20 11:19:22 +0200443
Willy Tarreaub4c84932013-07-23 19:15:30 +0200444 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200445 void *ptr;
446
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100447 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100448 continue;
449
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100450 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_SESS_CNT);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200451 if (ptr)
452 stktable_data_cast(ptr, sess_cnt)++;
453
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100454 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_SESS_RATE);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200455 if (ptr)
456 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau20d46a52012-12-09 15:55:40 +0100457 s->stkctr[i].table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200458 }
459
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200460 /* this part should be common with other protocols */
Willy Tarreau819d3322014-11-28 12:12:34 +0100461 si_reset(&s->si[0]);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200462 si_set_state(&s->si[0], SI_ST_EST);
463
Willy Tarreaub4f98092014-05-08 21:06:11 +0200464 /* attach the incoming connection to the stream interface now.
465 * We must do that *before* clearing ->target because we need
466 * to keep a pointer to the connection in case we have to call
467 * kill_mini_session().
468 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200469 si_attach_conn(&s->si[0], conn);
470
471 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
472 s->si[0].flags |= SI_FL_INDEP_STR;
473
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200474 /* pre-initialize the other side's stream interface to an INIT state. The
475 * callbacks will be initialized before attempting to connect.
476 */
Willy Tarreau819d3322014-11-28 12:12:34 +0100477 si_reset(&s->si[1]);
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200478 si_detach(&s->si[1]);
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200479
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200480 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
481 s->si[1].flags |= SI_FL_INDEP_STR;
482
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200483 session_init_srv_conn(s);
Willy Tarreau10b688f2015-03-13 16:43:12 +0100484 s->target = l->default_target; /* used by peers and CLI */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200485 s->pend_pos = NULL;
486
487 /* init store persistence */
488 s->store_count = 0;
489
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100490 channel_init(&s->req);
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100491 s->req.flags |= CF_READ_ATTACHED; /* the producer is already connected */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200492
493 /* activate default analysers enabled for this listener */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100494 s->req.analysers = l->analysers;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200495
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100496 s->req.wto = TICK_ETERNITY;
497 s->req.rto = TICK_ETERNITY;
498 s->req.rex = TICK_ETERNITY;
499 s->req.wex = TICK_ETERNITY;
500 s->req.analyse_exp = TICK_ETERNITY;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200501
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100502 channel_init(&s->res);
Willy Tarreauef573c02014-11-28 14:17:09 +0100503 s->res.flags |= CF_ISRESP;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100504 s->res.analysers = 0;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200505
Willy Tarreau96e31212011-05-30 18:10:30 +0200506 if (s->fe->options2 & PR_O2_NODELAY) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100507 s->req.flags |= CF_NEVER_WAIT;
508 s->res.flags |= CF_NEVER_WAIT;
Willy Tarreau96e31212011-05-30 18:10:30 +0200509 }
510
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100511 s->res.rto = TICK_ETERNITY;
512 s->res.wto = TICK_ETERNITY;
513 s->res.rex = TICK_ETERNITY;
514 s->res.wex = TICK_ETERNITY;
515 s->res.analyse_exp = TICK_ETERNITY;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200516
Willy Tarreau62f791e2012-03-09 11:32:30 +0100517 txn = &s->txn;
518 /* Those variables will be checked and freed if non-NULL in
519 * session.c:session_free(). It is important that they are
520 * properly initialized.
521 */
522 txn->sessid = NULL;
523 txn->srv_cookie = NULL;
524 txn->cli_cookie = NULL;
525 txn->uri = NULL;
526 txn->req.cap = NULL;
527 txn->rsp.cap = NULL;
528 txn->hdr_idx.v = NULL;
529 txn->hdr_idx.size = txn->hdr_idx.used = 0;
Willy Tarreau068621e2013-12-23 15:11:25 +0100530 txn->flags = 0;
Willy Tarreau62f791e2012-03-09 11:32:30 +0100531 txn->req.flags = 0;
532 txn->rsp.flags = 0;
533 /* the HTTP messages need to know what buffer they're associated with */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100534 txn->req.chn = &s->req;
535 txn->rsp.chn = &s->res;
Willy Tarreau62f791e2012-03-09 11:32:30 +0100536
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100537 HLUA_INIT(&s->hlua);
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100538
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200539 /* finish initialization of the accepted file descriptor */
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200540 conn_data_want_recv(conn);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200541
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100542 if (p->accept && (ret = p->accept(s)) <= 0) {
543 /* Either we had an unrecoverable error (<0) or work is
544 * finished (=0, eg: monitoring), in both situations,
545 * we can release everything and close.
546 */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100547 goto out_free_strm;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200548 }
549
Willy Tarreau93dbc2b2012-10-12 18:01:49 +0200550 /* if logs require transport layer information, note it on the connection */
551 if (s->logs.logwait & LW_XPRT)
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200552 conn->flags |= CO_FL_XPRT_TRACKED;
Willy Tarreau93dbc2b2012-10-12 18:01:49 +0200553
Willy Tarreau2542b532012-08-31 16:01:23 +0200554 /* we want the connection handler to notify the stream interface about updates. */
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200555 conn->flags |= CO_FL_WAKE_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200556
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200557 /* it is important not to call the wakeup function directly but to
558 * pass through task_wakeup(), because this one knows how to apply
559 * priorities to tasks.
560 */
561 task_wakeup(t, TASK_WOKEN_INIT);
562 return 1;
563
564 /* Error unrolling */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100565 out_free_strm:
Willy Tarreaub4f98092014-05-08 21:06:11 +0200566 /* and restore the connection pointer in case we destroyed it,
567 * because kill_mini_session() will need it.
568 */
Willy Tarreau3b246412014-11-25 17:10:33 +0100569 LIST_DEL(&s->list);
Willy Tarreaub4f98092014-05-08 21:06:11 +0200570 s->target = &conn->obj_type;
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100571 return ret;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200572}
573
Willy Tarreaubaaee002006-06-26 02:48:02 +0200574/*
575 * frees the context associated to a session. It must have been removed first.
576 */
Simon Hormandec5be42011-06-08 09:19:07 +0900577static void session_free(struct session *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200578{
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100579 struct http_txn *txn = &s->txn;
Willy Tarreau632f5a72007-07-11 10:42:35 +0200580 struct proxy *fe = s->fe;
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100581 struct bref *bref, *back;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200582 struct connection *cli_conn = objt_conn(s->si[0].end);
Willy Tarreaua4cda672010-06-06 18:28:49 +0200583 int i;
Willy Tarreau0f7562b2007-01-07 15:46:13 +0100584
Willy Tarreaubaaee002006-06-26 02:48:02 +0200585 if (s->pend_pos)
586 pendconn_free(s->pend_pos);
Willy Tarreau922a8062008-12-04 09:33:58 +0100587
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100588 if (objt_server(s->target)) { /* there may be requests left pending in queue */
Willy Tarreau1e62de62008-11-11 20:20:02 +0100589 if (s->flags & SN_CURR_SESS) {
590 s->flags &= ~SN_CURR_SESS;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100591 objt_server(s->target)->cur_sess--;
Willy Tarreau1e62de62008-11-11 20:20:02 +0100592 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100593 if (may_dequeue_tasks(objt_server(s->target), s->be))
594 process_srv_queue(objt_server(s->target));
Willy Tarreau1e62de62008-11-11 20:20:02 +0100595 }
Willy Tarreau922a8062008-12-04 09:33:58 +0100596
Willy Tarreau7c669d72008-06-20 15:04:11 +0200597 if (unlikely(s->srv_conn)) {
598 /* the session still has a reserved slot on a server, but
599 * it should normally be only the same as the one above,
600 * so this should not happen in fact.
601 */
602 sess_change_server(s, NULL);
603 }
604
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100605 if (s->req.pipe)
606 put_pipe(s->req.pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100607
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100608 if (s->res.pipe)
609 put_pipe(s->res.pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100610
Willy Tarreaubf883e02014-11-25 21:10:35 +0100611 /* We may still be present in the buffer wait queue */
612 if (!LIST_ISEMPTY(&s->buffer_wait)) {
613 LIST_DEL(&s->buffer_wait);
614 LIST_INIT(&s->buffer_wait);
615 }
616
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100617 b_drop(&s->req.buf);
618 b_drop(&s->res.buf);
Willy Tarreaubf883e02014-11-25 21:10:35 +0100619 if (!LIST_ISEMPTY(&buffer_wq))
Willy Tarreaua24adf02014-11-27 01:11:56 +0100620 session_offer_buffers();
Willy Tarreau9b28e032012-10-12 23:49:43 +0200621
Thierry FOURNIERa718b292015-03-04 16:48:34 +0100622 hlua_ctx_destroy(&s->hlua);
Willy Tarreau46023632010-01-07 22:51:47 +0100623 http_end_txn(s);
624
Willy Tarreau1e954912012-10-12 17:50:05 +0200625 /* ensure the client-side transport layer is destroyed */
Willy Tarreauf79c8172013-10-21 16:30:56 +0200626 if (cli_conn)
627 conn_force_close(cli_conn);
Willy Tarreau1e954912012-10-12 17:50:05 +0200628
Willy Tarreaua4cda672010-06-06 18:28:49 +0200629 for (i = 0; i < s->store_count; i++) {
630 if (!s->store[i].ts)
631 continue;
632 stksess_free(s->store[i].table, s->store[i].ts);
633 s->store[i].ts = NULL;
634 }
635
Willy Tarreau34eb6712011-10-24 18:15:04 +0200636 pool_free2(pool2_hdr_idx, txn->hdr_idx.v);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200637 if (fe) {
Willy Tarreau46023632010-01-07 22:51:47 +0100638 pool_free2(fe->rsp_cap_pool, txn->rsp.cap);
639 pool_free2(fe->req_cap_pool, txn->req.cap);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200640 }
Willy Tarreau0937bc42009-12-22 15:03:09 +0100641
Willy Tarreau7af7d592013-07-01 18:07:03 +0200642 session_store_counters(s);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200643
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100644 list_for_each_entry_safe(bref, back, &s->back_refs, users) {
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100645 /* we have to unlink all watchers. We must not relink them if
646 * this session was the last one in the list.
647 */
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100648 LIST_DEL(&bref->users);
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100649 LIST_INIT(&bref->users);
650 if (s->list.n != &sessions)
651 LIST_ADDQ(&LIST_ELEM(s->list.n, struct session *, list)->back_refs, &bref->users);
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100652 bref->ref = s->list.n;
653 }
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100654 LIST_DEL(&s->list);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200655 si_release_endpoint(&s->si[1]);
656 si_release_endpoint(&s->si[0]);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200657 pool_free2(pool2_session, s);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200658
659 /* We may want to free the maximum amount of pools if the proxy is stopping */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200660 if (fe && unlikely(fe->state == PR_STSTOPPED)) {
Willy Tarreau9b28e032012-10-12 23:49:43 +0200661 pool_flush2(pool2_buffer);
Willy Tarreau34eb6712011-10-24 18:15:04 +0200662 pool_flush2(pool2_hdr_idx);
Willy Tarreau48d63db2008-08-03 17:41:33 +0200663 pool_flush2(pool2_requri);
664 pool_flush2(pool2_capture);
665 pool_flush2(pool2_session);
Willy Tarreau3a5e0602014-11-13 16:46:28 +0100666 pool_flush2(pool2_connection);
667 pool_flush2(pool2_pendconn);
Willy Tarreau48d63db2008-08-03 17:41:33 +0200668 pool_flush2(fe->req_cap_pool);
669 pool_flush2(fe->rsp_cap_pool);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200670 }
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200671}
672
Willy Tarreau78955f42014-12-28 13:09:02 +0100673/* Allocates a receive buffer for channel <chn>, but only if it's guaranteed
674 * that it's not the last available buffer or it's the response buffer. Unless
675 * the buffer is the response buffer, an extra control is made so that we always
676 * keep <tune.buffers.reserved> buffers available after this allocation. To be
677 * called at the beginning of recv() callbacks to ensure that the required
678 * buffers are properly allocated. Returns 0 in case of failure, non-zero
679 * otherwise.
Willy Tarreau656859d2014-11-25 19:46:36 +0100680 */
Willy Tarreau78955f42014-12-28 13:09:02 +0100681int session_alloc_recv_buffer(struct channel *chn)
Willy Tarreau656859d2014-11-25 19:46:36 +0100682{
Willy Tarreau78955f42014-12-28 13:09:02 +0100683 struct session *s;
Willy Tarreau656859d2014-11-25 19:46:36 +0100684 struct buffer *b;
Willy Tarreaua24adf02014-11-27 01:11:56 +0100685 int margin = 0;
Willy Tarreau656859d2014-11-25 19:46:36 +0100686
Willy Tarreau78955f42014-12-28 13:09:02 +0100687 if (!(chn->flags & CF_ISRESP))
Willy Tarreaua24adf02014-11-27 01:11:56 +0100688 margin = global.tune.reserved_bufs;
689
Willy Tarreau78955f42014-12-28 13:09:02 +0100690 s = chn_sess(chn);
691
692 b = b_alloc_margin(&chn->buf, margin);
Willy Tarreau656859d2014-11-25 19:46:36 +0100693 if (b)
694 return 1;
695
Willy Tarreaubf883e02014-11-25 21:10:35 +0100696 if (LIST_ISEMPTY(&s->buffer_wait))
697 LIST_ADDQ(&buffer_wq, &s->buffer_wait);
Willy Tarreau656859d2014-11-25 19:46:36 +0100698 return 0;
699}
700
Willy Tarreaua24adf02014-11-27 01:11:56 +0100701/* Allocates a work buffer for session <s>. It is meant to be called inside
702 * process_session(). It will only allocate the side needed for the function
703 * to work fine. For a regular connection, only the response is needed so that
704 * an error message may be built and returned. In case where the initiator is
705 * an applet (eg: peers), then we need to allocate the request buffer for the
706 * applet to be able to send its data (in this case a response is not needed).
707 * Request buffers are never picked from the reserved pool, but response
708 * buffers may be allocated from the reserve. This is critical to ensure that
709 * a response may always flow and will never block a server from releasing a
710 * connection. Returns 0 in case of failure, non-zero otherwise.
Willy Tarreau656859d2014-11-25 19:46:36 +0100711 */
Willy Tarreaua24adf02014-11-27 01:11:56 +0100712int session_alloc_work_buffer(struct session *s)
Willy Tarreau656859d2014-11-25 19:46:36 +0100713{
Willy Tarreaua24adf02014-11-27 01:11:56 +0100714 int margin;
715 struct buffer **buf;
716
717 if (objt_appctx(s->si[0].end)) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100718 buf = &s->req.buf;
Willy Tarreaua24adf02014-11-27 01:11:56 +0100719 margin = global.tune.reserved_bufs;
720 }
721 else {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100722 buf = &s->res.buf;
Willy Tarreaua24adf02014-11-27 01:11:56 +0100723 margin = 0;
724 }
725
Willy Tarreaubf883e02014-11-25 21:10:35 +0100726 if (!LIST_ISEMPTY(&s->buffer_wait)) {
727 LIST_DEL(&s->buffer_wait);
728 LIST_INIT(&s->buffer_wait);
729 }
Willy Tarreau656859d2014-11-25 19:46:36 +0100730
Willy Tarreaua24adf02014-11-27 01:11:56 +0100731 if (b_alloc_margin(buf, margin))
Willy Tarreau656859d2014-11-25 19:46:36 +0100732 return 1;
733
Willy Tarreaubf883e02014-11-25 21:10:35 +0100734 LIST_ADDQ(&buffer_wq, &s->buffer_wait);
Willy Tarreau656859d2014-11-25 19:46:36 +0100735 return 0;
736}
737
738/* releases unused buffers after processing. Typically used at the end of the
Willy Tarreaubf883e02014-11-25 21:10:35 +0100739 * update() functions. It will try to wake up as many tasks as the number of
740 * buffers that it releases. In practice, most often sessions are blocked on
741 * a single buffer, so it makes sense to try to wake two up when two buffers
742 * are released at once.
Willy Tarreau656859d2014-11-25 19:46:36 +0100743 */
744void session_release_buffers(struct session *s)
745{
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100746 if (s->req.buf->size && buffer_empty(s->req.buf))
747 b_free(&s->req.buf);
Willy Tarreau656859d2014-11-25 19:46:36 +0100748
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100749 if (s->res.buf->size && buffer_empty(s->res.buf))
750 b_free(&s->res.buf);
Willy Tarreau656859d2014-11-25 19:46:36 +0100751
Willy Tarreaubf883e02014-11-25 21:10:35 +0100752 /* if we're certain to have at least 1 buffer available, and there is
753 * someone waiting, we can wake up a waiter and offer them.
754 */
Willy Tarreaua24adf02014-11-27 01:11:56 +0100755 if (!LIST_ISEMPTY(&buffer_wq))
756 session_offer_buffers();
Willy Tarreaubf883e02014-11-25 21:10:35 +0100757}
758
Willy Tarreaua24adf02014-11-27 01:11:56 +0100759/* Runs across the list of pending sessions waiting for a buffer and wakes one
760 * up if buffers are available. Will stop when the run queue reaches <rqlimit>.
761 * Should not be called directly, use session_offer_buffers() instead.
Willy Tarreaubf883e02014-11-25 21:10:35 +0100762 */
Willy Tarreaua24adf02014-11-27 01:11:56 +0100763void __session_offer_buffers(int rqlimit)
Willy Tarreaubf883e02014-11-25 21:10:35 +0100764{
765 struct session *sess, *bak;
766
767 list_for_each_entry_safe(sess, bak, &buffer_wq, buffer_wait) {
Willy Tarreaua24adf02014-11-27 01:11:56 +0100768 if (rqlimit <= run_queue)
769 break;
770
Willy Tarreaubf883e02014-11-25 21:10:35 +0100771 if (sess->task->state & TASK_RUNNING)
772 continue;
773
774 LIST_DEL(&sess->buffer_wait);
775 LIST_INIT(&sess->buffer_wait);
Willy Tarreaubf883e02014-11-25 21:10:35 +0100776 task_wakeup(sess->task, TASK_WOKEN_RES);
Willy Tarreaubf883e02014-11-25 21:10:35 +0100777 }
Willy Tarreau656859d2014-11-25 19:46:36 +0100778}
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200779
780/* perform minimal intializations, report 0 in case of error, 1 if OK. */
781int init_session()
782{
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100783 LIST_INIT(&sessions);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200784 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
785 return pool2_session != NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200786}
787
Willy Tarreau30e71012007-11-26 20:15:35 +0100788void session_process_counters(struct session *s)
789{
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100790 unsigned long long bytes;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100791 void *ptr;
792 int i;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100793
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100794 bytes = s->req.total - s->logs.bytes_in;
795 s->logs.bytes_in = s->req.total;
796 if (bytes) {
797 s->fe->fe_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100798
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100799 s->be->be_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100800
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100801 if (objt_server(s->target))
802 objt_server(s->target)->counters.bytes_in += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200803
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100804 if (s->listener && s->listener->counters)
805 s->listener->counters->bytes_in += bytes;
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200806
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100807 for (i = 0; i < MAX_SESS_STKCTR; i++) {
808 if (!stkctr_entry(&s->stkctr[i]))
809 continue;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200810
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100811 ptr = stktable_data_ptr(s->stkctr[i].table,
812 stkctr_entry(&s->stkctr[i]),
813 STKTABLE_DT_BYTES_IN_CNT);
814 if (ptr)
815 stktable_data_cast(ptr, bytes_in_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200816
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100817 ptr = stktable_data_ptr(s->stkctr[i].table,
818 stkctr_entry(&s->stkctr[i]),
819 STKTABLE_DT_BYTES_IN_RATE);
820 if (ptr)
821 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
822 s->stkctr[i].table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u, bytes);
Willy Tarreau30e71012007-11-26 20:15:35 +0100823 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100824 }
825
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100826 bytes = s->res.total - s->logs.bytes_out;
827 s->logs.bytes_out = s->res.total;
828 if (bytes) {
829 s->fe->fe_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100830
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100831 s->be->be_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100832
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100833 if (objt_server(s->target))
834 objt_server(s->target)->counters.bytes_out += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200835
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100836 if (s->listener && s->listener->counters)
837 s->listener->counters->bytes_out += bytes;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200838
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100839 for (i = 0; i < MAX_SESS_STKCTR; i++) {
840 if (!stkctr_entry(&s->stkctr[i]))
841 continue;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200842
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100843 ptr = stktable_data_ptr(s->stkctr[i].table,
844 stkctr_entry(&s->stkctr[i]),
845 STKTABLE_DT_BYTES_OUT_CNT);
846 if (ptr)
847 stktable_data_cast(ptr, bytes_out_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200848
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100849 ptr = stktable_data_ptr(s->stkctr[i].table,
850 stkctr_entry(&s->stkctr[i]),
851 STKTABLE_DT_BYTES_OUT_RATE);
852 if (ptr)
853 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
854 s->stkctr[i].table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u, bytes);
Willy Tarreau30e71012007-11-26 20:15:35 +0100855 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100856 }
857}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200858
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100859/* This function is called with (si->state == SI_ST_CON) meaning that a
860 * connection was attempted and that the file descriptor is already allocated.
861 * We must check for establishment, error and abort. Possible output states
862 * are SI_ST_EST (established), SI_ST_CER (error), SI_ST_DIS (abort), and
863 * SI_ST_CON (no change). The function returns 0 if it switches to SI_ST_CER,
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200864 * otherwise 1. This only works with connection-based sessions.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100865 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +0100866static int sess_update_st_con_tcp(struct session *s)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100867{
Willy Tarreau7b8c4f92014-11-28 15:15:44 +0100868 struct stream_interface *si = &s->si[1];
869 struct channel *req = &s->req;
870 struct channel *rep = &s->res;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200871 struct connection *srv_conn = __objt_conn(si->end);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100872
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100873 /* If we got an error, or if nothing happened and the connection timed
874 * out, we must give up. The CER state handler will take care of retry
875 * attempts and error reports.
876 */
877 if (unlikely(si->flags & (SI_FL_EXP|SI_FL_ERR))) {
Willy Tarreau103197d2014-11-28 15:26:12 +0100878 if (unlikely(req->flags & CF_WRITE_PARTIAL)) {
Willy Tarreaue3224e82012-10-29 22:41:31 +0100879 /* Some data were sent past the connection establishment,
880 * so we need to pretend we're established to log correctly
881 * and let later states handle the failure.
882 */
Willy Tarreaue3224e82012-10-29 22:41:31 +0100883 si->state = SI_ST_EST;
884 si->err_type = SI_ET_DATA_ERR;
Willy Tarreau103197d2014-11-28 15:26:12 +0100885 rep->flags |= CF_READ_ERROR | CF_WRITE_ERROR;
Willy Tarreaue3224e82012-10-29 22:41:31 +0100886 return 1;
887 }
Willy Tarreau127334e2009-03-28 10:47:26 +0100888 si->exp = TICK_ETERNITY;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100889 si->state = SI_ST_CER;
Willy Tarreau0ede5a32012-12-08 08:44:02 +0100890
Willy Tarreauf79c8172013-10-21 16:30:56 +0200891 conn_force_close(srv_conn);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100892
893 if (si->err_type)
894 return 0;
895
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100896 if (si->flags & SI_FL_ERR)
897 si->err_type = SI_ET_CONN_ERR;
898 else
899 si->err_type = SI_ET_CONN_TO;
900 return 0;
901 }
902
903 /* OK, maybe we want to abort */
Willy Tarreaua7a7ebc2012-12-30 00:50:35 +0100904 if (!(req->flags & CF_WRITE_PARTIAL) &&
905 unlikely((rep->flags & CF_SHUTW) ||
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200906 ((req->flags & CF_SHUTW_NOW) && /* FIXME: this should not prevent a connection from establishing */
907 ((!(req->flags & CF_WRITE_ACTIVITY) && channel_is_empty(req)) ||
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100908 s->be->options & PR_O_ABRT_CLOSE)))) {
909 /* give up */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200910 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100911 si->err_type |= SI_ET_CONN_ABRT;
Willy Tarreau84455332009-03-15 22:34:05 +0100912 if (s->srv_error)
913 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100914 return 1;
915 }
916
917 /* we need to wait a bit more if there was no activity either */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200918 if (!(req->flags & CF_WRITE_ACTIVITY))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100919 return 1;
920
921 /* OK, this means that a connection succeeded. The caller will be
922 * responsible for handling the transition from CON to EST.
923 */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100924 si->state = SI_ST_EST;
925 si->err_type = SI_ET_NONE;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100926 return 1;
927}
928
929/* This function is called with (si->state == SI_ST_CER) meaning that a
930 * previous connection attempt has failed and that the file descriptor
931 * has already been released. Possible causes include asynchronous error
932 * notification and time out. Possible output states are SI_ST_CLO when
933 * retries are exhausted, SI_ST_TAR when a delay is wanted before a new
934 * connection attempt, SI_ST_ASS when it's wise to retry on the same server,
935 * and SI_ST_REQ when an immediate redispatch is wanted. The buffers are
936 * marked as in error state. It returns 0.
937 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +0100938static int sess_update_st_cer(struct session *s)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100939{
Willy Tarreau7b8c4f92014-11-28 15:15:44 +0100940 struct stream_interface *si = &s->si[1];
941
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100942 /* we probably have to release last session from the server */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100943 if (objt_server(s->target)) {
944 health_adjust(objt_server(s->target), HANA_STATUS_L4_ERR);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100945
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100946 if (s->flags & SN_CURR_SESS) {
947 s->flags &= ~SN_CURR_SESS;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100948 objt_server(s->target)->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100949 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100950 }
951
952 /* ensure that we have enough retries left */
Willy Tarreauee28de02010-06-01 09:51:00 +0200953 si->conn_retries--;
954 if (si->conn_retries < 0) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100955 if (!si->err_type) {
956 si->err_type = SI_ET_CONN_ERR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100957 }
958
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100959 if (objt_server(s->target))
960 objt_server(s->target)->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100961 s->be->be_counters.failed_conns++;
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100962 sess_change_server(s, NULL);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100963 if (may_dequeue_tasks(objt_server(s->target), s->be))
964 process_srv_queue(objt_server(s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100965
966 /* shutw is enough so stop a connecting socket */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200967 si_shutw(si);
Willy Tarreau103197d2014-11-28 15:26:12 +0100968 s->req.flags |= CF_WRITE_ERROR;
969 s->res.flags |= CF_READ_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100970
971 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100972 if (s->srv_error)
973 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100974 return 0;
975 }
976
977 /* If the "redispatch" option is set on the backend, we are allowed to
978 * retry on another server for the last retry. In order to achieve this,
979 * we must mark the session unassigned, and eventually clear the DIRECT
980 * bit to ignore any persistence cookie. We won't count a retry nor a
981 * redispatch yet, because this will depend on what server is selected.
Willy Tarreau33a14e52014-06-13 17:49:40 +0200982 * If the connection is not persistent, the balancing algorithm is not
983 * determinist (round robin) and there is more than one active server,
984 * we accept to perform an immediate redispatch without waiting since
985 * we don't care about this particular server.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100986 */
Willy Tarreau33a14e52014-06-13 17:49:40 +0200987 if (objt_server(s->target) &&
988 (si->conn_retries == 0 ||
989 (!(s->flags & SN_DIRECT) && s->be->srv_act > 1 &&
990 ((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR))) &&
Willy Tarreau4de91492010-01-22 19:10:05 +0100991 s->be->options & PR_O_REDISP && !(s->flags & SN_FORCE_PRST)) {
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100992 sess_change_server(s, NULL);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100993 if (may_dequeue_tasks(objt_server(s->target), s->be))
994 process_srv_queue(objt_server(s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100995
996 s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100997 si->state = SI_ST_REQ;
998 } else {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100999 if (objt_server(s->target))
1000 objt_server(s->target)->counters.retries++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001001 s->be->be_counters.retries++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001002 si->state = SI_ST_ASS;
1003 }
1004
1005 if (si->flags & SI_FL_ERR) {
1006 /* The error was an asynchronous connection error, and we will
1007 * likely have to retry connecting to the same server, most
1008 * likely leading to the same result. To avoid this, we wait
Willy Tarreaub0290662014-06-13 17:04:44 +02001009 * MIN(one second, connect timeout) before retrying.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001010 */
1011
Willy Tarreaub0290662014-06-13 17:04:44 +02001012 int delay = 1000;
1013
1014 if (s->be->timeout.connect && s->be->timeout.connect < delay)
1015 delay = s->be->timeout.connect;
1016
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001017 if (!si->err_type)
1018 si->err_type = SI_ET_CONN_ERR;
1019
Willy Tarreaudb6d0122014-06-13 17:40:15 +02001020 /* only wait when we're retrying on the same server */
1021 if (si->state == SI_ST_ASS ||
1022 (s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_RR ||
1023 (s->be->srv_act <= 1)) {
1024 si->state = SI_ST_TAR;
1025 si->exp = tick_add(now_ms, MS_TO_TICKS(delay));
1026 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001027 return 0;
1028 }
1029 return 0;
1030}
1031
1032/*
1033 * This function handles the transition between the SI_ST_CON state and the
Willy Tarreau85e7d002010-05-31 11:57:51 +02001034 * SI_ST_EST state. It must only be called after switching from SI_ST_CON (or
Willy Tarreau26d8c592012-05-07 18:12:14 +02001035 * SI_ST_INI) to SI_ST_EST, but only when a ->proto is defined.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001036 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001037static void sess_establish(struct session *s)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001038{
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001039 struct stream_interface *si = &s->si[1];
1040 struct channel *req = &s->req;
1041 struct channel *rep = &s->res;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001042
Willy Tarreau0e37f1c2013-12-31 23:06:46 +01001043 /* First, centralize the timers information */
1044 s->logs.t_connect = tv_ms_elapsed(&s->logs.tv_accept, &now);
1045 si->exp = TICK_ETERNITY;
1046
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001047 if (objt_server(s->target))
1048 health_adjust(objt_server(s->target), HANA_STATUS_L4_OK);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +01001049
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001050 if (s->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001051 /* if the user wants to log as soon as possible, without counting
1052 * bytes from the server, then this is the right moment. */
Willy Tarreaud79a3b22012-12-28 09:40:16 +01001053 if (!LIST_ISEMPTY(&s->fe->logformat) && !(s->logs.logwait & LW_BYTES)) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001054 s->logs.t_close = s->logs.t_connect; /* to get a valid end date */
Willy Tarreaua5555ec2008-11-30 19:02:32 +01001055 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001056 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001057 }
1058 else {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001059 s->txn.rsp.msg_state = HTTP_MSG_RPBEFORE;
Willy Tarreaud81ca042013-12-31 22:33:13 +01001060 rep->flags |= CF_READ_DONTWAIT; /* a single read is enough to get response headers */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001061 }
1062
Willy Tarreau4e5b8282009-08-16 22:57:50 +02001063 rep->analysers |= s->fe->fe_rsp_ana | s->be->be_rsp_ana;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001064 rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Willy Tarreau644c1012014-04-30 18:11:11 +02001065 if (req->flags & CF_WAKE_CONNECT) {
1066 req->flags |= CF_WAKE_ONCE;
1067 req->flags &= ~CF_WAKE_CONNECT;
1068 }
Willy Tarreaub363a1f2013-10-01 10:45:07 +02001069 if (objt_conn(si->end)) {
Willy Tarreaud04e8582010-05-31 12:31:35 +02001070 /* real connections have timeouts */
1071 req->wto = s->be->timeout.server;
1072 rep->rto = s->be->timeout.server;
1073 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001074 req->wex = TICK_ETERNITY;
1075}
1076
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001077/* Update back stream interface status for input states SI_ST_ASS, SI_ST_QUE,
1078 * SI_ST_TAR. Other input states are simply ignored.
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +01001079 * Possible output states are SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ, SI_ST_CON
1080 * and SI_ST_EST. Flags must have previously been updated for timeouts and other
1081 * conditions.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001082 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001083static void sess_update_stream_int(struct session *s)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001084{
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001085 struct server *srv = objt_server(s->target);
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001086 struct stream_interface *si = &s->si[1];
Willy Tarreau103197d2014-11-28 15:26:12 +01001087 struct channel *req = &s->req;
Willy Tarreau827aee92011-03-10 16:55:02 +01001088
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001089 DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001090 now_ms, __FUNCTION__,
1091 s,
Willy Tarreau103197d2014-11-28 15:26:12 +01001092 req, s->rep,
1093 req->rex, s->res.wex,
1094 req->flags, s->res.flags,
1095 req->buf->i, req->buf->o, s->res.buf->i, s->res.buf->o, s->si[0].state, req->cons->state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001096
1097 if (si->state == SI_ST_ASS) {
1098 /* Server assigned to connection request, we have to try to connect now */
1099 int conn_err;
1100
1101 conn_err = connect_server(s);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001102 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001103
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001104 if (conn_err == SN_ERR_NONE) {
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +01001105 /* state = SI_ST_CON or SI_ST_EST now */
Willy Tarreau827aee92011-03-10 16:55:02 +01001106 if (srv)
1107 srv_inc_sess_ctr(srv);
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -05001108 if (srv)
1109 srv_set_sess_last(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001110 return;
1111 }
1112
1113 /* We have received a synchronous error. We might have to
1114 * abort, retry immediately or redispatch.
1115 */
1116 if (conn_err == SN_ERR_INTERNAL) {
1117 if (!si->err_type) {
1118 si->err_type = SI_ET_CONN_OTHER;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001119 }
1120
Willy Tarreau827aee92011-03-10 16:55:02 +01001121 if (srv)
1122 srv_inc_sess_ctr(srv);
1123 if (srv)
Bhaskar Maddalaa20cb852014-02-03 16:26:46 -05001124 srv_set_sess_last(srv);
1125 if (srv)
Willy Tarreau827aee92011-03-10 16:55:02 +01001126 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001127 s->be->be_counters.failed_conns++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001128
1129 /* release other sessions waiting for this server */
Willy Tarreaub89cfca2010-12-29 14:32:28 +01001130 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001131 if (may_dequeue_tasks(srv, s->be))
1132 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001133
1134 /* Failed and not retryable. */
Willy Tarreau73b013b2012-05-21 16:31:45 +02001135 si_shutr(si);
1136 si_shutw(si);
Willy Tarreau103197d2014-11-28 15:26:12 +01001137 req->flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001138
1139 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1140
1141 /* no session was ever accounted for this server */
1142 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001143 if (s->srv_error)
1144 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001145 return;
1146 }
1147
1148 /* We are facing a retryable error, but we don't want to run a
1149 * turn-around now, as the problem is likely a source port
1150 * allocation problem, so we want to retry now.
1151 */
1152 si->state = SI_ST_CER;
1153 si->flags &= ~SI_FL_ERR;
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001154 sess_update_st_cer(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001155 /* now si->state is one of SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ */
1156 return;
1157 }
1158 else if (si->state == SI_ST_QUE) {
1159 /* connection request was queued, check for any update */
1160 if (!s->pend_pos) {
1161 /* The connection is not in the queue anymore. Either
1162 * we have a server connection slot available and we
1163 * go directly to the assigned state, or we need to
1164 * load-balance first and go to the INI state.
1165 */
1166 si->exp = TICK_ETERNITY;
1167 if (unlikely(!(s->flags & SN_ASSIGNED)))
1168 si->state = SI_ST_REQ;
1169 else {
1170 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1171 si->state = SI_ST_ASS;
1172 }
1173 return;
1174 }
1175
1176 /* Connection request still in queue... */
1177 if (si->flags & SI_FL_EXP) {
1178 /* ... and timeout expired */
1179 si->exp = TICK_ETERNITY;
1180 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau827aee92011-03-10 16:55:02 +01001181 if (srv)
1182 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001183 s->be->be_counters.failed_conns++;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001184 si_shutr(si);
1185 si_shutw(si);
Willy Tarreau103197d2014-11-28 15:26:12 +01001186 req->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001187 if (!si->err_type)
1188 si->err_type = SI_ET_QUEUE_TO;
1189 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001190 if (s->srv_error)
1191 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001192 return;
1193 }
1194
1195 /* Connection remains in queue, check if we have to abort it */
Willy Tarreau103197d2014-11-28 15:26:12 +01001196 if ((req->flags & (CF_READ_ERROR)) ||
1197 ((req->flags & CF_SHUTW_NOW) && /* empty and client aborted */
1198 (channel_is_empty(req) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001199 /* give up */
1200 si->exp = TICK_ETERNITY;
1201 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau73b013b2012-05-21 16:31:45 +02001202 si_shutr(si);
1203 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001204 si->err_type |= SI_ET_QUEUE_ABRT;
1205 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001206 if (s->srv_error)
1207 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001208 return;
1209 }
1210
1211 /* Nothing changed */
1212 return;
1213 }
1214 else if (si->state == SI_ST_TAR) {
1215 /* Connection request might be aborted */
Willy Tarreau103197d2014-11-28 15:26:12 +01001216 if ((req->flags & (CF_READ_ERROR)) ||
1217 ((req->flags & CF_SHUTW_NOW) && /* empty and client aborted */
1218 (channel_is_empty(req) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001219 /* give up */
1220 si->exp = TICK_ETERNITY;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001221 si_shutr(si);
1222 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001223 si->err_type |= SI_ET_CONN_ABRT;
1224 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001225 if (s->srv_error)
1226 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001227 return;
1228 }
1229
1230 if (!(si->flags & SI_FL_EXP))
1231 return; /* still in turn-around */
1232
1233 si->exp = TICK_ETERNITY;
1234
1235 /* we keep trying on the same server as long as the session is
1236 * marked "assigned".
1237 * FIXME: Should we force a redispatch attempt when the server is down ?
1238 */
1239 if (s->flags & SN_ASSIGNED)
1240 si->state = SI_ST_ASS;
1241 else
1242 si->state = SI_ST_REQ;
1243 return;
1244 }
1245}
1246
Simon Hormandec5be42011-06-08 09:19:07 +09001247/* Set correct session termination flags in case no analyser has done it. It
1248 * also counts a failed request if the server state has not reached the request
1249 * stage.
1250 */
1251static void sess_set_term_flags(struct session *s)
1252{
1253 if (!(s->flags & SN_FINST_MASK)) {
1254 if (s->si[1].state < SI_ST_REQ) {
1255
1256 s->fe->fe_counters.failed_req++;
1257 if (s->listener->counters)
1258 s->listener->counters->failed_req++;
1259
1260 s->flags |= SN_FINST_R;
1261 }
1262 else if (s->si[1].state == SI_ST_QUE)
1263 s->flags |= SN_FINST_Q;
1264 else if (s->si[1].state < SI_ST_EST)
1265 s->flags |= SN_FINST_C;
1266 else if (s->si[1].state == SI_ST_EST || s->si[1].prev_state == SI_ST_EST)
1267 s->flags |= SN_FINST_D;
1268 else
1269 s->flags |= SN_FINST_L;
1270 }
1271}
1272
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001273/* This function initiates a server connection request on a stream interface
Willy Tarreaud84fb5e2013-11-30 09:06:53 +01001274 * already in SI_ST_REQ state. Upon success, the state goes to SI_ST_ASS for
1275 * a real connection to a server, indicating that a server has been assigned,
1276 * or SI_ST_EST for a successful connection to an applet. It may also return
1277 * SI_ST_QUE, or SI_ST_CLO upon error.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001278 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001279static void sess_prepare_conn_req(struct session *s)
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001280{
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001281 struct stream_interface *si = &s->si[1];
1282
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001283 DPRINTF(stderr,"[%u] %s: sess=%p rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001284 now_ms, __FUNCTION__,
1285 s,
1286 s->req, s->rep,
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001287 s->req.rex, s->res.wex,
1288 s->req.flags, s->res.flags,
Willy Tarreau350f4872014-11-28 14:42:25 +01001289 s->req.buf->i, s->req.buf->o, s->res.buf->i, s->res.buf->o, s->si[0].state, s->req.cons->state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001290
1291 if (si->state != SI_ST_REQ)
1292 return;
1293
Willy Tarreaud84fb5e2013-11-30 09:06:53 +01001294 if (unlikely(obj_type(s->target) == OBJ_TYPE_APPLET)) {
1295 /* the applet directly goes to the EST state */
Willy Tarreau4384ddf2013-12-01 12:25:52 +01001296 struct appctx *appctx = objt_appctx(si->end);
1297
1298 if (!appctx || appctx->applet != __objt_applet(s->target))
1299 appctx = stream_int_register_handler(si, objt_applet(s->target));
1300
1301 if (!appctx) {
1302 /* No more memory, let's immediately abort. Force the
1303 * error code to ignore the ERR_LOCAL which is not a
1304 * real error.
1305 */
Willy Tarreau6bbb2f62013-12-09 17:14:23 +01001306 s->flags &= ~(SN_ERR_MASK | SN_FINST_MASK);
Willy Tarreau4384ddf2013-12-01 12:25:52 +01001307
1308 si_shutr(si);
1309 si_shutw(si);
Willy Tarreau103197d2014-11-28 15:26:12 +01001310 s->req.flags |= CF_WRITE_ERROR;
Willy Tarreau6bbb2f62013-12-09 17:14:23 +01001311 si->err_type = SI_ET_CONN_RES;
Willy Tarreau4384ddf2013-12-01 12:25:52 +01001312 si->state = SI_ST_CLO;
1313 if (s->srv_error)
1314 s->srv_error(s, si);
1315 return;
1316 }
1317
Willy Tarreaud84fb5e2013-11-30 09:06:53 +01001318 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreaud84fb5e2013-11-30 09:06:53 +01001319 si->state = SI_ST_EST;
1320 si->err_type = SI_ET_NONE;
Willy Tarreaub9a551e2014-04-23 00:35:17 +02001321 be_set_sess_last(s->be);
Willy Tarreaufac4bd12013-11-30 09:21:49 +01001322 /* let sess_establish() finish the job */
Willy Tarreaud84fb5e2013-11-30 09:06:53 +01001323 return;
1324 }
1325
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001326 /* Try to assign a server */
1327 if (srv_redispatch_connect(s) != 0) {
1328 /* We did not get a server. Either we queued the
1329 * connection request, or we encountered an error.
1330 */
1331 if (si->state == SI_ST_QUE)
1332 return;
1333
1334 /* we did not get any server, let's check the cause */
Willy Tarreau73b013b2012-05-21 16:31:45 +02001335 si_shutr(si);
1336 si_shutw(si);
Willy Tarreau103197d2014-11-28 15:26:12 +01001337 s->req.flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001338 if (!si->err_type)
1339 si->err_type = SI_ET_CONN_OTHER;
1340 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001341 if (s->srv_error)
1342 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001343 return;
1344 }
1345
1346 /* The server is assigned */
1347 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1348 si->state = SI_ST_ASS;
Willy Tarreaub9a551e2014-04-23 00:35:17 +02001349 be_set_sess_last(s->be);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001350}
1351
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001352/* This stream analyser checks the switching rules and changes the backend
Willy Tarreau4de91492010-01-22 19:10:05 +01001353 * if appropriate. The default_backend rule is also considered, then the
1354 * target backend's forced persistence rules are also evaluated last if any.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001355 * It returns 1 if the processing can continue on next analysers, or zero if it
1356 * either needs more data or wants to immediately abort the request.
1357 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001358static int process_switching_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001359{
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001360 struct persist_rule *prst_rule;
Willy Tarreau4de91492010-01-22 19:10:05 +01001361
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001362 req->analysers &= ~an_bit;
1363 req->analyse_exp = TICK_ETERNITY;
1364
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001365 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001366 now_ms, __FUNCTION__,
1367 s,
1368 req,
1369 req->rex, req->wex,
1370 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001371 req->buf->i,
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001372 req->analysers);
1373
1374 /* now check whether we have some switching rules for this request */
1375 if (!(s->flags & SN_BE_ASSIGNED)) {
1376 struct switching_rule *rule;
1377
1378 list_for_each_entry(rule, &s->fe->switching_rules, list) {
Willy Tarreauf51658d2014-04-23 01:21:56 +02001379 int ret = 1;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001380
Willy Tarreauf51658d2014-04-23 01:21:56 +02001381 if (rule->cond) {
1382 ret = acl_exec_cond(rule->cond, s->fe, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
1383 ret = acl_pass(ret);
1384 if (rule->cond->pol == ACL_COND_UNLESS)
1385 ret = !ret;
1386 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001387
1388 if (ret) {
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01001389 /* If the backend name is dynamic, try to resolve the name.
1390 * If we can't resolve the name, or if any error occurs, break
1391 * the loop and fallback to the default backend.
1392 */
1393 struct proxy *backend;
1394
1395 if (rule->dynamic) {
1396 struct chunk *tmp = get_trash_chunk();
1397 if (!build_logline(s, tmp->str, tmp->size, &rule->be.expr))
1398 break;
1399 backend = findproxy(tmp->str, PR_CAP_BE);
1400 if (!backend)
1401 break;
1402 }
1403 else
1404 backend = rule->be.backend;
1405
1406 if (!session_set_backend(s, backend))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001407 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001408 break;
1409 }
1410 }
1411
1412 /* To ensure correct connection accounting on the backend, we
1413 * have to assign one if it was not set (eg: a listen). This
1414 * measure also takes care of correctly setting the default
1415 * backend if any.
1416 */
1417 if (!(s->flags & SN_BE_ASSIGNED))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001418 if (!session_set_backend(s, s->fe->defbe.be ? s->fe->defbe.be : s->be))
1419 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001420 }
1421
Willy Tarreaufb356202010-08-03 14:02:05 +02001422 /* we don't want to run the TCP or HTTP filters again if the backend has not changed */
1423 if (s->fe == s->be) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001424 s->req.analysers &= ~AN_REQ_INSPECT_BE;
1425 s->req.analysers &= ~AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaufb356202010-08-03 14:02:05 +02001426 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001427
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001428 /* as soon as we know the backend, we must check if we have a matching forced or ignored
Willy Tarreau4de91492010-01-22 19:10:05 +01001429 * persistence rule, and report that in the session.
1430 */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001431 list_for_each_entry(prst_rule, &s->be->persist_rules, list) {
Willy Tarreau4de91492010-01-22 19:10:05 +01001432 int ret = 1;
1433
1434 if (prst_rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001435 ret = acl_exec_cond(prst_rule->cond, s->be, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreau4de91492010-01-22 19:10:05 +01001436 ret = acl_pass(ret);
1437 if (prst_rule->cond->pol == ACL_COND_UNLESS)
1438 ret = !ret;
1439 }
1440
1441 if (ret) {
1442 /* no rule, or the rule matches */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001443 if (prst_rule->type == PERSIST_TYPE_FORCE) {
1444 s->flags |= SN_FORCE_PRST;
1445 } else {
1446 s->flags |= SN_IGNORE_PRST;
1447 }
Willy Tarreau4de91492010-01-22 19:10:05 +01001448 break;
1449 }
1450 }
1451
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001452 return 1;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001453
1454 sw_failed:
1455 /* immediately abort this request in case of allocation failure */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001456 channel_abort(&s->req);
1457 channel_abort(&s->res);
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001458
1459 if (!(s->flags & SN_ERR_MASK))
1460 s->flags |= SN_ERR_RESOURCE;
1461 if (!(s->flags & SN_FINST_MASK))
1462 s->flags |= SN_FINST_R;
1463
1464 s->txn.status = 500;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001465 s->req.analysers = 0;
1466 s->req.analyse_exp = TICK_ETERNITY;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001467 return 0;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001468}
1469
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001470/* This stream analyser works on a request. It applies all use-server rules on
1471 * it then returns 1. The data must already be present in the buffer otherwise
1472 * they won't match. It always returns 1.
1473 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001474static int process_server_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001475{
1476 struct proxy *px = s->be;
1477 struct server_rule *rule;
1478
1479 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
1480 now_ms, __FUNCTION__,
1481 s,
1482 req,
1483 req->rex, req->wex,
1484 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001485 req->buf->i + req->buf->o,
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001486 req->analysers);
1487
1488 if (!(s->flags & SN_ASSIGNED)) {
1489 list_for_each_entry(rule, &px->server_rules, list) {
1490 int ret;
1491
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001492 ret = acl_exec_cond(rule->cond, s->be, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001493 ret = acl_pass(ret);
1494 if (rule->cond->pol == ACL_COND_UNLESS)
1495 ret = !ret;
1496
1497 if (ret) {
1498 struct server *srv = rule->srv.ptr;
1499
Willy Tarreau892337c2014-05-13 23:41:20 +02001500 if ((srv->state != SRV_ST_STOPPED) ||
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001501 (px->options & PR_O_PERSIST) ||
1502 (s->flags & SN_FORCE_PRST)) {
1503 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001504 s->target = &srv->obj_type;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001505 break;
1506 }
1507 /* if the server is not UP, let's go on with next rules
1508 * just in case another one is suited.
1509 */
1510 }
1511 }
1512 }
1513
1514 req->analysers &= ~an_bit;
1515 req->analyse_exp = TICK_ETERNITY;
1516 return 1;
1517}
1518
Emeric Brun1d33b292010-01-04 15:47:17 +01001519/* This stream analyser works on a request. It applies all sticking rules on
1520 * it then returns 1. The data must already be present in the buffer otherwise
1521 * they won't match. It always returns 1.
1522 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001523static int process_sticking_rules(struct session *s, struct channel *req, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001524{
1525 struct proxy *px = s->be;
1526 struct sticking_rule *rule;
1527
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001528 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
Emeric Brun1d33b292010-01-04 15:47:17 +01001529 now_ms, __FUNCTION__,
1530 s,
1531 req,
1532 req->rex, req->wex,
1533 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001534 req->buf->i,
Emeric Brun1d33b292010-01-04 15:47:17 +01001535 req->analysers);
1536
1537 list_for_each_entry(rule, &px->sticking_rules, list) {
1538 int ret = 1 ;
1539 int i;
1540
Willy Tarreau9667a802013-12-09 12:52:13 +01001541 /* Only the first stick store-request of each table is applied
1542 * and other ones are ignored. The purpose is to allow complex
1543 * configurations which look for multiple entries by decreasing
1544 * order of precision and to stop at the first which matches.
1545 * An example could be a store of the IP address from an HTTP
1546 * header first, then from the source if not found.
1547 */
Emeric Brun1d33b292010-01-04 15:47:17 +01001548 for (i = 0; i < s->store_count; i++) {
1549 if (rule->table.t == s->store[i].table)
1550 break;
1551 }
1552
1553 if (i != s->store_count)
1554 continue;
1555
1556 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001557 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001558 ret = acl_pass(ret);
1559 if (rule->cond->pol == ACL_COND_UNLESS)
1560 ret = !ret;
1561 }
1562
1563 if (ret) {
1564 struct stktable_key *key;
1565
Willy Tarreaub5975de2014-06-25 16:20:53 +02001566 key = stktable_fetch_key(rule->table.t, px, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->expr, NULL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001567 if (!key)
1568 continue;
1569
1570 if (rule->flags & STK_IS_MATCH) {
1571 struct stksess *ts;
1572
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001573 if ((ts = stktable_lookup_key(rule->table.t, key)) != NULL) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001574 if (!(s->flags & SN_ASSIGNED)) {
1575 struct eb32_node *node;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001576 void *ptr;
Emeric Brun1d33b292010-01-04 15:47:17 +01001577
1578 /* srv found in table */
Willy Tarreau13c29de2010-06-06 16:40:39 +02001579 ptr = stktable_data_ptr(rule->table.t, ts, STKTABLE_DT_SERVER_ID);
1580 node = eb32_lookup(&px->conf.used_server_id, stktable_data_cast(ptr, server_id));
Emeric Brun1d33b292010-01-04 15:47:17 +01001581 if (node) {
1582 struct server *srv;
1583
1584 srv = container_of(node, struct server, conf.id);
Willy Tarreau892337c2014-05-13 23:41:20 +02001585 if ((srv->state != SRV_ST_STOPPED) ||
Willy Tarreau4de91492010-01-22 19:10:05 +01001586 (px->options & PR_O_PERSIST) ||
1587 (s->flags & SN_FORCE_PRST)) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001588 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001589 s->target = &srv->obj_type;
Emeric Brun1d33b292010-01-04 15:47:17 +01001590 }
1591 }
1592 }
Emeric Brun85e77c72010-09-23 18:16:52 +02001593 stktable_touch(rule->table.t, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001594 }
1595 }
1596 if (rule->flags & STK_IS_STORE) {
1597 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1598 struct stksess *ts;
1599
1600 ts = stksess_new(rule->table.t, key);
1601 if (ts) {
1602 s->store[s->store_count].table = rule->table.t;
1603 s->store[s->store_count++].ts = ts;
1604 }
1605 }
1606 }
1607 }
1608 }
1609
1610 req->analysers &= ~an_bit;
1611 req->analyse_exp = TICK_ETERNITY;
1612 return 1;
1613}
1614
1615/* This stream analyser works on a response. It applies all store rules on it
1616 * then returns 1. The data must already be present in the buffer otherwise
1617 * they won't match. It always returns 1.
1618 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001619static int process_store_rules(struct session *s, struct channel *rep, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001620{
1621 struct proxy *px = s->be;
1622 struct sticking_rule *rule;
1623 int i;
Willy Tarreau9667a802013-12-09 12:52:13 +01001624 int nbreq = s->store_count;
Emeric Brun1d33b292010-01-04 15:47:17 +01001625
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001626 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bh=%d analysers=%02x\n",
Emeric Brun1d33b292010-01-04 15:47:17 +01001627 now_ms, __FUNCTION__,
1628 s,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001629 rep,
1630 rep->rex, rep->wex,
1631 rep->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001632 rep->buf->i,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001633 rep->analysers);
Emeric Brun1d33b292010-01-04 15:47:17 +01001634
1635 list_for_each_entry(rule, &px->storersp_rules, list) {
1636 int ret = 1 ;
Emeric Brun1d33b292010-01-04 15:47:17 +01001637
Willy Tarreau9667a802013-12-09 12:52:13 +01001638 /* Only the first stick store-response of each table is applied
1639 * and other ones are ignored. The purpose is to allow complex
1640 * configurations which look for multiple entries by decreasing
1641 * order of precision and to stop at the first which matches.
1642 * An example could be a store of a set-cookie value, with a
1643 * fallback to a parameter found in a 302 redirect.
1644 *
1645 * The store-response rules are not allowed to override the
1646 * store-request rules for the same table, but they may coexist.
1647 * Thus we can have up to one store-request entry and one store-
1648 * response entry for the same table at any time.
1649 */
1650 for (i = nbreq; i < s->store_count; i++) {
1651 if (rule->table.t == s->store[i].table)
1652 break;
1653 }
1654
1655 /* skip existing entries for this table */
1656 if (i < s->store_count)
1657 continue;
1658
Emeric Brun1d33b292010-01-04 15:47:17 +01001659 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001660 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_RES|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001661 ret = acl_pass(ret);
1662 if (rule->cond->pol == ACL_COND_UNLESS)
1663 ret = !ret;
1664 }
1665
1666 if (ret) {
1667 struct stktable_key *key;
1668
Willy Tarreaub5975de2014-06-25 16:20:53 +02001669 key = stktable_fetch_key(rule->table.t, px, s, &s->txn, SMP_OPT_DIR_RES|SMP_OPT_FINAL, rule->expr, NULL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001670 if (!key)
1671 continue;
1672
Willy Tarreau37e340c2013-12-06 23:05:21 +01001673 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001674 struct stksess *ts;
1675
1676 ts = stksess_new(rule->table.t, key);
1677 if (ts) {
1678 s->store[s->store_count].table = rule->table.t;
Emeric Brun1d33b292010-01-04 15:47:17 +01001679 s->store[s->store_count++].ts = ts;
1680 }
1681 }
1682 }
1683 }
1684
1685 /* process store request and store response */
1686 for (i = 0; i < s->store_count; i++) {
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001687 struct stksess *ts;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001688 void *ptr;
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001689
Willy Tarreauc93cd162014-05-13 15:54:22 +02001690 if (objt_server(s->target) && objt_server(s->target)->flags & SRV_F_NON_STICK) {
Simon Hormanfa461682011-06-25 09:39:49 +09001691 stksess_free(s->store[i].table, s->store[i].ts);
1692 s->store[i].ts = NULL;
1693 continue;
1694 }
1695
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001696 ts = stktable_lookup(s->store[i].table, s->store[i].ts);
1697 if (ts) {
1698 /* the entry already existed, we can free ours */
Emeric Brun85e77c72010-09-23 18:16:52 +02001699 stktable_touch(s->store[i].table, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001700 stksess_free(s->store[i].table, s->store[i].ts);
Emeric Brun1d33b292010-01-04 15:47:17 +01001701 }
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001702 else
Emeric Brun85e77c72010-09-23 18:16:52 +02001703 ts = stktable_store(s->store[i].table, s->store[i].ts, 1);
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001704
1705 s->store[i].ts = NULL;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001706 ptr = stktable_data_ptr(s->store[i].table, ts, STKTABLE_DT_SERVER_ID);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001707 stktable_data_cast(ptr, server_id) = objt_server(s->target)->puid;
Emeric Brun1d33b292010-01-04 15:47:17 +01001708 }
Willy Tarreau2a164ee2010-06-18 09:57:45 +02001709 s->store_count = 0; /* everything is stored */
Emeric Brun1d33b292010-01-04 15:47:17 +01001710
1711 rep->analysers &= ~an_bit;
1712 rep->analyse_exp = TICK_ETERNITY;
1713 return 1;
1714}
1715
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001716/* This macro is very specific to the function below. See the comments in
1717 * process_session() below to understand the logic and the tests.
1718 */
1719#define UPDATE_ANALYSERS(real, list, back, flag) { \
1720 list = (((list) & ~(flag)) | ~(back)) & (real); \
1721 back = real; \
1722 if (!(list)) \
1723 break; \
1724 if (((list) ^ ((list) & ((list) - 1))) < (flag)) \
1725 continue; \
1726}
1727
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001728/* Processes the client, server, request and response jobs of a session task,
1729 * then puts it back to the wait queue in a clean state, or cleans up its
1730 * resources if it must be deleted. Returns in <next> the date the task wants
1731 * to be woken up, or TICK_ETERNITY. In order not to call all functions for
1732 * nothing too many times, the request and response buffers flags are monitored
1733 * and each function is called only if at least another function has changed at
1734 * least one flag it is interested in.
1735 */
Willy Tarreau26c25062009-03-08 09:38:41 +01001736struct task *process_session(struct task *t)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001737{
Willy Tarreau827aee92011-03-10 16:55:02 +01001738 struct server *srv;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001739 struct session *s = t->context;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001740 unsigned int rqf_last, rpf_last;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001741 unsigned int rq_prod_last, rq_cons_last;
1742 unsigned int rp_cons_last, rp_prod_last;
Willy Tarreau576507f2010-01-07 00:09:04 +01001743 unsigned int req_ana_back;
Willy Tarreau8f128b42014-11-28 15:07:47 +01001744 struct channel *req, *res;
1745 struct stream_interface *si_f, *si_b;
1746
1747 req = &s->req;
1748 res = &s->res;
1749
1750 si_f = &s->si[0];
1751 si_b = &s->si[1];
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001752
1753 //DPRINTF(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__,
Willy Tarreau8f128b42014-11-28 15:07:47 +01001754 // si_f->state, si_b->state, si_b->err_type, req->flags, res->flags);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001755
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001756 /* this data may be no longer valid, clear it */
1757 memset(&s->txn.auth, 0, sizeof(s->txn.auth));
1758
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02001759 /* This flag must explicitly be set every time */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001760 req->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
1761 res->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001762
1763 /* Keep a copy of req/rep flags so that we can detect shutdowns */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001764 rqf_last = req->flags & ~CF_MASK_ANALYSER;
1765 rpf_last = res->flags & ~CF_MASK_ANALYSER;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001766
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001767 /* we don't want the stream interface functions to recursively wake us up */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001768 si_f->flags |= SI_FL_DONT_WAKE;
1769 si_b->flags |= SI_FL_DONT_WAKE;
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001770
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001771 /* 1a: Check for low level timeouts if needed. We just set a flag on
1772 * stream interfaces when their timeouts have expired.
1773 */
1774 if (unlikely(t->state & TASK_WOKEN_TIMER)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01001775 stream_int_check_timeouts(si_f);
1776 stream_int_check_timeouts(si_b);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001777
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001778 /* check channel timeouts, and close the corresponding stream interfaces
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001779 * for future reads or writes. Note: this will also concern upper layers
1780 * but we do not touch any other flag. We must be careful and correctly
1781 * detect state changes when calling them.
1782 */
1783
Willy Tarreau8f128b42014-11-28 15:07:47 +01001784 channel_check_timeouts(req);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001785
Willy Tarreau8f128b42014-11-28 15:07:47 +01001786 if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
1787 si_b->flags |= SI_FL_NOLINGER;
1788 si_shutw(si_b);
Willy Tarreau14641402009-12-29 14:49:56 +01001789 }
1790
Willy Tarreau8f128b42014-11-28 15:07:47 +01001791 if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
1792 if (si_f->flags & SI_FL_NOHALF)
1793 si_f->flags |= SI_FL_NOLINGER;
1794 si_shutr(si_f);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001795 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001796
Willy Tarreau8f128b42014-11-28 15:07:47 +01001797 channel_check_timeouts(res);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001798
Willy Tarreau8f128b42014-11-28 15:07:47 +01001799 if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
1800 si_f->flags |= SI_FL_NOLINGER;
1801 si_shutw(si_f);
Willy Tarreau14641402009-12-29 14:49:56 +01001802 }
1803
Willy Tarreau8f128b42014-11-28 15:07:47 +01001804 if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
1805 if (si_b->flags & SI_FL_NOHALF)
1806 si_b->flags |= SI_FL_NOLINGER;
1807 si_shutr(si_b);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001808 }
Willy Tarreau798f4322012-11-08 14:49:17 +01001809
1810 /* Once in a while we're woken up because the task expires. But
1811 * this does not necessarily mean that a timeout has been reached.
1812 * So let's not run a whole session processing if only an expiration
1813 * timeout needs to be refreshed.
1814 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001815 if (!((req->flags | res->flags) &
Willy Tarreau798f4322012-11-08 14:49:17 +01001816 (CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
1817 CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01001818 !((si_f->flags | si_b->flags) & (SI_FL_EXP|SI_FL_ERR)) &&
Willy Tarreau798f4322012-11-08 14:49:17 +01001819 ((t->state & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER))
1820 goto update_exp_and_leave;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001821 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001822
Willy Tarreau10fc09e2014-11-25 19:46:36 +01001823 /* below we may emit error messages so we have to ensure that we have
1824 * our buffers properly allocated.
1825 */
Willy Tarreaua24adf02014-11-27 01:11:56 +01001826 if (!session_alloc_work_buffer(s)) {
Willy Tarreau10fc09e2014-11-25 19:46:36 +01001827 /* No buffer available, we've been subscribed to the list of
1828 * buffer waiters, let's wait for our turn.
1829 */
1830 goto update_exp_and_leave;
1831 }
1832
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001833 /* 1b: check for low-level errors reported at the stream interface.
1834 * First we check if it's a retryable error (in which case we don't
1835 * want to tell the buffer). Otherwise we report the error one level
1836 * upper by setting flags into the buffers. Note that the side towards
1837 * the client cannot have connect (hence retryable) errors. Also, the
1838 * connection setup code must be able to deal with any type of abort.
1839 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001840 srv = objt_server(s->target);
Willy Tarreau8f128b42014-11-28 15:07:47 +01001841 if (unlikely(si_f->flags & SI_FL_ERR)) {
1842 if (si_f->state == SI_ST_EST || si_f->state == SI_ST_DIS) {
1843 si_shutr(si_f);
1844 si_shutw(si_f);
1845 stream_int_report_error(si_f);
1846 if (!(req->analysers) && !(res->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001847 s->be->be_counters.cli_aborts++;
1848 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001849 if (srv)
1850 srv->counters.cli_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001851 if (!(s->flags & SN_ERR_MASK))
1852 s->flags |= SN_ERR_CLICL;
1853 if (!(s->flags & SN_FINST_MASK))
1854 s->flags |= SN_FINST_D;
1855 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001856 }
1857 }
1858
Willy Tarreau8f128b42014-11-28 15:07:47 +01001859 if (unlikely(si_b->flags & SI_FL_ERR)) {
1860 if (si_b->state == SI_ST_EST || si_b->state == SI_ST_DIS) {
1861 si_shutr(si_b);
1862 si_shutw(si_b);
1863 stream_int_report_error(si_b);
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001864 s->be->be_counters.failed_resp++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001865 if (srv)
1866 srv->counters.failed_resp++;
Willy Tarreau8f128b42014-11-28 15:07:47 +01001867 if (!(req->analysers) && !(res->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001868 s->be->be_counters.srv_aborts++;
1869 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001870 if (srv)
1871 srv->counters.srv_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001872 if (!(s->flags & SN_ERR_MASK))
1873 s->flags |= SN_ERR_SRVCL;
1874 if (!(s->flags & SN_FINST_MASK))
1875 s->flags |= SN_FINST_D;
1876 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001877 }
1878 /* note: maybe we should process connection errors here ? */
1879 }
1880
Willy Tarreau8f128b42014-11-28 15:07:47 +01001881 if (si_b->state == SI_ST_CON) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001882 /* we were trying to establish a connection on the server side,
1883 * maybe it succeeded, maybe it failed, maybe we timed out, ...
1884 */
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001885 if (unlikely(!sess_update_st_con_tcp(s)))
1886 sess_update_st_cer(s);
Willy Tarreau8f128b42014-11-28 15:07:47 +01001887 else if (si_b->state == SI_ST_EST)
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01001888 sess_establish(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001889
1890 /* state is now one of SI_ST_CON (still in progress), SI_ST_EST
1891 * (established), SI_ST_DIS (abort), SI_ST_CLO (last error),
1892 * SI_ST_ASS/SI_ST_TAR/SI_ST_REQ for retryable errors.
1893 */
1894 }
1895
Willy Tarreau8f128b42014-11-28 15:07:47 +01001896 rq_prod_last = si_f->state;
1897 rq_cons_last = si_b->state;
1898 rp_cons_last = si_f->state;
1899 rp_prod_last = si_b->state;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001900
1901 resync_stream_interface:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001902 /* Check for connection closure */
1903
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001904 DPRINTF(stderr,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001905 "[%u] %s:%d: task=%p s=%p, sfl=0x%08x, rq=%p, rp=%p, exp(r,w)=%u,%u rqf=%08x rpf=%08x rqh=%d rqt=%d rph=%d rpt=%d cs=%d ss=%d, cet=0x%x set=0x%x retr=%d\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001906 now_ms, __FUNCTION__, __LINE__,
1907 t,
1908 s, s->flags,
Willy Tarreau8f128b42014-11-28 15:07:47 +01001909 req, res,
1910 req->rex, res->wex,
1911 req->flags, res->flags,
1912 req->buf->i, req->buf->o, res->buf->i, res->buf->o, si_f->state, si_b->state,
1913 si_f->err_type, si_b->err_type,
1914 si_b->conn_retries);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001915
1916 /* nothing special to be done on client side */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001917 if (unlikely(si_f->state == SI_ST_DIS))
1918 si_f->state = SI_ST_CLO;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001919
1920 /* When a server-side connection is released, we have to count it and
1921 * check for pending connections on this server.
1922 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001923 if (unlikely(si_b->state == SI_ST_DIS)) {
1924 si_b->state = SI_ST_CLO;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001925 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001926 if (srv) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001927 if (s->flags & SN_CURR_SESS) {
1928 s->flags &= ~SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001929 srv->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001930 }
1931 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001932 if (may_dequeue_tasks(srv, s->be))
1933 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001934 }
1935 }
1936
1937 /*
1938 * Note: of the transient states (REQ, CER, DIS), only REQ may remain
1939 * at this point.
1940 */
1941
Willy Tarreau0be0ef92009-03-08 19:20:25 +01001942 resync_request:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001943 /* Analyse request */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001944 if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
1945 ((req->flags ^ rqf_last) & CF_MASK_STATIC) ||
1946 si_f->state != rq_prod_last ||
1947 si_b->state != rq_cons_last ||
Thierry FOURNIER2e05a8c2014-11-24 14:49:56 +01001948 s->task->state & TASK_WOKEN_MSG) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01001949 unsigned int flags = req->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001950
Willy Tarreau8f128b42014-11-28 15:07:47 +01001951 if (si_f->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001952 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001953 unsigned int ana_list;
1954 unsigned int ana_back;
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001955
Willy Tarreau90deb182010-01-07 00:20:41 +01001956 /* it's up to the analysers to stop new connections,
1957 * disable reading or closing. Note: if an analyser
1958 * disables any of these bits, it is responsible for
1959 * enabling them again when it disables itself, so
1960 * that other analysers are called in similar conditions.
1961 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001962 channel_auto_read(req);
1963 channel_auto_connect(req);
1964 channel_auto_close(req);
Willy Tarreauedcf6682008-11-30 23:15:34 +01001965
1966 /* We will call all analysers for which a bit is set in
Willy Tarreau8f128b42014-11-28 15:07:47 +01001967 * req->analysers, following the bit order from LSB
Willy Tarreauedcf6682008-11-30 23:15:34 +01001968 * to MSB. The analysers must remove themselves from
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001969 * the list when not needed. Any analyser may return 0
1970 * to break out of the loop, either because of missing
1971 * data to take a decision, or because it decides to
1972 * kill the session. We loop at least once through each
1973 * analyser, and we may loop again if other analysers
1974 * are added in the middle.
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001975 *
1976 * We build a list of analysers to run. We evaluate all
1977 * of these analysers in the order of the lower bit to
1978 * the higher bit. This ordering is very important.
1979 * An analyser will often add/remove other analysers,
1980 * including itself. Any changes to itself have no effect
1981 * on the loop. If it removes any other analysers, we
1982 * want those analysers not to be called anymore during
1983 * this loop. If it adds an analyser that is located
1984 * after itself, we want it to be scheduled for being
1985 * processed during the loop. If it adds an analyser
1986 * which is located before it, we want it to switch to
1987 * it immediately, even if it has already been called
1988 * once but removed since.
1989 *
1990 * In order to achieve this, we compare the analyser
1991 * list after the call with a copy of it before the
1992 * call. The work list is fed with analyser bits that
1993 * appeared during the call. Then we compare previous
1994 * work list with the new one, and check the bits that
1995 * appeared. If the lowest of these bits is lower than
1996 * the current bit, it means we have enabled a previous
1997 * analyser and must immediately loop again.
Willy Tarreauedcf6682008-11-30 23:15:34 +01001998 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001999
Willy Tarreau8f128b42014-11-28 15:07:47 +01002000 ana_list = ana_back = req->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01002001 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002002 /* Warning! ensure that analysers are always placed in ascending order! */
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02002003
Willy Tarreaufb356202010-08-03 14:02:05 +02002004 if (ana_list & AN_REQ_INSPECT_FE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002005 if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_FE))
Willy Tarreauedcf6682008-11-30 23:15:34 +01002006 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002007 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02002008 }
Willy Tarreauedcf6682008-11-30 23:15:34 +01002009
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002010 if (ana_list & AN_REQ_WAIT_HTTP) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002011 if (!http_wait_for_request(s, req, AN_REQ_WAIT_HTTP))
Willy Tarreaud787e662009-07-07 10:14:51 +02002012 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002013 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
Willy Tarreaud787e662009-07-07 10:14:51 +02002014 }
2015
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002016 if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002017 if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_FE, s->fe))
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002018 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002019 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002020 }
2021
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002022 if (ana_list & AN_REQ_SWITCHING_RULES) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002023 if (!process_switching_rules(s, req, AN_REQ_SWITCHING_RULES))
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002024 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002025 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002026 }
2027
Willy Tarreaufb356202010-08-03 14:02:05 +02002028 if (ana_list & AN_REQ_INSPECT_BE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002029 if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_BE))
Willy Tarreaufb356202010-08-03 14:02:05 +02002030 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002031 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
Willy Tarreaufb356202010-08-03 14:02:05 +02002032 }
2033
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002034 if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002035 if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_BE, s->be))
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002036 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002037 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02002038 }
2039
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002040 if (ana_list & AN_REQ_HTTP_TARPIT) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002041 if (!http_process_tarpit(s, req, AN_REQ_HTTP_TARPIT))
Willy Tarreau60b85b02008-11-30 23:28:40 +01002042 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002043 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02002044 }
Willy Tarreau60b85b02008-11-30 23:28:40 +01002045
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002046 if (ana_list & AN_REQ_SRV_RULES) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002047 if (!process_server_rules(s, req, AN_REQ_SRV_RULES))
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002048 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002049 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02002050 }
2051
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002052 if (ana_list & AN_REQ_HTTP_INNER) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002053 if (!http_process_request(s, req, AN_REQ_HTTP_INNER))
Willy Tarreauc465fd72009-08-31 00:17:18 +02002054 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002055 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
Willy Tarreauc465fd72009-08-31 00:17:18 +02002056 }
2057
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002058 if (ana_list & AN_REQ_HTTP_BODY) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002059 if (!http_wait_for_request_body(s, req, AN_REQ_HTTP_BODY))
Willy Tarreaud34af782008-11-30 23:36:37 +01002060 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002061 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02002062 }
Emeric Brun647caf12009-06-30 17:57:00 +02002063
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002064 if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002065 if (!tcp_persist_rdp_cookie(s, req, AN_REQ_PRST_RDP_COOKIE))
Emeric Brun647caf12009-06-30 17:57:00 +02002066 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002067 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
Emeric Brun647caf12009-06-30 17:57:00 +02002068 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01002069
Emeric Brun1d33b292010-01-04 15:47:17 +01002070 if (ana_list & AN_REQ_STICKING_RULES) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002071 if (!process_sticking_rules(s, req, AN_REQ_STICKING_RULES))
Emeric Brun1d33b292010-01-04 15:47:17 +01002072 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002073 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
Emeric Brun1d33b292010-01-04 15:47:17 +01002074 }
2075
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002076 if (ana_list & AN_REQ_HTTP_XFER_BODY) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002077 if (!http_request_forward_body(s, req, AN_REQ_HTTP_XFER_BODY))
Willy Tarreaud98cf932009-12-27 22:54:55 +01002078 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002079 UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01002080 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01002081 break;
2082 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002083 }
Willy Tarreau84455332009-03-15 22:34:05 +01002084
Willy Tarreau8f128b42014-11-28 15:07:47 +01002085 rq_prod_last = si_f->state;
2086 rq_cons_last = si_b->state;
2087 req->flags &= ~CF_WAKE_ONCE;
2088 rqf_last = req->flags;
Willy Tarreau815a9b22010-07-27 17:15:12 +02002089
Willy Tarreau8f128b42014-11-28 15:07:47 +01002090 if ((req->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002091 goto resync_request;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002092 }
2093
Willy Tarreau576507f2010-01-07 00:09:04 +01002094 /* we'll monitor the request analysers while parsing the response,
2095 * because some response analysers may indirectly enable new request
2096 * analysers (eg: HTTP keep-alive).
2097 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002098 req_ana_back = req->analysers;
Willy Tarreau576507f2010-01-07 00:09:04 +01002099
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002100 resync_response:
2101 /* Analyse response */
2102
Willy Tarreau8f128b42014-11-28 15:07:47 +01002103 if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
2104 (res->flags ^ rpf_last) & CF_MASK_STATIC ||
2105 si_f->state != rp_cons_last ||
2106 si_b->state != rp_prod_last ||
Thierry FOURNIER2e05a8c2014-11-24 14:49:56 +01002107 s->task->state & TASK_WOKEN_MSG) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002108 unsigned int flags = res->flags;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002109
Willy Tarreau8f128b42014-11-28 15:07:47 +01002110 if ((res->flags & CF_MASK_ANALYSER) &&
2111 (res->analysers & AN_REQ_ALL)) {
Willy Tarreau0499e352010-12-17 07:13:42 +01002112 /* Due to HTTP pipelining, the HTTP request analyser might be waiting
2113 * for some free space in the response buffer, so we might need to call
2114 * it when something changes in the response buffer, but still we pass
2115 * it the request buffer. Note that the SI state might very well still
2116 * be zero due to us returning a flow of redirects!
2117 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002118 res->analysers &= ~AN_REQ_ALL;
2119 req->flags |= CF_WAKE_ONCE;
Willy Tarreau0499e352010-12-17 07:13:42 +01002120 }
2121
Willy Tarreau8f128b42014-11-28 15:07:47 +01002122 if (si_b->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01002123 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002124 unsigned int ana_list;
2125 unsigned int ana_back;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002126
Willy Tarreau90deb182010-01-07 00:20:41 +01002127 /* it's up to the analysers to stop disable reading or
2128 * closing. Note: if an analyser disables any of these
2129 * bits, it is responsible for enabling them again when
2130 * it disables itself, so that other analysers are called
2131 * in similar conditions.
2132 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002133 channel_auto_read(res);
2134 channel_auto_close(res);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002135
2136 /* We will call all analysers for which a bit is set in
Willy Tarreau8f128b42014-11-28 15:07:47 +01002137 * res->analysers, following the bit order from LSB
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002138 * to MSB. The analysers must remove themselves from
2139 * the list when not needed. Any analyser may return 0
2140 * to break out of the loop, either because of missing
2141 * data to take a decision, or because it decides to
2142 * kill the session. We loop at least once through each
2143 * analyser, and we may loop again if other analysers
2144 * are added in the middle.
2145 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002146
Willy Tarreau8f128b42014-11-28 15:07:47 +01002147 ana_list = ana_back = res->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01002148 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002149 /* Warning! ensure that analysers are always placed in ascending order! */
2150
Emeric Brun97679e72010-09-23 17:56:44 +02002151 if (ana_list & AN_RES_INSPECT) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002152 if (!tcp_inspect_response(s, res, AN_RES_INSPECT))
Emeric Brun97679e72010-09-23 17:56:44 +02002153 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002154 UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_INSPECT);
Emeric Brun97679e72010-09-23 17:56:44 +02002155 }
2156
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002157 if (ana_list & AN_RES_WAIT_HTTP) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002158 if (!http_wait_for_response(s, res, AN_RES_WAIT_HTTP))
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002159 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002160 UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002161 }
2162
Emeric Brun1d33b292010-01-04 15:47:17 +01002163 if (ana_list & AN_RES_STORE_RULES) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002164 if (!process_store_rules(s, res, AN_RES_STORE_RULES))
Emeric Brun1d33b292010-01-04 15:47:17 +01002165 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002166 UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
Emeric Brun1d33b292010-01-04 15:47:17 +01002167 }
2168
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002169 if (ana_list & AN_RES_HTTP_PROCESS_BE) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002170 if (!http_process_res_common(s, res, AN_RES_HTTP_PROCESS_BE, s->be))
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002171 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002172 UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002173 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01002174
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002175 if (ana_list & AN_RES_HTTP_XFER_BODY) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002176 if (!http_response_forward_body(s, res, AN_RES_HTTP_XFER_BODY))
Willy Tarreaud98cf932009-12-27 22:54:55 +01002177 break;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002178 UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01002179 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01002180 break;
2181 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002182 }
2183
Willy Tarreau8f128b42014-11-28 15:07:47 +01002184 rp_cons_last = si_f->state;
2185 rp_prod_last = si_b->state;
2186 rpf_last = res->flags;
Willy Tarreau815a9b22010-07-27 17:15:12 +02002187
Willy Tarreau8f128b42014-11-28 15:07:47 +01002188 if ((res->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002189 goto resync_response;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002190 }
2191
Willy Tarreau576507f2010-01-07 00:09:04 +01002192 /* maybe someone has added some request analysers, so we must check and loop */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002193 if (req->analysers & ~req_ana_back)
Willy Tarreau576507f2010-01-07 00:09:04 +01002194 goto resync_request;
2195
Willy Tarreau8f128b42014-11-28 15:07:47 +01002196 if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
Willy Tarreau0499e352010-12-17 07:13:42 +01002197 goto resync_request;
2198
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002199 /* FIXME: here we should call protocol handlers which rely on
2200 * both buffers.
2201 */
2202
2203
2204 /*
Willy Tarreauae526782010-03-04 20:34:23 +01002205 * Now we propagate unhandled errors to the session. Normally
2206 * we're just in a data phase here since it means we have not
2207 * seen any analyser who could set an error status.
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002208 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002209 srv = objt_server(s->target);
Willy Tarreau2f976e12010-11-11 14:28:47 +01002210 if (unlikely(!(s->flags & SN_ERR_MASK))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002211 if (req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002212 /* Report it if the client got an error or a read timeout expired */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002213 req->analysers = 0;
2214 if (req->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002215 s->be->be_counters.cli_aborts++;
2216 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002217 if (srv)
2218 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002219 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002220 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002221 else if (req->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002222 s->be->be_counters.cli_aborts++;
2223 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002224 if (srv)
2225 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002226 s->flags |= SN_ERR_CLITO;
Willy Tarreauae526782010-03-04 20:34:23 +01002227 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002228 else if (req->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002229 s->be->be_counters.srv_aborts++;
2230 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002231 if (srv)
2232 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002233 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002234 }
2235 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002236 s->be->be_counters.srv_aborts++;
2237 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002238 if (srv)
2239 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002240 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002241 }
Willy Tarreau84455332009-03-15 22:34:05 +01002242 sess_set_term_flags(s);
2243 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002244 else if (res->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002245 /* Report it if the server got an error or a read timeout expired */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002246 res->analysers = 0;
2247 if (res->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002248 s->be->be_counters.srv_aborts++;
2249 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002250 if (srv)
2251 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002252 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002253 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002254 else if (res->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002255 s->be->be_counters.srv_aborts++;
2256 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002257 if (srv)
2258 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002259 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002260 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002261 else if (res->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002262 s->be->be_counters.cli_aborts++;
2263 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002264 if (srv)
2265 srv->counters.cli_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002266 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002267 }
2268 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002269 s->be->be_counters.cli_aborts++;
2270 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002271 if (srv)
2272 srv->counters.cli_aborts++;
Willy Tarreauae526782010-03-04 20:34:23 +01002273 s->flags |= SN_ERR_CLITO;
2274 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002275 sess_set_term_flags(s);
2276 }
Willy Tarreau84455332009-03-15 22:34:05 +01002277 }
2278
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002279 /*
2280 * Here we take care of forwarding unhandled data. This also includes
2281 * connection establishments and shutdown requests.
2282 */
2283
2284
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002285 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002286 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002287 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002288 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002289 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002290 if (unlikely(!req->analysers &&
2291 !(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
2292 (si_f->state >= SI_ST_EST) &&
2293 (req->to_forward != CHN_INFINITE_FORWARD))) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002294 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002295 * attached to it. If any data are left in, we'll permit them to
2296 * move.
2297 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002298 channel_auto_read(req);
2299 channel_auto_connect(req);
2300 channel_auto_close(req);
2301 buffer_flush(req->buf);
Willy Tarreau5bd8c372009-01-19 00:32:22 +01002302
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002303 /* We'll let data flow between the producer (if still connected)
2304 * to the consumer (which might possibly not be connected yet).
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002305 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002306 if (!(req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
2307 channel_forward(req, CHN_INFINITE_FORWARD);
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002308 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002309
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002310 /* check if it is wise to enable kernel splicing to forward request data */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002311 if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
2312 req->to_forward &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002313 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002314 (objt_conn(si_f->end) && __objt_conn(si_f->end)->xprt && __objt_conn(si_f->end)->xprt->rcv_pipe) &&
2315 (objt_conn(si_b->end) && __objt_conn(si_b->end)->xprt && __objt_conn(si_b->end)->xprt->snd_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002316 (pipes_used < global.maxpipes) &&
2317 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
2318 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002319 (req->flags & CF_STREAMER_FAST)))) {
2320 req->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002321 }
2322
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002323 /* reflect what the L7 analysers have seen last */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002324 rqf_last = req->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002325
2326 /*
2327 * Now forward all shutdown requests between both sides of the buffer
2328 */
2329
Willy Tarreau520d95e2009-09-19 21:04:57 +02002330 /* first, let's check if the request buffer needs to shutdown(write), which may
2331 * happen either because the input is closed or because we want to force a close
Willy Tarreau05cdd962014-05-10 14:30:07 +02002332 * once the server has begun to respond. If a half-closed timeout is set, we adjust
2333 * the other side's timeout as well.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002334 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002335 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreau05cdd962014-05-10 14:30:07 +02002336 (CF_AUTO_CLOSE|CF_SHUTR))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002337 channel_shutw_now(req);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002338 if (tick_isset(s->fe->timeout.clientfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002339 res->wto = s->fe->timeout.clientfin;
2340 res->wex = tick_add(now_ms, res->wto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002341 }
2342 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002343
2344 /* shutdown(write) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002345 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
2346 channel_is_empty(req))) {
2347 if (req->flags & CF_READ_ERROR)
2348 si_b->flags |= SI_FL_NOLINGER;
2349 si_shutw(si_b);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002350 if (tick_isset(s->be->timeout.serverfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002351 res->rto = s->be->timeout.serverfin;
2352 res->rex = tick_add(now_ms, res->rto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002353 }
Willy Tarreau8615c2a2013-06-21 08:20:19 +02002354 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002355
2356 /* shutdown(write) done on server side, we must stop the client too */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002357 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
2358 !req->analysers))
2359 channel_shutr_now(req);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002360
2361 /* shutdown(read) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002362 if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
2363 if (si_f->flags & SI_FL_NOHALF)
2364 si_f->flags |= SI_FL_NOLINGER;
2365 si_shutr(si_f);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002366 if (tick_isset(s->fe->timeout.clientfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002367 res->wto = s->fe->timeout.clientfin;
2368 res->wex = tick_add(now_ms, res->wto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002369 }
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002370 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002371
Willy Tarreau520d95e2009-09-19 21:04:57 +02002372 /* it's possible that an upper layer has requested a connection setup or abort.
2373 * There are 2 situations where we decide to establish a new connection :
2374 * - there are data scheduled for emission in the buffer
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002375 * - the CF_AUTO_CONNECT flag is set (active connection)
Willy Tarreau520d95e2009-09-19 21:04:57 +02002376 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002377 if (si_b->state == SI_ST_INI) {
2378 if (!(req->flags & CF_SHUTW)) {
2379 if ((req->flags & CF_AUTO_CONNECT) || !channel_is_empty(req)) {
Willy Tarreaucf644ed2013-09-29 17:19:56 +02002380 /* If we have an appctx, there is no connect method, so we
2381 * immediately switch to the connected state, otherwise we
2382 * perform a connection request.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002383 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002384 si_b->state = SI_ST_REQ; /* new connection requested */
2385 si_b->conn_retries = s->be->conn_retries;
Willy Tarreau520d95e2009-09-19 21:04:57 +02002386 }
Willy Tarreau73201222009-08-16 18:27:24 +02002387 }
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002388 else {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002389 si_b->state = SI_ST_CLO; /* shutw+ini = abort */
2390 channel_shutw_now(req); /* fix buffer flags upon abort */
2391 channel_shutr_now(res);
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002392 }
Willy Tarreau92795622009-03-06 12:51:23 +01002393 }
2394
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002395
2396 /* we may have a pending connection request, or a connection waiting
2397 * for completion.
2398 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002399 if (si_b->state >= SI_ST_REQ && si_b->state < SI_ST_CON) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002400 do {
2401 /* nb: step 1 might switch from QUE to ASS, but we first want
2402 * to give a chance to step 2 to perform a redirect if needed.
2403 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002404 if (si_b->state != SI_ST_REQ)
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01002405 sess_update_stream_int(s);
Willy Tarreau8f128b42014-11-28 15:07:47 +01002406 if (si_b->state == SI_ST_REQ)
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01002407 sess_prepare_conn_req(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002408
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +01002409 /* applets directly go to the ESTABLISHED state. Similarly,
2410 * servers experience the same fate when their connection
2411 * is reused.
2412 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002413 if (unlikely(si_b->state == SI_ST_EST))
Willy Tarreau7b8c4f92014-11-28 15:15:44 +01002414 sess_establish(s);
Willy Tarreaufac4bd12013-11-30 09:21:49 +01002415
Willy Tarreaub44c8732013-12-31 23:16:50 +01002416 /* Now we can add the server name to a header (if requested) */
2417 /* check for HTTP mode and proxy server_name_hdr_name != NULL */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002418 if ((si_b->state >= SI_ST_CON) &&
Willy Tarreaub44c8732013-12-31 23:16:50 +01002419 (s->be->server_id_hdr_name != NULL) &&
2420 (s->be->mode == PR_MODE_HTTP) &&
2421 objt_server(s->target)) {
2422 http_send_name_header(&s->txn, s->be, objt_server(s->target)->id);
Willy Tarreau1e5dfda2013-04-07 18:19:16 +02002423 }
2424
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002425 srv = objt_server(s->target);
Willy Tarreau8f128b42014-11-28 15:07:47 +01002426 if (si_b->state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
2427 http_perform_server_redirect(s, si_b);
2428 } while (si_b->state == SI_ST_ASS);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002429 }
2430
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002431 /* Benchmarks have shown that it's optimal to do a full resync now */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002432 if (si_f->state == SI_ST_DIS || si_b->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002433 goto resync_stream_interface;
2434
Willy Tarreau815a9b22010-07-27 17:15:12 +02002435 /* otherwise we want to check if we need to resync the req buffer or not */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002436 if ((req->flags ^ rqf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002437 goto resync_request;
2438
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002439 /* perform output updates to the response buffer */
Willy Tarreau84455332009-03-15 22:34:05 +01002440
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002441 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002442 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002443 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002444 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002445 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002446 if (unlikely(!res->analysers &&
2447 !(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
2448 (si_b->state >= SI_ST_EST) &&
2449 (res->to_forward != CHN_INFINITE_FORWARD))) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002450 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002451 * attached to it. If any data are left in, we'll permit them to
2452 * move.
2453 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002454 channel_auto_read(res);
2455 channel_auto_close(res);
2456 buffer_flush(res->buf);
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002457
2458 /* We'll let data flow between the producer (if still connected)
2459 * to the consumer.
2460 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002461 if (!(res->flags & (CF_SHUTR|CF_SHUTW_NOW)))
2462 channel_forward(res, CHN_INFINITE_FORWARD);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002463
2464 /* if we have no analyser anymore in any direction and have a
Willy Tarreau05cdd962014-05-10 14:30:07 +02002465 * tunnel timeout set, use it now. Note that we must respect
2466 * the half-closed timeouts as well.
Willy Tarreauce887fd2012-05-12 12:50:00 +02002467 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002468 if (!req->analysers && s->be->timeout.tunnel) {
2469 req->rto = req->wto = res->rto = res->wto =
Willy Tarreauce887fd2012-05-12 12:50:00 +02002470 s->be->timeout.tunnel;
Willy Tarreau05cdd962014-05-10 14:30:07 +02002471
Willy Tarreau8f128b42014-11-28 15:07:47 +01002472 if ((req->flags & CF_SHUTR) && tick_isset(s->fe->timeout.clientfin))
2473 res->wto = s->fe->timeout.clientfin;
2474 if ((req->flags & CF_SHUTW) && tick_isset(s->be->timeout.serverfin))
2475 res->rto = s->be->timeout.serverfin;
2476 if ((res->flags & CF_SHUTR) && tick_isset(s->be->timeout.serverfin))
2477 req->wto = s->be->timeout.serverfin;
2478 if ((res->flags & CF_SHUTW) && tick_isset(s->fe->timeout.clientfin))
2479 req->rto = s->fe->timeout.clientfin;
Willy Tarreau05cdd962014-05-10 14:30:07 +02002480
Willy Tarreau8f128b42014-11-28 15:07:47 +01002481 req->rex = tick_add(now_ms, req->rto);
2482 req->wex = tick_add(now_ms, req->wto);
2483 res->rex = tick_add(now_ms, res->rto);
2484 res->wex = tick_add(now_ms, res->wto);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002485 }
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002486 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002487
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002488 /* check if it is wise to enable kernel splicing to forward response data */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002489 if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
2490 res->to_forward &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002491 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002492 (objt_conn(si_f->end) && __objt_conn(si_f->end)->xprt && __objt_conn(si_f->end)->xprt->snd_pipe) &&
2493 (objt_conn(si_b->end) && __objt_conn(si_b->end)->xprt && __objt_conn(si_b->end)->xprt->rcv_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002494 (pipes_used < global.maxpipes) &&
2495 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
2496 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002497 (res->flags & CF_STREAMER_FAST)))) {
2498 res->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002499 }
2500
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002501 /* reflect what the L7 analysers have seen last */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002502 rpf_last = res->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002503
2504 /*
2505 * Now forward all shutdown requests between both sides of the buffer
2506 */
2507
2508 /*
2509 * FIXME: this is probably where we should produce error responses.
2510 */
2511
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002512 /* first, let's check if the response buffer needs to shutdown(write) */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002513 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreau05cdd962014-05-10 14:30:07 +02002514 (CF_AUTO_CLOSE|CF_SHUTR))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002515 channel_shutw_now(res);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002516 if (tick_isset(s->be->timeout.serverfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002517 req->wto = s->be->timeout.serverfin;
2518 req->wex = tick_add(now_ms, req->wto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002519 }
2520 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002521
2522 /* shutdown(write) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002523 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
2524 channel_is_empty(res))) {
2525 si_shutw(si_f);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002526 if (tick_isset(s->fe->timeout.clientfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002527 req->rto = s->fe->timeout.clientfin;
2528 req->rex = tick_add(now_ms, req->rto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002529 }
2530 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002531
2532 /* shutdown(write) done on the client side, we must stop the server too */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002533 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
2534 !res->analysers)
2535 channel_shutr_now(res);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002536
2537 /* shutdown(read) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002538 if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
2539 if (si_b->flags & SI_FL_NOHALF)
2540 si_b->flags |= SI_FL_NOLINGER;
2541 si_shutr(si_b);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002542 if (tick_isset(s->be->timeout.serverfin)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002543 req->wto = s->be->timeout.serverfin;
2544 req->wex = tick_add(now_ms, req->wto);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002545 }
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002546 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002547
Willy Tarreau8f128b42014-11-28 15:07:47 +01002548 if (si_f->state == SI_ST_DIS || si_b->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002549 goto resync_stream_interface;
2550
Willy Tarreau8f128b42014-11-28 15:07:47 +01002551 if (req->flags != rqf_last)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002552 goto resync_request;
2553
Willy Tarreau8f128b42014-11-28 15:07:47 +01002554 if ((res->flags ^ rpf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002555 goto resync_response;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002556
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002557 /* we're interested in getting wakeups again */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002558 si_f->flags &= ~SI_FL_DONT_WAKE;
2559 si_b->flags &= ~SI_FL_DONT_WAKE;
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002560
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002561 /* This is needed only when debugging is enabled, to indicate
2562 * client-side or server-side close. Please note that in the unlikely
2563 * event where both sides would close at once, the sequence is reported
2564 * on the server side first.
2565 */
2566 if (unlikely((global.mode & MODE_DEBUG) &&
2567 (!(global.mode & MODE_QUIET) ||
2568 (global.mode & MODE_VERBOSE)))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002569 if (si_b->state == SI_ST_CLO &&
2570 si_b->prev_state == SI_ST_EST) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002571 chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002572 s->uniq_id, s->be->id,
Willy Tarreau8f128b42014-11-28 15:07:47 +01002573 objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
2574 objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
Willy Tarreau89efaed2013-12-13 15:14:55 +01002575 shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002576 }
2577
Willy Tarreau8f128b42014-11-28 15:07:47 +01002578 if (si_f->state == SI_ST_CLO &&
2579 si_f->prev_state == SI_ST_EST) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002580 chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002581 s->uniq_id, s->be->id,
Willy Tarreau8f128b42014-11-28 15:07:47 +01002582 objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
2583 objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
Willy Tarreau89efaed2013-12-13 15:14:55 +01002584 shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002585 }
2586 }
2587
Willy Tarreau8f128b42014-11-28 15:07:47 +01002588 if (likely((si_f->state != SI_ST_CLO) ||
2589 (si_b->state > SI_ST_INI && si_b->state < SI_ST_CLO))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002590
2591 if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
2592 session_process_counters(s);
2593
Willy Tarreau8f128b42014-11-28 15:07:47 +01002594 if (si_f->state == SI_ST_EST && obj_type(si_f->end) != OBJ_TYPE_APPCTX)
2595 si_update(si_f);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002596
Willy Tarreau8f128b42014-11-28 15:07:47 +01002597 if (si_b->state == SI_ST_EST && obj_type(si_b->end) != OBJ_TYPE_APPCTX)
2598 si_update(si_b);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002599
Willy Tarreau8f128b42014-11-28 15:07:47 +01002600 req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
2601 res->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
2602 si_f->prev_state = si_f->state;
2603 si_b->prev_state = si_b->state;
2604 si_f->flags &= ~(SI_FL_ERR|SI_FL_EXP);
2605 si_b->flags &= ~(SI_FL_ERR|SI_FL_EXP);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002606
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02002607 /* Trick: if a request is being waiting for the server to respond,
2608 * and if we know the server can timeout, we don't want the timeout
2609 * to expire on the client side first, but we're still interested
2610 * in passing data from the client to the server (eg: POST). Thus,
2611 * we can cancel the client's request timeout if the server's
2612 * request timeout is set and the server has not yet sent a response.
2613 */
2614
Willy Tarreau8f128b42014-11-28 15:07:47 +01002615 if ((res->flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
2616 (tick_isset(req->wex) || tick_isset(res->rex))) {
2617 req->flags |= CF_READ_NOEXP;
2618 req->rex = TICK_ETERNITY;
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02002619 }
2620
Willy Tarreaucf644ed2013-09-29 17:19:56 +02002621 /* When any of the stream interfaces is attached to an applet,
2622 * we have to call it here. Note that this one may wake the
2623 * task up again. If at least one applet was called, the current
2624 * task might have been woken up, in which case we don't want it
2625 * to be requeued to the wait queue but rather to the run queue
2626 * to run ASAP. The bitwise "or" in the condition ensures that
2627 * both functions are always called and that we wake up if at
2628 * least one did something.
Willy Tarreau1accfc02009-09-05 20:57:35 +02002629 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002630 if ((si_applet_call(si_b) | si_applet_call(si_f)) != 0) {
Willy Tarreau1accfc02009-09-05 20:57:35 +02002631 if (task_in_rq(t)) {
Willy Tarreau1accfc02009-09-05 20:57:35 +02002632 t->expire = TICK_ETERNITY;
Willy Tarreau10fc09e2014-11-25 19:46:36 +01002633 session_release_buffers(s);
Willy Tarreau1accfc02009-09-05 20:57:35 +02002634 return t;
2635 }
2636 }
2637
Willy Tarreau798f4322012-11-08 14:49:17 +01002638 update_exp_and_leave:
Willy Tarreau8f128b42014-11-28 15:07:47 +01002639 t->expire = tick_first(tick_first(req->rex, req->wex),
2640 tick_first(res->rex, res->wex));
2641 if (req->analysers)
2642 t->expire = tick_first(t->expire, req->analyse_exp);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002643
Willy Tarreau8f128b42014-11-28 15:07:47 +01002644 if (si_f->exp)
2645 t->expire = tick_first(t->expire, si_f->exp);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002646
Willy Tarreau8f128b42014-11-28 15:07:47 +01002647 if (si_b->exp)
2648 t->expire = tick_first(t->expire, si_b->exp);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002649
2650#ifdef DEBUG_FULL
Willy Tarreau127334e2009-03-28 10:47:26 +01002651 fprintf(stderr,
2652 "[%u] queuing with exp=%u req->rex=%u req->wex=%u req->ana_exp=%u"
2653 " rep->rex=%u rep->wex=%u, si[0].exp=%u, si[1].exp=%u, cs=%d, ss=%d\n",
Willy Tarreau8f128b42014-11-28 15:07:47 +01002654 now_ms, t->expire, req->rex, req->wex, req->analyse_exp,
2655 res->rex, res->wex, si_f->exp, si_b->exp, si_f->state, si_b->state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002656#endif
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002657
2658#ifdef DEBUG_DEV
2659 /* this may only happen when no timeout is set or in case of an FSM bug */
Willy Tarreaud0a201b2009-03-08 15:53:06 +01002660 if (!tick_isset(t->expire))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002661 ABORT_NOW();
2662#endif
Willy Tarreau10fc09e2014-11-25 19:46:36 +01002663 session_release_buffers(s);
Willy Tarreau26c25062009-03-08 09:38:41 +01002664 return t; /* nothing more to do */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002665 }
2666
2667 s->fe->feconn--;
2668 if (s->flags & SN_BE_ASSIGNED)
2669 s->be->beconn--;
Willy Tarreauaf7ad002010-08-31 15:39:26 +02002670 jobs--;
Thierry FOURNIERa47a94f2014-03-20 15:42:53 +01002671 if (s->listener) {
2672 if (!(s->listener->options & LI_O_UNLIMITED))
2673 actconn--;
2674 s->listener->nbconn--;
2675 if (s->listener->state == LI_FULL)
2676 resume_listener(s->listener);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002677
Thierry FOURNIERa47a94f2014-03-20 15:42:53 +01002678 /* Dequeues all of the listeners waiting for a resource */
2679 if (!LIST_ISEMPTY(&global_listener_queue))
2680 dequeue_all_listeners(&global_listener_queue);
Willy Tarreau08ceb102011-07-24 22:58:00 +02002681
Thierry FOURNIERa47a94f2014-03-20 15:42:53 +01002682 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
2683 (!s->fe->fe_sps_lim || freq_ctr_remain(&s->fe->fe_sess_per_sec, s->fe->fe_sps_lim, 0) > 0))
2684 dequeue_all_listeners(&s->fe->listener_queue);
2685 }
Willy Tarreau07687c12011-07-24 23:55:06 +02002686
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002687 if (unlikely((global.mode & MODE_DEBUG) &&
2688 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002689 chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002690 s->uniq_id, s->be->id,
Willy Tarreau8f128b42014-11-28 15:07:47 +01002691 objt_conn(si_f->end) ? (unsigned short)objt_conn(si_f->end)->t.sock.fd : -1,
2692 objt_conn(si_b->end) ? (unsigned short)objt_conn(si_b->end)->t.sock.fd : -1);
Willy Tarreau89efaed2013-12-13 15:14:55 +01002693 shut_your_big_mouth_gcc(write(1, trash.str, trash.len));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002694 }
2695
2696 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2697 session_process_counters(s);
2698
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002699 if (s->txn.status) {
2700 int n;
2701
2702 n = s->txn.status / 100;
2703 if (n < 1 || n > 5)
2704 n = 0;
2705
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002706 if (s->fe->mode == PR_MODE_HTTP) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002707 s->fe->fe_counters.p.http.rsp[n]++;
Willy Tarreau8139b992012-11-27 07:35:31 +01002708 if (s->comp_algo && (s->flags & SN_COMP_READY))
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002709 s->fe->fe_counters.p.http.comp_rsp++;
2710 }
Willy Tarreau24657792010-02-26 10:30:28 +01002711 if ((s->flags & SN_BE_ASSIGNED) &&
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002712 (s->be->mode == PR_MODE_HTTP)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002713 s->be->be_counters.p.http.rsp[n]++;
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002714 s->be->be_counters.p.http.cum_req++;
Willy Tarreau8139b992012-11-27 07:35:31 +01002715 if (s->comp_algo && (s->flags & SN_COMP_READY))
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002716 s->be->be_counters.p.http.comp_rsp++;
2717 }
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002718 }
2719
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002720 /* let's do a final log if we need it */
Willy Tarreaud79a3b22012-12-28 09:40:16 +01002721 if (!LIST_ISEMPTY(&s->fe->logformat) && s->logs.logwait &&
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002722 !(s->flags & SN_MONITOR) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002723 (!(s->fe->options & PR_O_NULLNOLOG) || req->total)) {
Willy Tarreaua5555ec2008-11-30 19:02:32 +01002724 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002725 }
2726
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002727 /* update time stats for this session */
2728 session_update_time_stats(s);
2729
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002730 /* the task MUST not be in the run queue anymore */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002731 session_free(s);
Willy Tarreau26c25062009-03-08 09:38:41 +01002732 task_delete(t);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002733 task_free(t);
Willy Tarreau26c25062009-03-08 09:38:41 +01002734 return NULL;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002735}
2736
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002737/* Update the session's backend and server time stats */
2738void session_update_time_stats(struct session *s)
2739{
2740 int t_request;
2741 int t_queue;
2742 int t_connect;
2743 int t_data;
2744 int t_close;
2745 struct server *srv;
2746
2747 t_request = 0;
2748 t_queue = s->logs.t_queue;
2749 t_connect = s->logs.t_connect;
2750 t_close = s->logs.t_close;
2751 t_data = s->logs.t_data;
2752
2753 if (s->be->mode != PR_MODE_HTTP)
2754 t_data = t_connect;
2755
2756 if (t_connect < 0 || t_data < 0)
2757 return;
2758
2759 if (tv_isge(&s->logs.tv_request, &s->logs.tv_accept))
2760 t_request = tv_ms_elapsed(&s->logs.tv_accept, &s->logs.tv_request);
2761
2762 t_data -= t_connect;
2763 t_connect -= t_queue;
2764 t_queue -= t_request;
2765
2766 srv = objt_server(s->target);
2767 if (srv) {
2768 swrate_add(&srv->counters.q_time, TIME_STATS_SAMPLES, t_queue);
2769 swrate_add(&srv->counters.c_time, TIME_STATS_SAMPLES, t_connect);
2770 swrate_add(&srv->counters.d_time, TIME_STATS_SAMPLES, t_data);
2771 swrate_add(&srv->counters.t_time, TIME_STATS_SAMPLES, t_close);
2772 }
2773 swrate_add(&s->be->be_counters.q_time, TIME_STATS_SAMPLES, t_queue);
2774 swrate_add(&s->be->be_counters.c_time, TIME_STATS_SAMPLES, t_connect);
2775 swrate_add(&s->be->be_counters.d_time, TIME_STATS_SAMPLES, t_data);
2776 swrate_add(&s->be->be_counters.t_time, TIME_STATS_SAMPLES, t_close);
2777}
2778
Willy Tarreau7c669d72008-06-20 15:04:11 +02002779/*
2780 * This function adjusts sess->srv_conn and maintains the previous and new
2781 * server's served session counts. Setting newsrv to NULL is enough to release
2782 * current connection slot. This function also notifies any LB algo which might
2783 * expect to be informed about any change in the number of active sessions on a
2784 * server.
2785 */
2786void sess_change_server(struct session *sess, struct server *newsrv)
2787{
2788 if (sess->srv_conn == newsrv)
2789 return;
2790
2791 if (sess->srv_conn) {
2792 sess->srv_conn->served--;
2793 if (sess->srv_conn->proxy->lbprm.server_drop_conn)
2794 sess->srv_conn->proxy->lbprm.server_drop_conn(sess->srv_conn);
Simon Hormanaf514952011-06-21 14:34:57 +09002795 session_del_srv_conn(sess);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002796 }
2797
2798 if (newsrv) {
2799 newsrv->served++;
2800 if (newsrv->proxy->lbprm.server_take_conn)
2801 newsrv->proxy->lbprm.server_take_conn(newsrv);
Simon Hormanaf514952011-06-21 14:34:57 +09002802 session_add_srv_conn(sess, newsrv);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002803 }
2804}
2805
Willy Tarreau84455332009-03-15 22:34:05 +01002806/* Handle server-side errors for default protocols. It is called whenever a a
2807 * connection setup is aborted or a request is aborted in queue. It sets the
2808 * session termination flags so that the caller does not have to worry about
2809 * them. It's installed as ->srv_error for the server-side stream_interface.
2810 */
2811void default_srv_error(struct session *s, struct stream_interface *si)
2812{
2813 int err_type = si->err_type;
2814 int err = 0, fin = 0;
2815
2816 if (err_type & SI_ET_QUEUE_ABRT) {
2817 err = SN_ERR_CLICL;
2818 fin = SN_FINST_Q;
2819 }
2820 else if (err_type & SI_ET_CONN_ABRT) {
2821 err = SN_ERR_CLICL;
2822 fin = SN_FINST_C;
2823 }
2824 else if (err_type & SI_ET_QUEUE_TO) {
2825 err = SN_ERR_SRVTO;
2826 fin = SN_FINST_Q;
2827 }
2828 else if (err_type & SI_ET_QUEUE_ERR) {
2829 err = SN_ERR_SRVCL;
2830 fin = SN_FINST_Q;
2831 }
2832 else if (err_type & SI_ET_CONN_TO) {
2833 err = SN_ERR_SRVTO;
2834 fin = SN_FINST_C;
2835 }
2836 else if (err_type & SI_ET_CONN_ERR) {
2837 err = SN_ERR_SRVCL;
2838 fin = SN_FINST_C;
2839 }
Willy Tarreau2d400bb2012-05-14 12:11:47 +02002840 else if (err_type & SI_ET_CONN_RES) {
2841 err = SN_ERR_RESOURCE;
2842 fin = SN_FINST_C;
2843 }
Willy Tarreau84455332009-03-15 22:34:05 +01002844 else /* SI_ET_CONN_OTHER and others */ {
2845 err = SN_ERR_INTERNAL;
2846 fin = SN_FINST_C;
2847 }
2848
2849 if (!(s->flags & SN_ERR_MASK))
2850 s->flags |= err;
2851 if (!(s->flags & SN_FINST_MASK))
2852 s->flags |= fin;
2853}
Willy Tarreau7c669d72008-06-20 15:04:11 +02002854
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002855/* kill a session and set the termination flags to <why> (one of SN_ERR_*) */
2856void session_shutdown(struct session *session, int why)
2857{
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002858 if (session->req.flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002859 return;
2860
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01002861 channel_shutw_now(&session->req);
2862 channel_shutr_now(&session->res);
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002863 session->task->nice = 1024;
2864 if (!(session->flags & SN_ERR_MASK))
2865 session->flags |= why;
2866 task_wakeup(session->task, TASK_WOKEN_OTHER);
2867}
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02002868
Willy Tarreau8b22a712010-06-18 17:46:06 +02002869/************************************************************************/
2870/* All supported ACL keywords must be declared here. */
2871/************************************************************************/
2872
Willy Tarreau4d4149c2013-07-23 19:33:46 +02002873/* Returns a pointer to a stkctr depending on the fetch keyword name.
2874 * It is designed to be called as sc[0-9]_* sc_* or src_* exclusively.
Willy Tarreaua65536c2013-07-22 22:40:11 +02002875 * sc[0-9]_* will return a pointer to the respective field in the
Willy Tarreau4d4149c2013-07-23 19:33:46 +02002876 * session <l4>. sc_* requires an UINT argument specifying the stick
2877 * counter number. src_* will fill a locally allocated structure with
Willy Tarreaua65536c2013-07-22 22:40:11 +02002878 * the table and entry corresponding to what is specified with src_*.
Willy Tarreau0f791d42013-07-23 19:56:43 +02002879 * NULL may be returned if the designated stkctr is not tracked. For
2880 * the sc_* and sc[0-9]_* forms, an optional table argument may be
2881 * passed. When present, the currently tracked key is then looked up
2882 * in the specified table instead of the current table. The purpose is
2883 * to be able to convery multiple values per key (eg: have gpc0 from
2884 * multiple tables).
Willy Tarreaua65536c2013-07-22 22:40:11 +02002885 */
Willy Tarreaue12704b2014-07-15 19:06:18 +02002886struct stkctr *
Willy Tarreaua65536c2013-07-22 22:40:11 +02002887smp_fetch_sc_stkctr(struct session *l4, const struct arg *args, const char *kw)
2888{
2889 static struct stkctr stkctr;
Willy Tarreau6a0b6bd2014-04-09 13:25:42 +02002890 struct stksess *stksess;
Willy Tarreau4d4149c2013-07-23 19:33:46 +02002891 unsigned int num = kw[2] - '0';
Willy Tarreau0f791d42013-07-23 19:56:43 +02002892 int arg = 0;
Willy Tarreaua65536c2013-07-22 22:40:11 +02002893
Willy Tarreau0f791d42013-07-23 19:56:43 +02002894 if (num == '_' - '0') {
2895 /* sc_* variant, args[0] = ctr# (mandatory) */
2896 num = args[arg++].data.uint;
Willy Tarreau4d4149c2013-07-23 19:33:46 +02002897 if (num >= MAX_SESS_STKCTR)
2898 return NULL;
Willy Tarreaua65536c2013-07-22 22:40:11 +02002899 }
Willy Tarreau0f791d42013-07-23 19:56:43 +02002900 else if (num > 9) { /* src_* variant, args[0] = table */
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002901 struct stktable_key *key;
2902 struct connection *conn = objt_conn(l4->si[0].end);
2903
2904 if (!conn)
2905 return NULL;
Willy Tarreaua65536c2013-07-22 22:40:11 +02002906
Thierry FOURNIER74c219d2014-04-14 14:35:40 +02002907 key = addr_to_stktable_key(&conn->addr.from, args->data.prx->table.type);
Willy Tarreaua65536c2013-07-22 22:40:11 +02002908 if (!key)
2909 return NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02002910
Willy Tarreaua65536c2013-07-22 22:40:11 +02002911 stkctr.table = &args->data.prx->table;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01002912 stkctr_set_entry(&stkctr, stktable_lookup_key(stkctr.table, key));
Willy Tarreaua65536c2013-07-22 22:40:11 +02002913 return &stkctr;
2914 }
Willy Tarreau0f791d42013-07-23 19:56:43 +02002915
2916 /* Here, <num> contains the counter number from 0 to 9 for
2917 * the sc[0-9]_ form, or even higher using sc_(num) if needed.
2918 * args[arg] is the first optional argument.
2919 */
Willy Tarreau6a0b6bd2014-04-09 13:25:42 +02002920 stksess = stkctr_entry(&l4->stkctr[num]);
2921 if (!stksess)
2922 return NULL;
2923
Willy Tarreau0f791d42013-07-23 19:56:43 +02002924 if (unlikely(args[arg].type == ARGT_TAB)) {
2925 /* an alternate table was specified, let's look up the same key there */
2926 stkctr.table = &args[arg].data.prx->table;
Willy Tarreau6a0b6bd2014-04-09 13:25:42 +02002927 stkctr_set_entry(&stkctr, stktable_lookup(stkctr.table, stksess));
Willy Tarreau0f791d42013-07-23 19:56:43 +02002928 return &stkctr;
2929 }
Willy Tarreau6a0b6bd2014-04-09 13:25:42 +02002930 return &l4->stkctr[num];
Willy Tarreaua65536c2013-07-22 22:40:11 +02002931}
2932
Willy Tarreau88821242013-07-22 18:29:29 +02002933/* set return a boolean indicating if the requested session counter is
2934 * currently being tracked or not.
2935 * Supports being called as "sc[0-9]_tracked" only.
2936 */
Willy Tarreau6f1615f2013-06-03 15:15:22 +02002937static int
Willy Tarreau88821242013-07-22 18:29:29 +02002938smp_fetch_sc_tracked(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01002939 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6f1615f2013-06-03 15:15:22 +02002940{
2941 smp->flags = SMP_F_VOL_TEST;
2942 smp->type = SMP_T_BOOL;
Thierry FOURNIERd988f212014-04-15 01:15:52 +02002943 smp->data.uint = !!smp_fetch_sc_stkctr(l4, args, kw);
Willy Tarreau6f1615f2013-06-03 15:15:22 +02002944 return 1;
2945}
2946
Willy Tarreau30b20462013-07-22 19:46:52 +02002947/* set <smp> to the General Purpose Counter 0 value from the session's tracked
2948 * frontend counters or from the src.
2949 * Supports being called as "sc[0-9]_get_gpc0" or "src_get_gpc0" only. Value
2950 * zero is returned if the key is new.
2951 */
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002952static int
Willy Tarreau30b20462013-07-22 19:46:52 +02002953smp_fetch_sc_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01002954 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002955{
Willy Tarreau30b20462013-07-22 19:46:52 +02002956 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
2957
2958 if (!stkctr)
2959 return 0;
2960
Willy Tarreau37406352012-04-23 16:16:37 +02002961 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002962 smp->type = SMP_T_UINT;
2963 smp->data.uint = 0;
Willy Tarreau30b20462013-07-22 19:46:52 +02002964
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01002965 if (stkctr_entry(stkctr) != NULL) {
2966 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002967 if (!ptr)
2968 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002969 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002970 }
2971 return 1;
2972}
2973
Willy Tarreaub5e0af02013-07-22 23:47:07 +02002974/* set <smp> to the General Purpose Counter 0's event rate from the session's
2975 * tracked frontend counters or from the src.
2976 * Supports being called as "sc[0-9]_gpc0_rate" or "src_gpc0_rate" only.
2977 * Value zero is returned if the key is new.
2978 */
Willy Tarreauba2ffd12013-05-29 15:54:14 +02002979static int
Willy Tarreaub5e0af02013-07-22 23:47:07 +02002980smp_fetch_sc_gpc0_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01002981 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauba2ffd12013-05-29 15:54:14 +02002982{
Willy Tarreaub5e0af02013-07-22 23:47:07 +02002983 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
2984
2985 if (!stkctr)
2986 return 0;
2987
Willy Tarreauba2ffd12013-05-29 15:54:14 +02002988 smp->flags = SMP_F_VOL_TEST;
2989 smp->type = SMP_T_UINT;
2990 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01002991 if (stkctr_entry(stkctr) != NULL) {
2992 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE);
Willy Tarreauba2ffd12013-05-29 15:54:14 +02002993 if (!ptr)
2994 return 0; /* parameter not stored */
2995 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
Willy Tarreaub5e0af02013-07-22 23:47:07 +02002996 stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u);
Willy Tarreauba2ffd12013-05-29 15:54:14 +02002997 }
2998 return 1;
2999}
3000
Willy Tarreau710d38c2013-07-23 00:07:04 +02003001/* Increment the General Purpose Counter 0 value from the session's tracked
3002 * frontend counters and return it into temp integer.
3003 * Supports being called as "sc[0-9]_inc_gpc0" or "src_inc_gpc0" only.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02003004 */
3005static int
Willy Tarreau710d38c2013-07-23 00:07:04 +02003006smp_fetch_sc_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003007 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02003008{
Willy Tarreau710d38c2013-07-23 00:07:04 +02003009 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3010
3011 if (!stkctr)
3012 return 0;
3013
Willy Tarreau37406352012-04-23 16:16:37 +02003014 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003015 smp->type = SMP_T_UINT;
3016 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003017 if (stkctr_entry(stkctr) != NULL) {
Willy Tarreauba2ffd12013-05-29 15:54:14 +02003018 void *ptr;
3019
3020 /* First, update gpc0_rate if it's tracked. Second, update its
3021 * gpc0 if tracked. Returns gpc0's value otherwise the curr_ctr.
3022 */
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003023 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE);
Willy Tarreauba2ffd12013-05-29 15:54:14 +02003024 if (ptr) {
3025 update_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
Willy Tarreau710d38c2013-07-23 00:07:04 +02003026 stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u, 1);
Willy Tarreauba2ffd12013-05-29 15:54:14 +02003027 smp->data.uint = (&stktable_data_cast(ptr, gpc0_rate))->curr_ctr;
3028 }
3029
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003030 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
Willy Tarreauba2ffd12013-05-29 15:54:14 +02003031 if (ptr)
3032 smp->data.uint = ++stktable_data_cast(ptr, gpc0);
3033
Willy Tarreauc3bd9722010-06-20 12:47:25 +02003034 }
3035 return 1;
3036}
3037
Willy Tarreaub9f441d2013-07-23 00:10:35 +02003038/* Clear the General Purpose Counter 0 value from the session's tracked
3039 * frontend counters and return its previous value into temp integer.
3040 * Supports being called as "sc[0-9]_clr_gpc0" or "src_clr_gpc0" only.
Willy Tarreauf73cd112011-08-13 01:45:16 +02003041 */
3042static int
Willy Tarreaub9f441d2013-07-23 00:10:35 +02003043smp_fetch_sc_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003044 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauf73cd112011-08-13 01:45:16 +02003045{
Willy Tarreaub9f441d2013-07-23 00:10:35 +02003046 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3047
3048 if (!stkctr)
3049 return 0;
3050
Willy Tarreau37406352012-04-23 16:16:37 +02003051 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003052 smp->type = SMP_T_UINT;
3053 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003054 if (stkctr_entry(stkctr) != NULL) {
3055 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
Willy Tarreauf73cd112011-08-13 01:45:16 +02003056 if (!ptr)
3057 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003058 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauf73cd112011-08-13 01:45:16 +02003059 stktable_data_cast(ptr, gpc0) = 0;
3060 }
3061 return 1;
3062}
3063
Willy Tarreau3b46c5c2013-07-23 00:22:50 +02003064/* set <smp> to the cumulated number of connections from the session's tracked
3065 * frontend counters. Supports being called as "sc[0-9]_conn_cnt" or
3066 * "src_conn_cnt" only.
3067 */
Willy Tarreau9a3f8492010-06-18 19:53:25 +02003068static int
Willy Tarreau3b46c5c2013-07-23 00:22:50 +02003069smp_fetch_sc_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003070 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02003071{
Willy Tarreau3b46c5c2013-07-23 00:22:50 +02003072 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3073
3074 if (!stkctr)
3075 return 0;
3076
Willy Tarreau37406352012-04-23 16:16:37 +02003077 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003078 smp->type = SMP_T_UINT;
3079 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003080 if (stkctr_entry(stkctr) != NULL) {
3081 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CNT);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02003082 if (!ptr)
3083 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003084 smp->data.uint = stktable_data_cast(ptr, conn_cnt);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02003085 }
Willy Tarreau9a3f8492010-06-18 19:53:25 +02003086 return 1;
3087}
3088
Willy Tarreauc8c65702013-07-23 15:09:35 +02003089/* set <smp> to the connection rate from the session's tracked frontend
3090 * counters. Supports being called as "sc[0-9]_conn_rate" or "src_conn_rate"
3091 * only.
3092 */
Willy Tarreau91c43d72010-06-20 11:19:22 +02003093static int
Willy Tarreauc8c65702013-07-23 15:09:35 +02003094smp_fetch_sc_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003095 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003096{
Willy Tarreauc8c65702013-07-23 15:09:35 +02003097 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3098
3099 if (!stkctr)
3100 return 0;
3101
Willy Tarreau37406352012-04-23 16:16:37 +02003102 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003103 smp->type = SMP_T_UINT;
3104 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003105 if (stkctr_entry(stkctr) != NULL) {
3106 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_RATE);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003107 if (!ptr)
3108 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003109 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
Willy Tarreauc8c65702013-07-23 15:09:35 +02003110 stkctr->table->data_arg[STKTABLE_DT_CONN_RATE].u);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003111 }
3112 return 1;
3113}
3114
Willy Tarreaua5e37562011-12-16 17:06:15 +01003115/* set temp integer to the number of connections from the session's source address
Willy Tarreau8b22a712010-06-18 17:46:06 +02003116 * in the table pointed to by expr, after updating it.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003117 * Accepts exactly 1 argument of type table.
Willy Tarreau8b22a712010-06-18 17:46:06 +02003118 */
3119static int
Willy Tarreau281c7992013-01-08 01:23:27 +01003120smp_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003121 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau8b22a712010-06-18 17:46:06 +02003122{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02003123 struct connection *conn = objt_conn(l4->si[0].end);
Willy Tarreau8b22a712010-06-18 17:46:06 +02003124 struct stksess *ts;
3125 struct stktable_key *key;
3126 void *ptr;
3127
Willy Tarreaub363a1f2013-10-01 10:45:07 +02003128 if (!conn)
3129 return 0;
3130
Thierry FOURNIER74c219d2014-04-14 14:35:40 +02003131 key = addr_to_stktable_key(&conn->addr.from, px->table.type);
Willy Tarreau8b22a712010-06-18 17:46:06 +02003132 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003133 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02003134
Willy Tarreau24e32d82012-04-23 23:55:44 +02003135 px = args->data.prx;
Willy Tarreau8b22a712010-06-18 17:46:06 +02003136
Willy Tarreau1f7e9252010-06-20 12:27:21 +02003137 if ((ts = stktable_update_key(&px->table, key)) == NULL)
3138 /* entry does not exist and could not be created */
3139 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02003140
3141 ptr = stktable_data_ptr(&px->table, ts, STKTABLE_DT_CONN_CNT);
3142 if (!ptr)
3143 return 0; /* parameter not stored in this table */
3144
Willy Tarreauf853c462012-04-23 18:53:56 +02003145 smp->type = SMP_T_UINT;
3146 smp->data.uint = ++stktable_data_cast(ptr, conn_cnt);
Willy Tarreau37406352012-04-23 16:16:37 +02003147 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau8b22a712010-06-18 17:46:06 +02003148 return 1;
3149}
3150
Willy Tarreauf44a5532013-07-23 15:17:53 +02003151/* set <smp> to the number of concurrent connections from the session's tracked
3152 * frontend counters. Supports being called as "sc[0-9]_conn_cur" or
3153 * "src_conn_cur" only.
3154 */
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02003155static int
Willy Tarreauf44a5532013-07-23 15:17:53 +02003156smp_fetch_sc_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003157 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02003158{
Willy Tarreauf44a5532013-07-23 15:17:53 +02003159 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3160
3161 if (!stkctr)
3162 return 0;
3163
Willy Tarreau37406352012-04-23 16:16:37 +02003164 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003165 smp->type = SMP_T_UINT;
3166 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003167 if (stkctr_entry(stkctr) != NULL) {
3168 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CUR);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02003169 if (!ptr)
3170 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003171 smp->data.uint = stktable_data_cast(ptr, conn_cur);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02003172 }
3173 return 1;
3174}
3175
Willy Tarreau20843082013-07-23 15:35:33 +02003176/* set <smp> to the cumulated number of sessions from the session's tracked
3177 * frontend counters. Supports being called as "sc[0-9]_sess_cnt" or
3178 * "src_sess_cnt" only.
3179 */
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003180static int
Willy Tarreau20843082013-07-23 15:35:33 +02003181smp_fetch_sc_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003182 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003183{
Willy Tarreau20843082013-07-23 15:35:33 +02003184 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3185
3186 if (!stkctr)
3187 return 0;
3188
Willy Tarreau37406352012-04-23 16:16:37 +02003189 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003190 smp->type = SMP_T_UINT;
3191 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003192 if (stkctr_entry(stkctr) != NULL) {
3193 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003194 if (!ptr)
3195 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003196 smp->data.uint = stktable_data_cast(ptr, sess_cnt);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003197 }
3198 return 1;
3199}
3200
Willy Tarreau3a96f3f2013-07-23 15:48:01 +02003201/* set <smp> to the session rate from the session's tracked frontend counters.
3202 * Supports being called as "sc[0-9]_sess_rate" or "src_sess_rate" only.
3203 */
Willy Tarreau91c43d72010-06-20 11:19:22 +02003204static int
Willy Tarreau3a96f3f2013-07-23 15:48:01 +02003205smp_fetch_sc_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003206 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003207{
Willy Tarreau3a96f3f2013-07-23 15:48:01 +02003208 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3209
3210 if (!stkctr)
3211 return 0;
3212
Willy Tarreau37406352012-04-23 16:16:37 +02003213 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003214 smp->type = SMP_T_UINT;
3215 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003216 if (stkctr_entry(stkctr) != NULL) {
3217 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003218 if (!ptr)
3219 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003220 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau3a96f3f2013-07-23 15:48:01 +02003221 stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003222 }
3223 return 1;
3224}
3225
Willy Tarreau91200da2013-07-23 15:55:19 +02003226/* set <smp> to the cumulated number of HTTP requests from the session's tracked
3227 * frontend counters. Supports being called as "sc[0-9]_http_req_cnt" or
3228 * "src_http_req_cnt" only.
3229 */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003230static int
Willy Tarreau91200da2013-07-23 15:55:19 +02003231smp_fetch_sc_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003232 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003233{
Willy Tarreau91200da2013-07-23 15:55:19 +02003234 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3235
3236 if (!stkctr)
3237 return 0;
3238
Willy Tarreau37406352012-04-23 16:16:37 +02003239 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003240 smp->type = SMP_T_UINT;
3241 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003242 if (stkctr_entry(stkctr) != NULL) {
3243 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003244 if (!ptr)
3245 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003246 smp->data.uint = stktable_data_cast(ptr, http_req_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003247 }
3248 return 1;
3249}
3250
Willy Tarreaucf477632013-07-23 16:04:37 +02003251/* set <smp> to the HTTP request rate from the session's tracked frontend
3252 * counters. Supports being called as "sc[0-9]_http_req_rate" or
3253 * "src_http_req_rate" only.
3254 */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003255static int
Willy Tarreaucf477632013-07-23 16:04:37 +02003256smp_fetch_sc_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003257 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003258{
Willy Tarreaucf477632013-07-23 16:04:37 +02003259 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3260
3261 if (!stkctr)
3262 return 0;
3263
Willy Tarreau37406352012-04-23 16:16:37 +02003264 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003265 smp->type = SMP_T_UINT;
3266 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003267 if (stkctr_entry(stkctr) != NULL) {
3268 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003269 if (!ptr)
3270 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003271 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreaucf477632013-07-23 16:04:37 +02003272 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003273 }
3274 return 1;
3275}
3276
Willy Tarreau30d07c32013-07-23 16:45:38 +02003277/* set <smp> to the cumulated number of HTTP requests errors from the session's
3278 * tracked frontend counters. Supports being called as "sc[0-9]_http_err_cnt" or
3279 * "src_http_err_cnt" only.
3280 */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003281static int
Willy Tarreau30d07c32013-07-23 16:45:38 +02003282smp_fetch_sc_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003283 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003284{
Willy Tarreau30d07c32013-07-23 16:45:38 +02003285 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3286
3287 if (!stkctr)
3288 return 0;
3289
Willy Tarreau37406352012-04-23 16:16:37 +02003290 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003291 smp->type = SMP_T_UINT;
3292 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003293 if (stkctr_entry(stkctr) != NULL) {
3294 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003295 if (!ptr)
3296 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003297 smp->data.uint = stktable_data_cast(ptr, http_err_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003298 }
3299 return 1;
3300}
3301
Willy Tarreau9daf2622013-07-23 16:48:54 +02003302/* set <smp> to the HTTP request error rate from the session's tracked frontend
3303 * counters. Supports being called as "sc[0-9]_http_err_rate" or
3304 * "src_http_err_rate" only.
3305 */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003306static int
Willy Tarreau9daf2622013-07-23 16:48:54 +02003307smp_fetch_sc_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003308 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003309{
Willy Tarreau9daf2622013-07-23 16:48:54 +02003310 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3311
3312 if (!stkctr)
3313 return 0;
3314
Willy Tarreau37406352012-04-23 16:16:37 +02003315 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003316 smp->type = SMP_T_UINT;
3317 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003318 if (stkctr_entry(stkctr) != NULL) {
3319 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003320 if (!ptr)
3321 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003322 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreau9daf2622013-07-23 16:48:54 +02003323 stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003324 }
3325 return 1;
3326}
3327
Willy Tarreau5077d4b2013-07-23 17:17:10 +02003328/* set <smp> to the number of kbytes received from clients, as found in the
3329 * session's tracked frontend counters. Supports being called as
3330 * "sc[0-9]_kbytes_in" or "src_kbytes_in" only.
3331 */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003332static int
Willy Tarreau5077d4b2013-07-23 17:17:10 +02003333smp_fetch_sc_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003334 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003335{
Willy Tarreau5077d4b2013-07-23 17:17:10 +02003336 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3337
3338 if (!stkctr)
3339 return 0;
3340
Willy Tarreau37406352012-04-23 16:16:37 +02003341 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003342 smp->type = SMP_T_UINT;
3343 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003344 if (stkctr_entry(stkctr) != NULL) {
3345 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_CNT);
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003346 if (!ptr)
3347 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003348 smp->data.uint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003349 }
3350 return 1;
3351}
3352
Willy Tarreau613fe992013-07-23 17:39:19 +02003353/* set <smp> to the data rate received from clients in bytes/s, as found
3354 * in the session's tracked frontend counters. Supports being called as
3355 * "sc[0-9]_bytes_in_rate" or "src_bytes_in_rate" only.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003356 */
3357static int
Willy Tarreau613fe992013-07-23 17:39:19 +02003358smp_fetch_sc_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003359 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003360{
Willy Tarreau613fe992013-07-23 17:39:19 +02003361 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3362
3363 if (!stkctr)
3364 return 0;
3365
Willy Tarreau37406352012-04-23 16:16:37 +02003366 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003367 smp->type = SMP_T_UINT;
3368 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003369 if (stkctr_entry(stkctr) != NULL) {
3370 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_RATE);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003371 if (!ptr)
3372 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003373 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau613fe992013-07-23 17:39:19 +02003374 stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003375 }
3376 return 1;
3377}
3378
Willy Tarreau53aea102013-07-23 17:39:02 +02003379/* set <smp> to the number of kbytes sent to clients, as found in the
3380 * session's tracked frontend counters. Supports being called as
3381 * "sc[0-9]_kbytes_out" or "src_kbytes_out" only.
3382 */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003383static int
Willy Tarreau53aea102013-07-23 17:39:02 +02003384smp_fetch_sc_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003385 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003386{
Willy Tarreau53aea102013-07-23 17:39:02 +02003387 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3388
3389 if (!stkctr)
3390 return 0;
3391
Willy Tarreau37406352012-04-23 16:16:37 +02003392 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003393 smp->type = SMP_T_UINT;
3394 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003395 if (stkctr_entry(stkctr) != NULL) {
3396 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003397 if (!ptr)
3398 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003399 smp->data.uint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003400 }
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003401 return 1;
3402}
3403
Willy Tarreaua0b68ed2013-07-23 18:26:32 +02003404/* set <smp> to the data rate sent to clients in bytes/s, as found in the
3405 * session's tracked frontend counters. Supports being called as
3406 * "sc[0-9]_bytes_out_rate" or "src_bytes_out_rate" only.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003407 */
3408static int
Willy Tarreaua0b68ed2013-07-23 18:26:32 +02003409smp_fetch_sc_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003410 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003411{
Willy Tarreaua0b68ed2013-07-23 18:26:32 +02003412 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
3413
3414 if (!stkctr)
3415 return 0;
3416
Willy Tarreau37406352012-04-23 16:16:37 +02003417 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003418 smp->type = SMP_T_UINT;
3419 smp->data.uint = 0;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003420 if (stkctr_entry(stkctr) != NULL) {
3421 void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_RATE);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003422 if (!ptr)
3423 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003424 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreaua0b68ed2013-07-23 18:26:32 +02003425 stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003426 }
3427 return 1;
3428}
3429
Willy Tarreau563eef42013-07-23 18:32:02 +02003430/* set <smp> to the number of active trackers on the SC entry in the session's
3431 * tracked frontend counters. Supports being called as "sc[0-9]_trackers" only.
3432 */
Willy Tarreau2406db42012-12-09 12:16:43 +01003433static int
Willy Tarreau563eef42013-07-23 18:32:02 +02003434smp_fetch_sc_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003435 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau2406db42012-12-09 12:16:43 +01003436{
Willy Tarreau563eef42013-07-23 18:32:02 +02003437 struct stkctr *stkctr = smp_fetch_sc_stkctr(l4, args, kw);
Willy Tarreau2406db42012-12-09 12:16:43 +01003438
Willy Tarreau563eef42013-07-23 18:32:02 +02003439 if (!stkctr)
Willy Tarreau2406db42012-12-09 12:16:43 +01003440 return 0;
3441
Willy Tarreau563eef42013-07-23 18:32:02 +02003442 smp->flags = SMP_F_VOL_TEST;
3443 smp->type = SMP_T_UINT;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +01003444 smp->data.uint = stkctr_entry(stkctr)->ref_cnt;
Willy Tarreau563eef42013-07-23 18:32:02 +02003445 return 1;
Willy Tarreaue25c9172013-05-28 18:32:20 +02003446}
3447
Willy Tarreau34db1082012-04-19 17:16:54 +02003448/* set temp integer to the number of used entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003449 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003450 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003451static int
Willy Tarreau281c7992013-01-08 01:23:27 +01003452smp_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003453 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauc735a072011-03-29 00:57:02 +02003454{
Willy Tarreau37406352012-04-23 16:16:37 +02003455 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003456 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02003457 smp->data.uint = args->data.prx->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003458 return 1;
3459}
3460
Willy Tarreau34db1082012-04-19 17:16:54 +02003461/* set temp integer to the number of free entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003462 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003463 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003464static int
Willy Tarreau281c7992013-01-08 01:23:27 +01003465smp_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Thierry FOURNIERf41a8092014-12-07 18:37:57 +01003466 const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauc735a072011-03-29 00:57:02 +02003467{
Willy Tarreau24e32d82012-04-23 23:55:44 +02003468 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003469 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003470 smp->type = SMP_T_UINT;
3471 smp->data.uint = px->table.size - px->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003472 return 1;
3473}
Willy Tarreau8b22a712010-06-18 17:46:06 +02003474
Willy Tarreau61612d42012-04-19 18:42:05 +02003475/* Note: must not be declared <const> as its list will be overwritten.
3476 * Please take care of keeping this list alphabetically sorted.
3477 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003478static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau281c7992013-01-08 01:23:27 +01003479 { /* END */ },
Willy Tarreau8b22a712010-06-18 17:46:06 +02003480}};
3481
Willy Tarreau281c7992013-01-08 01:23:27 +01003482/* Note: must not be declared <const> as its list will be overwritten.
3483 * Please take care of keeping this list alphabetically sorted.
3484 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003485static struct sample_fetch_kw_list smp_fetch_keywords = {ILH, {
Willy Tarreau0f791d42013-07-23 19:56:43 +02003486 { "sc_bytes_in_rate", smp_fetch_sc_bytes_in_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3487 { "sc_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3488 { "sc_clr_gpc0", smp_fetch_sc_clr_gpc0, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3489 { "sc_conn_cnt", smp_fetch_sc_conn_cnt, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3490 { "sc_conn_cur", smp_fetch_sc_conn_cur, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3491 { "sc_conn_rate", smp_fetch_sc_conn_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3492 { "sc_get_gpc0", smp_fetch_sc_get_gpc0, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3493 { "sc_gpc0_rate", smp_fetch_sc_gpc0_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3494 { "sc_http_err_cnt", smp_fetch_sc_http_err_cnt, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3495 { "sc_http_err_rate", smp_fetch_sc_http_err_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3496 { "sc_http_req_cnt", smp_fetch_sc_http_req_cnt, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3497 { "sc_http_req_rate", smp_fetch_sc_http_req_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3498 { "sc_inc_gpc0", smp_fetch_sc_inc_gpc0, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3499 { "sc_kbytes_in", smp_fetch_sc_kbytes_in, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3500 { "sc_kbytes_out", smp_fetch_sc_kbytes_out, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3501 { "sc_sess_cnt", smp_fetch_sc_sess_cnt, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3502 { "sc_sess_rate", smp_fetch_sc_sess_rate, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3503 { "sc_tracked", smp_fetch_sc_tracked, ARG2(1,UINT,TAB), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
3504 { "sc_trackers", smp_fetch_sc_trackers, ARG2(1,UINT,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3505 { "sc0_bytes_in_rate", smp_fetch_sc_bytes_in_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3506 { "sc0_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3507 { "sc0_clr_gpc0", smp_fetch_sc_clr_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3508 { "sc0_conn_cnt", smp_fetch_sc_conn_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3509 { "sc0_conn_cur", smp_fetch_sc_conn_cur, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3510 { "sc0_conn_rate", smp_fetch_sc_conn_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3511 { "sc0_get_gpc0", smp_fetch_sc_get_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3512 { "sc0_gpc0_rate", smp_fetch_sc_gpc0_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3513 { "sc0_http_err_cnt", smp_fetch_sc_http_err_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3514 { "sc0_http_err_rate", smp_fetch_sc_http_err_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3515 { "sc0_http_req_cnt", smp_fetch_sc_http_req_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3516 { "sc0_http_req_rate", smp_fetch_sc_http_req_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3517 { "sc0_inc_gpc0", smp_fetch_sc_inc_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3518 { "sc0_kbytes_in", smp_fetch_sc_kbytes_in, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3519 { "sc0_kbytes_out", smp_fetch_sc_kbytes_out, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3520 { "sc0_sess_cnt", smp_fetch_sc_sess_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3521 { "sc0_sess_rate", smp_fetch_sc_sess_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3522 { "sc0_tracked", smp_fetch_sc_tracked, ARG1(0,TAB), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
3523 { "sc0_trackers", smp_fetch_sc_trackers, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3524 { "sc1_bytes_in_rate", smp_fetch_sc_bytes_in_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3525 { "sc1_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3526 { "sc1_clr_gpc0", smp_fetch_sc_clr_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3527 { "sc1_conn_cnt", smp_fetch_sc_conn_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3528 { "sc1_conn_cur", smp_fetch_sc_conn_cur, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3529 { "sc1_conn_rate", smp_fetch_sc_conn_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3530 { "sc1_get_gpc0", smp_fetch_sc_get_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3531 { "sc1_gpc0_rate", smp_fetch_sc_gpc0_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3532 { "sc1_http_err_cnt", smp_fetch_sc_http_err_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3533 { "sc1_http_err_rate", smp_fetch_sc_http_err_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3534 { "sc1_http_req_cnt", smp_fetch_sc_http_req_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3535 { "sc1_http_req_rate", smp_fetch_sc_http_req_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3536 { "sc1_inc_gpc0", smp_fetch_sc_inc_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3537 { "sc1_kbytes_in", smp_fetch_sc_kbytes_in, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3538 { "sc1_kbytes_out", smp_fetch_sc_kbytes_out, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3539 { "sc1_sess_cnt", smp_fetch_sc_sess_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3540 { "sc1_sess_rate", smp_fetch_sc_sess_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3541 { "sc1_tracked", smp_fetch_sc_tracked, ARG1(0,TAB), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
3542 { "sc1_trackers", smp_fetch_sc_trackers, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3543 { "sc2_bytes_in_rate", smp_fetch_sc_bytes_in_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3544 { "sc2_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3545 { "sc2_clr_gpc0", smp_fetch_sc_clr_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3546 { "sc2_conn_cnt", smp_fetch_sc_conn_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3547 { "sc2_conn_cur", smp_fetch_sc_conn_cur, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3548 { "sc2_conn_rate", smp_fetch_sc_conn_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3549 { "sc2_get_gpc0", smp_fetch_sc_get_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3550 { "sc2_gpc0_rate", smp_fetch_sc_gpc0_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3551 { "sc2_http_err_cnt", smp_fetch_sc_http_err_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3552 { "sc2_http_err_rate", smp_fetch_sc_http_err_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3553 { "sc2_http_req_cnt", smp_fetch_sc_http_req_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3554 { "sc2_http_req_rate", smp_fetch_sc_http_req_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3555 { "sc2_inc_gpc0", smp_fetch_sc_inc_gpc0, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3556 { "sc2_kbytes_in", smp_fetch_sc_kbytes_in, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3557 { "sc2_kbytes_out", smp_fetch_sc_kbytes_out, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3558 { "sc2_sess_cnt", smp_fetch_sc_sess_cnt, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3559 { "sc2_sess_rate", smp_fetch_sc_sess_rate, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3560 { "sc2_tracked", smp_fetch_sc_tracked, ARG1(0,TAB), NULL, SMP_T_BOOL, SMP_USE_INTRN, },
3561 { "sc2_trackers", smp_fetch_sc_trackers, ARG1(0,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3562 { "src_bytes_in_rate", smp_fetch_sc_bytes_in_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3563 { "src_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3564 { "src_clr_gpc0", smp_fetch_sc_clr_gpc0, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3565 { "src_conn_cnt", smp_fetch_sc_conn_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3566 { "src_conn_cur", smp_fetch_sc_conn_cur, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3567 { "src_conn_rate", smp_fetch_sc_conn_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3568 { "src_get_gpc0", smp_fetch_sc_get_gpc0, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3569 { "src_gpc0_rate", smp_fetch_sc_gpc0_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3570 { "src_http_err_cnt", smp_fetch_sc_http_err_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3571 { "src_http_err_rate", smp_fetch_sc_http_err_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3572 { "src_http_req_cnt", smp_fetch_sc_http_req_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3573 { "src_http_req_rate", smp_fetch_sc_http_req_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3574 { "src_inc_gpc0", smp_fetch_sc_inc_gpc0, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3575 { "src_kbytes_in", smp_fetch_sc_kbytes_in, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3576 { "src_kbytes_out", smp_fetch_sc_kbytes_out, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3577 { "src_sess_cnt", smp_fetch_sc_sess_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3578 { "src_sess_rate", smp_fetch_sc_sess_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3579 { "src_updt_conn_cnt", smp_fetch_src_updt_conn_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
3580 { "table_avl", smp_fetch_table_avl, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
3581 { "table_cnt", smp_fetch_table_cnt, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
Willy Tarreau281c7992013-01-08 01:23:27 +01003582 { /* END */ },
3583}};
3584
Willy Tarreau8b22a712010-06-18 17:46:06 +02003585__attribute__((constructor))
3586static void __session_init(void)
3587{
Willy Tarreau281c7992013-01-08 01:23:27 +01003588 sample_register_fetches(&smp_fetch_keywords);
Willy Tarreau8b22a712010-06-18 17:46:06 +02003589 acl_register_keywords(&acl_kws);
3590}
3591
Willy Tarreaubaaee002006-06-26 02:48:02 +02003592/*
3593 * Local variables:
3594 * c-indent-level: 8
3595 * c-basic-offset: 8
3596 * End:
3597 */