blob: 47982a476b0ff3b4d16a1022b8c1d89c72b2d50c [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
13#include <common/buffer.h>
14#include <common/debug.h>
15#include <common/cfgparse.h>
16#include <common/compat.h>
17#include <common/config.h>
18#include <common/errors.h>
Willy Tarreaub96b77e2018-12-11 10:22:41 +010019#include <common/htx.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010020#include <common/initcall.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020021#include <common/namespace.h>
22#include <common/standard.h>
Christopher Faulet71a6a8e2017-07-27 16:33:28 +020023#include <common/hathreads.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020024
25#include <types/filters.h>
26#include <types/proto_http.h>
27
28#include <proto/compression.h>
29#include <proto/filters.h>
Christopher Faulet92d36382015-11-05 13:35:03 +010030#include <proto/flt_http_comp.h>
Christopher Faulet75bc9132018-11-30 15:18:09 +010031#include <proto/http_htx.h>
Christopher Fauletd7c91962015-04-30 11:48:27 +020032#include <proto/proto_http.h>
33#include <proto/stream.h>
34#include <proto/stream_interface.h>
35
36/* Pool used to allocate filters */
Willy Tarreau8ceae722018-11-26 11:58:30 +010037DECLARE_STATIC_POOL(pool_head_filter, "filter", sizeof(struct filter));
Christopher Fauletd7c91962015-04-30 11:48:27 +020038
39static int handle_analyzer_result(struct stream *s, struct channel *chn, unsigned int an_bit, int ret);
40
41/* - RESUME_FILTER_LOOP and RESUME_FILTER_END must always be used together.
42 * The first one begins a loop and the seconds one ends it.
43 *
44 * - BREAK_EXECUTION must be used to break the loop and set the filter from
45 * which to resume the next time.
46 *
Bertrand Jacquin874a35c2018-09-10 21:26:07 +010047 * Here is an example:
Christopher Fauletd7c91962015-04-30 11:48:27 +020048 *
49 * RESUME_FILTER_LOOP(stream, channel) {
50 * ...
51 * if (cond)
52 * BREAK_EXECUTION(stream, channel, label);
53 * ...
54 * } RESUME_FILTER_END;
55 * ...
56 * label:
57 * ...
58 *
59 */
60#define RESUME_FILTER_LOOP(strm, chn) \
61 do { \
62 struct filter *filter; \
63 \
Christopher Fauletda02e172015-12-04 09:25:05 +010064 if (strm_flt(strm)->current[CHN_IDX(chn)]) { \
65 filter = strm_flt(strm)->current[CHN_IDX(chn)]; \
66 strm_flt(strm)->current[CHN_IDX(chn)] = NULL; \
Christopher Fauletd7c91962015-04-30 11:48:27 +020067 goto resume_execution; \
68 } \
69 \
Christopher Fauletfcf035c2015-12-03 11:48:03 +010070 list_for_each_entry(filter, &strm_flt(s)->filters, list) { \
Christopher Fauletda02e172015-12-04 09:25:05 +010071 resume_execution:
Christopher Fauletd7c91962015-04-30 11:48:27 +020072
73#define RESUME_FILTER_END \
74 } \
75 } while(0)
76
Christopher Fauletda02e172015-12-04 09:25:05 +010077#define BREAK_EXECUTION(strm, chn, label) \
78 do { \
79 strm_flt(strm)->current[CHN_IDX(chn)] = filter; \
80 goto label; \
Christopher Fauletd7c91962015-04-30 11:48:27 +020081 } while (0)
82
83
84/* List head of all known filter keywords */
85static struct flt_kw_list flt_keywords = {
86 .list = LIST_HEAD_INIT(flt_keywords.list)
87};
88
89/*
90 * Registers the filter keyword list <kwl> as a list of valid keywords for next
91 * parsing sessions.
92 */
93void
94flt_register_keywords(struct flt_kw_list *kwl)
95{
96 LIST_ADDQ(&flt_keywords.list, &kwl->list);
97}
98
99/*
100 * Returns a pointer to the filter keyword <kw>, or NULL if not found. If the
101 * keyword is found with a NULL ->parse() function, then an attempt is made to
102 * find one with a valid ->parse() function. This way it is possible to declare
103 * platform-dependant, known keywords as NULL, then only declare them as valid
104 * if some options are met. Note that if the requested keyword contains an
105 * opening parenthesis, everything from this point is ignored.
106 */
107struct flt_kw *
108flt_find_kw(const char *kw)
109{
110 int index;
111 const char *kwend;
112 struct flt_kw_list *kwl;
113 struct flt_kw *ret = NULL;
114
115 kwend = strchr(kw, '(');
116 if (!kwend)
117 kwend = kw + strlen(kw);
118
119 list_for_each_entry(kwl, &flt_keywords.list, list) {
120 for (index = 0; kwl->kw[index].kw != NULL; index++) {
121 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
122 kwl->kw[index].kw[kwend-kw] == 0) {
123 if (kwl->kw[index].parse)
124 return &kwl->kw[index]; /* found it !*/
125 else
126 ret = &kwl->kw[index]; /* may be OK */
127 }
128 }
129 }
130 return ret;
131}
132
133/*
134 * Dumps all registered "filter" keywords to the <out> string pointer. The
135 * unsupported keywords are only dumped if their supported form was not found.
136 */
137void
138flt_dump_kws(char **out)
139{
140 struct flt_kw_list *kwl;
141 int index;
142
143 *out = NULL;
144 list_for_each_entry(kwl, &flt_keywords.list, list) {
145 for (index = 0; kwl->kw[index].kw != NULL; index++) {
146 if (kwl->kw[index].parse ||
147 flt_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
148 memprintf(out, "%s[%4s] %s%s\n", *out ? *out : "",
149 kwl->scope,
150 kwl->kw[index].kw,
151 kwl->kw[index].parse ? "" : " (not supported)");
152 }
153 }
154 }
155}
156
157/*
Christopher Fauletb3f4e142016-03-07 12:46:38 +0100158 * Lists the known filters on <out>
159 */
160void
161list_filters(FILE *out)
162{
163 char *filters, *p, *f;
164
165 fprintf(out, "Available filters :\n");
166 flt_dump_kws(&filters);
167 for (p = filters; (f = strtok_r(p,"\n",&p));)
168 fprintf(out, "\t%s\n", f);
169 free(filters);
170}
171
172/*
Christopher Fauletd7c91962015-04-30 11:48:27 +0200173 * Parses the "filter" keyword. All keywords must be handled by filters
174 * themselves
175 */
176static int
177parse_filter(char **args, int section_type, struct proxy *curpx,
178 struct proxy *defpx, const char *file, int line, char **err)
179{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100180 struct flt_conf *fconf = NULL;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200181
182 /* Filter cannot be defined on a default proxy */
183 if (curpx == defpx) {
Christopher Fauletcc7317d2016-04-04 10:51:17 +0200184 memprintf(err, "parsing [%s:%d] : %s is not allowed in a 'default' section.",
Christopher Fauletd7c91962015-04-30 11:48:27 +0200185 file, line, args[0]);
186 return -1;
187 }
188 if (!strcmp(args[0], "filter")) {
189 struct flt_kw *kw;
190 int cur_arg;
191
192 if (!*args[1]) {
193 memprintf(err,
194 "parsing [%s:%d] : missing argument for '%s' in %s '%s'.",
195 file, line, args[0], proxy_type_str(curpx), curpx->id);
196 goto error;
197 }
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100198 fconf = calloc(1, sizeof(*fconf));
199 if (!fconf) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200200 memprintf(err, "'%s' : out of memory", args[0]);
201 goto error;
202 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200203
204 cur_arg = 1;
205 kw = flt_find_kw(args[cur_arg]);
206 if (kw) {
207 if (!kw->parse) {
208 memprintf(err, "parsing [%s:%d] : '%s' : "
209 "'%s' option is not implemented in this version (check build options).",
210 file, line, args[0], args[cur_arg]);
211 goto error;
212 }
Thierry Fournier3610c392016-04-13 18:27:51 +0200213 if (kw->parse(args, &cur_arg, curpx, fconf, err, kw->private) != 0) {
Christopher Fauletd7c91962015-04-30 11:48:27 +0200214 if (err && *err)
215 memprintf(err, "'%s' : '%s'",
216 args[0], *err);
217 else
218 memprintf(err, "'%s' : error encountered while processing '%s'",
219 args[0], args[cur_arg]);
220 goto error;
221 }
222 }
223 else {
224 flt_dump_kws(err);
225 indent_msg(err, 4);
226 memprintf(err, "'%s' : unknown keyword '%s'.%s%s",
227 args[0], args[cur_arg],
228 err && *err ? " Registered keywords :" : "", err && *err ? *err : "");
229 goto error;
230 }
231 if (*args[cur_arg]) {
232 memprintf(err, "'%s %s' : unknown keyword '%s'.",
233 args[0], args[1], args[cur_arg]);
234 goto error;
235 }
Christopher Faulet00e818a2016-04-19 17:00:44 +0200236 if (fconf->ops == NULL) {
237 memprintf(err, "'%s %s' : no callbacks defined.",
238 args[0], args[1]);
239 goto error;
240 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200241
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100242 LIST_ADDQ(&curpx->filter_configs, &fconf->list);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200243 }
244 return 0;
245
246 error:
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100247 free(fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200248 return -1;
249
250
251}
252
253/*
254 * Calls 'init' callback for all filters attached to a proxy. This happens after
255 * the configuration parsing. Filters can finish to fill their config. Returns
256 * (ERR_ALERT|ERR_FATAL) if an error occurs, 0 otherwise.
257 */
Willy Tarreau64bca592016-12-21 20:13:11 +0100258static int
Christopher Fauletd7c91962015-04-30 11:48:27 +0200259flt_init(struct proxy *proxy)
260{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100261 struct flt_conf *fconf;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200262
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100263 list_for_each_entry(fconf, &proxy->filter_configs, list) {
264 if (fconf->ops->init && fconf->ops->init(proxy, fconf) < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200265 return ERR_ALERT|ERR_FATAL;
266 }
267 return 0;
268}
269
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200270/*
271 * Calls 'init_per_thread' callback for all filters attached to a proxy for each
272 * threads. This happens after the thread creation. Filters can finish to fill
273 * their config. Returns (ERR_ALERT|ERR_FATAL) if an error occurs, 0 otherwise.
274 */
275static int
276flt_init_per_thread(struct proxy *proxy)
277{
278 struct flt_conf *fconf;
279
280 list_for_each_entry(fconf, &proxy->filter_configs, list) {
281 if (fconf->ops->init_per_thread && fconf->ops->init_per_thread(proxy, fconf) < 0)
282 return ERR_ALERT|ERR_FATAL;
283 }
284 return 0;
285}
286
Willy Tarreau64bca592016-12-21 20:13:11 +0100287/* Calls flt_init() for all proxies, see above */
288static int
289flt_init_all()
290{
291 struct proxy *px;
292 int err_code = 0;
293
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100294 for (px = proxies_list; px; px = px->next) {
Willy Tarreau64bca592016-12-21 20:13:11 +0100295 err_code |= flt_init(px);
296 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100297 ha_alert("Failed to initialize filters for proxy '%s'.\n",
298 px->id);
Willy Tarreau64bca592016-12-21 20:13:11 +0100299 return err_code;
300 }
301 }
302 return 0;
303}
304
Joseph Herlantb35ea682018-11-15 12:24:23 -0800305/* Calls flt_init_per_thread() for all proxies, see above. Be careful here, it
306 * returns 0 if an error occurred. This is the opposite of flt_init_all. */
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200307static int
308flt_init_all_per_thread()
309{
310 struct proxy *px;
311 int err_code = 0;
312
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100313 for (px = proxies_list; px; px = px->next) {
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200314 err_code = flt_init_per_thread(px);
315 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100316 ha_alert("Failed to initialize filters for proxy '%s' for thread %u.\n",
317 px->id, tid);
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200318 return 0;
319 }
320 }
321 return 1;
322}
323
Christopher Fauletd7c91962015-04-30 11:48:27 +0200324/*
325 * Calls 'check' callback for all filters attached to a proxy. This happens
326 * after the configuration parsing but before filters initialization. Returns
327 * the number of encountered errors.
328 */
329int
330flt_check(struct proxy *proxy)
331{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100332 struct flt_conf *fconf;
333 int err = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200334
Christopher Fauletff17b182019-01-07 15:03:22 +0100335 err += check_implicit_http_comp_flt(proxy);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100336 list_for_each_entry(fconf, &proxy->filter_configs, list) {
337 if (fconf->ops->check)
338 err += fconf->ops->check(proxy, fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200339 }
340 return err;
341}
342
343/*
344 * Calls 'denit' callback for all filters attached to a proxy. This happens when
345 * HAProxy is stopped.
346 */
347void
348flt_deinit(struct proxy *proxy)
349{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100350 struct flt_conf *fconf, *back;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200351
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100352 list_for_each_entry_safe(fconf, back, &proxy->filter_configs, list) {
353 if (fconf->ops->deinit)
354 fconf->ops->deinit(proxy, fconf);
355 LIST_DEL(&fconf->list);
356 free(fconf);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200357 }
358}
359
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200360/*
361 * Calls 'denit_per_thread' callback for all filters attached to a proxy for
362 * each threads. This happens before exiting a thread.
363 */
364void
365flt_deinit_per_thread(struct proxy *proxy)
366{
367 struct flt_conf *fconf, *back;
368
369 list_for_each_entry_safe(fconf, back, &proxy->filter_configs, list) {
370 if (fconf->ops->deinit_per_thread)
371 fconf->ops->deinit_per_thread(proxy, fconf);
372 }
373}
374
375
376/* Calls flt_deinit_per_thread() for all proxies, see above */
377static void
378flt_deinit_all_per_thread()
379{
380 struct proxy *px;
381
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100382 for (px = proxies_list; px; px = px->next)
Christopher Faulet71a6a8e2017-07-27 16:33:28 +0200383 flt_deinit_per_thread(px);
384}
385
Christopher Faulet92d36382015-11-05 13:35:03 +0100386/* Attaches a filter to a stream. Returns -1 if an error occurs, 0 otherwise. */
387static int
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100388flt_stream_add_filter(struct stream *s, struct flt_conf *fconf, unsigned int flags)
Christopher Faulet92d36382015-11-05 13:35:03 +0100389{
Christopher Faulet75bc9132018-11-30 15:18:09 +0100390 struct filter *f;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200391
Christopher Faulet0f17a9b2019-04-05 10:11:38 +0200392 if (IS_HTX_STRM(s) && !(fconf->flags & FLT_CFG_FL_HTX))
Christopher Faulet75bc9132018-11-30 15:18:09 +0100393 return 0;
394
395 f = pool_alloc(pool_head_filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100396 if (!f) /* not enough memory */
397 return -1;
398 memset(f, 0, sizeof(*f));
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100399 f->config = fconf;
Christopher Fauletda02e172015-12-04 09:25:05 +0100400 f->flags |= flags;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200401
402 if (FLT_OPS(f)->attach) {
403 int ret = FLT_OPS(f)->attach(s, f);
404 if (ret <= 0) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100405 pool_free(pool_head_filter, f);
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200406 return ret;
407 }
408 }
409
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100410 LIST_ADDQ(&strm_flt(s)->filters, &f->list);
Christopher Fauletda02e172015-12-04 09:25:05 +0100411 strm_flt(s)->flags |= STRM_FLT_FL_HAS_FILTERS;
Christopher Faulet92d36382015-11-05 13:35:03 +0100412 return 0;
413}
414
415/*
416 * Called when a stream is created. It attaches all frontend filters to the
417 * stream. Returns -1 if an error occurs, 0 otherwise.
418 */
419int
420flt_stream_init(struct stream *s)
421{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100422 struct flt_conf *fconf;
Christopher Faulet92d36382015-11-05 13:35:03 +0100423
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100424 memset(strm_flt(s), 0, sizeof(*strm_flt(s)));
425 LIST_INIT(&strm_flt(s)->filters);
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100426 list_for_each_entry(fconf, &strm_fe(s)->filter_configs, list) {
427 if (flt_stream_add_filter(s, fconf, 0) < 0)
Christopher Faulet92d36382015-11-05 13:35:03 +0100428 return -1;
429 }
430 return 0;
431}
432
433/*
434 * Called when a stream is closed or when analyze ends (For an HTTP stream, this
435 * happens after each request/response exchange). When analyze ends, backend
436 * filters are removed. When the stream is closed, all filters attached to the
437 * stream are removed.
438 */
439void
440flt_stream_release(struct stream *s, int only_backend)
441{
442 struct filter *filter, *back;
443
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100444 list_for_each_entry_safe(filter, back, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100445 if (!only_backend || (filter->flags & FLT_FL_IS_BACKEND_FILTER)) {
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200446 if (FLT_OPS(filter)->detach)
447 FLT_OPS(filter)->detach(s, filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100448 LIST_DEL(&filter->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100449 pool_free(pool_head_filter, filter);
Christopher Faulet92d36382015-11-05 13:35:03 +0100450 }
451 }
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100452 if (LIST_ISEMPTY(&strm_flt(s)->filters))
Christopher Fauletda02e172015-12-04 09:25:05 +0100453 strm_flt(s)->flags &= ~STRM_FLT_FL_HAS_FILTERS;
Christopher Faulet92d36382015-11-05 13:35:03 +0100454}
455
Christopher Fauletd7c91962015-04-30 11:48:27 +0200456/*
457 * Calls 'stream_start' for all filters attached to a stream. This happens when
458 * the stream is created, just after calling flt_stream_init
459 * function. Returns -1 if an error occurs, 0 otherwise.
460 */
461int
462flt_stream_start(struct stream *s)
463{
464 struct filter *filter;
465
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100466 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100467 if (FLT_OPS(filter)->stream_start && FLT_OPS(filter)->stream_start(s, filter) < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200468 return -1;
469 }
470 return 0;
471}
472
473/*
474 * Calls 'stream_stop' for all filters attached to a stream. This happens when
475 * the stream is stopped, just before calling flt_stream_release function.
476 */
477void
478flt_stream_stop(struct stream *s)
479{
480 struct filter *filter;
481
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100482 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100483 if (FLT_OPS(filter)->stream_stop)
484 FLT_OPS(filter)->stream_stop(s, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200485 }
486}
487
Christopher Faulet92d36382015-11-05 13:35:03 +0100488/*
Christopher Fauleta00d8172016-11-10 14:58:05 +0100489 * Calls 'check_timeouts' for all filters attached to a stream. This happens when
490 * the stream is woken up because of expired timer.
491 */
492void
493flt_stream_check_timeouts(struct stream *s)
494{
495 struct filter *filter;
496
497 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
498 if (FLT_OPS(filter)->check_timeouts)
499 FLT_OPS(filter)->check_timeouts(s, filter);
500 }
501}
502
503/*
Christopher Faulet92d36382015-11-05 13:35:03 +0100504 * Called when a backend is set for a stream. If the frontend and the backend
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200505 * are not the same, this function attaches all backend filters to the
506 * stream. Returns -1 if an error occurs, 0 otherwise.
Christopher Faulet92d36382015-11-05 13:35:03 +0100507 */
508int
509flt_set_stream_backend(struct stream *s, struct proxy *be)
510{
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100511 struct flt_conf *fconf;
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200512 struct filter *filter;
Christopher Faulet92d36382015-11-05 13:35:03 +0100513
514 if (strm_fe(s) == be)
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200515 goto end;
Christopher Faulet92d36382015-11-05 13:35:03 +0100516
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100517 list_for_each_entry(fconf, &be->filter_configs, list) {
518 if (flt_stream_add_filter(s, fconf, FLT_FL_IS_BACKEND_FILTER) < 0)
Christopher Faulet92d36382015-11-05 13:35:03 +0100519 return -1;
520 }
Christopher Faulet31ed32d2016-06-21 11:42:37 +0200521
522 end:
523 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
524 if (FLT_OPS(filter)->stream_set_backend &&
525 FLT_OPS(filter)->stream_set_backend(s, filter, be) < 0)
526 return -1;
527 }
528
Christopher Faulet92d36382015-11-05 13:35:03 +0100529 return 0;
530}
531
Christopher Fauletd7c91962015-04-30 11:48:27 +0200532/*
533 * Calls 'http_data' callback for all "data" filters attached to a stream. This
534 * function is called when incoming data are available (excluding chunks
535 * envelope for chunked messages) in the AN_REQ_HTTP_XFER_BODY and
536 * AN_RES_HTTP_XFER_BODY analyzers. It takes care to update the next offset of
537 * filters and adjusts available data to be sure that a filter cannot parse more
538 * data than its predecessors. A filter can choose to not consume all available
539 * data. Returns -1 if an error occurs, the number of consumed bytes otherwise.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100540 *
541 * DEPRECATED FUNCTION - CALLED FROM LEGACY HTTP ANALYZERS
Christopher Fauletd7c91962015-04-30 11:48:27 +0200542 */
543int
544flt_http_data(struct stream *s, struct http_msg *msg)
545{
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100546 struct filter *filter;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200547 unsigned int buf_i;
Christopher Faulet55048a42016-06-21 10:44:32 +0200548 int delta = 0, ret = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200549
Christopher Fauletd7c91962015-04-30 11:48:27 +0200550 /* Save buffer state */
Willy Tarreau44a41a82018-06-19 07:16:31 +0200551 buf_i = ci_data(msg->chn);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100552
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100553 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100554 unsigned int *nxt;
555
556 /* Call "data" filters only */
557 if (!IS_DATA_FILTER(filter, msg->chn))
558 continue;
559
Christopher Faulet2fb28802015-12-01 10:40:57 +0100560 /* If the HTTP parser is ahead, we update the next offset of the
561 * current filter. This happens for chunked messages, at the
Joseph Herlantb35ea682018-11-15 12:24:23 -0800562 * beginning of a new chunk. */
Christopher Fauletda02e172015-12-04 09:25:05 +0100563 nxt = &FLT_NXT(filter, msg->chn);
564 if (msg->next > *nxt)
565 *nxt = msg->next;
566
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100567 if (FLT_OPS(filter)->http_data) {
Willy Tarreau44a41a82018-06-19 07:16:31 +0200568 unsigned int i = ci_data(msg->chn);
Christopher Faulet55048a42016-06-21 10:44:32 +0200569
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100570 ret = FLT_OPS(filter)->http_data(s, filter, msg);
Christopher Fauletda02e172015-12-04 09:25:05 +0100571 if (ret < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200572 break;
Willy Tarreau44a41a82018-06-19 07:16:31 +0200573 delta += (int)(ci_data(msg->chn) - i);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100574
575 /* Update the next offset of the current filter */
Christopher Fauletda02e172015-12-04 09:25:05 +0100576 *nxt += ret;
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100577
578 /* And set this value as the bound for the next
579 * filter. It will not able to parse more data than this
580 * one. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200581 b_set_data(&msg->chn->buf, co_data(msg->chn) + *nxt);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200582 }
583 else {
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100584 /* Consume all available data and update the next offset
585 * of the current filter. buf->i is untouched here. */
Willy Tarreau44a41a82018-06-19 07:16:31 +0200586 ret = MIN(msg->chunk_len + msg->next, ci_data(msg->chn)) - *nxt;
Christopher Fauletda02e172015-12-04 09:25:05 +0100587 *nxt += ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200588 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200589 }
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100590
Christopher Fauletd7c91962015-04-30 11:48:27 +0200591 /* Restore the original buffer state */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200592 b_set_data(&msg->chn->buf, co_data(msg->chn) + buf_i + delta);
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100593
Christopher Fauletd7c91962015-04-30 11:48:27 +0200594 return ret;
595}
596
Christopher Fauletd7c91962015-04-30 11:48:27 +0200597/*
598 * Calls 'http_chunk_trailers' callback for all "data" filters attached to a
599 * stream. This function is called for chunked messages only when a part of the
600 * trailers was parsed in the AN_REQ_HTTP_XFER_BODY and AN_RES_HTTP_XFER_BODY
601 * analyzers. Filters can know how much data were parsed by the HTTP parsing
602 * until the last call with the msg->sol value. Returns a negative value if an
603 * error occurs, any other value otherwise.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100604 *
605 * DEPRECATED FUNCTION - CALLED FROM LEGACY HTTP ANALYZERS
Christopher Fauletd7c91962015-04-30 11:48:27 +0200606 */
607int
608flt_http_chunk_trailers(struct stream *s, struct http_msg *msg)
609{
Christopher Faulet2fb28802015-12-01 10:40:57 +0100610 struct filter *filter;
Christopher Fauletda02e172015-12-04 09:25:05 +0100611 int ret = 1;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200612
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100613 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100614 unsigned int *nxt;
615
616 /* Call "data" filters only */
617 if (!IS_DATA_FILTER(filter, msg->chn))
618 continue;
619
Christopher Faulet2fb28802015-12-01 10:40:57 +0100620 /* Be sure to set the next offset of the filter at the right
621 * place. This is really useful when the first part of the
622 * trailers was parsed. */
Christopher Fauletda02e172015-12-04 09:25:05 +0100623 nxt = &FLT_NXT(filter, msg->chn);
624 *nxt = msg->next;
625
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100626 if (FLT_OPS(filter)->http_chunk_trailers) {
627 ret = FLT_OPS(filter)->http_chunk_trailers(s, filter, msg);
Christopher Faulet2fb28802015-12-01 10:40:57 +0100628 if (ret < 0)
629 break;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200630 }
Christopher Faulet2fb28802015-12-01 10:40:57 +0100631 /* Update the next offset of the current filter. Here all data
632 * are always consumed. */
Christopher Fauletda02e172015-12-04 09:25:05 +0100633 *nxt += msg->sol;
Christopher Faulet2fb28802015-12-01 10:40:57 +0100634 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200635 return ret;
636}
637
638/*
639 * Calls 'http_end' callback for all filters attached to a stream. All filters
640 * are called here, but only if there is at least one "data" filter. This
641 * functions is called when all data were parsed and forwarded. 'http_end'
642 * callback is resumable, so this function returns a negative value if an error
643 * occurs, 0 if it needs to wait for some reason, any other value otherwise.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100644 *
645 * Be carefull, this function can be called from the HTTP legacy analyzers or
646 * from HTX analyzers. If your filter is compatible with the two modes, use
647 * IS_HTX_STRM macro on the stream.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200648 */
649int
650flt_http_end(struct stream *s, struct http_msg *msg)
651{
652 int ret = 1;
653
Christopher Fauletd7c91962015-04-30 11:48:27 +0200654 RESUME_FILTER_LOOP(s, msg->chn) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100655 if (FLT_OPS(filter)->http_end) {
656 ret = FLT_OPS(filter)->http_end(s, filter, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200657 if (ret <= 0)
658 BREAK_EXECUTION(s, msg->chn, end);
659 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200660 } RESUME_FILTER_END;
661end:
662 return ret;
663}
664
665/*
666 * Calls 'http_reset' callback for all filters attached to a stream. This
667 * happens when a 100-continue response is received.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100668 *
669 * Be carefull, this function can be called from the HTTP legacy analyzers or
670 * from HTX analyzers. If your filter is compatible with the two modes, use
671 * IS_HTX_STRM macro on the stream.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200672 */
673void
674flt_http_reset(struct stream *s, struct http_msg *msg)
675{
676 struct filter *filter;
677
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100678 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100679 if (FLT_OPS(filter)->http_reset)
680 FLT_OPS(filter)->http_reset(s, filter, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200681 }
682}
683
684/*
685 * Calls 'http_reply' callback for all filters attached to a stream when HA
686 * decides to stop the HTTP message processing.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100687 *
688 * Be carefull, this function can be called from the HTTP legacy analyzers or
689 * from HTX analyzers. If your filter is compatible with the two modes, use
690 * IS_HTX_STRM macro on the stream.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200691 */
692void
Willy Tarreau83061a82018-07-13 11:56:34 +0200693flt_http_reply(struct stream *s, short status, const struct buffer *msg)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200694{
695 struct filter *filter;
696
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100697 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100698 if (FLT_OPS(filter)->http_reply)
699 FLT_OPS(filter)->http_reply(s, filter, status, msg);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200700 }
701}
702
703/*
Christopher Faulet75bc9132018-11-30 15:18:09 +0100704 * Calls 'http_forward_data' callback for all "data" filters attached to a HTTP
705 * legacy stream. This function is called when some data can be forwarded in the
Christopher Fauletd7c91962015-04-30 11:48:27 +0200706 * AN_REQ_HTTP_XFER_BODY and AN_RES_HTTP_XFER_BODY analyzers. It takes care to
707 * update the forward offset of filters and adjusts "forwardable" data to be
708 * sure that a filter cannot forward more data than its predecessors. A filter
709 * can choose to not forward all parsed data. Returns a negative value if an
710 * error occurs, else the number of forwarded bytes.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100711 *
712 * DEPRECATED FUNCTION - CALLED FROM LEGACY HTTP ANALYZERS
Christopher Fauletd7c91962015-04-30 11:48:27 +0200713 */
714int
715flt_http_forward_data(struct stream *s, struct http_msg *msg, unsigned int len)
716{
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100717 struct filter *filter;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200718 int ret = len;
719
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100720 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100721 unsigned int *nxt, *fwd;
722
723 /* Call "data" filters only */
724 if (!IS_DATA_FILTER(filter, msg->chn))
725 continue;
726
Christopher Faulet2fb28802015-12-01 10:40:57 +0100727 /* If the HTTP parser is ahead, we update the next offset of the
728 * current filter. This happens for chunked messages, when the
729 * chunk envelope is parsed. */
Christopher Fauletda02e172015-12-04 09:25:05 +0100730 nxt = &FLT_NXT(filter, msg->chn);
731 fwd = &FLT_FWD(filter, msg->chn);
732 if (msg->next > *nxt)
733 *nxt = msg->next;
734
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100735 if (FLT_OPS(filter)->http_forward_data) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100736 /* Remove bytes that the current filter considered as
737 * forwarded */
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100738 ret = FLT_OPS(filter)->http_forward_data(s, filter, msg, ret - *fwd);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200739 if (ret < 0)
740 goto end;
741 }
742
743 /* Adjust bytes that the current filter considers as
744 * forwarded */
Christopher Fauletda02e172015-12-04 09:25:05 +0100745 *fwd += ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200746
747 /* And set this value as the bound for the next filter. It will
748 * not able to forward more data than the current one. */
Christopher Fauletda02e172015-12-04 09:25:05 +0100749 ret = *fwd;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200750 }
751
752 if (!ret)
753 goto end;
754
755 /* Finally, adjust filters offsets by removing data that HAProxy will
756 * forward. */
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100757 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +0100758 if (!IS_DATA_FILTER(filter, msg->chn))
759 continue;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200760 FLT_NXT(filter, msg->chn) -= ret;
761 FLT_FWD(filter, msg->chn) -= ret;
762 }
763 end:
764 return ret;
765}
766
767/*
Christopher Faulet75bc9132018-11-30 15:18:09 +0100768 * Calls 'http_payload' callback for all "data" filters attached to a
769 * stream. This function is called when some data can be forwarded in the
770 * AN_REQ_HTTP_XFER_BODY and AN_RES_HTTP_XFER_BODY analyzers. It takes care to
771 * update the filters and the stream offset to be sure that a filter cannot
772 * forward more data than its predecessors. A filter can choose to not forward
773 * all data. Returns a negative value if an error occurs, else the number of
774 * forwarded bytes.
775 *
776 * Be carefull, this callback is only called from HTX analyzers. So the
777 * channel's buffer must be considered as an HTX structured. Of course, your
778 * filter must support HTX streams.
779 */
780int
781flt_http_payload(struct stream *s, struct http_msg *msg, unsigned int len)
782{
783 struct filter *filter;
784 unsigned long long *strm_off = &FLT_STRM_OFF(s, msg->chn);
Christopher Faulet421e7692019-06-13 11:16:45 +0200785 unsigned int out = co_data(msg->chn);
Christopher Fauleta2f67b32020-02-07 16:40:33 +0100786 int ret = 0, data = len - out;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100787
788 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
789 /* Call "data" filters only */
790 if (!IS_DATA_FILTER(filter, msg->chn))
791 continue;
792 if (FLT_OPS(filter)->http_payload) {
793 unsigned long long *flt_off = &FLT_OFF(filter, msg->chn);
794 unsigned int offset = *flt_off - *strm_off;
795
Christopher Fauleta2f67b32020-02-07 16:40:33 +0100796 ret = FLT_OPS(filter)->http_payload(s, filter, msg, out + offset, data - offset);
Christopher Faulet75bc9132018-11-30 15:18:09 +0100797 if (ret < 0)
798 goto end;
799 *flt_off += ret;
Christopher Fauleta2f67b32020-02-07 16:40:33 +0100800 data = ret + offset;
Christopher Faulet75bc9132018-11-30 15:18:09 +0100801 }
802 }
Christopher Fauleta2f67b32020-02-07 16:40:33 +0100803
804 /* Only forward data if the last filter decides to forward something */
805 if (ret > 0) {
806 ret = data;
807 *strm_off += ret;
808 }
Christopher Faulet75bc9132018-11-30 15:18:09 +0100809 end:
810 return ret;
811}
812
813/*
Christopher Fauletd7c91962015-04-30 11:48:27 +0200814 * Calls 'channel_start_analyze' callback for all filters attached to a
815 * stream. This function is called when we start to analyze a request or a
816 * response. For frontend filters, it is called before all other analyzers. For
817 * backend ones, it is called before all backend
818 * analyzers. 'channel_start_analyze' callback is resumable, so this function
819 * returns 0 if an error occurs or if it needs to wait, any other value
820 * otherwise.
821 */
822int
823flt_start_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
824{
825 int ret = 1;
826
827 /* If this function is called, this means there is at least one filter,
828 * so we do not need to check the filter list's emptiness. */
829
Christopher Faulete6006242017-03-10 11:52:44 +0100830 /* Set flag on channel to tell that the channel is filtered */
831 chn->flags |= CF_FLT_ANALYZE;
832
Christopher Fauletd7c91962015-04-30 11:48:27 +0200833 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet0184ea72017-01-05 14:06:34 +0100834 if (!(chn->flags & CF_ISRESP)) {
835 if (an_bit == AN_REQ_FLT_START_BE &&
836 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
837 continue;
838 }
839 else {
840 if (an_bit == AN_RES_FLT_START_BE &&
841 !(filter->flags & FLT_FL_IS_BACKEND_FILTER))
842 continue;
843 }
Christopher Fauletd7c91962015-04-30 11:48:27 +0200844
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100845 FLT_NXT(filter, chn) = 0;
846 FLT_FWD(filter, chn) = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +0200847
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100848 if (FLT_OPS(filter)->channel_start_analyze) {
849 ret = FLT_OPS(filter)->channel_start_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200850 if (ret <= 0)
851 BREAK_EXECUTION(s, chn, end);
852 }
853 } RESUME_FILTER_END;
854
855 end:
856 return handle_analyzer_result(s, chn, an_bit, ret);
857}
858
859/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200860 * Calls 'channel_pre_analyze' callback for all filters attached to a
861 * stream. This function is called BEFORE each analyzer attached to a channel,
862 * expects analyzers responsible for data sending. 'channel_pre_analyze'
863 * callback is resumable, so this function returns 0 if an error occurs or if it
864 * needs to wait, any other value otherwise.
865 *
866 * Note this function can be called many times for the same analyzer. In fact,
867 * it is called until the analyzer finishes its processing.
Christopher Fauletd7c91962015-04-30 11:48:27 +0200868 */
869int
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200870flt_pre_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200871{
872 int ret = 1;
873
Christopher Fauletd7c91962015-04-30 11:48:27 +0200874 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200875 if (FLT_OPS(filter)->channel_pre_analyze && (filter->pre_analyzers & an_bit)) {
876 ret = FLT_OPS(filter)->channel_pre_analyze(s, filter, chn, an_bit);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200877 if (ret <= 0)
878 BREAK_EXECUTION(s, chn, check_result);
879 }
880 } RESUME_FILTER_END;
881
882 check_result:
Christopher Faulet309c6412015-12-02 09:57:32 +0100883 return handle_analyzer_result(s, chn, 0, ret);
884}
885
886/*
Christopher Faulet3a394fa2016-05-11 17:13:39 +0200887 * Calls 'channel_post_analyze' callback for all filters attached to a
888 * stream. This function is called AFTER each analyzer attached to a channel,
889 * expects analyzers responsible for data sending. 'channel_post_analyze'
890 * callback is NOT resumable, so this function returns a 0 if an error occurs,
891 * any other value otherwise.
892 *
893 * Here, AFTER means when the analyzer finishes its processing.
894 */
895int
896flt_post_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
897{
898 struct filter *filter;
899 int ret = 1;
900
901 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
902 if (FLT_OPS(filter)->channel_post_analyze && (filter->post_analyzers & an_bit)) {
903 ret = FLT_OPS(filter)->channel_post_analyze(s, filter, chn, an_bit);
904 if (ret < 0)
905 break;
906 }
907 }
908 return handle_analyzer_result(s, chn, 0, ret);
909}
910
911/*
Christopher Faulet0184ea72017-01-05 14:06:34 +0100912 * This function is the AN_REQ/RES_FLT_HTTP_HDRS analyzer, used to filter HTTP
913 * headers or a request or a response. Returns 0 if an error occurs or if it
914 * needs to wait, any other value otherwise.
Christopher Faulet75bc9132018-11-30 15:18:09 +0100915 *
916 * Be carefull, this function can be called from the HTTP legacy analyzers or
917 * from HTX analyzers. If your filter is compatible with the two modes, use
918 * IS_HTX_STRM macro on the stream.
Christopher Faulet309c6412015-12-02 09:57:32 +0100919 */
920int
921flt_analyze_http_headers(struct stream *s, struct channel *chn, unsigned int an_bit)
922{
Christopher Faulet1339d742016-05-11 16:48:33 +0200923 struct filter *filter;
924 struct http_msg *msg;
925 int ret = 1;
Christopher Faulet309c6412015-12-02 09:57:32 +0100926
Christopher Faulet1339d742016-05-11 16:48:33 +0200927 msg = ((chn->flags & CF_ISRESP) ? &s->txn->rsp : &s->txn->req);
Christopher Faulet309c6412015-12-02 09:57:32 +0100928 RESUME_FILTER_LOOP(s, chn) {
Christopher Faulet1339d742016-05-11 16:48:33 +0200929 if (FLT_OPS(filter)->http_headers) {
930 ret = FLT_OPS(filter)->http_headers(s, filter, msg);
Christopher Faulet309c6412015-12-02 09:57:32 +0100931 if (ret <= 0)
932 BREAK_EXECUTION(s, chn, check_result);
933 }
934 } RESUME_FILTER_END;
935
Christopher Fauletdf7d6812020-02-12 15:31:20 +0100936 if (IS_HTX_STRM(s)) {
937 if (HAS_DATA_FILTERS(s, chn)) {
938 size_t data = http_get_hdrs_size(htxbuf(&chn->buf));
939 struct filter *f;
940
941 list_for_each_entry(f, &strm_flt(s)->filters, list) {
942 if (IS_DATA_FILTER(f, chn))
943 FLT_OFF(f, chn) = data;
944 }
945 }
946 }
Christopher Faulet75bc9132018-11-30 15:18:09 +0100947 else {
948 /* We increase next offset of all "data" filters after all processing on
949 * headers because any filter can alter them. So the definitive size of
950 * headers (msg->sov) is only known when all filters have been
951 * called. */
952 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
953 /* Handle "data" filters only */
954 if (!IS_DATA_FILTER(filter, chn))
955 continue;
956 FLT_NXT(filter, chn) = msg->sov;
957 }
Christopher Faulet309c6412015-12-02 09:57:32 +0100958 }
959
960 check_result:
961 return handle_analyzer_result(s, chn, an_bit, ret);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200962}
963
964/*
965 * Calls 'channel_end_analyze' callback for all filters attached to a
966 * stream. This function is called when we stop to analyze a request or a
967 * response. It is called after all other analyzers. 'channel_end_analyze'
968 * callback is resumable, so this function returns 0 if an error occurs or if it
969 * needs to wait, any other value otherwise.
970 */
971int
972flt_end_analyze(struct stream *s, struct channel *chn, unsigned int an_bit)
973{
974 int ret = 1;
975
Christopher Faulete6006242017-03-10 11:52:44 +0100976 /* Check if all filters attached on the stream have finished their
977 * processing on this channel. */
978 if (!(chn->flags & CF_FLT_ANALYZE))
979 goto sync;
980
Christopher Fauletd7c91962015-04-30 11:48:27 +0200981 RESUME_FILTER_LOOP(s, chn) {
Christopher Fauletfcf035c2015-12-03 11:48:03 +0100982 FLT_NXT(filter, chn) = 0;
983 FLT_FWD(filter, chn) = 0;
Christopher Fauletda02e172015-12-04 09:25:05 +0100984 unregister_data_filter(s, chn, filter);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200985
Christopher Faulet443ea1a2016-02-04 13:40:26 +0100986 if (FLT_OPS(filter)->channel_end_analyze) {
987 ret = FLT_OPS(filter)->channel_end_analyze(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +0200988 if (ret <= 0)
989 BREAK_EXECUTION(s, chn, end);
990 }
991 } RESUME_FILTER_END;
992
Christopher Faulete6006242017-03-10 11:52:44 +0100993 end:
994 /* We don't remove yet this analyzer because we need to synchronize the
995 * both channels. So here, we just remove the flag CF_FLT_ANALYZE. */
996 ret = handle_analyzer_result(s, chn, 0, ret);
Christopher Faulet570f7992017-07-06 15:53:02 +0200997 if (ret) {
Christopher Faulete6006242017-03-10 11:52:44 +0100998 chn->flags &= ~CF_FLT_ANALYZE;
Christopher Faulet02c7b222015-12-22 12:01:29 +0100999
Christopher Faulet570f7992017-07-06 15:53:02 +02001000 /* Pretend there is an activity on both channels. Flag on the
1001 * current one will be automatically removed, so only the other
1002 * one will remain. This is a way to be sure that
1003 * 'channel_end_analyze' callback will have a chance to be
1004 * called at least once for the other side to finish the current
Joseph Herlantb35ea682018-11-15 12:24:23 -08001005 * processing. Of course, this is the filter responsibility to
Christopher Faulet570f7992017-07-06 15:53:02 +02001006 * wakeup the stream if it choose to loop on this callback. */
1007 s->req.flags |= CF_WAKE_ONCE;
1008 s->res.flags |= CF_WAKE_ONCE;
1009 }
1010
1011
Christopher Faulete6006242017-03-10 11:52:44 +01001012 sync:
1013 /* Now we can check if filters have finished their work on the both
1014 * channels */
1015 if (!(s->req.flags & CF_FLT_ANALYZE) && !(s->res.flags & CF_FLT_ANALYZE)) {
1016 /* Sync channels by removing this analyzer for the both channels */
1017 s->req.analysers &= ~AN_REQ_FLT_END;
1018 s->res.analysers &= ~AN_RES_FLT_END;
Christopher Fauletc6062be2016-10-31 11:22:37 +01001019
Christopher Faulete6006242017-03-10 11:52:44 +01001020 /* Clean up the HTTP transaction if needed */
1021 if (s->txn && (s->txn->flags & TX_WAIT_CLEANUP))
1022 http_end_txn_clean_session(s);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001023
Christopher Faulete6006242017-03-10 11:52:44 +01001024 /* Remove backend filters from the list */
1025 flt_stream_release(s, 1);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001026 }
Christopher Faulet2b553de2017-03-30 11:13:22 +02001027
Christopher Fauletd7c91962015-04-30 11:48:27 +02001028 return ret;
1029}
1030
1031
1032/*
1033 * Calls 'tcp_data' callback for all "data" filters attached to a stream. This
1034 * function is called when incoming data are available. It takes care to update
1035 * the next offset of filters and adjusts available data to be sure that a
1036 * filter cannot parse more data than its predecessors. A filter can choose to
1037 * not consume all available data. Returns -1 if an error occurs, the number of
1038 * consumed bytes otherwise.
1039 */
1040static int
1041flt_data(struct stream *s, struct channel *chn)
1042{
Christopher Fauletda02e172015-12-04 09:25:05 +01001043 struct filter *filter;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001044 unsigned int buf_i;
Christopher Faulet55048a42016-06-21 10:44:32 +02001045 int delta = 0, ret = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001046
1047 /* Save buffer state */
Willy Tarreau44a41a82018-06-19 07:16:31 +02001048 buf_i = ci_data(chn);
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001049
1050 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +01001051 unsigned int *nxt;
1052
1053 /* Call "data" filters only */
1054 if (!IS_DATA_FILTER(filter, chn))
1055 continue;
1056
1057 nxt = &FLT_NXT(filter, chn);
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001058 if (FLT_OPS(filter)->tcp_data) {
Willy Tarreau44a41a82018-06-19 07:16:31 +02001059 unsigned int i = ci_data(chn);
Christopher Faulet55048a42016-06-21 10:44:32 +02001060
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001061 ret = FLT_OPS(filter)->tcp_data(s, filter, chn);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001062 if (ret < 0)
1063 break;
Willy Tarreau44a41a82018-06-19 07:16:31 +02001064 delta += (int)(ci_data(chn) - i);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001065
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001066 /* Increase next offset of the current filter */
Christopher Fauletda02e172015-12-04 09:25:05 +01001067 *nxt += ret;
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001068
1069 /* And set this value as the bound for the next
1070 * filter. It will not able to parse more data than the
1071 * current one. */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001072 b_set_data(&chn->buf, co_data(chn) + *nxt);
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001073 }
1074 else {
1075 /* Consume all available data */
Willy Tarreau44a41a82018-06-19 07:16:31 +02001076 *nxt = ci_data(chn);
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001077 }
Christopher Fauletd7c91962015-04-30 11:48:27 +02001078
1079 /* Update <ret> value to be sure to have the last one when we
Christopher Fauletda02e172015-12-04 09:25:05 +01001080 * exit from the loop. This value will be used to know how much
1081 * data are "forwardable" */
1082 ret = *nxt;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001083 }
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001084
1085 /* Restore the original buffer state */
Willy Tarreauc9fa0482018-07-10 17:43:27 +02001086 b_set_data(&chn->buf, co_data(chn) + buf_i + delta);
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001087
Christopher Fauletd7c91962015-04-30 11:48:27 +02001088 return ret;
1089}
1090
1091/*
1092 * Calls 'tcp_forward_data' callback for all "data" filters attached to a
1093 * stream. This function is called when some data can be forwarded. It takes
1094 * care to update the forward offset of filters and adjusts "forwardable" data
1095 * to be sure that a filter cannot forward more data than its predecessors. A
1096 * filter can choose to not forward all parsed data. Returns a negative value if
1097 * an error occurs, else the number of forwarded bytes.
1098 */
1099static int
1100flt_forward_data(struct stream *s, struct channel *chn, unsigned int len)
1101{
Christopher Fauletda02e172015-12-04 09:25:05 +01001102 struct filter *filter;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001103 int ret = len;
1104
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001105 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +01001106 unsigned int *fwd;
1107
1108 /* Call "data" filters only */
1109 if (!IS_DATA_FILTER(filter, chn))
1110 continue;
1111
1112 fwd = &FLT_FWD(filter, chn);
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001113 if (FLT_OPS(filter)->tcp_forward_data) {
Christopher Fauletd7c91962015-04-30 11:48:27 +02001114 /* Remove bytes that the current filter considered as
1115 * forwarded */
Christopher Faulet443ea1a2016-02-04 13:40:26 +01001116 ret = FLT_OPS(filter)->tcp_forward_data(s, filter, chn, ret - *fwd);
Christopher Fauletd7c91962015-04-30 11:48:27 +02001117 if (ret < 0)
1118 goto end;
1119 }
1120
Christopher Fauletda02e172015-12-04 09:25:05 +01001121 /* Adjust bytes that the current filter considers as
Christopher Fauletd7c91962015-04-30 11:48:27 +02001122 * forwarded */
Christopher Fauletda02e172015-12-04 09:25:05 +01001123 *fwd += ret;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001124
1125 /* And set this value as the bound for the next filter. It will
1126 * not able to forward more data than the current one. */
Christopher Fauletda02e172015-12-04 09:25:05 +01001127 ret = *fwd;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001128 }
1129
1130 if (!ret)
1131 goto end;
1132
Christopher Fauletda02e172015-12-04 09:25:05 +01001133 /* Finally, adjust filters offsets by removing data that HAProxy will
1134 * forward. */
Christopher Fauletfcf035c2015-12-03 11:48:03 +01001135 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
Christopher Fauletda02e172015-12-04 09:25:05 +01001136 if (!IS_DATA_FILTER(filter, chn))
1137 continue;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001138 FLT_NXT(filter, chn) -= ret;
1139 FLT_FWD(filter, chn) -= ret;
1140 }
1141
Christopher Fauletd7c91962015-04-30 11:48:27 +02001142 end:
1143 return ret;
1144}
1145
1146/*
1147 * Called when TCP data must be filtered on a channel. This function is the
Christopher Faulet0184ea72017-01-05 14:06:34 +01001148 * AN_REQ/RES_FLT_XFER_DATA analyzer. When called, it is responsible to forward
1149 * data when the proxy is not in http mode. Behind the scene, it calls
1150 * consecutively 'tcp_data' and 'tcp_forward_data' callbacks for all "data"
1151 * filters attached to a stream. Returns 0 if an error occurs or if it needs to
1152 * wait, any other value otherwise.
Christopher Fauletd7c91962015-04-30 11:48:27 +02001153 */
1154int
1155flt_xfer_data(struct stream *s, struct channel *chn, unsigned int an_bit)
1156{
1157 int ret = 1;
1158
Christopher Fauletda02e172015-12-04 09:25:05 +01001159 /* If there is no "data" filters, we do nothing */
Christopher Faulet166bd752019-11-08 15:31:49 +01001160 if (!HAS_DATA_FILTERS(s, chn) || (s->flags & SF_HTX))
Christopher Fauletda02e172015-12-04 09:25:05 +01001161 goto end;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001162
1163 /* Be sure that the output is still opened. Else we stop the data
1164 * filtering. */
1165 if ((chn->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) ||
Willy Tarreau44a41a82018-06-19 07:16:31 +02001166 ((chn->flags & CF_SHUTW) && (chn->to_forward || co_data(chn))))
Christopher Fauletd7c91962015-04-30 11:48:27 +02001167 goto end;
1168
1169 /* Let all "data" filters parsing incoming data */
1170 ret = flt_data(s, chn);
1171 if (ret < 0)
1172 goto end;
1173
1174 /* And forward them */
1175 ret = flt_forward_data(s, chn, ret);
1176 if (ret < 0)
1177 goto end;
1178
Christopher Fauletda02e172015-12-04 09:25:05 +01001179 /* Consume data that all filters consider as forwarded. */
Willy Tarreaubcbd3932018-06-06 07:13:22 +02001180 c_adv(chn, ret);
Christopher Fauletda02e172015-12-04 09:25:05 +01001181
Christopher Fauletd7c91962015-04-30 11:48:27 +02001182 /* Stop waiting data if the input in closed and no data is pending or if
1183 * the output is closed. */
1184 if ((chn->flags & CF_SHUTW) ||
Willy Tarreau5ba65522018-06-15 15:14:53 +02001185 ((chn->flags & CF_SHUTR) && !ci_data(chn))) {
Christopher Fauletd7c91962015-04-30 11:48:27 +02001186 ret = 1;
1187 goto end;
1188 }
1189
1190 /* Wait for data */
1191 return 0;
1192 end:
1193 /* Terminate the data filtering. If <ret> is negative, an error was
1194 * encountered during the filtering. */
1195 return handle_analyzer_result(s, chn, an_bit, ret);
1196}
1197
1198/*
1199 * Handles result of filter's analyzers. It returns 0 if an error occurs or if
1200 * it needs to wait, any other value otherwise.
1201 */
1202static int
1203handle_analyzer_result(struct stream *s, struct channel *chn,
1204 unsigned int an_bit, int ret)
1205{
1206 int finst;
Christopher Fauleteab13f02019-09-06 15:24:55 +02001207 int status = 0;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001208
1209 if (ret < 0)
1210 goto return_bad_req;
1211 else if (!ret)
1212 goto wait;
1213
1214 /* End of job, return OK */
1215 if (an_bit) {
1216 chn->analysers &= ~an_bit;
1217 chn->analyse_exp = TICK_ETERNITY;
1218 }
1219 return 1;
1220
1221 return_bad_req:
1222 /* An error occurs */
1223 channel_abort(&s->req);
1224 channel_abort(&s->res);
1225
1226 if (!(chn->flags & CF_ISRESP)) {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001227 s->req.analysers &= AN_REQ_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001228 finst = SF_FINST_R;
Christopher Fauleteab13f02019-09-06 15:24:55 +02001229 status = 400;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001230 /* FIXME: incr counters */
1231 }
1232 else {
Christopher Faulet0184ea72017-01-05 14:06:34 +01001233 s->res.analysers &= AN_RES_FLT_END;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001234 finst = SF_FINST_H;
Christopher Fauleteab13f02019-09-06 15:24:55 +02001235 status = 502;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001236 /* FIXME: incr counters */
1237 }
1238
1239 if (s->txn) {
1240 /* Do not do that when we are waiting for the next request */
Christopher Fauleteab13f02019-09-06 15:24:55 +02001241 if (s->txn->status > 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +02001242 http_reply_and_close(s, s->txn->status, NULL);
1243 else {
Christopher Fauleteab13f02019-09-06 15:24:55 +02001244 s->txn->status = status;
1245 http_reply_and_close(s, status, http_error_message(s));
Christopher Fauletd7c91962015-04-30 11:48:27 +02001246 }
1247 }
1248
1249 if (!(s->flags & SF_ERR_MASK))
1250 s->flags |= SF_ERR_PRXCOND;
1251 if (!(s->flags & SF_FINST_MASK))
1252 s->flags |= finst;
1253 return 0;
1254
1255 wait:
1256 if (!(chn->flags & CF_ISRESP))
1257 channel_dont_connect(chn);
1258 return 0;
1259}
1260
1261
1262/* Note: must not be declared <const> as its list will be overwritten.
1263 * Please take care of keeping this list alphabetically sorted, doing so helps
1264 * all code contributors.
1265 * Optional keywords are also declared with a NULL ->parse() function so that
1266 * the config parser can report an appropriate error when a known keyword was
1267 * not enabled. */
1268static struct cfg_kw_list cfg_kws = {ILH, {
1269 { CFG_LISTEN, "filter", parse_filter },
1270 { 0, NULL, NULL },
1271 }
1272};
1273
Willy Tarreau0108d902018-11-25 19:14:37 +01001274INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1275
Willy Tarreau172f5ce2018-11-26 11:21:50 +01001276REGISTER_POST_CHECK(flt_init_all);
1277REGISTER_PER_THREAD_INIT(flt_init_all_per_thread);
1278REGISTER_PER_THREAD_DEINIT(flt_deinit_all_per_thread);
1279
Christopher Fauletd7c91962015-04-30 11:48:27 +02001280/*
1281 * Local variables:
1282 * c-indent-level: 8
1283 * c-basic-offset: 8
1284 * End:
1285 */