blob: fd5c56eab699f0b493614b40ecd3e813279c23fa [file] [log] [blame]
Christopher Fauletd7c91962015-04-30 11:48:27 +02001/*
2 * Stream filters related variables and functions.
3 *
4 * Copyright (C) 2015 Qualys Inc., Christopher Faulet <cfaulet@qualys.com>
5 *
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
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020013#include <haproxy/api.h>
Willy Tarreau2741c8c2020-06-02 11:28:02 +020014#include <haproxy/buf-t.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020015#include <haproxy/cfgparse.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020016#include <haproxy/compression.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020017#include <haproxy/errors.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020018#include <haproxy/filters.h>
Willy Tarreau7d865a52020-06-04 10:57:05 +020019#include <haproxy/flt_http_comp.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020020#include <haproxy/http_ana.h>
Willy Tarreau87735332020-06-04 09:08:41 +020021#include <haproxy/http_htx.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020022#include <haproxy/htx.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020023#include <haproxy/namespace.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020024#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020025#include <haproxy/stream_interface.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020026#include <haproxy/tools.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020027#include <haproxy/trace.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020028
Christopher Fauletd7c91962015-04-30 11:48:27 +020029
Christopher Fauleteea8fc72019-11-05 16:18:10 +010030#define TRACE_SOURCE &trace_strm
31
Christopher Fauletd7c91962015-04-30 11:48:27 +020032/* Pool used to allocate filters */
Willy Tarreau8ceae722018-11-26 11:58:30 +010033DECLARE_STATIC_POOL(pool_head_filter, "filter", sizeof(struct filter));
Christopher Fauletd7c91962015-04-30 11:48:27 +020034
35static int handle_analyzer_result(struct stream *s, struct channel *chn, unsigned int an_bit, int ret);
36
37/* - RESUME_FILTER_LOOP and RESUME_FILTER_END must always be used together.
38 * The first one begins a loop and the seconds one ends it.
39 *
40 * - BREAK_EXECUTION must be used to break the loop and set the filter from
41 * which to resume the next time.
42 *
Bertrand Jacquin874a35c2018-09-10 21:26:07 +010043 * Here is an example:
Christopher Fauletd7c91962015-04-30 11:48:27 +020044 *
45 * RESUME_FILTER_LOOP(stream, channel) {
46 * ...
47 * if (cond)
48 * BREAK_EXECUTION(stream, channel, label);
49 * ...
50 * } RESUME_FILTER_END;
51 * ...
52 * label:
53 * ...
54 *
55 */
56#define RESUME_FILTER_LOOP(strm, chn) \
57 do { \
58 struct filter *filter; \
59 \
Christopher Fauletda02e172015-12-04 09:25:05 +010060 if (strm_flt(strm)->current[CHN_IDX(chn)]) { \
61 filter = strm_flt(strm)->current[CHN_IDX(chn)]; \
62 strm_flt(strm)->current[CHN_IDX(chn)] = NULL; \
Christopher Fauletd7c91962015-04-30 11:48:27 +020063 goto resume_execution; \
64 } \
65 \
Christopher Fauletfcf035c2015-12-03 11:48:03 +010066 list_for_each_entry(filter, &strm_flt(s)->filters, list) { \
Christopher Fauletda02e172015-12-04 09:25:05 +010067 resume_execution:
Christopher Fauletd7c91962015-04-30 11:48:27 +020068
69#define RESUME_FILTER_END \
70 } \
71 } while(0)
72
Christopher Fauletda02e172015-12-04 09:25:05 +010073#define BREAK_EXECUTION(strm, chn, label) \
74 do { \
75 strm_flt(strm)->current[CHN_IDX(chn)] = filter; \
76 goto label; \
Christopher Fauletd7c91962015-04-30 11:48:27 +020077 } while (0)
78
79
80/* List head of all known filter keywords */
81static struct flt_kw_list flt_keywords = {
82 .list = LIST_HEAD_INIT(flt_keywords.list)
83};
84
85/*
86 * Registers the filter keyword list <kwl> as a list of valid keywords for next
87 * parsing sessions.
88 */
89void
90flt_register_keywords(struct flt_kw_list *kwl)
91{
92 LIST_ADDQ(&flt_keywords.list, &kwl->list);
93}
94
95/*
96 * Returns a pointer to the filter keyword <kw>, or NULL if not found. If the
97 * keyword is found with a NULL ->parse() function, then an attempt is made to
98 * find one with a valid ->parse() function. This way it is possible to declare
99 * platform-dependant, known keywords as NULL, then only declare them as valid
100 * if some options are met. Note that if the requested keyword contains an
101 * opening parenthesis, everything from this point is ignored.
102 */
103struct flt_kw *
104flt_find_kw(const char *kw)
105{
106 int index;
107 const char *kwend;
108 struct flt_kw_list *kwl;
109 struct flt_kw *ret = NULL;
110
111 kwend = strchr(kw, '(');
112 if (!kwend)
113 kwend = kw + strlen(kw);
114
115 list_for_each_entry(kwl, &flt_keywords.list, list) {
116 for (index = 0; kwl->kw[index].kw != NULL; index++) {
117 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
118 kwl->kw[index].kw[kwend-kw] == 0) {
119 if (kwl->kw[index].parse)
120 return &kwl->kw[index]; /* found it !*/
121 else
122 ret = &kwl->kw[index]; /* may be OK */
123 }
124 }
125 }
126 return ret;
127}
128
129/*
130 * Dumps all registered "filter" keywords to the <out> string pointer. The
131 * unsupported keywords are only dumped if their supported form was not found.
132 */
133void
134flt_dump_kws(char **out)
135{
136 struct flt_kw_list *kwl;
137 int index;
138
Christopher Faulet784063e2020-05-18 12:14:18 +0200139 if (!out)
140 return;
141
Christopher Fauletd7c91962015-04-30 11:48:27 +0200142 *out = NULL;
143 list_for_each_entry(kwl, &flt_keywords.list, list) {
144 for (index = 0; kwl->kw[index].kw != NULL; index++) {
145 if (kwl->kw[index].parse ||
146 flt_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
147 memprintf(out, "%s[%4s] %s%s\n", *out ? *out : "",
148 kwl->scope,
149 kwl->kw[index].kw,
150 kwl->kw[index].parse ? "" : " (not supported)");
151 }
152 }
153 }
154}
155
156/*
Christopher Fauletb3f4e142016-03-07 12:46:38 +0100157 * Lists the known filters on <out>
158 */
159void
160list_filters(FILE *out)
161{
162 char *filters, *p, *f;
163
164 fprintf(out, "Available filters :\n");
165 flt_dump_kws(&filters);
166 for (p = filters; (f = strtok_r(p,"\n",&p));)
167 fprintf(out, "\t%s\n", f);
168 free(filters);
169}
170
171/*
Christopher Fauletd7c91962015-04-30 11:48:27 +0200172 * Parses the "filter" keyword. All keywords must be handled by filters
173 * themselves
174 */
175static int
176parse_filter(char **args, int section_type, struct proxy *curpx,
177 struct proxy *defpx, const char *file, int line, char **err)
178{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100179 struct flt_conf *fconf = NULL;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200180
181 /* Filter cannot be defined on a default proxy */
182 if (curpx == defpx) {
Christopher Fauletcc7317d2016-04-04 10:51:17 +0200183 memprintf(err, "parsing [%s:%d] : %s is not allowed in a 'default' section.",
Christopher Fauletd7c91962015-04-30 11:48:27 +0200184 file, line, args[0]);
185 return -1;
186 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100187 if (strcmp(args[0], "filter") == 0) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200188 struct flt_kw *kw;
189 int cur_arg;
190
191 if (!*args[1]) {
192 memprintf(err,
193 "parsing [%s:%d] : missing argument for '%s' in %s '%s'.",
194 file, line, args[0], proxy_type_str(curpx), curpx->id);
195 goto error;
196 }
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100197 fconf = calloc(1, sizeof(*fconf));
198 if (!fconf) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200199 memprintf(err, "'%s' : out of memory", args[0]);
200 goto error;
201 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200202
203 cur_arg = 1;
204 kw = flt_find_kw(args[cur_arg]);
205 if (kw) {
206 if (!kw->parse) {
207 memprintf(err, "parsing [%s:%d] : '%s' : "
208 "'%s' option is not implemented in this version (check build options).",
209 file, line, args[0], args[cur_arg]);
210 goto error;
211 }
Thierry Fournier3610c392016-04-13 18:27:51 +0200212 if (kw->parse(args, &cur_arg, curpx, fconf, err, kw->private) != 0) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200213 if (err && *err)
214 memprintf(err, "'%s' : '%s'",
215 args[0], *err);
216 else
217 memprintf(err, "'%s' : error encountered while processing '%s'",
218 args[0], args[cur_arg]);
219 goto error;
220 }
221 }
222 else {
223 flt_dump_kws(err);
224 indent_msg(err, 4);
225 memprintf(err, "'%s' : unknown keyword '%s'.%s%s",
226 args[0], args[cur_arg],
227 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
228 goto error;
229 }
230 if (*args[cur_arg]) {
231 memprintf(err, "'%s %s' : unknown keyword '%s'.",
232 args[0], args[1], args[cur_arg]);
233 goto error;
234 }
Christopher Faulet00e818a2016-04-19 17:00:44 +0200235 if (fconf->ops == NULL) {
236 memprintf(err, "'%s %s' : no callbacks defined.",
237 args[0], args[1]);
238 goto error;
239 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200240
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100241 LIST_ADDQ(&curpx->filter_configs, &fconf->list);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200242 }
243 return 0;
244
245 error:
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100246 free(fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200247 return -1;
248
249
250}
251
252/*
253 * Calls 'init' callback for all filters attached to a proxy. This happens after
254 * the configuration parsing. Filters can finish to fill their config. Returns
255 * (ERR_ALERT|ERR_FATAL) if an error occurs, 0 otherwise.
256 */
Willy Tarreau64bca592016-12-21 20:13:11 +0100257static int
Christopher Fauletd7c91962015-04-30 11:48:27 +0200258flt_init(struct proxy *proxy)
259{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100260 struct flt_conf *fconf;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200261
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100262 list_for_each_entry(fconf, &proxy->filter_configs, list) {
263 if (fconf->ops->init && fconf->ops->init(proxy, fconf) < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200264 return ERR_ALERT|ERR_FATAL;
265 }
266 return 0;
267}
268
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200269/*
270 * Calls 'init_per_thread' callback for all filters attached to a proxy for each
271 * threads. This happens after the thread creation. Filters can finish to fill
272 * their config. Returns (ERR_ALERT|ERR_FATAL) if an error occurs, 0 otherwise.
273 */
274static int
275flt_init_per_thread(struct proxy *proxy)
276{
277 struct flt_conf *fconf;
278
279 list_for_each_entry(fconf, &proxy->filter_configs, list) {
280 if (fconf->ops->init_per_thread && fconf->ops->init_per_thread(proxy, fconf) < 0)
281 return ERR_ALERT|ERR_FATAL;
282 }
283 return 0;
284}
285
Willy Tarreau64bca592016-12-21 20:13:11 +0100286/* Calls flt_init() for all proxies, see above */
287static int
288flt_init_all()
289{
290 struct proxy *px;
Christopher Fauletfc633b62020-11-06 15:24:23 +0100291 int err_code = ERR_NONE;
Willy Tarreau64bca592016-12-21 20:13:11 +0100292
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100293 for (px = proxies_list; px; px = px->next) {
Christopher Faulet400829c2020-11-02 16:08:09 +0100294 if (px->disabled) {
295 flt_deinit(px);
296 continue;
297 }
Willy Tarreau64bca592016-12-21 20:13:11 +0100298 err_code |= flt_init(px);
299 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100300 ha_alert("Failed to initialize filters for proxy '%s'.\n",
301 px->id);
Willy Tarreau64bca592016-12-21 20:13:11 +0100302 return err_code;
303 }
304 }
305 return 0;
306}
307
Joseph Herlantb35ea682018-11-15 12:24:23 -0800308/* Calls flt_init_per_thread() for all proxies, see above. Be careful here, it
309 * returns 0 if an error occurred. This is the opposite of flt_init_all. */
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200310static int
311flt_init_all_per_thread()
312{
313 struct proxy *px;
314 int err_code = 0;
315
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100316 for (px = proxies_list; px; px = px->next) {
Christopher Faulet400829c2020-11-02 16:08:09 +0100317 if (px->disabled)
318 continue;
319
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200320 err_code = flt_init_per_thread(px);
321 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100322 ha_alert("Failed to initialize filters for proxy '%s' for thread %u.\n",
323 px->id, tid);
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200324 return 0;
325 }
326 }
327 return 1;
328}
329
Christopher Fauletd7c91962015-04-30 11:48:27 +0200330/*
331 * Calls 'check' callback for all filters attached to a proxy. This happens
332 * after the configuration parsing but before filters initialization. Returns
333 * the number of encountered errors.
334 */
335int
336flt_check(struct proxy *proxy)
337{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100338 struct flt_conf *fconf;
339 int err = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200340
Christopher Fauletff17b182019-01-07 15:03:22 +0100341 err += check_implicit_http_comp_flt(proxy);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100342 list_for_each_entry(fconf, &proxy->filter_configs, list) {
343 if (fconf->ops->check)
344 err += fconf->ops->check(proxy, fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200345 }
346 return err;
347}
348
349/*
350 * Calls 'denit' callback for all filters attached to a proxy. This happens when
351 * HAProxy is stopped.
352 */
353void
354flt_deinit(struct proxy *proxy)
355{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100356 struct flt_conf *fconf, *back;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200357
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100358 list_for_each_entry_safe(fconf, back, &proxy->filter_configs, list) {
Christopher Faulet743bd6a2020-11-03 16:40:37 +0100359 if (fconf->ops->deinit)
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100360 fconf->ops->deinit(proxy, fconf);
361 LIST_DEL(&fconf->list);
362 free(fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200363 }
364}
365
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200366/*
367 * Calls 'denit_per_thread' callback for all filters attached to a proxy for
368 * each threads. This happens before exiting a thread.
369 */
370void
371flt_deinit_per_thread(struct proxy *proxy)
372{
373 struct flt_conf *fconf, *back;
374
375 list_for_each_entry_safe(fconf, back, &proxy->filter_configs, list) {
376 if (fconf->ops->deinit_per_thread)
377 fconf->ops->deinit_per_thread(proxy, fconf);
378 }
379}
380
381
382/* Calls flt_deinit_per_thread() for all proxies, see above */
383static void
384flt_deinit_all_per_thread()
385{
386 struct proxy *px;
387
Christopher Faulet743bd6a2020-11-03 16:40:37 +0100388 for (px = proxies_list; px; px = px->next)
389 flt_deinit_per_thread(px);
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200390}
391
Christopher Faulet92d36382015-11-05 13:35:03 +0100392/* Attaches a filter to a stream. Returns -1 if an error occurs, 0 otherwise. */
393static int
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100394flt_stream_add_filter(struct stream *s, struct flt_conf *fconf, unsigned int flags)
Christopher Faulet92d36382015-11-05 13:35:03 +0100395{
Christopher Faulet75bc9132018-11-30 15:18:09 +0100396 struct filter *f;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200397
Christopher Faulet0f17a9b2019-04-05 10:11:38 +0200398 if (IS_HTX_STRM(s) && !(fconf->flags & FLT_CFG_FL_HTX))
Christopher Faulet75bc9132018-11-30 15:18:09 +0100399 return 0;
400
401 f = pool_alloc(pool_head_filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100402 if (!f) /* not enough memory */
403 return -1;
404 memset(f, 0, sizeof(*f));
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100405 f->config = fconf;
Christopher Fauletda02e172015-12-04 09:25:05 +0100406 f->flags |= flags;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200407
408 if (FLT_OPS(f)->attach) {
409 int ret = FLT_OPS(f)->attach(s, f);
410 if (ret <= 0) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100411 pool_free(pool_head_filter, f);
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200412 return ret;
413 }
414 }
415
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100416 LIST_ADDQ(&strm_flt(s)->filters, &f->list);
Christopher Fauletda02e172015-12-04 09:25:05 +0100417 strm_flt(s)->flags |= STRM_FLT_FL_HAS_FILTERS;
Christopher Faulet92d36382015-11-05 13:35:03 +0100418 return 0;
419}
420
421/*
422 * Called when a stream is created. It attaches all frontend filters to the
423 * stream. Returns -1 if an error occurs, 0 otherwise.
424 */
425int
426flt_stream_init(struct stream *s)
427{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100428 struct flt_conf *fconf;
Christopher Faulet92d36382015-11-05 13:35:03 +0100429
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100430 memset(strm_flt(s), 0, sizeof(*strm_flt(s)));
431 LIST_INIT(&strm_flt(s)->filters);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100432 list_for_each_entry(fconf, &strm_fe(s)->filter_configs, list) {
433 if (flt_stream_add_filter(s, fconf, 0) < 0)
Christopher Faulet92d36382015-11-05 13:35:03 +0100434 return -1;
435 }
436 return 0;
437}
438
439/*
440 * Called when a stream is closed or when analyze ends (For an HTTP stream, this
441 * happens after each request/response exchange). When analyze ends, backend
442 * filters are removed. When the stream is closed, all filters attached to the
443 * stream are removed.
444 */
445void
446flt_stream_release(struct stream *s, int only_backend)
447{
448 struct filter *filter, *back;
449
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100450 list_for_each_entry_safe(filter, back, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100451 if (!only_backend || (filter->flags & FLT_FL_IS_BACKEND_FILTER)) {
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200452 if (FLT_OPS(filter)->detach)
453 FLT_OPS(filter)->detach(s, filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100454 LIST_DEL(&filter->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100455 pool_free(pool_head_filter, filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100456 }
457 }
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100458 if (LIST_ISEMPTY(&strm_flt(s)->filters))
Christopher Fauletda02e172015-12-04 09:25:05 +0100459 strm_flt(s)->flags &= ~STRM_FLT_FL_HAS_FILTERS;
Christopher Faulet92d36382015-11-05 13:35:03 +0100460}
461
Christopher Fauletd7c91962015-04-30 11:48:27 +0200462/*
463 * Calls 'stream_start' for all filters attached to a stream. This happens when
464 * the stream is created, just after calling flt_stream_init
465 * function. Returns -1 if an error occurs, 0 otherwise.
466 */
467int
468flt_stream_start(struct stream *s)
469{
470 struct filter *filter;
471
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100472 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100473 if (FLT_OPS(filter)->stream_start && FLT_OPS(filter)->stream_start(s, filter) < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200474 return -1;
475 }
476 return 0;
477}
478
479/*
480 * Calls 'stream_stop' for all filters attached to a stream. This happens when
481 * the stream is stopped, just before calling flt_stream_release function.
482 */
483void
484flt_stream_stop(struct stream *s)
485{
486 struct filter *filter;
487
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100488 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100489 if (FLT_OPS(filter)->stream_stop)
490 FLT_OPS(filter)->stream_stop(s, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200491 }
492}
493
Christopher Faulet92d36382015-11-05 13:35:03 +0100494/*
Christopher Fauleta00d8172016-11-10 14:58:05 +0100495 * Calls 'check_timeouts' for all filters attached to a stream. This happens when
496 * the stream is woken up because of expired timer.
497 */
498void
499flt_stream_check_timeouts(struct stream *s)
500{
501 struct filter *filter;
502
503 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
504 if (FLT_OPS(filter)->check_timeouts)
505 FLT_OPS(filter)->check_timeouts(s, filter);
506 }
507}
508
509/*
Christopher Faulet92d36382015-11-05 13:35:03 +0100510 * Called when a backend is set for a stream. If the frontend and the backend
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200511 * are not the same, this function attaches all backend filters to the
512 * stream. Returns -1 if an error occurs, 0 otherwise.
Christopher Faulet92d36382015-11-05 13:35:03 +0100513 */
514int
515flt_set_stream_backend(struct stream *s, struct proxy *be)
516{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100517 struct flt_conf *fconf;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200518 struct filter *filter;
Christopher Faulet92d36382015-11-05 13:35:03 +0100519
520 if (strm_fe(s) == be)
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200521 goto end;
Christopher Faulet92d36382015-11-05 13:35:03 +0100522
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100523 list_for_each_entry(fconf, &be->filter_configs, list) {
524 if (flt_stream_add_filter(s, fconf, FLT_FL_IS_BACKEND_FILTER) < 0)
Christopher Faulet92d36382015-11-05 13:35:03 +0100525 return -1;
526 }
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200527
528 end:
529 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
530 if (FLT_OPS(filter)->stream_set_backend &&
531 FLT_OPS(filter)->stream_set_backend(s, filter, be) < 0)
532 return -1;
533 }
534
Christopher Faulet92d36382015-11-05 13:35:03 +0100535 return 0;
536}
537
Christopher Fauletd7c91962015-04-30 11:48:27 +0200538
539/*
540 * Calls 'http_end' callback for all filters attached to a stream. All filters
541 * are called here, but only if there is at least one "data" filter. This
542 * functions is called when all data were parsed and forwarded. 'http_end'
543 * callback is resumable, so this function returns a negative value if an error
544 * occurs, 0 if it needs to wait for some reason, any other value otherwise.
545 */
546int
547flt_http_end(struct stream *s, struct http_msg *msg)
548{
Christopher Faulet22fca1f2020-11-16 10:10:38 +0100549 unsigned long long *strm_off = &FLT_STRM_OFF(s, msg->chn);
550 unsigned int offset = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200551 int ret = 1;
552
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100553 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200554 RESUME_FILTER_LOOP(s, msg->chn) {
Christopher Faulet22fca1f2020-11-16 10:10:38 +0100555 unsigned long long flt_off = FLT_OFF(filter, msg->chn);
556 offset = flt_off - *strm_off;
557
Christopher Faulet401e6db2020-11-24 09:49:01 +0100558 /* Call http_end for data filters only. But the filter offset is
559 * still valid for all filters
560 . */
561 if (!IS_DATA_FILTER(filter, msg->chn))
562 continue;
563
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100564 if (FLT_OPS(filter)->http_end) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100565 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100566 ret = FLT_OPS(filter)->http_end(s, filter, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200567 if (ret <= 0)
568 BREAK_EXECUTION(s, msg->chn, end);
569 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200570 } RESUME_FILTER_END;
Christopher Faulet22fca1f2020-11-16 10:10:38 +0100571
572 c_adv(msg->chn, offset);
573 *strm_off += offset;
574
Christopher Fauletd7c91962015-04-30 11:48:27 +0200575end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100576 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200577 return ret;
578}
579
580/*
581 * Calls 'http_reset' callback for all filters attached to a stream. This
582 * happens when a 100-continue response is received.
583 */
584void
585flt_http_reset(struct stream *s, struct http_msg *msg)
586{
587 struct filter *filter;
588
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100589 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100590 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100591 if (FLT_OPS(filter)->http_reset) {
592 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100593 FLT_OPS(filter)->http_reset(s, filter, msg);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100594 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200595 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100596 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200597}
598
599/*
600 * Calls 'http_reply' callback for all filters attached to a stream when HA
601 * decides to stop the HTTP message processing.
602 */
603void
Willy Tarreau83061a82018-07-13 11:56:34 +0200604flt_http_reply(struct stream *s, short status, const struct buffer *msg)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200605{
606 struct filter *filter;
607
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100608 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100609 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100610 if (FLT_OPS(filter)->http_reply) {
611 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100612 FLT_OPS(filter)->http_reply(s, filter, status, msg);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100613 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200614 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100615 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200616}
617
618/*
Christopher Faulet75bc9132018-11-30 15:18:09 +0100619 * Calls 'http_payload' callback for all "data" filters attached to a
620 * stream. This function is called when some data can be forwarded in the
621 * AN_REQ_HTTP_XFER_BODY and AN_RES_HTTP_XFER_BODY analyzers. It takes care to
622 * update the filters and the stream offset to be sure that a filter cannot
623 * forward more data than its predecessors. A filter can choose to not forward
624 * all data. Returns a negative value if an error occurs, else the number of
625 * forwarded bytes.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100626 */
627int
628flt_http_payload(struct stream *s, struct http_msg *msg, unsigned int len)
629{
630 struct filter *filter;
631 unsigned long long *strm_off = &FLT_STRM_OFF(s, msg->chn);
Christopher Faulet421e7692019-06-13 11:16:45 +0200632 unsigned int out = co_data(msg->chn);
Christopher Faulet81340d72020-02-26 15:47:22 +0100633 int ret, data;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100634
Christopher Faulet81340d72020-02-26 15:47:22 +0100635 ret = data = len - out;
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100636 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100637 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet401e6db2020-11-24 09:49:01 +0100638 unsigned long long *flt_off = &FLT_OFF(filter, msg->chn);
639 unsigned int offset = *flt_off - *strm_off;
640
641 /* Call http_payload for filters only. Forward all data for
642 * others and update the filter offset
643 */
644 if (!IS_DATA_FILTER(filter, msg->chn)) {
645 *flt_off += data - offset;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100646 continue;
Christopher Faulet401e6db2020-11-24 09:49:01 +0100647 }
Christopher Faulet75bc9132018-11-30 15:18:09 +0100648
Christopher Faulet401e6db2020-11-24 09:49:01 +0100649 if (FLT_OPS(filter)->http_payload) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100650 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet71179a32020-02-07 16:40:33 +0100651 ret = FLT_OPS(filter)->http_payload(s, filter, msg, out + offset, data - offset);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100652 if (ret < 0)
653 goto end;
Christopher Fauletc50ee0b2020-02-24 16:20:09 +0100654 data = ret + *flt_off - *strm_off;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100655 *flt_off += ret;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100656 }
657 }
Christopher Faulet71179a32020-02-07 16:40:33 +0100658
659 /* Only forward data if the last filter decides to forward something */
660 if (ret > 0) {
661 ret = data;
662 *strm_off += ret;
663 }
Christopher Faulet75bc9132018-11-30 15:18:09 +0100664 end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100665 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100666 return ret;
667}
668
669/*
Christopher Fauletd7c91962015-04-30 11:48:27 +0200670 * Calls 'channel_start_analyze' callback for all filters attached to a
671 * stream. This function is called when we start to analyze a request or a
672 * response. For frontend filters, it is called before all other analyzers. For
673 * backend ones, it is called before all backend
674 * analyzers. 'channel_start_analyze' callback is resumable, so this function
675 * returns 0 if an error occurs or if it needs to wait, any other value
676 * otherwise.
677 */
678int
679flt_start_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
680{
681 int ret = 1;
682
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100683 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
684
Christopher Fauletd7c91962015-04-30 11:48:27 +0200685 /* If this function is called, this means there is at least one filter,
686 * so we do not need to check the filter list's emptiness. */
687
Christopher Faulete6006242017-03-10 11:52:44 +0100688 /* Set flag on channel to tell that the channel is filtered */
689 chn->flags |= CF_FLT_ANALYZE;
690
Christopher Fauletd7c91962015-04-30 11:48:27 +0200691 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet0184ea72017-01-05 14:06:34 +0100692 if (!(chn->flags & CF_ISRESP)) {
693 if (an_bit == AN_REQ_FLT_START_BE &&
694 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
695 continue;
696 }
697 else {
698 if (an_bit == AN_RES_FLT_START_BE &&
699 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
700 continue;
701 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200702
Christopher Fauletb2e58492019-11-12 11:13:01 +0100703 FLT_OFF(filter, chn) = 0;
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100704 if (FLT_OPS(filter)->channel_start_analyze) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100705 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100706 ret = FLT_OPS(filter)->channel_start_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200707 if (ret <= 0)
708 BREAK_EXECUTION(s, chn, end);
709 }
710 } RESUME_FILTER_END;
711
712 end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100713 ret = handle_analyzer_result(s, chn, an_bit, ret);
714 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
715 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200716}
717
718/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200719 * Calls 'channel_pre_analyze' callback for all filters attached to a
720 * stream. This function is called BEFORE each analyzer attached to a channel,
721 * expects analyzers responsible for data sending. 'channel_pre_analyze'
722 * callback is resumable, so this function returns 0 if an error occurs or if it
723 * needs to wait, any other value otherwise.
724 *
725 * Note this function can be called many times for the same analyzer. In fact,
726 * it is called until the analyzer finishes its processing.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200727 */
728int
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200729flt_pre_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200730{
731 int ret = 1;
732
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100733 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
734
Christopher Fauletd7c91962015-04-30 11:48:27 +0200735 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200736 if (FLT_OPS(filter)->channel_pre_analyze && (filter->pre_analyzers & an_bit)) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100737 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200738 ret = FLT_OPS(filter)->channel_pre_analyze(s, filter, chn, an_bit);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200739 if (ret <= 0)
740 BREAK_EXECUTION(s, chn, check_result);
741 }
742 } RESUME_FILTER_END;
743
744 check_result:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100745 ret = handle_analyzer_result(s, chn, 0, ret);
746 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
747 return ret;
Christopher Faulet309c6412015-12-02 09:57:32 +0100748}
749
750/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200751 * Calls 'channel_post_analyze' callback for all filters attached to a
752 * stream. This function is called AFTER each analyzer attached to a channel,
753 * expects analyzers responsible for data sending. 'channel_post_analyze'
754 * callback is NOT resumable, so this function returns a 0 if an error occurs,
755 * any other value otherwise.
756 *
757 * Here, AFTER means when the analyzer finishes its processing.
758 */
759int
760flt_post_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
761{
762 struct filter *filter;
763 int ret = 1;
764
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100765 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
766
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200767 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
768 if (FLT_OPS(filter)->channel_post_analyze && (filter->post_analyzers & an_bit)) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100769 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200770 ret = FLT_OPS(filter)->channel_post_analyze(s, filter, chn, an_bit);
771 if (ret < 0)
772 break;
773 }
774 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100775 ret = handle_analyzer_result(s, chn, 0, ret);
776 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
777 return ret;
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200778}
779
780/*
Christopher Faulet0184ea72017-01-05 14:06:34 +0100781 * This function is the AN_REQ/RES_FLT_HTTP_HDRS analyzer, used to filter HTTP
782 * headers or a request or a response. Returns 0 if an error occurs or if it
783 * needs to wait, any other value otherwise.
Christopher Faulet309c6412015-12-02 09:57:32 +0100784 */
785int
786flt_analyze_http_headers(struct stream *s, struct channel *chn, unsigned int an_bit)
787{
Christopher Faulet1339d742016-05-11 16:48:33 +0200788 struct http_msg *msg;
789 int ret = 1;
Christopher Faulet309c6412015-12-02 09:57:32 +0100790
Christopher Faulet1339d742016-05-11 16:48:33 +0200791 msg = ((chn->flags & CF_ISRESP) ? &s->txn->rsp : &s->txn->req);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100792 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
793
Christopher Faulet309c6412015-12-02 09:57:32 +0100794 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet1339d742016-05-11 16:48:33 +0200795 if (FLT_OPS(filter)->http_headers) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100796 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet1339d742016-05-11 16:48:33 +0200797 ret = FLT_OPS(filter)->http_headers(s, filter, msg);
Christopher Faulet309c6412015-12-02 09:57:32 +0100798 if (ret <= 0)
799 BREAK_EXECUTION(s, chn, check_result);
800 }
801 } RESUME_FILTER_END;
Christopher Faulet9c44e482020-02-12 15:31:20 +0100802
803 if (HAS_DATA_FILTERS(s, chn)) {
804 size_t data = http_get_hdrs_size(htxbuf(&chn->buf));
805 struct filter *f;
806
Christopher Faulet401e6db2020-11-24 09:49:01 +0100807 list_for_each_entry(f, &strm_flt(s)->filters, list)
808 FLT_OFF(f, chn) = data;
Christopher Faulet9c44e482020-02-12 15:31:20 +0100809 }
Christopher Faulet309c6412015-12-02 09:57:32 +0100810
811 check_result:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100812 ret = handle_analyzer_result(s, chn, an_bit, ret);
813 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
814 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200815}
816
817/*
818 * Calls 'channel_end_analyze' callback for all filters attached to a
819 * stream. This function is called when we stop to analyze a request or a
820 * response. It is called after all other analyzers. 'channel_end_analyze'
821 * callback is resumable, so this function returns 0 if an error occurs or if it
822 * needs to wait, any other value otherwise.
823 */
824int
825flt_end_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
826{
827 int ret = 1;
828
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100829 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
830
Christopher Faulete6006242017-03-10 11:52:44 +0100831 /* Check if all filters attached on the stream have finished their
832 * processing on this channel. */
833 if (!(chn->flags & CF_FLT_ANALYZE))
834 goto sync;
835
Christopher Fauletd7c91962015-04-30 11:48:27 +0200836 RESUME_FILTER_LOOP(s, chn) {
Christopher Fauletb2e58492019-11-12 11:13:01 +0100837 FLT_OFF(filter, chn) = 0;
Christopher Fauletda02e172015-12-04 09:25:05 +0100838 unregister_data_filter(s, chn, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200839
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100840 if (FLT_OPS(filter)->channel_end_analyze) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100841 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100842 ret = FLT_OPS(filter)->channel_end_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200843 if (ret <= 0)
844 BREAK_EXECUTION(s, chn, end);
845 }
846 } RESUME_FILTER_END;
847
Christopher Faulete6006242017-03-10 11:52:44 +0100848 end:
849 /* We don't remove yet this analyzer because we need to synchronize the
850 * both channels. So here, we just remove the flag CF_FLT_ANALYZE. */
851 ret = handle_analyzer_result(s, chn, 0, ret);
Christopher Faulet570f7992017-07-06 15:53:02 +0200852 if (ret) {
Christopher Faulete6006242017-03-10 11:52:44 +0100853 chn->flags &= ~CF_FLT_ANALYZE;
Christopher Faulet02c7b222015-12-22 12:01:29 +0100854
Christopher Faulet570f7992017-07-06 15:53:02 +0200855 /* Pretend there is an activity on both channels. Flag on the
856 * current one will be automatically removed, so only the other
857 * one will remain. This is a way to be sure that
858 * 'channel_end_analyze' callback will have a chance to be
859 * called at least once for the other side to finish the current
Joseph Herlantb35ea682018-11-15 12:24:23 -0800860 * processing. Of course, this is the filter responsibility to
Christopher Faulet570f7992017-07-06 15:53:02 +0200861 * wakeup the stream if it choose to loop on this callback. */
862 s->req.flags |= CF_WAKE_ONCE;
863 s->res.flags |= CF_WAKE_ONCE;
864 }
865
866
Christopher Faulete6006242017-03-10 11:52:44 +0100867 sync:
868 /* Now we can check if filters have finished their work on the both
869 * channels */
870 if (!(s->req.flags & CF_FLT_ANALYZE) && !(s->res.flags & CF_FLT_ANALYZE)) {
871 /* Sync channels by removing this analyzer for the both channels */
872 s->req.analysers &= ~AN_REQ_FLT_END;
873 s->res.analysers &= ~AN_RES_FLT_END;
Christopher Fauletc6062be2016-10-31 11:22:37 +0100874
Christopher Faulete6006242017-03-10 11:52:44 +0100875 /* Remove backend filters from the list */
876 flt_stream_release(s, 1);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100877 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200878 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100879 else {
880 DBG_TRACE_DEVEL("waiting for sync", STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
881 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200882 return ret;
883}
884
Christopher Fauletd7c91962015-04-30 11:48:27 +0200885
886/*
Christopher Fauletb2e58492019-11-12 11:13:01 +0100887 * Calls 'tcp_payload' callback for all "data" filters attached to a
888 * stream. This function is called when some data can be forwarded in the
889 * AN_REQ_FLT_XFER_BODY and AN_RES_FLT_XFER_BODY analyzers. It takes care to
890 * update the filters and the stream offset to be sure that a filter cannot
891 * forward more data than its predecessors. A filter can choose to not forward
892 * all data. Returns a negative value if an error occurs, else the number of
893 * forwarded bytes.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200894 */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100895int
896flt_tcp_payload(struct stream *s, struct channel *chn, unsigned int len)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200897{
Christopher Fauletda02e172015-12-04 09:25:05 +0100898 struct filter *filter;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100899 unsigned long long *strm_off = &FLT_STRM_OFF(s, chn);
900 unsigned int out = co_data(chn);
Christopher Faulet81340d72020-02-26 15:47:22 +0100901 int ret, data;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200902
Christopher Faulet81340d72020-02-26 15:47:22 +0100903 ret = data = len - out;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100904 DBG_TRACE_ENTER(STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100905 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet401e6db2020-11-24 09:49:01 +0100906 unsigned long long *flt_off = &FLT_OFF(filter, chn);
907 unsigned int offset = *flt_off - *strm_off;
908
909 /* Call tcp_payload for filters only. Forward all data for
910 * others and update the filter offset
911 */
912 if (!IS_DATA_FILTER(filter, chn)) {
913 *flt_off += data - offset;
Christopher Fauletda02e172015-12-04 09:25:05 +0100914 continue;
Christopher Faulet401e6db2020-11-24 09:49:01 +0100915 }
916
Christopher Fauletb2e58492019-11-12 11:13:01 +0100917 if (FLT_OPS(filter)->tcp_payload) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100918
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100919 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet71179a32020-02-07 16:40:33 +0100920 ret = FLT_OPS(filter)->tcp_payload(s, filter, chn, out + offset, data - offset);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200921 if (ret < 0)
922 goto end;
Christopher Fauletc50ee0b2020-02-24 16:20:09 +0100923 data = ret + *flt_off - *strm_off;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100924 *flt_off += ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200925 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200926 }
Christopher Faulet71179a32020-02-07 16:40:33 +0100927
928 /* Only forward data if the last filter decides to forward something */
929 if (ret > 0) {
930 ret = data;
931 *strm_off += ret;
932 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200933 end:
Christopher Fauletb2e58492019-11-12 11:13:01 +0100934 DBG_TRACE_LEAVE(STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200935 return ret;
936}
937
938/*
939 * Called when TCP data must be filtered on a channel. This function is the
Christopher Faulet0184ea72017-01-05 14:06:34 +0100940 * AN_REQ/RES_FLT_XFER_DATA analyzer. When called, it is responsible to forward
941 * data when the proxy is not in http mode. Behind the scene, it calls
942 * consecutively 'tcp_data' and 'tcp_forward_data' callbacks for all "data"
943 * filters attached to a stream. Returns 0 if an error occurs or if it needs to
944 * wait, any other value otherwise.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200945 */
946int
947flt_xfer_data(struct stream *s, struct channel *chn, unsigned int an_bit)
948{
Christopher Fauletb2e58492019-11-12 11:13:01 +0100949 unsigned int len;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200950 int ret = 1;
951
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100952 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
953
Christopher Fauletda02e172015-12-04 09:25:05 +0100954 /* If there is no "data" filters, we do nothing */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100955 if (!HAS_DATA_FILTERS(s, chn))
Christopher Fauletda02e172015-12-04 09:25:05 +0100956 goto end;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200957
958 /* Be sure that the output is still opened. Else we stop the data
959 * filtering. */
960 if ((chn->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) ||
Willy Tarreau44a41a82018-06-19 07:16:31 +0200961 ((chn->flags & CF_SHUTW) && (chn->to_forward || co_data(chn))))
Christopher Fauletd7c91962015-04-30 11:48:27 +0200962 goto end;
963
Christopher Fauletb2e58492019-11-12 11:13:01 +0100964 if (s->flags & SF_HTX) {
965 struct htx *htx = htxbuf(&chn->buf);
966 len = htx->data;
967 }
968 else
969 len = c_data(chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200970
Christopher Fauletb2e58492019-11-12 11:13:01 +0100971 ret = flt_tcp_payload(s, chn, len);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200972 if (ret < 0)
973 goto end;
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200974 c_adv(chn, ret);
Christopher Fauletda02e172015-12-04 09:25:05 +0100975
Christopher Fauletd7c91962015-04-30 11:48:27 +0200976 /* Stop waiting data if the input in closed and no data is pending or if
977 * the output is closed. */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100978 if (chn->flags & CF_SHUTW) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200979 ret = 1;
980 goto end;
981 }
Christopher Fauletb2e58492019-11-12 11:13:01 +0100982 if (chn->flags & CF_SHUTR) {
983 if (((s->flags & SF_HTX) && htx_is_empty(htxbuf(&chn->buf))) || c_empty(chn)) {
984 ret = 1;
985 goto end;
986 }
987 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200988
989 /* Wait for data */
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100990 DBG_TRACE_DEVEL("waiting for more data", STRM_EV_STRM_ANA|STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200991 return 0;
992 end:
993 /* Terminate the data filtering. If <ret> is negative, an error was
994 * encountered during the filtering. */
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100995 ret = handle_analyzer_result(s, chn, an_bit, ret);
996 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
997 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200998}
999
1000/*
1001 * Handles result of filter's analyzers. It returns 0 if an error occurs or if
1002 * it needs to wait, any other value otherwise.
1003 */
1004static int
1005handle_analyzer_result(struct stream *s, struct channel *chn,
1006 unsigned int an_bit, int ret)
1007{
1008 int finst;
Christopher Faulete058f732019-09-06 15:24:55 +02001009 int status = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001010
1011 if (ret < 0)
1012 goto return_bad_req;
1013 else if (!ret)
1014 goto wait;
1015
1016 /* End of job, return OK */
1017 if (an_bit) {
1018 chn->analysers &= ~an_bit;
1019 chn->analyse_exp = TICK_ETERNITY;
1020 }
1021 return 1;
1022
1023 return_bad_req:
1024 /* An error occurs */
1025 channel_abort(&s->req);
1026 channel_abort(&s->res);
1027
1028 if (!(chn->flags & CF_ISRESP)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001029 s->req.analysers &= AN_REQ_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001030 finst = SF_FINST_R;
Christopher Faulete058f732019-09-06 15:24:55 +02001031 status = 400;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001032 /* FIXME: incr counters */
1033 }
1034 else {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001035 s->res.analysers &= AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001036 finst = SF_FINST_H;
Christopher Faulete058f732019-09-06 15:24:55 +02001037 status = 502;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001038 /* FIXME: incr counters */
1039 }
1040
Christopher Faulet3d119692019-07-15 22:04:51 +02001041 if (IS_HTX_STRM(s)) {
Christopher Fauletd7c91962015-04-30 11:48:27 +02001042 /* Do not do that when we are waiting for the next request */
Christopher Faulete058f732019-09-06 15:24:55 +02001043 if (s->txn->status > 0)
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001044 http_reply_and_close(s, s->txn->status, NULL);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001045 else {
Christopher Faulete058f732019-09-06 15:24:55 +02001046 s->txn->status = status;
1047 http_reply_and_close(s, status, http_error_message(s));
Christopher Fauletd7c91962015-04-30 11:48:27 +02001048 }
1049 }
1050
1051 if (!(s->flags & SF_ERR_MASK))
1052 s->flags |= SF_ERR_PRXCOND;
1053 if (!(s->flags & SF_FINST_MASK))
1054 s->flags |= finst;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001055 DBG_TRACE_DEVEL("leaving on error", STRM_EV_FLT_ANA|STRM_EV_FLT_ERR, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001056 return 0;
1057
1058 wait:
1059 if (!(chn->flags & CF_ISRESP))
1060 channel_dont_connect(chn);
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001061 DBG_TRACE_DEVEL("wairing for more data", STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001062 return 0;
1063}
1064
1065
1066/* Note: must not be declared <const> as its list will be overwritten.
1067 * Please take care of keeping this list alphabetically sorted, doing so helps
1068 * all code contributors.
1069 * Optional keywords are also declared with a NULL ->parse() function so that
1070 * the config parser can report an appropriate error when a known keyword was
1071 * not enabled. */
1072static struct cfg_kw_list cfg_kws = {ILH, {
1073 { CFG_LISTEN, "filter", parse_filter },
1074 { 0, NULL, NULL },
1075 }
1076};
1077
Willy Tarreau0108d902018-11-25 19:14:37 +01001078INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1079
Willy Tarreau172f5ce2018-11-26 11:21:50 +01001080REGISTER_POST_CHECK(flt_init_all);
1081REGISTER_PER_THREAD_INIT(flt_init_all_per_thread);
1082REGISTER_PER_THREAD_DEINIT(flt_deinit_all_per_thread);
1083
Christopher Fauletd7c91962015-04-30 11:48:27 +02001084/*
1085 * Local variables:
1086 * c-indent-level: 8
1087 * c-basic-offset: 8
1088 * End:
1089 */