blob: 7ef518d4b047edfa6c67d59c4d878a398e85ca40 [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>
Willy Tarreaud1d54542012-09-12 22:58:11 +020036#include <proto/listener.h>
Willy Tarreau332f8bf2007-05-13 21:36:56 +020037#include <proto/log.h>
Willy Tarreaucbaaec42012-09-06 11:32:07 +020038#include <proto/raw_sock.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020039#include <proto/session.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010040#include <proto/pipe.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010041#include <proto/proto_http.h>
42#include <proto/proto_tcp.h>
Willy Tarreau1d0dfb12009-07-07 15:10:31 +020043#include <proto/proxy.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020044#include <proto/queue.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +010045#include <proto/server.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020046#include <proto/sample.h>
Emeric Brun1d33b292010-01-04 15:47:17 +010047#include <proto/stick_table.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010048#include <proto/stream_interface.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010049#include <proto/task.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020050
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020051struct pool_head *pool2_session;
Willy Tarreauf54f8bd2008-11-23 19:53:55 +010052struct list sessions;
Willy Tarreaubaaee002006-06-26 02:48:02 +020053
Willy Tarreau071e1372012-10-03 01:39:48 +020054static int conn_session_complete(struct connection *conn);
Willy Tarreau9683e9a2012-10-03 21:17:23 +020055static int conn_session_update(struct connection *conn);
Willy Tarreau2542b532012-08-31 16:01:23 +020056static struct task *expire_mini_session(struct task *t);
57int session_complete(struct session *s);
58
Willy Tarreau5e75e272012-10-02 21:21:20 +020059/* data layer callbacks for an embryonic session */
60struct data_cb sess_conn_cb = {
61 .recv = NULL,
62 .send = NULL,
Willy Tarreau9683e9a2012-10-03 21:17:23 +020063 .wake = conn_session_update,
Willy Tarreau071e1372012-10-03 01:39:48 +020064 .init = conn_session_complete,
Willy Tarreau5e75e272012-10-02 21:21:20 +020065};
66
Willy Tarreau2542b532012-08-31 16:01:23 +020067/* This function is called from the protocol layer accept() in order to
68 * instanciate a new embryonic session on behalf of a given listener and
69 * frontend. It returns a positive value upon success, 0 if the connection
70 * can be ignored, or a negative value upon critical failure. The accepted
71 * file descriptor is closed if we return <= 0.
Willy Tarreau81f9aa32010-06-01 17:45:26 +020072 */
73int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
74{
75 struct proxy *p = l->frontend;
76 struct session *s;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020077 struct task *t;
Willy Tarreauabe8ea52010-11-11 10:56:04 +010078 int ret;
79
80
81 ret = -1; /* assume unrecoverable error by default */
Willy Tarreau81f9aa32010-06-01 17:45:26 +020082
Willy Tarreaufffe1322010-11-11 09:48:16 +010083 if (unlikely((s = pool_alloc2(pool2_session)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +020084 goto out_close;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020085
Willy Tarreauf2943dc2012-10-26 20:10:28 +020086 if (unlikely((s->si[0].conn = pool_alloc2(pool2_connection)) == NULL))
87 goto out_fail_conn0;
88
89 if (unlikely((s->si[1].conn = pool_alloc2(pool2_connection)) == NULL))
90 goto out_fail_conn1;
91
Willy Tarreau2542b532012-08-31 16:01:23 +020092 /* minimum session initialization required for an embryonic session is
93 * fairly low. We need very little to execute L4 ACLs, then we need a
94 * task to make the client-side connection live on its own.
95 * - flags
96 * - stick-entry tracking
97 */
Willy Tarreau81f9aa32010-06-01 17:45:26 +020098 s->flags = 0;
99 s->logs.logwait = p->to_log;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100100 s->stkctr[0].entry = NULL;
101 s->stkctr[1].entry = NULL;
102 s->stkctr[0].table = NULL;
103 s->stkctr[1].table = NULL;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200104
Willy Tarreau2542b532012-08-31 16:01:23 +0200105 s->listener = l;
106 s->fe = p;
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100107
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200108 /* OK, we're keeping the session, so let's properly initialize the session */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200109 s->si[0].conn->t.sock.fd = cfd;
110 s->si[0].conn->ctrl = l->proto;
111 s->si[0].conn->flags = CO_FL_NONE;
Willy Tarreau14cba4b2012-11-30 17:33:05 +0100112 s->si[0].conn->err_code = CO_ER_NONE;
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200113 s->si[0].conn->addr.from = *addr;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100114 s->si[0].conn->target = &l->obj_type;
Willy Tarreau2542b532012-08-31 16:01:23 +0200115
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200116 s->logs.accept_date = date; /* user-visible date for logging */
117 s->logs.tv_accept = now; /* corrected date for internal use */
118 s->uniq_id = totalconn;
Willy Tarreau2542b532012-08-31 16:01:23 +0200119 p->feconn++;
120 /* This session was accepted, count it now */
121 if (p->feconn > p->fe_counters.conn_max)
122 p->fe_counters.conn_max = p->feconn;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200123
Willy Tarreau2542b532012-08-31 16:01:23 +0200124 proxy_inc_fe_conn_ctr(l, p);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200125
126 /* now evaluate the tcp-request layer4 rules. Since we expect to be able
127 * to abort right here as soon as possible, we check the rules before
128 * even initializing the stream interfaces.
129 */
130 if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(s)) {
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200131 /* let's do a no-linger now to close with a single RST. */
132 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100133 ret = 0; /* successful termination */
Willy Tarreau2542b532012-08-31 16:01:23 +0200134 goto out_free_session;
135 }
136
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200137#ifndef USE_ACCEPT4
138 /* Adjust some socket options if the connection was accepted by a plain
139 * accept() syscall.
140 */
Willy Tarreau82569f92012-09-27 23:48:56 +0200141 if (unlikely(fcntl(cfd, F_SETFL, O_NONBLOCK) == -1))
142 goto out_free_session;
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200143#endif
Willy Tarreau82569f92012-09-27 23:48:56 +0200144
145 /* monitor-net and health mode are processed immediately after TCP
146 * connection rules. This way it's possible to block them, but they
147 * never use the lower data layers, they send directly over the socket,
148 * as they were designed for. We first flush the socket receive buffer
149 * in order to avoid emission of an RST by the system. We ignore any
150 * error.
151 */
152 if (unlikely((p->mode == PR_MODE_HEALTH) ||
153 ((l->options & LI_O_CHK_MONNET) &&
154 addr->ss_family == AF_INET &&
155 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
156 /* we have 4 possibilities here :
157 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
158 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
159 * - HEALTH mode without HTTP check => just send "OK"
160 * - TCP mode from monitoring address => just close
161 */
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100162 recv(cfd, trash.str, trash.size, MSG_DONTWAIT);
Willy Tarreau82569f92012-09-27 23:48:56 +0200163 if (p->mode == PR_MODE_HTTP ||
164 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
165 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
166 else if (p->mode == PR_MODE_HEALTH)
167 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
168 ret = 0;
169 goto out_free_session;
170 }
171
172
Willy Tarreau22cda212012-08-31 17:43:29 +0200173 /* wait for a PROXY protocol header */
174 if (l->options & LI_O_ACC_PROXY) {
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200175 s->si[0].conn->flags |= CO_FL_ACCEPT_PROXY;
176 conn_sock_want_recv(s->si[0].conn);
Willy Tarreau22cda212012-08-31 17:43:29 +0200177 }
178
Willy Tarreau2542b532012-08-31 16:01:23 +0200179 if (unlikely((t = task_new()) == NULL))
180 goto out_free_session;
181
182 t->context = s;
183 t->nice = l->nice;
184 s->task = t;
185
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200186 /* Add the various callbacks. Right now the transport layer is present
187 * but not initialized. Also note we need to be careful as the stream
188 * int is not initialized yet.
Willy Tarreau2542b532012-08-31 16:01:23 +0200189 */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200190 conn_prepare(s->si[0].conn, &sess_conn_cb, l->proto, l->xprt, s);
Willy Tarreau2542b532012-08-31 16:01:23 +0200191
192 /* finish initialization of the accepted file descriptor */
193 fd_insert(cfd);
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200194 fdtab[cfd].owner = s->si[0].conn;
Willy Tarreau2542b532012-08-31 16:01:23 +0200195 fdtab[cfd].iocb = conn_fd_handler;
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200196 conn_data_want_recv(s->si[0].conn);
197 if (conn_xprt_init(s->si[0].conn) < 0)
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100198 goto out_free_task;
Willy Tarreau2542b532012-08-31 16:01:23 +0200199
200 /* OK, now either we have a pending handshake to execute with and
201 * then we must return to the I/O layer, or we can proceed with the
202 * end of the session initialization. In case of handshake, we also
203 * set the I/O timeout to the frontend's client timeout.
204 */
205
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200206 if (s->si[0].conn->flags & CO_FL_HANDSHAKE) {
Willy Tarreau2542b532012-08-31 16:01:23 +0200207 t->process = expire_mini_session;
208 t->expire = tick_add_ifset(now_ms, p->timeout.client);
209 task_queue(t);
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200210 s->si[0].conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200211 return 1;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200212 }
213
Willy Tarreau815f5ec2012-11-06 00:14:25 +0100214 /* OK let's complete session initialization since there is no handshake */
215 s->si[0].conn->flags |= CO_FL_CONNECTED;
Willy Tarreau2542b532012-08-31 16:01:23 +0200216 ret = session_complete(s);
217 if (ret > 0)
218 return ret;
219
220 /* Error unrolling */
221 out_free_task:
222 task_free(t);
223 out_free_session:
224 p->feconn--;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100225 if (s->stkctr[0].entry || s->stkctr[1].entry)
Willy Tarreau2542b532012-08-31 16:01:23 +0200226 session_store_counters(s);
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200227 pool_free2(pool2_connection, s->si[1].conn);
228 out_fail_conn1:
229 pool_free2(pool2_connection, s->si[0].conn);
230 out_fail_conn0:
Willy Tarreau2542b532012-08-31 16:01:23 +0200231 pool_free2(pool2_session, s);
232 out_close:
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200233 if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
Willy Tarreau2542b532012-08-31 16:01:23 +0200234 /* critical error, no more memory, try to emit a 500 response */
Willy Tarreau783f2582012-09-04 12:19:04 +0200235 struct chunk *err_msg = http_error_message(s, HTTP_ERR_500);
Willy Tarreau2542b532012-08-31 16:01:23 +0200236 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
237 }
238
239 if (fdtab[cfd].owner)
240 fd_delete(cfd);
241 else
242 close(cfd);
243 return ret;
244}
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100245
Willy Tarreau0af29122012-12-03 15:35:00 +0100246
247/* prepare the trash with a log prefix for session <s> */
248static void prepare_mini_sess_log_prefix(struct session *s)
249{
250 struct tm tm;
251 char pn[INET6_ADDRSTRLEN];
252 int ret;
253 char *end;
254
255 ret = addr_to_str(&s->si[0].conn->addr.from, pn, sizeof(pn));
256 if (ret <= 0)
257 chunk_printf(&trash, "unknown [");
258 else if (ret == AF_UNIX)
259 chunk_printf(&trash, "%s:%d [", pn, s->listener->luid);
260 else
261 chunk_printf(&trash, "%s:%d [", pn, get_host_port(&s->si[0].conn->addr.from));
262
263 get_localtime(s->logs.accept_date.tv_sec, &tm);
264 end = date2str_log(trash.str + trash.len, &tm, &(s->logs.accept_date), trash.size - trash.len);
265 trash.len = end - trash.str;
266 if (s->listener->name)
267 chunk_appendf(&trash, "] %s/%s", s->fe->id, s->listener->name);
268 else
269 chunk_appendf(&trash, "] %s/%d", s->fe->id, s->listener->luid);
270}
271
Willy Tarreau2542b532012-08-31 16:01:23 +0200272/* This function kills an existing embryonic session. It stops the connection's
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200273 * transport layer, releases assigned resources, resumes the listener if it was
Willy Tarreau2542b532012-08-31 16:01:23 +0200274 * disabled and finally kills the file descriptor.
275 */
276static void kill_mini_session(struct session *s)
277{
Willy Tarreau0af29122012-12-03 15:35:00 +0100278 int level = LOG_INFO;
279 struct connection *conn = s->si[0].conn;
280 unsigned int log = s->logs.logwait;
281 const char *err_msg;
282
283 if (s->fe->options2 & PR_O2_LOGERRORS)
284 level = LOG_ERR;
285
286 if (log && (s->fe->options & PR_O_NULLNOLOG)) {
287 /* with "option dontlognull", we don't log connections with no transfer */
Willy Tarreau8e3bf692012-12-03 15:41:18 +0100288 if (!conn->err_code ||
Willy Tarreau20879a02012-12-03 16:32:10 +0100289 conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
290 conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
Willy Tarreau0af29122012-12-03 15:35:00 +0100291 log = 0;
292 }
293
294 if (log) {
295 if (!conn->err_code && (s->task->state & TASK_WOKEN_TIMER)) {
296 if (conn->flags & CO_FL_ACCEPT_PROXY)
297 conn->err_code = CO_ER_PRX_TIMEOUT;
298 else if (conn->flags & CO_FL_SSL_WAIT_HS)
299 conn->err_code = CO_ER_SSL_TIMEOUT;
300 }
301
302 prepare_mini_sess_log_prefix(s);
303 err_msg = conn_err_code_str(conn);
304 if (err_msg)
305 send_log(s->fe, level, "%s: %s\n", trash.str, err_msg);
306 else
307 send_log(s->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
308 trash.str, conn->err_code, conn->flags);
309 }
310
Willy Tarreau2542b532012-08-31 16:01:23 +0200311 /* kill the connection now */
Willy Tarreau2b199c92012-11-23 17:32:21 +0100312 conn_full_close(s->si[0].conn);
Willy Tarreau2542b532012-08-31 16:01:23 +0200313
314 s->fe->feconn--;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100315 if (s->stkctr[0].entry || s->stkctr[1].entry)
Willy Tarreau2542b532012-08-31 16:01:23 +0200316 session_store_counters(s);
317
318 if (!(s->listener->options & LI_O_UNLIMITED))
319 actconn--;
320 jobs--;
321 s->listener->nbconn--;
322 if (s->listener->state == LI_FULL)
323 resume_listener(s->listener);
324
325 /* Dequeues all of the listeners waiting for a resource */
326 if (!LIST_ISEMPTY(&global_listener_queue))
327 dequeue_all_listeners(&global_listener_queue);
328
329 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
330 (!s->fe->fe_sps_lim || freq_ctr_remain(&s->fe->fe_sess_per_sec, s->fe->fe_sps_lim, 0) > 0))
331 dequeue_all_listeners(&s->fe->listener_queue);
332
333 task_delete(s->task);
334 task_free(s->task);
335
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200336 pool_free2(pool2_connection, s->si[1].conn);
337 pool_free2(pool2_connection, s->si[0].conn);
Willy Tarreau2542b532012-08-31 16:01:23 +0200338 pool_free2(pool2_session, s);
339}
340
Willy Tarreau22cda212012-08-31 17:43:29 +0200341/* Finish initializing a session from a connection, or kills it if the
342 * connection shows and error. Returns <0 if the connection was killed.
Willy Tarreau2542b532012-08-31 16:01:23 +0200343 */
Willy Tarreau071e1372012-10-03 01:39:48 +0200344static int conn_session_complete(struct connection *conn)
Willy Tarreau2542b532012-08-31 16:01:23 +0200345{
Willy Tarreau5e75e272012-10-02 21:21:20 +0200346 struct session *s = conn->owner;
Willy Tarreau2542b532012-08-31 16:01:23 +0200347
Willy Tarreau22cda212012-08-31 17:43:29 +0200348 if (!(conn->flags & CO_FL_ERROR) && (session_complete(s) > 0)) {
Willy Tarreau071e1372012-10-03 01:39:48 +0200349 conn->flags &= ~CO_FL_INIT_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200350 return 0;
351 }
352
353 /* kill the connection now */
354 kill_mini_session(s);
355 return -1;
356}
357
Willy Tarreau9683e9a2012-10-03 21:17:23 +0200358/* Update an embryonic session status. The connection is killed in case of
359 * error, and <0 will be returned. Otherwise it does nothing.
360 */
361static int conn_session_update(struct connection *conn)
362{
363 if (conn->flags & CO_FL_ERROR) {
364 kill_mini_session(conn->owner);
365 return -1;
366 }
367 return 0;
368}
369
Willy Tarreau2542b532012-08-31 16:01:23 +0200370/* Manages embryonic sessions timeout. It is only called when the timeout
371 * strikes and performs the required cleanup.
372 */
373static struct task *expire_mini_session(struct task *t)
374{
375 struct session *s = t->context;
376
377 if (!(t->state & TASK_WOKEN_TIMER))
378 return t;
379
380 kill_mini_session(s);
381 return NULL;
382}
383
384/* This function is called from the I/O handler which detects the end of
385 * handshake, in order to complete initialization of a valid session. It must
386 * be called with an embryonic session. It returns a positive value upon
387 * success, 0 if the connection can be ignored, or a negative value upon
388 * critical failure. The accepted file descriptor is closed if we return <= 0.
389 */
390int session_complete(struct session *s)
391{
392 struct listener *l = s->listener;
393 struct proxy *p = s->fe;
394 struct http_txn *txn;
395 struct task *t = s->task;
396 int ret;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100397 int i;
Willy Tarreau2542b532012-08-31 16:01:23 +0200398
399 ret = -1; /* assume unrecoverable error by default */
400
401 /* OK, we're keeping the session, so let's properly initialize the session */
402 LIST_ADDQ(&sessions, &s->list);
403 LIST_INIT(&s->back_refs);
Willy Tarreau5e75e272012-10-02 21:21:20 +0200404 si_takeover_conn(&s->si[0], l->proto, l->xprt);
Willy Tarreau2542b532012-08-31 16:01:23 +0200405 s->flags |= SN_INITIALIZED;
406
407 s->unique_id = NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200408
409 t->process = l->handler;
410 t->context = s;
411 t->expire = TICK_ETERNITY;
412
413 /* Note: initially, the session's backend points to the frontend.
414 * This changes later when switching rules are executed or
415 * when the default backend is assigned.
416 */
417 s->be = s->fe;
418 s->req = s->rep = NULL; /* will be allocated later */
William Lallemand82fe75c2012-10-23 10:25:10 +0200419 s->comp_algo = NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200420
421 /* Let's count a session now */
Willy Tarreaub36b4242010-06-04 20:59:39 +0200422 proxy_inc_fe_sess_ctr(l, p);
Willy Tarreau91c43d72010-06-20 11:19:22 +0200423
Willy Tarreau20d46a52012-12-09 15:55:40 +0100424 for (i = 0; i < sizeof(s->stkctr) / sizeof(s->stkctr[0]); i++) {
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200425 void *ptr;
426
Willy Tarreau20d46a52012-12-09 15:55:40 +0100427 if (!s->stkctr[i].entry)
428 continue;
429
430 ptr = stktable_data_ptr(s->stkctr[i].table, s->stkctr[i].entry, STKTABLE_DT_SESS_CNT);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200431 if (ptr)
432 stktable_data_cast(ptr, sess_cnt)++;
433
Willy Tarreau20d46a52012-12-09 15:55:40 +0100434 ptr = stktable_data_ptr(s->stkctr[i].table, s->stkctr[i].entry, STKTABLE_DT_SESS_RATE);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200435 if (ptr)
436 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau20d46a52012-12-09 15:55:40 +0100437 s->stkctr[i].table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200438 }
439
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200440 /* this part should be common with other protocols */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200441 s->si[0].owner = t;
442 s->si[0].state = s->si[0].prev_state = SI_ST_EST;
443 s->si[0].err_type = SI_ET_NONE;
444 s->si[0].err_loc = NULL;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200445 s->si[0].release = NULL;
Willy Tarreau63e7fe32012-05-08 15:20:43 +0200446 s->si[0].send_proxy_ofs = 0;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200447 s->si[0].exp = TICK_ETERNITY;
448 s->si[0].flags = SI_FL_NONE;
449
450 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
451 s->si[0].flags |= SI_FL_INDEP_STR;
452
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200453 /* pre-initialize the other side's stream interface to an INIT state. The
454 * callbacks will be initialized before attempting to connect.
455 */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200456 s->si[1].conn->t.sock.fd = -1; /* just to help with debugging */
457 s->si[1].conn->flags = CO_FL_NONE;
Willy Tarreau14cba4b2012-11-30 17:33:05 +0100458 s->si[1].conn->err_code = CO_ER_NONE;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200459 s->si[1].owner = t;
460 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
461 s->si[1].err_type = SI_ET_NONE;
Willy Tarreau0b3a4112011-03-27 19:16:56 +0200462 s->si[1].conn_retries = 0; /* used for logging too */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200463 s->si[1].err_loc = NULL;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200464 s->si[1].release = NULL;
Willy Tarreau63e7fe32012-05-08 15:20:43 +0200465 s->si[1].send_proxy_ofs = 0;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100466 s->si[1].conn->target = NULL;
Willy Tarreauc5788912012-08-24 18:12:41 +0200467 si_prepare_embedded(&s->si[1]);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200468 s->si[1].exp = TICK_ETERNITY;
469 s->si[1].flags = SI_FL_NONE;
470
471 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
472 s->si[1].flags |= SI_FL_INDEP_STR;
473
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200474 session_init_srv_conn(s);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100475 s->target = NULL;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200476 s->pend_pos = NULL;
477
478 /* init store persistence */
479 s->store_count = 0;
480
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200481 if (unlikely((s->req = pool_alloc2(pool2_channel)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200482 goto out_free_task; /* no memory */
483
Willy Tarreau9b28e032012-10-12 23:49:43 +0200484 if (unlikely((s->req->buf = pool_alloc2(pool2_buffer)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200485 goto out_free_req; /* no memory */
486
Willy Tarreau9b28e032012-10-12 23:49:43 +0200487 if (unlikely((s->rep = pool_alloc2(pool2_channel)) == NULL))
488 goto out_free_req_buf; /* no memory */
489
490 if (unlikely((s->rep->buf = pool_alloc2(pool2_buffer)) == NULL))
491 goto out_free_rep; /* no memory */
492
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200493 /* initialize the request buffer */
Willy Tarreau9b28e032012-10-12 23:49:43 +0200494 s->req->buf->size = global.tune.bufsize;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200495 channel_init(s->req);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200496 s->req->prod = &s->si[0];
497 s->req->cons = &s->si[1];
498 s->si[0].ib = s->si[1].ob = s->req;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200499 s->req->flags |= CF_READ_ATTACHED; /* the producer is already connected */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200500
501 /* activate default analysers enabled for this listener */
502 s->req->analysers = l->analysers;
503
504 s->req->wto = TICK_ETERNITY;
505 s->req->rto = TICK_ETERNITY;
506 s->req->rex = TICK_ETERNITY;
507 s->req->wex = TICK_ETERNITY;
508 s->req->analyse_exp = TICK_ETERNITY;
509
510 /* initialize response buffer */
Willy Tarreau9b28e032012-10-12 23:49:43 +0200511 s->rep->buf->size = global.tune.bufsize;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200512 channel_init(s->rep);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200513 s->rep->prod = &s->si[1];
514 s->rep->cons = &s->si[0];
515 s->si[0].ob = s->si[1].ib = s->rep;
516 s->rep->analysers = 0;
517
Willy Tarreau96e31212011-05-30 18:10:30 +0200518 if (s->fe->options2 & PR_O2_NODELAY) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200519 s->req->flags |= CF_NEVER_WAIT;
520 s->rep->flags |= CF_NEVER_WAIT;
Willy Tarreau96e31212011-05-30 18:10:30 +0200521 }
522
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200523 s->rep->rto = TICK_ETERNITY;
524 s->rep->wto = TICK_ETERNITY;
525 s->rep->rex = TICK_ETERNITY;
526 s->rep->wex = TICK_ETERNITY;
527 s->rep->analyse_exp = TICK_ETERNITY;
528
Willy Tarreau62f791e2012-03-09 11:32:30 +0100529 txn = &s->txn;
530 /* Those variables will be checked and freed if non-NULL in
531 * session.c:session_free(). It is important that they are
532 * properly initialized.
533 */
534 txn->sessid = NULL;
535 txn->srv_cookie = NULL;
536 txn->cli_cookie = NULL;
537 txn->uri = NULL;
538 txn->req.cap = NULL;
539 txn->rsp.cap = NULL;
540 txn->hdr_idx.v = NULL;
541 txn->hdr_idx.size = txn->hdr_idx.used = 0;
542 txn->req.flags = 0;
543 txn->rsp.flags = 0;
544 /* the HTTP messages need to know what buffer they're associated with */
Willy Tarreau394db372012-10-12 22:40:39 +0200545 txn->req.chn = s->req;
546 txn->rsp.chn = s->rep;
Willy Tarreau62f791e2012-03-09 11:32:30 +0100547
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200548 /* finish initialization of the accepted file descriptor */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200549 conn_data_want_recv(s->si[0].conn);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200550
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100551 if (p->accept && (ret = p->accept(s)) <= 0) {
552 /* Either we had an unrecoverable error (<0) or work is
553 * finished (=0, eg: monitoring), in both situations,
554 * we can release everything and close.
555 */
Willy Tarreau9b28e032012-10-12 23:49:43 +0200556 goto out_free_rep_buf;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200557 }
558
Willy Tarreau93dbc2b2012-10-12 18:01:49 +0200559 /* if logs require transport layer information, note it on the connection */
560 if (s->logs.logwait & LW_XPRT)
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200561 s->si[0].conn->flags |= CO_FL_XPRT_TRACKED;
Willy Tarreau93dbc2b2012-10-12 18:01:49 +0200562
Willy Tarreau2542b532012-08-31 16:01:23 +0200563 /* we want the connection handler to notify the stream interface about updates. */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200564 s->si[0].conn->flags |= CO_FL_WAKE_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200565
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200566 /* it is important not to call the wakeup function directly but to
567 * pass through task_wakeup(), because this one knows how to apply
568 * priorities to tasks.
569 */
570 task_wakeup(t, TASK_WOKEN_INIT);
571 return 1;
572
573 /* Error unrolling */
Willy Tarreau9b28e032012-10-12 23:49:43 +0200574 out_free_rep_buf:
575 pool_free2(pool2_buffer, s->rep->buf);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200576 out_free_rep:
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200577 pool_free2(pool2_channel, s->rep);
Willy Tarreau9b28e032012-10-12 23:49:43 +0200578 out_free_req_buf:
579 pool_free2(pool2_buffer, s->req->buf);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200580 out_free_req:
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200581 pool_free2(pool2_channel, s->req);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200582 out_free_task:
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100583 return ret;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200584}
585
Willy Tarreaubaaee002006-06-26 02:48:02 +0200586/*
587 * frees the context associated to a session. It must have been removed first.
588 */
Simon Hormandec5be42011-06-08 09:19:07 +0900589static void session_free(struct session *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200590{
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100591 struct http_txn *txn = &s->txn;
Willy Tarreau632f5a72007-07-11 10:42:35 +0200592 struct proxy *fe = s->fe;
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100593 struct bref *bref, *back;
Willy Tarreaua4cda672010-06-06 18:28:49 +0200594 int i;
Willy Tarreau0f7562b2007-01-07 15:46:13 +0100595
Willy Tarreaubaaee002006-06-26 02:48:02 +0200596 if (s->pend_pos)
597 pendconn_free(s->pend_pos);
Willy Tarreau922a8062008-12-04 09:33:58 +0100598
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100599 if (objt_server(s->target)) { /* there may be requests left pending in queue */
Willy Tarreau1e62de62008-11-11 20:20:02 +0100600 if (s->flags & SN_CURR_SESS) {
601 s->flags &= ~SN_CURR_SESS;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100602 objt_server(s->target)->cur_sess--;
Willy Tarreau1e62de62008-11-11 20:20:02 +0100603 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100604 if (may_dequeue_tasks(objt_server(s->target), s->be))
605 process_srv_queue(objt_server(s->target));
Willy Tarreau1e62de62008-11-11 20:20:02 +0100606 }
Willy Tarreau922a8062008-12-04 09:33:58 +0100607
Willy Tarreau7c669d72008-06-20 15:04:11 +0200608 if (unlikely(s->srv_conn)) {
609 /* the session still has a reserved slot on a server, but
610 * it should normally be only the same as the one above,
611 * so this should not happen in fact.
612 */
613 sess_change_server(s, NULL);
614 }
615
Willy Tarreau543db622012-11-15 16:41:22 +0100616 if (s->flags & SN_COMP_READY)
William Lallemand1c2d6222012-10-30 15:52:53 +0100617 s->comp_algo->end(&s->comp_ctx);
Willy Tarreau543db622012-11-15 16:41:22 +0100618 s->comp_algo = NULL;
619 s->flags &= ~SN_COMP_READY;
William Lallemand82fe75c2012-10-23 10:25:10 +0200620
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100621 if (s->req->pipe)
622 put_pipe(s->req->pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100623
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100624 if (s->rep->pipe)
625 put_pipe(s->rep->pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100626
Willy Tarreau9b28e032012-10-12 23:49:43 +0200627 pool_free2(pool2_buffer, s->req->buf);
628 pool_free2(pool2_buffer, s->rep->buf);
629
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200630 pool_free2(pool2_channel, s->req);
631 pool_free2(pool2_channel, s->rep);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200632
Willy Tarreau46023632010-01-07 22:51:47 +0100633 http_end_txn(s);
634
Willy Tarreau1e954912012-10-12 17:50:05 +0200635 /* ensure the client-side transport layer is destroyed */
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200636 s->si[0].conn->flags &= ~CO_FL_XPRT_TRACKED;
Willy Tarreau0ede5a32012-12-08 08:44:02 +0100637 conn_full_close(s->si[0].conn);
Willy Tarreau1e954912012-10-12 17:50:05 +0200638
Willy Tarreaua4cda672010-06-06 18:28:49 +0200639 for (i = 0; i < s->store_count; i++) {
640 if (!s->store[i].ts)
641 continue;
642 stksess_free(s->store[i].table, s->store[i].ts);
643 s->store[i].ts = NULL;
644 }
645
Willy Tarreau34eb6712011-10-24 18:15:04 +0200646 pool_free2(pool2_hdr_idx, txn->hdr_idx.v);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200647 if (fe) {
Willy Tarreau46023632010-01-07 22:51:47 +0100648 pool_free2(fe->rsp_cap_pool, txn->rsp.cap);
649 pool_free2(fe->req_cap_pool, txn->req.cap);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200650 }
Willy Tarreau0937bc42009-12-22 15:03:09 +0100651
Willy Tarreau20d46a52012-12-09 15:55:40 +0100652 if (s->stkctr[0].entry || s->stkctr[1].entry)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200653 session_store_counters(s);
654
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100655 list_for_each_entry_safe(bref, back, &s->back_refs, users) {
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100656 /* we have to unlink all watchers. We must not relink them if
657 * this session was the last one in the list.
658 */
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100659 LIST_DEL(&bref->users);
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100660 LIST_INIT(&bref->users);
661 if (s->list.n != &sessions)
662 LIST_ADDQ(&LIST_ELEM(s->list.n, struct session *, list)->back_refs, &bref->users);
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100663 bref->ref = s->list.n;
664 }
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100665 LIST_DEL(&s->list);
Willy Tarreauf2943dc2012-10-26 20:10:28 +0200666 pool_free2(pool2_connection, s->si[1].conn);
667 pool_free2(pool2_connection, s->si[0].conn);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200668 pool_free2(pool2_session, s);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200669
670 /* We may want to free the maximum amount of pools if the proxy is stopping */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200671 if (fe && unlikely(fe->state == PR_STSTOPPED)) {
Willy Tarreau9b28e032012-10-12 23:49:43 +0200672 pool_flush2(pool2_buffer);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200673 pool_flush2(pool2_channel);
Willy Tarreau34eb6712011-10-24 18:15:04 +0200674 pool_flush2(pool2_hdr_idx);
Willy Tarreau48d63db2008-08-03 17:41:33 +0200675 pool_flush2(pool2_requri);
676 pool_flush2(pool2_capture);
677 pool_flush2(pool2_session);
678 pool_flush2(fe->req_cap_pool);
679 pool_flush2(fe->rsp_cap_pool);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200680 }
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200681}
682
683
684/* perform minimal intializations, report 0 in case of error, 1 if OK. */
685int init_session()
686{
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100687 LIST_INIT(&sessions);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200688 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
689 return pool2_session != NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200690}
691
Willy Tarreau30e71012007-11-26 20:15:35 +0100692void session_process_counters(struct session *s)
693{
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100694 unsigned long long bytes;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100695 void *ptr;
696 int i;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100697
Willy Tarreau30e71012007-11-26 20:15:35 +0100698 if (s->req) {
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100699 bytes = s->req->total - s->logs.bytes_in;
Willy Tarreau30e71012007-11-26 20:15:35 +0100700 s->logs.bytes_in = s->req->total;
701 if (bytes) {
Willy Tarreau20d46a52012-12-09 15:55:40 +0100702 s->fe->fe_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100703
Willy Tarreau20d46a52012-12-09 15:55:40 +0100704 s->be->be_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100705
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100706 if (objt_server(s->target))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100707 objt_server(s->target)->counters.bytes_in += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200708
709 if (s->listener->counters)
Willy Tarreau20d46a52012-12-09 15:55:40 +0100710 s->listener->counters->bytes_in += bytes;
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200711
Willy Tarreau20d46a52012-12-09 15:55:40 +0100712 for (i = 0; i < sizeof(s->stkctr) / sizeof(s->stkctr[0]); i++) {
713 if (!s->stkctr[i].entry)
714 continue;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200715
Willy Tarreau20d46a52012-12-09 15:55:40 +0100716 ptr = stktable_data_ptr(s->stkctr[i].table,
717 s->stkctr[i].entry,
718 STKTABLE_DT_BYTES_IN_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200719 if (ptr)
720 stktable_data_cast(ptr, bytes_in_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200721
Willy Tarreau20d46a52012-12-09 15:55:40 +0100722 ptr = stktable_data_ptr(s->stkctr[i].table,
723 s->stkctr[i].entry,
724 STKTABLE_DT_BYTES_IN_RATE);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200725 if (ptr)
726 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau20d46a52012-12-09 15:55:40 +0100727 s->stkctr[i].table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u, bytes);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200728 }
Willy Tarreau30e71012007-11-26 20:15:35 +0100729 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100730 }
731
Willy Tarreau30e71012007-11-26 20:15:35 +0100732 if (s->rep) {
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100733 bytes = s->rep->total - s->logs.bytes_out;
Willy Tarreau30e71012007-11-26 20:15:35 +0100734 s->logs.bytes_out = s->rep->total;
735 if (bytes) {
Willy Tarreau20d46a52012-12-09 15:55:40 +0100736 s->fe->fe_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100737
Willy Tarreau20d46a52012-12-09 15:55:40 +0100738 s->be->be_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100739
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100740 if (objt_server(s->target))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100741 objt_server(s->target)->counters.bytes_out += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200742
743 if (s->listener->counters)
Willy Tarreau20d46a52012-12-09 15:55:40 +0100744 s->listener->counters->bytes_out += bytes;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200745
Willy Tarreau20d46a52012-12-09 15:55:40 +0100746 for (i = 0; i < sizeof(s->stkctr) / sizeof(s->stkctr[0]); i++) {
747 if (!s->stkctr[i].entry)
748 continue;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200749
Willy Tarreau20d46a52012-12-09 15:55:40 +0100750 ptr = stktable_data_ptr(s->stkctr[i].table,
751 s->stkctr[i].entry,
752 STKTABLE_DT_BYTES_OUT_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200753 if (ptr)
754 stktable_data_cast(ptr, bytes_out_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200755
Willy Tarreau20d46a52012-12-09 15:55:40 +0100756 ptr = stktable_data_ptr(s->stkctr[i].table,
757 s->stkctr[i].entry,
758 STKTABLE_DT_BYTES_OUT_RATE);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200759 if (ptr)
760 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreau20d46a52012-12-09 15:55:40 +0100761 s->stkctr[i].table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u, bytes);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200762 }
Willy Tarreau30e71012007-11-26 20:15:35 +0100763 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100764 }
765}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200766
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100767/* This function is called with (si->state == SI_ST_CON) meaning that a
768 * connection was attempted and that the file descriptor is already allocated.
769 * We must check for establishment, error and abort. Possible output states
770 * are SI_ST_EST (established), SI_ST_CER (error), SI_ST_DIS (abort), and
771 * SI_ST_CON (no change). The function returns 0 if it switches to SI_ST_CER,
772 * otherwise 1.
773 */
Simon Hormandec5be42011-06-08 09:19:07 +0900774static int sess_update_st_con_tcp(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100775{
Willy Tarreau7421efb2012-07-02 15:11:27 +0200776 struct channel *req = si->ob;
777 struct channel *rep = si->ib;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100778
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100779 /* If we got an error, or if nothing happened and the connection timed
780 * out, we must give up. The CER state handler will take care of retry
781 * attempts and error reports.
782 */
783 if (unlikely(si->flags & (SI_FL_EXP|SI_FL_ERR))) {
Willy Tarreaue3224e82012-10-29 22:41:31 +0100784 if (unlikely(si->ob->flags & CF_WRITE_PARTIAL)) {
785 /* Some data were sent past the connection establishment,
786 * so we need to pretend we're established to log correctly
787 * and let later states handle the failure.
788 */
789 s->logs.t_connect = tv_ms_elapsed(&s->logs.tv_accept, &now);
790 si->exp = TICK_ETERNITY;
791 si->state = SI_ST_EST;
792 si->err_type = SI_ET_DATA_ERR;
793 si->ib->flags |= CF_READ_ERROR | CF_WRITE_ERROR;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100794 si->err_loc = objt_server(s->target);
Willy Tarreaue3224e82012-10-29 22:41:31 +0100795 return 1;
796 }
Willy Tarreau127334e2009-03-28 10:47:26 +0100797 si->exp = TICK_ETERNITY;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100798 si->state = SI_ST_CER;
Willy Tarreau0ede5a32012-12-08 08:44:02 +0100799
800 si->conn->flags &= ~CO_FL_XPRT_TRACKED;
801 conn_full_close(si->conn);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100802
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200803 if (si->release)
804 si->release(si);
805
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100806 if (si->err_type)
807 return 0;
808
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100809 si->err_loc = objt_server(s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100810 if (si->flags & SI_FL_ERR)
811 si->err_type = SI_ET_CONN_ERR;
812 else
813 si->err_type = SI_ET_CONN_TO;
814 return 0;
815 }
816
817 /* OK, maybe we want to abort */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200818 if (unlikely((rep->flags & CF_SHUTW) ||
819 ((req->flags & CF_SHUTW_NOW) && /* FIXME: this should not prevent a connection from establishing */
820 ((!(req->flags & CF_WRITE_ACTIVITY) && channel_is_empty(req)) ||
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100821 s->be->options & PR_O_ABRT_CLOSE)))) {
822 /* give up */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200823 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100824 si->err_type |= SI_ET_CONN_ABRT;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100825 si->err_loc = objt_server(s->target);
Willy Tarreau84455332009-03-15 22:34:05 +0100826 if (s->srv_error)
827 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100828 return 1;
829 }
830
831 /* we need to wait a bit more if there was no activity either */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200832 if (!(req->flags & CF_WRITE_ACTIVITY))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100833 return 1;
834
835 /* OK, this means that a connection succeeded. The caller will be
836 * responsible for handling the transition from CON to EST.
837 */
838 s->logs.t_connect = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau127334e2009-03-28 10:47:26 +0100839 si->exp = TICK_ETERNITY;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100840 si->state = SI_ST_EST;
841 si->err_type = SI_ET_NONE;
842 si->err_loc = NULL;
843 return 1;
844}
845
846/* This function is called with (si->state == SI_ST_CER) meaning that a
847 * previous connection attempt has failed and that the file descriptor
848 * has already been released. Possible causes include asynchronous error
849 * notification and time out. Possible output states are SI_ST_CLO when
850 * retries are exhausted, SI_ST_TAR when a delay is wanted before a new
851 * connection attempt, SI_ST_ASS when it's wise to retry on the same server,
852 * and SI_ST_REQ when an immediate redispatch is wanted. The buffers are
853 * marked as in error state. It returns 0.
854 */
Simon Hormandec5be42011-06-08 09:19:07 +0900855static int sess_update_st_cer(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100856{
857 /* we probably have to release last session from the server */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100858 if (objt_server(s->target)) {
859 health_adjust(objt_server(s->target), HANA_STATUS_L4_ERR);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100860
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100861 if (s->flags & SN_CURR_SESS) {
862 s->flags &= ~SN_CURR_SESS;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100863 objt_server(s->target)->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100864 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100865 }
866
867 /* ensure that we have enough retries left */
Willy Tarreauee28de02010-06-01 09:51:00 +0200868 si->conn_retries--;
869 if (si->conn_retries < 0) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100870 if (!si->err_type) {
871 si->err_type = SI_ET_CONN_ERR;
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100872 si->err_loc = objt_server(s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100873 }
874
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100875 if (objt_server(s->target))
876 objt_server(s->target)->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100877 s->be->be_counters.failed_conns++;
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100878 sess_change_server(s, NULL);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100879 if (may_dequeue_tasks(objt_server(s->target), s->be))
880 process_srv_queue(objt_server(s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100881
882 /* shutw is enough so stop a connecting socket */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200883 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200884 si->ob->flags |= CF_WRITE_ERROR;
885 si->ib->flags |= CF_READ_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100886
887 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100888 if (s->srv_error)
889 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100890 return 0;
891 }
892
893 /* If the "redispatch" option is set on the backend, we are allowed to
894 * retry on another server for the last retry. In order to achieve this,
895 * we must mark the session unassigned, and eventually clear the DIRECT
896 * bit to ignore any persistence cookie. We won't count a retry nor a
897 * redispatch yet, because this will depend on what server is selected.
898 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100899 if (objt_server(s->target) && si->conn_retries == 0 &&
Willy Tarreau4de91492010-01-22 19:10:05 +0100900 s->be->options & PR_O_REDISP && !(s->flags & SN_FORCE_PRST)) {
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100901 sess_change_server(s, NULL);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100902 if (may_dequeue_tasks(objt_server(s->target), s->be))
903 process_srv_queue(objt_server(s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100904
905 s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100906 si->state = SI_ST_REQ;
907 } else {
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100908 if (objt_server(s->target))
909 objt_server(s->target)->counters.retries++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100910 s->be->be_counters.retries++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100911 si->state = SI_ST_ASS;
912 }
913
914 if (si->flags & SI_FL_ERR) {
915 /* The error was an asynchronous connection error, and we will
916 * likely have to retry connecting to the same server, most
917 * likely leading to the same result. To avoid this, we wait
918 * one second before retrying.
919 */
920
921 if (!si->err_type)
922 si->err_type = SI_ET_CONN_ERR;
923
924 si->state = SI_ST_TAR;
925 si->exp = tick_add(now_ms, MS_TO_TICKS(1000));
926 return 0;
927 }
928 return 0;
929}
930
931/*
932 * This function handles the transition between the SI_ST_CON state and the
Willy Tarreau85e7d002010-05-31 11:57:51 +0200933 * SI_ST_EST state. It must only be called after switching from SI_ST_CON (or
Willy Tarreau26d8c592012-05-07 18:12:14 +0200934 * SI_ST_INI) to SI_ST_EST, but only when a ->proto is defined.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100935 */
Simon Hormandec5be42011-06-08 09:19:07 +0900936static void sess_establish(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100937{
Willy Tarreau7421efb2012-07-02 15:11:27 +0200938 struct channel *req = si->ob;
939 struct channel *rep = si->ib;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100940
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100941 if (objt_server(s->target))
942 health_adjust(objt_server(s->target), HANA_STATUS_L4_OK);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100943
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100944 if (s->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100945 /* if the user wants to log as soon as possible, without counting
946 * bytes from the server, then this is the right moment. */
947 if (s->fe->to_log && !(s->logs.logwait & LW_BYTES)) {
948 s->logs.t_close = s->logs.t_connect; /* to get a valid end date */
Willy Tarreaua5555ec2008-11-30 19:02:32 +0100949 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100950 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100951 }
952 else {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100953 s->txn.rsp.msg_state = HTTP_MSG_RPBEFORE;
954 /* reset hdr_idx which was already initialized by the request.
955 * right now, the http parser does it.
956 * hdr_idx_init(&s->txn.hdr_idx);
957 */
958 }
959
Willy Tarreau4e5b8282009-08-16 22:57:50 +0200960 rep->analysers |= s->fe->fe_rsp_ana | s->be->be_rsp_ana;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200961 rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200962 if (si_ctrl(si)) {
Willy Tarreaud04e8582010-05-31 12:31:35 +0200963 /* real connections have timeouts */
964 req->wto = s->be->timeout.server;
965 rep->rto = s->be->timeout.server;
966 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100967 req->wex = TICK_ETERNITY;
968}
969
970/* Update stream interface status for input states SI_ST_ASS, SI_ST_QUE, SI_ST_TAR.
971 * Other input states are simply ignored.
972 * Possible output states are SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ, SI_ST_CON.
973 * Flags must have previously been updated for timeouts and other conditions.
974 */
Simon Hormandec5be42011-06-08 09:19:07 +0900975static void sess_update_stream_int(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100976{
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100977 struct server *srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +0100978
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100979 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 +0100980 now_ms, __FUNCTION__,
981 s,
982 s->req, s->rep,
983 s->req->rex, s->rep->wex,
984 s->req->flags, s->rep->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +0200985 s->req->buf->i, s->req->buf->o, s->rep->buf->i, s->rep->buf->o, s->rep->cons->state, s->req->cons->state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100986
987 if (si->state == SI_ST_ASS) {
988 /* Server assigned to connection request, we have to try to connect now */
989 int conn_err;
990
991 conn_err = connect_server(s);
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100992 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +0100993
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100994 if (conn_err == SN_ERR_NONE) {
995 /* state = SI_ST_CON now */
Willy Tarreau827aee92011-03-10 16:55:02 +0100996 if (srv)
997 srv_inc_sess_ctr(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100998 return;
999 }
1000
1001 /* We have received a synchronous error. We might have to
1002 * abort, retry immediately or redispatch.
1003 */
1004 if (conn_err == SN_ERR_INTERNAL) {
1005 if (!si->err_type) {
1006 si->err_type = SI_ET_CONN_OTHER;
Willy Tarreau827aee92011-03-10 16:55:02 +01001007 si->err_loc = srv;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001008 }
1009
Willy Tarreau827aee92011-03-10 16:55:02 +01001010 if (srv)
1011 srv_inc_sess_ctr(srv);
1012 if (srv)
1013 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001014 s->be->be_counters.failed_conns++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001015
1016 /* release other sessions waiting for this server */
Willy Tarreaub89cfca2010-12-29 14:32:28 +01001017 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001018 if (may_dequeue_tasks(srv, s->be))
1019 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001020
1021 /* Failed and not retryable. */
Willy Tarreau73b013b2012-05-21 16:31:45 +02001022 si_shutr(si);
1023 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001024 si->ob->flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001025
1026 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1027
1028 /* no session was ever accounted for this server */
1029 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001030 if (s->srv_error)
1031 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001032 return;
1033 }
1034
1035 /* We are facing a retryable error, but we don't want to run a
1036 * turn-around now, as the problem is likely a source port
1037 * allocation problem, so we want to retry now.
1038 */
1039 si->state = SI_ST_CER;
1040 si->flags &= ~SI_FL_ERR;
1041 sess_update_st_cer(s, si);
1042 /* now si->state is one of SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ */
1043 return;
1044 }
1045 else if (si->state == SI_ST_QUE) {
1046 /* connection request was queued, check for any update */
1047 if (!s->pend_pos) {
1048 /* The connection is not in the queue anymore. Either
1049 * we have a server connection slot available and we
1050 * go directly to the assigned state, or we need to
1051 * load-balance first and go to the INI state.
1052 */
1053 si->exp = TICK_ETERNITY;
1054 if (unlikely(!(s->flags & SN_ASSIGNED)))
1055 si->state = SI_ST_REQ;
1056 else {
1057 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1058 si->state = SI_ST_ASS;
1059 }
1060 return;
1061 }
1062
1063 /* Connection request still in queue... */
1064 if (si->flags & SI_FL_EXP) {
1065 /* ... and timeout expired */
1066 si->exp = TICK_ETERNITY;
1067 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau827aee92011-03-10 16:55:02 +01001068 if (srv)
1069 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001070 s->be->be_counters.failed_conns++;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001071 si_shutr(si);
1072 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001073 si->ob->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001074 if (!si->err_type)
1075 si->err_type = SI_ET_QUEUE_TO;
1076 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001077 if (s->srv_error)
1078 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001079 return;
1080 }
1081
1082 /* Connection remains in queue, check if we have to abort it */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001083 if ((si->ob->flags & (CF_READ_ERROR)) ||
1084 ((si->ob->flags & CF_SHUTW_NOW) && /* empty and client aborted */
Willy Tarreau8e21bb92012-08-24 22:40:29 +02001085 (channel_is_empty(si->ob) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001086 /* give up */
1087 si->exp = TICK_ETERNITY;
1088 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau73b013b2012-05-21 16:31:45 +02001089 si_shutr(si);
1090 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001091 si->err_type |= SI_ET_QUEUE_ABRT;
1092 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001093 if (s->srv_error)
1094 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001095 return;
1096 }
1097
1098 /* Nothing changed */
1099 return;
1100 }
1101 else if (si->state == SI_ST_TAR) {
1102 /* Connection request might be aborted */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001103 if ((si->ob->flags & (CF_READ_ERROR)) ||
1104 ((si->ob->flags & CF_SHUTW_NOW) && /* empty and client aborted */
Willy Tarreau8e21bb92012-08-24 22:40:29 +02001105 (channel_is_empty(si->ob) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001106 /* give up */
1107 si->exp = TICK_ETERNITY;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001108 si_shutr(si);
1109 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001110 si->err_type |= SI_ET_CONN_ABRT;
1111 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001112 if (s->srv_error)
1113 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001114 return;
1115 }
1116
1117 if (!(si->flags & SI_FL_EXP))
1118 return; /* still in turn-around */
1119
1120 si->exp = TICK_ETERNITY;
1121
1122 /* we keep trying on the same server as long as the session is
1123 * marked "assigned".
1124 * FIXME: Should we force a redispatch attempt when the server is down ?
1125 */
1126 if (s->flags & SN_ASSIGNED)
1127 si->state = SI_ST_ASS;
1128 else
1129 si->state = SI_ST_REQ;
1130 return;
1131 }
1132}
1133
Simon Hormandec5be42011-06-08 09:19:07 +09001134/* Set correct session termination flags in case no analyser has done it. It
1135 * also counts a failed request if the server state has not reached the request
1136 * stage.
1137 */
1138static void sess_set_term_flags(struct session *s)
1139{
1140 if (!(s->flags & SN_FINST_MASK)) {
1141 if (s->si[1].state < SI_ST_REQ) {
1142
1143 s->fe->fe_counters.failed_req++;
1144 if (s->listener->counters)
1145 s->listener->counters->failed_req++;
1146
1147 s->flags |= SN_FINST_R;
1148 }
1149 else if (s->si[1].state == SI_ST_QUE)
1150 s->flags |= SN_FINST_Q;
1151 else if (s->si[1].state < SI_ST_EST)
1152 s->flags |= SN_FINST_C;
1153 else if (s->si[1].state == SI_ST_EST || s->si[1].prev_state == SI_ST_EST)
1154 s->flags |= SN_FINST_D;
1155 else
1156 s->flags |= SN_FINST_L;
1157 }
1158}
1159
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001160/* This function initiates a server connection request on a stream interface
1161 * already in SI_ST_REQ state. Upon success, the state goes to SI_ST_ASS,
1162 * indicating that a server has been assigned. It may also return SI_ST_QUE,
1163 * or SI_ST_CLO upon error.
1164 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001165static void sess_prepare_conn_req(struct session *s, struct stream_interface *si)
1166{
1167 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 +01001168 now_ms, __FUNCTION__,
1169 s,
1170 s->req, s->rep,
1171 s->req->rex, s->rep->wex,
1172 s->req->flags, s->rep->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001173 s->req->buf->i, s->req->buf->o, s->rep->buf->i, s->rep->buf->o, s->rep->cons->state, s->req->cons->state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001174
1175 if (si->state != SI_ST_REQ)
1176 return;
1177
1178 /* Try to assign a server */
1179 if (srv_redispatch_connect(s) != 0) {
1180 /* We did not get a server. Either we queued the
1181 * connection request, or we encountered an error.
1182 */
1183 if (si->state == SI_ST_QUE)
1184 return;
1185
1186 /* we did not get any server, let's check the cause */
Willy Tarreau73b013b2012-05-21 16:31:45 +02001187 si_shutr(si);
1188 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001189 si->ob->flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001190 if (!si->err_type)
1191 si->err_type = SI_ET_CONN_OTHER;
1192 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001193 if (s->srv_error)
1194 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001195 return;
1196 }
1197
1198 /* The server is assigned */
1199 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1200 si->state = SI_ST_ASS;
1201}
1202
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001203/* This stream analyser checks the switching rules and changes the backend
Willy Tarreau4de91492010-01-22 19:10:05 +01001204 * if appropriate. The default_backend rule is also considered, then the
1205 * target backend's forced persistence rules are also evaluated last if any.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001206 * It returns 1 if the processing can continue on next analysers, or zero if it
1207 * either needs more data or wants to immediately abort the request.
1208 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001209static int process_switching_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001210{
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001211 struct persist_rule *prst_rule;
Willy Tarreau4de91492010-01-22 19:10:05 +01001212
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001213 req->analysers &= ~an_bit;
1214 req->analyse_exp = TICK_ETERNITY;
1215
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001216 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 +02001217 now_ms, __FUNCTION__,
1218 s,
1219 req,
1220 req->rex, req->wex,
1221 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001222 req->buf->i,
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001223 req->analysers);
1224
1225 /* now check whether we have some switching rules for this request */
1226 if (!(s->flags & SN_BE_ASSIGNED)) {
1227 struct switching_rule *rule;
1228
1229 list_for_each_entry(rule, &s->fe->switching_rules, list) {
1230 int ret;
1231
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001232 ret = acl_exec_cond(rule->cond, s->fe, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001233 ret = acl_pass(ret);
1234 if (rule->cond->pol == ACL_COND_UNLESS)
1235 ret = !ret;
1236
1237 if (ret) {
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001238 if (!session_set_backend(s, rule->be.backend))
1239 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001240 break;
1241 }
1242 }
1243
1244 /* To ensure correct connection accounting on the backend, we
1245 * have to assign one if it was not set (eg: a listen). This
1246 * measure also takes care of correctly setting the default
1247 * backend if any.
1248 */
1249 if (!(s->flags & SN_BE_ASSIGNED))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001250 if (!session_set_backend(s, s->fe->defbe.be ? s->fe->defbe.be : s->be))
1251 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001252 }
1253
Willy Tarreaufb356202010-08-03 14:02:05 +02001254 /* we don't want to run the TCP or HTTP filters again if the backend has not changed */
1255 if (s->fe == s->be) {
1256 s->req->analysers &= ~AN_REQ_INSPECT_BE;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001257 s->req->analysers &= ~AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaufb356202010-08-03 14:02:05 +02001258 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001259
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001260 /* 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 +01001261 * persistence rule, and report that in the session.
1262 */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001263 list_for_each_entry(prst_rule, &s->be->persist_rules, list) {
Willy Tarreau4de91492010-01-22 19:10:05 +01001264 int ret = 1;
1265
1266 if (prst_rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001267 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 +01001268 ret = acl_pass(ret);
1269 if (prst_rule->cond->pol == ACL_COND_UNLESS)
1270 ret = !ret;
1271 }
1272
1273 if (ret) {
1274 /* no rule, or the rule matches */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001275 if (prst_rule->type == PERSIST_TYPE_FORCE) {
1276 s->flags |= SN_FORCE_PRST;
1277 } else {
1278 s->flags |= SN_IGNORE_PRST;
1279 }
Willy Tarreau4de91492010-01-22 19:10:05 +01001280 break;
1281 }
1282 }
1283
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001284 return 1;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001285
1286 sw_failed:
1287 /* immediately abort this request in case of allocation failure */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001288 channel_abort(s->req);
1289 channel_abort(s->rep);
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001290
1291 if (!(s->flags & SN_ERR_MASK))
1292 s->flags |= SN_ERR_RESOURCE;
1293 if (!(s->flags & SN_FINST_MASK))
1294 s->flags |= SN_FINST_R;
1295
1296 s->txn.status = 500;
1297 s->req->analysers = 0;
1298 s->req->analyse_exp = TICK_ETERNITY;
1299 return 0;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001300}
1301
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001302/* This stream analyser works on a request. It applies all use-server rules on
1303 * it then returns 1. The data must already be present in the buffer otherwise
1304 * they won't match. It always returns 1.
1305 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001306static int process_server_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001307{
1308 struct proxy *px = s->be;
1309 struct server_rule *rule;
1310
1311 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
1312 now_ms, __FUNCTION__,
1313 s,
1314 req,
1315 req->rex, req->wex,
1316 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001317 req->buf->i + req->buf->o,
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001318 req->analysers);
1319
1320 if (!(s->flags & SN_ASSIGNED)) {
1321 list_for_each_entry(rule, &px->server_rules, list) {
1322 int ret;
1323
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001324 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 +02001325 ret = acl_pass(ret);
1326 if (rule->cond->pol == ACL_COND_UNLESS)
1327 ret = !ret;
1328
1329 if (ret) {
1330 struct server *srv = rule->srv.ptr;
1331
1332 if ((srv->state & SRV_RUNNING) ||
1333 (px->options & PR_O_PERSIST) ||
1334 (s->flags & SN_FORCE_PRST)) {
1335 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001336 s->target = &srv->obj_type;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001337 break;
1338 }
1339 /* if the server is not UP, let's go on with next rules
1340 * just in case another one is suited.
1341 */
1342 }
1343 }
1344 }
1345
1346 req->analysers &= ~an_bit;
1347 req->analyse_exp = TICK_ETERNITY;
1348 return 1;
1349}
1350
Emeric Brun1d33b292010-01-04 15:47:17 +01001351/* This stream analyser works on a request. It applies all sticking rules on
1352 * it then returns 1. The data must already be present in the buffer otherwise
1353 * they won't match. It always returns 1.
1354 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001355static int process_sticking_rules(struct session *s, struct channel *req, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001356{
1357 struct proxy *px = s->be;
1358 struct sticking_rule *rule;
1359
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001360 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 +01001361 now_ms, __FUNCTION__,
1362 s,
1363 req,
1364 req->rex, req->wex,
1365 req->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001366 req->buf->i,
Emeric Brun1d33b292010-01-04 15:47:17 +01001367 req->analysers);
1368
1369 list_for_each_entry(rule, &px->sticking_rules, list) {
1370 int ret = 1 ;
1371 int i;
1372
1373 for (i = 0; i < s->store_count; i++) {
1374 if (rule->table.t == s->store[i].table)
1375 break;
1376 }
1377
1378 if (i != s->store_count)
1379 continue;
1380
1381 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001382 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001383 ret = acl_pass(ret);
1384 if (rule->cond->pol == ACL_COND_UNLESS)
1385 ret = !ret;
1386 }
1387
1388 if (ret) {
1389 struct stktable_key *key;
1390
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001391 key = stktable_fetch_key(rule->table.t, px, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->expr);
Emeric Brun1d33b292010-01-04 15:47:17 +01001392 if (!key)
1393 continue;
1394
1395 if (rule->flags & STK_IS_MATCH) {
1396 struct stksess *ts;
1397
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001398 if ((ts = stktable_lookup_key(rule->table.t, key)) != NULL) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001399 if (!(s->flags & SN_ASSIGNED)) {
1400 struct eb32_node *node;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001401 void *ptr;
Emeric Brun1d33b292010-01-04 15:47:17 +01001402
1403 /* srv found in table */
Willy Tarreau13c29de2010-06-06 16:40:39 +02001404 ptr = stktable_data_ptr(rule->table.t, ts, STKTABLE_DT_SERVER_ID);
1405 node = eb32_lookup(&px->conf.used_server_id, stktable_data_cast(ptr, server_id));
Emeric Brun1d33b292010-01-04 15:47:17 +01001406 if (node) {
1407 struct server *srv;
1408
1409 srv = container_of(node, struct server, conf.id);
Willy Tarreau4de91492010-01-22 19:10:05 +01001410 if ((srv->state & SRV_RUNNING) ||
1411 (px->options & PR_O_PERSIST) ||
1412 (s->flags & SN_FORCE_PRST)) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001413 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001414 s->target = &srv->obj_type;
Emeric Brun1d33b292010-01-04 15:47:17 +01001415 }
1416 }
1417 }
Emeric Brun85e77c72010-09-23 18:16:52 +02001418 stktable_touch(rule->table.t, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001419 }
1420 }
1421 if (rule->flags & STK_IS_STORE) {
1422 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1423 struct stksess *ts;
1424
1425 ts = stksess_new(rule->table.t, key);
1426 if (ts) {
1427 s->store[s->store_count].table = rule->table.t;
1428 s->store[s->store_count++].ts = ts;
1429 }
1430 }
1431 }
1432 }
1433 }
1434
1435 req->analysers &= ~an_bit;
1436 req->analyse_exp = TICK_ETERNITY;
1437 return 1;
1438}
1439
1440/* This stream analyser works on a response. It applies all store rules on it
1441 * then returns 1. The data must already be present in the buffer otherwise
1442 * they won't match. It always returns 1.
1443 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001444static int process_store_rules(struct session *s, struct channel *rep, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001445{
1446 struct proxy *px = s->be;
1447 struct sticking_rule *rule;
1448 int i;
1449
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001450 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 +01001451 now_ms, __FUNCTION__,
1452 s,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001453 rep,
1454 rep->rex, rep->wex,
1455 rep->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001456 rep->buf->i,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001457 rep->analysers);
Emeric Brun1d33b292010-01-04 15:47:17 +01001458
1459 list_for_each_entry(rule, &px->storersp_rules, list) {
1460 int ret = 1 ;
1461 int storereqidx = -1;
1462
1463 for (i = 0; i < s->store_count; i++) {
1464 if (rule->table.t == s->store[i].table) {
1465 if (!(s->store[i].flags))
1466 storereqidx = i;
1467 break;
1468 }
1469 }
1470
1471 if ((i != s->store_count) && (storereqidx == -1))
1472 continue;
1473
1474 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001475 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_RES|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001476 ret = acl_pass(ret);
1477 if (rule->cond->pol == ACL_COND_UNLESS)
1478 ret = !ret;
1479 }
1480
1481 if (ret) {
1482 struct stktable_key *key;
1483
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001484 key = stktable_fetch_key(rule->table.t, px, s, &s->txn, SMP_OPT_DIR_RES|SMP_OPT_FINAL, rule->expr);
Emeric Brun1d33b292010-01-04 15:47:17 +01001485 if (!key)
1486 continue;
1487
1488 if (storereqidx != -1) {
Willy Tarreau393379c2010-06-06 12:11:37 +02001489 stksess_setkey(s->store[storereqidx].table, s->store[storereqidx].ts, key);
Emeric Brun1d33b292010-01-04 15:47:17 +01001490 s->store[storereqidx].flags = 1;
1491 }
1492 else if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1493 struct stksess *ts;
1494
1495 ts = stksess_new(rule->table.t, key);
1496 if (ts) {
1497 s->store[s->store_count].table = rule->table.t;
1498 s->store[s->store_count].flags = 1;
1499 s->store[s->store_count++].ts = ts;
1500 }
1501 }
1502 }
1503 }
1504
1505 /* process store request and store response */
1506 for (i = 0; i < s->store_count; i++) {
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001507 struct stksess *ts;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001508 void *ptr;
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001509
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001510 if (objt_server(s->target) && objt_server(s->target)->state & SRV_NON_STICK) {
Simon Hormanfa461682011-06-25 09:39:49 +09001511 stksess_free(s->store[i].table, s->store[i].ts);
1512 s->store[i].ts = NULL;
1513 continue;
1514 }
1515
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001516 ts = stktable_lookup(s->store[i].table, s->store[i].ts);
1517 if (ts) {
1518 /* the entry already existed, we can free ours */
Emeric Brun85e77c72010-09-23 18:16:52 +02001519 stktable_touch(s->store[i].table, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001520 stksess_free(s->store[i].table, s->store[i].ts);
Emeric Brun1d33b292010-01-04 15:47:17 +01001521 }
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001522 else
Emeric Brun85e77c72010-09-23 18:16:52 +02001523 ts = stktable_store(s->store[i].table, s->store[i].ts, 1);
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001524
1525 s->store[i].ts = NULL;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001526 ptr = stktable_data_ptr(s->store[i].table, ts, STKTABLE_DT_SERVER_ID);
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001527 stktable_data_cast(ptr, server_id) = objt_server(s->target)->puid;
Emeric Brun1d33b292010-01-04 15:47:17 +01001528 }
Willy Tarreau2a164ee2010-06-18 09:57:45 +02001529 s->store_count = 0; /* everything is stored */
Emeric Brun1d33b292010-01-04 15:47:17 +01001530
1531 rep->analysers &= ~an_bit;
1532 rep->analyse_exp = TICK_ETERNITY;
1533 return 1;
1534}
1535
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001536/* This macro is very specific to the function below. See the comments in
1537 * process_session() below to understand the logic and the tests.
1538 */
1539#define UPDATE_ANALYSERS(real, list, back, flag) { \
1540 list = (((list) & ~(flag)) | ~(back)) & (real); \
1541 back = real; \
1542 if (!(list)) \
1543 break; \
1544 if (((list) ^ ((list) & ((list) - 1))) < (flag)) \
1545 continue; \
1546}
1547
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001548/* Processes the client, server, request and response jobs of a session task,
1549 * then puts it back to the wait queue in a clean state, or cleans up its
1550 * resources if it must be deleted. Returns in <next> the date the task wants
1551 * to be woken up, or TICK_ETERNITY. In order not to call all functions for
1552 * nothing too many times, the request and response buffers flags are monitored
1553 * and each function is called only if at least another function has changed at
1554 * least one flag it is interested in.
1555 */
Willy Tarreau26c25062009-03-08 09:38:41 +01001556struct task *process_session(struct task *t)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001557{
Willy Tarreau827aee92011-03-10 16:55:02 +01001558 struct server *srv;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001559 struct session *s = t->context;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001560 unsigned int rqf_last, rpf_last;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001561 unsigned int rq_prod_last, rq_cons_last;
1562 unsigned int rp_cons_last, rp_prod_last;
Willy Tarreau576507f2010-01-07 00:09:04 +01001563 unsigned int req_ana_back;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001564
1565 //DPRINTF(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__,
1566 // s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s->rep->flags);
1567
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001568 /* this data may be no longer valid, clear it */
1569 memset(&s->txn.auth, 0, sizeof(s->txn.auth));
1570
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001571 /* This flag must explicitly be set every time */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001572 s->req->flags &= ~CF_READ_NOEXP;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001573
1574 /* Keep a copy of req/rep flags so that we can detect shutdowns */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001575 rqf_last = s->req->flags & ~CF_MASK_ANALYSER;
1576 rpf_last = s->rep->flags & ~CF_MASK_ANALYSER;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001577
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001578 /* we don't want the stream interface functions to recursively wake us up */
1579 if (s->req->prod->owner == t)
1580 s->req->prod->flags |= SI_FL_DONT_WAKE;
1581 if (s->req->cons->owner == t)
1582 s->req->cons->flags |= SI_FL_DONT_WAKE;
1583
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001584 /* 1a: Check for low level timeouts if needed. We just set a flag on
1585 * stream interfaces when their timeouts have expired.
1586 */
1587 if (unlikely(t->state & TASK_WOKEN_TIMER)) {
1588 stream_int_check_timeouts(&s->si[0]);
1589 stream_int_check_timeouts(&s->si[1]);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001590
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001591 /* check channel timeouts, and close the corresponding stream interfaces
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001592 * for future reads or writes. Note: this will also concern upper layers
1593 * but we do not touch any other flag. We must be careful and correctly
1594 * detect state changes when calling them.
1595 */
1596
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001597 channel_check_timeouts(s->req);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001598
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001599 if (unlikely((s->req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreau14641402009-12-29 14:49:56 +01001600 s->req->cons->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001601 si_shutw(s->req->cons);
Willy Tarreau14641402009-12-29 14:49:56 +01001602 }
1603
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001604 if (unlikely((s->req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001605 if (s->req->prod->flags & SI_FL_NOHALF)
1606 s->req->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001607 si_shutr(s->req->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001608 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001609
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001610 channel_check_timeouts(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001611
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001612 if (unlikely((s->rep->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreau14641402009-12-29 14:49:56 +01001613 s->rep->cons->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001614 si_shutw(s->rep->cons);
Willy Tarreau14641402009-12-29 14:49:56 +01001615 }
1616
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001617 if (unlikely((s->rep->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001618 if (s->rep->prod->flags & SI_FL_NOHALF)
1619 s->rep->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001620 si_shutr(s->rep->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001621 }
Willy Tarreau798f4322012-11-08 14:49:17 +01001622
1623 /* Once in a while we're woken up because the task expires. But
1624 * this does not necessarily mean that a timeout has been reached.
1625 * So let's not run a whole session processing if only an expiration
1626 * timeout needs to be refreshed.
1627 */
1628 if (!((s->req->flags | s->rep->flags) &
1629 (CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
1630 CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
1631 !((s->si[0].flags | s->si[1].flags) & (SI_FL_EXP|SI_FL_ERR)) &&
1632 ((t->state & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER))
1633 goto update_exp_and_leave;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001634 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001635
1636 /* 1b: check for low-level errors reported at the stream interface.
1637 * First we check if it's a retryable error (in which case we don't
1638 * want to tell the buffer). Otherwise we report the error one level
1639 * upper by setting flags into the buffers. Note that the side towards
1640 * the client cannot have connect (hence retryable) errors. Also, the
1641 * connection setup code must be able to deal with any type of abort.
1642 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001643 srv = objt_server(s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001644 if (unlikely(s->si[0].flags & SI_FL_ERR)) {
1645 if (s->si[0].state == SI_ST_EST || s->si[0].state == SI_ST_DIS) {
Willy Tarreau73b013b2012-05-21 16:31:45 +02001646 si_shutr(&s->si[0]);
1647 si_shutw(&s->si[0]);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001648 stream_int_report_error(&s->si[0]);
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001649 if (!(s->req->analysers) && !(s->rep->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001650 s->be->be_counters.cli_aborts++;
1651 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001652 if (srv)
1653 srv->counters.cli_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001654 if (!(s->flags & SN_ERR_MASK))
1655 s->flags |= SN_ERR_CLICL;
1656 if (!(s->flags & SN_FINST_MASK))
1657 s->flags |= SN_FINST_D;
1658 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001659 }
1660 }
1661
1662 if (unlikely(s->si[1].flags & SI_FL_ERR)) {
1663 if (s->si[1].state == SI_ST_EST || s->si[1].state == SI_ST_DIS) {
Willy Tarreau73b013b2012-05-21 16:31:45 +02001664 si_shutr(&s->si[1]);
1665 si_shutw(&s->si[1]);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001666 stream_int_report_error(&s->si[1]);
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001667 s->be->be_counters.failed_resp++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001668 if (srv)
1669 srv->counters.failed_resp++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001670 if (!(s->req->analysers) && !(s->rep->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001671 s->be->be_counters.srv_aborts++;
1672 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001673 if (srv)
1674 srv->counters.srv_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001675 if (!(s->flags & SN_ERR_MASK))
1676 s->flags |= SN_ERR_SRVCL;
1677 if (!(s->flags & SN_FINST_MASK))
1678 s->flags |= SN_FINST_D;
1679 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001680 }
1681 /* note: maybe we should process connection errors here ? */
1682 }
1683
1684 if (s->si[1].state == SI_ST_CON) {
1685 /* we were trying to establish a connection on the server side,
1686 * maybe it succeeded, maybe it failed, maybe we timed out, ...
1687 */
1688 if (unlikely(!sess_update_st_con_tcp(s, &s->si[1])))
1689 sess_update_st_cer(s, &s->si[1]);
1690 else if (s->si[1].state == SI_ST_EST)
1691 sess_establish(s, &s->si[1]);
1692
1693 /* state is now one of SI_ST_CON (still in progress), SI_ST_EST
1694 * (established), SI_ST_DIS (abort), SI_ST_CLO (last error),
1695 * SI_ST_ASS/SI_ST_TAR/SI_ST_REQ for retryable errors.
1696 */
1697 }
1698
Willy Tarreau815a9b22010-07-27 17:15:12 +02001699 rq_prod_last = s->si[0].state;
1700 rq_cons_last = s->si[1].state;
1701 rp_cons_last = s->si[0].state;
1702 rp_prod_last = s->si[1].state;
1703
1704 resync_stream_interface:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001705 /* Check for connection closure */
1706
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001707 DPRINTF(stderr,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001708 "[%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 +01001709 now_ms, __FUNCTION__, __LINE__,
1710 t,
1711 s, s->flags,
1712 s->req, s->rep,
1713 s->req->rex, s->rep->wex,
1714 s->req->flags, s->rep->flags,
Willy Tarreau9b28e032012-10-12 23:49:43 +02001715 s->req->buf->i, s->req->buf->o, s->rep->buf->i, s->rep->buf->o, s->rep->cons->state, s->req->cons->state,
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001716 s->rep->cons->err_type, s->req->cons->err_type,
Willy Tarreauee28de02010-06-01 09:51:00 +02001717 s->req->cons->conn_retries);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001718
1719 /* nothing special to be done on client side */
1720 if (unlikely(s->req->prod->state == SI_ST_DIS))
1721 s->req->prod->state = SI_ST_CLO;
1722
1723 /* When a server-side connection is released, we have to count it and
1724 * check for pending connections on this server.
1725 */
1726 if (unlikely(s->req->cons->state == SI_ST_DIS)) {
1727 s->req->cons->state = SI_ST_CLO;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001728 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001729 if (srv) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001730 if (s->flags & SN_CURR_SESS) {
1731 s->flags &= ~SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001732 srv->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001733 }
1734 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001735 if (may_dequeue_tasks(srv, s->be))
1736 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001737 }
1738 }
1739
1740 /*
1741 * Note: of the transient states (REQ, CER, DIS), only REQ may remain
1742 * at this point.
1743 */
1744
Willy Tarreau0be0ef92009-03-08 19:20:25 +01001745 resync_request:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001746 /* Analyse request */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001747 if (((s->req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
1748 ((s->req->flags ^ rqf_last) & CF_MASK_STATIC) ||
Willy Tarreau815a9b22010-07-27 17:15:12 +02001749 s->si[0].state != rq_prod_last ||
1750 s->si[1].state != rq_cons_last) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001751 unsigned int flags = s->req->flags;
1752
1753 if (s->req->prod->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001754 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001755 unsigned int ana_list;
1756 unsigned int ana_back;
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001757
Willy Tarreau90deb182010-01-07 00:20:41 +01001758 /* it's up to the analysers to stop new connections,
1759 * disable reading or closing. Note: if an analyser
1760 * disables any of these bits, it is responsible for
1761 * enabling them again when it disables itself, so
1762 * that other analysers are called in similar conditions.
1763 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001764 channel_auto_read(s->req);
1765 channel_auto_connect(s->req);
1766 channel_auto_close(s->req);
Willy Tarreauedcf6682008-11-30 23:15:34 +01001767
1768 /* We will call all analysers for which a bit is set in
1769 * s->req->analysers, following the bit order from LSB
1770 * to MSB. The analysers must remove themselves from
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001771 * the list when not needed. Any analyser may return 0
1772 * to break out of the loop, either because of missing
1773 * data to take a decision, or because it decides to
1774 * kill the session. We loop at least once through each
1775 * analyser, and we may loop again if other analysers
1776 * are added in the middle.
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001777 *
1778 * We build a list of analysers to run. We evaluate all
1779 * of these analysers in the order of the lower bit to
1780 * the higher bit. This ordering is very important.
1781 * An analyser will often add/remove other analysers,
1782 * including itself. Any changes to itself have no effect
1783 * on the loop. If it removes any other analysers, we
1784 * want those analysers not to be called anymore during
1785 * this loop. If it adds an analyser that is located
1786 * after itself, we want it to be scheduled for being
1787 * processed during the loop. If it adds an analyser
1788 * which is located before it, we want it to switch to
1789 * it immediately, even if it has already been called
1790 * once but removed since.
1791 *
1792 * In order to achieve this, we compare the analyser
1793 * list after the call with a copy of it before the
1794 * call. The work list is fed with analyser bits that
1795 * appeared during the call. Then we compare previous
1796 * work list with the new one, and check the bits that
1797 * appeared. If the lowest of these bits is lower than
1798 * the current bit, it means we have enabled a previous
1799 * analyser and must immediately loop again.
Willy Tarreauedcf6682008-11-30 23:15:34 +01001800 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001801
1802 ana_list = ana_back = s->req->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01001803 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001804 /* Warning! ensure that analysers are always placed in ascending order! */
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001805
Willy Tarreaufb356202010-08-03 14:02:05 +02001806 if (ana_list & AN_REQ_INSPECT_FE) {
1807 if (!tcp_inspect_request(s, s->req, AN_REQ_INSPECT_FE))
Willy Tarreauedcf6682008-11-30 23:15:34 +01001808 break;
Willy Tarreaufb356202010-08-03 14:02:05 +02001809 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001810 }
Willy Tarreauedcf6682008-11-30 23:15:34 +01001811
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001812 if (ana_list & AN_REQ_WAIT_HTTP) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001813 if (!http_wait_for_request(s, s->req, AN_REQ_WAIT_HTTP))
Willy Tarreaud787e662009-07-07 10:14:51 +02001814 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001815 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
Willy Tarreaud787e662009-07-07 10:14:51 +02001816 }
1817
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001818 if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001819 if (!http_process_req_common(s, s->req, AN_REQ_HTTP_PROCESS_FE, s->fe))
1820 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001821 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001822 }
1823
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001824 if (ana_list & AN_REQ_SWITCHING_RULES) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001825 if (!process_switching_rules(s, s->req, AN_REQ_SWITCHING_RULES))
1826 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001827 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001828 }
1829
Willy Tarreaufb356202010-08-03 14:02:05 +02001830 if (ana_list & AN_REQ_INSPECT_BE) {
1831 if (!tcp_inspect_request(s, s->req, AN_REQ_INSPECT_BE))
1832 break;
1833 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
1834 }
1835
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001836 if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001837 if (!http_process_req_common(s, s->req, AN_REQ_HTTP_PROCESS_BE, s->be))
1838 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001839 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001840 }
1841
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001842 if (ana_list & AN_REQ_HTTP_TARPIT) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001843 if (!http_process_tarpit(s, s->req, AN_REQ_HTTP_TARPIT))
Willy Tarreau60b85b02008-11-30 23:28:40 +01001844 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001845 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001846 }
Willy Tarreau60b85b02008-11-30 23:28:40 +01001847
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001848 if (ana_list & AN_REQ_SRV_RULES) {
1849 if (!process_server_rules(s, s->req, AN_REQ_SRV_RULES))
1850 break;
1851 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
1852 }
1853
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001854 if (ana_list & AN_REQ_HTTP_INNER) {
Willy Tarreauc465fd72009-08-31 00:17:18 +02001855 if (!http_process_request(s, s->req, AN_REQ_HTTP_INNER))
1856 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001857 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
Willy Tarreauc465fd72009-08-31 00:17:18 +02001858 }
1859
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001860 if (ana_list & AN_REQ_HTTP_BODY) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001861 if (!http_process_request_body(s, s->req, AN_REQ_HTTP_BODY))
Willy Tarreaud34af782008-11-30 23:36:37 +01001862 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001863 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001864 }
Emeric Brun647caf12009-06-30 17:57:00 +02001865
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001866 if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
Emeric Brun647caf12009-06-30 17:57:00 +02001867 if (!tcp_persist_rdp_cookie(s, s->req, AN_REQ_PRST_RDP_COOKIE))
1868 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001869 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
Emeric Brun647caf12009-06-30 17:57:00 +02001870 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01001871
Emeric Brun1d33b292010-01-04 15:47:17 +01001872 if (ana_list & AN_REQ_STICKING_RULES) {
1873 if (!process_sticking_rules(s, s->req, AN_REQ_STICKING_RULES))
1874 break;
1875 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
1876 }
1877
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001878 if (ana_list & AN_REQ_HTTP_XFER_BODY) {
Willy Tarreaud98cf932009-12-27 22:54:55 +01001879 if (!http_request_forward_body(s, s->req, AN_REQ_HTTP_XFER_BODY))
1880 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001881 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01001882 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01001883 break;
1884 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001885 }
Willy Tarreau84455332009-03-15 22:34:05 +01001886
Willy Tarreau815a9b22010-07-27 17:15:12 +02001887 rq_prod_last = s->si[0].state;
1888 rq_cons_last = s->si[1].state;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001889 s->req->flags &= ~CF_WAKE_ONCE;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001890 rqf_last = s->req->flags;
1891
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001892 if ((s->req->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001893 goto resync_request;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001894 }
1895
Willy Tarreau576507f2010-01-07 00:09:04 +01001896 /* we'll monitor the request analysers while parsing the response,
1897 * because some response analysers may indirectly enable new request
1898 * analysers (eg: HTTP keep-alive).
1899 */
1900 req_ana_back = s->req->analysers;
1901
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001902 resync_response:
1903 /* Analyse response */
1904
Willy Tarreaub31c9712012-11-11 23:05:39 +01001905 if (((s->rep->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001906 (s->rep->flags ^ rpf_last) & CF_MASK_STATIC ||
Willy Tarreau815a9b22010-07-27 17:15:12 +02001907 s->si[0].state != rp_cons_last ||
1908 s->si[1].state != rp_prod_last) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001909 unsigned int flags = s->rep->flags;
1910
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001911 if ((s->rep->flags & CF_MASK_ANALYSER) &&
Willy Tarreau0499e352010-12-17 07:13:42 +01001912 (s->rep->analysers & AN_REQ_WAIT_HTTP)) {
1913 /* Due to HTTP pipelining, the HTTP request analyser might be waiting
1914 * for some free space in the response buffer, so we might need to call
1915 * it when something changes in the response buffer, but still we pass
1916 * it the request buffer. Note that the SI state might very well still
1917 * be zero due to us returning a flow of redirects!
1918 */
1919 s->rep->analysers &= ~AN_REQ_WAIT_HTTP;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001920 s->req->flags |= CF_WAKE_ONCE;
Willy Tarreau0499e352010-12-17 07:13:42 +01001921 }
1922
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001923 if (s->rep->prod->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001924 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001925 unsigned int ana_list;
1926 unsigned int ana_back;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001927
Willy Tarreau90deb182010-01-07 00:20:41 +01001928 /* it's up to the analysers to stop disable reading or
1929 * closing. Note: if an analyser disables any of these
1930 * bits, it is responsible for enabling them again when
1931 * it disables itself, so that other analysers are called
1932 * in similar conditions.
1933 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001934 channel_auto_read(s->rep);
1935 channel_auto_close(s->rep);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001936
1937 /* We will call all analysers for which a bit is set in
1938 * s->rep->analysers, following the bit order from LSB
1939 * to MSB. The analysers must remove themselves from
1940 * the list when not needed. Any analyser may return 0
1941 * to break out of the loop, either because of missing
1942 * data to take a decision, or because it decides to
1943 * kill the session. We loop at least once through each
1944 * analyser, and we may loop again if other analysers
1945 * are added in the middle.
1946 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001947
1948 ana_list = ana_back = s->rep->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01001949 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001950 /* Warning! ensure that analysers are always placed in ascending order! */
1951
Emeric Brun97679e72010-09-23 17:56:44 +02001952 if (ana_list & AN_RES_INSPECT) {
1953 if (!tcp_inspect_response(s, s->rep, AN_RES_INSPECT))
1954 break;
1955 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_INSPECT);
1956 }
1957
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001958 if (ana_list & AN_RES_WAIT_HTTP) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001959 if (!http_wait_for_response(s, s->rep, AN_RES_WAIT_HTTP))
1960 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001961 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001962 }
1963
Emeric Brun1d33b292010-01-04 15:47:17 +01001964 if (ana_list & AN_RES_STORE_RULES) {
1965 if (!process_store_rules(s, s->rep, AN_RES_STORE_RULES))
1966 break;
1967 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
1968 }
1969
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001970 if (ana_list & AN_RES_HTTP_PROCESS_BE) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001971 if (!http_process_res_common(s, s->rep, AN_RES_HTTP_PROCESS_BE, s->be))
1972 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001973 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001974 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01001975
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001976 if (ana_list & AN_RES_HTTP_XFER_BODY) {
Willy Tarreaud98cf932009-12-27 22:54:55 +01001977 if (!http_response_forward_body(s, s->rep, AN_RES_HTTP_XFER_BODY))
1978 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001979 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01001980 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01001981 break;
1982 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001983 }
1984
Willy Tarreau815a9b22010-07-27 17:15:12 +02001985 rp_cons_last = s->si[0].state;
1986 rp_prod_last = s->si[1].state;
1987 rpf_last = s->rep->flags;
1988
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001989 if ((s->rep->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001990 goto resync_response;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001991 }
1992
Willy Tarreau576507f2010-01-07 00:09:04 +01001993 /* maybe someone has added some request analysers, so we must check and loop */
1994 if (s->req->analysers & ~req_ana_back)
1995 goto resync_request;
1996
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001997 if ((s->req->flags & ~rqf_last) & CF_MASK_ANALYSER)
Willy Tarreau0499e352010-12-17 07:13:42 +01001998 goto resync_request;
1999
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002000 /* FIXME: here we should call protocol handlers which rely on
2001 * both buffers.
2002 */
2003
2004
2005 /*
Willy Tarreauae526782010-03-04 20:34:23 +01002006 * Now we propagate unhandled errors to the session. Normally
2007 * we're just in a data phase here since it means we have not
2008 * seen any analyser who could set an error status.
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002009 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002010 srv = objt_server(s->target);
Willy Tarreau2f976e12010-11-11 14:28:47 +01002011 if (unlikely(!(s->flags & SN_ERR_MASK))) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002012 if (s->req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002013 /* Report it if the client got an error or a read timeout expired */
Willy Tarreau84455332009-03-15 22:34:05 +01002014 s->req->analysers = 0;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002015 if (s->req->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002016 s->be->be_counters.cli_aborts++;
2017 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002018 if (srv)
2019 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002020 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002021 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002022 else if (s->req->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002023 s->be->be_counters.cli_aborts++;
2024 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002025 if (srv)
2026 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002027 s->flags |= SN_ERR_CLITO;
Willy Tarreauae526782010-03-04 20:34:23 +01002028 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002029 else if (s->req->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002030 s->be->be_counters.srv_aborts++;
2031 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002032 if (srv)
2033 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002034 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002035 }
2036 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002037 s->be->be_counters.srv_aborts++;
2038 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002039 if (srv)
2040 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01002041 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002042 }
Willy Tarreau84455332009-03-15 22:34:05 +01002043 sess_set_term_flags(s);
2044 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002045 else if (s->rep->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002046 /* Report it if the server got an error or a read timeout expired */
2047 s->rep->analysers = 0;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002048 if (s->rep->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002049 s->be->be_counters.srv_aborts++;
2050 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002051 if (srv)
2052 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002053 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002054 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002055 else if (s->rep->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002056 s->be->be_counters.srv_aborts++;
2057 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002058 if (srv)
2059 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002060 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002061 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002062 else if (s->rep->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002063 s->be->be_counters.cli_aborts++;
2064 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002065 if (srv)
2066 srv->counters.cli_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002067 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002068 }
2069 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002070 s->be->be_counters.cli_aborts++;
2071 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002072 if (srv)
2073 srv->counters.cli_aborts++;
Willy Tarreauae526782010-03-04 20:34:23 +01002074 s->flags |= SN_ERR_CLITO;
2075 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002076 sess_set_term_flags(s);
2077 }
Willy Tarreau84455332009-03-15 22:34:05 +01002078 }
2079
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002080 /*
2081 * Here we take care of forwarding unhandled data. This also includes
2082 * connection establishments and shutdown requests.
2083 */
2084
2085
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002086 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002087 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002088 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002089 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002090 */
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002091 if (!s->req->analysers &&
Willy Tarreaub31c9712012-11-11 23:05:39 +01002092 !(s->req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau31971e52009-09-20 12:07:52 +02002093 (s->req->prod->state >= SI_ST_EST) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002094 (s->req->to_forward != CHN_INFINITE_FORWARD)) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002095 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002096 * attached to it. If any data are left in, we'll permit them to
2097 * move.
2098 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002099 channel_auto_read(s->req);
2100 channel_auto_connect(s->req);
2101 channel_auto_close(s->req);
Willy Tarreau9b28e032012-10-12 23:49:43 +02002102 buffer_flush(s->req->buf);
Willy Tarreau5bd8c372009-01-19 00:32:22 +01002103
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002104 /* We'll let data flow between the producer (if still connected)
2105 * to the consumer (which might possibly not be connected yet).
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002106 */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002107 if (!(s->req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002108 channel_forward(s->req, CHN_INFINITE_FORWARD);
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002109 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002110
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002111 /* check if it is wise to enable kernel splicing to forward request data */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002112 if (!(s->req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002113 s->req->to_forward &&
2114 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002115 (s->si[0].conn->xprt && s->si[0].conn->xprt->rcv_pipe && s->si[0].conn->xprt->snd_pipe) &&
2116 (s->si[1].conn->xprt && s->si[1].conn->xprt->rcv_pipe && s->si[1].conn->xprt->snd_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002117 (pipes_used < global.maxpipes) &&
2118 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
2119 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002120 (s->req->flags & CF_STREAMER_FAST)))) {
2121 s->req->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002122 }
2123
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002124 /* reflect what the L7 analysers have seen last */
2125 rqf_last = s->req->flags;
2126
2127 /*
2128 * Now forward all shutdown requests between both sides of the buffer
2129 */
2130
Willy Tarreau520d95e2009-09-19 21:04:57 +02002131 /* first, let's check if the request buffer needs to shutdown(write), which may
2132 * happen either because the input is closed or because we want to force a close
Willy Tarreaue4599762010-03-21 23:25:09 +01002133 * once the server has begun to respond.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002134 */
Willy Tarreaub31c9712012-11-11 23:05:39 +01002135 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002136 (CF_AUTO_CLOSE|CF_SHUTR)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002137 channel_shutw_now(s->req);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002138
2139 /* shutdown(write) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002140 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
Willy Tarreau8e21bb92012-08-24 22:40:29 +02002141 channel_is_empty(s->req)))
Willy Tarreau73b013b2012-05-21 16:31:45 +02002142 si_shutw(s->req->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002143
2144 /* shutdown(write) done on server side, we must stop the client too */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002145 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
Willy Tarreau3dbc6942008-12-07 13:05:04 +01002146 !s->req->analysers))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002147 channel_shutr_now(s->req);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002148
2149 /* shutdown(read) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002150 if (unlikely((s->req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002151 if (s->req->prod->flags & SI_FL_NOHALF)
2152 s->req->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02002153 si_shutr(s->req->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002154 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002155
Willy Tarreau520d95e2009-09-19 21:04:57 +02002156 /* it's possible that an upper layer has requested a connection setup or abort.
2157 * There are 2 situations where we decide to establish a new connection :
2158 * - there are data scheduled for emission in the buffer
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002159 * - the CF_AUTO_CONNECT flag is set (active connection)
Willy Tarreau520d95e2009-09-19 21:04:57 +02002160 */
2161 if (s->req->cons->state == SI_ST_INI) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002162 if (!(s->req->flags & CF_SHUTW)) {
2163 if ((s->req->flags & CF_AUTO_CONNECT) || !channel_is_empty(s->req)) {
Willy Tarreaub24281b2011-02-13 13:16:36 +01002164 /* If we have an applet without a connect method, we immediately
Willy Tarreau85e7d002010-05-31 11:57:51 +02002165 * switch to the connected state, otherwise we perform a connection
2166 * request.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002167 */
Willy Tarreau85e7d002010-05-31 11:57:51 +02002168 s->req->cons->state = SI_ST_REQ; /* new connection requested */
Willy Tarreau070ceb62010-06-01 10:36:43 +02002169 s->req->cons->conn_retries = s->be->conn_retries;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002170 if (unlikely(obj_type(s->req->cons->conn->target) == OBJ_TYPE_APPLET &&
Willy Tarreau73b013b2012-05-21 16:31:45 +02002171 !(si_ctrl(s->req->cons) && si_ctrl(s->req->cons)->connect))) {
Willy Tarreau520d95e2009-09-19 21:04:57 +02002172 s->req->cons->state = SI_ST_EST; /* connection established */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002173 s->rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Willy Tarreau85e7d002010-05-31 11:57:51 +02002174 s->req->wex = TICK_ETERNITY;
2175 }
Willy Tarreau520d95e2009-09-19 21:04:57 +02002176 }
Willy Tarreau73201222009-08-16 18:27:24 +02002177 }
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002178 else {
Willy Tarreau92795622009-03-06 12:51:23 +01002179 s->req->cons->state = SI_ST_CLO; /* shutw+ini = abort */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002180 channel_shutw_now(s->req); /* fix buffer flags upon abort */
2181 channel_shutr_now(s->rep);
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002182 }
Willy Tarreau92795622009-03-06 12:51:23 +01002183 }
2184
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002185
2186 /* we may have a pending connection request, or a connection waiting
2187 * for completion.
2188 */
2189 if (s->si[1].state >= SI_ST_REQ && s->si[1].state < SI_ST_CON) {
2190 do {
2191 /* nb: step 1 might switch from QUE to ASS, but we first want
2192 * to give a chance to step 2 to perform a redirect if needed.
2193 */
2194 if (s->si[1].state != SI_ST_REQ)
2195 sess_update_stream_int(s, &s->si[1]);
2196 if (s->si[1].state == SI_ST_REQ)
2197 sess_prepare_conn_req(s, &s->si[1]);
2198
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002199 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01002200 if (s->si[1].state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002201 perform_http_redirect(s, &s->si[1]);
2202 } while (s->si[1].state == SI_ST_ASS);
Mark Lamourinec2247f02012-01-04 13:02:01 -05002203
2204 /* Now we can add the server name to a header (if requested) */
2205 /* check for HTTP mode and proxy server_name_hdr_name != NULL */
Stathis Voukelatos09a030a2012-01-09 14:27:13 +01002206 if ((s->flags & SN_BE_ASSIGNED) &&
Willy Tarreau45c0d982012-03-09 12:11:57 +01002207 (s->be->mode == PR_MODE_HTTP) &&
2208 (s->be->server_id_hdr_name != NULL)) {
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002209 http_send_name_header(&s->txn, s->be, objt_server(s->target)->id);
Mark Lamourinec2247f02012-01-04 13:02:01 -05002210 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002211 }
2212
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002213 /* Benchmarks have shown that it's optimal to do a full resync now */
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002214 if (s->req->prod->state == SI_ST_DIS || s->req->cons->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002215 goto resync_stream_interface;
2216
Willy Tarreau815a9b22010-07-27 17:15:12 +02002217 /* otherwise we want to check if we need to resync the req buffer or not */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002218 if ((s->req->flags ^ rqf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002219 goto resync_request;
2220
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002221 /* perform output updates to the response buffer */
Willy Tarreau84455332009-03-15 22:34:05 +01002222
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002223 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002224 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002225 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002226 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002227 */
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002228 if (!s->rep->analysers &&
Willy Tarreaub31c9712012-11-11 23:05:39 +01002229 !(s->rep->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau31971e52009-09-20 12:07:52 +02002230 (s->rep->prod->state >= SI_ST_EST) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002231 (s->rep->to_forward != CHN_INFINITE_FORWARD)) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002232 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002233 * attached to it. If any data are left in, we'll permit them to
2234 * move.
2235 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002236 channel_auto_read(s->rep);
2237 channel_auto_close(s->rep);
Willy Tarreau9b28e032012-10-12 23:49:43 +02002238 buffer_flush(s->rep->buf);
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002239
2240 /* We'll let data flow between the producer (if still connected)
2241 * to the consumer.
2242 */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002243 if (!(s->rep->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002244 channel_forward(s->rep, CHN_INFINITE_FORWARD);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002245
2246 /* if we have no analyser anymore in any direction and have a
2247 * tunnel timeout set, use it now.
2248 */
2249 if (!s->req->analysers && s->be->timeout.tunnel) {
2250 s->req->rto = s->req->wto = s->rep->rto = s->rep->wto =
2251 s->be->timeout.tunnel;
2252 s->req->rex = s->req->wex = s->rep->rex = s->rep->wex =
2253 tick_add(now_ms, s->be->timeout.tunnel);
2254 }
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002255 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002256
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002257 /* check if it is wise to enable kernel splicing to forward response data */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002258 if (!(s->rep->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002259 s->rep->to_forward &&
2260 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002261 (s->si[0].conn->xprt && s->si[0].conn->xprt->rcv_pipe && s->si[0].conn->xprt->snd_pipe) &&
2262 (s->si[1].conn->xprt && s->si[1].conn->xprt->rcv_pipe && s->si[1].conn->xprt->snd_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002263 (pipes_used < global.maxpipes) &&
2264 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
2265 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002266 (s->rep->flags & CF_STREAMER_FAST)))) {
2267 s->rep->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002268 }
2269
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002270 /* reflect what the L7 analysers have seen last */
2271 rpf_last = s->rep->flags;
2272
2273 /*
2274 * Now forward all shutdown requests between both sides of the buffer
2275 */
2276
2277 /*
2278 * FIXME: this is probably where we should produce error responses.
2279 */
2280
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002281 /* first, let's check if the response buffer needs to shutdown(write) */
Willy Tarreaub31c9712012-11-11 23:05:39 +01002282 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002283 (CF_AUTO_CLOSE|CF_SHUTR)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002284 channel_shutw_now(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002285
2286 /* shutdown(write) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002287 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
Willy Tarreau8e21bb92012-08-24 22:40:29 +02002288 channel_is_empty(s->rep)))
Willy Tarreau73b013b2012-05-21 16:31:45 +02002289 si_shutw(s->rep->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002290
2291 /* shutdown(write) done on the client side, we must stop the server too */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002292 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
Willy Tarreau3dbc6942008-12-07 13:05:04 +01002293 !s->rep->analysers)
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002294 channel_shutr_now(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002295
2296 /* shutdown(read) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002297 if (unlikely((s->rep->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002298 if (s->rep->prod->flags & SI_FL_NOHALF)
2299 s->rep->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02002300 si_shutr(s->rep->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002301 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002302
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002303 if (s->req->prod->state == SI_ST_DIS || s->req->cons->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002304 goto resync_stream_interface;
2305
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002306 if (s->req->flags != rqf_last)
2307 goto resync_request;
2308
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002309 if ((s->rep->flags ^ rpf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002310 goto resync_response;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002311
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002312 /* we're interested in getting wakeups again */
2313 s->req->prod->flags &= ~SI_FL_DONT_WAKE;
2314 s->req->cons->flags &= ~SI_FL_DONT_WAKE;
2315
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002316 /* This is needed only when debugging is enabled, to indicate
2317 * client-side or server-side close. Please note that in the unlikely
2318 * event where both sides would close at once, the sequence is reported
2319 * on the server side first.
2320 */
2321 if (unlikely((global.mode & MODE_DEBUG) &&
2322 (!(global.mode & MODE_QUIET) ||
2323 (global.mode & MODE_VERBOSE)))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002324 if (s->si[1].state == SI_ST_CLO &&
2325 s->si[1].prev_state == SI_ST_EST) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002326 chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002327 s->uniq_id, s->be->id,
Willy Tarreau7f7ad912012-11-11 19:27:15 +01002328 (unsigned short)s->si[0].conn->t.sock.fd,
2329 (unsigned short)s->si[1].conn->t.sock.fd);
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002330 if (write(1, trash.str, trash.len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002331 }
2332
2333 if (s->si[0].state == SI_ST_CLO &&
2334 s->si[0].prev_state == SI_ST_EST) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002335 chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002336 s->uniq_id, s->be->id,
Willy Tarreau7f7ad912012-11-11 19:27:15 +01002337 (unsigned short)s->si[0].conn->t.sock.fd,
2338 (unsigned short)s->si[1].conn->t.sock.fd);
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002339 if (write(1, trash.str, trash.len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002340 }
2341 }
2342
2343 if (likely((s->rep->cons->state != SI_ST_CLO) ||
2344 (s->req->cons->state > SI_ST_INI && s->req->cons->state < SI_ST_CLO))) {
2345
2346 if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
2347 session_process_counters(s);
2348
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002349 if (s->rep->cons->state == SI_ST_EST && obj_type(s->rep->cons->conn->target) != OBJ_TYPE_APPLET)
Willy Tarreau73b013b2012-05-21 16:31:45 +02002350 si_update(s->rep->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002351
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002352 if (s->req->cons->state == SI_ST_EST && obj_type(s->req->cons->conn->target) != OBJ_TYPE_APPLET)
Willy Tarreau73b013b2012-05-21 16:31:45 +02002353 si_update(s->req->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002354
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002355 s->req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
2356 s->rep->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002357 s->si[0].prev_state = s->si[0].state;
2358 s->si[1].prev_state = s->si[1].state;
Willy Tarreaub0ef7352008-12-14 13:26:20 +01002359 s->si[0].flags &= ~(SI_FL_ERR|SI_FL_EXP);
2360 s->si[1].flags &= ~(SI_FL_ERR|SI_FL_EXP);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002361
2362 /* Trick: if a request is being waiting for the server to respond,
2363 * and if we know the server can timeout, we don't want the timeout
2364 * to expire on the client side first, but we're still interested
2365 * in passing data from the client to the server (eg: POST). Thus,
2366 * we can cancel the client's request timeout if the server's
2367 * request timeout is set and the server has not yet sent a response.
2368 */
2369
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002370 if ((s->rep->flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
Willy Tarreau86491c32008-12-14 09:04:47 +01002371 (tick_isset(s->req->wex) || tick_isset(s->rep->rex))) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002372 s->req->flags |= CF_READ_NOEXP;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002373 s->req->rex = TICK_ETERNITY;
Willy Tarreau86491c32008-12-14 09:04:47 +01002374 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002375
Willy Tarreau7a20aa62010-07-13 16:30:45 +02002376 /* Call the stream interfaces' I/O handlers when embedded.
Willy Tarreau1accfc02009-09-05 20:57:35 +02002377 * Note that this one may wake the task up again.
2378 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002379 if (obj_type(s->req->cons->conn->target) == OBJ_TYPE_APPLET ||
2380 obj_type(s->rep->cons->conn->target) == OBJ_TYPE_APPLET) {
2381 if (objt_applet(s->req->cons->conn->target))
2382 objt_applet(s->req->cons->conn->target)->fct(s->req->cons);
2383 if (objt_applet(s->rep->cons->conn->target))
2384 objt_applet(s->rep->cons->conn->target)->fct(s->rep->cons);
Willy Tarreau1accfc02009-09-05 20:57:35 +02002385 if (task_in_rq(t)) {
2386 /* If we woke up, we don't want to requeue the
2387 * task to the wait queue, but rather requeue
2388 * it into the runqueue ASAP.
2389 */
2390 t->expire = TICK_ETERNITY;
2391 return t;
2392 }
2393 }
2394
Willy Tarreau798f4322012-11-08 14:49:17 +01002395 update_exp_and_leave:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002396 t->expire = tick_first(tick_first(s->req->rex, s->req->wex),
2397 tick_first(s->rep->rex, s->rep->wex));
2398 if (s->req->analysers)
2399 t->expire = tick_first(t->expire, s->req->analyse_exp);
2400
2401 if (s->si[0].exp)
2402 t->expire = tick_first(t->expire, s->si[0].exp);
2403
2404 if (s->si[1].exp)
2405 t->expire = tick_first(t->expire, s->si[1].exp);
2406
2407#ifdef DEBUG_FULL
Willy Tarreau127334e2009-03-28 10:47:26 +01002408 fprintf(stderr,
2409 "[%u] queuing with exp=%u req->rex=%u req->wex=%u req->ana_exp=%u"
2410 " rep->rex=%u rep->wex=%u, si[0].exp=%u, si[1].exp=%u, cs=%d, ss=%d\n",
2411 now_ms, t->expire, s->req->rex, s->req->wex, s->req->analyse_exp,
2412 s->rep->rex, s->rep->wex, s->si[0].exp, s->si[1].exp, s->si[0].state, s->si[1].state);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002413#endif
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002414
2415#ifdef DEBUG_DEV
2416 /* this may only happen when no timeout is set or in case of an FSM bug */
Willy Tarreaud0a201b2009-03-08 15:53:06 +01002417 if (!tick_isset(t->expire))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002418 ABORT_NOW();
2419#endif
Willy Tarreau26c25062009-03-08 09:38:41 +01002420 return t; /* nothing more to do */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002421 }
2422
2423 s->fe->feconn--;
2424 if (s->flags & SN_BE_ASSIGNED)
2425 s->be->beconn--;
Willy Tarreau3c63fd82011-09-07 18:00:47 +02002426 if (!(s->listener->options & LI_O_UNLIMITED))
2427 actconn--;
Willy Tarreauaf7ad002010-08-31 15:39:26 +02002428 jobs--;
Willy Tarreau6e6fb2b2009-08-16 18:20:44 +02002429 s->listener->nbconn--;
Willy Tarreau62793712011-07-24 19:23:38 +02002430 if (s->listener->state == LI_FULL)
2431 resume_listener(s->listener);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002432
Willy Tarreau08ceb102011-07-24 22:58:00 +02002433 /* Dequeues all of the listeners waiting for a resource */
2434 if (!LIST_ISEMPTY(&global_listener_queue))
2435 dequeue_all_listeners(&global_listener_queue);
2436
Willy Tarreaub32907b2011-07-25 08:37:44 +02002437 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
2438 (!s->fe->fe_sps_lim || freq_ctr_remain(&s->fe->fe_sess_per_sec, s->fe->fe_sps_lim, 0) > 0))
Willy Tarreau07687c12011-07-24 23:55:06 +02002439 dequeue_all_listeners(&s->fe->listener_queue);
2440
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002441 if (unlikely((global.mode & MODE_DEBUG) &&
2442 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002443 chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002444 s->uniq_id, s->be->id,
Willy Tarreau7f7ad912012-11-11 19:27:15 +01002445 (unsigned short)s->req->prod->conn->t.sock.fd,
2446 (unsigned short)s->req->cons->conn->t.sock.fd);
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002447 if (write(1, trash.str, trash.len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002448 }
2449
2450 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2451 session_process_counters(s);
2452
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002453 if (s->txn.status) {
2454 int n;
2455
2456 n = s->txn.status / 100;
2457 if (n < 1 || n > 5)
2458 n = 0;
2459
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002460 if (s->fe->mode == PR_MODE_HTTP) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002461 s->fe->fe_counters.p.http.rsp[n]++;
Willy Tarreau8139b992012-11-27 07:35:31 +01002462 if (s->comp_algo && (s->flags & SN_COMP_READY))
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002463 s->fe->fe_counters.p.http.comp_rsp++;
2464 }
Willy Tarreau24657792010-02-26 10:30:28 +01002465 if ((s->flags & SN_BE_ASSIGNED) &&
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002466 (s->be->mode == PR_MODE_HTTP)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002467 s->be->be_counters.p.http.rsp[n]++;
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002468 s->be->be_counters.p.http.cum_req++;
Willy Tarreau8139b992012-11-27 07:35:31 +01002469 if (s->comp_algo && (s->flags & SN_COMP_READY))
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002470 s->be->be_counters.p.http.comp_rsp++;
2471 }
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002472 }
2473
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002474 /* let's do a final log if we need it */
2475 if (s->logs.logwait &&
2476 !(s->flags & SN_MONITOR) &&
2477 (!(s->fe->options & PR_O_NULLNOLOG) || s->req->total)) {
Willy Tarreaua5555ec2008-11-30 19:02:32 +01002478 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002479 }
2480
2481 /* the task MUST not be in the run queue anymore */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002482 session_free(s);
Willy Tarreau26c25062009-03-08 09:38:41 +01002483 task_delete(t);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002484 task_free(t);
Willy Tarreau26c25062009-03-08 09:38:41 +01002485 return NULL;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002486}
2487
Willy Tarreau7c669d72008-06-20 15:04:11 +02002488/*
2489 * This function adjusts sess->srv_conn and maintains the previous and new
2490 * server's served session counts. Setting newsrv to NULL is enough to release
2491 * current connection slot. This function also notifies any LB algo which might
2492 * expect to be informed about any change in the number of active sessions on a
2493 * server.
2494 */
2495void sess_change_server(struct session *sess, struct server *newsrv)
2496{
2497 if (sess->srv_conn == newsrv)
2498 return;
2499
2500 if (sess->srv_conn) {
2501 sess->srv_conn->served--;
2502 if (sess->srv_conn->proxy->lbprm.server_drop_conn)
2503 sess->srv_conn->proxy->lbprm.server_drop_conn(sess->srv_conn);
Simon Hormanaf514952011-06-21 14:34:57 +09002504 session_del_srv_conn(sess);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002505 }
2506
2507 if (newsrv) {
2508 newsrv->served++;
2509 if (newsrv->proxy->lbprm.server_take_conn)
2510 newsrv->proxy->lbprm.server_take_conn(newsrv);
Simon Hormanaf514952011-06-21 14:34:57 +09002511 session_add_srv_conn(sess, newsrv);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002512 }
2513}
2514
Willy Tarreau84455332009-03-15 22:34:05 +01002515/* Handle server-side errors for default protocols. It is called whenever a a
2516 * connection setup is aborted or a request is aborted in queue. It sets the
2517 * session termination flags so that the caller does not have to worry about
2518 * them. It's installed as ->srv_error for the server-side stream_interface.
2519 */
2520void default_srv_error(struct session *s, struct stream_interface *si)
2521{
2522 int err_type = si->err_type;
2523 int err = 0, fin = 0;
2524
2525 if (err_type & SI_ET_QUEUE_ABRT) {
2526 err = SN_ERR_CLICL;
2527 fin = SN_FINST_Q;
2528 }
2529 else if (err_type & SI_ET_CONN_ABRT) {
2530 err = SN_ERR_CLICL;
2531 fin = SN_FINST_C;
2532 }
2533 else if (err_type & SI_ET_QUEUE_TO) {
2534 err = SN_ERR_SRVTO;
2535 fin = SN_FINST_Q;
2536 }
2537 else if (err_type & SI_ET_QUEUE_ERR) {
2538 err = SN_ERR_SRVCL;
2539 fin = SN_FINST_Q;
2540 }
2541 else if (err_type & SI_ET_CONN_TO) {
2542 err = SN_ERR_SRVTO;
2543 fin = SN_FINST_C;
2544 }
2545 else if (err_type & SI_ET_CONN_ERR) {
2546 err = SN_ERR_SRVCL;
2547 fin = SN_FINST_C;
2548 }
2549 else /* SI_ET_CONN_OTHER and others */ {
2550 err = SN_ERR_INTERNAL;
2551 fin = SN_FINST_C;
2552 }
2553
2554 if (!(s->flags & SN_ERR_MASK))
2555 s->flags |= err;
2556 if (!(s->flags & SN_FINST_MASK))
2557 s->flags |= fin;
2558}
Willy Tarreau7c669d72008-06-20 15:04:11 +02002559
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002560/* kill a session and set the termination flags to <why> (one of SN_ERR_*) */
2561void session_shutdown(struct session *session, int why)
2562{
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002563 if (session->req->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002564 return;
2565
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002566 channel_shutw_now(session->req);
2567 channel_shutr_now(session->rep);
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002568 session->task->nice = 1024;
2569 if (!(session->flags & SN_ERR_MASK))
2570 session->flags |= why;
2571 task_wakeup(session->task, TASK_WOKEN_OTHER);
2572}
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02002573
Willy Tarreau8b22a712010-06-18 17:46:06 +02002574/************************************************************************/
2575/* All supported ACL keywords must be declared here. */
2576/************************************************************************/
2577
Willy Tarreaua5e37562011-12-16 17:06:15 +01002578/* set temp integer to the General Purpose Counter 0 value in the stksess entry <ts> */
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002579static int
Willy Tarreau37406352012-04-23 16:16:37 +02002580acl_fetch_get_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002581{
Willy Tarreau37406352012-04-23 16:16:37 +02002582 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002583 smp->type = SMP_T_UINT;
2584 smp->data.uint = 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002585 if (ts != NULL) {
2586 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2587 if (!ptr)
2588 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002589 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002590 }
2591 return 1;
2592}
2593
Willy Tarreaua5e37562011-12-16 17:06:15 +01002594/* set temp integer to the General Purpose Counter 0 value from the session's tracked
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002595 * frontend counters.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002596 */
2597static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002598acl_fetch_sc1_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002599 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002600{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002601 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002602 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002603 return acl_fetch_get_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002604}
2605
Willy Tarreaua5e37562011-12-16 17:06:15 +01002606/* set temp integer to the General Purpose Counter 0 value from the session's tracked
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002607 * backend counters.
2608 */
2609static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002610acl_fetch_sc2_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002611 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002612{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002613 if (!l4->stkctr[1].entry)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002614 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002615 return acl_fetch_get_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002616}
2617
Willy Tarreaua5e37562011-12-16 17:06:15 +01002618/* set temp integer to the General Purpose Counter 0 value from the session's source
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002619 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002620 * Accepts exactly 1 argument of type table.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002621 */
2622static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002623acl_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002624 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002625{
2626 struct stktable_key *key;
2627
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002628 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002629 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002630 return 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002631
Willy Tarreau24e32d82012-04-23 23:55:44 +02002632 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002633 return acl_fetch_get_gpc0(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002634}
2635
2636/* Increment the General Purpose Counter 0 value in the stksess entry <ts> and
Willy Tarreaua5e37562011-12-16 17:06:15 +01002637 * return it into temp integer.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002638 */
2639static int
Willy Tarreau37406352012-04-23 16:16:37 +02002640acl_fetch_inc_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002641{
Willy Tarreau37406352012-04-23 16:16:37 +02002642 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002643 smp->type = SMP_T_UINT;
2644 smp->data.uint = 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002645 if (ts != NULL) {
2646 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2647 if (!ptr)
2648 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002649 smp->data.uint = ++stktable_data_cast(ptr, gpc0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002650 }
2651 return 1;
2652}
2653
2654/* Increment the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002655 * frontend counters and return it into temp integer.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002656 */
2657static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002658acl_fetch_sc1_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002659 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002660{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002661 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002662 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002663 return acl_fetch_inc_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002664}
2665
2666/* Increment the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002667 * backend counters and return it into temp integer.
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002668 */
2669static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002670acl_fetch_sc2_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002671 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002672{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002673 if (!l4->stkctr[1].entry)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002674 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002675 return acl_fetch_inc_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002676}
2677
2678/* Increment the General Purpose Counter 0 value from the session's source
Willy Tarreaua5e37562011-12-16 17:06:15 +01002679 * address in the table pointed to by expr, and return it into temp integer.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002680 * Accepts exactly 1 argument of type table.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002681 */
2682static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002683acl_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002684 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002685{
2686 struct stktable_key *key;
2687
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002688 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002689 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002690 return 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002691
Willy Tarreau24e32d82012-04-23 23:55:44 +02002692 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002693 return acl_fetch_inc_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002694}
2695
Willy Tarreauf73cd112011-08-13 01:45:16 +02002696/* Clear the General Purpose Counter 0 value in the stksess entry <ts> and
Willy Tarreaua5e37562011-12-16 17:06:15 +01002697 * return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002698 */
2699static int
Willy Tarreau37406352012-04-23 16:16:37 +02002700acl_fetch_clr_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002701{
Willy Tarreau37406352012-04-23 16:16:37 +02002702 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002703 smp->type = SMP_T_UINT;
2704 smp->data.uint = 0;
Willy Tarreauf73cd112011-08-13 01:45:16 +02002705 if (ts != NULL) {
2706 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2707 if (!ptr)
2708 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002709 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002710 stktable_data_cast(ptr, gpc0) = 0;
2711 }
2712 return 1;
2713}
2714
2715/* Clear the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002716 * frontend counters and return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002717 */
2718static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002719acl_fetch_sc1_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002720 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002721{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002722 if (!l4->stkctr[0].entry)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002723 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002724 return acl_fetch_clr_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002725}
2726
2727/* Clear the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002728 * backend counters and return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002729 */
2730static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002731acl_fetch_sc2_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002732 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002733{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002734 if (!l4->stkctr[1].entry)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002735 return 0;
Willy Tarreau20d46a52012-12-09 15:55:40 +01002736 return acl_fetch_clr_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002737}
2738
2739/* Clear the General Purpose Counter 0 value from the session's source address
Willy Tarreaua5e37562011-12-16 17:06:15 +01002740 * in the table pointed to by expr, and return its previous value into temp integer.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002741 * Accepts exactly 1 argument of type table.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002742 */
2743static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002744acl_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002745 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002746{
2747 struct stktable_key *key;
2748
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002749 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002750 if (!key)
2751 return 0;
2752
Willy Tarreau24e32d82012-04-23 23:55:44 +02002753 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002754 return acl_fetch_clr_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
Willy Tarreauf73cd112011-08-13 01:45:16 +02002755}
2756
Willy Tarreaua5e37562011-12-16 17:06:15 +01002757/* set temp integer to the cumulated number of connections in the stksess entry <ts> */
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002758static int
Willy Tarreau37406352012-04-23 16:16:37 +02002759acl_fetch_conn_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002760{
Willy Tarreau37406352012-04-23 16:16:37 +02002761 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002762 smp->type = SMP_T_UINT;
2763 smp->data.uint = 0;
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002764 if (ts != NULL) {
2765 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_CNT);
2766 if (!ptr)
2767 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002768 smp->data.uint = stktable_data_cast(ptr, conn_cnt);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002769 }
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002770 return 1;
2771}
2772
Willy Tarreaua5e37562011-12-16 17:06:15 +01002773/* set temp integer to the cumulated number of connections from the session's tracked FE counters */
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002774static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002775acl_fetch_sc1_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002776 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002777{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002778 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002779 return 0;
2780
Willy Tarreau20d46a52012-12-09 15:55:40 +01002781 return acl_fetch_conn_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002782}
2783
Willy Tarreaua5e37562011-12-16 17:06:15 +01002784/* set temp integer to the cumulated number of connections from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002785static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002786acl_fetch_sc2_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002787 const struct arg *args, struct sample *smp)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002788{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002789 if (!l4->stkctr[1].entry)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002790 return 0;
2791
Willy Tarreau20d46a52012-12-09 15:55:40 +01002792 return acl_fetch_conn_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002793}
2794
Willy Tarreaua5e37562011-12-16 17:06:15 +01002795/* set temp integer to the cumulated number of connections from the session's source
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002796 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002797 * Accepts exactly 1 argument of type table.
Willy Tarreau8b22a712010-06-18 17:46:06 +02002798 */
2799static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002800acl_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002801 const struct arg *args, struct sample *smp)
Willy Tarreau8b22a712010-06-18 17:46:06 +02002802{
Willy Tarreau8b22a712010-06-18 17:46:06 +02002803 struct stktable_key *key;
2804
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002805 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau8b22a712010-06-18 17:46:06 +02002806 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002807 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002808
Willy Tarreau24e32d82012-04-23 23:55:44 +02002809 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002810 return acl_fetch_conn_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau8b22a712010-06-18 17:46:06 +02002811}
2812
Willy Tarreaua5e37562011-12-16 17:06:15 +01002813/* set temp integer to the connection rate in the stksess entry <ts> over the configured period */
Willy Tarreau91c43d72010-06-20 11:19:22 +02002814static int
Willy Tarreau37406352012-04-23 16:16:37 +02002815acl_fetch_conn_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002816{
Willy Tarreau37406352012-04-23 16:16:37 +02002817 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002818 smp->type = SMP_T_UINT;
2819 smp->data.uint = 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002820 if (ts != NULL) {
2821 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_RATE);
2822 if (!ptr)
2823 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002824 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
Willy Tarreau91c43d72010-06-20 11:19:22 +02002825 table->data_arg[STKTABLE_DT_CONN_RATE].u);
2826 }
2827 return 1;
2828}
2829
Willy Tarreaua5e37562011-12-16 17:06:15 +01002830/* set temp integer to the connection rate from the session's tracked FE counters over
Willy Tarreau91c43d72010-06-20 11:19:22 +02002831 * the configured period.
2832 */
2833static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002834acl_fetch_sc1_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002835 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002836{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002837 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002838 return 0;
2839
Willy Tarreau20d46a52012-12-09 15:55:40 +01002840 return acl_fetch_conn_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002841}
2842
Willy Tarreaua5e37562011-12-16 17:06:15 +01002843/* set temp integer to the connection rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002844 * the configured period.
2845 */
2846static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002847acl_fetch_sc2_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002848 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002849{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002850 if (!l4->stkctr[1].entry)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002851 return 0;
2852
Willy Tarreau20d46a52012-12-09 15:55:40 +01002853 return acl_fetch_conn_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002854}
2855
Willy Tarreaua5e37562011-12-16 17:06:15 +01002856/* set temp integer to the connection rate from the session's source address in the
Willy Tarreau91c43d72010-06-20 11:19:22 +02002857 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002858 * Accepts exactly 1 argument of type table.
Willy Tarreau91c43d72010-06-20 11:19:22 +02002859 */
2860static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002861acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002862 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002863{
2864 struct stktable_key *key;
2865
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002866 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002867 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002868 return 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002869
Willy Tarreau24e32d82012-04-23 23:55:44 +02002870 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002871 return acl_fetch_conn_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau91c43d72010-06-20 11:19:22 +02002872}
2873
Willy Tarreaua5e37562011-12-16 17:06:15 +01002874/* set temp integer to the number of connections from the session's source address
Willy Tarreau8b22a712010-06-18 17:46:06 +02002875 * in the table pointed to by expr, after updating it.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002876 * Accepts exactly 1 argument of type table.
Willy Tarreau8b22a712010-06-18 17:46:06 +02002877 */
2878static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002879acl_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002880 const struct arg *args, struct sample *smp)
Willy Tarreau8b22a712010-06-18 17:46:06 +02002881{
2882 struct stksess *ts;
2883 struct stktable_key *key;
2884 void *ptr;
2885
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002886 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau8b22a712010-06-18 17:46:06 +02002887 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002888 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002889
Willy Tarreau24e32d82012-04-23 23:55:44 +02002890 px = args->data.prx;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002891
Willy Tarreau1f7e9252010-06-20 12:27:21 +02002892 if ((ts = stktable_update_key(&px->table, key)) == NULL)
2893 /* entry does not exist and could not be created */
2894 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002895
2896 ptr = stktable_data_ptr(&px->table, ts, STKTABLE_DT_CONN_CNT);
2897 if (!ptr)
2898 return 0; /* parameter not stored in this table */
2899
Willy Tarreauf853c462012-04-23 18:53:56 +02002900 smp->type = SMP_T_UINT;
2901 smp->data.uint = ++stktable_data_cast(ptr, conn_cnt);
Willy Tarreau37406352012-04-23 16:16:37 +02002902 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002903 return 1;
2904}
2905
Willy Tarreaua5e37562011-12-16 17:06:15 +01002906/* set temp integer to the number of concurrent connections in the stksess entry <ts> */
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002907static int
Willy Tarreau37406352012-04-23 16:16:37 +02002908acl_fetch_conn_cur(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002909{
Willy Tarreau37406352012-04-23 16:16:37 +02002910 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002911 smp->type = SMP_T_UINT;
2912 smp->data.uint = 0;
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002913
2914 if (ts != NULL) {
2915 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_CUR);
2916 if (!ptr)
2917 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002918 smp->data.uint = stktable_data_cast(ptr, conn_cur);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002919 }
2920 return 1;
2921}
2922
Willy Tarreaua5e37562011-12-16 17:06:15 +01002923/* set temp integer to the number of concurrent connections from the session's tracked FE counters */
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002924static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002925acl_fetch_sc1_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002926 const struct arg *args, struct sample *smp)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002927{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002928 if (!l4->stkctr[0].entry)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002929 return 0;
2930
Willy Tarreau20d46a52012-12-09 15:55:40 +01002931 return acl_fetch_conn_cur(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002932}
2933
Willy Tarreaua5e37562011-12-16 17:06:15 +01002934/* set temp integer to the number of concurrent connections from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002935static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002936acl_fetch_sc2_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002937 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002938{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002939 if (!l4->stkctr[1].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002940 return 0;
2941
Willy Tarreau20d46a52012-12-09 15:55:40 +01002942 return acl_fetch_conn_cur(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002943}
2944
Willy Tarreaua5e37562011-12-16 17:06:15 +01002945/* set temp integer to the number of concurrent connections from the session's source
Willy Tarreau38285c12010-06-18 16:35:43 +02002946 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002947 * Accepts exactly 1 argument of type table.
Willy Tarreau38285c12010-06-18 16:35:43 +02002948 */
2949static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002950acl_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002951 const struct arg *args, struct sample *smp)
Willy Tarreau38285c12010-06-18 16:35:43 +02002952{
Willy Tarreau38285c12010-06-18 16:35:43 +02002953 struct stktable_key *key;
2954
Willy Tarreauf2943dc2012-10-26 20:10:28 +02002955 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau38285c12010-06-18 16:35:43 +02002956 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002957 return 0;
Willy Tarreau38285c12010-06-18 16:35:43 +02002958
Willy Tarreau24e32d82012-04-23 23:55:44 +02002959 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002960 return acl_fetch_conn_cur(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau38285c12010-06-18 16:35:43 +02002961}
2962
Willy Tarreaua5e37562011-12-16 17:06:15 +01002963/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002964static int
Willy Tarreau37406352012-04-23 16:16:37 +02002965acl_fetch_sess_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002966{
Willy Tarreau37406352012-04-23 16:16:37 +02002967 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002968 smp->type = SMP_T_UINT;
2969 smp->data.uint = 0;
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002970 if (ts != NULL) {
2971 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_SESS_CNT);
2972 if (!ptr)
2973 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002974 smp->data.uint = stktable_data_cast(ptr, sess_cnt);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002975 }
2976 return 1;
2977}
2978
Willy Tarreaua5e37562011-12-16 17:06:15 +01002979/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002980static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002981acl_fetch_sc1_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002982 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002983{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002984 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002985 return 0;
2986
Willy Tarreau20d46a52012-12-09 15:55:40 +01002987 return acl_fetch_sess_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002988}
2989
Willy Tarreaua5e37562011-12-16 17:06:15 +01002990/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002991static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002992acl_fetch_sc2_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002993 const struct arg *args, struct sample *smp)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002994{
Willy Tarreau20d46a52012-12-09 15:55:40 +01002995 if (!l4->stkctr[1].entry)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002996 return 0;
2997
Willy Tarreau20d46a52012-12-09 15:55:40 +01002998 return acl_fetch_sess_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002999}
3000
Willy Tarreaua5e37562011-12-16 17:06:15 +01003001/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003002 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003003 * Accepts exactly 1 argument of type table.
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003004 */
3005static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003006acl_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003007 const struct arg *args, struct sample *smp)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003008{
3009 struct stktable_key *key;
3010
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003011 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003012 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003013 return 0;
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003014
Willy Tarreau24e32d82012-04-23 23:55:44 +02003015 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003016 return acl_fetch_sess_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauf4d17d92010-06-18 22:10:12 +02003017}
3018
Willy Tarreaua5e37562011-12-16 17:06:15 +01003019/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreau91c43d72010-06-20 11:19:22 +02003020static int
Willy Tarreau37406352012-04-23 16:16:37 +02003021acl_fetch_sess_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003022{
Willy Tarreau37406352012-04-23 16:16:37 +02003023 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003024 smp->type = SMP_T_UINT;
3025 smp->data.uint = 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02003026 if (ts != NULL) {
3027 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_SESS_RATE);
3028 if (!ptr)
3029 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003030 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau91c43d72010-06-20 11:19:22 +02003031 table->data_arg[STKTABLE_DT_SESS_RATE].u);
3032 }
3033 return 1;
3034}
3035
Willy Tarreaua5e37562011-12-16 17:06:15 +01003036/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003037 * the configured period.
3038 */
3039static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003040acl_fetch_sc1_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003041 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003042{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003043 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003044 return 0;
3045
Willy Tarreau20d46a52012-12-09 15:55:40 +01003046 return acl_fetch_sess_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003047}
3048
Willy Tarreaua5e37562011-12-16 17:06:15 +01003049/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreau91c43d72010-06-20 11:19:22 +02003050 * the configured period.
3051 */
3052static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003053acl_fetch_sc2_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003054 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003055{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003056 if (!l4->stkctr[1].entry)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003057 return 0;
3058
Willy Tarreau20d46a52012-12-09 15:55:40 +01003059 return acl_fetch_sess_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003060}
3061
Willy Tarreaua5e37562011-12-16 17:06:15 +01003062/* set temp integer to the session rate from the session's source address in the
Willy Tarreau91c43d72010-06-20 11:19:22 +02003063 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003064 * Accepts exactly 1 argument of type table.
Willy Tarreau91c43d72010-06-20 11:19:22 +02003065 */
3066static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003067acl_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003068 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02003069{
3070 struct stktable_key *key;
3071
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003072 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau91c43d72010-06-20 11:19:22 +02003073 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003074 return 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02003075
Willy Tarreau24e32d82012-04-23 23:55:44 +02003076 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003077 return acl_fetch_sess_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau91c43d72010-06-20 11:19:22 +02003078}
3079
Willy Tarreaua5e37562011-12-16 17:06:15 +01003080/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003081static int
Willy Tarreau37406352012-04-23 16:16:37 +02003082acl_fetch_http_req_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003083{
Willy Tarreau37406352012-04-23 16:16:37 +02003084 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003085 smp->type = SMP_T_UINT;
3086 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003087 if (ts != NULL) {
3088 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_REQ_CNT);
3089 if (!ptr)
3090 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003091 smp->data.uint = stktable_data_cast(ptr, http_req_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003092 }
3093 return 1;
3094}
3095
Willy Tarreaua5e37562011-12-16 17:06:15 +01003096/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003097static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003098acl_fetch_sc1_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003099 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003100{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003101 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003102 return 0;
3103
Willy Tarreau20d46a52012-12-09 15:55:40 +01003104 return acl_fetch_http_req_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003105}
3106
Willy Tarreaua5e37562011-12-16 17:06:15 +01003107/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003108static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003109acl_fetch_sc2_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003110 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003111{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003112 if (!l4->stkctr[1].entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003113 return 0;
3114
Willy Tarreau20d46a52012-12-09 15:55:40 +01003115 return acl_fetch_http_req_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003116}
3117
Willy Tarreaua5e37562011-12-16 17:06:15 +01003118/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauda7ff642010-06-23 11:44:09 +02003119 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003120 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003121 */
3122static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003123acl_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003124 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003125{
3126 struct stktable_key *key;
3127
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003128 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003129 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003130 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003131
Willy Tarreau24e32d82012-04-23 23:55:44 +02003132 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003133 return acl_fetch_http_req_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003134}
3135
Willy Tarreaua5e37562011-12-16 17:06:15 +01003136/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003137static int
Willy Tarreau37406352012-04-23 16:16:37 +02003138acl_fetch_http_req_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003139{
Willy Tarreau37406352012-04-23 16:16:37 +02003140 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003141 smp->type = SMP_T_UINT;
3142 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003143 if (ts != NULL) {
3144 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_REQ_RATE);
3145 if (!ptr)
3146 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003147 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreauda7ff642010-06-23 11:44:09 +02003148 table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
3149 }
3150 return 1;
3151}
3152
Willy Tarreaua5e37562011-12-16 17:06:15 +01003153/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauda7ff642010-06-23 11:44:09 +02003154 * the configured period.
3155 */
3156static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003157acl_fetch_sc1_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003158 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003159{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003160 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003161 return 0;
3162
Willy Tarreau20d46a52012-12-09 15:55:40 +01003163 return acl_fetch_http_req_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003164}
3165
Willy Tarreaua5e37562011-12-16 17:06:15 +01003166/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003167 * the configured period.
3168 */
3169static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003170acl_fetch_sc2_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003171 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003172{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003173 if (!l4->stkctr[1].entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003174 return 0;
3175
Willy Tarreau20d46a52012-12-09 15:55:40 +01003176 return acl_fetch_http_req_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003177}
3178
Willy Tarreaua5e37562011-12-16 17:06:15 +01003179/* set temp integer to the session rate from the session's source address in the
Willy Tarreauda7ff642010-06-23 11:44:09 +02003180 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003181 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003182 */
3183static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003184acl_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003185 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003186{
3187 struct stktable_key *key;
3188
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003189 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003190 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003191 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003192
Willy Tarreau24e32d82012-04-23 23:55:44 +02003193 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003194 return acl_fetch_http_req_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003195}
3196
Willy Tarreaua5e37562011-12-16 17:06:15 +01003197/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003198static int
Willy Tarreau37406352012-04-23 16:16:37 +02003199acl_fetch_http_err_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003200{
Willy Tarreau37406352012-04-23 16:16:37 +02003201 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003202 smp->type = SMP_T_UINT;
3203 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003204 if (ts != NULL) {
3205 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_ERR_CNT);
3206 if (!ptr)
3207 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003208 smp->data.uint = stktable_data_cast(ptr, http_err_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003209 }
3210 return 1;
3211}
3212
Willy Tarreaua5e37562011-12-16 17:06:15 +01003213/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003214static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003215acl_fetch_sc1_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003216 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003217{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003218 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003219 return 0;
3220
Willy Tarreau20d46a52012-12-09 15:55:40 +01003221 return acl_fetch_http_err_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003222}
3223
Willy Tarreaua5e37562011-12-16 17:06:15 +01003224/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003225static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003226acl_fetch_sc2_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003227 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003228{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003229 if (!l4->stkctr[1].entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003230 return 0;
3231
Willy Tarreau20d46a52012-12-09 15:55:40 +01003232 return acl_fetch_http_err_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003233}
3234
Willy Tarreaua5e37562011-12-16 17:06:15 +01003235/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauda7ff642010-06-23 11:44:09 +02003236 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003237 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003238 */
3239static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003240acl_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003241 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003242{
3243 struct stktable_key *key;
3244
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003245 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003246 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003247 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003248
Willy Tarreau24e32d82012-04-23 23:55:44 +02003249 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003250 return acl_fetch_http_err_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003251}
3252
Willy Tarreaua5e37562011-12-16 17:06:15 +01003253/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003254static int
Willy Tarreau37406352012-04-23 16:16:37 +02003255acl_fetch_http_err_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003256{
Willy Tarreau37406352012-04-23 16:16:37 +02003257 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003258 smp->type = SMP_T_UINT;
3259 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003260 if (ts != NULL) {
3261 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_ERR_RATE);
3262 if (!ptr)
3263 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003264 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreauda7ff642010-06-23 11:44:09 +02003265 table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
3266 }
3267 return 1;
3268}
3269
Willy Tarreaua5e37562011-12-16 17:06:15 +01003270/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauda7ff642010-06-23 11:44:09 +02003271 * the configured period.
3272 */
3273static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003274acl_fetch_sc1_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003275 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003276{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003277 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003278 return 0;
3279
Willy Tarreau20d46a52012-12-09 15:55:40 +01003280 return acl_fetch_http_err_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003281}
3282
Willy Tarreaua5e37562011-12-16 17:06:15 +01003283/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003284 * the configured period.
3285 */
3286static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003287acl_fetch_sc2_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003288 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003289{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003290 if (!l4->stkctr[1].entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003291 return 0;
3292
Willy Tarreau20d46a52012-12-09 15:55:40 +01003293 return acl_fetch_http_err_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003294}
3295
Willy Tarreaua5e37562011-12-16 17:06:15 +01003296/* set temp integer to the session rate from the session's source address in the
Willy Tarreauda7ff642010-06-23 11:44:09 +02003297 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003298 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003299 */
3300static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003301acl_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003302 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003303{
3304 struct stktable_key *key;
3305
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003306 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003307 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003308 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003309
Willy Tarreau24e32d82012-04-23 23:55:44 +02003310 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003311 return acl_fetch_http_err_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003312}
3313
Willy Tarreaua5e37562011-12-16 17:06:15 +01003314/* set temp integer to the number of kbytes received from clients matching the stksess entry <ts> */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003315static int
Willy Tarreau37406352012-04-23 16:16:37 +02003316acl_fetch_kbytes_in(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003317{
Willy Tarreau37406352012-04-23 16:16:37 +02003318 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003319 smp->type = SMP_T_UINT;
3320 smp->data.uint = 0;
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003321
3322 if (ts != NULL) {
3323 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_IN_CNT);
3324 if (!ptr)
3325 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003326 smp->data.uint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003327 }
3328 return 1;
3329}
3330
Willy Tarreaua5e37562011-12-16 17:06:15 +01003331/* set temp integer to the number of kbytes received from clients according to the
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003332 * session's tracked FE counters.
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003333 */
3334static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003335acl_fetch_sc1_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003336 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003337{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003338 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003339 return 0;
3340
Willy Tarreau20d46a52012-12-09 15:55:40 +01003341 return acl_fetch_kbytes_in(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003342}
3343
Willy Tarreaua5e37562011-12-16 17:06:15 +01003344/* set temp integer to the number of kbytes received from clients according to the
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003345 * session's tracked BE counters.
3346 */
3347static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003348acl_fetch_sc2_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003349 const struct arg *args, struct sample *smp)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003350{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003351 if (!l4->stkctr[1].entry)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003352 return 0;
3353
Willy Tarreau20d46a52012-12-09 15:55:40 +01003354 return acl_fetch_kbytes_in(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003355}
3356
Willy Tarreaua5e37562011-12-16 17:06:15 +01003357/* set temp integer to the number of kbytes received from the session's source
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003358 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003359 * Accepts exactly 1 argument of type table.
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003360 */
3361static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003362acl_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003363 const struct arg *args, struct sample *smp)
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003364{
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003365 struct stktable_key *key;
3366
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003367 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003368 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003369 return 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003370
Willy Tarreau24e32d82012-04-23 23:55:44 +02003371 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003372 return acl_fetch_kbytes_in(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003373}
3374
Willy Tarreaua5e37562011-12-16 17:06:15 +01003375/* set temp integer to the bytes rate from clients in the stksess entry <ts> over the
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003376 * configured period.
3377 */
3378static int
Willy Tarreau37406352012-04-23 16:16:37 +02003379acl_fetch_bytes_in_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003380{
Willy Tarreau37406352012-04-23 16:16:37 +02003381 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003382 smp->type = SMP_T_UINT;
3383 smp->data.uint = 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003384 if (ts != NULL) {
3385 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_IN_RATE);
3386 if (!ptr)
3387 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003388 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003389 table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
3390 }
3391 return 1;
3392}
3393
Willy Tarreaua5e37562011-12-16 17:06:15 +01003394/* set temp integer to the bytes rate from clients from the session's tracked FE
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003395 * counters over the configured period.
3396 */
3397static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003398acl_fetch_sc1_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003399 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003400{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003401 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003402 return 0;
3403
Willy Tarreau20d46a52012-12-09 15:55:40 +01003404 return acl_fetch_bytes_in_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003405}
3406
Willy Tarreaua5e37562011-12-16 17:06:15 +01003407/* set temp integer to the bytes rate from clients from the session's tracked BE
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003408 * counters over the configured period.
3409 */
3410static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003411acl_fetch_sc2_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003412 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003413{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003414 if (!l4->stkctr[1].entry)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003415 return 0;
3416
Willy Tarreau20d46a52012-12-09 15:55:40 +01003417 return acl_fetch_bytes_in_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003418}
3419
Willy Tarreaua5e37562011-12-16 17:06:15 +01003420/* set temp integer to the bytes rate from clients from the session's source address
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003421 * in the table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003422 * Accepts exactly 1 argument of type table.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003423 */
3424static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003425acl_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003426 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003427{
3428 struct stktable_key *key;
3429
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003430 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003431 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003432 return 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003433
Willy Tarreau24e32d82012-04-23 23:55:44 +02003434 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003435 return acl_fetch_bytes_in_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003436}
3437
Willy Tarreaua5e37562011-12-16 17:06:15 +01003438/* set temp integer to the number of kbytes sent to clients matching the stksess entry <ts> */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003439static int
Willy Tarreau37406352012-04-23 16:16:37 +02003440acl_fetch_kbytes_out(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003441{
Willy Tarreau37406352012-04-23 16:16:37 +02003442 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003443 smp->type = SMP_T_UINT;
3444 smp->data.uint = 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003445
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003446 if (ts != NULL) {
3447 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_OUT_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003448 if (!ptr)
3449 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003450 smp->data.uint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003451 }
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003452 return 1;
3453}
3454
Willy Tarreaua5e37562011-12-16 17:06:15 +01003455/* set temp integer to the number of kbytes sent to clients according to the session's
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003456 * tracked FE counters.
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003457 */
3458static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003459acl_fetch_sc1_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003460 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003461{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003462 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003463 return 0;
3464
Willy Tarreau20d46a52012-12-09 15:55:40 +01003465 return acl_fetch_kbytes_out(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003466}
3467
Willy Tarreaua5e37562011-12-16 17:06:15 +01003468/* set temp integer to the number of kbytes sent to clients according to the session's
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003469 * tracked BE counters.
3470 */
3471static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003472acl_fetch_sc2_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003473 const struct arg *args, struct sample *smp)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003474{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003475 if (!l4->stkctr[1].entry)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003476 return 0;
3477
Willy Tarreau20d46a52012-12-09 15:55:40 +01003478 return acl_fetch_kbytes_out(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003479}
3480
Willy Tarreaua5e37562011-12-16 17:06:15 +01003481/* set temp integer to the number of kbytes sent to the session's source address in
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003482 * the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003483 * Accepts exactly 1 argument of type table.
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003484 */
3485static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003486acl_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003487 const struct arg *args, struct sample *smp)
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003488{
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003489 struct stktable_key *key;
3490
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003491 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003492 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003493 return 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003494
Willy Tarreau24e32d82012-04-23 23:55:44 +02003495 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003496 return acl_fetch_kbytes_out(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003497}
3498
Willy Tarreaua5e37562011-12-16 17:06:15 +01003499/* set temp integer to the bytes rate to clients in the stksess entry <ts> over the
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003500 * configured period.
3501 */
3502static int
Willy Tarreau37406352012-04-23 16:16:37 +02003503acl_fetch_bytes_out_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003504{
Willy Tarreau37406352012-04-23 16:16:37 +02003505 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003506 smp->type = SMP_T_UINT;
3507 smp->data.uint = 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003508 if (ts != NULL) {
3509 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_OUT_RATE);
3510 if (!ptr)
3511 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003512 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003513 table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
3514 }
3515 return 1;
3516}
3517
Willy Tarreaua5e37562011-12-16 17:06:15 +01003518/* set temp integer to the bytes rate to clients from the session's tracked FE counters
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003519 * over the configured period.
3520 */
3521static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003522acl_fetch_sc1_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003523 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003524{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003525 if (!l4->stkctr[0].entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003526 return 0;
3527
Willy Tarreau20d46a52012-12-09 15:55:40 +01003528 return acl_fetch_bytes_out_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003529}
3530
Willy Tarreaua5e37562011-12-16 17:06:15 +01003531/* set temp integer to the bytes rate to clients from the session's tracked BE counters
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003532 * over the configured period.
3533 */
3534static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003535acl_fetch_sc2_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003536 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003537{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003538 if (!l4->stkctr[1].entry)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003539 return 0;
3540
Willy Tarreau20d46a52012-12-09 15:55:40 +01003541 return acl_fetch_bytes_out_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003542}
3543
Willy Tarreaua5e37562011-12-16 17:06:15 +01003544/* set temp integer to the bytes rate to client from the session's source address in
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003545 * the table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003546 * Accepts exactly 1 argument of type table.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003547 */
3548static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003549acl_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003550 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003551{
3552 struct stktable_key *key;
3553
Willy Tarreauf2943dc2012-10-26 20:10:28 +02003554 key = addr_to_stktable_key(&l4->si[0].conn->addr.from);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003555 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003556 return 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003557
Willy Tarreau24e32d82012-04-23 23:55:44 +02003558 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003559 return acl_fetch_bytes_out_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003560}
3561
Willy Tarreau2406db42012-12-09 12:16:43 +01003562/* set temp integer to the number of active trackers on the SC1 entry */
3563static int
3564acl_fetch_sc1_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
3565 const struct arg *args, struct sample *smp)
3566{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003567 if (!l4->stkctr[0].entry)
Willy Tarreau2406db42012-12-09 12:16:43 +01003568 return 0;
3569
Willy Tarreau20d46a52012-12-09 15:55:40 +01003570 return l4->stkctr[0].entry->ref_cnt;
Willy Tarreau2406db42012-12-09 12:16:43 +01003571}
3572
3573/* set temp integer to the number of active trackers on the SC1 entry */
3574static int
3575acl_fetch_sc2_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
3576 const struct arg *args, struct sample *smp)
3577{
Willy Tarreau20d46a52012-12-09 15:55:40 +01003578 if (!l4->stkctr[1].entry)
Willy Tarreau2406db42012-12-09 12:16:43 +01003579 return 0;
3580
Willy Tarreau20d46a52012-12-09 15:55:40 +01003581 return l4->stkctr[1].entry->ref_cnt;
Willy Tarreau2406db42012-12-09 12:16:43 +01003582}
3583
Willy Tarreau34db1082012-04-19 17:16:54 +02003584/* set temp integer to the number of used entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003585 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003586 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003587static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003588acl_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003589 const struct arg *args, struct sample *smp)
Willy Tarreauc735a072011-03-29 00:57:02 +02003590{
Willy Tarreau37406352012-04-23 16:16:37 +02003591 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003592 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02003593 smp->data.uint = args->data.prx->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003594 return 1;
3595}
3596
Willy Tarreau34db1082012-04-19 17:16:54 +02003597/* set temp integer to the number of free entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003598 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003599 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003600static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003601acl_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003602 const struct arg *args, struct sample *smp)
Willy Tarreauc735a072011-03-29 00:57:02 +02003603{
Willy Tarreau24e32d82012-04-23 23:55:44 +02003604 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003605 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003606 smp->type = SMP_T_UINT;
3607 smp->data.uint = px->table.size - px->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003608 return 1;
3609}
Willy Tarreau8b22a712010-06-18 17:46:06 +02003610
Willy Tarreau61612d42012-04-19 18:42:05 +02003611/* Note: must not be declared <const> as its list will be overwritten.
3612 * Please take care of keeping this list alphabetically sorted.
3613 */
Willy Tarreau8b22a712010-06-18 17:46:06 +02003614static struct acl_kw_list acl_kws = {{ },{
Willy Tarreau61612d42012-04-19 18:42:05 +02003615 { "sc1_bytes_in_rate", acl_parse_int, acl_fetch_sc1_bytes_in_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3616 { "sc1_bytes_out_rate", acl_parse_int, acl_fetch_sc1_bytes_out_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3617 { "sc1_clr_gpc0", acl_parse_int, acl_fetch_sc1_clr_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3618 { "sc1_conn_cnt", acl_parse_int, acl_fetch_sc1_conn_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3619 { "sc1_conn_cur", acl_parse_int, acl_fetch_sc1_conn_cur, acl_match_int, ACL_USE_NOTHING, 0 },
3620 { "sc1_conn_rate", acl_parse_int, acl_fetch_sc1_conn_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3621 { "sc1_get_gpc0", acl_parse_int, acl_fetch_sc1_get_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3622 { "sc1_http_err_cnt", acl_parse_int, acl_fetch_sc1_http_err_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3623 { "sc1_http_err_rate", acl_parse_int, acl_fetch_sc1_http_err_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3624 { "sc1_http_req_cnt", acl_parse_int, acl_fetch_sc1_http_req_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3625 { "sc1_http_req_rate", acl_parse_int, acl_fetch_sc1_http_req_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3626 { "sc1_inc_gpc0", acl_parse_int, acl_fetch_sc1_inc_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3627 { "sc1_kbytes_in", acl_parse_int, acl_fetch_sc1_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3628 { "sc1_kbytes_out", acl_parse_int, acl_fetch_sc1_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3629 { "sc1_sess_cnt", acl_parse_int, acl_fetch_sc1_sess_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3630 { "sc1_sess_rate", acl_parse_int, acl_fetch_sc1_sess_rate, acl_match_int, ACL_USE_NOTHING, 0 },
Willy Tarreau2406db42012-12-09 12:16:43 +01003631 { "sc1_trackers", acl_parse_int, acl_fetch_sc1_trackers, acl_match_int, ACL_USE_NOTHING, 0 },
Willy Tarreau61612d42012-04-19 18:42:05 +02003632 { "sc2_bytes_in_rate", acl_parse_int, acl_fetch_sc2_bytes_in_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3633 { "sc2_bytes_out_rate", acl_parse_int, acl_fetch_sc2_bytes_out_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3634 { "sc2_clr_gpc0", acl_parse_int, acl_fetch_sc2_clr_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3635 { "sc2_conn_cnt", acl_parse_int, acl_fetch_sc2_conn_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3636 { "sc2_conn_cur", acl_parse_int, acl_fetch_sc2_conn_cur, acl_match_int, ACL_USE_NOTHING, 0 },
3637 { "sc2_conn_rate", acl_parse_int, acl_fetch_sc2_conn_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3638 { "sc2_get_gpc0", acl_parse_int, acl_fetch_sc2_get_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3639 { "sc2_http_err_cnt", acl_parse_int, acl_fetch_sc2_http_err_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3640 { "sc2_http_err_rate", acl_parse_int, acl_fetch_sc2_http_err_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3641 { "sc2_http_req_cnt", acl_parse_int, acl_fetch_sc2_http_req_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3642 { "sc2_http_req_rate", acl_parse_int, acl_fetch_sc2_http_req_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3643 { "sc2_inc_gpc0", acl_parse_int, acl_fetch_sc2_inc_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3644 { "sc2_kbytes_in", acl_parse_int, acl_fetch_sc2_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3645 { "sc2_kbytes_out", acl_parse_int, acl_fetch_sc2_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3646 { "sc2_sess_cnt", acl_parse_int, acl_fetch_sc2_sess_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3647 { "sc2_sess_rate", acl_parse_int, acl_fetch_sc2_sess_rate, acl_match_int, ACL_USE_NOTHING, 0 },
Willy Tarreau2406db42012-12-09 12:16:43 +01003648 { "sc2_trackers", acl_parse_int, acl_fetch_sc2_trackers, acl_match_int, ACL_USE_NOTHING, 0 },
Willy Tarreaufc2c1fd2012-04-19 23:35:54 +02003649 { "src_bytes_in_rate", acl_parse_int, acl_fetch_src_bytes_in_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3650 { "src_bytes_out_rate", acl_parse_int, acl_fetch_src_bytes_out_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3651 { "src_clr_gpc0", acl_parse_int, acl_fetch_src_clr_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3652 { "src_conn_cnt", acl_parse_int, acl_fetch_src_conn_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3653 { "src_conn_cur", acl_parse_int, acl_fetch_src_conn_cur, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3654 { "src_conn_rate", acl_parse_int, acl_fetch_src_conn_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3655 { "src_get_gpc0", acl_parse_int, acl_fetch_src_get_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3656 { "src_http_err_cnt", acl_parse_int, acl_fetch_src_http_err_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3657 { "src_http_err_rate", acl_parse_int, acl_fetch_src_http_err_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3658 { "src_http_req_cnt", acl_parse_int, acl_fetch_src_http_req_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3659 { "src_http_req_rate", acl_parse_int, acl_fetch_src_http_req_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3660 { "src_inc_gpc0", acl_parse_int, acl_fetch_src_inc_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3661 { "src_kbytes_in", acl_parse_int, acl_fetch_src_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3662 { "src_kbytes_out", acl_parse_int, acl_fetch_src_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3663 { "src_sess_cnt", acl_parse_int, acl_fetch_src_sess_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3664 { "src_sess_rate", acl_parse_int, acl_fetch_src_sess_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3665 { "src_updt_conn_cnt", acl_parse_int, acl_fetch_src_updt_conn_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3666 { "table_avl", acl_parse_int, acl_fetch_table_avl, acl_match_int, ACL_USE_NOTHING, ARG1(1,TAB) },
3667 { "table_cnt", acl_parse_int, acl_fetch_table_cnt, acl_match_int, ACL_USE_NOTHING, ARG1(1,TAB) },
Willy Tarreau8b22a712010-06-18 17:46:06 +02003668 { NULL, NULL, NULL, NULL },
3669}};
3670
Willy Tarreau8b22a712010-06-18 17:46:06 +02003671__attribute__((constructor))
3672static void __session_init(void)
3673{
3674 acl_register_keywords(&acl_kws);
3675}
3676
Willy Tarreaubaaee002006-06-26 02:48:02 +02003677/*
3678 * Local variables:
3679 * c-indent-level: 8
3680 * c-basic-offset: 8
3681 * End:
3682 */