blob: f33650fc0ebc048e39b4abd91e426dca695bcebf [file] [log] [blame]
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001/*
2 * Functions about FCGI applications and filters.
3 *
4 * Copyright (C) 2019 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.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 Tarreaudcc048a2020-06-04 19:11:43 +020013#include <haproxy/acl.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020014#include <haproxy/api.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020015#include <haproxy/cfgparse.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020016#include <haproxy/chunk.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020017#include <haproxy/errors.h>
Willy Tarreauc6599682020-06-04 21:33:21 +020018#include <haproxy/fcgi-app.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020019#include <haproxy/filters.h>
Willy Tarreau126ba3a2020-06-04 18:26:43 +020020#include <haproxy/http_fetch.h>
Willy Tarreau87735332020-06-04 09:08:41 +020021#include <haproxy/http_htx.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020022#include <haproxy/log.h>
Willy Tarreau03f839d2021-05-08 20:23:18 +020023#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020024#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020025#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020026#include <haproxy/server-t.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020027#include <haproxy/session.h>
Christopher Fauletc97406f2020-06-22 11:07:18 +020028#include <haproxy/sink.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020029#include <haproxy/tools.h>
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020030
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020031
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020032/* Global list of all FCGI applications */
33static struct fcgi_app *fcgi_apps = NULL;
34
35struct flt_ops fcgi_flt_ops;
36const char *fcgi_flt_id = "FCGI filter";
37
38DECLARE_STATIC_POOL(pool_head_fcgi_flt_ctx, "fcgi_flt_ctx", sizeof(struct fcgi_flt_ctx));
39DECLARE_STATIC_POOL(pool_head_fcgi_param_rule, "fcgi_param_rule", sizeof(struct fcgi_param_rule));
40DECLARE_STATIC_POOL(pool_head_fcgi_hdr_rule, "fcgi_hdr_rule", sizeof(struct fcgi_hdr_rule));
41
42/**************************************************************************/
43/***************************** Uitls **************************************/
44/**************************************************************************/
45/* Makes a fcgi parameter name (prefixed by ':fcgi-') with <name> (in
46 * lowercase). All non alphanumeric character are replaced by an underscore
47 * ('_'). The result is copied into <dst>. the corrsponding ist is returned.
48 */
49static struct ist fcgi_param_name(char *dst, const struct ist name)
50{
51 size_t ofs1, ofs2;
52
53 memcpy(dst, ":fcgi-", 6);
54 ofs1 = 6;
55 for (ofs2 = 0; ofs2 < name.len; ofs2++) {
Willy Tarreau90807112020-02-25 08:16:33 +010056 if (isalnum((unsigned char)name.ptr[ofs2]))
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020057 dst[ofs1++] = ist_lc[(unsigned char)name.ptr[ofs2]];
58 else
59 dst[ofs1++] = '_';
60 }
61 return ist2(dst, ofs1);
62}
63
Ilya Shipitsin47d17182020-06-21 21:42:57 +050064/* Returns a pointer to the FCGi application matching the name <name>. NULL is
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020065 * returned if no match found.
66 */
67struct fcgi_app *fcgi_app_find_by_name(const char *name)
68{
69 struct fcgi_app *app;
70
71 for (app = fcgi_apps; app != NULL; app = app->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +010072 if (strcmp(app->name, name) == 0)
Christopher Faulet78fbb9f2019-08-11 23:11:03 +020073 return app;
74 }
75
76 return NULL;
77}
78
79struct fcgi_flt_conf *find_px_fcgi_conf(struct proxy *px)
80{
81 struct flt_conf *fconf;
82
83 list_for_each_entry(fconf, &px->filter_configs, list) {
84 if (fconf->id == fcgi_flt_id)
85 return fconf->conf;
86 }
87 return NULL;
88}
89
90struct fcgi_flt_ctx *find_strm_fcgi_ctx(struct stream *s)
91{
92 struct filter *filter;
93
94 if (!s)
95 return NULL;
96
97 list_for_each_entry(filter, &strm_flt(s)->filters, list) {
98 if (FLT_ID(filter) == fcgi_flt_id)
99 return FLT_CONF(filter);
100 }
101 return NULL;
102}
103
104struct fcgi_app *get_px_fcgi_app(struct proxy *px)
105{
106 struct fcgi_flt_conf *fcgi_conf = find_px_fcgi_conf(px);
107
108 if (fcgi_conf)
109 return fcgi_conf->app;
110 return NULL;
111}
112
113struct fcgi_app *get_strm_fcgi_app(struct stream *s)
114{
115 struct fcgi_flt_ctx *fcgi_ctx = find_strm_fcgi_ctx(s);
116
117 if (fcgi_ctx)
118 return fcgi_ctx->app;
119 return NULL;
120}
121
122static void fcgi_release_rule_conf(struct fcgi_rule_conf *rule)
123{
124 if (!rule)
125 return;
126 free(rule->name);
127 free(rule->value);
128 if (rule->cond) {
129 prune_acl_cond(rule->cond);
130 free(rule->cond);
131 }
132 free(rule);
133}
134
135static void fcgi_release_rule(struct fcgi_rule *rule)
136{
137 if (!rule)
138 return;
139
140 if (!LIST_ISEMPTY(&rule->value)) {
141 struct logformat_node *lf, *lfb;
142
143 list_for_each_entry_safe(lf, lfb, &rule->value, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200144 LIST_DELETE(&lf->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200145 release_sample_expr(lf->expr);
146 free(lf->arg);
147 free(lf);
148 }
149 }
150 /* ->cond and ->name are not owned by the rule */
151 free(rule);
152}
153
154/**************************************************************************/
155/*********************** FCGI Sample fetches ******************************/
156/**************************************************************************/
157
158static int smp_fetch_fcgi_docroot(const struct arg *args, struct sample *smp,
159 const char *kw, void *private)
160{
161 struct fcgi_app *app = get_strm_fcgi_app(smp->strm);
162
163 if (!app)
164 return 0;
165
166 smp->data.type = SMP_T_STR;
167 smp->data.u.str.area = app->docroot.ptr;
168 smp->data.u.str.data = app->docroot.len;
169 smp->flags = SMP_F_CONST;
170 return 1;
171}
172
173static int smp_fetch_fcgi_index(const struct arg *args, struct sample *smp,
174 const char *kw, void *private)
175{
176 struct fcgi_app *app = get_strm_fcgi_app(smp->strm);
177
178 if (!app || !istlen(app->index))
179 return 0;
180
181 smp->data.type = SMP_T_STR;
182 smp->data.u.str.area = app->index.ptr;
183 smp->data.u.str.data = app->index.len;
184 smp->flags = SMP_F_CONST;
185 return 1;
186}
187
188/**************************************************************************/
189/************************** FCGI filter ***********************************/
190/**************************************************************************/
191static int fcgi_flt_init(struct proxy *px, struct flt_conf *fconf)
192{
193 fconf->flags |= FLT_CFG_FL_HTX;
194 return 0;
195}
196
197static void fcgi_flt_deinit(struct proxy *px, struct flt_conf *fconf)
198{
199 struct fcgi_flt_conf *fcgi_conf = fconf->conf;
200 struct fcgi_rule *rule, *back;
201
202 if (!fcgi_conf)
203 return;
204
205 free(fcgi_conf->name);
206
207 list_for_each_entry_safe(rule, back, &fcgi_conf->param_rules, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200208 LIST_DELETE(&rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200209 fcgi_release_rule(rule);
210 }
211
212 list_for_each_entry_safe(rule, back, &fcgi_conf->hdr_rules, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200213 LIST_DELETE(&rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200214 fcgi_release_rule(rule);
215 }
216
217 free(fcgi_conf);
218}
219
220static int fcgi_flt_check(struct proxy *px, struct flt_conf *fconf)
221{
222 struct fcgi_flt_conf *fcgi_conf = fconf->conf;
223 struct fcgi_rule_conf *crule, *back;
224 struct fcgi_rule *rule = NULL;
225 struct flt_conf *f;
226 char *errmsg = NULL;
227
228 fcgi_conf->app = fcgi_app_find_by_name(fcgi_conf->name);
229 if (!fcgi_conf->app) {
230 ha_alert("config : proxy '%s' : fcgi-app '%s' not found.\n",
231 px->id, fcgi_conf->name);
232 goto err;
233 }
234
235 list_for_each_entry(f, &px->filter_configs, list) {
236 if (f->id == http_comp_flt_id || f->id == cache_store_flt_id)
237 continue;
238 else if ((f->id == fconf->id) && f->conf != fcgi_conf) {
239 ha_alert("config : proxy '%s' : only one fcgi-app supported per backend.\n",
240 px->id);
241 goto err;
242 }
243 else if (f->id != fconf->id) {
244 /* Implicit declaration is only allowed with the
245 * compression and cache. For other filters, an implicit
246 * declaration is required. */
247 ha_alert("config: proxy '%s': require an explicit filter declaration "
248 "to use the fcgi-app '%s'.\n", px->id, fcgi_conf->name);
249 goto err;
250 }
251 }
252
253 list_for_each_entry_safe(crule, back, &fcgi_conf->app->conf.rules, list) {
254 rule = calloc(1, sizeof(*rule));
255 if (!rule) {
256 ha_alert("config : proxy '%s' : out of memory.\n", px->id);
257 goto err;
258 }
259 rule->type = crule->type;
260 rule->name = ist(crule->name);
261 rule->cond = crule->cond;
262 LIST_INIT(&rule->value);
263
264 if (crule->value) {
265 if (!parse_logformat_string(crule->value, px, &rule->value, LOG_OPT_HTTP,
266 SMP_VAL_BE_HRQ_HDR, &errmsg)) {
267 ha_alert("config : proxy '%s' : %s.\n", px->id, errmsg);
268 goto err;
269 }
270 }
271
272 if (rule->type == FCGI_RULE_SET_PARAM || rule->type == FCGI_RULE_UNSET_PARAM)
Willy Tarreau2b718102021-04-21 07:32:39 +0200273 LIST_APPEND(&fcgi_conf->param_rules, &rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200274 else /* FCGI_RULE_PASS_HDR/FCGI_RULE_HIDE_HDR */
Willy Tarreau2b718102021-04-21 07:32:39 +0200275 LIST_APPEND(&fcgi_conf->hdr_rules, &rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200276 rule = NULL;
277 }
278 return 0;
279
280 err:
281 free(errmsg);
282 free(rule);
283 return 1;
284}
285
286static int fcgi_flt_start(struct stream *s, struct filter *filter)
287{
288 struct fcgi_flt_conf *fcgi_conf = FLT_CONF(filter);
289 struct fcgi_flt_ctx *fcgi_ctx;
290
Willy Tarreau18f43d82021-03-22 15:07:37 +0100291 fcgi_ctx = pool_alloc(pool_head_fcgi_flt_ctx);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200292 if (fcgi_ctx == NULL) {
293 // FIXME: send a warning
294 return 0;
295 }
296 fcgi_ctx->filter = filter;
297 fcgi_ctx->app = fcgi_conf->app;
298 filter->ctx = fcgi_ctx;
299
300 s->req.analysers |= AN_REQ_HTTP_BODY;
301 return 1;
302}
303
304static void fcgi_flt_stop(struct stream *s, struct filter *filter)
305{
306 struct flt_fcgi_ctx *fcgi_ctx = filter->ctx;
307
308 if (!fcgi_ctx)
309 return;
310 pool_free(pool_head_fcgi_flt_ctx, fcgi_ctx);
311 filter->ctx = NULL;
312}
313
314static int fcgi_flt_http_headers(struct stream *s, struct filter *filter, struct http_msg *msg)
315{
316 struct session *sess = strm_sess(s);
317 struct buffer *value;
318 struct fcgi_flt_conf *fcgi_conf = FLT_CONF(filter);
319 struct fcgi_rule *rule;
320 struct fcgi_param_rule *param_rule;
321 struct fcgi_hdr_rule *hdr_rule;
322 struct ebpt_node *node, *next;
323 struct eb_root param_rules = EB_ROOT;
324 struct eb_root hdr_rules = EB_ROOT;
325 struct htx *htx;
326 struct http_hdr_ctx ctx;
327 int ret;
328
329 htx = htxbuf(&msg->chn->buf);
330
331 if (msg->chn->flags & CF_ISRESP) {
332 struct htx_sl *sl;
333
334 /* Remove the header "Status:" from the response */
335 ctx.blk = NULL;
336 while (http_find_header(htx, ist("status"), &ctx, 1))
337 http_remove_header(htx, &ctx);
338
339 /* Add the header "Date:" if not found */
340 ctx.blk = NULL;
341 if (!http_find_header(htx, ist("date"), &ctx, 1)) {
342 struct tm tm;
343
344 get_gmtime(date.tv_sec, &tm);
345 trash.data = strftime(trash.area, trash.size, "%a, %d %b %Y %T %Z", &tm);
346 if (trash.data)
347 http_add_header(htx, ist("date"), ist2(trash.area, trash.data));
348 }
349
350 /* Add the header "Content-Length:" if possible */
351 sl = http_get_stline(htx);
352 if (sl &&
353 (sl->flags & (HTX_SL_F_XFER_LEN|HTX_SL_F_CLEN|HTX_SL_F_CHNK)) == HTX_SL_F_XFER_LEN &&
Christopher Fauletd1ac2b92020-12-02 19:12:22 +0100354 (htx->flags & HTX_FL_EOM)) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200355 struct htx_blk * blk;
356 char *end;
357 size_t len = 0;
358
359 for (blk = htx_get_first_blk(htx); blk; blk = htx_get_next_blk(htx, blk)) {
360 enum htx_blk_type type = htx_get_blk_type(blk);
361
Christopher Fauletd1ac2b92020-12-02 19:12:22 +0100362 if (type == HTX_BLK_TLR || type == HTX_BLK_EOT)
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200363 break;
364 if (type == HTX_BLK_DATA)
365 len += htx_get_blksz(blk);
366 }
367 end = ultoa_o(len, trash.area, trash.size);
368 if (http_add_header(htx, ist("content-length"), ist2(trash.area, end-trash.area)))
369 sl->flags |= HTX_SL_F_CLEN;
370 }
371
372 return 1;
373 }
374
375 /* Analyze the request's headers */
376
377 value = alloc_trash_chunk();
378 if (!value)
379 goto end;
380
381 list_for_each_entry(rule, &fcgi_conf->param_rules, list) {
382 if (rule->cond) {
383 ret = acl_exec_cond(rule->cond, s->be, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
384 ret = acl_pass(ret);
385 if (rule->cond->pol == ACL_COND_UNLESS)
386 ret = !ret;
387
388 /* the rule does not match */
389 if (!ret)
390 continue;
391 }
392
393 param_rule = NULL;
394 node = ebis_lookup_len(&param_rules, rule->name.ptr, rule->name.len);
395 if (node) {
396 param_rule = container_of(node, struct fcgi_param_rule, node);
397 ebpt_delete(node);
398 }
399 else {
Willy Tarreau18f43d82021-03-22 15:07:37 +0100400 param_rule = pool_alloc(pool_head_fcgi_param_rule);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200401 if (param_rule == NULL)
402 goto param_rule_err;
403 }
404
405 param_rule->node.key = rule->name.ptr;
406 param_rule->name = rule->name;
407 param_rule->value = &rule->value;
408 ebis_insert(&param_rules, &param_rule->node);
409 }
410
411 list_for_each_entry(rule, &fcgi_conf->hdr_rules, list) {
412 if (rule->cond) {
413 ret = acl_exec_cond(rule->cond, s->be, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
414 ret = acl_pass(ret);
415 if (rule->cond->pol == ACL_COND_UNLESS)
416 ret = !ret;
417
418 /* the rule does not match */
419 if (!ret)
420 continue;
421 }
422
423 hdr_rule = NULL;
424 node = ebis_lookup_len(&hdr_rules, rule->name.ptr, rule->name.len);
425 if (node) {
426 hdr_rule = container_of(node, struct fcgi_hdr_rule, node);
427 ebpt_delete(node);
428 }
429 else {
Willy Tarreau18f43d82021-03-22 15:07:37 +0100430 hdr_rule = pool_alloc(pool_head_fcgi_hdr_rule);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200431 if (hdr_rule == NULL)
432 goto hdr_rule_err;
433 }
434
435 hdr_rule->node.key = rule->name.ptr;
436 hdr_rule->name = rule->name;
437 hdr_rule->pass = (rule->type == FCGI_RULE_PASS_HDR);
438 ebis_insert(&hdr_rules, &hdr_rule->node);
439 }
440
441 node = ebpt_first(&param_rules);
442 while (node) {
443 next = ebpt_next(node);
444 ebpt_delete(node);
445 param_rule = container_of(node, struct fcgi_param_rule, node);
446 node = next;
447
448 b_reset(value);
449 value->data = build_logline(s, value->area, value->size, param_rule->value);
Harris Kaufmannb605a732020-07-15 16:26:13 +0200450 if (!value->data) {
451 pool_free(pool_head_fcgi_param_rule, param_rule);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200452 continue;
Harris Kaufmannb605a732020-07-15 16:26:13 +0200453 }
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200454 if (!http_add_header(htx, param_rule->name, ist2(value->area, value->data)))
455 goto rewrite_err;
456 pool_free(pool_head_fcgi_param_rule, param_rule);
457 }
458
459 node = ebpt_first(&hdr_rules);
460 while (node) {
461 next = ebpt_next(node);
462 ebpt_delete(node);
463 hdr_rule = container_of(node, struct fcgi_hdr_rule, node);
464 node = next;
465
466 if (!hdr_rule->pass) {
467 ctx.blk = NULL;
468 while (http_find_header(htx, hdr_rule->name, &ctx, 1))
469 http_remove_header(htx, &ctx);
470 }
471 pool_free(pool_head_fcgi_hdr_rule, hdr_rule);
472 }
473
474 goto end;
475
476 rewrite_err:
Willy Tarreau4781b152021-04-06 13:53:36 +0200477 _HA_ATOMIC_INC(&sess->fe->fe_counters.failed_rewrites);
478 _HA_ATOMIC_INC(&s->be->be_counters.failed_rewrites);
William Lallemand36119de2021-03-08 15:26:48 +0100479 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +0200480 _HA_ATOMIC_INC(&sess->listener->counters->failed_rewrites);
Christopher Fauletcff0f732019-12-16 16:13:44 +0100481 if (objt_server(s->target))
Willy Tarreau4781b152021-04-06 13:53:36 +0200482 _HA_ATOMIC_INC(&__objt_server(s->target)->counters.failed_rewrites);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200483 hdr_rule_err:
484 node = ebpt_first(&hdr_rules);
485 while (node) {
486 next = ebpt_next(node);
487 ebpt_delete(node);
488 hdr_rule = container_of(node, struct fcgi_hdr_rule, node);
489 node = next;
490 pool_free(pool_head_fcgi_hdr_rule, hdr_rule);
491 }
492 param_rule_err:
493 node = ebpt_first(&param_rules);
494 while (node) {
495 next = ebpt_next(node);
496 ebpt_delete(node);
497 param_rule = container_of(node, struct fcgi_param_rule, node);
498 node = next;
499 pool_free(pool_head_fcgi_param_rule, param_rule);
500 }
501 end:
502 free_trash_chunk(value);
503 return 1;
504}
505
506struct flt_ops fcgi_flt_ops = {
507 .init = fcgi_flt_init,
508 .check = fcgi_flt_check,
509 .deinit = fcgi_flt_deinit,
510
511 .attach = fcgi_flt_start,
512 .detach = fcgi_flt_stop,
513
514 .http_headers = fcgi_flt_http_headers,
515};
516
517/**************************************************************************/
518/*********************** FCGI Config parsing ******************************/
519/**************************************************************************/
520static int
521parse_fcgi_flt(char **args, int *cur_arg, struct proxy *px,
522 struct flt_conf *fconf, char **err, void *private)
523{
524 struct flt_conf *f, *back;
525 struct fcgi_flt_conf *fcgi_conf = NULL;
526 char *name = NULL;
527 int pos = *cur_arg;
528
529 /* Get the fcgi-app name*/
Christopher Faulet0ce57b02019-09-18 11:18:33 +0200530 if (!*args[pos + 1]) {
531 memprintf(err, "%s : expects a <name> argument", args[pos]);
532 goto err;
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200533 }
Christopher Faulet0ce57b02019-09-18 11:18:33 +0200534 name = strdup(args[pos + 1]);
535 if (!name) {
536 memprintf(err, "%s '%s' : out of memory", args[pos], args[pos + 1]);
537 goto err;
538 }
539 pos += 2;
540
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200541 /* Check if an fcgi-app filter with the same name already exists */
542 list_for_each_entry_safe(f, back, &px->filter_configs, list) {
543 if (f->id != fcgi_flt_id)
544 continue;
545 fcgi_conf = f->conf;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100546 if (strcmp(name, fcgi_conf->name) != 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200547 fcgi_conf = NULL;
548 continue;
549 }
550
551 /* Place the filter at its right position */
Willy Tarreau2b718102021-04-21 07:32:39 +0200552 LIST_DELETE(&f->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200553 free(f);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100554 ha_free(&name);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200555 break;
556 }
557
558 /* No other fcgi-app filter found, create configuration for the explicit one */
559 if (!fcgi_conf) {
560 fcgi_conf = calloc(1, sizeof(*fcgi_conf));
561 if (!fcgi_conf) {
562 memprintf(err, "%s: out of memory", args[*cur_arg]);
563 goto err;
564 }
565 fcgi_conf->name = name;
566 LIST_INIT(&fcgi_conf->param_rules);
567 LIST_INIT(&fcgi_conf->hdr_rules);
568 }
569
570 fconf->id = fcgi_flt_id;
571 fconf->conf = fcgi_conf;
572 fconf->ops = &fcgi_flt_ops;
573
574 *cur_arg = pos;
575 return 0;
576 err:
577 free(name);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200578 return -1;
579}
580
581/* Parses the "use-fcgi-app" proxy keyword */
582static int proxy_parse_use_fcgi_app(char **args, int section, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +0100583 const struct proxy *defpx, const char *file, int line,
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200584 char **err)
585{
586 struct flt_conf *fconf = NULL;
587 struct fcgi_flt_conf *fcgi_conf = NULL;
588 int retval = 0;
589
590 if (!(curpx->cap & PR_CAP_BE)) {
591 memprintf(err, "'%s' only available in backend or listen section", args[0]);
592 retval = -1;
593 goto end;
594 }
595
596 if (!*(args[1])) {
597 memprintf(err, "'%s' expects <name> as argument", args[0]);
598 retval = -1;
599 goto end;
600 }
601
602 /* check if a fcgi filter was already registered with this name,
603 * if that's the case, must use it. */
604 list_for_each_entry(fconf, &curpx->filter_configs, list) {
605 if (fconf->id == fcgi_flt_id) {
606 fcgi_conf = fconf->conf;
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100607 if (fcgi_conf && strcmp((char *)fcgi_conf->name, args[1]) == 0)
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200608 goto end;
609 memprintf(err, "'%s' : only one fcgi-app supported per backend", args[0]);
610 retval = -1;
611 goto end;
612 }
613 }
614
615 /* Create the FCGI filter config */
616 fcgi_conf = calloc(1, sizeof(*fcgi_conf));
617 if (!fcgi_conf)
618 goto err;
619 fcgi_conf->name = strdup(args[1]);
620 LIST_INIT(&fcgi_conf->param_rules);
621 LIST_INIT(&fcgi_conf->hdr_rules);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200622
623 /* Register the filter */
624 fconf = calloc(1, sizeof(*fconf));
625 if (!fconf)
626 goto err;
627 fconf->id = fcgi_flt_id;
628 fconf->conf = fcgi_conf;
629 fconf->ops = &fcgi_flt_ops;
Willy Tarreau2b718102021-04-21 07:32:39 +0200630 LIST_APPEND(&curpx->filter_configs, &fconf->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200631
632 end:
633 return retval;
634 err:
635 if (fcgi_conf) {
636 free(fcgi_conf->name);
637 free(fcgi_conf);
638 }
639 memprintf(err, "out of memory");
640 retval = -1;
641 goto end;
642}
643
644/* Finishes the parsing of FCGI application of proxies and servers */
645static int cfg_fcgi_apps_postparser()
646{
647 struct fcgi_app *curapp;
648 struct proxy *px;
649 struct server *srv;
Christopher Fauletc97406f2020-06-22 11:07:18 +0200650 struct logsrv *logsrv;
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200651 int err_code = 0;
652
653 for (px = proxies_list; px; px = px->next) {
654 struct fcgi_flt_conf *fcgi_conf = find_px_fcgi_conf(px);
655 int nb_fcgi_srv = 0;
656
657 if (px->mode == PR_MODE_TCP && fcgi_conf) {
658 ha_alert("config : proxy '%s': FCGI application cannot be used in non-HTTP mode.\n",
659 px->id);
660 err_code |= ERR_ALERT | ERR_FATAL;
661 goto end;
662 }
663
664 for (srv = px->srv; srv; srv = srv->next) {
665 if (srv->mux_proto && isteq(srv->mux_proto->token, ist("fcgi"))) {
666 nb_fcgi_srv++;
667 if (fcgi_conf)
668 continue;
669 ha_alert("config : proxy '%s': FCGI server '%s' has no FCGI app configured.\n",
670 px->id, srv->id);
671 err_code |= ERR_ALERT | ERR_FATAL;
672 goto end;
673 }
674 }
675 if (fcgi_conf && !nb_fcgi_srv) {
676 ha_alert("config : proxy '%s': FCGI app configured but no FCGI server found.\n",
677 px->id);
678 err_code |= ERR_ALERT | ERR_FATAL;
679 goto end;
680 }
681 }
682
683 for (curapp = fcgi_apps; curapp != NULL; curapp = curapp->next) {
684 if (!istlen(curapp->docroot)) {
685 ha_alert("config : fcgi-app '%s': no docroot configured.\n",
686 curapp->name);
687 err_code |= ERR_ALERT | ERR_FATAL;
688 goto end;
689 }
690 if (!(curapp->flags & (FCGI_APP_FL_MPXS_CONNS|FCGI_APP_FL_GET_VALUES))) {
691 if (curapp->maxreqs > 1) {
692 ha_warning("config : fcgi-app '%s': multiplexing not supported, "
693 "ignore the option 'max-reqs'.\n",
694 curapp->name);
695 err_code |= ERR_WARN;
696 }
697 curapp->maxreqs = 1;
698 }
Christopher Fauletc97406f2020-06-22 11:07:18 +0200699
700 list_for_each_entry(logsrv, &curapp->logsrvs, list) {
701 if (logsrv->type == LOG_TARGET_BUFFER) {
702 struct sink *sink = sink_find(logsrv->ring_name);
703
704 if (!sink || sink->type != SINK_TYPE_BUFFER) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500705 ha_alert("config : fcgi-app '%s' : log server uses unknown ring named '%s'.\n",
Christopher Fauletc97406f2020-06-22 11:07:18 +0200706 curapp->name, logsrv->ring_name);
707 err_code |= ERR_ALERT | ERR_FATAL;
708 }
709 logsrv->sink = sink;
710 }
711 }
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200712 }
713
714 end:
715 return err_code;
716}
717
718static int fcgi_app_add_rule(struct fcgi_app *curapp, enum fcgi_rule_type type, char *name, char *value,
719 struct acl_cond *cond, char **err)
720{
721 struct fcgi_rule_conf *rule;
722
723 /* Param not found, add a new one */
724 rule = calloc(1, sizeof(*rule));
725 if (!rule)
726 goto err;
727 LIST_INIT(&rule->list);
728 rule->type = type;
729 if (type == FCGI_RULE_SET_PARAM || type == FCGI_RULE_UNSET_PARAM) {
730 struct ist fname = fcgi_param_name(trash.area, ist(name));
731 rule->name = my_strndup(fname.ptr, fname.len);
732 }
Christopher Fauletbc96c902019-12-02 10:33:31 +0100733 else { /* FCGI_RULE_PASS_HDR/FCGI_RULE_HIDE_HDR */
734 struct ist fname = ist2bin_lc(trash.area, ist(name));
735 rule->name = my_strndup(fname.ptr, fname.len);
736 }
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200737 if (!rule->name)
738 goto err;
739
740 if (value) {
741 rule->value = strdup(value);
742 if (!rule->value)
743 goto err;
744 }
745 rule->cond = cond;
Willy Tarreau2b718102021-04-21 07:32:39 +0200746 LIST_APPEND(&curapp->conf.rules, &rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200747 return 1;
748
749 err:
750 if (rule) {
751 free(rule->name);
752 free(rule->value);
753 free(rule);
754 }
755 if (cond) {
756 prune_acl_cond(cond);
757 free(cond);
758 }
759 memprintf(err, "out of memory");
760 return 0;
761}
762
763/* Parses "fcgi-app" section */
764static int cfg_parse_fcgi_app(const char *file, int linenum, char **args, int kwm)
765{
766 static struct fcgi_app *curapp = NULL;
767 struct acl_cond *cond = NULL;
768 char *name, *value = NULL;
769 enum fcgi_rule_type type;
770 int err_code = 0;
771 const char *err;
772 char *errmsg = NULL;
773
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100774 if (strcmp(args[0], "fcgi-app") == 0) { /* new fcgi-app */
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200775 if (!*(args[1])) {
776 ha_alert("parsing [%s:%d]: '%s' expects <name> as argument.\n",
777 file, linenum, args[0]);
778 err_code |= ERR_ALERT | ERR_FATAL;
779 goto out;
780 }
781 if (alertif_too_many_args(1, file, linenum, args, &err_code))
782 goto out;
783
784 err = invalid_char(args[1]);
785 if (err) {
786 ha_alert("parsing [%s:%d]: character '%c' is not permitted in '%s' name '%s'.\n",
787 file, linenum, *err, args[0], args[1]);
788 err_code |= ERR_ALERT | ERR_FATAL;
789 goto out;
790 }
791
792 for (curapp = fcgi_apps; curapp != NULL; curapp = curapp->next) {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100793 if (strcmp(curapp->name, args[1]) == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200794 ha_alert("Parsing [%s:%d]: fcgi-app section '%s' has the same name as another one declared at %s:%d.\n",
795 file, linenum, args[1], curapp->conf.file, curapp->conf.line);
796 err_code |= ERR_ALERT | ERR_FATAL;
797 }
798 }
799
800 curapp = calloc(1, sizeof(*curapp));
801 if (!curapp) {
802 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
803 err_code |= ERR_ALERT | ERR_ABORT;
804 goto out;
805 }
806
807 curapp->next = fcgi_apps;
808 fcgi_apps = curapp;
809 curapp->flags = FCGI_APP_FL_KEEP_CONN;
810 curapp->docroot = ist(NULL);
811 curapp->index = ist(NULL);
812 curapp->pathinfo_re = NULL;
813 curapp->name = strdup(args[1]);
814 curapp->maxreqs = 1;
815 curapp->conf.file = strdup(file);
816 curapp->conf.line = linenum;
817 LIST_INIT(&curapp->acls);
818 LIST_INIT(&curapp->logsrvs);
819 LIST_INIT(&curapp->conf.args.list);
820 LIST_INIT(&curapp->conf.rules);
821
822 /* Set info about authentication */
823 if (!fcgi_app_add_rule(curapp, FCGI_RULE_SET_PARAM, "REMOTE_USER", "%[http_auth_user]", NULL, &errmsg) ||
824 !fcgi_app_add_rule(curapp, FCGI_RULE_SET_PARAM, "AUTH_TYPE", "%[http_auth_type]", NULL, &errmsg)) {
825 ha_alert("parsing [%s:%d] : '%s' : %s.\n", file, linenum,
826 args[1], errmsg);
827 err_code |= ERR_ALERT | ERR_FATAL;
828 }
829
830 /* Hide hop-by-hop headers by default */
831 if (!fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "connection", NULL, NULL, &errmsg) ||
832 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "keep-alive", NULL, NULL, &errmsg) ||
833 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "authorization", NULL, NULL, &errmsg) ||
834 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "proxy", NULL, NULL, &errmsg) ||
835 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "proxy-authorization", NULL, NULL, &errmsg) ||
836 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "proxy-authenticate", NULL, NULL, &errmsg) ||
837 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "te", NULL, NULL, &errmsg) ||
838 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "trailers", NULL, NULL, &errmsg) ||
839 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "transfer-encoding", NULL, NULL, &errmsg) ||
840 !fcgi_app_add_rule(curapp, FCGI_RULE_HIDE_HDR, "upgrade", NULL, NULL, &errmsg)) {
841 ha_alert("parsing [%s:%d] : '%s' : %s.\n", file, linenum,
842 args[1], errmsg);
843 err_code |= ERR_ALERT | ERR_FATAL;
844 }
845 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100846 else if (strcmp(args[0], "docroot") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200847 if (!*(args[1])) {
848 ha_alert("parsing [%s:%d] : '%s' expects <path> as argument.\n",
849 file, linenum, args[0]);
850 err_code |= ERR_ALERT | ERR_FATAL;
851 goto out;
852 }
853 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
854 goto out;
Tim Duesterhused526372020-03-05 17:56:33 +0100855 istfree(&curapp->docroot);
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100856 curapp->docroot = ist(strdup(args[1]));
Tim Duesterhused526372020-03-05 17:56:33 +0100857 if (!isttest(curapp->docroot)) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200858 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
859 err_code |= ERR_ALERT | ERR_ABORT;
860 }
861 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100862 else if (strcmp(args[0], "path-info") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200863 if (!*(args[1])) {
864 ha_alert("parsing [%s:%d] : '%s' expects <regex> as argument.\n",
865 file, linenum, args[0]);
866 err_code |= ERR_ALERT | ERR_FATAL;
867 goto out;
868 }
869 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
870 goto out;
871 regex_free(curapp->pathinfo_re);
872 curapp->pathinfo_re = regex_comp(args[1], 1, 1, &errmsg);
873 if (!curapp->pathinfo_re) {
874 ha_alert("parsing [%s:%d] : '%s' : %s.\n", file, linenum,
875 args[1], errmsg);
876 err_code |= ERR_ALERT | ERR_FATAL;
877 }
878 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100879 else if (strcmp(args[0], "index") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200880 if (!*(args[1])) {
881 ha_alert("parsing [%s:%d] : '%s' expects <filename> as argument.\n",
882 file, linenum, args[0]);
883 err_code |= ERR_ALERT | ERR_FATAL;
884 goto out;
885 }
886 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
887 goto out;
Tim Duesterhused526372020-03-05 17:56:33 +0100888 istfree(&curapp->index);
Tim Duesterhusdcf753a2021-03-04 17:31:47 +0100889 curapp->index = ist(strdup(args[1]));
Tim Duesterhused526372020-03-05 17:56:33 +0100890 if (!isttest(curapp->index)) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200891 ha_alert("parsing [%s:%d] : out of memory.\n", file, linenum);
892 err_code |= ERR_ALERT | ERR_ABORT;
893 }
894 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100895 else if (strcmp(args[0], "acl") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200896 const char *err;
897 err = invalid_char(args[1]);
898 if (err) {
899 ha_alert("parsing [%s:%d] : character '%c' is not permitted in acl name '%s'.\n",
900 file, linenum, *err, args[1]);
901 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus0cf811a2020-02-05 21:00:50 +0100902 goto out;
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200903 }
Tim Duesterhus0cf811a2020-02-05 21:00:50 +0100904 if (strcasecmp(args[1], "or") == 0) {
Tim Duesterhusf1bc24c2020-02-06 22:04:03 +0100905 ha_alert("parsing [%s:%d] : acl name '%s' will never match. 'or' is used to express a "
Tim Duesterhus0cf811a2020-02-05 21:00:50 +0100906 "logical disjunction within a condition.\n",
907 file, linenum, args[1]);
908 err_code |= ERR_ALERT | ERR_FATAL;
909 goto out;
910 }
911 if (parse_acl((const char **)args+1, &curapp->acls, &errmsg, &curapp->conf.args, file, linenum) == NULL) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200912 ha_alert("parsing [%s:%d] : error detected while parsing ACL '%s' : %s.\n",
913 file, linenum, args[1], errmsg);
914 err_code |= ERR_ALERT | ERR_FATAL;
Tim Duesterhus0cf811a2020-02-05 21:00:50 +0100915 goto out;
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200916 }
917 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100918 else if (strcmp(args[0], "set-param") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200919 if (!*(args[1]) || !*(args[2])) {
920 ha_alert("parsing [%s:%d] : '%s' expects <name> and <value> as arguments.\n",
921 file, linenum, args[0]);
922 err_code |= ERR_ALERT | ERR_FATAL;
923 goto out;
924 }
925 type = FCGI_RULE_SET_PARAM;
926 name = args[1];
927 value = args[2];
928 cond = NULL;
929 args += 3;
930
931 parse_cond_rule:
932 if (!*(args[0])) /* No condition */
933 goto add_rule;
934
935 if (strcmp(args[0], "if") == 0)
936 cond = parse_acl_cond((const char **)args+1, &curapp->acls, ACL_COND_IF, &errmsg, &curapp->conf.args,
937 file, linenum);
938 else if (strcmp(args[0], "unless") == 0)
939 cond = parse_acl_cond((const char **)args+1, &curapp->acls, ACL_COND_UNLESS, &errmsg, &curapp->conf.args,
940 file, linenum);
941 if (!cond) {
942 ha_alert("parsing [%s:%d] : '%s' : %s.\n", file, linenum,
943 name, errmsg);
944 err_code |= ERR_ALERT | ERR_FATAL;
945 }
946 add_rule:
947 if (!fcgi_app_add_rule(curapp, type, name, value, cond, &errmsg)) {
948 ha_alert("parsing [%s:%d] : '%s' : %s.\n", file, linenum,
949 name, errmsg);
950 err_code |= ERR_ALERT | ERR_FATAL;
951 }
952 }
953#if 0 /* Disabled for now */
954 else if (!strcmp(args[0], "unset-param")) {
955 if (!*(args[1])) {
956 ha_alert("parsing [%s:%d] : '%s' expects <name> as arguments.\n",
957 file, linenum, args[0]);
958 err_code |= ERR_ALERT | ERR_FATAL;
959 goto out;
960 }
961 type = FCGI_RULE_UNSET_PARAM;
962 name = args[1];
963 value = NULL;
964 cond = NULL;
965 args += 2;
966 goto parse_cond_rule;
967 }
968#endif
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100969 else if (strcmp(args[0], "pass-header") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +0200970 if (!*(args[1])) {
971 ha_alert("parsing [%s:%d] : '%s' expects <name> as arguments.\n",
972 file, linenum, args[0]);
973 err_code |= ERR_ALERT | ERR_FATAL;
974 goto out;
975 }
976 type = FCGI_RULE_PASS_HDR;
977 name = args[1];
978 value = NULL;
979 cond = NULL;
980 args += 2;
981 goto parse_cond_rule;
982 }
983#if 0 /* Disabled for now */
984 else if (!strcmp(args[0], "hide-header")) {
985 if (!*(args[1])) {
986 ha_alert("parsing [%s:%d] : '%s' expects <name> as arguments.\n",
987 file, linenum, args[0]);
988 err_code |= ERR_ALERT | ERR_FATAL;
989 goto out;
990 }
991 type = FCGI_RULE_HIDE_HDR;
992 name = args[1];
993 value = NULL;
994 cond = NULL;
995 args += 2;
996 goto parse_cond_rule;
997 }
998#endif
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100999 else if (strcmp(args[0], "option") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001000 if (!*(args[1])) {
1001 ha_alert("parsing [%s:%d]: '%s' expects an option name.\n",
1002 file, linenum, args[0]);
1003 err_code |= ERR_ALERT | ERR_FATAL;
1004 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001005 else if (strcmp(args[1], "keep-conn") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001006 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
1007 goto out;
1008 if (kwm == KWM_STD)
1009 curapp->flags |= FCGI_APP_FL_KEEP_CONN;
1010 else if (kwm == KWM_NO)
1011 curapp->flags &= ~FCGI_APP_FL_KEEP_CONN;
1012 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001013 else if (strcmp(args[1], "get-values") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001014 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
1015 goto out;
1016 if (kwm == KWM_STD)
1017 curapp->flags |= FCGI_APP_FL_GET_VALUES;
1018 else if (kwm == KWM_NO)
1019 curapp->flags &= ~FCGI_APP_FL_GET_VALUES;
1020 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001021 else if (strcmp(args[1], "mpxs-conns") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001022 if (alertif_too_many_args_idx(0, 1, file, linenum, args, &err_code))
1023 goto out;
1024 if (kwm == KWM_STD)
1025 curapp->flags |= FCGI_APP_FL_MPXS_CONNS;
1026 else if (kwm == KWM_NO)
1027 curapp->flags &= ~FCGI_APP_FL_MPXS_CONNS;
1028 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001029 else if (strcmp(args[1], "max-reqs") == 0) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001030 if (kwm != KWM_STD) {
1031 ha_alert("parsing [%s:%d]: negation/default is not supported for option '%s'.\n",
1032 file, linenum, args[1]);
1033 err_code |= ERR_ALERT | ERR_FATAL;
1034 goto out;
1035 }
1036 if (!*(args[2])) {
1037 ha_alert("parsing [%s:%d]: option '%s' expects an integer argument.\n",
1038 file, linenum, args[1]);
1039 err_code |= ERR_ALERT | ERR_FATAL;
1040 goto out;
1041 }
1042 if (alertif_too_many_args_idx(1, 1, file, linenum, args, &err_code))
1043 goto out;
1044
1045 curapp->maxreqs = atol(args[2]);
1046 if (!curapp->maxreqs) {
1047 ha_alert("parsing [%s:%d]: option '%s' expects a strictly positive integer argument.\n",
1048 file, linenum, args[1]);
1049 err_code |= ERR_ALERT | ERR_FATAL;
1050 goto out;
1051 }
1052 }
1053 else {
1054 ha_alert("parsing [%s:%d] : unknown option '%s'.\n", file, linenum, args[1]);
1055 err_code |= ERR_ALERT | ERR_FATAL;
1056 }
1057 }
Tim Duesterhuse5ff1412021-01-02 22:31:53 +01001058 else if (strcmp(args[0], "log-stderr") == 0) {
Emeric Brun9533a702021-04-02 10:13:43 +02001059 if (!parse_logsrv(args, &curapp->logsrvs, (kwm == KWM_NO), file, linenum, &errmsg)) {
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001060 ha_alert("parsing [%s:%d] : %s : %s\n", file, linenum, args[0], errmsg);
1061 err_code |= ERR_ALERT | ERR_FATAL;
1062 }
1063 }
1064 else {
1065 ha_alert("parsing [%s:%d]: unknown keyword '%s' in '%s' section\n", file, linenum, args[0], "fcgi-app");
1066 err_code |= ERR_ALERT | ERR_FATAL;
1067 }
1068
1069out:
1070 free(errmsg);
1071 return err_code;
1072}
1073
1074
1075/**************************************************************************/
1076/*********************** FCGI Deinit functions ****************************/
1077/**************************************************************************/
1078void fcgi_apps_deinit()
1079{
1080 struct fcgi_app *curapp, *nextapp;
1081 struct logsrv *log, *logb;
1082
1083 for (curapp = fcgi_apps; curapp != NULL; curapp = nextapp) {
1084 struct fcgi_rule_conf *rule, *back;
1085
1086 free(curapp->name);
Tim Duesterhused526372020-03-05 17:56:33 +01001087 istfree(&curapp->docroot);
1088 istfree(&curapp->index);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001089 regex_free(curapp->pathinfo_re);
1090 free(curapp->conf.file);
1091
1092 list_for_each_entry_safe(log, logb, &curapp->logsrvs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001093 LIST_DELETE(&log->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001094 free(log);
1095 }
1096
1097 list_for_each_entry_safe(rule, back, &curapp->conf.rules, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02001098 LIST_DELETE(&rule->list);
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001099 fcgi_release_rule_conf(rule);
1100 }
1101
1102 nextapp = curapp->next;
1103 free(curapp);
1104 }
1105}
1106
1107
1108/**************************************************************************/
1109/*************** Keywords definition and registration *********************/
1110/**************************************************************************/
1111static struct cfg_kw_list cfg_kws = {ILH, {
1112 { CFG_LISTEN, "use-fcgi-app", proxy_parse_use_fcgi_app },
1113 { 0, NULL, NULL },
1114}};
1115
1116// FIXME: Add rep.fcgi smp_fetch
1117static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
1118 { "fcgi.docroot", smp_fetch_fcgi_docroot, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
Willy Tarreaufc41e252019-09-27 22:45:17 +02001119 { "fcgi.index", smp_fetch_fcgi_index, 0, NULL, SMP_T_STR, SMP_USE_HRQHV },
1120 { /* END */ }
Christopher Faulet78fbb9f2019-08-11 23:11:03 +02001121}};
1122
1123/* Declare the filter parser for "fcgi-app" keyword */
1124static struct flt_kw_list filter_kws = { "FCGI", { }, {
1125 { "fcgi-app", parse_fcgi_flt, NULL },
1126 { NULL, NULL, NULL },
1127 }
1128};
1129
1130INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
1131INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1132INITCALL1(STG_REGISTER, flt_register_keywords, &filter_kws);
1133
1134INITCALL1(STG_REGISTER, hap_register_post_deinit, fcgi_apps_deinit);
1135
1136REGISTER_CONFIG_SECTION("fcgi-app", cfg_parse_fcgi_app, NULL);
1137REGISTER_CONFIG_POSTPARSER("fcgi-apps", cfg_fcgi_apps_postparser);
1138
1139/*
1140 * Local variables:
1141 * c-indent-level: 8
1142 * c-basic-offset: 8
1143 * End:
1144 */