1
2 #include "httpd.h"
3 #include "httpd_policy.h"
4
5 #define EX_UTILS_NO_FUNCS 1
6 #include "ex_utils.h"
7
8 #include "mk.h"
9
httpd__policy_path_ref_free(Vstr_ref * ref)10 static void httpd__policy_path_ref_free(Vstr_ref *ref)
11 {
12 Httpd_policy_path *path = NULL;
13
14 if (!ref)
15 return;
16
17 path = ref->ptr;
18 vstr_free_base(path->s1);
19 (*path->ref_func)(ref);
20 }
21
httpd__policy_path_init(Httpd_policy_path * path,Vstr_base * s1,size_t pos,size_t len,Vstr_ref * ref)22 static int httpd__policy_path_init(Httpd_policy_path *path,
23 Vstr_base *s1, size_t pos, size_t len,
24 Vstr_ref *ref)
25 {
26 size_t tmp = 0;
27
28 ASSERT(ref->ref == 1);
29
30 if (!(s1 = vstr_dup_vstr(s1->conf, s1, pos, len, 0)))
31 return (FALSE);
32 path->s1 = s1;
33
34 /* remove any double slashes... */
35 while ((tmp = vstr_srch_cstr_buf_fwd(s1, 1, s1->len, "//")))
36 if (!vstr_del(s1, tmp, 1))
37 {
38 vstr_free_base(s1);
39 return (FALSE);
40 }
41
42 path->ref_func = ref->func;
43
44 ref->func = httpd__policy_path_ref_free;
45
46 return (TRUE);
47 }
48
httpd_policy__build_parent_path(Vstr_base * s1,Vstr_base * s2)49 static int httpd_policy__build_parent_path(Vstr_base *s1, Vstr_base *s2)
50 {
51 size_t pos = 0;
52 size_t len = 0;
53
54 ASSERT(s1 && s2);
55
56 if (!s2->len)
57 return (TRUE);
58
59 if (s2->len == 1)
60 {
61 ASSERT(vstr_cmp_cstr_eq(s2, 1, s2->len, "/"));
62 vstr_add_cstr_ptr(s1, s1->len, "/");
63 return (TRUE);
64 }
65
66 if (!(pos = vstr_srch_chr_rev(s2, 1, s2->len - 1, '/')))
67 {
68 vstr_add_cstr_ptr(s1, s1->len, "./");
69 return (TRUE);
70 }
71
72 len = vstr_sc_posdiff(1, pos);
73 HTTPD_APP_REF_VSTR(s1, s2, 1, len);
74
75 return (TRUE);
76 }
77
78 /* builds into conf->tmp */
httpd_policy_build_path(struct Con * con,Httpd_req_data * req,const Conf_parse * conf,Conf_token * token,int * used_policy,int * used_req)79 int httpd_policy_build_path(struct Con *con, Httpd_req_data *req,
80 const Conf_parse *conf, Conf_token *token,
81 int *used_policy, int *used_req)
82 {
83 unsigned int cur_depth = token->depth_num;
84 int dummy_used_policy;
85 int dummy_used_req;
86
87 if (!used_policy) used_policy = &dummy_used_policy;
88 if (!used_req) used_req = &dummy_used_req;
89 *used_policy = *used_req = FALSE;
90
91 vstr_del(conf->tmp, 1, conf->tmp->len);
92 while (conf_token_list_num(token, cur_depth))
93 {
94 CONF_SC_PARSE_TOP_TOKEN_RET(conf, token, FALSE);
95
96 if (0) { }
97
98 else if (OPT_SERV_SYM_EQ("<basename>"))
99 {
100 size_t pos = 1;
101 size_t len = req->fname->len;
102
103 *used_req = TRUE;
104 httpd_policy_path_mod_name(req->fname, &pos, &len);
105 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
106 }
107 else if (OPT_SERV_SYM_EQ("<url-basename>"))
108 {
109 size_t pos = req->path_pos;
110 size_t len = req->path_len;
111
112 *used_req = TRUE;
113 httpd_policy_path_mod_name(con->evnt->io_r, &pos, &len);
114 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
115 }
116 else if (OPT_SERV_SYM_EQ("<basename-without-extension>"))
117 {
118 size_t pos = 1;
119 size_t len = req->fname->len;
120
121 *used_req = TRUE;
122 httpd_policy_path_mod_bwen(req->fname, &pos, &len);
123 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
124 }
125 else if (OPT_SERV_SYM_EQ("<url-basename-without-extension>"))
126 {
127 size_t pos = req->path_pos;
128 size_t len = req->path_len;
129
130 *used_req = TRUE;
131 httpd_policy_path_mod_bwen(con->evnt->io_r, &pos, &len);
132 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
133 }
134 else if (OPT_SERV_SYM_EQ("<basename-without-extensions>"))
135 {
136 size_t pos = 1;
137 size_t len = req->fname->len;
138
139 *used_req = TRUE;
140 httpd_policy_path_mod_bwes(req->fname, &pos, &len);
141 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
142 }
143 else if (OPT_SERV_SYM_EQ("<url-basename-without-extensions>"))
144 {
145 size_t pos = req->path_pos;
146 size_t len = req->path_len;
147
148 *used_req = TRUE;
149 httpd_policy_path_mod_bwes(con->evnt->io_r, &pos, &len);
150 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
151 }
152 else if (OPT_SERV_SYM_EQ("<directory-filename>"))
153 {
154 Vstr_base *s1 = req->policy->dir_filename;
155 *used_policy = TRUE;
156 HTTPD_APP_REF_ALLVSTR(conf->tmp, s1);
157 }
158 else if (OPT_SERV_SYM_EQ("<dirname>"))
159 {
160 size_t pos = 1;
161 size_t len = req->fname->len;
162
163 *used_req = TRUE;
164 httpd_policy_path_mod_dirn(req->fname, &pos, &len);
165 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
166 }
167 else if (OPT_SERV_SYM_EQ("<url-dirname>"))
168 {
169 size_t pos = req->path_pos;
170 size_t len = req->path_len;
171
172 *used_req = TRUE;
173 httpd_policy_path_mod_dirn(con->evnt->io_r, &pos, &len);
174 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
175 }
176 else if (OPT_SERV_SYM_EQ("<document-root>") ||
177 OPT_SERV_SYM_EQ("<doc-root>"))
178 {
179 Vstr_base *s1 = req->policy->document_root;
180 *used_policy = TRUE;
181 HTTPD_APP_REF_ALLVSTR(conf->tmp, s1);
182 }
183 else if (OPT_SERV_SYM_EQ("<document-root/..>") ||
184 OPT_SERV_SYM_EQ("<doc-root/..>"))
185 {
186 ASSERT(req->policy->document_root->len);
187 if (!httpd_policy__build_parent_path(conf->tmp,
188 req->policy->document_root))
189 return (FALSE);
190 *used_policy = TRUE;
191 }
192 else if (OPT_SERV_SYM_EQ("<extension>"))
193 {
194 size_t pos = 1;
195 size_t len = req->fname->len;
196
197 *used_req = TRUE;
198 httpd_policy_path_mod_extn(req->fname, &pos, &len);
199 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
200 }
201 else if (OPT_SERV_SYM_EQ("<url-extension>"))
202 {
203 size_t pos = req->path_pos;
204 size_t len = req->path_len;
205
206 *used_req = TRUE;
207 httpd_policy_path_mod_extn(con->evnt->io_r, &pos, &len);
208 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
209 }
210 else if (OPT_SERV_SYM_EQ("<extensions>"))
211 {
212 size_t pos = 1;
213 size_t len = req->fname->len;
214
215 *used_req = TRUE;
216 httpd_policy_path_mod_exts(req->fname, &pos, &len);
217 HTTPD_APP_REF_VSTR(conf->tmp, req->fname, pos, len);
218 }
219 else if (OPT_SERV_SYM_EQ("<url-extensions>"))
220 {
221 size_t pos = req->path_pos;
222 size_t len = req->path_len;
223
224 *used_req = TRUE;
225 httpd_policy_path_mod_exts(con->evnt->io_r, &pos, &len);
226 HTTPD_APP_REF_VSTR(conf->tmp, con->evnt->io_r, pos, len);
227 }
228 else if (OPT_SERV_SYM_EQ("<hostname>"))
229 {
230 Vstr_base *http_data = con->evnt->io_r;
231 Vstr_sect_node *h_h = req->http_hdrs->hdr_host;
232
233 *used_req = TRUE;
234 if (h_h->len)
235 HTTPD_APP_REF_VSTR(conf->tmp, http_data, h_h->pos, h_h->len);
236 else
237 httpd_sc_add_default_hostname(con, req, conf->tmp, conf->tmp->len);
238 }
239 else if (OPT_SERV_SYM_EQ("<request-configuration-directory>") ||
240 OPT_SERV_SYM_EQ("<req-conf-dir>"))
241 {
242 Vstr_base *s1 = req->policy->req_conf_dir;
243 *used_policy = TRUE;
244 HTTPD_APP_REF_ALLVSTR(conf->tmp, s1);
245 }
246 else if (OPT_SERV_SYM_EQ("<request-configuration-directory/..>") ||
247 OPT_SERV_SYM_EQ("<req-conf-dir/..>"))
248 {
249 if (!httpd_policy__build_parent_path(conf->tmp,
250 req->policy->req_conf_dir))
251 return (FALSE);
252 *used_policy = TRUE;
253 }
254 else if (OPT_SERV_SYM_EQ("<request-error-directory>") ||
255 OPT_SERV_SYM_EQ("<req-err-dir>"))
256 {
257 Vstr_base *s1 = req->policy->req_err_dir;
258 *used_policy = TRUE;
259 HTTPD_APP_REF_ALLVSTR(conf->tmp, s1);
260 }
261 else if (OPT_SERV_SYM_EQ("<request-error-directory/..>") ||
262 OPT_SERV_SYM_EQ("<req-err-dir/..>"))
263 {
264 if (!httpd_policy__build_parent_path(conf->tmp, req->policy->req_err_dir))
265 return (FALSE);
266 *used_policy = TRUE;
267 }
268 else if (OPT_SERV_SYM_EQ("<file-path>") || OPT_SERV_SYM_EQ("<path>"))
269 {
270 *used_req = TRUE;
271 HTTPD_APP_REF_ALLVSTR(conf->tmp, req->fname);
272 }
273 else if (OPT_SERV_SYM_EQ("<url-path>"))
274 {
275 *used_req = TRUE;
276 HTTPD_APP_REF_VSTR(conf->tmp,
277 con->evnt->io_r, req->path_pos, req->path_len);
278 }
279 else if (OPT_SERV_SYM_EQ("<content-type-extension>") ||
280 OPT_SERV_SYM_EQ("<content-type-path>"))
281 {
282 const Vstr_base *s1 = req->ext_vary_a_vs1;
283 size_t pos = req->ext_vary_a_pos;
284 size_t len = req->ext_vary_a_len;
285
286 *used_req = TRUE;
287 if (s1 && len)
288 HTTPD_APP_REF_VSTR(conf->tmp, s1, pos, len);
289 }
290 else if (OPT_SERV_SYM_EQ("<content-language-extension>") ||
291 OPT_SERV_SYM_EQ("<content-language-path>"))
292 {
293 const Vstr_base *s1 = req->ext_vary_al_vs1;
294 size_t pos = req->ext_vary_al_pos;
295 size_t len = req->ext_vary_al_len;
296
297 *used_req = TRUE;
298 if (s1 && len)
299 HTTPD_APP_REF_VSTR(conf->tmp, s1, pos, len);
300 }
301 else
302 { /* unknown symbol or string */
303 size_t pos = conf->tmp->len + 1;
304 const Vstr_sect_node *pv = conf_token_value(token);
305
306 if (!pv || !HTTPD_APP_REF_VSTR(conf->tmp, conf->data, pv->pos, pv->len))
307 return (FALSE);
308
309 OPT_SERV_X__ESC_VSTR(conf->tmp, pos, pv->len);
310 }
311 }
312
313 /* we "didn't use the policy" if we only have one policy */
314 if (!con->policy->s->beg->def_policy->next)
315 *used_policy = FALSE;
316 /* FIXME: if we are in here inside a group with a test for policy-eq
317 * then we can act like we didn't use the policy.
318 */
319
320 return (TRUE);
321 }
322
httpd_policy_path_make(struct Con * con,Httpd_req_data * req,Conf_parse * conf,Conf_token * token,unsigned int type,Vstr_ref ** ret_ref)323 int httpd_policy_path_make(struct Con *con, Httpd_req_data *req,
324 Conf_parse *conf, Conf_token *token,
325 unsigned int type, Vstr_ref **ret_ref)
326 {
327 Conf_token save = *token;
328 Vstr_ref *ref = NULL;
329 int ret = FALSE;
330 int used_pol = FALSE;
331 int used_req = FALSE;
332 int clist = FALSE;
333
334 ASSERT(ret_ref);
335 *ret_ref = NULL;
336
337 CONF_SC_PARSE_TOP_TOKEN_RET(conf, token, FALSE);
338 CONF_SC_TOGGLE_CLIST_VAR(clist);
339
340 if (OPT_SERV_SYM_EQ("assign") || OPT_SERV_SYM_EQ("="))
341 {
342 if (!httpd_policy_build_path(con, req, conf, token, &used_pol, &used_req))
343 return (FALSE);
344 }
345 else if (clist)
346 return (FALSE);
347 else
348 {
349 const Vstr_sect_node *pv = conf_token_value(token);
350 Vstr_base *s1 = conf->tmp;
351 if (!pv || !vstr_sub_vstr(s1, 1, s1->len, conf->data, pv->pos, pv->len,
352 VSTR_TYPE_SUB_BUF_REF))
353 return (FALSE);
354 OPT_SERV_X__ESC_VSTR(s1, 1, pv->len);
355 }
356
357 if (!(ref = vstr_ref_make_malloc(sizeof(Httpd_policy_path))))
358 return (FALSE);
359
360 ret = httpd__policy_path_init(ref->ptr, conf->tmp, 1, conf->tmp->len, ref);
361 if (ret && !(used_pol || used_req))
362 ret = conf_token_set_user_value(conf, &save, type, ref, token->num);
363
364 if (ret)
365 *ret_ref = ref;
366
367 return (ret);
368 }
369
httpd_policy_exit(Httpd_policy_opts * opts)370 void httpd_policy_exit(Httpd_policy_opts *opts)
371 {
372 ASSERT(opts);
373
374 vstr_free_base(opts->document_root); opts->document_root = NULL;
375 vstr_free_base(opts->server_name); opts->server_name = NULL;
376 vstr_free_base(opts->dir_filename); opts->dir_filename = NULL;
377 vstr_free_base(opts->mime_types_def_ct); opts->mime_types_def_ct = NULL;
378 vstr_free_base(opts->mime_types_main); opts->mime_types_main = NULL;
379 vstr_free_base(opts->mime_types_xtra); opts->mime_types_xtra = NULL;
380 vstr_free_base(opts->default_hostname); opts->default_hostname = NULL;
381 vstr_free_base(opts->req_conf_dir); opts->req_conf_dir = NULL;
382 vstr_free_base(opts->req_err_dir); opts->req_err_dir = NULL;
383 vstr_free_base(opts->auth_realm); opts->auth_realm = NULL;
384 vstr_free_base(opts->auth_token); opts->auth_token = NULL;
385
386 opt_policy_exit(opts->s);
387 }
388
httpd_policy_init(Httpd_opts * beg,Httpd_policy_opts * opts)389 int httpd_policy_init(Httpd_opts *beg, Httpd_policy_opts *opts)
390 {
391 if (!opt_policy_init(beg->s, opts->s))
392 return (FALSE);
393
394 ASSERT(opts->s->beg == beg->s);
395
396 /* do all, then check ... so we don't have to unwind */
397 opts->document_root = vstr_make_base(NULL);
398 opts->server_name = vstr_make_base(NULL);
399 opts->dir_filename = vstr_make_base(NULL);
400 opts->mime_types_def_ct = vstr_make_base(NULL);
401 opts->mime_types_main = vstr_make_base(NULL);
402 opts->mime_types_xtra = vstr_make_base(NULL);
403 opts->default_hostname = vstr_make_base(NULL);
404 opts->req_conf_dir = vstr_make_base(NULL);
405 opts->req_err_dir = vstr_make_base(NULL);
406 opts->auth_realm = vstr_make_base(NULL);
407 opts->auth_token = vstr_make_base(NULL);
408
409 if (!opts->document_root ||
410 !opts->server_name ||
411 !opts->dir_filename ||
412 !opts->mime_types_def_ct ||
413 !opts->mime_types_main ||
414 !opts->mime_types_xtra ||
415 !opts->default_hostname ||
416 !opts->req_conf_dir ||
417 !opts->req_err_dir ||
418 !opts->auth_realm ||
419 !opts->auth_token ||
420 FALSE)
421 {
422 httpd_policy_exit(opts);
423 return (FALSE);
424 }
425
426 opts->mime_types->ref = NULL;
427 opts->mime_types->def_type_vs1 = NULL;
428 opts->mime_types->def_type_pos = 0;
429 opts->mime_types->def_type_len = 0;
430
431 opts->use_mmap = HTTPD_CONF_USE_MMAP;
432 opts->use_sendfile = HTTPD_CONF_USE_SENDFILE;
433 opts->use_keep_alive = HTTPD_CONF_USE_KEEPA;
434 opts->use_keep_alive_1_0 = HTTPD_CONF_USE_KEEPA_1_0;
435 opts->use_vhosts_name = HTTPD_CONF_USE_VHOSTS_NAME;
436 opts->use_range = HTTPD_CONF_USE_RANGE;
437 opts->use_range_1_0 = HTTPD_CONF_USE_RANGE_1_0;
438 opts->use_public_only = HTTPD_CONF_USE_PUBLIC_ONLY; /* 8th bitfield */
439 opts->use_enc_content_replacement = HTTPD_CONF_USE_ENC_CONTENT_REPLACEMENT;
440
441 opts->use_err_406 = HTTPD_CONF_USE_ERR_406;
442 opts->use_canonize_host = HTTPD_CONF_USE_CANONIZE_HOST;
443 opts->use_host_err_400 = HTTPD_CONF_USE_HOST_ERR_400;
444 opts->use_host_err_chk = HTTPD_CONF_USE_HOST_ERR_CHK;
445 opts->use_x2_hdr_chk = HTTPD_CONF_USE_x2_HDR_CHK;
446 opts->use_trace_op = HTTPD_CONF_USE_TRACE_OP;
447 opts->remove_url_frag = HTTPD_CONF_USE_REMOVE_FRAG;
448 opts->remove_url_query = HTTPD_CONF_USE_REMOVE_QUERY;
449 opts->use_secure_dirs = HTTPD_CONF_USE_SECURE_DIRS;
450 opts->use_friendly_dirs = HTTPD_CONF_USE_FRIENDLY_DIRS;
451
452 opts->use_posix_fadvise = HTTPD_CONF_USE_POSIX_FADVISE;
453 opts->use_tcp_cork = HTTPD_CONF_USE_TCP_CORK;
454
455 opts->use_req_conf = HTTPD_CONF_USE_REQ_CONF;
456 opts->allow_hdr_split = HTTPD_CONF_USE_ALLOW_HDR_SPLIT; /* 16th bitfield */
457 opts->allow_hdr_nil = HTTPD_CONF_USE_ALLOW_HDR_NIL;
458
459 opts->chk_dot_dir = HTTPD_CONF_USE_CHK_DOT_DIR;
460
461 opts->chk_encoded_slash = HTTPD_CONF_USE_CHK_ENCODED_SLASH;
462 opts->chk_encoded_dot = HTTPD_CONF_USE_CHK_ENCODED_DOT;
463
464 opts->add_def_port = HTTPD_CONF_ADD_DEF_PORT;
465
466 opts->use_non_spc_hdrs = HTTPD_CONF_USE_NON_SPC_HDRS; /* 22nd bitfield */
467
468 opts->max_header_sz = HTTPD_CONF_INPUT_MAXSZ;
469
470 opts->max_requests = HTTPD_CONF_MAX_REQUESTS;
471
472 opts->max_neg_A_nodes = HTTPD_CONF_MAX_NEG_A_NODES;
473 opts->max_neg_AL_nodes = HTTPD_CONF_MAX_NEG_AL_NODES;
474
475 opts->max_A_nodes = HTTPD_CONF_MAX_A_NODES;
476 opts->max_AC_nodes = HTTPD_CONF_MAX_AC_NODES;
477 opts->max_AE_nodes = HTTPD_CONF_MAX_AE_NODES;
478 opts->max_AL_nodes = HTTPD_CONF_MAX_AL_NODES;
479
480 opts->max_connection_nodes = HTTPD_CONF_MAX_CONNECTION_NODES;
481 opts->max_etag_nodes = HTTPD_CONF_MAX_ETAG_NODES;
482
483 opts->max_range_nodes = HTTPD_CONF_MAX_RANGE_NODES;
484
485 opts->max_req_conf_sz = HTTPD_CONF_REQ_CONF_MAXSZ;
486
487 return (TRUE);
488 }
489
httpd_policy_free(Vstr_ref * ref)490 static void httpd_policy_free(Vstr_ref *ref)
491 {
492 Httpd_policy_opts *opts = NULL;
493
494 if (!ref)
495 return;
496
497 if ((opts = ref->ptr))
498 httpd_policy_exit(opts);
499 F(opts);
500 free(ref);
501 }
502
httpd_policy_make(Opt_serv_opts * beg)503 Opt_serv_policy_opts *httpd_policy_make(Opt_serv_opts *beg)
504 {
505 Opt_serv_policy_opts *opts = MK(sizeof(Httpd_policy_opts));
506 Vstr_ref *ref = NULL;
507
508 if (!opts)
509 goto mk_opts_fail;
510
511 if (!(ref = vstr_ref_make_ptr(opts, httpd_policy_free)))
512 goto mk_ref_fail;
513 opts->ref = ref;
514
515 if (!httpd_policy_init((Httpd_opts *)beg, (Httpd_policy_opts *)opts))
516 goto policy_init_fail;
517
518 return (opts);
519
520 policy_init_fail:
521 ref->ptr = NULL;
522 vstr_ref_del(ref);
523 mk_ref_fail:
524 F(opts);
525 mk_opts_fail:
526 return (NULL);
527 }
528
529 #define HTTPD_POLICY_CP_VSTR(x) \
530 vstr_sub_vstr(dst-> x , 1, dst-> x ->len, src-> x , 1, src-> x ->len, \
531 VSTR_TYPE_SUB_BUF_REF)
532 #define HTTPD_POLICY_CP_VAL(x) \
533 dst-> x = src-> x
534
httpd_policy_copy(Opt_serv_policy_opts * sdst,const Opt_serv_policy_opts * ssrc)535 int httpd_policy_copy(Opt_serv_policy_opts *sdst,
536 const Opt_serv_policy_opts *ssrc)
537 {
538 Httpd_policy_opts *dst = (Httpd_policy_opts *)sdst;
539 Httpd_policy_opts *src = (Httpd_policy_opts *)ssrc;
540
541 if (!opt_policy_copy(sdst, ssrc))
542 return (FALSE);
543
544 HTTPD_POLICY_CP_VSTR(document_root);
545 HTTPD_POLICY_CP_VSTR(server_name);
546 HTTPD_POLICY_CP_VSTR(dir_filename);
547
548 HTTPD_POLICY_CP_VSTR(mime_types_def_ct);
549 HTTPD_POLICY_CP_VSTR(mime_types_main);
550 HTTPD_POLICY_CP_VSTR(mime_types_xtra);
551 HTTPD_POLICY_CP_VSTR(default_hostname);
552 HTTPD_POLICY_CP_VSTR(req_conf_dir);
553 HTTPD_POLICY_CP_VSTR(req_err_dir);
554
555 HTTPD_POLICY_CP_VAL(use_mmap);
556 HTTPD_POLICY_CP_VAL(use_sendfile);
557 HTTPD_POLICY_CP_VAL(use_keep_alive);
558 HTTPD_POLICY_CP_VAL(use_keep_alive_1_0);
559 HTTPD_POLICY_CP_VAL(use_vhosts_name);
560 HTTPD_POLICY_CP_VAL(use_range);
561 HTTPD_POLICY_CP_VAL(use_range_1_0);
562 HTTPD_POLICY_CP_VAL(use_public_only);
563 HTTPD_POLICY_CP_VAL(use_enc_content_replacement);
564 HTTPD_POLICY_CP_VAL(use_err_406);
565 HTTPD_POLICY_CP_VAL(use_canonize_host);
566 HTTPD_POLICY_CP_VAL(use_host_err_400);
567 HTTPD_POLICY_CP_VAL(use_host_err_chk);
568 HTTPD_POLICY_CP_VAL(use_x2_hdr_chk);
569 HTTPD_POLICY_CP_VAL(use_trace_op);
570 HTTPD_POLICY_CP_VAL(remove_url_frag);
571 HTTPD_POLICY_CP_VAL(remove_url_query);
572 HTTPD_POLICY_CP_VAL(use_secure_dirs);
573 HTTPD_POLICY_CP_VAL(use_friendly_dirs);
574 HTTPD_POLICY_CP_VAL(use_posix_fadvise);
575 HTTPD_POLICY_CP_VAL(use_tcp_cork);
576 HTTPD_POLICY_CP_VAL(use_req_conf);
577 HTTPD_POLICY_CP_VAL(allow_hdr_split);
578 HTTPD_POLICY_CP_VAL(allow_hdr_nil);
579 HTTPD_POLICY_CP_VAL(chk_dot_dir);
580 HTTPD_POLICY_CP_VAL(chk_encoded_slash);
581 HTTPD_POLICY_CP_VAL(chk_encoded_dot);
582 HTTPD_POLICY_CP_VAL(add_def_port);
583
584 HTTPD_POLICY_CP_VAL(use_non_spc_hdrs);
585
586 HTTPD_POLICY_CP_VAL(max_header_sz);
587 HTTPD_POLICY_CP_VAL(max_requests);
588
589 HTTPD_POLICY_CP_VAL(max_neg_A_nodes);
590 HTTPD_POLICY_CP_VAL(max_neg_AL_nodes);
591
592 HTTPD_POLICY_CP_VAL(max_AC_nodes);
593 HTTPD_POLICY_CP_VAL(max_AE_nodes);
594 HTTPD_POLICY_CP_VAL(max_AL_nodes);
595
596 HTTPD_POLICY_CP_VAL(max_connection_nodes);
597 HTTPD_POLICY_CP_VAL(max_etag_nodes);
598
599 HTTPD_POLICY_CP_VAL(max_range_nodes);
600
601 HTTPD_POLICY_CP_VAL(max_req_conf_sz);
602
603 return (!dst->document_root->conf->malloc_bad);
604 }
605