blob: b5e83aec3798b8cd8c8c3415b7ef291dbc281fec [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 }
187 if (!strcmp(args[0], "filter")) {
188 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;
291 int err_code = 0;
292
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 }
Christopher Faulet1b89c272021-03-08 13:40:30 +0100476 if (strm_li(s) && (strm_li(s)->analysers & AN_REQ_FLT_START_FE))
477 s->req.flags |= CF_FLT_ANALYZE;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200478 return 0;
479}
480
481/*
482 * Calls 'stream_stop' for all filters attached to a stream. This happens when
483 * the stream is stopped, just before calling flt_stream_release function.
484 */
485void
486flt_stream_stop(struct stream *s)
487{
488 struct filter *filter;
489
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100490 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100491 if (FLT_OPS(filter)->stream_stop)
492 FLT_OPS(filter)->stream_stop(s, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200493 }
494}
495
Christopher Faulet92d36382015-11-05 13:35:03 +0100496/*
Christopher Fauleta00d8172016-11-10 14:58:05 +0100497 * Calls 'check_timeouts' for all filters attached to a stream. This happens when
498 * the stream is woken up because of expired timer.
499 */
500void
501flt_stream_check_timeouts(struct stream *s)
502{
503 struct filter *filter;
504
505 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
506 if (FLT_OPS(filter)->check_timeouts)
507 FLT_OPS(filter)->check_timeouts(s, filter);
508 }
509}
510
511/*
Christopher Faulet92d36382015-11-05 13:35:03 +0100512 * Called when a backend is set for a stream. If the frontend and the backend
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200513 * are not the same, this function attaches all backend filters to the
514 * stream. Returns -1 if an error occurs, 0 otherwise.
Christopher Faulet92d36382015-11-05 13:35:03 +0100515 */
516int
517flt_set_stream_backend(struct stream *s, struct proxy *be)
518{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100519 struct flt_conf *fconf;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200520 struct filter *filter;
Christopher Faulet92d36382015-11-05 13:35:03 +0100521
522 if (strm_fe(s) == be)
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200523 goto end;
Christopher Faulet92d36382015-11-05 13:35:03 +0100524
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100525 list_for_each_entry(fconf, &be->filter_configs, list) {
526 if (flt_stream_add_filter(s, fconf, FLT_FL_IS_BACKEND_FILTER) < 0)
Christopher Faulet92d36382015-11-05 13:35:03 +0100527 return -1;
528 }
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200529
530 end:
531 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
532 if (FLT_OPS(filter)->stream_set_backend &&
533 FLT_OPS(filter)->stream_set_backend(s, filter, be) < 0)
534 return -1;
535 }
Christopher Faulet1b89c272021-03-08 13:40:30 +0100536 if (be->be_req_ana & AN_REQ_FLT_START_BE)
537 s->req.flags |= CF_FLT_ANALYZE;
538 if ((strm_fe(s)->fe_rsp_ana | be->be_rsp_ana) & (AN_RES_FLT_START_FE|AN_RES_FLT_START_BE))
539 s->res.flags |= CF_FLT_ANALYZE;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200540
Christopher Faulet92d36382015-11-05 13:35:03 +0100541 return 0;
542}
543
Christopher Fauletd7c91962015-04-30 11:48:27 +0200544
545/*
546 * Calls 'http_end' callback for all filters attached to a stream. All filters
547 * are called here, but only if there is at least one "data" filter. This
548 * functions is called when all data were parsed and forwarded. 'http_end'
549 * callback is resumable, so this function returns a negative value if an error
550 * occurs, 0 if it needs to wait for some reason, any other value otherwise.
551 */
552int
553flt_http_end(struct stream *s, struct http_msg *msg)
554{
Christopher Faulet44ba5db2020-11-16 10:10:38 +0100555 unsigned long long *strm_off = &FLT_STRM_OFF(s, msg->chn);
556 unsigned int offset = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200557 int ret = 1;
558
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100559 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 +0200560 RESUME_FILTER_LOOP(s, msg->chn) {
Christopher Faulet44ba5db2020-11-16 10:10:38 +0100561 unsigned long long flt_off = FLT_OFF(filter, msg->chn);
562 offset = flt_off - *strm_off;
563
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100564 /* Call http_end for data filters only. But the filter offset is
565 * still valid for all filters
566 . */
567 if (!IS_DATA_FILTER(filter, msg->chn))
568 continue;
569
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100570 if (FLT_OPS(filter)->http_end) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100571 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100572 ret = FLT_OPS(filter)->http_end(s, filter, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200573 if (ret <= 0)
574 BREAK_EXECUTION(s, msg->chn, end);
575 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200576 } RESUME_FILTER_END;
Christopher Faulet44ba5db2020-11-16 10:10:38 +0100577
578 c_adv(msg->chn, offset);
579 *strm_off += offset;
580
Christopher Fauletd7c91962015-04-30 11:48:27 +0200581end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100582 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200583 return ret;
584}
585
586/*
587 * Calls 'http_reset' callback for all filters attached to a stream. This
588 * happens when a 100-continue response is received.
589 */
590void
591flt_http_reset(struct stream *s, struct http_msg *msg)
592{
593 struct filter *filter;
594
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100595 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 +0100596 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100597 if (FLT_OPS(filter)->http_reset) {
598 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100599 FLT_OPS(filter)->http_reset(s, filter, msg);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100600 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200601 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100602 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200603}
604
605/*
606 * Calls 'http_reply' callback for all filters attached to a stream when HA
607 * decides to stop the HTTP message processing.
608 */
609void
Willy Tarreau83061a82018-07-13 11:56:34 +0200610flt_http_reply(struct stream *s, short status, const struct buffer *msg)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200611{
612 struct filter *filter;
613
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100614 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 +0100615 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100616 if (FLT_OPS(filter)->http_reply) {
617 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100618 FLT_OPS(filter)->http_reply(s, filter, status, msg);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100619 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200620 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100621 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200622}
623
624/*
Christopher Faulet75bc9132018-11-30 15:18:09 +0100625 * Calls 'http_payload' callback for all "data" filters attached to a
626 * stream. This function is called when some data can be forwarded in the
627 * AN_REQ_HTTP_XFER_BODY and AN_RES_HTTP_XFER_BODY analyzers. It takes care to
628 * update the filters and the stream offset to be sure that a filter cannot
629 * forward more data than its predecessors. A filter can choose to not forward
630 * all data. Returns a negative value if an error occurs, else the number of
631 * forwarded bytes.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100632 */
633int
634flt_http_payload(struct stream *s, struct http_msg *msg, unsigned int len)
635{
636 struct filter *filter;
637 unsigned long long *strm_off = &FLT_STRM_OFF(s, msg->chn);
Christopher Faulet421e7692019-06-13 11:16:45 +0200638 unsigned int out = co_data(msg->chn);
Christopher Faulet81340d72020-02-26 15:47:22 +0100639 int ret, data;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100640
Christopher Faulet65e7b382021-01-25 12:02:00 +0100641 strm_flt(s)->flags &= ~STRM_FLT_FL_HOLD_HTTP_HDRS;
642
Christopher Faulet81340d72020-02-26 15:47:22 +0100643 ret = data = len - out;
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100644 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 +0100645 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100646 unsigned long long *flt_off = &FLT_OFF(filter, msg->chn);
647 unsigned int offset = *flt_off - *strm_off;
648
649 /* Call http_payload for filters only. Forward all data for
650 * others and update the filter offset
651 */
652 if (!IS_DATA_FILTER(filter, msg->chn)) {
653 *flt_off += data - offset;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100654 continue;
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100655 }
Christopher Faulet75bc9132018-11-30 15:18:09 +0100656
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100657 if (FLT_OPS(filter)->http_payload) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100658 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet71179a32020-02-07 16:40:33 +0100659 ret = FLT_OPS(filter)->http_payload(s, filter, msg, out + offset, data - offset);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100660 if (ret < 0)
661 goto end;
Christopher Fauletc50ee0b2020-02-24 16:20:09 +0100662 data = ret + *flt_off - *strm_off;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100663 *flt_off += ret;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100664 }
665 }
Christopher Faulet71179a32020-02-07 16:40:33 +0100666
Christopher Faulet65e7b382021-01-25 12:02:00 +0100667 /* If nothing was forwarded yet, we take care to hold the headers if
668 * following conditions are met :
669 *
670 * - *strm_off == 0 (nothing forwarded yet)
671 * - ret == 0 (no data forwarded at all on this turn)
672 * - STRM_FLT_FL_HOLD_HTTP_HDRS flag set (at least one filter want to hold the headers)
673 *
674 * Be careful, STRM_FLT_FL_HOLD_HTTP_HDRS is removed before each http_payload loop.
675 * Thus, it must explicitly be set when necessary. We must do that to hold the headers
676 * when there is no payload.
677 */
678 if (!ret && !*strm_off && (strm_flt(s)->flags & STRM_FLT_FL_HOLD_HTTP_HDRS))
679 goto end;
680
681 ret = data;
682 *strm_off += ret;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100683 end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100684 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100685 return ret;
686}
687
688/*
Christopher Fauletd7c91962015-04-30 11:48:27 +0200689 * Calls 'channel_start_analyze' callback for all filters attached to a
690 * stream. This function is called when we start to analyze a request or a
691 * response. For frontend filters, it is called before all other analyzers. For
692 * backend ones, it is called before all backend
693 * analyzers. 'channel_start_analyze' callback is resumable, so this function
694 * returns 0 if an error occurs or if it needs to wait, any other value
695 * otherwise.
696 */
697int
698flt_start_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
699{
700 int ret = 1;
701
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100702 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
703
Christopher Fauletd7c91962015-04-30 11:48:27 +0200704 /* If this function is called, this means there is at least one filter,
705 * so we do not need to check the filter list's emptiness. */
706
Christopher Faulete6006242017-03-10 11:52:44 +0100707 /* Set flag on channel to tell that the channel is filtered */
708 chn->flags |= CF_FLT_ANALYZE;
709
Christopher Fauletd7c91962015-04-30 11:48:27 +0200710 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet0184ea72017-01-05 14:06:34 +0100711 if (!(chn->flags & CF_ISRESP)) {
712 if (an_bit == AN_REQ_FLT_START_BE &&
713 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
714 continue;
715 }
716 else {
717 if (an_bit == AN_RES_FLT_START_BE &&
718 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
719 continue;
720 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200721
Christopher Fauletb2e58492019-11-12 11:13:01 +0100722 FLT_OFF(filter, chn) = 0;
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100723 if (FLT_OPS(filter)->channel_start_analyze) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100724 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100725 ret = FLT_OPS(filter)->channel_start_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200726 if (ret <= 0)
727 BREAK_EXECUTION(s, chn, end);
728 }
729 } RESUME_FILTER_END;
730
731 end:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100732 ret = handle_analyzer_result(s, chn, an_bit, ret);
733 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
734 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200735}
736
737/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200738 * Calls 'channel_pre_analyze' callback for all filters attached to a
739 * stream. This function is called BEFORE each analyzer attached to a channel,
740 * expects analyzers responsible for data sending. 'channel_pre_analyze'
741 * callback is resumable, so this function returns 0 if an error occurs or if it
742 * needs to wait, any other value otherwise.
743 *
744 * Note this function can be called many times for the same analyzer. In fact,
745 * it is called until the analyzer finishes its processing.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200746 */
747int
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200748flt_pre_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200749{
750 int ret = 1;
751
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100752 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
753
Christopher Fauletd7c91962015-04-30 11:48:27 +0200754 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200755 if (FLT_OPS(filter)->channel_pre_analyze && (filter->pre_analyzers & an_bit)) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100756 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200757 ret = FLT_OPS(filter)->channel_pre_analyze(s, filter, chn, an_bit);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200758 if (ret <= 0)
759 BREAK_EXECUTION(s, chn, check_result);
Christopher Faulet088f3782021-05-20 18:00:55 +0200760 filter->pre_analyzers &= ~an_bit;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200761 }
762 } RESUME_FILTER_END;
763
764 check_result:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100765 ret = handle_analyzer_result(s, chn, 0, ret);
766 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
767 return ret;
Christopher Faulet309c6412015-12-02 09:57:32 +0100768}
769
770/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200771 * Calls 'channel_post_analyze' callback for all filters attached to a
772 * stream. This function is called AFTER each analyzer attached to a channel,
773 * expects analyzers responsible for data sending. 'channel_post_analyze'
774 * callback is NOT resumable, so this function returns a 0 if an error occurs,
775 * any other value otherwise.
776 *
777 * Here, AFTER means when the analyzer finishes its processing.
778 */
779int
780flt_post_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
781{
782 struct filter *filter;
783 int ret = 1;
784
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100785 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
786
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200787 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
788 if (FLT_OPS(filter)->channel_post_analyze && (filter->post_analyzers & an_bit)) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100789 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200790 ret = FLT_OPS(filter)->channel_post_analyze(s, filter, chn, an_bit);
791 if (ret < 0)
792 break;
Christopher Faulet088f3782021-05-20 18:00:55 +0200793 filter->post_analyzers &= ~an_bit;
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200794 }
795 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100796 ret = handle_analyzer_result(s, chn, 0, ret);
797 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
798 return ret;
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200799}
800
801/*
Christopher Faulet0184ea72017-01-05 14:06:34 +0100802 * This function is the AN_REQ/RES_FLT_HTTP_HDRS analyzer, used to filter HTTP
803 * headers or a request or a response. Returns 0 if an error occurs or if it
804 * needs to wait, any other value otherwise.
Christopher Faulet309c6412015-12-02 09:57:32 +0100805 */
806int
807flt_analyze_http_headers(struct stream *s, struct channel *chn, unsigned int an_bit)
808{
Christopher Faulet1339d742016-05-11 16:48:33 +0200809 struct http_msg *msg;
810 int ret = 1;
Christopher Faulet309c6412015-12-02 09:57:32 +0100811
Christopher Faulet1339d742016-05-11 16:48:33 +0200812 msg = ((chn->flags & CF_ISRESP) ? &s->txn->rsp : &s->txn->req);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100813 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s, s->txn, msg);
814
Christopher Faulet309c6412015-12-02 09:57:32 +0100815 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet1339d742016-05-11 16:48:33 +0200816 if (FLT_OPS(filter)->http_headers) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100817 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet1339d742016-05-11 16:48:33 +0200818 ret = FLT_OPS(filter)->http_headers(s, filter, msg);
Christopher Faulet309c6412015-12-02 09:57:32 +0100819 if (ret <= 0)
820 BREAK_EXECUTION(s, chn, check_result);
821 }
822 } RESUME_FILTER_END;
Christopher Faulet9c44e482020-02-12 15:31:20 +0100823
824 if (HAS_DATA_FILTERS(s, chn)) {
825 size_t data = http_get_hdrs_size(htxbuf(&chn->buf));
826 struct filter *f;
827
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100828 list_for_each_entry(f, &strm_flt(s)->filters, list)
829 FLT_OFF(f, chn) = data;
Christopher Faulet9c44e482020-02-12 15:31:20 +0100830 }
Christopher Faulet309c6412015-12-02 09:57:32 +0100831
832 check_result:
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100833 ret = handle_analyzer_result(s, chn, an_bit, ret);
834 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_HTTP_ANA|STRM_EV_FLT_ANA, s);
835 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200836}
837
838/*
839 * Calls 'channel_end_analyze' callback for all filters attached to a
840 * stream. This function is called when we stop to analyze a request or a
841 * response. It is called after all other analyzers. 'channel_end_analyze'
842 * callback is resumable, so this function returns 0 if an error occurs or if it
843 * needs to wait, any other value otherwise.
844 */
845int
846flt_end_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
847{
848 int ret = 1;
849
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100850 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
851
Christopher Faulete6006242017-03-10 11:52:44 +0100852 /* Check if all filters attached on the stream have finished their
853 * processing on this channel. */
854 if (!(chn->flags & CF_FLT_ANALYZE))
855 goto sync;
856
Christopher Fauletd7c91962015-04-30 11:48:27 +0200857 RESUME_FILTER_LOOP(s, chn) {
Christopher Fauletb2e58492019-11-12 11:13:01 +0100858 FLT_OFF(filter, chn) = 0;
Christopher Fauletda02e172015-12-04 09:25:05 +0100859 unregister_data_filter(s, chn, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200860
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100861 if (FLT_OPS(filter)->channel_end_analyze) {
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100862 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_FLT_ANA, s);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100863 ret = FLT_OPS(filter)->channel_end_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200864 if (ret <= 0)
865 BREAK_EXECUTION(s, chn, end);
866 }
867 } RESUME_FILTER_END;
868
Christopher Faulete6006242017-03-10 11:52:44 +0100869 end:
870 /* We don't remove yet this analyzer because we need to synchronize the
871 * both channels. So here, we just remove the flag CF_FLT_ANALYZE. */
872 ret = handle_analyzer_result(s, chn, 0, ret);
Christopher Faulet570f7992017-07-06 15:53:02 +0200873 if (ret) {
Christopher Faulete6006242017-03-10 11:52:44 +0100874 chn->flags &= ~CF_FLT_ANALYZE;
Christopher Faulet02c7b222015-12-22 12:01:29 +0100875
Christopher Faulet570f7992017-07-06 15:53:02 +0200876 /* Pretend there is an activity on both channels. Flag on the
877 * current one will be automatically removed, so only the other
878 * one will remain. This is a way to be sure that
879 * 'channel_end_analyze' callback will have a chance to be
880 * called at least once for the other side to finish the current
Joseph Herlantb35ea682018-11-15 12:24:23 -0800881 * processing. Of course, this is the filter responsibility to
Christopher Faulet570f7992017-07-06 15:53:02 +0200882 * wakeup the stream if it choose to loop on this callback. */
883 s->req.flags |= CF_WAKE_ONCE;
884 s->res.flags |= CF_WAKE_ONCE;
885 }
886
887
Christopher Faulete6006242017-03-10 11:52:44 +0100888 sync:
889 /* Now we can check if filters have finished their work on the both
890 * channels */
891 if (!(s->req.flags & CF_FLT_ANALYZE) && !(s->res.flags & CF_FLT_ANALYZE)) {
892 /* Sync channels by removing this analyzer for the both channels */
893 s->req.analysers &= ~AN_REQ_FLT_END;
894 s->res.analysers &= ~AN_RES_FLT_END;
Christopher Fauletc6062be2016-10-31 11:22:37 +0100895
Christopher Faulete6006242017-03-10 11:52:44 +0100896 /* Remove backend filters from the list */
897 flt_stream_release(s, 1);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100898 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200899 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100900 else {
901 DBG_TRACE_DEVEL("waiting for sync", STRM_EV_STRM_ANA|STRM_EV_FLT_ANA, s);
902 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200903 return ret;
904}
905
Christopher Fauletd7c91962015-04-30 11:48:27 +0200906
907/*
Christopher Fauletb2e58492019-11-12 11:13:01 +0100908 * Calls 'tcp_payload' callback for all "data" filters attached to a
909 * stream. This function is called when some data can be forwarded in the
910 * AN_REQ_FLT_XFER_BODY and AN_RES_FLT_XFER_BODY analyzers. It takes care to
911 * update the filters and the stream offset to be sure that a filter cannot
912 * forward more data than its predecessors. A filter can choose to not forward
913 * all data. Returns a negative value if an error occurs, else the number of
914 * forwarded bytes.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200915 */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100916int
917flt_tcp_payload(struct stream *s, struct channel *chn, unsigned int len)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200918{
Christopher Fauletda02e172015-12-04 09:25:05 +0100919 struct filter *filter;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100920 unsigned long long *strm_off = &FLT_STRM_OFF(s, chn);
921 unsigned int out = co_data(chn);
Christopher Faulet81340d72020-02-26 15:47:22 +0100922 int ret, data;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200923
Christopher Faulet81340d72020-02-26 15:47:22 +0100924 ret = data = len - out;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100925 DBG_TRACE_ENTER(STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100926 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100927 unsigned long long *flt_off = &FLT_OFF(filter, chn);
928 unsigned int offset = *flt_off - *strm_off;
929
930 /* Call tcp_payload for filters only. Forward all data for
931 * others and update the filter offset
932 */
933 if (!IS_DATA_FILTER(filter, chn)) {
934 *flt_off += data - offset;
Christopher Fauletda02e172015-12-04 09:25:05 +0100935 continue;
Christopher Fauletbd2dc872020-11-24 09:49:01 +0100936 }
937
Christopher Fauletb2e58492019-11-12 11:13:01 +0100938 if (FLT_OPS(filter)->tcp_payload) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100939
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100940 DBG_TRACE_DEVEL(FLT_ID(filter), STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Faulet71179a32020-02-07 16:40:33 +0100941 ret = FLT_OPS(filter)->tcp_payload(s, filter, chn, out + offset, data - offset);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200942 if (ret < 0)
943 goto end;
Christopher Fauletc50ee0b2020-02-24 16:20:09 +0100944 data = ret + *flt_off - *strm_off;
Christopher Fauletb2e58492019-11-12 11:13:01 +0100945 *flt_off += ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200946 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200947 }
Christopher Faulet71179a32020-02-07 16:40:33 +0100948
949 /* Only forward data if the last filter decides to forward something */
950 if (ret > 0) {
951 ret = data;
952 *strm_off += ret;
953 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200954 end:
Christopher Fauletb2e58492019-11-12 11:13:01 +0100955 DBG_TRACE_LEAVE(STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200956 return ret;
957}
958
959/*
960 * Called when TCP data must be filtered on a channel. This function is the
Christopher Faulet0184ea72017-01-05 14:06:34 +0100961 * AN_REQ/RES_FLT_XFER_DATA analyzer. When called, it is responsible to forward
962 * data when the proxy is not in http mode. Behind the scene, it calls
963 * consecutively 'tcp_data' and 'tcp_forward_data' callbacks for all "data"
964 * filters attached to a stream. Returns 0 if an error occurs or if it needs to
965 * wait, any other value otherwise.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200966 */
967int
968flt_xfer_data(struct stream *s, struct channel *chn, unsigned int an_bit)
969{
Christopher Fauletb2e58492019-11-12 11:13:01 +0100970 unsigned int len;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200971 int ret = 1;
972
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100973 DBG_TRACE_ENTER(STRM_EV_STRM_ANA|STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
974
Christopher Fauletda02e172015-12-04 09:25:05 +0100975 /* If there is no "data" filters, we do nothing */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100976 if (!HAS_DATA_FILTERS(s, chn))
Christopher Fauletda02e172015-12-04 09:25:05 +0100977 goto end;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200978
979 /* Be sure that the output is still opened. Else we stop the data
980 * filtering. */
981 if ((chn->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) ||
Willy Tarreau44a41a82018-06-19 07:16:31 +0200982 ((chn->flags & CF_SHUTW) && (chn->to_forward || co_data(chn))))
Christopher Fauletd7c91962015-04-30 11:48:27 +0200983 goto end;
984
Christopher Fauletb2e58492019-11-12 11:13:01 +0100985 if (s->flags & SF_HTX) {
986 struct htx *htx = htxbuf(&chn->buf);
987 len = htx->data;
988 }
989 else
990 len = c_data(chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200991
Christopher Fauletb2e58492019-11-12 11:13:01 +0100992 ret = flt_tcp_payload(s, chn, len);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200993 if (ret < 0)
994 goto end;
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200995 c_adv(chn, ret);
Christopher Fauletda02e172015-12-04 09:25:05 +0100996
Christopher Fauletd7c91962015-04-30 11:48:27 +0200997 /* Stop waiting data if the input in closed and no data is pending or if
998 * the output is closed. */
Christopher Fauletb2e58492019-11-12 11:13:01 +0100999 if (chn->flags & CF_SHUTW) {
Christopher Fauletd7c91962015-04-30 11:48:27 +02001000 ret = 1;
1001 goto end;
1002 }
Christopher Fauletb2e58492019-11-12 11:13:01 +01001003 if (chn->flags & CF_SHUTR) {
1004 if (((s->flags & SF_HTX) && htx_is_empty(htxbuf(&chn->buf))) || c_empty(chn)) {
1005 ret = 1;
1006 goto end;
1007 }
1008 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02001009
1010 /* Wait for data */
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001011 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 +02001012 return 0;
1013 end:
1014 /* Terminate the data filtering. If <ret> is negative, an error was
1015 * encountered during the filtering. */
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001016 ret = handle_analyzer_result(s, chn, an_bit, ret);
1017 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA|STRM_EV_TCP_ANA|STRM_EV_FLT_ANA, s);
1018 return ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001019}
1020
1021/*
1022 * Handles result of filter's analyzers. It returns 0 if an error occurs or if
1023 * it needs to wait, any other value otherwise.
1024 */
1025static int
1026handle_analyzer_result(struct stream *s, struct channel *chn,
1027 unsigned int an_bit, int ret)
1028{
1029 int finst;
Christopher Faulete058f732019-09-06 15:24:55 +02001030 int status = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001031
1032 if (ret < 0)
1033 goto return_bad_req;
1034 else if (!ret)
1035 goto wait;
1036
1037 /* End of job, return OK */
1038 if (an_bit) {
1039 chn->analysers &= ~an_bit;
1040 chn->analyse_exp = TICK_ETERNITY;
1041 }
1042 return 1;
1043
1044 return_bad_req:
1045 /* An error occurs */
1046 channel_abort(&s->req);
1047 channel_abort(&s->res);
1048
1049 if (!(chn->flags & CF_ISRESP)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001050 s->req.analysers &= AN_REQ_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001051 finst = SF_FINST_R;
Christopher Faulete058f732019-09-06 15:24:55 +02001052 status = 400;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001053 /* FIXME: incr counters */
1054 }
1055 else {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001056 s->res.analysers &= AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001057 finst = SF_FINST_H;
Christopher Faulete058f732019-09-06 15:24:55 +02001058 status = 502;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001059 /* FIXME: incr counters */
1060 }
1061
Christopher Faulet3d119692019-07-15 22:04:51 +02001062 if (IS_HTX_STRM(s)) {
Christopher Fauletd7c91962015-04-30 11:48:27 +02001063 /* Do not do that when we are waiting for the next request */
Christopher Faulete058f732019-09-06 15:24:55 +02001064 if (s->txn->status > 0)
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001065 http_reply_and_close(s, s->txn->status, NULL);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001066 else {
Christopher Faulete058f732019-09-06 15:24:55 +02001067 s->txn->status = status;
1068 http_reply_and_close(s, status, http_error_message(s));
Christopher Fauletd7c91962015-04-30 11:48:27 +02001069 }
1070 }
1071
1072 if (!(s->flags & SF_ERR_MASK))
1073 s->flags |= SF_ERR_PRXCOND;
1074 if (!(s->flags & SF_FINST_MASK))
1075 s->flags |= finst;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001076 DBG_TRACE_DEVEL("leaving on error", STRM_EV_FLT_ANA|STRM_EV_FLT_ERR, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001077 return 0;
1078
1079 wait:
1080 if (!(chn->flags & CF_ISRESP))
1081 channel_dont_connect(chn);
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001082 DBG_TRACE_DEVEL("wairing for more data", STRM_EV_FLT_ANA, s);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001083 return 0;
1084}
1085
1086
1087/* Note: must not be declared <const> as its list will be overwritten.
1088 * Please take care of keeping this list alphabetically sorted, doing so helps
1089 * all code contributors.
1090 * Optional keywords are also declared with a NULL ->parse() function so that
1091 * the config parser can report an appropriate error when a known keyword was
1092 * not enabled. */
1093static struct cfg_kw_list cfg_kws = {ILH, {
1094 { CFG_LISTEN, "filter", parse_filter },
1095 { 0, NULL, NULL },
1096 }
1097};
1098
Willy Tarreau0108d902018-11-25 19:14:37 +01001099INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1100
Willy Tarreau172f5ce2018-11-26 11:21:50 +01001101REGISTER_POST_CHECK(flt_init_all);
1102REGISTER_PER_THREAD_INIT(flt_init_all_per_thread);
1103REGISTER_PER_THREAD_DEINIT(flt_deinit_all_per_thread);
1104
Christopher Fauletd7c91962015-04-30 11:48:27 +02001105/*
1106 * Local variables:
1107 * c-indent-level: 8
1108 * c-basic-offset: 8
1109 * End:
1110 */