blob: 3fcce844a043da96b013bfa98c0c163dddcdce19 [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 Tarreau7c669d72008-06-20 15:04:11 +020018#include <common/debug.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020019#include <common/memory.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020020
Willy Tarreaubaaee002006-06-26 02:48:02 +020021#include <types/capture.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010022#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020023
Willy Tarreau1d0dfb12009-07-07 15:10:31 +020024#include <proto/acl.h>
Willy Tarreau61612d42012-04-19 18:42:05 +020025#include <proto/arg.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010026#include <proto/backend.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020027#include <proto/channel.h>
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +010028#include <proto/checks.h>
Willy Tarreaud2274c62012-07-06 14:29:45 +020029#include <proto/connection.h>
Willy Tarreau5ca791d2009-08-16 19:06:42 +020030#include <proto/dumpstats.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020031#include <proto/fd.h>
Willy Tarreau91c43d72010-06-20 11:19:22 +020032#include <proto/freq_ctr.h>
Willy Tarreau3041b9f2010-10-15 23:25:20 +020033#include <proto/frontend.h>
Willy Tarreau8d5d7f22007-01-21 19:16:41 +010034#include <proto/hdr_idx.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020035#include <proto/listener.h>
Willy Tarreau332f8bf2007-05-13 21:36:56 +020036#include <proto/log.h>
Willy Tarreaucbaaec42012-09-06 11:32:07 +020037#include <proto/raw_sock.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020038#include <proto/session.h>
Willy Tarreau3eba98a2009-01-25 13:56:13 +010039#include <proto/pipe.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010040#include <proto/proto_http.h>
41#include <proto/proto_tcp.h>
Willy Tarreau1d0dfb12009-07-07 15:10:31 +020042#include <proto/proxy.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043#include <proto/queue.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +010044#include <proto/server.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020045#include <proto/sample.h>
Emeric Brun1d33b292010-01-04 15:47:17 +010046#include <proto/stick_table.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010047#include <proto/stream_interface.h>
Willy Tarreau55a8d0e2008-11-30 18:47:21 +010048#include <proto/task.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020049
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020050struct pool_head *pool2_session;
Willy Tarreauf54f8bd2008-11-23 19:53:55 +010051struct list sessions;
Willy Tarreaubaaee002006-06-26 02:48:02 +020052
Willy Tarreau071e1372012-10-03 01:39:48 +020053static int conn_session_complete(struct connection *conn);
Willy Tarreau9683e9a2012-10-03 21:17:23 +020054static int conn_session_update(struct connection *conn);
Willy Tarreau2542b532012-08-31 16:01:23 +020055static struct task *expire_mini_session(struct task *t);
56int session_complete(struct session *s);
57
Willy Tarreau5e75e272012-10-02 21:21:20 +020058/* data layer callbacks for an embryonic session */
59struct data_cb sess_conn_cb = {
60 .recv = NULL,
61 .send = NULL,
Willy Tarreau9683e9a2012-10-03 21:17:23 +020062 .wake = conn_session_update,
Willy Tarreau071e1372012-10-03 01:39:48 +020063 .init = conn_session_complete,
Willy Tarreau5e75e272012-10-02 21:21:20 +020064};
65
Willy Tarreau2542b532012-08-31 16:01:23 +020066/* This function is called from the protocol layer accept() in order to
67 * instanciate a new embryonic session on behalf of a given listener and
68 * frontend. It returns a positive value upon success, 0 if the connection
69 * can be ignored, or a negative value upon critical failure. The accepted
70 * file descriptor is closed if we return <= 0.
Willy Tarreau81f9aa32010-06-01 17:45:26 +020071 */
72int session_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
73{
74 struct proxy *p = l->frontend;
75 struct session *s;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020076 struct task *t;
Willy Tarreauabe8ea52010-11-11 10:56:04 +010077 int ret;
78
79
80 ret = -1; /* assume unrecoverable error by default */
Willy Tarreau81f9aa32010-06-01 17:45:26 +020081
Willy Tarreaufffe1322010-11-11 09:48:16 +010082 if (unlikely((s = pool_alloc2(pool2_session)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +020083 goto out_close;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020084
Willy Tarreau2542b532012-08-31 16:01:23 +020085 /* minimum session initialization required for an embryonic session is
86 * fairly low. We need very little to execute L4 ACLs, then we need a
87 * task to make the client-side connection live on its own.
88 * - flags
89 * - stick-entry tracking
90 */
Willy Tarreau81f9aa32010-06-01 17:45:26 +020091 s->flags = 0;
92 s->logs.logwait = p->to_log;
Willy Tarreau56123282010-08-06 19:06:56 +020093 s->stkctr1_entry = NULL;
94 s->stkctr2_entry = NULL;
95 s->stkctr1_table = NULL;
96 s->stkctr2_table = NULL;
Willy Tarreau81f9aa32010-06-01 17:45:26 +020097
Willy Tarreau2542b532012-08-31 16:01:23 +020098 s->listener = l;
99 s->fe = p;
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100100
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200101 /* OK, we're keeping the session, so let's properly initialize the session */
Willy Tarreau96596ae2012-06-08 22:57:36 +0200102 s->si[0].conn.t.sock.fd = cfd;
103 s->si[0].conn.ctrl = l->proto;
Willy Tarreau2542b532012-08-31 16:01:23 +0200104 s->si[0].conn.flags = CO_FL_NONE;
Willy Tarreau986a9d22012-08-30 21:11:38 +0200105 s->si[0].conn.addr.from = *addr;
Willy Tarreau2542b532012-08-31 16:01:23 +0200106 set_target_client(&s->si[0].conn.target, l);
107
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200108 s->logs.accept_date = date; /* user-visible date for logging */
109 s->logs.tv_accept = now; /* corrected date for internal use */
110 s->uniq_id = totalconn;
Willy Tarreau2542b532012-08-31 16:01:23 +0200111 p->feconn++;
112 /* This session was accepted, count it now */
113 if (p->feconn > p->fe_counters.conn_max)
114 p->fe_counters.conn_max = p->feconn;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200115
Willy Tarreau2542b532012-08-31 16:01:23 +0200116 proxy_inc_fe_conn_ctr(l, p);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200117
118 /* now evaluate the tcp-request layer4 rules. Since we expect to be able
119 * to abort right here as soon as possible, we check the rules before
120 * even initializing the stream interfaces.
121 */
122 if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(s)) {
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200123 /* let's do a no-linger now to close with a single RST. */
124 setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100125 ret = 0; /* successful termination */
Willy Tarreau2542b532012-08-31 16:01:23 +0200126 goto out_free_session;
127 }
128
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200129#ifndef USE_ACCEPT4
130 /* Adjust some socket options if the connection was accepted by a plain
131 * accept() syscall.
132 */
Willy Tarreau82569f92012-09-27 23:48:56 +0200133 if (unlikely(fcntl(cfd, F_SETFL, O_NONBLOCK) == -1))
134 goto out_free_session;
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200135#endif
Willy Tarreau82569f92012-09-27 23:48:56 +0200136
137 /* monitor-net and health mode are processed immediately after TCP
138 * connection rules. This way it's possible to block them, but they
139 * never use the lower data layers, they send directly over the socket,
140 * as they were designed for. We first flush the socket receive buffer
141 * in order to avoid emission of an RST by the system. We ignore any
142 * error.
143 */
144 if (unlikely((p->mode == PR_MODE_HEALTH) ||
145 ((l->options & LI_O_CHK_MONNET) &&
146 addr->ss_family == AF_INET &&
147 (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
148 /* we have 4 possibilities here :
149 * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
150 * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
151 * - HEALTH mode without HTTP check => just send "OK"
152 * - TCP mode from monitoring address => just close
153 */
154 recv(cfd, trash, trashlen, 0&MSG_DONTWAIT);
155 if (p->mode == PR_MODE_HTTP ||
156 (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
157 send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
158 else if (p->mode == PR_MODE_HEALTH)
159 send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
160 ret = 0;
161 goto out_free_session;
162 }
163
164
Willy Tarreau22cda212012-08-31 17:43:29 +0200165 /* wait for a PROXY protocol header */
166 if (l->options & LI_O_ACC_PROXY) {
167 s->si[0].conn.flags |= CO_FL_ACCEPT_PROXY;
168 conn_sock_want_recv(&s->si[0].conn);
169 }
170
Willy Tarreau2542b532012-08-31 16:01:23 +0200171 if (unlikely((t = task_new()) == NULL))
172 goto out_free_session;
173
174 t->context = s;
175 t->nice = l->nice;
176 s->task = t;
177
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200178 /* Add the various callbacks. Right now the transport layer is present
179 * but not initialized. Also note we need to be careful as the stream
180 * int is not initialized yet.
Willy Tarreau2542b532012-08-31 16:01:23 +0200181 */
Willy Tarreau5e75e272012-10-02 21:21:20 +0200182 conn_prepare(&s->si[0].conn, &sess_conn_cb, l->proto, l->xprt, s);
Willy Tarreau2542b532012-08-31 16:01:23 +0200183
184 /* finish initialization of the accepted file descriptor */
185 fd_insert(cfd);
186 fdtab[cfd].owner = &s->si[0].conn;
Willy Tarreau2542b532012-08-31 16:01:23 +0200187 fdtab[cfd].iocb = conn_fd_handler;
188 conn_data_want_recv(&s->si[0].conn);
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200189 if (conn_xprt_init(&s->si[0].conn) < 0)
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100190 goto out_free_task;
Willy Tarreau2542b532012-08-31 16:01:23 +0200191
192 /* OK, now either we have a pending handshake to execute with and
193 * then we must return to the I/O layer, or we can proceed with the
194 * end of the session initialization. In case of handshake, we also
195 * set the I/O timeout to the frontend's client timeout.
196 */
197
198 if (s->si[0].conn.flags & CO_FL_HANDSHAKE) {
199 t->process = expire_mini_session;
200 t->expire = tick_add_ifset(now_ms, p->timeout.client);
201 task_queue(t);
Willy Tarreau071e1372012-10-03 01:39:48 +0200202 s->si[0].conn.flags |= CO_FL_INIT_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200203 return 1;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200204 }
205
Willy Tarreau2542b532012-08-31 16:01:23 +0200206 /* OK let's complete session initialization */
207 ret = session_complete(s);
208 if (ret > 0)
209 return ret;
210
211 /* Error unrolling */
212 out_free_task:
213 task_free(t);
214 out_free_session:
215 p->feconn--;
216 if (s->stkctr1_entry || s->stkctr2_entry)
217 session_store_counters(s);
218 pool_free2(pool2_session, s);
219 out_close:
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200220 if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
Willy Tarreau2542b532012-08-31 16:01:23 +0200221 /* critical error, no more memory, try to emit a 500 response */
Willy Tarreau783f2582012-09-04 12:19:04 +0200222 struct chunk *err_msg = http_error_message(s, HTTP_ERR_500);
Willy Tarreau2542b532012-08-31 16:01:23 +0200223 send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
224 }
225
226 if (fdtab[cfd].owner)
227 fd_delete(cfd);
228 else
229 close(cfd);
230 return ret;
231}
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100232
Willy Tarreau2542b532012-08-31 16:01:23 +0200233/* This function kills an existing embryonic session. It stops the connection's
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200234 * transport layer, releases assigned resources, resumes the listener if it was
Willy Tarreau2542b532012-08-31 16:01:23 +0200235 * disabled and finally kills the file descriptor.
236 */
237static void kill_mini_session(struct session *s)
238{
239 /* kill the connection now */
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200240 conn_xprt_close(&s->si[0].conn);
Willy Tarreau2542b532012-08-31 16:01:23 +0200241
242 s->fe->feconn--;
243 if (s->stkctr1_entry || s->stkctr2_entry)
244 session_store_counters(s);
245
246 if (!(s->listener->options & LI_O_UNLIMITED))
247 actconn--;
248 jobs--;
249 s->listener->nbconn--;
250 if (s->listener->state == LI_FULL)
251 resume_listener(s->listener);
252
253 /* Dequeues all of the listeners waiting for a resource */
254 if (!LIST_ISEMPTY(&global_listener_queue))
255 dequeue_all_listeners(&global_listener_queue);
256
257 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
258 (!s->fe->fe_sps_lim || freq_ctr_remain(&s->fe->fe_sess_per_sec, s->fe->fe_sps_lim, 0) > 0))
259 dequeue_all_listeners(&s->fe->listener_queue);
260
261 task_delete(s->task);
262 task_free(s->task);
263
264 if (fdtab[s->si[0].conn.t.sock.fd].owner)
265 fd_delete(s->si[0].conn.t.sock.fd);
266 else
267 close(s->si[0].conn.t.sock.fd);
268
269 pool_free2(pool2_session, s);
270}
271
Willy Tarreau22cda212012-08-31 17:43:29 +0200272/* Finish initializing a session from a connection, or kills it if the
273 * connection shows and error. Returns <0 if the connection was killed.
Willy Tarreau2542b532012-08-31 16:01:23 +0200274 */
Willy Tarreau071e1372012-10-03 01:39:48 +0200275static int conn_session_complete(struct connection *conn)
Willy Tarreau2542b532012-08-31 16:01:23 +0200276{
Willy Tarreau5e75e272012-10-02 21:21:20 +0200277 struct session *s = conn->owner;
Willy Tarreau2542b532012-08-31 16:01:23 +0200278
Willy Tarreau22cda212012-08-31 17:43:29 +0200279 if (!(conn->flags & CO_FL_ERROR) && (session_complete(s) > 0)) {
Willy Tarreau071e1372012-10-03 01:39:48 +0200280 conn->flags &= ~CO_FL_INIT_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200281 return 0;
282 }
283
284 /* kill the connection now */
285 kill_mini_session(s);
286 return -1;
287}
288
Willy Tarreau9683e9a2012-10-03 21:17:23 +0200289/* Update an embryonic session status. The connection is killed in case of
290 * error, and <0 will be returned. Otherwise it does nothing.
291 */
292static int conn_session_update(struct connection *conn)
293{
294 if (conn->flags & CO_FL_ERROR) {
295 kill_mini_session(conn->owner);
296 return -1;
297 }
298 return 0;
299}
300
Willy Tarreau2542b532012-08-31 16:01:23 +0200301/* Manages embryonic sessions timeout. It is only called when the timeout
302 * strikes and performs the required cleanup.
303 */
304static struct task *expire_mini_session(struct task *t)
305{
306 struct session *s = t->context;
307
308 if (!(t->state & TASK_WOKEN_TIMER))
309 return t;
310
311 kill_mini_session(s);
312 return NULL;
313}
314
315/* This function is called from the I/O handler which detects the end of
316 * handshake, in order to complete initialization of a valid session. It must
317 * be called with an embryonic session. It returns a positive value upon
318 * success, 0 if the connection can be ignored, or a negative value upon
319 * critical failure. The accepted file descriptor is closed if we return <= 0.
320 */
321int session_complete(struct session *s)
322{
323 struct listener *l = s->listener;
324 struct proxy *p = s->fe;
325 struct http_txn *txn;
326 struct task *t = s->task;
327 int ret;
328
329 ret = -1; /* assume unrecoverable error by default */
330
331 /* OK, we're keeping the session, so let's properly initialize the session */
332 LIST_ADDQ(&sessions, &s->list);
333 LIST_INIT(&s->back_refs);
Willy Tarreau5e75e272012-10-02 21:21:20 +0200334 si_takeover_conn(&s->si[0], l->proto, l->xprt);
Willy Tarreau2542b532012-08-31 16:01:23 +0200335 s->flags |= SN_INITIALIZED;
336
337 s->unique_id = NULL;
338 s->term_trace = 0;
339
340 t->process = l->handler;
341 t->context = s;
342 t->expire = TICK_ETERNITY;
343
344 /* Note: initially, the session's backend points to the frontend.
345 * This changes later when switching rules are executed or
346 * when the default backend is assigned.
347 */
348 s->be = s->fe;
349 s->req = s->rep = NULL; /* will be allocated later */
350
351 /* Let's count a session now */
Willy Tarreaub36b4242010-06-04 20:59:39 +0200352 proxy_inc_fe_sess_ctr(l, p);
Willy Tarreau56123282010-08-06 19:06:56 +0200353 if (s->stkctr1_entry) {
Willy Tarreau91c43d72010-06-20 11:19:22 +0200354 void *ptr;
355
Willy Tarreau56123282010-08-06 19:06:56 +0200356 ptr = stktable_data_ptr(s->stkctr1_table, s->stkctr1_entry, STKTABLE_DT_SESS_CNT);
Willy Tarreauf4d17d92010-06-18 22:10:12 +0200357 if (ptr)
358 stktable_data_cast(ptr, sess_cnt)++;
Willy Tarreau91c43d72010-06-20 11:19:22 +0200359
Willy Tarreau56123282010-08-06 19:06:56 +0200360 ptr = stktable_data_ptr(s->stkctr1_table, s->stkctr1_entry, STKTABLE_DT_SESS_RATE);
Willy Tarreau91c43d72010-06-20 11:19:22 +0200361 if (ptr)
362 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200363 s->stkctr1_table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
Willy Tarreauf4d17d92010-06-18 22:10:12 +0200364 }
Willy Tarreaub36b4242010-06-04 20:59:39 +0200365
Willy Tarreau56123282010-08-06 19:06:56 +0200366 if (s->stkctr2_entry) {
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200367 void *ptr;
368
Willy Tarreau56123282010-08-06 19:06:56 +0200369 ptr = stktable_data_ptr(s->stkctr2_table, s->stkctr2_entry, STKTABLE_DT_SESS_CNT);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200370 if (ptr)
371 stktable_data_cast(ptr, sess_cnt)++;
372
Willy Tarreau56123282010-08-06 19:06:56 +0200373 ptr = stktable_data_ptr(s->stkctr2_table, s->stkctr2_entry, STKTABLE_DT_SESS_RATE);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200374 if (ptr)
375 update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200376 s->stkctr2_table->data_arg[STKTABLE_DT_SESS_RATE].u, 1);
Willy Tarreau9e9879a2010-08-06 15:25:22 +0200377 }
378
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200379 /* this part should be common with other protocols */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200380 s->si[0].owner = t;
381 s->si[0].state = s->si[0].prev_state = SI_ST_EST;
382 s->si[0].err_type = SI_ET_NONE;
383 s->si[0].err_loc = NULL;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200384 s->si[0].release = NULL;
Willy Tarreau63e7fe32012-05-08 15:20:43 +0200385 s->si[0].send_proxy_ofs = 0;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200386 s->si[0].exp = TICK_ETERNITY;
387 s->si[0].flags = SI_FL_NONE;
388
389 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
390 s->si[0].flags |= SI_FL_INDEP_STR;
391
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200392 /* pre-initialize the other side's stream interface to an INIT state. The
393 * callbacks will be initialized before attempting to connect.
394 */
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200395 s->si[1].conn.t.sock.fd = -1; /* just to help with debugging */
Willy Tarreau505e34a2012-07-06 10:17:53 +0200396 s->si[1].conn.flags = CO_FL_NONE;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200397 s->si[1].owner = t;
398 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
399 s->si[1].err_type = SI_ET_NONE;
Willy Tarreau0b3a4112011-03-27 19:16:56 +0200400 s->si[1].conn_retries = 0; /* used for logging too */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200401 s->si[1].err_loc = NULL;
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200402 s->si[1].release = NULL;
Willy Tarreau63e7fe32012-05-08 15:20:43 +0200403 s->si[1].send_proxy_ofs = 0;
Willy Tarreau3cefd522012-08-30 15:49:18 +0200404 clear_target(&s->si[1].conn.target);
Willy Tarreauc5788912012-08-24 18:12:41 +0200405 si_prepare_embedded(&s->si[1]);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200406 s->si[1].exp = TICK_ETERNITY;
407 s->si[1].flags = SI_FL_NONE;
408
409 if (likely(s->fe->options2 & PR_O2_INDEPSTR))
410 s->si[1].flags |= SI_FL_INDEP_STR;
411
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200412 session_init_srv_conn(s);
Willy Tarreau9e000c62011-03-10 14:03:36 +0100413 clear_target(&s->target);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200414 s->pend_pos = NULL;
415
416 /* init store persistence */
417 s->store_count = 0;
418
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200419 if (unlikely((s->req = pool_alloc2(pool2_channel)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200420 goto out_free_task; /* no memory */
421
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200422 if (unlikely((s->rep = pool_alloc2(pool2_channel)) == NULL))
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200423 goto out_free_req; /* no memory */
424
425 /* initialize the request buffer */
Willy Tarreau572bf902012-07-02 17:01:20 +0200426 s->req->buf.size = global.tune.bufsize;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200427 channel_init(s->req);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200428 s->req->prod = &s->si[0];
429 s->req->cons = &s->si[1];
430 s->si[0].ib = s->si[1].ob = s->req;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200431 s->req->flags |= CF_READ_ATTACHED; /* the producer is already connected */
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200432
433 /* activate default analysers enabled for this listener */
434 s->req->analysers = l->analysers;
435
436 s->req->wto = TICK_ETERNITY;
437 s->req->rto = TICK_ETERNITY;
438 s->req->rex = TICK_ETERNITY;
439 s->req->wex = TICK_ETERNITY;
440 s->req->analyse_exp = TICK_ETERNITY;
441
442 /* initialize response buffer */
Willy Tarreau572bf902012-07-02 17:01:20 +0200443 s->rep->buf.size = global.tune.bufsize;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200444 channel_init(s->rep);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200445 s->rep->prod = &s->si[1];
446 s->rep->cons = &s->si[0];
447 s->si[0].ob = s->si[1].ib = s->rep;
448 s->rep->analysers = 0;
449
Willy Tarreau96e31212011-05-30 18:10:30 +0200450 if (s->fe->options2 & PR_O2_NODELAY) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200451 s->req->flags |= CF_NEVER_WAIT;
452 s->rep->flags |= CF_NEVER_WAIT;
Willy Tarreau96e31212011-05-30 18:10:30 +0200453 }
454
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200455 s->rep->rto = TICK_ETERNITY;
456 s->rep->wto = TICK_ETERNITY;
457 s->rep->rex = TICK_ETERNITY;
458 s->rep->wex = TICK_ETERNITY;
459 s->rep->analyse_exp = TICK_ETERNITY;
460
Willy Tarreau62f791e2012-03-09 11:32:30 +0100461 txn = &s->txn;
462 /* Those variables will be checked and freed if non-NULL in
463 * session.c:session_free(). It is important that they are
464 * properly initialized.
465 */
466 txn->sessid = NULL;
467 txn->srv_cookie = NULL;
468 txn->cli_cookie = NULL;
469 txn->uri = NULL;
470 txn->req.cap = NULL;
471 txn->rsp.cap = NULL;
472 txn->hdr_idx.v = NULL;
473 txn->hdr_idx.size = txn->hdr_idx.used = 0;
474 txn->req.flags = 0;
475 txn->rsp.flags = 0;
476 /* the HTTP messages need to know what buffer they're associated with */
477 txn->req.buf = s->req;
478 txn->rsp.buf = s->rep;
479
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200480 /* finish initialization of the accepted file descriptor */
Willy Tarreauf9dabec2012-08-17 17:33:53 +0200481 conn_data_want_recv(&s->si[0].conn);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200482
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100483 if (p->accept && (ret = p->accept(s)) <= 0) {
484 /* Either we had an unrecoverable error (<0) or work is
485 * finished (=0, eg: monitoring), in both situations,
486 * we can release everything and close.
487 */
488 goto out_free_rep;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200489 }
490
Willy Tarreau2542b532012-08-31 16:01:23 +0200491 /* we want the connection handler to notify the stream interface about updates. */
Willy Tarreau4aa36832012-10-02 20:07:22 +0200492 s->si[0].conn.flags |= CO_FL_WAKE_DATA;
Willy Tarreau2542b532012-08-31 16:01:23 +0200493
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200494 /* it is important not to call the wakeup function directly but to
495 * pass through task_wakeup(), because this one knows how to apply
496 * priorities to tasks.
497 */
498 task_wakeup(t, TASK_WOKEN_INIT);
499 return 1;
500
501 /* Error unrolling */
502 out_free_rep:
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200503 pool_free2(pool2_channel, s->rep);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200504 out_free_req:
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200505 pool_free2(pool2_channel, s->req);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200506 out_free_task:
Willy Tarreauabe8ea52010-11-11 10:56:04 +0100507 return ret;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200508}
509
Willy Tarreaubaaee002006-06-26 02:48:02 +0200510/*
511 * frees the context associated to a session. It must have been removed first.
512 */
Simon Hormandec5be42011-06-08 09:19:07 +0900513static void session_free(struct session *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200514{
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100515 struct http_txn *txn = &s->txn;
Willy Tarreau632f5a72007-07-11 10:42:35 +0200516 struct proxy *fe = s->fe;
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100517 struct bref *bref, *back;
Willy Tarreaua4cda672010-06-06 18:28:49 +0200518 int i;
Willy Tarreau0f7562b2007-01-07 15:46:13 +0100519
Willy Tarreaubaaee002006-06-26 02:48:02 +0200520 if (s->pend_pos)
521 pendconn_free(s->pend_pos);
Willy Tarreau922a8062008-12-04 09:33:58 +0100522
Willy Tarreau827aee92011-03-10 16:55:02 +0100523 if (target_srv(&s->target)) { /* there may be requests left pending in queue */
Willy Tarreau1e62de62008-11-11 20:20:02 +0100524 if (s->flags & SN_CURR_SESS) {
525 s->flags &= ~SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +0100526 target_srv(&s->target)->cur_sess--;
Willy Tarreau1e62de62008-11-11 20:20:02 +0100527 }
Willy Tarreau827aee92011-03-10 16:55:02 +0100528 if (may_dequeue_tasks(target_srv(&s->target), s->be))
529 process_srv_queue(target_srv(&s->target));
Willy Tarreau1e62de62008-11-11 20:20:02 +0100530 }
Willy Tarreau922a8062008-12-04 09:33:58 +0100531
Willy Tarreau7c669d72008-06-20 15:04:11 +0200532 if (unlikely(s->srv_conn)) {
533 /* the session still has a reserved slot on a server, but
534 * it should normally be only the same as the one above,
535 * so this should not happen in fact.
536 */
537 sess_change_server(s, NULL);
538 }
539
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100540 if (s->req->pipe)
541 put_pipe(s->req->pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100542
Willy Tarreau3eba98a2009-01-25 13:56:13 +0100543 if (s->rep->pipe)
544 put_pipe(s->rep->pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100545
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200546 pool_free2(pool2_channel, s->req);
547 pool_free2(pool2_channel, s->rep);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200548
Willy Tarreau46023632010-01-07 22:51:47 +0100549 http_end_txn(s);
550
Willy Tarreaua4cda672010-06-06 18:28:49 +0200551 for (i = 0; i < s->store_count; i++) {
552 if (!s->store[i].ts)
553 continue;
554 stksess_free(s->store[i].table, s->store[i].ts);
555 s->store[i].ts = NULL;
556 }
557
Willy Tarreau34eb6712011-10-24 18:15:04 +0200558 pool_free2(pool2_hdr_idx, txn->hdr_idx.v);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200559 if (fe) {
Willy Tarreau46023632010-01-07 22:51:47 +0100560 pool_free2(fe->rsp_cap_pool, txn->rsp.cap);
561 pool_free2(fe->req_cap_pool, txn->req.cap);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200562 }
Willy Tarreau0937bc42009-12-22 15:03:09 +0100563
Willy Tarreau56123282010-08-06 19:06:56 +0200564 if (s->stkctr1_entry || s->stkctr2_entry)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200565 session_store_counters(s);
566
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100567 list_for_each_entry_safe(bref, back, &s->back_refs, users) {
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100568 /* we have to unlink all watchers. We must not relink them if
569 * this session was the last one in the list.
570 */
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100571 LIST_DEL(&bref->users);
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100572 LIST_INIT(&bref->users);
573 if (s->list.n != &sessions)
574 LIST_ADDQ(&LIST_ELEM(s->list.n, struct session *, list)->back_refs, &bref->users);
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100575 bref->ref = s->list.n;
576 }
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100577 LIST_DEL(&s->list);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200578 pool_free2(pool2_session, s);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200579
580 /* We may want to free the maximum amount of pools if the proxy is stopping */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200581 if (fe && unlikely(fe->state == PR_STSTOPPED)) {
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200582 pool_flush2(pool2_channel);
Willy Tarreau34eb6712011-10-24 18:15:04 +0200583 pool_flush2(pool2_hdr_idx);
Willy Tarreau48d63db2008-08-03 17:41:33 +0200584 pool_flush2(pool2_requri);
585 pool_flush2(pool2_capture);
586 pool_flush2(pool2_session);
587 pool_flush2(fe->req_cap_pool);
588 pool_flush2(fe->rsp_cap_pool);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200589 }
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200590}
591
592
593/* perform minimal intializations, report 0 in case of error, 1 if OK. */
594int init_session()
595{
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100596 LIST_INIT(&sessions);
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200597 pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
598 return pool2_session != NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200599}
600
Willy Tarreau30e71012007-11-26 20:15:35 +0100601void session_process_counters(struct session *s)
602{
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100603 unsigned long long bytes;
604
Willy Tarreau30e71012007-11-26 20:15:35 +0100605 if (s->req) {
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100606 bytes = s->req->total - s->logs.bytes_in;
Willy Tarreau30e71012007-11-26 20:15:35 +0100607 s->logs.bytes_in = s->req->total;
608 if (bytes) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100609 s->fe->fe_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100610
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100611 s->be->be_counters.bytes_in += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100612
Willy Tarreau827aee92011-03-10 16:55:02 +0100613 if (target_srv(&s->target))
614 target_srv(&s->target)->counters.bytes_in += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200615
616 if (s->listener->counters)
617 s->listener->counters->bytes_in += bytes;
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200618
Willy Tarreau56123282010-08-06 19:06:56 +0200619 if (s->stkctr2_entry) {
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200620 void *ptr;
621
Willy Tarreau56123282010-08-06 19:06:56 +0200622 ptr = stktable_data_ptr(s->stkctr2_table,
623 s->stkctr2_entry,
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200624 STKTABLE_DT_BYTES_IN_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200625 if (ptr)
626 stktable_data_cast(ptr, bytes_in_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200627
Willy Tarreau56123282010-08-06 19:06:56 +0200628 ptr = stktable_data_ptr(s->stkctr2_table,
629 s->stkctr2_entry,
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200630 STKTABLE_DT_BYTES_IN_RATE);
631 if (ptr)
632 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200633 s->stkctr2_table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u, bytes);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200634 }
635
Willy Tarreau56123282010-08-06 19:06:56 +0200636 if (s->stkctr1_entry) {
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200637 void *ptr;
638
Willy Tarreau56123282010-08-06 19:06:56 +0200639 ptr = stktable_data_ptr(s->stkctr1_table,
640 s->stkctr1_entry,
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200641 STKTABLE_DT_BYTES_IN_CNT);
642 if (ptr)
643 stktable_data_cast(ptr, bytes_in_cnt) += bytes;
644
Willy Tarreau56123282010-08-06 19:06:56 +0200645 ptr = stktable_data_ptr(s->stkctr1_table,
646 s->stkctr1_entry,
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200647 STKTABLE_DT_BYTES_IN_RATE);
648 if (ptr)
649 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200650 s->stkctr1_table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u, bytes);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200651 }
Willy Tarreau30e71012007-11-26 20:15:35 +0100652 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100653 }
654
Willy Tarreau30e71012007-11-26 20:15:35 +0100655 if (s->rep) {
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100656 bytes = s->rep->total - s->logs.bytes_out;
Willy Tarreau30e71012007-11-26 20:15:35 +0100657 s->logs.bytes_out = s->rep->total;
658 if (bytes) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100659 s->fe->fe_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100660
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100661 s->be->be_counters.bytes_out += bytes;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100662
Willy Tarreau827aee92011-03-10 16:55:02 +0100663 if (target_srv(&s->target))
664 target_srv(&s->target)->counters.bytes_out += bytes;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200665
666 if (s->listener->counters)
667 s->listener->counters->bytes_out += bytes;
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200668
Willy Tarreau56123282010-08-06 19:06:56 +0200669 if (s->stkctr2_entry) {
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200670 void *ptr;
671
Willy Tarreau56123282010-08-06 19:06:56 +0200672 ptr = stktable_data_ptr(s->stkctr2_table,
673 s->stkctr2_entry,
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200674 STKTABLE_DT_BYTES_OUT_CNT);
675 if (ptr)
676 stktable_data_cast(ptr, bytes_out_cnt) += bytes;
677
Willy Tarreau56123282010-08-06 19:06:56 +0200678 ptr = stktable_data_ptr(s->stkctr2_table,
679 s->stkctr2_entry,
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200680 STKTABLE_DT_BYTES_OUT_RATE);
681 if (ptr)
682 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200683 s->stkctr2_table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u, bytes);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200684 }
685
Willy Tarreau56123282010-08-06 19:06:56 +0200686 if (s->stkctr1_entry) {
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200687 void *ptr;
688
Willy Tarreau56123282010-08-06 19:06:56 +0200689 ptr = stktable_data_ptr(s->stkctr1_table,
690 s->stkctr1_entry,
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200691 STKTABLE_DT_BYTES_OUT_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200692 if (ptr)
693 stktable_data_cast(ptr, bytes_out_cnt) += bytes;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200694
Willy Tarreau56123282010-08-06 19:06:56 +0200695 ptr = stktable_data_ptr(s->stkctr1_table,
696 s->stkctr1_entry,
Willy Tarreau6c59e0a2010-06-20 11:56:30 +0200697 STKTABLE_DT_BYTES_OUT_RATE);
698 if (ptr)
699 update_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreau56123282010-08-06 19:06:56 +0200700 s->stkctr1_table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u, bytes);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200701 }
Willy Tarreau30e71012007-11-26 20:15:35 +0100702 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100703 }
704}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200705
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100706/* This function is called with (si->state == SI_ST_CON) meaning that a
707 * connection was attempted and that the file descriptor is already allocated.
708 * We must check for establishment, error and abort. Possible output states
709 * are SI_ST_EST (established), SI_ST_CER (error), SI_ST_DIS (abort), and
710 * SI_ST_CON (no change). The function returns 0 if it switches to SI_ST_CER,
711 * otherwise 1.
712 */
Simon Hormandec5be42011-06-08 09:19:07 +0900713static int sess_update_st_con_tcp(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100714{
Willy Tarreau7421efb2012-07-02 15:11:27 +0200715 struct channel *req = si->ob;
716 struct channel *rep = si->ib;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100717
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100718 /* If we got an error, or if nothing happened and the connection timed
719 * out, we must give up. The CER state handler will take care of retry
720 * attempts and error reports.
721 */
722 if (unlikely(si->flags & (SI_FL_EXP|SI_FL_ERR))) {
Willy Tarreau127334e2009-03-28 10:47:26 +0100723 si->exp = TICK_ETERNITY;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100724 si->state = SI_ST_CER;
Willy Tarreaufb7508a2012-05-21 16:47:54 +0200725 fd_delete(si_fd(si));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100726
Willy Tarreauf7bc57c2012-10-03 00:19:48 +0200727 conn_xprt_close(&si->conn);
Willy Tarreau0bd05ea2010-07-02 11:18:03 +0200728 if (si->release)
729 si->release(si);
730
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100731 if (si->err_type)
732 return 0;
733
Willy Tarreau827aee92011-03-10 16:55:02 +0100734 si->err_loc = target_srv(&s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100735 if (si->flags & SI_FL_ERR)
736 si->err_type = SI_ET_CONN_ERR;
737 else
738 si->err_type = SI_ET_CONN_TO;
739 return 0;
740 }
741
742 /* OK, maybe we want to abort */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200743 if (unlikely((rep->flags & CF_SHUTW) ||
744 ((req->flags & CF_SHUTW_NOW) && /* FIXME: this should not prevent a connection from establishing */
745 ((!(req->flags & CF_WRITE_ACTIVITY) && channel_is_empty(req)) ||
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100746 s->be->options & PR_O_ABRT_CLOSE)))) {
747 /* give up */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200748 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100749 si->err_type |= SI_ET_CONN_ABRT;
Willy Tarreau827aee92011-03-10 16:55:02 +0100750 si->err_loc = target_srv(&s->target);
Willy Tarreau84455332009-03-15 22:34:05 +0100751 if (s->srv_error)
752 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100753 return 1;
754 }
755
756 /* we need to wait a bit more if there was no activity either */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200757 if (!(req->flags & CF_WRITE_ACTIVITY))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100758 return 1;
759
760 /* OK, this means that a connection succeeded. The caller will be
761 * responsible for handling the transition from CON to EST.
762 */
763 s->logs.t_connect = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau127334e2009-03-28 10:47:26 +0100764 si->exp = TICK_ETERNITY;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100765 si->state = SI_ST_EST;
766 si->err_type = SI_ET_NONE;
767 si->err_loc = NULL;
768 return 1;
769}
770
771/* This function is called with (si->state == SI_ST_CER) meaning that a
772 * previous connection attempt has failed and that the file descriptor
773 * has already been released. Possible causes include asynchronous error
774 * notification and time out. Possible output states are SI_ST_CLO when
775 * retries are exhausted, SI_ST_TAR when a delay is wanted before a new
776 * connection attempt, SI_ST_ASS when it's wise to retry on the same server,
777 * and SI_ST_REQ when an immediate redispatch is wanted. The buffers are
778 * marked as in error state. It returns 0.
779 */
Simon Hormandec5be42011-06-08 09:19:07 +0900780static int sess_update_st_cer(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100781{
782 /* we probably have to release last session from the server */
Willy Tarreau827aee92011-03-10 16:55:02 +0100783 if (target_srv(&s->target)) {
784 health_adjust(target_srv(&s->target), HANA_STATUS_L4_ERR);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100785
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100786 if (s->flags & SN_CURR_SESS) {
787 s->flags &= ~SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +0100788 target_srv(&s->target)->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100789 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100790 }
791
792 /* ensure that we have enough retries left */
Willy Tarreauee28de02010-06-01 09:51:00 +0200793 si->conn_retries--;
794 if (si->conn_retries < 0) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100795 if (!si->err_type) {
796 si->err_type = SI_ET_CONN_ERR;
Willy Tarreau827aee92011-03-10 16:55:02 +0100797 si->err_loc = target_srv(&s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100798 }
799
Willy Tarreau827aee92011-03-10 16:55:02 +0100800 if (target_srv(&s->target))
801 target_srv(&s->target)->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100802 s->be->be_counters.failed_conns++;
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100803 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +0100804 if (may_dequeue_tasks(target_srv(&s->target), s->be))
805 process_srv_queue(target_srv(&s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100806
807 /* shutw is enough so stop a connecting socket */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200808 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200809 si->ob->flags |= CF_WRITE_ERROR;
810 si->ib->flags |= CF_READ_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100811
812 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100813 if (s->srv_error)
814 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100815 return 0;
816 }
817
818 /* If the "redispatch" option is set on the backend, we are allowed to
819 * retry on another server for the last retry. In order to achieve this,
820 * we must mark the session unassigned, and eventually clear the DIRECT
821 * bit to ignore any persistence cookie. We won't count a retry nor a
822 * redispatch yet, because this will depend on what server is selected.
823 */
Willy Tarreau827aee92011-03-10 16:55:02 +0100824 if (target_srv(&s->target) && si->conn_retries == 0 &&
Willy Tarreau4de91492010-01-22 19:10:05 +0100825 s->be->options & PR_O_REDISP && !(s->flags & SN_FORCE_PRST)) {
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100826 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +0100827 if (may_dequeue_tasks(target_srv(&s->target), s->be))
828 process_srv_queue(target_srv(&s->target));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100829
830 s->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100831 si->state = SI_ST_REQ;
832 } else {
Willy Tarreau827aee92011-03-10 16:55:02 +0100833 if (target_srv(&s->target))
834 target_srv(&s->target)->counters.retries++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100835 s->be->be_counters.retries++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100836 si->state = SI_ST_ASS;
837 }
838
839 if (si->flags & SI_FL_ERR) {
840 /* The error was an asynchronous connection error, and we will
841 * likely have to retry connecting to the same server, most
842 * likely leading to the same result. To avoid this, we wait
843 * one second before retrying.
844 */
845
846 if (!si->err_type)
847 si->err_type = SI_ET_CONN_ERR;
848
849 si->state = SI_ST_TAR;
850 si->exp = tick_add(now_ms, MS_TO_TICKS(1000));
851 return 0;
852 }
853 return 0;
854}
855
856/*
857 * This function handles the transition between the SI_ST_CON state and the
Willy Tarreau85e7d002010-05-31 11:57:51 +0200858 * SI_ST_EST state. It must only be called after switching from SI_ST_CON (or
Willy Tarreau26d8c592012-05-07 18:12:14 +0200859 * SI_ST_INI) to SI_ST_EST, but only when a ->proto is defined.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100860 */
Simon Hormandec5be42011-06-08 09:19:07 +0900861static void sess_establish(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100862{
Willy Tarreau7421efb2012-07-02 15:11:27 +0200863 struct channel *req = si->ob;
864 struct channel *rep = si->ib;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100865
Willy Tarreau827aee92011-03-10 16:55:02 +0100866 if (target_srv(&s->target))
867 health_adjust(target_srv(&s->target), HANA_STATUS_L4_OK);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100868
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100869 if (s->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100870 /* if the user wants to log as soon as possible, without counting
871 * bytes from the server, then this is the right moment. */
872 if (s->fe->to_log && !(s->logs.logwait & LW_BYTES)) {
873 s->logs.t_close = s->logs.t_connect; /* to get a valid end date */
Willy Tarreaua5555ec2008-11-30 19:02:32 +0100874 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100875 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100876 }
877 else {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100878 s->txn.rsp.msg_state = HTTP_MSG_RPBEFORE;
879 /* reset hdr_idx which was already initialized by the request.
880 * right now, the http parser does it.
881 * hdr_idx_init(&s->txn.hdr_idx);
882 */
883 }
884
Willy Tarreau4e5b8282009-08-16 22:57:50 +0200885 rep->analysers |= s->fe->fe_rsp_ana | s->be->be_rsp_ana;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200886 rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200887 if (si_ctrl(si)) {
Willy Tarreaud04e8582010-05-31 12:31:35 +0200888 /* real connections have timeouts */
889 req->wto = s->be->timeout.server;
890 rep->rto = s->be->timeout.server;
891 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100892 req->wex = TICK_ETERNITY;
893}
894
895/* Update stream interface status for input states SI_ST_ASS, SI_ST_QUE, SI_ST_TAR.
896 * Other input states are simply ignored.
897 * Possible output states are SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ, SI_ST_CON.
898 * Flags must have previously been updated for timeouts and other conditions.
899 */
Simon Hormandec5be42011-06-08 09:19:07 +0900900static void sess_update_stream_int(struct session *s, struct stream_interface *si)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100901{
Willy Tarreau827aee92011-03-10 16:55:02 +0100902 struct server *srv = target_srv(&s->target);
903
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100904 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 +0100905 now_ms, __FUNCTION__,
906 s,
907 s->req, s->rep,
908 s->req->rex, s->rep->wex,
909 s->req->flags, s->rep->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +0200910 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 +0100911
912 if (si->state == SI_ST_ASS) {
913 /* Server assigned to connection request, we have to try to connect now */
914 int conn_err;
915
916 conn_err = connect_server(s);
Willy Tarreau827aee92011-03-10 16:55:02 +0100917 srv = target_srv(&s->target);
918
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100919 if (conn_err == SN_ERR_NONE) {
920 /* state = SI_ST_CON now */
Willy Tarreau827aee92011-03-10 16:55:02 +0100921 if (srv)
922 srv_inc_sess_ctr(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100923 return;
924 }
925
926 /* We have received a synchronous error. We might have to
927 * abort, retry immediately or redispatch.
928 */
929 if (conn_err == SN_ERR_INTERNAL) {
930 if (!si->err_type) {
931 si->err_type = SI_ET_CONN_OTHER;
Willy Tarreau827aee92011-03-10 16:55:02 +0100932 si->err_loc = srv;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100933 }
934
Willy Tarreau827aee92011-03-10 16:55:02 +0100935 if (srv)
936 srv_inc_sess_ctr(srv);
937 if (srv)
938 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100939 s->be->be_counters.failed_conns++;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100940
941 /* release other sessions waiting for this server */
Willy Tarreaub89cfca2010-12-29 14:32:28 +0100942 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +0100943 if (may_dequeue_tasks(srv, s->be))
944 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100945
946 /* Failed and not retryable. */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200947 si_shutr(si);
948 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200949 si->ob->flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100950
951 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
952
953 /* no session was ever accounted for this server */
954 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100955 if (s->srv_error)
956 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100957 return;
958 }
959
960 /* We are facing a retryable error, but we don't want to run a
961 * turn-around now, as the problem is likely a source port
962 * allocation problem, so we want to retry now.
963 */
964 si->state = SI_ST_CER;
965 si->flags &= ~SI_FL_ERR;
966 sess_update_st_cer(s, si);
967 /* now si->state is one of SI_ST_CLO, SI_ST_TAR, SI_ST_ASS, SI_ST_REQ */
968 return;
969 }
970 else if (si->state == SI_ST_QUE) {
971 /* connection request was queued, check for any update */
972 if (!s->pend_pos) {
973 /* The connection is not in the queue anymore. Either
974 * we have a server connection slot available and we
975 * go directly to the assigned state, or we need to
976 * load-balance first and go to the INI state.
977 */
978 si->exp = TICK_ETERNITY;
979 if (unlikely(!(s->flags & SN_ASSIGNED)))
980 si->state = SI_ST_REQ;
981 else {
982 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
983 si->state = SI_ST_ASS;
984 }
985 return;
986 }
987
988 /* Connection request still in queue... */
989 if (si->flags & SI_FL_EXP) {
990 /* ... and timeout expired */
991 si->exp = TICK_ETERNITY;
992 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau827aee92011-03-10 16:55:02 +0100993 if (srv)
994 srv->counters.failed_conns++;
Willy Tarreau7d0aaf32011-03-10 23:25:56 +0100995 s->be->be_counters.failed_conns++;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200996 si_shutr(si);
997 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200998 si->ob->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100999 if (!si->err_type)
1000 si->err_type = SI_ET_QUEUE_TO;
1001 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001002 if (s->srv_error)
1003 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001004 return;
1005 }
1006
1007 /* Connection remains in queue, check if we have to abort it */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001008 if ((si->ob->flags & (CF_READ_ERROR)) ||
1009 ((si->ob->flags & CF_SHUTW_NOW) && /* empty and client aborted */
Willy Tarreau8e21bb92012-08-24 22:40:29 +02001010 (channel_is_empty(si->ob) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001011 /* give up */
1012 si->exp = TICK_ETERNITY;
1013 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
Willy Tarreau73b013b2012-05-21 16:31:45 +02001014 si_shutr(si);
1015 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001016 si->err_type |= SI_ET_QUEUE_ABRT;
1017 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001018 if (s->srv_error)
1019 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001020 return;
1021 }
1022
1023 /* Nothing changed */
1024 return;
1025 }
1026 else if (si->state == SI_ST_TAR) {
1027 /* Connection request might be aborted */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001028 if ((si->ob->flags & (CF_READ_ERROR)) ||
1029 ((si->ob->flags & CF_SHUTW_NOW) && /* empty and client aborted */
Willy Tarreau8e21bb92012-08-24 22:40:29 +02001030 (channel_is_empty(si->ob) || s->be->options & PR_O_ABRT_CLOSE))) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001031 /* give up */
1032 si->exp = TICK_ETERNITY;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001033 si_shutr(si);
1034 si_shutw(si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001035 si->err_type |= SI_ET_CONN_ABRT;
1036 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001037 if (s->srv_error)
1038 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001039 return;
1040 }
1041
1042 if (!(si->flags & SI_FL_EXP))
1043 return; /* still in turn-around */
1044
1045 si->exp = TICK_ETERNITY;
1046
1047 /* we keep trying on the same server as long as the session is
1048 * marked "assigned".
1049 * FIXME: Should we force a redispatch attempt when the server is down ?
1050 */
1051 if (s->flags & SN_ASSIGNED)
1052 si->state = SI_ST_ASS;
1053 else
1054 si->state = SI_ST_REQ;
1055 return;
1056 }
1057}
1058
Simon Hormandec5be42011-06-08 09:19:07 +09001059/* Set correct session termination flags in case no analyser has done it. It
1060 * also counts a failed request if the server state has not reached the request
1061 * stage.
1062 */
1063static void sess_set_term_flags(struct session *s)
1064{
1065 if (!(s->flags & SN_FINST_MASK)) {
1066 if (s->si[1].state < SI_ST_REQ) {
1067
1068 s->fe->fe_counters.failed_req++;
1069 if (s->listener->counters)
1070 s->listener->counters->failed_req++;
1071
1072 s->flags |= SN_FINST_R;
1073 }
1074 else if (s->si[1].state == SI_ST_QUE)
1075 s->flags |= SN_FINST_Q;
1076 else if (s->si[1].state < SI_ST_EST)
1077 s->flags |= SN_FINST_C;
1078 else if (s->si[1].state == SI_ST_EST || s->si[1].prev_state == SI_ST_EST)
1079 s->flags |= SN_FINST_D;
1080 else
1081 s->flags |= SN_FINST_L;
1082 }
1083}
1084
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001085/* This function initiates a server connection request on a stream interface
1086 * already in SI_ST_REQ state. Upon success, the state goes to SI_ST_ASS,
1087 * indicating that a server has been assigned. It may also return SI_ST_QUE,
1088 * or SI_ST_CLO upon error.
1089 */
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001090static void sess_prepare_conn_req(struct session *s, struct stream_interface *si)
1091{
1092 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 +01001093 now_ms, __FUNCTION__,
1094 s,
1095 s->req, s->rep,
1096 s->req->rex, s->rep->wex,
1097 s->req->flags, s->rep->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001098 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 +01001099
1100 if (si->state != SI_ST_REQ)
1101 return;
1102
1103 /* Try to assign a server */
1104 if (srv_redispatch_connect(s) != 0) {
1105 /* We did not get a server. Either we queued the
1106 * connection request, or we encountered an error.
1107 */
1108 if (si->state == SI_ST_QUE)
1109 return;
1110
1111 /* we did not get any server, let's check the cause */
Willy Tarreau73b013b2012-05-21 16:31:45 +02001112 si_shutr(si);
1113 si_shutw(si);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001114 si->ob->flags |= CF_WRITE_ERROR;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001115 if (!si->err_type)
1116 si->err_type = SI_ET_CONN_OTHER;
1117 si->state = SI_ST_CLO;
Willy Tarreau0cac36f2008-11-30 20:44:17 +01001118 if (s->srv_error)
1119 s->srv_error(s, si);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001120 return;
1121 }
1122
1123 /* The server is assigned */
1124 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
1125 si->state = SI_ST_ASS;
1126}
1127
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001128/* This stream analyser checks the switching rules and changes the backend
Willy Tarreau4de91492010-01-22 19:10:05 +01001129 * if appropriate. The default_backend rule is also considered, then the
1130 * target backend's forced persistence rules are also evaluated last if any.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001131 * It returns 1 if the processing can continue on next analysers, or zero if it
1132 * either needs more data or wants to immediately abort the request.
1133 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001134static int process_switching_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001135{
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001136 struct persist_rule *prst_rule;
Willy Tarreau4de91492010-01-22 19:10:05 +01001137
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001138 req->analysers &= ~an_bit;
1139 req->analyse_exp = TICK_ETERNITY;
1140
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001141 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 +02001142 now_ms, __FUNCTION__,
1143 s,
1144 req,
1145 req->rex, req->wex,
1146 req->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001147 req->buf.i,
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001148 req->analysers);
1149
1150 /* now check whether we have some switching rules for this request */
1151 if (!(s->flags & SN_BE_ASSIGNED)) {
1152 struct switching_rule *rule;
1153
1154 list_for_each_entry(rule, &s->fe->switching_rules, list) {
1155 int ret;
1156
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001157 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 +02001158 ret = acl_pass(ret);
1159 if (rule->cond->pol == ACL_COND_UNLESS)
1160 ret = !ret;
1161
1162 if (ret) {
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001163 if (!session_set_backend(s, rule->be.backend))
1164 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001165 break;
1166 }
1167 }
1168
1169 /* To ensure correct connection accounting on the backend, we
1170 * have to assign one if it was not set (eg: a listen). This
1171 * measure also takes care of correctly setting the default
1172 * backend if any.
1173 */
1174 if (!(s->flags & SN_BE_ASSIGNED))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001175 if (!session_set_backend(s, s->fe->defbe.be ? s->fe->defbe.be : s->be))
1176 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001177 }
1178
Willy Tarreaufb356202010-08-03 14:02:05 +02001179 /* we don't want to run the TCP or HTTP filters again if the backend has not changed */
1180 if (s->fe == s->be) {
1181 s->req->analysers &= ~AN_REQ_INSPECT_BE;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001182 s->req->analysers &= ~AN_REQ_HTTP_PROCESS_BE;
Willy Tarreaufb356202010-08-03 14:02:05 +02001183 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001184
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001185 /* 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 +01001186 * persistence rule, and report that in the session.
1187 */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001188 list_for_each_entry(prst_rule, &s->be->persist_rules, list) {
Willy Tarreau4de91492010-01-22 19:10:05 +01001189 int ret = 1;
1190
1191 if (prst_rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001192 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 +01001193 ret = acl_pass(ret);
1194 if (prst_rule->cond->pol == ACL_COND_UNLESS)
1195 ret = !ret;
1196 }
1197
1198 if (ret) {
1199 /* no rule, or the rule matches */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001200 if (prst_rule->type == PERSIST_TYPE_FORCE) {
1201 s->flags |= SN_FORCE_PRST;
1202 } else {
1203 s->flags |= SN_IGNORE_PRST;
1204 }
Willy Tarreau4de91492010-01-22 19:10:05 +01001205 break;
1206 }
1207 }
1208
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001209 return 1;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001210
1211 sw_failed:
1212 /* immediately abort this request in case of allocation failure */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001213 channel_abort(s->req);
1214 channel_abort(s->rep);
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001215
1216 if (!(s->flags & SN_ERR_MASK))
1217 s->flags |= SN_ERR_RESOURCE;
1218 if (!(s->flags & SN_FINST_MASK))
1219 s->flags |= SN_FINST_R;
1220
1221 s->txn.status = 500;
1222 s->req->analysers = 0;
1223 s->req->analyse_exp = TICK_ETERNITY;
1224 return 0;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001225}
1226
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001227/* This stream analyser works on a request. It applies all use-server rules on
1228 * it then returns 1. The data must already be present in the buffer otherwise
1229 * they won't match. It always returns 1.
1230 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001231static int process_server_rules(struct session *s, struct channel *req, int an_bit)
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001232{
1233 struct proxy *px = s->be;
1234 struct server_rule *rule;
1235
1236 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
1237 now_ms, __FUNCTION__,
1238 s,
1239 req,
1240 req->rex, req->wex,
1241 req->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001242 req->buf.i + req->buf.o,
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001243 req->analysers);
1244
1245 if (!(s->flags & SN_ASSIGNED)) {
1246 list_for_each_entry(rule, &px->server_rules, list) {
1247 int ret;
1248
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001249 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 +02001250 ret = acl_pass(ret);
1251 if (rule->cond->pol == ACL_COND_UNLESS)
1252 ret = !ret;
1253
1254 if (ret) {
1255 struct server *srv = rule->srv.ptr;
1256
1257 if ((srv->state & SRV_RUNNING) ||
1258 (px->options & PR_O_PERSIST) ||
1259 (s->flags & SN_FORCE_PRST)) {
1260 s->flags |= SN_DIRECT | SN_ASSIGNED;
1261 set_target_server(&s->target, srv);
1262 break;
1263 }
1264 /* if the server is not UP, let's go on with next rules
1265 * just in case another one is suited.
1266 */
1267 }
1268 }
1269 }
1270
1271 req->analysers &= ~an_bit;
1272 req->analyse_exp = TICK_ETERNITY;
1273 return 1;
1274}
1275
Emeric Brun1d33b292010-01-04 15:47:17 +01001276/* This stream analyser works on a request. It applies all sticking rules on
1277 * it then returns 1. The data must already be present in the buffer otherwise
1278 * they won't match. It always returns 1.
1279 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001280static int process_sticking_rules(struct session *s, struct channel *req, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001281{
1282 struct proxy *px = s->be;
1283 struct sticking_rule *rule;
1284
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001285 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 +01001286 now_ms, __FUNCTION__,
1287 s,
1288 req,
1289 req->rex, req->wex,
1290 req->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001291 req->buf.i,
Emeric Brun1d33b292010-01-04 15:47:17 +01001292 req->analysers);
1293
1294 list_for_each_entry(rule, &px->sticking_rules, list) {
1295 int ret = 1 ;
1296 int i;
1297
1298 for (i = 0; i < s->store_count; i++) {
1299 if (rule->table.t == s->store[i].table)
1300 break;
1301 }
1302
1303 if (i != s->store_count)
1304 continue;
1305
1306 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001307 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001308 ret = acl_pass(ret);
1309 if (rule->cond->pol == ACL_COND_UNLESS)
1310 ret = !ret;
1311 }
1312
1313 if (ret) {
1314 struct stktable_key *key;
1315
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001316 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 +01001317 if (!key)
1318 continue;
1319
1320 if (rule->flags & STK_IS_MATCH) {
1321 struct stksess *ts;
1322
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001323 if ((ts = stktable_lookup_key(rule->table.t, key)) != NULL) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001324 if (!(s->flags & SN_ASSIGNED)) {
1325 struct eb32_node *node;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001326 void *ptr;
Emeric Brun1d33b292010-01-04 15:47:17 +01001327
1328 /* srv found in table */
Willy Tarreau13c29de2010-06-06 16:40:39 +02001329 ptr = stktable_data_ptr(rule->table.t, ts, STKTABLE_DT_SERVER_ID);
1330 node = eb32_lookup(&px->conf.used_server_id, stktable_data_cast(ptr, server_id));
Emeric Brun1d33b292010-01-04 15:47:17 +01001331 if (node) {
1332 struct server *srv;
1333
1334 srv = container_of(node, struct server, conf.id);
Willy Tarreau4de91492010-01-22 19:10:05 +01001335 if ((srv->state & SRV_RUNNING) ||
1336 (px->options & PR_O_PERSIST) ||
1337 (s->flags & SN_FORCE_PRST)) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001338 s->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau9e000c62011-03-10 14:03:36 +01001339 set_target_server(&s->target, srv);
Emeric Brun1d33b292010-01-04 15:47:17 +01001340 }
1341 }
1342 }
Emeric Brun85e77c72010-09-23 18:16:52 +02001343 stktable_touch(rule->table.t, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001344 }
1345 }
1346 if (rule->flags & STK_IS_STORE) {
1347 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1348 struct stksess *ts;
1349
1350 ts = stksess_new(rule->table.t, key);
1351 if (ts) {
1352 s->store[s->store_count].table = rule->table.t;
1353 s->store[s->store_count++].ts = ts;
1354 }
1355 }
1356 }
1357 }
1358 }
1359
1360 req->analysers &= ~an_bit;
1361 req->analyse_exp = TICK_ETERNITY;
1362 return 1;
1363}
1364
1365/* This stream analyser works on a response. It applies all store rules on it
1366 * then returns 1. The data must already be present in the buffer otherwise
1367 * they won't match. It always returns 1.
1368 */
Willy Tarreau7421efb2012-07-02 15:11:27 +02001369static int process_store_rules(struct session *s, struct channel *rep, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001370{
1371 struct proxy *px = s->be;
1372 struct sticking_rule *rule;
1373 int i;
1374
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001375 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 +01001376 now_ms, __FUNCTION__,
1377 s,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001378 rep,
1379 rep->rex, rep->wex,
1380 rep->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001381 rep->buf.i,
Willy Tarreau2e2b3eb2010-02-09 20:55:44 +01001382 rep->analysers);
Emeric Brun1d33b292010-01-04 15:47:17 +01001383
1384 list_for_each_entry(rule, &px->storersp_rules, list) {
1385 int ret = 1 ;
1386 int storereqidx = -1;
1387
1388 for (i = 0; i < s->store_count; i++) {
1389 if (rule->table.t == s->store[i].table) {
1390 if (!(s->store[i].flags))
1391 storereqidx = i;
1392 break;
1393 }
1394 }
1395
1396 if ((i != s->store_count) && (storereqidx == -1))
1397 continue;
1398
1399 if (rule->cond) {
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001400 ret = acl_exec_cond(rule->cond, px, s, &s->txn, SMP_OPT_DIR_RES|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001401 ret = acl_pass(ret);
1402 if (rule->cond->pol == ACL_COND_UNLESS)
1403 ret = !ret;
1404 }
1405
1406 if (ret) {
1407 struct stktable_key *key;
1408
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001409 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 +01001410 if (!key)
1411 continue;
1412
1413 if (storereqidx != -1) {
Willy Tarreau393379c2010-06-06 12:11:37 +02001414 stksess_setkey(s->store[storereqidx].table, s->store[storereqidx].ts, key);
Emeric Brun1d33b292010-01-04 15:47:17 +01001415 s->store[storereqidx].flags = 1;
1416 }
1417 else if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1418 struct stksess *ts;
1419
1420 ts = stksess_new(rule->table.t, key);
1421 if (ts) {
1422 s->store[s->store_count].table = rule->table.t;
1423 s->store[s->store_count].flags = 1;
1424 s->store[s->store_count++].ts = ts;
1425 }
1426 }
1427 }
1428 }
1429
1430 /* process store request and store response */
1431 for (i = 0; i < s->store_count; i++) {
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001432 struct stksess *ts;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001433 void *ptr;
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001434
Simon Hormanfa461682011-06-25 09:39:49 +09001435 if (target_srv(&s->target) && target_srv(&s->target)->state & SRV_NON_STICK) {
1436 stksess_free(s->store[i].table, s->store[i].ts);
1437 s->store[i].ts = NULL;
1438 continue;
1439 }
1440
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001441 ts = stktable_lookup(s->store[i].table, s->store[i].ts);
1442 if (ts) {
1443 /* the entry already existed, we can free ours */
Emeric Brun85e77c72010-09-23 18:16:52 +02001444 stktable_touch(s->store[i].table, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001445 stksess_free(s->store[i].table, s->store[i].ts);
Emeric Brun1d33b292010-01-04 15:47:17 +01001446 }
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001447 else
Emeric Brun85e77c72010-09-23 18:16:52 +02001448 ts = stktable_store(s->store[i].table, s->store[i].ts, 1);
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001449
1450 s->store[i].ts = NULL;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001451 ptr = stktable_data_ptr(s->store[i].table, ts, STKTABLE_DT_SERVER_ID);
Willy Tarreau827aee92011-03-10 16:55:02 +01001452 stktable_data_cast(ptr, server_id) = target_srv(&s->target)->puid;
Emeric Brun1d33b292010-01-04 15:47:17 +01001453 }
Willy Tarreau2a164ee2010-06-18 09:57:45 +02001454 s->store_count = 0; /* everything is stored */
Emeric Brun1d33b292010-01-04 15:47:17 +01001455
1456 rep->analysers &= ~an_bit;
1457 rep->analyse_exp = TICK_ETERNITY;
1458 return 1;
1459}
1460
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001461/* This macro is very specific to the function below. See the comments in
1462 * process_session() below to understand the logic and the tests.
1463 */
1464#define UPDATE_ANALYSERS(real, list, back, flag) { \
1465 list = (((list) & ~(flag)) | ~(back)) & (real); \
1466 back = real; \
1467 if (!(list)) \
1468 break; \
1469 if (((list) ^ ((list) & ((list) - 1))) < (flag)) \
1470 continue; \
1471}
1472
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001473/* Processes the client, server, request and response jobs of a session task,
1474 * then puts it back to the wait queue in a clean state, or cleans up its
1475 * resources if it must be deleted. Returns in <next> the date the task wants
1476 * to be woken up, or TICK_ETERNITY. In order not to call all functions for
1477 * nothing too many times, the request and response buffers flags are monitored
1478 * and each function is called only if at least another function has changed at
1479 * least one flag it is interested in.
1480 */
Willy Tarreau26c25062009-03-08 09:38:41 +01001481struct task *process_session(struct task *t)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001482{
Willy Tarreau827aee92011-03-10 16:55:02 +01001483 struct server *srv;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001484 struct session *s = t->context;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001485 unsigned int rqf_last, rpf_last;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001486 unsigned int rq_prod_last, rq_cons_last;
1487 unsigned int rp_cons_last, rp_prod_last;
Willy Tarreau576507f2010-01-07 00:09:04 +01001488 unsigned int req_ana_back;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001489
1490 //DPRINTF(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__,
1491 // s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s->rep->flags);
1492
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001493 /* this data may be no longer valid, clear it */
1494 memset(&s->txn.auth, 0, sizeof(s->txn.auth));
1495
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001496 /* This flag must explicitly be set every time */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001497 s->req->flags &= ~CF_READ_NOEXP;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001498
1499 /* Keep a copy of req/rep flags so that we can detect shutdowns */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001500 rqf_last = s->req->flags & ~CF_MASK_ANALYSER;
1501 rpf_last = s->rep->flags & ~CF_MASK_ANALYSER;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001502
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001503 /* we don't want the stream interface functions to recursively wake us up */
1504 if (s->req->prod->owner == t)
1505 s->req->prod->flags |= SI_FL_DONT_WAKE;
1506 if (s->req->cons->owner == t)
1507 s->req->cons->flags |= SI_FL_DONT_WAKE;
1508
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001509 /* 1a: Check for low level timeouts if needed. We just set a flag on
1510 * stream interfaces when their timeouts have expired.
1511 */
1512 if (unlikely(t->state & TASK_WOKEN_TIMER)) {
1513 stream_int_check_timeouts(&s->si[0]);
1514 stream_int_check_timeouts(&s->si[1]);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001515
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001516 /* check channel timeouts, and close the corresponding stream interfaces
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001517 * for future reads or writes. Note: this will also concern upper layers
1518 * but we do not touch any other flag. We must be careful and correctly
1519 * detect state changes when calling them.
1520 */
1521
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001522 channel_check_timeouts(s->req);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001523
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001524 if (unlikely((s->req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreau14641402009-12-29 14:49:56 +01001525 s->req->cons->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001526 si_shutw(s->req->cons);
Willy Tarreau14641402009-12-29 14:49:56 +01001527 }
1528
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001529 if (unlikely((s->req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001530 if (s->req->prod->flags & SI_FL_NOHALF)
1531 s->req->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001532 si_shutr(s->req->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001533 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001534
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001535 channel_check_timeouts(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001536
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001537 if (unlikely((s->rep->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreau14641402009-12-29 14:49:56 +01001538 s->rep->cons->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001539 si_shutw(s->rep->cons);
Willy Tarreau14641402009-12-29 14:49:56 +01001540 }
1541
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001542 if (unlikely((s->rep->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001543 if (s->rep->prod->flags & SI_FL_NOHALF)
1544 s->rep->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02001545 si_shutr(s->rep->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001546 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001547 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001548
1549 /* 1b: check for low-level errors reported at the stream interface.
1550 * First we check if it's a retryable error (in which case we don't
1551 * want to tell the buffer). Otherwise we report the error one level
1552 * upper by setting flags into the buffers. Note that the side towards
1553 * the client cannot have connect (hence retryable) errors. Also, the
1554 * connection setup code must be able to deal with any type of abort.
1555 */
Willy Tarreau827aee92011-03-10 16:55:02 +01001556 srv = target_srv(&s->target);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001557 if (unlikely(s->si[0].flags & SI_FL_ERR)) {
1558 if (s->si[0].state == SI_ST_EST || s->si[0].state == SI_ST_DIS) {
Willy Tarreau73b013b2012-05-21 16:31:45 +02001559 si_shutr(&s->si[0]);
1560 si_shutw(&s->si[0]);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001561 stream_int_report_error(&s->si[0]);
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001562 if (!(s->req->analysers) && !(s->rep->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001563 s->be->be_counters.cli_aborts++;
1564 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001565 if (srv)
1566 srv->counters.cli_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001567 if (!(s->flags & SN_ERR_MASK))
1568 s->flags |= SN_ERR_CLICL;
1569 if (!(s->flags & SN_FINST_MASK))
1570 s->flags |= SN_FINST_D;
1571 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001572 }
1573 }
1574
1575 if (unlikely(s->si[1].flags & SI_FL_ERR)) {
1576 if (s->si[1].state == SI_ST_EST || s->si[1].state == SI_ST_DIS) {
Willy Tarreau73b013b2012-05-21 16:31:45 +02001577 si_shutr(&s->si[1]);
1578 si_shutw(&s->si[1]);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001579 stream_int_report_error(&s->si[1]);
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001580 s->be->be_counters.failed_resp++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001581 if (srv)
1582 srv->counters.failed_resp++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001583 if (!(s->req->analysers) && !(s->rep->analysers)) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001584 s->be->be_counters.srv_aborts++;
1585 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001586 if (srv)
1587 srv->counters.srv_aborts++;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001588 if (!(s->flags & SN_ERR_MASK))
1589 s->flags |= SN_ERR_SRVCL;
1590 if (!(s->flags & SN_FINST_MASK))
1591 s->flags |= SN_FINST_D;
1592 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001593 }
1594 /* note: maybe we should process connection errors here ? */
1595 }
1596
1597 if (s->si[1].state == SI_ST_CON) {
1598 /* we were trying to establish a connection on the server side,
1599 * maybe it succeeded, maybe it failed, maybe we timed out, ...
1600 */
1601 if (unlikely(!sess_update_st_con_tcp(s, &s->si[1])))
1602 sess_update_st_cer(s, &s->si[1]);
1603 else if (s->si[1].state == SI_ST_EST)
1604 sess_establish(s, &s->si[1]);
1605
1606 /* state is now one of SI_ST_CON (still in progress), SI_ST_EST
1607 * (established), SI_ST_DIS (abort), SI_ST_CLO (last error),
1608 * SI_ST_ASS/SI_ST_TAR/SI_ST_REQ for retryable errors.
1609 */
1610 }
1611
Willy Tarreau815a9b22010-07-27 17:15:12 +02001612 rq_prod_last = s->si[0].state;
1613 rq_cons_last = s->si[1].state;
1614 rp_cons_last = s->si[0].state;
1615 rp_prod_last = s->si[1].state;
1616
1617 resync_stream_interface:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001618 /* Check for connection closure */
1619
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001620 DPRINTF(stderr,
Willy Tarreau02d6cfc2012-03-01 18:19:58 +01001621 "[%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 +01001622 now_ms, __FUNCTION__, __LINE__,
1623 t,
1624 s, s->flags,
1625 s->req, s->rep,
1626 s->req->rex, s->rep->wex,
1627 s->req->flags, s->rep->flags,
Cyril Bonté3aaba442012-09-23 14:19:12 +02001628 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 +01001629 s->rep->cons->err_type, s->req->cons->err_type,
Willy Tarreauee28de02010-06-01 09:51:00 +02001630 s->req->cons->conn_retries);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001631
1632 /* nothing special to be done on client side */
1633 if (unlikely(s->req->prod->state == SI_ST_DIS))
1634 s->req->prod->state = SI_ST_CLO;
1635
1636 /* When a server-side connection is released, we have to count it and
1637 * check for pending connections on this server.
1638 */
1639 if (unlikely(s->req->cons->state == SI_ST_DIS)) {
1640 s->req->cons->state = SI_ST_CLO;
Willy Tarreau827aee92011-03-10 16:55:02 +01001641 srv = target_srv(&s->target);
1642 if (srv) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001643 if (s->flags & SN_CURR_SESS) {
1644 s->flags &= ~SN_CURR_SESS;
Willy Tarreau827aee92011-03-10 16:55:02 +01001645 srv->cur_sess--;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001646 }
1647 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001648 if (may_dequeue_tasks(srv, s->be))
1649 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001650 }
1651 }
1652
1653 /*
1654 * Note: of the transient states (REQ, CER, DIS), only REQ may remain
1655 * at this point.
1656 */
1657
Willy Tarreau0be0ef92009-03-08 19:20:25 +01001658 resync_request:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001659 /* Analyse request */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001660 if (((s->req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
1661 ((s->req->flags ^ rqf_last) & CF_MASK_STATIC) ||
Willy Tarreau815a9b22010-07-27 17:15:12 +02001662 s->si[0].state != rq_prod_last ||
1663 s->si[1].state != rq_cons_last) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001664 unsigned int flags = s->req->flags;
1665
1666 if (s->req->prod->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001667 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001668 unsigned int ana_list;
1669 unsigned int ana_back;
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001670
Willy Tarreau90deb182010-01-07 00:20:41 +01001671 /* it's up to the analysers to stop new connections,
1672 * disable reading or closing. Note: if an analyser
1673 * disables any of these bits, it is responsible for
1674 * enabling them again when it disables itself, so
1675 * that other analysers are called in similar conditions.
1676 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001677 channel_auto_read(s->req);
1678 channel_auto_connect(s->req);
1679 channel_auto_close(s->req);
Willy Tarreauedcf6682008-11-30 23:15:34 +01001680
1681 /* We will call all analysers for which a bit is set in
1682 * s->req->analysers, following the bit order from LSB
1683 * to MSB. The analysers must remove themselves from
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001684 * the list when not needed. Any analyser may return 0
1685 * to break out of the loop, either because of missing
1686 * data to take a decision, or because it decides to
1687 * kill the session. We loop at least once through each
1688 * analyser, and we may loop again if other analysers
1689 * are added in the middle.
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001690 *
1691 * We build a list of analysers to run. We evaluate all
1692 * of these analysers in the order of the lower bit to
1693 * the higher bit. This ordering is very important.
1694 * An analyser will often add/remove other analysers,
1695 * including itself. Any changes to itself have no effect
1696 * on the loop. If it removes any other analysers, we
1697 * want those analysers not to be called anymore during
1698 * this loop. If it adds an analyser that is located
1699 * after itself, we want it to be scheduled for being
1700 * processed during the loop. If it adds an analyser
1701 * which is located before it, we want it to switch to
1702 * it immediately, even if it has already been called
1703 * once but removed since.
1704 *
1705 * In order to achieve this, we compare the analyser
1706 * list after the call with a copy of it before the
1707 * call. The work list is fed with analyser bits that
1708 * appeared during the call. Then we compare previous
1709 * work list with the new one, and check the bits that
1710 * appeared. If the lowest of these bits is lower than
1711 * the current bit, it means we have enabled a previous
1712 * analyser and must immediately loop again.
Willy Tarreauedcf6682008-11-30 23:15:34 +01001713 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001714
1715 ana_list = ana_back = s->req->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01001716 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001717 /* Warning! ensure that analysers are always placed in ascending order! */
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001718
Willy Tarreaufb356202010-08-03 14:02:05 +02001719 if (ana_list & AN_REQ_INSPECT_FE) {
1720 if (!tcp_inspect_request(s, s->req, AN_REQ_INSPECT_FE))
Willy Tarreauedcf6682008-11-30 23:15:34 +01001721 break;
Willy Tarreaufb356202010-08-03 14:02:05 +02001722 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001723 }
Willy Tarreauedcf6682008-11-30 23:15:34 +01001724
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001725 if (ana_list & AN_REQ_WAIT_HTTP) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001726 if (!http_wait_for_request(s, s->req, AN_REQ_WAIT_HTTP))
Willy Tarreaud787e662009-07-07 10:14:51 +02001727 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001728 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
Willy Tarreaud787e662009-07-07 10:14:51 +02001729 }
1730
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001731 if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001732 if (!http_process_req_common(s, s->req, AN_REQ_HTTP_PROCESS_FE, s->fe))
1733 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001734 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001735 }
1736
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001737 if (ana_list & AN_REQ_SWITCHING_RULES) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001738 if (!process_switching_rules(s, s->req, AN_REQ_SWITCHING_RULES))
1739 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001740 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001741 }
1742
Willy Tarreaufb356202010-08-03 14:02:05 +02001743 if (ana_list & AN_REQ_INSPECT_BE) {
1744 if (!tcp_inspect_request(s, s->req, AN_REQ_INSPECT_BE))
1745 break;
1746 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
1747 }
1748
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001749 if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001750 if (!http_process_req_common(s, s->req, AN_REQ_HTTP_PROCESS_BE, s->be))
1751 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001752 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001753 }
1754
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001755 if (ana_list & AN_REQ_HTTP_TARPIT) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001756 if (!http_process_tarpit(s, s->req, AN_REQ_HTTP_TARPIT))
Willy Tarreau60b85b02008-11-30 23:28:40 +01001757 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001758 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001759 }
Willy Tarreau60b85b02008-11-30 23:28:40 +01001760
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001761 if (ana_list & AN_REQ_SRV_RULES) {
1762 if (!process_server_rules(s, s->req, AN_REQ_SRV_RULES))
1763 break;
1764 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
1765 }
1766
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001767 if (ana_list & AN_REQ_HTTP_INNER) {
Willy Tarreauc465fd72009-08-31 00:17:18 +02001768 if (!http_process_request(s, s->req, AN_REQ_HTTP_INNER))
1769 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001770 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
Willy Tarreauc465fd72009-08-31 00:17:18 +02001771 }
1772
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001773 if (ana_list & AN_REQ_HTTP_BODY) {
Willy Tarreau3a816292009-07-07 10:55:49 +02001774 if (!http_process_request_body(s, s->req, AN_REQ_HTTP_BODY))
Willy Tarreaud34af782008-11-30 23:36:37 +01001775 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001776 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001777 }
Emeric Brun647caf12009-06-30 17:57:00 +02001778
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001779 if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
Emeric Brun647caf12009-06-30 17:57:00 +02001780 if (!tcp_persist_rdp_cookie(s, s->req, AN_REQ_PRST_RDP_COOKIE))
1781 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001782 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
Emeric Brun647caf12009-06-30 17:57:00 +02001783 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01001784
Emeric Brun1d33b292010-01-04 15:47:17 +01001785 if (ana_list & AN_REQ_STICKING_RULES) {
1786 if (!process_sticking_rules(s, s->req, AN_REQ_STICKING_RULES))
1787 break;
1788 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
1789 }
1790
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001791 if (ana_list & AN_REQ_HTTP_XFER_BODY) {
Willy Tarreaud98cf932009-12-27 22:54:55 +01001792 if (!http_request_forward_body(s, s->req, AN_REQ_HTTP_XFER_BODY))
1793 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001794 UPDATE_ANALYSERS(s->req->analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01001795 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01001796 break;
1797 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001798 }
Willy Tarreau84455332009-03-15 22:34:05 +01001799
Willy Tarreau815a9b22010-07-27 17:15:12 +02001800 rq_prod_last = s->si[0].state;
1801 rq_cons_last = s->si[1].state;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001802 s->req->flags &= ~CF_WAKE_ONCE;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001803 rqf_last = s->req->flags;
1804
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001805 if ((s->req->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001806 goto resync_request;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001807 }
1808
Willy Tarreau576507f2010-01-07 00:09:04 +01001809 /* we'll monitor the request analysers while parsing the response,
1810 * because some response analysers may indirectly enable new request
1811 * analysers (eg: HTTP keep-alive).
1812 */
1813 req_ana_back = s->req->analysers;
1814
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001815 resync_response:
1816 /* Analyse response */
1817
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001818 if (unlikely(s->rep->flags & CF_HIJACK)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001819 /* In inject mode, we wake up everytime something has
1820 * happened on the write side of the buffer.
1821 */
1822 unsigned int flags = s->rep->flags;
1823
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001824 if ((s->rep->flags & (CF_WRITE_PARTIAL|CF_WRITE_ERROR|CF_SHUTW)) &&
Willy Tarreau3bf1b2b2012-08-27 20:46:07 +02001825 !channel_full(s->rep)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001826 s->rep->hijacker(s, s->rep);
1827 }
1828
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001829 if ((s->rep->flags ^ flags) & CF_MASK_STATIC) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001830 rpf_last = s->rep->flags;
1831 goto resync_response;
1832 }
1833 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001834 else if (((s->rep->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
1835 (s->rep->flags ^ rpf_last) & CF_MASK_STATIC ||
Willy Tarreau815a9b22010-07-27 17:15:12 +02001836 s->si[0].state != rp_cons_last ||
1837 s->si[1].state != rp_prod_last) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001838 unsigned int flags = s->rep->flags;
1839
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001840 if ((s->rep->flags & CF_MASK_ANALYSER) &&
Willy Tarreau0499e352010-12-17 07:13:42 +01001841 (s->rep->analysers & AN_REQ_WAIT_HTTP)) {
1842 /* Due to HTTP pipelining, the HTTP request analyser might be waiting
1843 * for some free space in the response buffer, so we might need to call
1844 * it when something changes in the response buffer, but still we pass
1845 * it the request buffer. Note that the SI state might very well still
1846 * be zero due to us returning a flow of redirects!
1847 */
1848 s->rep->analysers &= ~AN_REQ_WAIT_HTTP;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001849 s->req->flags |= CF_WAKE_ONCE;
Willy Tarreau0499e352010-12-17 07:13:42 +01001850 }
1851
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001852 if (s->rep->prod->state >= SI_ST_EST) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001853 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001854 unsigned int ana_list;
1855 unsigned int ana_back;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001856
Willy Tarreau90deb182010-01-07 00:20:41 +01001857 /* it's up to the analysers to stop disable reading or
1858 * closing. Note: if an analyser disables any of these
1859 * bits, it is responsible for enabling them again when
1860 * it disables itself, so that other analysers are called
1861 * in similar conditions.
1862 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02001863 channel_auto_read(s->rep);
1864 channel_auto_close(s->rep);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001865
1866 /* We will call all analysers for which a bit is set in
1867 * s->rep->analysers, following the bit order from LSB
1868 * to MSB. The analysers must remove themselves from
1869 * the list when not needed. Any analyser may return 0
1870 * to break out of the loop, either because of missing
1871 * data to take a decision, or because it decides to
1872 * kill the session. We loop at least once through each
1873 * analyser, and we may loop again if other analysers
1874 * are added in the middle.
1875 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001876
1877 ana_list = ana_back = s->rep->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01001878 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001879 /* Warning! ensure that analysers are always placed in ascending order! */
1880
Emeric Brun97679e72010-09-23 17:56:44 +02001881 if (ana_list & AN_RES_INSPECT) {
1882 if (!tcp_inspect_response(s, s->rep, AN_RES_INSPECT))
1883 break;
1884 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_INSPECT);
1885 }
1886
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001887 if (ana_list & AN_RES_WAIT_HTTP) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001888 if (!http_wait_for_response(s, s->rep, AN_RES_WAIT_HTTP))
1889 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001890 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001891 }
1892
Emeric Brun1d33b292010-01-04 15:47:17 +01001893 if (ana_list & AN_RES_STORE_RULES) {
1894 if (!process_store_rules(s, s->rep, AN_RES_STORE_RULES))
1895 break;
1896 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
1897 }
1898
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001899 if (ana_list & AN_RES_HTTP_PROCESS_BE) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001900 if (!http_process_res_common(s, s->rep, AN_RES_HTTP_PROCESS_BE, s->be))
1901 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001902 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02001903 }
Willy Tarreaud98cf932009-12-27 22:54:55 +01001904
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001905 if (ana_list & AN_RES_HTTP_XFER_BODY) {
Willy Tarreaud98cf932009-12-27 22:54:55 +01001906 if (!http_response_forward_body(s, s->rep, AN_RES_HTTP_XFER_BODY))
1907 break;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001908 UPDATE_ANALYSERS(s->rep->analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
Willy Tarreaud98cf932009-12-27 22:54:55 +01001909 }
Willy Tarreaue34070e2010-01-08 00:32:27 +01001910 break;
1911 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001912 }
1913
Willy Tarreau815a9b22010-07-27 17:15:12 +02001914 rp_cons_last = s->si[0].state;
1915 rp_prod_last = s->si[1].state;
1916 rpf_last = s->rep->flags;
1917
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001918 if ((s->rep->flags ^ flags) & CF_MASK_STATIC)
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001919 goto resync_response;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001920 }
1921
Willy Tarreau576507f2010-01-07 00:09:04 +01001922 /* maybe someone has added some request analysers, so we must check and loop */
1923 if (s->req->analysers & ~req_ana_back)
1924 goto resync_request;
1925
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001926 if ((s->req->flags & ~rqf_last) & CF_MASK_ANALYSER)
Willy Tarreau0499e352010-12-17 07:13:42 +01001927 goto resync_request;
1928
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001929 /* FIXME: here we should call protocol handlers which rely on
1930 * both buffers.
1931 */
1932
1933
1934 /*
Willy Tarreauae526782010-03-04 20:34:23 +01001935 * Now we propagate unhandled errors to the session. Normally
1936 * we're just in a data phase here since it means we have not
1937 * seen any analyser who could set an error status.
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001938 */
Willy Tarreau827aee92011-03-10 16:55:02 +01001939 srv = target_srv(&s->target);
Willy Tarreau2f976e12010-11-11 14:28:47 +01001940 if (unlikely(!(s->flags & SN_ERR_MASK))) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001941 if (s->req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001942 /* Report it if the client got an error or a read timeout expired */
Willy Tarreau84455332009-03-15 22:34:05 +01001943 s->req->analysers = 0;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001944 if (s->req->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001945 s->be->be_counters.cli_aborts++;
1946 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001947 if (srv)
1948 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01001949 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01001950 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001951 else if (s->req->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001952 s->be->be_counters.cli_aborts++;
1953 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001954 if (srv)
1955 srv->counters.cli_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01001956 s->flags |= SN_ERR_CLITO;
Willy Tarreauae526782010-03-04 20:34:23 +01001957 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001958 else if (s->req->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001959 s->be->be_counters.srv_aborts++;
1960 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001961 if (srv)
1962 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01001963 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01001964 }
1965 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001966 s->be->be_counters.srv_aborts++;
1967 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001968 if (srv)
1969 srv->counters.srv_aborts++;
Willy Tarreau84455332009-03-15 22:34:05 +01001970 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01001971 }
Willy Tarreau84455332009-03-15 22:34:05 +01001972 sess_set_term_flags(s);
1973 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001974 else if (s->rep->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001975 /* Report it if the server got an error or a read timeout expired */
1976 s->rep->analysers = 0;
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001977 if (s->rep->flags & CF_READ_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001978 s->be->be_counters.srv_aborts++;
1979 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001980 if (srv)
1981 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001982 s->flags |= SN_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01001983 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001984 else if (s->rep->flags & CF_READ_TIMEOUT) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001985 s->be->be_counters.srv_aborts++;
1986 s->fe->fe_counters.srv_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001987 if (srv)
1988 srv->counters.srv_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001989 s->flags |= SN_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01001990 }
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02001991 else if (s->rep->flags & CF_WRITE_ERROR) {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001992 s->be->be_counters.cli_aborts++;
1993 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01001994 if (srv)
1995 srv->counters.cli_aborts++;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001996 s->flags |= SN_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01001997 }
1998 else {
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01001999 s->be->be_counters.cli_aborts++;
2000 s->fe->fe_counters.cli_aborts++;
Willy Tarreau827aee92011-03-10 16:55:02 +01002001 if (srv)
2002 srv->counters.cli_aborts++;
Willy Tarreauae526782010-03-04 20:34:23 +01002003 s->flags |= SN_ERR_CLITO;
2004 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002005 sess_set_term_flags(s);
2006 }
Willy Tarreau84455332009-03-15 22:34:05 +01002007 }
2008
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002009 /*
2010 * Here we take care of forwarding unhandled data. This also includes
2011 * connection establishments and shutdown requests.
2012 */
2013
2014
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002015 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002016 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002017 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002018 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002019 */
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002020 if (!s->req->analysers &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002021 !(s->req->flags & (CF_HIJACK|CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau31971e52009-09-20 12:07:52 +02002022 (s->req->prod->state >= SI_ST_EST) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002023 (s->req->to_forward != CHN_INFINITE_FORWARD)) {
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002024 /* This buffer is freewheeling, there's no analyser nor hijacker
2025 * attached to it. If any data are left in, we'll permit them to
2026 * move.
2027 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002028 channel_auto_read(s->req);
2029 channel_auto_connect(s->req);
2030 channel_auto_close(s->req);
Willy Tarreaua75bcef2012-08-24 22:56:11 +02002031 buffer_flush(&s->req->buf);
Willy Tarreau5bd8c372009-01-19 00:32:22 +01002032
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002033 /* We'll let data flow between the producer (if still connected)
2034 * to the consumer (which might possibly not be connected yet).
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002035 */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002036 if (!(s->req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002037 channel_forward(s->req, CHN_INFINITE_FORWARD);
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002038 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002039
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002040 /* check if it is wise to enable kernel splicing to forward request data */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002041 if (!(s->req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002042 s->req->to_forward &&
2043 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02002044 (s->si[0].conn.xprt && s->si[0].conn.xprt->rcv_pipe && s->si[0].conn.xprt->snd_pipe) &&
2045 (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 +01002046 (pipes_used < global.maxpipes) &&
2047 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
2048 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002049 (s->req->flags & CF_STREAMER_FAST)))) {
2050 s->req->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002051 }
2052
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002053 /* reflect what the L7 analysers have seen last */
2054 rqf_last = s->req->flags;
2055
2056 /*
2057 * Now forward all shutdown requests between both sides of the buffer
2058 */
2059
Willy Tarreau520d95e2009-09-19 21:04:57 +02002060 /* first, let's check if the request buffer needs to shutdown(write), which may
2061 * happen either because the input is closed or because we want to force a close
Willy Tarreaue4599762010-03-21 23:25:09 +01002062 * once the server has begun to respond.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002063 */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002064 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_HIJACK|CF_AUTO_CLOSE|CF_SHUTR)) ==
2065 (CF_AUTO_CLOSE|CF_SHUTR)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002066 channel_shutw_now(s->req);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002067
2068 /* shutdown(write) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002069 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
Willy Tarreau8e21bb92012-08-24 22:40:29 +02002070 channel_is_empty(s->req)))
Willy Tarreau73b013b2012-05-21 16:31:45 +02002071 si_shutw(s->req->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002072
2073 /* shutdown(write) done on server side, we must stop the client too */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002074 if (unlikely((s->req->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
Willy Tarreau3dbc6942008-12-07 13:05:04 +01002075 !s->req->analysers))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002076 channel_shutr_now(s->req);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002077
2078 /* shutdown(read) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002079 if (unlikely((s->req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002080 if (s->req->prod->flags & SI_FL_NOHALF)
2081 s->req->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02002082 si_shutr(s->req->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002083 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002084
Willy Tarreau520d95e2009-09-19 21:04:57 +02002085 /* it's possible that an upper layer has requested a connection setup or abort.
2086 * There are 2 situations where we decide to establish a new connection :
2087 * - there are data scheduled for emission in the buffer
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002088 * - the CF_AUTO_CONNECT flag is set (active connection)
Willy Tarreau520d95e2009-09-19 21:04:57 +02002089 */
2090 if (s->req->cons->state == SI_ST_INI) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002091 if (!(s->req->flags & CF_SHUTW)) {
2092 if ((s->req->flags & CF_AUTO_CONNECT) || !channel_is_empty(s->req)) {
Willy Tarreaub24281b2011-02-13 13:16:36 +01002093 /* If we have an applet without a connect method, we immediately
Willy Tarreau85e7d002010-05-31 11:57:51 +02002094 * switch to the connected state, otherwise we perform a connection
2095 * request.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002096 */
Willy Tarreau85e7d002010-05-31 11:57:51 +02002097 s->req->cons->state = SI_ST_REQ; /* new connection requested */
Willy Tarreau070ceb62010-06-01 10:36:43 +02002098 s->req->cons->conn_retries = s->be->conn_retries;
Willy Tarreau3cefd522012-08-30 15:49:18 +02002099 if (unlikely(s->req->cons->conn.target.type == TARG_TYPE_APPLET &&
Willy Tarreau73b013b2012-05-21 16:31:45 +02002100 !(si_ctrl(s->req->cons) && si_ctrl(s->req->cons)->connect))) {
Willy Tarreau520d95e2009-09-19 21:04:57 +02002101 s->req->cons->state = SI_ST_EST; /* connection established */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002102 s->rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Willy Tarreau85e7d002010-05-31 11:57:51 +02002103 s->req->wex = TICK_ETERNITY;
2104 }
Willy Tarreau520d95e2009-09-19 21:04:57 +02002105 }
Willy Tarreau73201222009-08-16 18:27:24 +02002106 }
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002107 else {
Willy Tarreau92795622009-03-06 12:51:23 +01002108 s->req->cons->state = SI_ST_CLO; /* shutw+ini = abort */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002109 channel_shutw_now(s->req); /* fix buffer flags upon abort */
2110 channel_shutr_now(s->rep);
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002111 }
Willy Tarreau92795622009-03-06 12:51:23 +01002112 }
2113
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002114
2115 /* we may have a pending connection request, or a connection waiting
2116 * for completion.
2117 */
2118 if (s->si[1].state >= SI_ST_REQ && s->si[1].state < SI_ST_CON) {
2119 do {
2120 /* nb: step 1 might switch from QUE to ASS, but we first want
2121 * to give a chance to step 2 to perform a redirect if needed.
2122 */
2123 if (s->si[1].state != SI_ST_REQ)
2124 sess_update_stream_int(s, &s->si[1]);
2125 if (s->si[1].state == SI_ST_REQ)
2126 sess_prepare_conn_req(s, &s->si[1]);
2127
Willy Tarreau827aee92011-03-10 16:55:02 +01002128 srv = target_srv(&s->target);
2129 if (s->si[1].state == SI_ST_ASS && srv && srv->rdr_len && (s->flags & SN_REDIRECTABLE))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002130 perform_http_redirect(s, &s->si[1]);
2131 } while (s->si[1].state == SI_ST_ASS);
Mark Lamourinec2247f02012-01-04 13:02:01 -05002132
2133 /* Now we can add the server name to a header (if requested) */
2134 /* check for HTTP mode and proxy server_name_hdr_name != NULL */
Stathis Voukelatos09a030a2012-01-09 14:27:13 +01002135 if ((s->flags & SN_BE_ASSIGNED) &&
Willy Tarreau45c0d982012-03-09 12:11:57 +01002136 (s->be->mode == PR_MODE_HTTP) &&
2137 (s->be->server_id_hdr_name != NULL)) {
2138 http_send_name_header(&s->txn, s->be, target_srv(&s->target)->id);
Mark Lamourinec2247f02012-01-04 13:02:01 -05002139 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002140 }
2141
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002142 /* Benchmarks have shown that it's optimal to do a full resync now */
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002143 if (s->req->prod->state == SI_ST_DIS || s->req->cons->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002144 goto resync_stream_interface;
2145
Willy Tarreau815a9b22010-07-27 17:15:12 +02002146 /* otherwise we want to check if we need to resync the req buffer or not */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002147 if ((s->req->flags ^ rqf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002148 goto resync_request;
2149
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002150 /* perform output updates to the response buffer */
Willy Tarreau84455332009-03-15 22:34:05 +01002151
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002152 /* If noone is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002153 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002154 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002155 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002156 */
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002157 if (!s->rep->analysers &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002158 !(s->rep->flags & (CF_HIJACK|CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau31971e52009-09-20 12:07:52 +02002159 (s->rep->prod->state >= SI_ST_EST) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002160 (s->rep->to_forward != CHN_INFINITE_FORWARD)) {
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002161 /* This buffer is freewheeling, there's no analyser nor hijacker
2162 * attached to it. If any data are left in, we'll permit them to
2163 * move.
2164 */
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002165 channel_auto_read(s->rep);
2166 channel_auto_close(s->rep);
Willy Tarreaua75bcef2012-08-24 22:56:11 +02002167 buffer_flush(&s->rep->buf);
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002168
2169 /* We'll let data flow between the producer (if still connected)
2170 * to the consumer.
2171 */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002172 if (!(s->rep->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002173 channel_forward(s->rep, CHN_INFINITE_FORWARD);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002174
2175 /* if we have no analyser anymore in any direction and have a
2176 * tunnel timeout set, use it now.
2177 */
2178 if (!s->req->analysers && s->be->timeout.tunnel) {
2179 s->req->rto = s->req->wto = s->rep->rto = s->rep->wto =
2180 s->be->timeout.tunnel;
2181 s->req->rex = s->req->wex = s->rep->rex = s->rep->wex =
2182 tick_add(now_ms, s->be->timeout.tunnel);
2183 }
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002184 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002185
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002186 /* check if it is wise to enable kernel splicing to forward response data */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002187 if (!(s->rep->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002188 s->rep->to_forward &&
2189 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02002190 (s->si[0].conn.xprt && s->si[0].conn.xprt->rcv_pipe && s->si[0].conn.xprt->snd_pipe) &&
2191 (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 +01002192 (pipes_used < global.maxpipes) &&
2193 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
2194 (((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002195 (s->rep->flags & CF_STREAMER_FAST)))) {
2196 s->rep->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002197 }
2198
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002199 /* reflect what the L7 analysers have seen last */
2200 rpf_last = s->rep->flags;
2201
2202 /*
2203 * Now forward all shutdown requests between both sides of the buffer
2204 */
2205
2206 /*
2207 * FIXME: this is probably where we should produce error responses.
2208 */
2209
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002210 /* first, let's check if the response buffer needs to shutdown(write) */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002211 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_HIJACK|CF_AUTO_CLOSE|CF_SHUTR)) ==
2212 (CF_AUTO_CLOSE|CF_SHUTR)))
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002213 channel_shutw_now(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002214
2215 /* shutdown(write) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002216 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
Willy Tarreau8e21bb92012-08-24 22:40:29 +02002217 channel_is_empty(s->rep)))
Willy Tarreau73b013b2012-05-21 16:31:45 +02002218 si_shutw(s->rep->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002219
2220 /* shutdown(write) done on the client side, we must stop the server too */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002221 if (unlikely((s->rep->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
Willy Tarreau3dbc6942008-12-07 13:05:04 +01002222 !s->rep->analysers)
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002223 channel_shutr_now(s->rep);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002224
2225 /* shutdown(read) pending */
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002226 if (unlikely((s->rep->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002227 if (s->rep->prod->flags & SI_FL_NOHALF)
2228 s->rep->prod->flags |= SI_FL_NOLINGER;
Willy Tarreau73b013b2012-05-21 16:31:45 +02002229 si_shutr(s->rep->prod);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002230 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002231
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002232 if (s->req->prod->state == SI_ST_DIS || s->req->cons->state == SI_ST_DIS)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002233 goto resync_stream_interface;
2234
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002235 if (s->req->flags != rqf_last)
2236 goto resync_request;
2237
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002238 if ((s->rep->flags ^ rpf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002239 goto resync_response;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002240
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002241 /* we're interested in getting wakeups again */
2242 s->req->prod->flags &= ~SI_FL_DONT_WAKE;
2243 s->req->cons->flags &= ~SI_FL_DONT_WAKE;
2244
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002245 /* This is needed only when debugging is enabled, to indicate
2246 * client-side or server-side close. Please note that in the unlikely
2247 * event where both sides would close at once, the sequence is reported
2248 * on the server side first.
2249 */
2250 if (unlikely((global.mode & MODE_DEBUG) &&
2251 (!(global.mode & MODE_QUIET) ||
2252 (global.mode & MODE_VERBOSE)))) {
2253 int len;
2254
2255 if (s->si[1].state == SI_ST_CLO &&
2256 s->si[1].prev_state == SI_ST_EST) {
2257 len = sprintf(trash, "%08x:%s.srvcls[%04x:%04x]\n",
2258 s->uniq_id, s->be->id,
Willy Tarreaufb7508a2012-05-21 16:47:54 +02002259 (unsigned short)si_fd(&s->si[0]),
2260 (unsigned short)si_fd(&s->si[1]));
Willy Tarreau21337822012-04-29 14:11:38 +02002261 if (write(1, trash, len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002262 }
2263
2264 if (s->si[0].state == SI_ST_CLO &&
2265 s->si[0].prev_state == SI_ST_EST) {
2266 len = sprintf(trash, "%08x:%s.clicls[%04x:%04x]\n",
2267 s->uniq_id, s->be->id,
Willy Tarreaufb7508a2012-05-21 16:47:54 +02002268 (unsigned short)si_fd(&s->si[0]),
2269 (unsigned short)si_fd(&s->si[1]));
Willy Tarreau21337822012-04-29 14:11:38 +02002270 if (write(1, trash, len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002271 }
2272 }
2273
2274 if (likely((s->rep->cons->state != SI_ST_CLO) ||
2275 (s->req->cons->state > SI_ST_INI && s->req->cons->state < SI_ST_CLO))) {
2276
2277 if ((s->fe->options & PR_O_CONTSTATS) && (s->flags & SN_BE_ASSIGNED))
2278 session_process_counters(s);
2279
Willy Tarreau3cefd522012-08-30 15:49:18 +02002280 if (s->rep->cons->state == SI_ST_EST && s->rep->cons->conn.target.type != TARG_TYPE_APPLET)
Willy Tarreau73b013b2012-05-21 16:31:45 +02002281 si_update(s->rep->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002282
Willy Tarreau3cefd522012-08-30 15:49:18 +02002283 if (s->req->cons->state == SI_ST_EST && s->req->cons->conn.target.type != TARG_TYPE_APPLET)
Willy Tarreau73b013b2012-05-21 16:31:45 +02002284 si_update(s->req->cons);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002285
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002286 s->req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_WRITE_NULL|CF_WRITE_PARTIAL|CF_READ_ATTACHED);
2287 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 +01002288 s->si[0].prev_state = s->si[0].state;
2289 s->si[1].prev_state = s->si[1].state;
Willy Tarreaub0ef7352008-12-14 13:26:20 +01002290 s->si[0].flags &= ~(SI_FL_ERR|SI_FL_EXP);
2291 s->si[1].flags &= ~(SI_FL_ERR|SI_FL_EXP);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002292
2293 /* Trick: if a request is being waiting for the server to respond,
2294 * and if we know the server can timeout, we don't want the timeout
2295 * to expire on the client side first, but we're still interested
2296 * in passing data from the client to the server (eg: POST). Thus,
2297 * we can cancel the client's request timeout if the server's
2298 * request timeout is set and the server has not yet sent a response.
2299 */
2300
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002301 if ((s->rep->flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
Willy Tarreau86491c32008-12-14 09:04:47 +01002302 (tick_isset(s->req->wex) || tick_isset(s->rep->rex))) {
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002303 s->req->flags |= CF_READ_NOEXP;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002304 s->req->rex = TICK_ETERNITY;
Willy Tarreau86491c32008-12-14 09:04:47 +01002305 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002306
Willy Tarreau7a20aa62010-07-13 16:30:45 +02002307 /* Call the stream interfaces' I/O handlers when embedded.
Willy Tarreau1accfc02009-09-05 20:57:35 +02002308 * Note that this one may wake the task up again.
2309 */
Willy Tarreau3cefd522012-08-30 15:49:18 +02002310 if (s->req->cons->conn.target.type == TARG_TYPE_APPLET ||
2311 s->rep->cons->conn.target.type == TARG_TYPE_APPLET) {
2312 if (s->req->cons->conn.target.type == TARG_TYPE_APPLET)
2313 s->req->cons->conn.target.ptr.a->fct(s->req->cons);
2314 if (s->rep->cons->conn.target.type == TARG_TYPE_APPLET)
2315 s->rep->cons->conn.target.ptr.a->fct(s->rep->cons);
Willy Tarreau1accfc02009-09-05 20:57:35 +02002316 if (task_in_rq(t)) {
2317 /* If we woke up, we don't want to requeue the
2318 * task to the wait queue, but rather requeue
2319 * it into the runqueue ASAP.
2320 */
2321 t->expire = TICK_ETERNITY;
2322 return t;
2323 }
2324 }
2325
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002326 t->expire = tick_first(tick_first(s->req->rex, s->req->wex),
2327 tick_first(s->rep->rex, s->rep->wex));
2328 if (s->req->analysers)
2329 t->expire = tick_first(t->expire, s->req->analyse_exp);
2330
2331 if (s->si[0].exp)
2332 t->expire = tick_first(t->expire, s->si[0].exp);
2333
2334 if (s->si[1].exp)
2335 t->expire = tick_first(t->expire, s->si[1].exp);
2336
2337#ifdef DEBUG_FULL
Willy Tarreau127334e2009-03-28 10:47:26 +01002338 fprintf(stderr,
2339 "[%u] queuing with exp=%u req->rex=%u req->wex=%u req->ana_exp=%u"
2340 " rep->rex=%u rep->wex=%u, si[0].exp=%u, si[1].exp=%u, cs=%d, ss=%d\n",
2341 now_ms, t->expire, s->req->rex, s->req->wex, s->req->analyse_exp,
2342 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 +01002343#endif
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002344
2345#ifdef DEBUG_DEV
2346 /* this may only happen when no timeout is set or in case of an FSM bug */
Willy Tarreaud0a201b2009-03-08 15:53:06 +01002347 if (!tick_isset(t->expire))
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002348 ABORT_NOW();
2349#endif
Willy Tarreau26c25062009-03-08 09:38:41 +01002350 return t; /* nothing more to do */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002351 }
2352
2353 s->fe->feconn--;
2354 if (s->flags & SN_BE_ASSIGNED)
2355 s->be->beconn--;
Willy Tarreau3c63fd82011-09-07 18:00:47 +02002356 if (!(s->listener->options & LI_O_UNLIMITED))
2357 actconn--;
Willy Tarreauaf7ad002010-08-31 15:39:26 +02002358 jobs--;
Willy Tarreau6e6fb2b2009-08-16 18:20:44 +02002359 s->listener->nbconn--;
Willy Tarreau62793712011-07-24 19:23:38 +02002360 if (s->listener->state == LI_FULL)
2361 resume_listener(s->listener);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002362
Willy Tarreau08ceb102011-07-24 22:58:00 +02002363 /* Dequeues all of the listeners waiting for a resource */
2364 if (!LIST_ISEMPTY(&global_listener_queue))
2365 dequeue_all_listeners(&global_listener_queue);
2366
Willy Tarreaub32907b2011-07-25 08:37:44 +02002367 if (!LIST_ISEMPTY(&s->fe->listener_queue) &&
2368 (!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 +02002369 dequeue_all_listeners(&s->fe->listener_queue);
2370
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002371 if (unlikely((global.mode & MODE_DEBUG) &&
2372 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
2373 int len;
Willy Tarreauec22b2c2009-03-06 13:07:40 +01002374 len = sprintf(trash, "%08x:%s.closed[%04x:%04x]\n",
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002375 s->uniq_id, s->be->id,
Willy Tarreaufb7508a2012-05-21 16:47:54 +02002376 (unsigned short)si_fd(s->req->prod), (unsigned short)si_fd(s->req->cons));
Willy Tarreau21337822012-04-29 14:11:38 +02002377 if (write(1, trash, len) < 0) /* shut gcc warning */;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002378 }
2379
2380 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2381 session_process_counters(s);
2382
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002383 if (s->txn.status) {
2384 int n;
2385
2386 n = s->txn.status / 100;
2387 if (n < 1 || n > 5)
2388 n = 0;
2389
2390 if (s->fe->mode == PR_MODE_HTTP)
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002391 s->fe->fe_counters.p.http.rsp[n]++;
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002392
Willy Tarreau24657792010-02-26 10:30:28 +01002393 if ((s->flags & SN_BE_ASSIGNED) &&
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002394 (s->be->mode == PR_MODE_HTTP))
Willy Tarreau7d0aaf32011-03-10 23:25:56 +01002395 s->be->be_counters.p.http.rsp[n]++;
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002396 }
2397
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002398 /* let's do a final log if we need it */
2399 if (s->logs.logwait &&
2400 !(s->flags & SN_MONITOR) &&
2401 (!(s->fe->options & PR_O_NULLNOLOG) || s->req->total)) {
Willy Tarreaua5555ec2008-11-30 19:02:32 +01002402 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002403 }
2404
2405 /* the task MUST not be in the run queue anymore */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002406 session_free(s);
Willy Tarreau26c25062009-03-08 09:38:41 +01002407 task_delete(t);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002408 task_free(t);
Willy Tarreau26c25062009-03-08 09:38:41 +01002409 return NULL;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002410}
2411
Willy Tarreau7c669d72008-06-20 15:04:11 +02002412/*
2413 * This function adjusts sess->srv_conn and maintains the previous and new
2414 * server's served session counts. Setting newsrv to NULL is enough to release
2415 * current connection slot. This function also notifies any LB algo which might
2416 * expect to be informed about any change in the number of active sessions on a
2417 * server.
2418 */
2419void sess_change_server(struct session *sess, struct server *newsrv)
2420{
2421 if (sess->srv_conn == newsrv)
2422 return;
2423
2424 if (sess->srv_conn) {
2425 sess->srv_conn->served--;
2426 if (sess->srv_conn->proxy->lbprm.server_drop_conn)
2427 sess->srv_conn->proxy->lbprm.server_drop_conn(sess->srv_conn);
Simon Hormanaf514952011-06-21 14:34:57 +09002428 session_del_srv_conn(sess);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002429 }
2430
2431 if (newsrv) {
2432 newsrv->served++;
2433 if (newsrv->proxy->lbprm.server_take_conn)
2434 newsrv->proxy->lbprm.server_take_conn(newsrv);
Simon Hormanaf514952011-06-21 14:34:57 +09002435 session_add_srv_conn(sess, newsrv);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002436 }
2437}
2438
Willy Tarreau84455332009-03-15 22:34:05 +01002439/* Handle server-side errors for default protocols. It is called whenever a a
2440 * connection setup is aborted or a request is aborted in queue. It sets the
2441 * session termination flags so that the caller does not have to worry about
2442 * them. It's installed as ->srv_error for the server-side stream_interface.
2443 */
2444void default_srv_error(struct session *s, struct stream_interface *si)
2445{
2446 int err_type = si->err_type;
2447 int err = 0, fin = 0;
2448
2449 if (err_type & SI_ET_QUEUE_ABRT) {
2450 err = SN_ERR_CLICL;
2451 fin = SN_FINST_Q;
2452 }
2453 else if (err_type & SI_ET_CONN_ABRT) {
2454 err = SN_ERR_CLICL;
2455 fin = SN_FINST_C;
2456 }
2457 else if (err_type & SI_ET_QUEUE_TO) {
2458 err = SN_ERR_SRVTO;
2459 fin = SN_FINST_Q;
2460 }
2461 else if (err_type & SI_ET_QUEUE_ERR) {
2462 err = SN_ERR_SRVCL;
2463 fin = SN_FINST_Q;
2464 }
2465 else if (err_type & SI_ET_CONN_TO) {
2466 err = SN_ERR_SRVTO;
2467 fin = SN_FINST_C;
2468 }
2469 else if (err_type & SI_ET_CONN_ERR) {
2470 err = SN_ERR_SRVCL;
2471 fin = SN_FINST_C;
2472 }
2473 else /* SI_ET_CONN_OTHER and others */ {
2474 err = SN_ERR_INTERNAL;
2475 fin = SN_FINST_C;
2476 }
2477
2478 if (!(s->flags & SN_ERR_MASK))
2479 s->flags |= err;
2480 if (!(s->flags & SN_FINST_MASK))
2481 s->flags |= fin;
2482}
Willy Tarreau7c669d72008-06-20 15:04:11 +02002483
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002484/* kill a session and set the termination flags to <why> (one of SN_ERR_*) */
2485void session_shutdown(struct session *session, int why)
2486{
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002487 if (session->req->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002488 return;
2489
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002490 channel_shutw_now(session->req);
2491 channel_shutr_now(session->rep);
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002492 session->task->nice = 1024;
2493 if (!(session->flags & SN_ERR_MASK))
2494 session->flags |= why;
2495 task_wakeup(session->task, TASK_WOKEN_OTHER);
2496}
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02002497
Willy Tarreau8b22a712010-06-18 17:46:06 +02002498/************************************************************************/
2499/* All supported ACL keywords must be declared here. */
2500/************************************************************************/
2501
Willy Tarreaua5e37562011-12-16 17:06:15 +01002502/* set temp integer to the General Purpose Counter 0 value in the stksess entry <ts> */
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002503static int
Willy Tarreau37406352012-04-23 16:16:37 +02002504acl_fetch_get_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002505{
Willy Tarreau37406352012-04-23 16:16:37 +02002506 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002507 smp->type = SMP_T_UINT;
2508 smp->data.uint = 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002509 if (ts != NULL) {
2510 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2511 if (!ptr)
2512 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002513 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002514 }
2515 return 1;
2516}
2517
Willy Tarreaua5e37562011-12-16 17:06:15 +01002518/* set temp integer to the General Purpose Counter 0 value from the session's tracked
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002519 * frontend counters.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002520 */
2521static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002522acl_fetch_sc1_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002523 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002524{
Willy Tarreau56123282010-08-06 19:06:56 +02002525 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002526 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002527 return acl_fetch_get_gpc0(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002528}
2529
Willy Tarreaua5e37562011-12-16 17:06:15 +01002530/* set temp integer to the General Purpose Counter 0 value from the session's tracked
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002531 * backend counters.
2532 */
2533static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002534acl_fetch_sc2_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002535 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002536{
Willy Tarreau56123282010-08-06 19:06:56 +02002537 if (!l4->stkctr2_entry)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002538 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002539 return acl_fetch_get_gpc0(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002540}
2541
Willy Tarreaua5e37562011-12-16 17:06:15 +01002542/* set temp integer to the General Purpose Counter 0 value from the session's source
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002543 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002544 * Accepts exactly 1 argument of type table.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002545 */
2546static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002547acl_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002548 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002549{
2550 struct stktable_key *key;
2551
Willy Tarreau64ee4912012-08-30 22:59:48 +02002552 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002553 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002554 return 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002555
Willy Tarreau24e32d82012-04-23 23:55:44 +02002556 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002557 return acl_fetch_get_gpc0(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002558}
2559
2560/* Increment the General Purpose Counter 0 value in the stksess entry <ts> and
Willy Tarreaua5e37562011-12-16 17:06:15 +01002561 * return it into temp integer.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002562 */
2563static int
Willy Tarreau37406352012-04-23 16:16:37 +02002564acl_fetch_inc_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002565{
Willy Tarreau37406352012-04-23 16:16:37 +02002566 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002567 smp->type = SMP_T_UINT;
2568 smp->data.uint = 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002569 if (ts != NULL) {
2570 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2571 if (!ptr)
2572 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002573 smp->data.uint = ++stktable_data_cast(ptr, gpc0);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002574 }
2575 return 1;
2576}
2577
2578/* Increment the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002579 * frontend counters and return it into temp integer.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002580 */
2581static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002582acl_fetch_sc1_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002583 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002584{
Willy Tarreau56123282010-08-06 19:06:56 +02002585 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002586 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002587 return acl_fetch_inc_gpc0(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002588}
2589
2590/* Increment the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002591 * backend counters and return it into temp integer.
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002592 */
2593static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002594acl_fetch_sc2_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002595 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002596{
Willy Tarreau56123282010-08-06 19:06:56 +02002597 if (!l4->stkctr2_entry)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002598 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002599 return acl_fetch_inc_gpc0(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002600}
2601
2602/* Increment the General Purpose Counter 0 value from the session's source
Willy Tarreaua5e37562011-12-16 17:06:15 +01002603 * address in the table pointed to by expr, and return it into temp integer.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002604 * Accepts exactly 1 argument of type table.
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002605 */
2606static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002607acl_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002608 const struct arg *args, struct sample *smp)
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002609{
2610 struct stktable_key *key;
2611
Willy Tarreau64ee4912012-08-30 22:59:48 +02002612 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002613 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002614 return 0;
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002615
Willy Tarreau24e32d82012-04-23 23:55:44 +02002616 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002617 return acl_fetch_inc_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
Willy Tarreauc3bd9722010-06-20 12:47:25 +02002618}
2619
Willy Tarreauf73cd112011-08-13 01:45:16 +02002620/* Clear the General Purpose Counter 0 value in the stksess entry <ts> and
Willy Tarreaua5e37562011-12-16 17:06:15 +01002621 * return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002622 */
2623static int
Willy Tarreau37406352012-04-23 16:16:37 +02002624acl_fetch_clr_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002625{
Willy Tarreau37406352012-04-23 16:16:37 +02002626 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002627 smp->type = SMP_T_UINT;
2628 smp->data.uint = 0;
Willy Tarreauf73cd112011-08-13 01:45:16 +02002629 if (ts != NULL) {
2630 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_GPC0);
2631 if (!ptr)
2632 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002633 smp->data.uint = stktable_data_cast(ptr, gpc0);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002634 stktable_data_cast(ptr, gpc0) = 0;
2635 }
2636 return 1;
2637}
2638
2639/* Clear the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002640 * frontend counters and return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002641 */
2642static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002643acl_fetch_sc1_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002644 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002645{
2646 if (!l4->stkctr1_entry)
2647 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002648 return acl_fetch_clr_gpc0(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002649}
2650
2651/* Clear the General Purpose Counter 0 value from the session's tracked
Willy Tarreaua5e37562011-12-16 17:06:15 +01002652 * backend counters and return its previous value into temp integer.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002653 */
2654static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002655acl_fetch_sc2_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002656 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002657{
2658 if (!l4->stkctr2_entry)
2659 return 0;
Willy Tarreau37406352012-04-23 16:16:37 +02002660 return acl_fetch_clr_gpc0(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002661}
2662
2663/* Clear the General Purpose Counter 0 value from the session's source address
Willy Tarreaua5e37562011-12-16 17:06:15 +01002664 * in the table pointed to by expr, and return its previous value into temp integer.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002665 * Accepts exactly 1 argument of type table.
Willy Tarreauf73cd112011-08-13 01:45:16 +02002666 */
2667static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002668acl_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002669 const struct arg *args, struct sample *smp)
Willy Tarreauf73cd112011-08-13 01:45:16 +02002670{
2671 struct stktable_key *key;
2672
Willy Tarreau64ee4912012-08-30 22:59:48 +02002673 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauf73cd112011-08-13 01:45:16 +02002674 if (!key)
2675 return 0;
2676
Willy Tarreau24e32d82012-04-23 23:55:44 +02002677 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002678 return acl_fetch_clr_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
Willy Tarreauf73cd112011-08-13 01:45:16 +02002679}
2680
Willy Tarreaua5e37562011-12-16 17:06:15 +01002681/* set temp integer to the cumulated number of connections in the stksess entry <ts> */
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002682static int
Willy Tarreau37406352012-04-23 16:16:37 +02002683acl_fetch_conn_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002684{
Willy Tarreau37406352012-04-23 16:16:37 +02002685 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002686 smp->type = SMP_T_UINT;
2687 smp->data.uint = 0;
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002688 if (ts != NULL) {
2689 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_CNT);
2690 if (!ptr)
2691 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002692 smp->data.uint = stktable_data_cast(ptr, conn_cnt);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002693 }
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002694 return 1;
2695}
2696
Willy Tarreaua5e37562011-12-16 17:06:15 +01002697/* set temp integer to the cumulated number of connections from the session's tracked FE counters */
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002698static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002699acl_fetch_sc1_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002700 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002701{
Willy Tarreau56123282010-08-06 19:06:56 +02002702 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002703 return 0;
2704
Willy Tarreau37406352012-04-23 16:16:37 +02002705 return acl_fetch_conn_cnt(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002706}
2707
Willy Tarreaua5e37562011-12-16 17:06:15 +01002708/* set temp integer to the cumulated number of connections from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002709static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002710acl_fetch_sc2_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002711 const struct arg *args, struct sample *smp)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002712{
Willy Tarreau56123282010-08-06 19:06:56 +02002713 if (!l4->stkctr2_entry)
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002714 return 0;
2715
Willy Tarreau37406352012-04-23 16:16:37 +02002716 return acl_fetch_conn_cnt(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002717}
2718
Willy Tarreaua5e37562011-12-16 17:06:15 +01002719/* set temp integer to the cumulated number of connections from the session's source
Willy Tarreau9a3f8492010-06-18 19:53:25 +02002720 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002721 * Accepts exactly 1 argument of type table.
Willy Tarreau8b22a712010-06-18 17:46:06 +02002722 */
2723static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002724acl_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002725 const struct arg *args, struct sample *smp)
Willy Tarreau8b22a712010-06-18 17:46:06 +02002726{
Willy Tarreau8b22a712010-06-18 17:46:06 +02002727 struct stktable_key *key;
2728
Willy Tarreau64ee4912012-08-30 22:59:48 +02002729 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau8b22a712010-06-18 17:46:06 +02002730 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002731 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002732
Willy Tarreau24e32d82012-04-23 23:55:44 +02002733 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002734 return acl_fetch_conn_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau8b22a712010-06-18 17:46:06 +02002735}
2736
Willy Tarreaua5e37562011-12-16 17:06:15 +01002737/* set temp integer to the connection rate in the stksess entry <ts> over the configured period */
Willy Tarreau91c43d72010-06-20 11:19:22 +02002738static int
Willy Tarreau37406352012-04-23 16:16:37 +02002739acl_fetch_conn_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002740{
Willy Tarreau37406352012-04-23 16:16:37 +02002741 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002742 smp->type = SMP_T_UINT;
2743 smp->data.uint = 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002744 if (ts != NULL) {
2745 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_RATE);
2746 if (!ptr)
2747 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002748 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
Willy Tarreau91c43d72010-06-20 11:19:22 +02002749 table->data_arg[STKTABLE_DT_CONN_RATE].u);
2750 }
2751 return 1;
2752}
2753
Willy Tarreaua5e37562011-12-16 17:06:15 +01002754/* set temp integer to the connection rate from the session's tracked FE counters over
Willy Tarreau91c43d72010-06-20 11:19:22 +02002755 * the configured period.
2756 */
2757static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002758acl_fetch_sc1_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002759 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002760{
Willy Tarreau56123282010-08-06 19:06:56 +02002761 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002762 return 0;
2763
Willy Tarreau37406352012-04-23 16:16:37 +02002764 return acl_fetch_conn_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002765}
2766
Willy Tarreaua5e37562011-12-16 17:06:15 +01002767/* set temp integer to the connection rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002768 * the configured period.
2769 */
2770static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002771acl_fetch_sc2_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002772 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002773{
Willy Tarreau56123282010-08-06 19:06:56 +02002774 if (!l4->stkctr2_entry)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002775 return 0;
2776
Willy Tarreau37406352012-04-23 16:16:37 +02002777 return acl_fetch_conn_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002778}
2779
Willy Tarreaua5e37562011-12-16 17:06:15 +01002780/* set temp integer to the connection rate from the session's source address in the
Willy Tarreau91c43d72010-06-20 11:19:22 +02002781 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002782 * Accepts exactly 1 argument of type table.
Willy Tarreau91c43d72010-06-20 11:19:22 +02002783 */
2784static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002785acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002786 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002787{
2788 struct stktable_key *key;
2789
Willy Tarreau64ee4912012-08-30 22:59:48 +02002790 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002791 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002792 return 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002793
Willy Tarreau24e32d82012-04-23 23:55:44 +02002794 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002795 return acl_fetch_conn_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau91c43d72010-06-20 11:19:22 +02002796}
2797
Willy Tarreaua5e37562011-12-16 17:06:15 +01002798/* set temp integer to the number of connections from the session's source address
Willy Tarreau8b22a712010-06-18 17:46:06 +02002799 * in the table pointed to by expr, after updating it.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002800 * Accepts exactly 1 argument of type table.
Willy Tarreau8b22a712010-06-18 17:46:06 +02002801 */
2802static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002803acl_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002804 const struct arg *args, struct sample *smp)
Willy Tarreau8b22a712010-06-18 17:46:06 +02002805{
2806 struct stksess *ts;
2807 struct stktable_key *key;
2808 void *ptr;
2809
Willy Tarreau64ee4912012-08-30 22:59:48 +02002810 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau8b22a712010-06-18 17:46:06 +02002811 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002812 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002813
Willy Tarreau24e32d82012-04-23 23:55:44 +02002814 px = args->data.prx;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002815
Willy Tarreau1f7e9252010-06-20 12:27:21 +02002816 if ((ts = stktable_update_key(&px->table, key)) == NULL)
2817 /* entry does not exist and could not be created */
2818 return 0;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002819
2820 ptr = stktable_data_ptr(&px->table, ts, STKTABLE_DT_CONN_CNT);
2821 if (!ptr)
2822 return 0; /* parameter not stored in this table */
2823
Willy Tarreauf853c462012-04-23 18:53:56 +02002824 smp->type = SMP_T_UINT;
2825 smp->data.uint = ++stktable_data_cast(ptr, conn_cnt);
Willy Tarreau37406352012-04-23 16:16:37 +02002826 smp->flags = SMP_F_VOL_TEST;
Willy Tarreau8b22a712010-06-18 17:46:06 +02002827 return 1;
2828}
2829
Willy Tarreaua5e37562011-12-16 17:06:15 +01002830/* set temp integer to the number of concurrent connections in the stksess entry <ts> */
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002831static int
Willy Tarreau37406352012-04-23 16:16:37 +02002832acl_fetch_conn_cur(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002833{
Willy Tarreau37406352012-04-23 16:16:37 +02002834 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002835 smp->type = SMP_T_UINT;
2836 smp->data.uint = 0;
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002837
2838 if (ts != NULL) {
2839 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_CONN_CUR);
2840 if (!ptr)
2841 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002842 smp->data.uint = stktable_data_cast(ptr, conn_cur);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002843 }
2844 return 1;
2845}
2846
Willy Tarreaua5e37562011-12-16 17:06:15 +01002847/* set temp integer to the number of concurrent connections from the session's tracked FE counters */
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002848static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002849acl_fetch_sc1_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002850 const struct arg *args, struct sample *smp)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002851{
Willy Tarreau56123282010-08-06 19:06:56 +02002852 if (!l4->stkctr1_entry)
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002853 return 0;
2854
Willy Tarreau37406352012-04-23 16:16:37 +02002855 return acl_fetch_conn_cur(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreau9b0ddcf2010-06-18 21:14:36 +02002856}
2857
Willy Tarreaua5e37562011-12-16 17:06:15 +01002858/* set temp integer to the number of concurrent connections from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002859static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002860acl_fetch_sc2_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002861 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002862{
Willy Tarreau56123282010-08-06 19:06:56 +02002863 if (!l4->stkctr2_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002864 return 0;
2865
Willy Tarreau37406352012-04-23 16:16:37 +02002866 return acl_fetch_conn_cur(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002867}
2868
Willy Tarreaua5e37562011-12-16 17:06:15 +01002869/* set temp integer to the number of concurrent connections from the session's source
Willy Tarreau38285c12010-06-18 16:35:43 +02002870 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002871 * Accepts exactly 1 argument of type table.
Willy Tarreau38285c12010-06-18 16:35:43 +02002872 */
2873static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002874acl_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002875 const struct arg *args, struct sample *smp)
Willy Tarreau38285c12010-06-18 16:35:43 +02002876{
Willy Tarreau38285c12010-06-18 16:35:43 +02002877 struct stktable_key *key;
2878
Willy Tarreau64ee4912012-08-30 22:59:48 +02002879 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau38285c12010-06-18 16:35:43 +02002880 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002881 return 0;
Willy Tarreau38285c12010-06-18 16:35:43 +02002882
Willy Tarreau24e32d82012-04-23 23:55:44 +02002883 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002884 return acl_fetch_conn_cur(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau38285c12010-06-18 16:35:43 +02002885}
2886
Willy Tarreaua5e37562011-12-16 17:06:15 +01002887/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002888static int
Willy Tarreau37406352012-04-23 16:16:37 +02002889acl_fetch_sess_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002890{
Willy Tarreau37406352012-04-23 16:16:37 +02002891 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002892 smp->type = SMP_T_UINT;
2893 smp->data.uint = 0;
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002894 if (ts != NULL) {
2895 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_SESS_CNT);
2896 if (!ptr)
2897 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002898 smp->data.uint = stktable_data_cast(ptr, sess_cnt);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002899 }
2900 return 1;
2901}
2902
Willy Tarreaua5e37562011-12-16 17:06:15 +01002903/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002904static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002905acl_fetch_sc1_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002906 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002907{
Willy Tarreau56123282010-08-06 19:06:56 +02002908 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002909 return 0;
2910
Willy Tarreau37406352012-04-23 16:16:37 +02002911 return acl_fetch_sess_cnt(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002912}
2913
Willy Tarreaua5e37562011-12-16 17:06:15 +01002914/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002915static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002916acl_fetch_sc2_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002917 const struct arg *args, struct sample *smp)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002918{
Willy Tarreau56123282010-08-06 19:06:56 +02002919 if (!l4->stkctr2_entry)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002920 return 0;
2921
Willy Tarreau37406352012-04-23 16:16:37 +02002922 return acl_fetch_sess_cnt(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002923}
2924
Willy Tarreaua5e37562011-12-16 17:06:15 +01002925/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002926 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002927 * Accepts exactly 1 argument of type table.
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002928 */
2929static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002930acl_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002931 const struct arg *args, struct sample *smp)
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002932{
2933 struct stktable_key *key;
2934
Willy Tarreau64ee4912012-08-30 22:59:48 +02002935 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002936 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002937 return 0;
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002938
Willy Tarreau24e32d82012-04-23 23:55:44 +02002939 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02002940 return acl_fetch_sess_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauf4d17d92010-06-18 22:10:12 +02002941}
2942
Willy Tarreaua5e37562011-12-16 17:06:15 +01002943/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreau91c43d72010-06-20 11:19:22 +02002944static int
Willy Tarreau37406352012-04-23 16:16:37 +02002945acl_fetch_sess_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002946{
Willy Tarreau37406352012-04-23 16:16:37 +02002947 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02002948 smp->type = SMP_T_UINT;
2949 smp->data.uint = 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002950 if (ts != NULL) {
2951 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_SESS_RATE);
2952 if (!ptr)
2953 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02002954 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
Willy Tarreau91c43d72010-06-20 11:19:22 +02002955 table->data_arg[STKTABLE_DT_SESS_RATE].u);
2956 }
2957 return 1;
2958}
2959
Willy Tarreaua5e37562011-12-16 17:06:15 +01002960/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002961 * the configured period.
2962 */
2963static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002964acl_fetch_sc1_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002965 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002966{
Willy Tarreau56123282010-08-06 19:06:56 +02002967 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002968 return 0;
2969
Willy Tarreau37406352012-04-23 16:16:37 +02002970 return acl_fetch_sess_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02002971}
2972
Willy Tarreaua5e37562011-12-16 17:06:15 +01002973/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreau91c43d72010-06-20 11:19:22 +02002974 * the configured period.
2975 */
2976static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002977acl_fetch_sc2_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002978 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002979{
Willy Tarreau56123282010-08-06 19:06:56 +02002980 if (!l4->stkctr2_entry)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002981 return 0;
2982
Willy Tarreau37406352012-04-23 16:16:37 +02002983 return acl_fetch_sess_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002984}
2985
Willy Tarreaua5e37562011-12-16 17:06:15 +01002986/* set temp integer to the session rate from the session's source address in the
Willy Tarreau91c43d72010-06-20 11:19:22 +02002987 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02002988 * Accepts exactly 1 argument of type table.
Willy Tarreau91c43d72010-06-20 11:19:22 +02002989 */
2990static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02002991acl_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02002992 const struct arg *args, struct sample *smp)
Willy Tarreau91c43d72010-06-20 11:19:22 +02002993{
2994 struct stktable_key *key;
2995
Willy Tarreau64ee4912012-08-30 22:59:48 +02002996 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau91c43d72010-06-20 11:19:22 +02002997 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01002998 return 0;
Willy Tarreau91c43d72010-06-20 11:19:22 +02002999
Willy Tarreau24e32d82012-04-23 23:55:44 +02003000 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003001 return acl_fetch_sess_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau91c43d72010-06-20 11:19:22 +02003002}
3003
Willy Tarreaua5e37562011-12-16 17:06:15 +01003004/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003005static int
Willy Tarreau37406352012-04-23 16:16:37 +02003006acl_fetch_http_req_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003007{
Willy Tarreau37406352012-04-23 16:16:37 +02003008 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003009 smp->type = SMP_T_UINT;
3010 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003011 if (ts != NULL) {
3012 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_REQ_CNT);
3013 if (!ptr)
3014 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003015 smp->data.uint = stktable_data_cast(ptr, http_req_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003016 }
3017 return 1;
3018}
3019
Willy Tarreaua5e37562011-12-16 17:06:15 +01003020/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003021static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003022acl_fetch_sc1_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003023 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003024{
Willy Tarreau56123282010-08-06 19:06:56 +02003025 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003026 return 0;
3027
Willy Tarreau37406352012-04-23 16:16:37 +02003028 return acl_fetch_http_req_cnt(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003029}
3030
Willy Tarreaua5e37562011-12-16 17:06:15 +01003031/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003032static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003033acl_fetch_sc2_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003034 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003035{
Willy Tarreau56123282010-08-06 19:06:56 +02003036 if (!l4->stkctr2_entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003037 return 0;
3038
Willy Tarreau37406352012-04-23 16:16:37 +02003039 return acl_fetch_http_req_cnt(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003040}
3041
Willy Tarreaua5e37562011-12-16 17:06:15 +01003042/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauda7ff642010-06-23 11:44:09 +02003043 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003044 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003045 */
3046static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003047acl_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003048 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003049{
3050 struct stktable_key *key;
3051
Willy Tarreau64ee4912012-08-30 22:59:48 +02003052 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003053 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003054 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003055
Willy Tarreau24e32d82012-04-23 23:55:44 +02003056 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003057 return acl_fetch_http_req_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003058}
3059
Willy Tarreaua5e37562011-12-16 17:06:15 +01003060/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003061static int
Willy Tarreau37406352012-04-23 16:16:37 +02003062acl_fetch_http_req_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003063{
Willy Tarreau37406352012-04-23 16:16:37 +02003064 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003065 smp->type = SMP_T_UINT;
3066 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003067 if (ts != NULL) {
3068 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_REQ_RATE);
3069 if (!ptr)
3070 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003071 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreauda7ff642010-06-23 11:44:09 +02003072 table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
3073 }
3074 return 1;
3075}
3076
Willy Tarreaua5e37562011-12-16 17:06:15 +01003077/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauda7ff642010-06-23 11:44:09 +02003078 * the configured period.
3079 */
3080static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003081acl_fetch_sc1_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003082 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003083{
Willy Tarreau56123282010-08-06 19:06:56 +02003084 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003085 return 0;
3086
Willy Tarreau37406352012-04-23 16:16:37 +02003087 return acl_fetch_http_req_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003088}
3089
Willy Tarreaua5e37562011-12-16 17:06:15 +01003090/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003091 * the configured period.
3092 */
3093static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003094acl_fetch_sc2_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003095 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003096{
Willy Tarreau56123282010-08-06 19:06:56 +02003097 if (!l4->stkctr2_entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003098 return 0;
3099
Willy Tarreau37406352012-04-23 16:16:37 +02003100 return acl_fetch_http_req_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003101}
3102
Willy Tarreaua5e37562011-12-16 17:06:15 +01003103/* set temp integer to the session rate from the session's source address in the
Willy Tarreauda7ff642010-06-23 11:44:09 +02003104 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003105 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003106 */
3107static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003108acl_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003109 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003110{
3111 struct stktable_key *key;
3112
Willy Tarreau64ee4912012-08-30 22:59:48 +02003113 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003114 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003115 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003116
Willy Tarreau24e32d82012-04-23 23:55:44 +02003117 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003118 return acl_fetch_http_req_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003119}
3120
Willy Tarreaua5e37562011-12-16 17:06:15 +01003121/* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003122static int
Willy Tarreau37406352012-04-23 16:16:37 +02003123acl_fetch_http_err_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003124{
Willy Tarreau37406352012-04-23 16:16:37 +02003125 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003126 smp->type = SMP_T_UINT;
3127 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003128 if (ts != NULL) {
3129 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_ERR_CNT);
3130 if (!ptr)
3131 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003132 smp->data.uint = stktable_data_cast(ptr, http_err_cnt);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003133 }
3134 return 1;
3135}
3136
Willy Tarreaua5e37562011-12-16 17:06:15 +01003137/* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003138static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003139acl_fetch_sc1_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003140 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003141{
Willy Tarreau56123282010-08-06 19:06:56 +02003142 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003143 return 0;
3144
Willy Tarreau37406352012-04-23 16:16:37 +02003145 return acl_fetch_http_err_cnt(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003146}
3147
Willy Tarreaua5e37562011-12-16 17:06:15 +01003148/* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003149static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003150acl_fetch_sc2_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003151 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003152{
Willy Tarreau56123282010-08-06 19:06:56 +02003153 if (!l4->stkctr2_entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003154 return 0;
3155
Willy Tarreau37406352012-04-23 16:16:37 +02003156 return acl_fetch_http_err_cnt(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003157}
3158
Willy Tarreaua5e37562011-12-16 17:06:15 +01003159/* set temp integer to the cumulated number of session from the session's source
Willy Tarreauda7ff642010-06-23 11:44:09 +02003160 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003161 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003162 */
3163static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003164acl_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003165 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003166{
3167 struct stktable_key *key;
3168
Willy Tarreau64ee4912012-08-30 22:59:48 +02003169 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003170 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003171 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003172
Willy Tarreau24e32d82012-04-23 23:55:44 +02003173 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003174 return acl_fetch_http_err_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003175}
3176
Willy Tarreaua5e37562011-12-16 17:06:15 +01003177/* set temp integer to the session rate in the stksess entry <ts> over the configured period */
Willy Tarreauda7ff642010-06-23 11:44:09 +02003178static int
Willy Tarreau37406352012-04-23 16:16:37 +02003179acl_fetch_http_err_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003180{
Willy Tarreau37406352012-04-23 16:16:37 +02003181 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003182 smp->type = SMP_T_UINT;
3183 smp->data.uint = 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003184 if (ts != NULL) {
3185 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_HTTP_ERR_RATE);
3186 if (!ptr)
3187 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003188 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreauda7ff642010-06-23 11:44:09 +02003189 table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
3190 }
3191 return 1;
3192}
3193
Willy Tarreaua5e37562011-12-16 17:06:15 +01003194/* set temp integer to the session rate from the session's tracked FE counters over
Willy Tarreauda7ff642010-06-23 11:44:09 +02003195 * the configured period.
3196 */
3197static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003198acl_fetch_sc1_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003199 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003200{
Willy Tarreau56123282010-08-06 19:06:56 +02003201 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003202 return 0;
3203
Willy Tarreau37406352012-04-23 16:16:37 +02003204 return acl_fetch_http_err_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003205}
3206
Willy Tarreaua5e37562011-12-16 17:06:15 +01003207/* set temp integer to the session rate from the session's tracked BE counters over
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003208 * the configured period.
3209 */
3210static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003211acl_fetch_sc2_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003212 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003213{
Willy Tarreau56123282010-08-06 19:06:56 +02003214 if (!l4->stkctr2_entry)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003215 return 0;
3216
Willy Tarreau37406352012-04-23 16:16:37 +02003217 return acl_fetch_http_err_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003218}
3219
Willy Tarreaua5e37562011-12-16 17:06:15 +01003220/* set temp integer to the session rate from the session's source address in the
Willy Tarreauda7ff642010-06-23 11:44:09 +02003221 * table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003222 * Accepts exactly 1 argument of type table.
Willy Tarreauda7ff642010-06-23 11:44:09 +02003223 */
3224static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003225acl_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003226 const struct arg *args, struct sample *smp)
Willy Tarreauda7ff642010-06-23 11:44:09 +02003227{
3228 struct stktable_key *key;
3229
Willy Tarreau64ee4912012-08-30 22:59:48 +02003230 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreauda7ff642010-06-23 11:44:09 +02003231 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003232 return 0;
Willy Tarreauda7ff642010-06-23 11:44:09 +02003233
Willy Tarreau24e32d82012-04-23 23:55:44 +02003234 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003235 return acl_fetch_http_err_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreauda7ff642010-06-23 11:44:09 +02003236}
3237
Willy Tarreaua5e37562011-12-16 17:06:15 +01003238/* set temp integer to the number of kbytes received from clients matching the stksess entry <ts> */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003239static int
Willy Tarreau37406352012-04-23 16:16:37 +02003240acl_fetch_kbytes_in(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003241{
Willy Tarreau37406352012-04-23 16:16:37 +02003242 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003243 smp->type = SMP_T_UINT;
3244 smp->data.uint = 0;
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003245
3246 if (ts != NULL) {
3247 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_IN_CNT);
3248 if (!ptr)
3249 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003250 smp->data.uint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003251 }
3252 return 1;
3253}
3254
Willy Tarreaua5e37562011-12-16 17:06:15 +01003255/* set temp integer to the number of kbytes received from clients according to the
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003256 * session's tracked FE counters.
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003257 */
3258static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003259acl_fetch_sc1_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003260 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003261{
Willy Tarreau56123282010-08-06 19:06:56 +02003262 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003263 return 0;
3264
Willy Tarreau37406352012-04-23 16:16:37 +02003265 return acl_fetch_kbytes_in(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003266}
3267
Willy Tarreaua5e37562011-12-16 17:06:15 +01003268/* set temp integer to the number of kbytes received from clients according to the
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003269 * session's tracked BE counters.
3270 */
3271static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003272acl_fetch_sc2_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003273 const struct arg *args, struct sample *smp)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003274{
Willy Tarreau56123282010-08-06 19:06:56 +02003275 if (!l4->stkctr2_entry)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003276 return 0;
3277
Willy Tarreau37406352012-04-23 16:16:37 +02003278 return acl_fetch_kbytes_in(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003279}
3280
Willy Tarreaua5e37562011-12-16 17:06:15 +01003281/* set temp integer to the number of kbytes received from the session's source
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003282 * address in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003283 * Accepts exactly 1 argument of type table.
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003284 */
3285static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003286acl_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003287 const struct arg *args, struct sample *smp)
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003288{
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003289 struct stktable_key *key;
3290
Willy Tarreau64ee4912012-08-30 22:59:48 +02003291 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003292 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003293 return 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003294
Willy Tarreau24e32d82012-04-23 23:55:44 +02003295 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003296 return acl_fetch_kbytes_in(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003297}
3298
Willy Tarreaua5e37562011-12-16 17:06:15 +01003299/* set temp integer to the bytes rate from clients in the stksess entry <ts> over the
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003300 * configured period.
3301 */
3302static int
Willy Tarreau37406352012-04-23 16:16:37 +02003303acl_fetch_bytes_in_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003304{
Willy Tarreau37406352012-04-23 16:16:37 +02003305 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003306 smp->type = SMP_T_UINT;
3307 smp->data.uint = 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003308 if (ts != NULL) {
3309 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_IN_RATE);
3310 if (!ptr)
3311 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003312 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003313 table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
3314 }
3315 return 1;
3316}
3317
Willy Tarreaua5e37562011-12-16 17:06:15 +01003318/* set temp integer to the bytes rate from clients from the session's tracked FE
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003319 * counters over the configured period.
3320 */
3321static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003322acl_fetch_sc1_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003323 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003324{
Willy Tarreau56123282010-08-06 19:06:56 +02003325 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003326 return 0;
3327
Willy Tarreau37406352012-04-23 16:16:37 +02003328 return acl_fetch_bytes_in_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003329}
3330
Willy Tarreaua5e37562011-12-16 17:06:15 +01003331/* set temp integer to the bytes rate from clients from the session's tracked BE
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003332 * counters over the configured period.
3333 */
3334static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003335acl_fetch_sc2_bytes_in_rate(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 Tarreau6c59e0a2010-06-20 11:56:30 +02003337{
Willy Tarreau56123282010-08-06 19:06:56 +02003338 if (!l4->stkctr2_entry)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003339 return 0;
3340
Willy Tarreau37406352012-04-23 16:16:37 +02003341 return acl_fetch_bytes_in_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003342}
3343
Willy Tarreaua5e37562011-12-16 17:06:15 +01003344/* set temp integer to the bytes rate from clients from the session's source address
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003345 * in the table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003346 * Accepts exactly 1 argument of type table.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003347 */
3348static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003349acl_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003350 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003351{
3352 struct stktable_key *key;
3353
Willy Tarreau64ee4912012-08-30 22:59:48 +02003354 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003355 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003356 return 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003357
Willy Tarreau24e32d82012-04-23 23:55:44 +02003358 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003359 return acl_fetch_bytes_in_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003360}
3361
Willy Tarreaua5e37562011-12-16 17:06:15 +01003362/* set temp integer to the number of kbytes sent to clients matching the stksess entry <ts> */
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003363static int
Willy Tarreau37406352012-04-23 16:16:37 +02003364acl_fetch_kbytes_out(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003365{
Willy Tarreau37406352012-04-23 16:16:37 +02003366 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003367 smp->type = SMP_T_UINT;
3368 smp->data.uint = 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003369
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003370 if (ts != NULL) {
3371 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_OUT_CNT);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003372 if (!ptr)
3373 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003374 smp->data.uint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003375 }
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003376 return 1;
3377}
3378
Willy Tarreaua5e37562011-12-16 17:06:15 +01003379/* set temp integer to the number of kbytes sent to clients according to the session's
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003380 * tracked FE counters.
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003381 */
3382static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003383acl_fetch_sc1_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003384 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003385{
Willy Tarreau56123282010-08-06 19:06:56 +02003386 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003387 return 0;
3388
Willy Tarreau37406352012-04-23 16:16:37 +02003389 return acl_fetch_kbytes_out(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003390}
3391
Willy Tarreaua5e37562011-12-16 17:06:15 +01003392/* set temp integer to the number of kbytes sent to clients according to the session's
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003393 * tracked BE counters.
3394 */
3395static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003396acl_fetch_sc2_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003397 const struct arg *args, struct sample *smp)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003398{
Willy Tarreau56123282010-08-06 19:06:56 +02003399 if (!l4->stkctr2_entry)
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003400 return 0;
3401
Willy Tarreau37406352012-04-23 16:16:37 +02003402 return acl_fetch_kbytes_out(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau1aa006f2010-06-18 21:52:52 +02003403}
3404
Willy Tarreaua5e37562011-12-16 17:06:15 +01003405/* set temp integer to the number of kbytes sent to the session's source address in
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003406 * the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003407 * Accepts exactly 1 argument of type table.
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003408 */
3409static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003410acl_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003411 const struct arg *args, struct sample *smp)
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003412{
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003413 struct stktable_key *key;
3414
Willy Tarreau64ee4912012-08-30 22:59:48 +02003415 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003416 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003417 return 0;
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003418
Willy Tarreau24e32d82012-04-23 23:55:44 +02003419 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003420 return acl_fetch_kbytes_out(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau855e4bb2010-06-18 18:33:32 +02003421}
3422
Willy Tarreaua5e37562011-12-16 17:06:15 +01003423/* set temp integer to the bytes rate to clients in the stksess entry <ts> over the
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003424 * configured period.
3425 */
3426static int
Willy Tarreau37406352012-04-23 16:16:37 +02003427acl_fetch_bytes_out_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003428{
Willy Tarreau37406352012-04-23 16:16:37 +02003429 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003430 smp->type = SMP_T_UINT;
3431 smp->data.uint = 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003432 if (ts != NULL) {
3433 void *ptr = stktable_data_ptr(table, ts, STKTABLE_DT_BYTES_OUT_RATE);
3434 if (!ptr)
3435 return 0; /* parameter not stored */
Willy Tarreauf853c462012-04-23 18:53:56 +02003436 smp->data.uint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003437 table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
3438 }
3439 return 1;
3440}
3441
Willy Tarreaua5e37562011-12-16 17:06:15 +01003442/* set temp integer to the bytes rate to clients from the session's tracked FE counters
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003443 * over the configured period.
3444 */
3445static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003446acl_fetch_sc1_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003447 const struct arg *args, struct sample *smp)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003448{
Willy Tarreau56123282010-08-06 19:06:56 +02003449 if (!l4->stkctr1_entry)
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003450 return 0;
3451
Willy Tarreau37406352012-04-23 16:16:37 +02003452 return acl_fetch_bytes_out_rate(l4->stkctr1_table, smp, l4->stkctr1_entry);
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003453}
3454
Willy Tarreaua5e37562011-12-16 17:06:15 +01003455/* set temp integer to the bytes rate to clients from the session's tracked BE counters
Willy Tarreauf059a0f2010-08-03 16:29:52 +02003456 * over the configured period.
3457 */
3458static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003459acl_fetch_sc2_bytes_out_rate(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 Tarreau6c59e0a2010-06-20 11:56:30 +02003461{
Willy Tarreau56123282010-08-06 19:06:56 +02003462 if (!l4->stkctr2_entry)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003463 return 0;
3464
Willy Tarreau37406352012-04-23 16:16:37 +02003465 return acl_fetch_bytes_out_rate(l4->stkctr2_table, smp, l4->stkctr2_entry);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003466}
3467
Willy Tarreaua5e37562011-12-16 17:06:15 +01003468/* set temp integer to the bytes rate to client from the session's source address in
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003469 * the table pointed to by expr, over the configured period.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003470 * Accepts exactly 1 argument of type table.
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003471 */
3472static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003473acl_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003474 const struct arg *args, struct sample *smp)
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003475{
3476 struct stktable_key *key;
3477
Willy Tarreau64ee4912012-08-30 22:59:48 +02003478 key = addr_to_stktable_key(&l4->si[0].conn.addr.from);
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003479 if (!key)
David du Colombier4f92d322011-03-24 11:09:31 +01003480 return 0;
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003481
Willy Tarreau24e32d82012-04-23 23:55:44 +02003482 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003483 return acl_fetch_bytes_out_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
Willy Tarreau6c59e0a2010-06-20 11:56:30 +02003484}
3485
Willy Tarreau34db1082012-04-19 17:16:54 +02003486/* set temp integer to the number of used entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003487 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003488 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003489static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003490acl_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003491 const struct arg *args, struct sample *smp)
Willy Tarreauc735a072011-03-29 00:57:02 +02003492{
Willy Tarreau37406352012-04-23 16:16:37 +02003493 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003494 smp->type = SMP_T_UINT;
Willy Tarreau24e32d82012-04-23 23:55:44 +02003495 smp->data.uint = args->data.prx->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003496 return 1;
3497}
3498
Willy Tarreau34db1082012-04-19 17:16:54 +02003499/* set temp integer to the number of free entries in the table pointed to by expr.
Willy Tarreau0146c2e2012-04-20 11:37:56 +02003500 * Accepts exactly 1 argument of type table.
Willy Tarreau34db1082012-04-19 17:16:54 +02003501 */
Willy Tarreauc735a072011-03-29 00:57:02 +02003502static int
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02003503acl_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
Willy Tarreau24e32d82012-04-23 23:55:44 +02003504 const struct arg *args, struct sample *smp)
Willy Tarreauc735a072011-03-29 00:57:02 +02003505{
Willy Tarreau24e32d82012-04-23 23:55:44 +02003506 px = args->data.prx;
Willy Tarreau37406352012-04-23 16:16:37 +02003507 smp->flags = SMP_F_VOL_TEST;
Willy Tarreauf853c462012-04-23 18:53:56 +02003508 smp->type = SMP_T_UINT;
3509 smp->data.uint = px->table.size - px->table.current;
Willy Tarreauc735a072011-03-29 00:57:02 +02003510 return 1;
3511}
Willy Tarreau8b22a712010-06-18 17:46:06 +02003512
Willy Tarreau61612d42012-04-19 18:42:05 +02003513/* Note: must not be declared <const> as its list will be overwritten.
3514 * Please take care of keeping this list alphabetically sorted.
3515 */
Willy Tarreau8b22a712010-06-18 17:46:06 +02003516static struct acl_kw_list acl_kws = {{ },{
Willy Tarreau61612d42012-04-19 18:42:05 +02003517 { "sc1_bytes_in_rate", acl_parse_int, acl_fetch_sc1_bytes_in_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3518 { "sc1_bytes_out_rate", acl_parse_int, acl_fetch_sc1_bytes_out_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3519 { "sc1_clr_gpc0", acl_parse_int, acl_fetch_sc1_clr_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3520 { "sc1_conn_cnt", acl_parse_int, acl_fetch_sc1_conn_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3521 { "sc1_conn_cur", acl_parse_int, acl_fetch_sc1_conn_cur, acl_match_int, ACL_USE_NOTHING, 0 },
3522 { "sc1_conn_rate", acl_parse_int, acl_fetch_sc1_conn_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3523 { "sc1_get_gpc0", acl_parse_int, acl_fetch_sc1_get_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3524 { "sc1_http_err_cnt", acl_parse_int, acl_fetch_sc1_http_err_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3525 { "sc1_http_err_rate", acl_parse_int, acl_fetch_sc1_http_err_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3526 { "sc1_http_req_cnt", acl_parse_int, acl_fetch_sc1_http_req_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3527 { "sc1_http_req_rate", acl_parse_int, acl_fetch_sc1_http_req_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3528 { "sc1_inc_gpc0", acl_parse_int, acl_fetch_sc1_inc_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3529 { "sc1_kbytes_in", acl_parse_int, acl_fetch_sc1_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3530 { "sc1_kbytes_out", acl_parse_int, acl_fetch_sc1_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3531 { "sc1_sess_cnt", acl_parse_int, acl_fetch_sc1_sess_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3532 { "sc1_sess_rate", acl_parse_int, acl_fetch_sc1_sess_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3533 { "sc2_bytes_in_rate", acl_parse_int, acl_fetch_sc2_bytes_in_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3534 { "sc2_bytes_out_rate", acl_parse_int, acl_fetch_sc2_bytes_out_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3535 { "sc2_clr_gpc0", acl_parse_int, acl_fetch_sc2_clr_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3536 { "sc2_conn_cnt", acl_parse_int, acl_fetch_sc2_conn_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3537 { "sc2_conn_cur", acl_parse_int, acl_fetch_sc2_conn_cur, acl_match_int, ACL_USE_NOTHING, 0 },
3538 { "sc2_conn_rate", acl_parse_int, acl_fetch_sc2_conn_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3539 { "sc2_get_gpc0", acl_parse_int, acl_fetch_sc2_get_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3540 { "sc2_http_err_cnt", acl_parse_int, acl_fetch_sc2_http_err_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3541 { "sc2_http_err_rate", acl_parse_int, acl_fetch_sc2_http_err_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3542 { "sc2_http_req_cnt", acl_parse_int, acl_fetch_sc2_http_req_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3543 { "sc2_http_req_rate", acl_parse_int, acl_fetch_sc2_http_req_rate, acl_match_int, ACL_USE_NOTHING, 0 },
3544 { "sc2_inc_gpc0", acl_parse_int, acl_fetch_sc2_inc_gpc0, acl_match_int, ACL_USE_NOTHING, 0 },
3545 { "sc2_kbytes_in", acl_parse_int, acl_fetch_sc2_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3546 { "sc2_kbytes_out", acl_parse_int, acl_fetch_sc2_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
3547 { "sc2_sess_cnt", acl_parse_int, acl_fetch_sc2_sess_cnt, acl_match_int, ACL_USE_NOTHING, 0 },
3548 { "sc2_sess_rate", acl_parse_int, acl_fetch_sc2_sess_rate, acl_match_int, ACL_USE_NOTHING, 0 },
Willy Tarreaufc2c1fd2012-04-19 23:35:54 +02003549 { "src_bytes_in_rate", acl_parse_int, acl_fetch_src_bytes_in_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3550 { "src_bytes_out_rate", acl_parse_int, acl_fetch_src_bytes_out_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3551 { "src_clr_gpc0", acl_parse_int, acl_fetch_src_clr_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3552 { "src_conn_cnt", acl_parse_int, acl_fetch_src_conn_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3553 { "src_conn_cur", acl_parse_int, acl_fetch_src_conn_cur, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3554 { "src_conn_rate", acl_parse_int, acl_fetch_src_conn_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3555 { "src_get_gpc0", acl_parse_int, acl_fetch_src_get_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3556 { "src_http_err_cnt", acl_parse_int, acl_fetch_src_http_err_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3557 { "src_http_err_rate", acl_parse_int, acl_fetch_src_http_err_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3558 { "src_http_req_cnt", acl_parse_int, acl_fetch_src_http_req_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3559 { "src_http_req_rate", acl_parse_int, acl_fetch_src_http_req_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3560 { "src_inc_gpc0", acl_parse_int, acl_fetch_src_inc_gpc0, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3561 { "src_kbytes_in", acl_parse_int, acl_fetch_src_kbytes_in, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3562 { "src_kbytes_out", acl_parse_int, acl_fetch_src_kbytes_out, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3563 { "src_sess_cnt", acl_parse_int, acl_fetch_src_sess_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3564 { "src_sess_rate", acl_parse_int, acl_fetch_src_sess_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3565 { "src_updt_conn_cnt", acl_parse_int, acl_fetch_src_updt_conn_cnt, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
3566 { "table_avl", acl_parse_int, acl_fetch_table_avl, acl_match_int, ACL_USE_NOTHING, ARG1(1,TAB) },
3567 { "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 +02003568 { NULL, NULL, NULL, NULL },
3569}};
3570
3571
Willy Tarreau56123282010-08-06 19:06:56 +02003572/* Parse a "track-sc[12]" line starting with "track-sc[12]" in args[arg-1].
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003573 * Returns the number of warnings emitted, or -1 in case of fatal errors. The
3574 * <prm> struct is fed with the table name if any. If unspecified, the caller
3575 * will assume that the current proxy's table is used.
3576 */
3577int parse_track_counters(char **args, int *arg,
3578 int section_type, struct proxy *curpx,
3579 struct track_ctr_prm *prm,
Willy Tarreau0a3dd742012-05-08 19:47:01 +02003580 struct proxy *defpx, char **err)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003581{
Willy Tarreau12785782012-04-27 21:37:17 +02003582 int sample_type = 0;
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003583
Willy Tarreau56123282010-08-06 19:06:56 +02003584 /* parse the arguments of "track-sc[12]" before the condition in the
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003585 * following form :
Willy Tarreau56123282010-08-06 19:06:56 +02003586 * track-sc[12] src [ table xxx ] [ if|unless ... ]
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003587 */
3588 while (args[*arg]) {
3589 if (strcmp(args[*arg], "src") == 0) {
3590 prm->type = STKTABLE_TYPE_IP;
Willy Tarreau12785782012-04-27 21:37:17 +02003591 sample_type = 1;
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003592 }
3593 else if (strcmp(args[*arg], "table") == 0) {
3594 if (!args[*arg + 1]) {
Willy Tarreau0a3dd742012-05-08 19:47:01 +02003595 memprintf(err, "missing table name");
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003596 return -1;
3597 }
3598 /* we copy the table name for now, it will be resolved later */
3599 prm->table.n = strdup(args[*arg + 1]);
3600 (*arg)++;
3601 }
3602 else {
3603 /* unhandled keywords are handled by the caller */
3604 break;
3605 }
3606 (*arg)++;
3607 }
3608
Willy Tarreau12785782012-04-27 21:37:17 +02003609 if (!sample_type) {
Willy Tarreau0a3dd742012-05-08 19:47:01 +02003610 memprintf(err,
3611 "tracking key not specified (found %s, only 'src' is supported)",
3612 quote_arg(args[*arg]));
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02003613 return -1;
3614 }
3615
3616 return 0;
3617}
3618
Willy Tarreau8b22a712010-06-18 17:46:06 +02003619__attribute__((constructor))
3620static void __session_init(void)
3621{
3622 acl_register_keywords(&acl_kws);
3623}
3624
Willy Tarreaubaaee002006-06-26 02:48:02 +02003625/*
3626 * Local variables:
3627 * c-indent-level: 8
3628 * c-basic-offset: 8
3629 * End:
3630 */