diff options
Diffstat (limited to 'rubbos/app/httpd-2.0.64/modules/filters/mod_include.c')
| -rw-r--r-- | rubbos/app/httpd-2.0.64/modules/filters/mod_include.c | 3751 |
1 files changed, 3751 insertions, 0 deletions
diff --git a/rubbos/app/httpd-2.0.64/modules/filters/mod_include.c b/rubbos/app/httpd-2.0.64/modules/filters/mod_include.c new file mode 100644 index 00000000..38dc3213 --- /dev/null +++ b/rubbos/app/httpd-2.0.64/modules/filters/mod_include.c @@ -0,0 +1,3751 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * http_include.c: Handles the server-parsed HTML documents + * + * Original by Rob McCool; substantial fixups by David Robinson; + * incorporated into the Apache module framework by rst. + * + */ + +#include "apr.h" +#include "apr_strings.h" +#include "apr_thread_proc.h" +#include "apr_hash.h" +#include "apr_user.h" +#include "apr_lib.h" +#include "apr_optional.h" + +#define APR_WANT_STRFUNC +#define APR_WANT_MEMFUNC +#include "apr_want.h" + +#define CORE_PRIVATE + +#include "ap_config.h" +#include "util_filter.h" +#include "httpd.h" +#include "http_config.h" +#include "http_core.h" +#include "http_request.h" +#include "http_core.h" +#include "http_protocol.h" +#include "http_log.h" +#include "http_main.h" +#include "util_script.h" +#include "http_core.h" + +#define MOD_INCLUDE_REDESIGN +#include "mod_include.h" +#include "util_ebcdic.h" + +module AP_MODULE_DECLARE_DATA include_module; +static apr_hash_t *include_hash; +static APR_OPTIONAL_FN_TYPE(ap_register_include_handler) *ssi_pfn_register; + +/***************************************************************** + * + * XBITHACK. Sigh... NB it's configurable per-directory; the compile-time + * option only changes the default. + */ + +enum xbithack { + xbithack_off, xbithack_on, xbithack_full +}; + +struct bndm_t { + unsigned int T[256]; + unsigned int x; +} ; + +typedef struct { + char *default_error_msg; + char *default_time_fmt; + enum xbithack *xbithack; +} include_dir_config; + +typedef struct { + char *default_start_tag; + char *default_end_tag; + int start_tag_len; + bndm_t start_seq_pat; + char *undefinedEcho; + int undefinedEchoLen; +} include_server_config; + +/* main parser states */ +typedef enum { + PARSE_PRE_HEAD, + PARSE_HEAD, + PARSE_DIRECTIVE, + PARSE_DIRECTIVE_POSTNAME, + PARSE_DIRECTIVE_TAIL, + PARSE_DIRECTIVE_POSTTAIL, + PARSE_PRE_ARG, + PARSE_ARG, + PARSE_ARG_NAME, + PARSE_ARG_POSTNAME, + PARSE_ARG_EQ, + PARSE_ARG_PREVAL, + PARSE_ARG_VAL, + PARSE_ARG_VAL_ESC, + PARSE_ARG_POSTVAL, + PARSE_TAIL, + PARSE_TAIL_SEQ, + PARSE_EXECUTE +} parse_state_t; + +typedef struct ssi_arg_item { + struct ssi_arg_item *next; + char *name; + apr_size_t name_len; + char *value; + apr_size_t value_len; +} ssi_arg_item_t; + +typedef struct { + parse_state_t state; + int seen_eos; + int error; + char quote; /* quote character value (or \0) */ + + apr_bucket_brigade *tmp_bb; + + apr_size_t end_seq_len; + char *directive; /* name of the current directive */ + + unsigned argc; /* argument counter (of the current + * directive) + */ + ssi_arg_item_t *argv; /* all arguments */ + ssi_arg_item_t *current_arg; /* currently parsed argument */ + request_rec *r; + include_ctx_t *ctx; /* public part of the context structure */ + + apr_pool_t *dpool; +} ssi_ctx_t; + +#ifdef XBITHACK +#define DEFAULT_XBITHACK xbithack_full +#else +#define DEFAULT_XBITHACK xbithack_off +#endif + +#define BYTE_COUNT_THRESHOLD AP_MIN_BYTES_TO_WRITE + +#define SSI_CREATE_ERROR_BUCKET(ctx, f, bb) APR_BRIGADE_INSERT_TAIL((bb), \ + apr_bucket_pool_create(apr_pstrdup((ctx)->pool, (ctx)->error_str), \ + strlen((ctx)->error_str), (ctx)->pool, \ + (f)->c->bucket_alloc)) + +/* ------------------------ Environment function -------------------------- */ + +/* Sentinel value to store in subprocess_env for items that + * shouldn't be evaluated until/unless they're actually used + */ +static const char lazy_eval_sentinel; +#define LAZY_VALUE (&lazy_eval_sentinel) + +static void add_include_vars(request_rec *r, char *timefmt) +{ + apr_table_t *e = r->subprocess_env; + char *t; + + apr_table_setn(e, "DATE_LOCAL", LAZY_VALUE); + apr_table_setn(e, "DATE_GMT", LAZY_VALUE); + apr_table_setn(e, "LAST_MODIFIED", LAZY_VALUE); + apr_table_setn(e, "DOCUMENT_URI", r->uri); + if (r->path_info && *r->path_info) { + apr_table_setn(e, "DOCUMENT_PATH_INFO", r->path_info); + } + apr_table_setn(e, "USER_NAME", LAZY_VALUE); + if (r->filename && (t = strrchr(r->filename, '/'))) { + apr_table_setn(e, "DOCUMENT_NAME", ++t); + } + else { + apr_table_setn(e, "DOCUMENT_NAME", r->uri); + } + if (r->args) { + char *arg_copy = apr_pstrdup(r->pool, r->args); + + ap_unescape_url(arg_copy); + apr_table_setn(e, "QUERY_STRING_UNESCAPED", + ap_escape_shell_cmd(r->pool, arg_copy)); + } +} + +static const char *add_include_vars_lazy(request_rec *r, const char *var) +{ + char *val; + if (!strcasecmp(var, "DATE_LOCAL")) { + include_dir_config *conf = + (include_dir_config *)ap_get_module_config(r->per_dir_config, + &include_module); + val = ap_ht_time(r->pool, r->request_time, conf->default_time_fmt, 0); + } + else if (!strcasecmp(var, "DATE_GMT")) { + include_dir_config *conf = + (include_dir_config *)ap_get_module_config(r->per_dir_config, + &include_module); + val = ap_ht_time(r->pool, r->request_time, conf->default_time_fmt, 1); + } + else if (!strcasecmp(var, "LAST_MODIFIED")) { + include_dir_config *conf = + (include_dir_config *)ap_get_module_config(r->per_dir_config, + &include_module); + val = ap_ht_time(r->pool, r->finfo.mtime, conf->default_time_fmt, 0); + } + else if (!strcasecmp(var, "USER_NAME")) { + if (apr_get_username(&val, r->finfo.user, r->pool) != APR_SUCCESS) { + val = "<unknown>"; + } + } + else { + val = NULL; + } + + if (val) { + apr_table_setn(r->subprocess_env, var, val); + } + return val; +} + +static const char *get_include_var(request_rec *r, include_ctx_t *ctx, + const char *var) +{ + const char *val; + if (apr_isdigit(*var) && !var[1]) { + /* Handle $0 .. $9 from the last regex evaluated. + * The choice of returning NULL strings on not-found, + * v.s. empty strings on an empty match is deliberate. + */ + if (!ctx->re_result || !ctx->re_string) { + return NULL; + } + else { + int idx = atoi(var); + apr_size_t len = (*ctx->re_result)[idx].rm_eo + - (*ctx->re_result)[idx].rm_so; + if ( (*ctx->re_result)[idx].rm_so < 0 + || (*ctx->re_result)[idx].rm_eo < 0) { + return NULL; + } + val = apr_pstrmemdup(r->pool, ctx->re_string + + (*ctx->re_result)[idx].rm_so, len); + } + } + else { + val = apr_table_get(r->subprocess_env, var); + + if (val == LAZY_VALUE) + val = add_include_vars_lazy(r, var); + } + return val; +} + +/* --------------------------- Parser functions --------------------------- */ + +/* This is an implementation of the BNDM search algorithm. + * + * Fast and Flexible String Matching by Combining Bit-parallelism and + * Suffix Automata (2001) + * Gonzalo Navarro, Mathieu Raffinot + * + * http://www-igm.univ-mlv.fr/~raffinot/ftp/jea2001.ps.gz + * + * Initial code submitted by Sascha Schumann. + */ + +/* Precompile the bndm_t data structure. */ +static void bndm_compile(bndm_t *t, const char *n, apr_size_t nl) +{ + unsigned int x; + const char *ne = n + nl; + + memset(t->T, 0, sizeof(unsigned int) * 256); + + for (x = 1; n < ne; x <<= 1) + t->T[(unsigned char) *n++] |= x; + + t->x = x - 1; +} + +/* Implements the BNDM search algorithm (as described above). + * + * n - the pattern to search for + * nl - length of the pattern to search for + * h - the string to look in + * hl - length of the string to look for + * t - precompiled bndm structure against the pattern + * + * Returns the count of character that is the first match or hl if no + * match is found. + */ +static apr_size_t bndm(const char *n, apr_size_t nl, const char *h, + apr_size_t hl, bndm_t *t) +{ + const char *skip; + const char *he, *p, *pi; + unsigned int *T, x, d; + + he = h + hl; + + T = t->T; + x = t->x; + + pi = h - 1; /* pi: p initial */ + p = pi + nl; /* compare window right to left. point to the first char */ + + while (p < he) { + skip = p; + d = x; + do { + d &= T[(unsigned char) *p--]; + if (!d) { + break; + } + if ((d & 1)) { + if (p != pi) + skip = p; + else + return p - h + 1; + } + d >>= 1; + } while (d); + + pi = skip; + p = pi + nl; + } + + return hl; +} + +/* + * decodes a string containing html entities or numeric character references. + * 's' is overwritten with the decoded string. + * If 's' is syntatically incorrect, then the followed fixups will be made: + * unknown entities will be left undecoded; + * references to unused numeric characters will be deleted. + * In particular, � will not be decoded, but will be deleted. + * + * drtr + */ + +/* maximum length of any ISO-LATIN-1 HTML entity name. */ +#define MAXENTLEN (6) + +/* The following is a shrinking transformation, therefore safe. */ + +static void decodehtml(char *s) +{ + int val, i, j; + char *p; + const char *ents; + static const char * const entlist[MAXENTLEN + 1] = + { + NULL, /* 0 */ + NULL, /* 1 */ + "lt\074gt\076", /* 2 */ + "amp\046ETH\320eth\360", /* 3 */ + "quot\042Auml\304Euml\313Iuml\317Ouml\326Uuml\334auml\344euml\353\ +iuml\357ouml\366uuml\374yuml\377", /* 4 */ + "Acirc\302Aring\305AElig\306Ecirc\312Icirc\316Ocirc\324Ucirc\333\ +THORN\336szlig\337acirc\342aring\345aelig\346ecirc\352icirc\356ocirc\364\ +ucirc\373thorn\376", /* 5 */ + "Agrave\300Aacute\301Atilde\303Ccedil\307Egrave\310Eacute\311\ +Igrave\314Iacute\315Ntilde\321Ograve\322Oacute\323Otilde\325Oslash\330\ +Ugrave\331Uacute\332Yacute\335agrave\340aacute\341atilde\343ccedil\347\ +egrave\350eacute\351igrave\354iacute\355ntilde\361ograve\362oacute\363\ +otilde\365oslash\370ugrave\371uacute\372yacute\375" /* 6 */ + }; + + /* Do a fast scan through the string until we find anything + * that needs more complicated handling + */ + for (; *s != '&'; s++) { + if (*s == '\0') { + return; + } + } + + for (p = s; *s != '\0'; s++, p++) { + if (*s != '&') { + *p = *s; + continue; + } + /* find end of entity */ + for (i = 1; s[i] != ';' && s[i] != '\0'; i++) { + continue; + } + + if (s[i] == '\0') { /* treat as normal data */ + *p = *s; + continue; + } + + /* is it numeric ? */ + if (s[1] == '#') { + for (j = 2, val = 0; j < i && apr_isdigit(s[j]); j++) { + val = val * 10 + s[j] - '0'; + } + s += i; + if (j < i || val <= 8 || (val >= 11 && val <= 31) || + (val >= 127 && val <= 160) || val >= 256) { + p--; /* no data to output */ + } + else { + *p = RAW_ASCII_CHAR(val); + } + } + else { + j = i - 1; + if (j > MAXENTLEN || entlist[j] == NULL) { + /* wrong length */ + *p = '&'; + continue; /* skip it */ + } + for (ents = entlist[j]; *ents != '\0'; ents += i) { + if (strncmp(s + 1, ents, j) == 0) { + break; + } + } + + if (*ents == '\0') { + *p = '&'; /* unknown */ + } + else { + *p = RAW_ASCII_CHAR(((const unsigned char *) ents)[j]); + s += i; + } + } + } + + *p = '\0'; +} + +/* + * Extract the next tag name and value. + * If there are no more tags, set the tag name to NULL. + * The tag value is html decoded if dodecode is non-zero. + * The tag value may be NULL if there is no tag value.. + * format: + * [WS]<Tag>[WS]=[WS]['|"|`]<Value>[['|"|`|]|WS] + */ + +#define SKIP_TAG_WHITESPACE(ptr) while ((*ptr != '\0') && (apr_isspace (*ptr))) ptr++ + +static void ap_ssi_get_tag_and_value(include_ctx_t *ctx, char **tag, + char **tag_val, int dodecode) +{ + *tag_val = NULL; + if (ctx->curr_tag_pos >= ctx->combined_tag + ctx->tag_length) { + *tag = NULL; + return; + } + + *tag = ctx->curr_tag_pos; + if (!**tag) { + *tag = NULL; + /* finitio */ + ctx->curr_tag_pos = ctx->combined_tag + ctx->tag_length; + return; + } + + *tag_val = ap_strchr(*tag, '='); + if (!*tag_val) { + ctx->curr_tag_pos = ctx->combined_tag + ctx->tag_length; + return; + } + + /* if it starts with '=' there was no tag name, just a value */ + if (*tag_val == *tag) { + *tag = NULL; + } + + *(*tag_val)++ = '\0'; + ctx->curr_tag_pos = *tag_val + strlen(*tag_val) + 1; /* skip \0 byte */ + + if (dodecode) { + decodehtml(*tag_val); + } + + return; +} + +/* initial buffer size for power-of-two allocator in ap_ssi_parse_string */ +#define PARSE_STRING_INITIAL_SIZE 64 + +/* + * Do variable substitution on strings + * (Note: If out==NULL, this function allocs a buffer for the resulting + * string from r->pool. The return value is the parsed string) + */ +static char *ap_ssi_parse_string(request_rec *r, include_ctx_t *ctx, + const char *in, char *out, + apr_size_t length, int leave_name) +{ + char ch; + char *next; + char *end_out; + apr_size_t out_size; + + /* allocate an output buffer if needed */ + if (!out) { + out_size = PARSE_STRING_INITIAL_SIZE; + if (out_size > length) { + out_size = length; + } + out = apr_palloc(r->pool, out_size); + } + else { + out_size = length; + } + + /* leave room for nul terminator */ + end_out = out + out_size - 1; + + next = out; + while ((ch = *in++) != '\0') { + switch (ch) { + case '\\': + if (next == end_out) { + if (out_size < length) { + /* double the buffer size */ + apr_size_t new_out_size = out_size * 2; + apr_size_t current_length = next - out; + char *new_out; + if (new_out_size > length) { + new_out_size = length; + } + new_out = apr_palloc(r->pool, new_out_size); + memcpy(new_out, out, current_length); + out = new_out; + out_size = new_out_size; + end_out = out + out_size - 1; + next = out + current_length; + } + else { + /* truncated */ + *next = '\0'; + return out; + } + } + if (*in == '$') { + *next++ = *in++; + } + else { + *next++ = ch; + } + break; + case '$': + { + const char *start_of_var_name; + char *end_of_var_name; /* end of var name + 1 */ + const char *expansion, *temp_end, *val; + char tmp_store; + apr_size_t l; + + /* guess that the expansion won't happen */ + expansion = in - 1; + if (*in == '{') { + ++in; + start_of_var_name = in; + in = ap_strchr_c(in, '}'); + if (in == NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, + 0, r, "Missing '}' on variable \"%s\"", + expansion); + *next = '\0'; + return out; + } + temp_end = in; + end_of_var_name = (char *)temp_end; + ++in; + } + else { + start_of_var_name = in; + while (apr_isalnum(*in) || *in == '_') { + ++in; + } + temp_end = in; + end_of_var_name = (char *)temp_end; + } + /* what a pain, too bad there's no table_getn where you can + * pass a non-nul terminated string */ + l = end_of_var_name - start_of_var_name; + if (l != 0) { + tmp_store = *end_of_var_name; + *end_of_var_name = '\0'; + val = get_include_var(r, ctx, start_of_var_name); + *end_of_var_name = tmp_store; + + if (val) { + expansion = val; + l = strlen(expansion); + } + else if (leave_name) { + l = in - expansion; + } + else { + /* no expansion to be done */ + break; + } + } + else { + /* zero-length variable name causes just the $ to be + * copied */ + l = 1; + } + if ((next + l > end_out) && (out_size < length)) { + /* increase the buffer size to accommodate l more chars */ + apr_size_t new_out_size = out_size; + apr_size_t current_length = next - out; + char *new_out; + do { + new_out_size *= 2; + } while (new_out_size < current_length + l + 1); /* +1 for NUL */ + if (new_out_size > length) { + new_out_size = length; + } + new_out = apr_palloc(r->pool, new_out_size); + memcpy(new_out, out, current_length); + out = new_out; + out_size = new_out_size; + end_out = out + out_size - 1; + next = out + current_length; + } + l = ((int)l > end_out - next) ? (end_out - next) : l; + memcpy(next, expansion, l); + next += l; + break; + } + default: + if (next == end_out) { + if (out_size < length) { + /* double the buffer size */ + apr_size_t new_out_size = out_size * 2; + apr_size_t current_length = next - out; + char *new_out; + if (new_out_size > length) { + new_out_size = length; + } + new_out = apr_palloc(r->pool, new_out_size); + memcpy(new_out, out, current_length); + out = new_out; + out_size = new_out_size; + end_out = out + out_size - 1; + next = out + current_length; + } + else { + /* truncated */ + *next = '\0'; + return out; + } + } + *next++ = ch; + break; + } + } + *next = '\0'; + return out; +} + +/* --------------------------- Action handlers ---------------------------- */ + +/* ensure that path is relative, and does not contain ".." elements + * ensentially ensure that it does not match the regex: + * (^/|(^|/)\.\.(/|$)) + * XXX: Simply replace with apr_filepath_merge + */ +static int is_only_below(const char *path) +{ +#ifdef HAVE_DRIVE_LETTERS + if (path[1] == ':') + return 0; +#endif +#ifdef NETWARE + if (ap_strchr_c(path, ':')) + return 0; +#endif + if (path[0] == '/') { + return 0; + } + while (*path) { + int dots = 0; + while (path[dots] == '.') + ++dots; +#if defined(WIN32) + /* If the name is canonical this is redundant + * but in security, redundancy is worthwhile. + * Does OS2 belong here (accepts ... for ..)? + */ + if (dots > 1 && (!path[dots] || path[dots] == '/')) + return 0; +#else + if (dots == 2 && (!path[dots] || path[dots] == '/')) + return 0; +#endif + path += dots; + /* Advance to either the null byte at the end of the + * string or the character right after the next slash, + * whichever comes first + */ + while (*path && (*path++ != '/')) { + continue; + } + } + return 1; +} + +static int handle_include(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_bucket *tmp_buck; + char *parsed_string; + int loglevel = APLOG_ERR; + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if (tag_val == NULL) { + if (tag == NULL) { + return (0); + } + else { + return (1); + } + } + if (!strcmp(tag, "virtual") || !strcmp(tag, "file")) { + request_rec *rr = NULL; + char *error_fmt = NULL; + apr_status_t rc = APR_SUCCESS; + + SPLIT_AND_PASS_PRETAG_BUCKETS(*bb, ctx, f->next, rc); + if (rc != APR_SUCCESS) { + return rc; + } + + parsed_string = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + if (tag[0] == 'f') { + /* XXX: Port to apr_filepath_merge + * be safe; only files in this directory or below allowed + */ + if (!is_only_below(parsed_string)) { + error_fmt = "unable to include file \"%s\" " + "in parsed file %s"; + } + else { + rr = ap_sub_req_lookup_uri(parsed_string, r, f->next); + } + } + else { + rr = ap_sub_req_lookup_uri(parsed_string, r, f->next); + } + + if (!error_fmt && rr->status != HTTP_OK) { + error_fmt = "unable to include \"%s\" in parsed file %s"; + } + + if (!error_fmt && (ctx->flags & FLAG_NO_EXEC) && + rr->content_type && + (strncmp(rr->content_type, "text/", 5))) { + error_fmt = "unable to include potential exec \"%s\" " + "in parsed file %s"; + } + + /* See the Kludge in send_parsed_file for why */ + /* Basically, it puts a bread crumb in here, then looks */ + /* for the crumb later to see if its been here. */ + if (rr) + ap_set_module_config(rr->request_config, + &include_module, r); + + if (!error_fmt && ap_run_sub_req(rr)) { + error_fmt = "unable to include \"%s\" in parsed file %s"; + } + if (error_fmt) { + ap_log_rerror(APLOG_MARK, loglevel, + 0, r, error_fmt, tag_val, r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + } + + /* Do *not* destroy the subrequest here; it may have allocated + * variables in this r->subprocess_env in the subrequest's + * r->pool, so that pool must survive as long as this request. + * Yes, this is a memory leak. */ + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" to tag include in %s", + tag, r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return 1; + } + } + } + return 0; +} + + +static int handle_echo(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + const char *echo_text = NULL; + apr_bucket *tmp_buck; + apr_size_t e_len; + enum {E_NONE, E_URL, E_ENTITY} encode; + + encode = E_ENTITY; + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if (tag_val == NULL) { + if (tag != NULL) { + return 1; + } + else { + return 0; + } + } + if (!strcmp(tag, "var")) { + conn_rec *c = r->connection; + const char *val = + get_include_var(r, ctx, + ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0)); + if (val) { + switch(encode) { + case E_NONE: + echo_text = val; + break; + case E_URL: + echo_text = ap_escape_uri(r->pool, val); + break; + case E_ENTITY: + echo_text = ap_escape_html(r->pool, val); + break; + } + + e_len = strlen(echo_text); + tmp_buck = apr_bucket_pool_create(echo_text, e_len, + r->pool, c->bucket_alloc); + } + else { + include_server_config *sconf= + ap_get_module_config(r->server->module_config, + &include_module); + tmp_buck = apr_bucket_pool_create(sconf->undefinedEcho, + sconf->undefinedEchoLen, + r->pool, c->bucket_alloc); + } + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } + else if (!strcmp(tag, "encoding")) { + if (!strcasecmp(tag_val, "none")) encode = E_NONE; + else if (!strcasecmp(tag_val, "url")) encode = E_URL; + else if (!strcasecmp(tag_val, "entity")) encode = E_ENTITY; + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown value \"%s\" to parameter \"encoding\" of " + "tag echo in %s", tag_val, r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" in tag echo of %s", + tag, r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return 1; + } + + } + } + return 0; +} + +/* error and tf must point to a string with room for at + * least MAX_STRING_LEN characters + */ +static int handle_config(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + char *parsed_string; + apr_table_t *env = r->subprocess_env; + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 0); + if (tag_val == NULL) { + if (tag == NULL) { + return 0; /* Reached the end of the string. */ + } + else { + return 1; /* tags must have values. */ + } + } + if (!strcmp(tag, "errmsg")) { + if (ctx->error_str_override == NULL) { + ctx->error_str_override = (char *)apr_palloc(ctx->pool, + MAX_STRING_LEN); + ctx->error_str = ctx->error_str_override; + } + ap_ssi_parse_string(r, ctx, tag_val, ctx->error_str_override, + MAX_STRING_LEN, 0); + } + else if (!strcmp(tag, "timefmt")) { + apr_time_t date = r->request_time; + if (ctx->time_str_override == NULL) { + ctx->time_str_override = (char *)apr_palloc(ctx->pool, + MAX_STRING_LEN); + ctx->time_str = ctx->time_str_override; + } + ap_ssi_parse_string(r, ctx, tag_val, ctx->time_str_override, + MAX_STRING_LEN, 0); + apr_table_setn(env, "DATE_LOCAL", ap_ht_time(r->pool, date, + ctx->time_str, 0)); + apr_table_setn(env, "DATE_GMT", ap_ht_time(r->pool, date, + ctx->time_str, 1)); + apr_table_setn(env, "LAST_MODIFIED", + ap_ht_time(r->pool, r->finfo.mtime, + ctx->time_str, 0)); + } + else if (!strcmp(tag, "sizefmt")) { + parsed_string = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + decodehtml(parsed_string); + if (!strcmp(parsed_string, "bytes")) { + ctx->flags |= FLAG_SIZE_IN_BYTES; + } + else if (!strcmp(parsed_string, "abbrev")) { + ctx->flags &= FLAG_SIZE_ABBREV; + } + } + else { + apr_bucket *tmp_buck; + + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" to tag config in %s", + tag, r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return 1; + } + } + } + return 0; +} + + +static int find_file(request_rec *r, const char *directive, const char *tag, + char *tag_val, apr_finfo_t *finfo) +{ + char *to_send = tag_val; + request_rec *rr = NULL; + int ret=0; + char *error_fmt = NULL; + apr_status_t rv = APR_SUCCESS; + + if (!strcmp(tag, "file")) { + /* XXX: Port to apr_filepath_merge + * be safe; only files in this directory or below allowed + */ + if (!is_only_below(tag_val)) { + error_fmt = "unable to access file \"%s\" " + "in parsed file %s"; + } + else { + ap_getparents(tag_val); /* get rid of any nasties */ + + /* note: it is okay to pass NULL for the "next filter" since + we never attempt to "run" this sub request. */ + rr = ap_sub_req_lookup_file(tag_val, r, NULL); + + if (rr->status == HTTP_OK && rr->finfo.filetype != 0) { + to_send = rr->filename; + if ((rv = apr_stat(finfo, to_send, + APR_FINFO_GPROT | APR_FINFO_MIN, rr->pool)) != APR_SUCCESS + && rv != APR_INCOMPLETE) { + error_fmt = "unable to get information about \"%s\" " + "in parsed file %s"; + } + } + else { + error_fmt = "unable to lookup information about \"%s\" " + "in parsed file %s"; + } + } + + if (error_fmt) { + ret = -1; + ap_log_rerror(APLOG_MARK, APLOG_ERR, + rv, r, error_fmt, to_send, r->filename); + } + + if (rr) ap_destroy_sub_req(rr); + + return ret; + } + else if (!strcmp(tag, "virtual")) { + /* note: it is okay to pass NULL for the "next filter" since + we never attempt to "run" this sub request. */ + rr = ap_sub_req_lookup_uri(tag_val, r, NULL); + + if (rr->status == HTTP_OK && rr->finfo.filetype != 0) { + memcpy((char *) finfo, (const char *) &rr->finfo, + sizeof(rr->finfo)); + ap_destroy_sub_req(rr); + return 0; + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unable to get information about \"%s\" " + "in parsed file %s", + tag_val, r->filename); + ap_destroy_sub_req(rr); + return -1; + } + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" to tag %s in %s", + tag, directive, r->filename); + return -1; + } +} + +static int handle_fsize(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_finfo_t finfo; + apr_size_t s_len; + apr_bucket *tmp_buck; + char *parsed_string; + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if (tag_val == NULL) { + if (tag == NULL) { + return 0; + } + else { + return 1; + } + } + else { + parsed_string = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + if (!find_file(r, "fsize", tag, parsed_string, &finfo)) { + /* XXX: if we *know* we're going to have to copy the + * thing off of the stack anyway, why not palloc buff + * instead of sticking it on the stack; then we can just + * use a pool bucket and skip the copy + */ + char buff[50]; + + if (!(ctx->flags & FLAG_SIZE_IN_BYTES)) { + apr_strfsize(finfo.size, buff); + s_len = strlen (buff); + } + else { + int l, x, pos = 0; + char tmp_buff[50]; + + apr_snprintf(tmp_buff, sizeof(tmp_buff), + "%" APR_OFF_T_FMT, finfo.size); + l = strlen(tmp_buff); /* grrr */ + for (x = 0; x < l; x++) { + if (x && (!((l - x) % 3))) { + buff[pos++] = ','; + } + buff[pos++] = tmp_buff[x]; + } + buff[pos] = '\0'; + s_len = pos; + } + + tmp_buck = apr_bucket_heap_create(buff, s_len, NULL, + r->connection->bucket_alloc); + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } + else { + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + } + } + } + return 0; +} + +static int handle_flastmod(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, + apr_bucket *head_ptr, apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_finfo_t finfo; + apr_size_t t_len; + apr_bucket *tmp_buck; + char *parsed_string; + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if (tag_val == NULL) { + if (tag == NULL) { + return 0; + } + else { + return 1; + } + } + else { + parsed_string = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + if (!find_file(r, "flastmod", tag, parsed_string, &finfo)) { + char *t_val; + + t_val = ap_ht_time(r->pool, finfo.mtime, ctx->time_str, 0); + t_len = strlen(t_val); + + tmp_buck = apr_bucket_pool_create(t_val, t_len, r->pool, + r->connection->bucket_alloc); + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } + else { + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + } + } + } + return 0; +} + +static int re_check(request_rec *r, include_ctx_t *ctx, + char *string, char *rexp) +{ + regex_t *compiled; + const apr_size_t nres = sizeof(*ctx->re_result) / sizeof(regmatch_t); + int regex_error; + + compiled = ap_pregcomp(r->pool, rexp, REG_EXTENDED | REG_NOSUB); + if (compiled == NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unable to compile pattern \"%s\"", rexp); + return -1; + } + if (!ctx->re_result) { + ctx->re_result = apr_pcalloc(r->pool, sizeof(*ctx->re_result)); + } + ctx->re_string = string; + regex_error = ap_regexec(compiled, string, nres, *ctx->re_result, 0); + ap_pregfree(r->pool, compiled); + return (!regex_error); +} + +enum token_type { + token_string, token_re, + token_and, token_or, token_not, token_eq, token_ne, + token_rbrace, token_lbrace, token_group, + token_ge, token_le, token_gt, token_lt +}; +struct token { + enum token_type type; + char* value; +}; + +static const char *get_ptoken(request_rec *r, const char *string, + struct token *token, int *unmatched) +{ + char ch; + int next = 0; + char qs = 0; + int tkn_fnd = 0; + + token->value = NULL; + + /* Skip leading white space */ + if (string == (char *) NULL) { + return (char *) NULL; + } + while ((ch = *string++)) { + if (!apr_isspace(ch)) { + break; + } + } + if (ch == '\0') { + return (char *) NULL; + } + + token->type = token_string; /* the default type */ + switch (ch) { + case '(': + token->type = token_lbrace; + return (string); + case ')': + token->type = token_rbrace; + return (string); + case '=': + token->type = token_eq; + return (string); + case '!': + if (*string == '=') { + token->type = token_ne; + return (string + 1); + } + else { + token->type = token_not; + return (string); + } + case '\'': + /* already token->type == token_string */ + qs = '\''; + break; + case '/': + token->type = token_re; + qs = '/'; + break; + case '|': + if (*string == '|') { + token->type = token_or; + return (string + 1); + } + break; + case '&': + if (*string == '&') { + token->type = token_and; + return (string + 1); + } + break; + case '>': + if (*string == '=') { + token->type = token_ge; + return (string + 1); + } + else { + token->type = token_gt; + return (string); + } + case '<': + if (*string == '=') { + token->type = token_le; + return (string + 1); + } + else { + token->type = token_lt; + return (string); + } + default: + /* already token->type == token_string */ + break; + } + /* We should only be here if we are in a string */ + token->value = apr_palloc(r->pool, strlen(string) + 2); /* 2 for ch plus + trailing null */ + if (!qs) { + --string; + } + + /* + * I used the ++string throughout this section so that string + * ends up pointing to the next token and I can just return it + */ + for (ch = *string; ((ch != '\0') && (!tkn_fnd)); ch = *++string) { + if (ch == '\\') { + if ((ch = *++string) == '\0') { + tkn_fnd = 1; + } + else { + token->value[next++] = ch; + } + } + else { + if (!qs) { + if (apr_isspace(ch)) { + tkn_fnd = 1; + } + else { + switch (ch) { + case '(': + case ')': + case '=': + case '!': + case '<': + case '>': + tkn_fnd = 1; + break; + case '|': + if (*(string + 1) == '|') { + tkn_fnd = 1; + } + break; + case '&': + if (*(string + 1) == '&') { + tkn_fnd = 1; + } + break; + } + if (!tkn_fnd) { + token->value[next++] = ch; + } + } + } + else { + if (ch == qs) { + qs = 0; + tkn_fnd = 1; + string++; + } + else { + token->value[next++] = ch; + } + } + } + if (tkn_fnd) { + break; + } + } + + /* If qs is still set, we have an unmatched quote */ + if (qs) { + *unmatched = 1; + next = 0; + } + token->value[next] = '\0'; + + return (string); +} + + +/* there is an implicit assumption here that expr is at most MAX_STRING_LEN-1 + * characters long... + */ +static int parse_expr(request_rec *r, include_ctx_t *ctx, const char *expr, + int *was_error, int *was_unmatched, char *debug) +{ + struct parse_node { + struct parse_node *left, *right, *parent; + struct token token; + int value, done; + } *root, *current, *new; + const char *parse; + char* buffer; + int retval = 0; + apr_size_t debug_pos = 0; + + debug[debug_pos] = '\0'; + *was_error = 0; + *was_unmatched = 0; + if ((parse = expr) == (char *) NULL) { + return (0); + } + root = current = (struct parse_node *) NULL; + + /* Create Parse Tree */ + while (1) { + new = (struct parse_node *) apr_palloc(r->pool, + sizeof(struct parse_node)); + new->parent = new->left = new->right = (struct parse_node *) NULL; + new->done = 0; + if ((parse = get_ptoken(r, parse, &new->token, was_unmatched)) == + (char *) NULL) { + break; + } + switch (new->token.type) { + + case token_string: +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], + " Token: string (%s)\n", + new->token.value); +#endif + if (current == (struct parse_node *) NULL) { + root = current = new; + break; + } + switch (current->token.type) { + case token_string: + current->token.value = apr_pstrcat(r->pool, + current->token.value, + current->token.value[0] ? " " : "", + new->token.value, + NULL); + + break; + case token_eq: + case token_ne: + case token_and: + case token_or: + case token_lbrace: + case token_not: + case token_ge: + case token_gt: + case token_le: + case token_lt: + new->parent = current; + current = current->right = new; + break; + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + break; + + case token_re: +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], + " Token: regex (%s)\n", + new->token.value); +#endif + if (current == (struct parse_node *) NULL) { + root = current = new; + break; + } + switch (current->token.type) { + case token_eq: + case token_ne: + case token_and: + case token_or: + case token_lbrace: + case token_not: + new->parent = current; + current = current->right = new; + break; + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + break; + + case token_and: + case token_or: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Token: and/or\n", + sizeof (" Token: and/or\n")); + debug_pos += sizeof (" Token: and/or\n"); +#endif + if (current == (struct parse_node *) NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + /* Percolate upwards */ + while (current != (struct parse_node *) NULL) { + switch (current->token.type) { + case token_string: + case token_re: + case token_group: + case token_not: + case token_eq: + case token_ne: + case token_and: + case token_or: + case token_ge: + case token_gt: + case token_le: + case token_lt: + current = current->parent; + continue; + case token_lbrace: + break; + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + break; + } + if (current == (struct parse_node *) NULL) { + new->left = root; + new->left->parent = new; + new->parent = (struct parse_node *) NULL; + root = new; + } + else { + new->left = current->right; + new->left->parent = new; + current->right = new; + new->parent = current; + } + current = new; + break; + + case token_not: +#ifdef DEBUG_INCLUDE + memcpy(&debug[debug_pos], " Token: not\n", + sizeof(" Token: not\n")); + debug_pos += sizeof(" Token: not\n"); +#endif + if (current == (struct parse_node *) NULL) { + root = current = new; + break; + } + /* Percolate upwards */ + if (current != (struct parse_node *) NULL) { + switch (current->token.type) { + case token_not: + case token_eq: + case token_ne: + case token_and: + case token_or: + case token_lbrace: + case token_ge: + case token_gt: + case token_le: + case token_lt: + break; + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + } + if (current == (struct parse_node *) NULL) { + new->left = root; + new->left->parent = new; + new->parent = (struct parse_node *) NULL; + root = new; + } + else { + new->left = current->right; + current->right = new; + new->parent = current; + } + current = new; + break; + + case token_eq: + case token_ne: + case token_ge: + case token_gt: + case token_le: + case token_lt: +#ifdef DEBUG_INCLUDE + memcpy(&debug[debug_pos], " Token: eq/ne/ge/gt/le/lt\n", + sizeof(" Token: eq/ne/ge/gt/le/lt\n")); + debug_pos += sizeof(" Token: eq/ne/ge/gt/le/lt\n"); +#endif + if (current == (struct parse_node *) NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + /* Percolate upwards */ + while (current != (struct parse_node *) NULL) { + switch (current->token.type) { + case token_string: + case token_re: + case token_group: + current = current->parent; + continue; + case token_lbrace: + case token_and: + case token_or: + break; + case token_not: + case token_eq: + case token_ne: + case token_ge: + case token_gt: + case token_le: + case token_lt: + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + break; + } + if (current == (struct parse_node *) NULL) { + new->left = root; + new->left->parent = new; + new->parent = (struct parse_node *) NULL; + root = new; + } + else { + new->left = current->right; + new->left->parent = new; + current->right = new; + new->parent = current; + } + current = new; + break; + + case token_rbrace: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Token: rbrace\n", + sizeof (" Token: rbrace\n")); + debug_pos += sizeof (" Token: rbrace\n"); +#endif + while (current != (struct parse_node *) NULL) { + if (current->token.type == token_lbrace) { + current->token.type = token_group; + break; + } + current = current->parent; + } + if (current == (struct parse_node *) NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Unmatched ')' in \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + break; + + case token_lbrace: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Token: lbrace\n", + sizeof (" Token: lbrace\n")); + debug_pos += sizeof (" Token: lbrace\n"); +#endif + if (current == (struct parse_node *) NULL) { + root = current = new; + break; + } + /* Percolate upwards */ + if (current != (struct parse_node *) NULL) { + switch (current->token.type) { + case token_not: + case token_eq: + case token_ne: + case token_and: + case token_or: + case token_lbrace: + case token_ge: + case token_gt: + case token_le: + case token_lt: + break; + case token_string: + case token_re: + case token_group: + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + } + if (current == (struct parse_node *) NULL) { + new->left = root; + new->left->parent = new; + new->parent = (struct parse_node *) NULL; + root = new; + } + else { + new->left = current->right; + current->right = new; + new->parent = current; + } + current = new; + break; + default: + break; + } + } + + /* Evaluate Parse Tree */ + current = root; + while (current != (struct parse_node *) NULL) { + switch (current->token.type) { + case token_string: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Evaluate string\n", + sizeof (" Evaluate string\n")); + debug_pos += sizeof (" Evaluate string\n"); +#endif + buffer = ap_ssi_parse_string(r, ctx, current->token.value, NULL, + MAX_STRING_LEN, 0); + current->token.value = buffer; + current->value = (current->token.value[0] != '\0'); + current->done = 1; + current = current->parent; + break; + + case token_re: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "No operator before regex of expr \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + + case token_and: + case token_or: +#ifdef DEBUG_INCLUDE + memcpy(&debug[debug_pos], " Evaluate and/or\n", + sizeof(" Evaluate and/or\n")); + debug_pos += sizeof(" Evaluate and/or\n"); +#endif + if (current->left == (struct parse_node *) NULL || + current->right == (struct parse_node *) NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + if (!current->left->done) { + switch (current->left->token.type) { + case token_string: + buffer = ap_ssi_parse_string(r, ctx, current->left->token.value, + NULL, MAX_STRING_LEN, 0); + current->left->token.value = buffer; + current->left->value = + (current->left->token.value[0] != '\0'); + current->left->done = 1; + break; + default: + current = current->left; + continue; + } + } + if (!current->right->done) { + switch (current->right->token.type) { + case token_string: + buffer = ap_ssi_parse_string(r, ctx, current->right->token.value, + NULL, MAX_STRING_LEN, 0); + current->right->token.value = buffer; + current->right->value = + (current->right->token.value[0] != '\0'); + current->right->done = 1; + break; + default: + current = current->right; + continue; + } + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Left: %c\n", + current->left->value ? '1' : '0'); + debug_pos += sprintf (&debug[debug_pos], " Right: %c\n", + current->right->value ? '1' : '0'); +#endif + if (current->token.type == token_and) { + current->value = current->left->value && current->right->value; + } + else { + current->value = current->left->value || current->right->value; + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Returning %c\n", + current->value ? '1' : '0'); +#endif + current->done = 1; + current = current->parent; + break; + + case token_eq: + case token_ne: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Evaluate eq/ne\n", + sizeof (" Evaluate eq/ne\n")); + debug_pos += sizeof (" Evaluate eq/ne\n"); +#endif + if ((current->left == (struct parse_node *) NULL) || + (current->right == (struct parse_node *) NULL) || + (current->left->token.type != token_string) || + ((current->right->token.type != token_string) && + (current->right->token.type != token_re))) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + buffer = ap_ssi_parse_string(r, ctx, current->left->token.value, + NULL, MAX_STRING_LEN, 0); + current->left->token.value = buffer; + buffer = ap_ssi_parse_string(r, ctx, current->right->token.value, + NULL, MAX_STRING_LEN, 0); + current->right->token.value = buffer; + if (current->right->token.type == token_re) { +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], + " Re Compare (%s) with /%s/\n", + current->left->token.value, + current->right->token.value); +#endif + current->value = + re_check(r, ctx, current->left->token.value, + current->right->token.value); + } + else { +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], + " Compare (%s) with (%s)\n", + current->left->token.value, + current->right->token.value); +#endif + current->value = + (strcmp(current->left->token.value, + current->right->token.value) == 0); + } + if (current->token.type == token_ne) { + current->value = !current->value; + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Returning %c\n", + current->value ? '1' : '0'); +#endif + current->done = 1; + current = current->parent; + break; + case token_ge: + case token_gt: + case token_le: + case token_lt: +#ifdef DEBUG_INCLUDE + memcpy (&debug[debug_pos], " Evaluate ge/gt/le/lt\n", + sizeof (" Evaluate ge/gt/le/lt\n")); + debug_pos += sizeof (" Evaluate ge/gt/le/lt\n"); +#endif + if ((current->left == (struct parse_node *) NULL) || + (current->right == (struct parse_node *) NULL) || + (current->left->token.type != token_string) || + (current->right->token.type != token_string)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid expression \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + } + buffer = ap_ssi_parse_string(r, ctx, current->left->token.value, + NULL, MAX_STRING_LEN, 0); + current->left->token.value = buffer; + buffer = ap_ssi_parse_string(r, ctx, current->right->token.value, + NULL, MAX_STRING_LEN, 0); + current->right->token.value = buffer; +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], + " Compare (%s) with (%s)\n", + current->left->token.value, + current->right->token.value); +#endif + current->value = + strcmp(current->left->token.value, + current->right->token.value); + if (current->token.type == token_ge) { + current->value = current->value >= 0; + } + else if (current->token.type == token_gt) { + current->value = current->value > 0; + } + else if (current->token.type == token_le) { + current->value = current->value <= 0; + } + else if (current->token.type == token_lt) { + current->value = current->value < 0; + } + else { + current->value = 0; /* Don't return -1 if unknown token */ + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Returning %c\n", + current->value ? '1' : '0'); +#endif + current->done = 1; + current = current->parent; + break; + + case token_not: + if (current->right != (struct parse_node *) NULL) { + if (!current->right->done) { + current = current->right; + continue; + } + current->value = !current->right->value; + } + else { + current->value = 0; + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Evaluate !: %c\n", + current->value ? '1' : '0'); +#endif + current->done = 1; + current = current->parent; + break; + + case token_group: + if (current->right != (struct parse_node *) NULL) { + if (!current->right->done) { + current = current->right; + continue; + } + current->value = current->right->value; + } + else { + current->value = 1; + } +#ifdef DEBUG_INCLUDE + debug_pos += sprintf (&debug[debug_pos], " Evaluate (): %c\n", + current->value ? '1' : '0'); +#endif + current->done = 1; + current = current->parent; + break; + + case token_lbrace: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Unmatched '(' in \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + + case token_rbrace: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Unmatched ')' in \"%s\" in file %s", + expr, r->filename); + *was_error = 1; + return retval; + + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "bad token type"); + *was_error = 1; + return retval; + } + } + + retval = (root == (struct parse_node *) NULL) ? 0 : root->value; + return (retval); +} + +/*-------------------------------------------------------------------------*/ +#ifdef DEBUG_INCLUDE + +#define MAX_DEBUG_SIZE MAX_STRING_LEN +#define LOG_COND_STATUS(cntx, t_buck, h_ptr, ins_head, tag_text) \ +{ \ + char cond_txt[] = "**** X conditional_status=\"0\"\n"; \ + \ + if (cntx->flags & FLAG_COND_TRUE) { \ + cond_txt[31] = '1'; \ + } \ + memcpy(&cond_txt[5], tag_text, sizeof(tag_text)-1); \ + t_buck = apr_bucket_heap_create(cond_txt, sizeof(cond_txt)-1, \ + NULL, h_ptr->list); \ + APR_BUCKET_INSERT_BEFORE(h_ptr, t_buck); \ + \ + if (ins_head == NULL) { \ + ins_head = t_buck; \ + } \ +} +#define DUMP_PARSE_EXPR_DEBUG(t_buck, h_ptr, d_buf, ins_head) \ +{ \ + if (d_buf[0] != '\0') { \ + t_buck = apr_bucket_heap_create(d_buf, strlen(d_buf), \ + NULL, h_ptr->list); \ + APR_BUCKET_INSERT_BEFORE(h_ptr, t_buck); \ + \ + if (ins_head == NULL) { \ + ins_head = t_buck; \ + } \ + } \ +} +#else + +#define MAX_DEBUG_SIZE 10 +#define LOG_COND_STATUS(cntx, t_buck, h_ptr, ins_head, tag_text) +#define DUMP_PARSE_EXPR_DEBUG(t_buck, h_ptr, d_buf, ins_head) + +#endif +/*-------------------------------------------------------------------------*/ + +/* pjr - These seem to allow expr="fred" expr="joe" where joe overwrites fred. */ +static int handle_if(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + char *expr = NULL; + int expr_ret, was_error, was_unmatched; + apr_bucket *tmp_buck; + char debug_buf[MAX_DEBUG_SIZE]; + + *inserted_head = NULL; + if (!(ctx->flags & FLAG_PRINTING)) { + ctx->if_nesting_level++; + } + else { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 0); + if (tag == NULL) { + if (expr == NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "missing expr in if statement: %s", + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + expr_ret = parse_expr(r, ctx, expr, &was_error, + &was_unmatched, debug_buf); + if (was_error) { + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + if (was_unmatched) { + DUMP_PARSE_EXPR_DEBUG(tmp_buck, head_ptr, + "\nUnmatched '\n", *inserted_head); + } + DUMP_PARSE_EXPR_DEBUG(tmp_buck, head_ptr, debug_buf, + *inserted_head); + + if (expr_ret) { + ctx->flags |= (FLAG_PRINTING | FLAG_COND_TRUE); + } + else { + ctx->flags &= FLAG_CLEAR_PRINT_COND; + } + LOG_COND_STATUS(ctx, tmp_buck, head_ptr, *inserted_head, + " if"); + ctx->if_nesting_level = 0; + return 0; + } + else if (!strcmp(tag, "expr")) { + expr = tag_val; +#ifdef DEBUG_INCLUDE + if (1) { + apr_size_t d_len = 0; + d_len = sprintf(debug_buf, "**** if expr=\"%s\"\n", expr); + tmp_buck = apr_bucket_heap_create(debug_buf, d_len, NULL, + r->connection->bucket_alloc); + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } +#endif + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" to tag if in %s", tag, + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return 1; + } + + } + } + return 0; +} + +static int handle_elif(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + char *expr = NULL; + int expr_ret, was_error, was_unmatched; + apr_bucket *tmp_buck; + char debug_buf[MAX_DEBUG_SIZE]; + + *inserted_head = NULL; + if (!ctx->if_nesting_level) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 0); + if (tag == '\0') { + LOG_COND_STATUS(ctx, tmp_buck, head_ptr, *inserted_head, + " elif"); + + if (ctx->flags & FLAG_COND_TRUE) { + ctx->flags &= FLAG_CLEAR_PRINTING; + return (0); + } + if (expr == NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "missing expr in elif statement: %s", + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + expr_ret = parse_expr(r, ctx, expr, &was_error, + &was_unmatched, debug_buf); + if (was_error) { + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return 1; + } + if (was_unmatched) { + DUMP_PARSE_EXPR_DEBUG(tmp_buck, head_ptr, + "\nUnmatched '\n", *inserted_head); + } + DUMP_PARSE_EXPR_DEBUG(tmp_buck, head_ptr, debug_buf, + *inserted_head); + + if (expr_ret) { + ctx->flags |= (FLAG_PRINTING | FLAG_COND_TRUE); + } + else { + ctx->flags &= FLAG_CLEAR_PRINT_COND; + } + LOG_COND_STATUS(ctx, tmp_buck, head_ptr, *inserted_head, + " elif"); + return (0); + } + else if (!strcmp(tag, "expr")) { + expr = tag_val; +#ifdef DEBUG_INCLUDE + if (1) { + apr_size_t d_len = 0; + d_len = sprintf(debug_buf, "**** elif expr=\"%s\"\n", expr); + tmp_buck = apr_bucket_heap_create(debug_buf, d_len, NULL, + r->connection->bucket_alloc); + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } +#endif + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown parameter \"%s\" to tag if in %s", tag, + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return 1; + } + } + } + return 0; +} + +static int handle_else(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_bucket *tmp_buck; + + *inserted_head = NULL; + if (!ctx->if_nesting_level) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if ((tag != NULL) || (tag_val != NULL)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "else directive does not take tags in %s", r->filename); + if (ctx->flags & FLAG_PRINTING) { + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + } + return -1; + } + else { + LOG_COND_STATUS(ctx, tmp_buck, head_ptr, *inserted_head, " else"); + + if (ctx->flags & FLAG_COND_TRUE) { + ctx->flags &= FLAG_CLEAR_PRINTING; + } + else { + ctx->flags |= (FLAG_PRINTING | FLAG_COND_TRUE); + } + return 0; + } + } + return 0; +} + +static int handle_endif(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_bucket *tmp_buck; + + *inserted_head = NULL; + if (!ctx->if_nesting_level) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if ((tag != NULL) || (tag_val != NULL)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "endif directive does not take tags in %s", r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return -1; + } + else { + LOG_COND_STATUS(ctx, tmp_buck, head_ptr, *inserted_head, "endif"); + ctx->flags |= (FLAG_PRINTING | FLAG_COND_TRUE); + return 0; + } + } + else { + ctx->if_nesting_level--; + return 0; + } +} + +static int handle_set(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, apr_bucket *head_ptr, + apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + char *var = NULL; + apr_bucket *tmp_buck; + char *parsed_string; + request_rec *sub = r->main; + apr_pool_t *p = r->pool; + + /* we need to use the 'main' request pool to set notes as that is + * a notes lifetime + */ + while (sub) { + p = sub->pool; + sub = sub->main; + } + + *inserted_head = NULL; + if (ctx->flags & FLAG_PRINTING) { + while (1) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if ((tag == NULL) && (tag_val == NULL)) { + return 0; + } + else if (tag_val == NULL) { + return 1; + } + else if (!strcmp(tag, "var")) { + var = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + } + else if (!strcmp(tag, "value")) { + if (var == (char *) NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "variable must precede value in set directive in %s", + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, + *inserted_head); + return (-1); + } + parsed_string = ap_ssi_parse_string(r, ctx, tag_val, NULL, + MAX_STRING_LEN, 0); + apr_table_setn(r->subprocess_env, apr_pstrdup(p, var), + apr_pstrdup(p, parsed_string)); + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "Invalid tag for set directive in %s", r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return -1; + } + } + } + return 0; +} + +static int handle_printenv(include_ctx_t *ctx, apr_bucket_brigade **bb, + request_rec *r, ap_filter_t *f, + apr_bucket *head_ptr, apr_bucket **inserted_head) +{ + char *tag = NULL; + char *tag_val = NULL; + apr_bucket *tmp_buck; + + if (ctx->flags & FLAG_PRINTING) { + ap_ssi_get_tag_and_value(ctx, &tag, &tag_val, 1); + if ((tag == NULL) && (tag_val == NULL)) { + const apr_array_header_t *arr = apr_table_elts(r->subprocess_env); + const apr_table_entry_t *elts = (const apr_table_entry_t *)arr->elts; + int i; + const char *key_text, *val_text; + char *key_val, *next; + apr_size_t k_len, v_len, kv_length; + + *inserted_head = NULL; + for (i = 0; i < arr->nelts; ++i) { + key_text = ap_escape_html(r->pool, elts[i].key); + val_text = elts[i].val; + if (val_text == LAZY_VALUE) { + val_text = add_include_vars_lazy(r, elts[i].key); + } + val_text = ap_escape_html(r->pool, elts[i].val); + k_len = strlen(key_text); + v_len = strlen(val_text); + kv_length = k_len + v_len + sizeof("=\n"); + key_val = apr_palloc(r->pool, kv_length); + next = key_val; + memcpy(next, key_text, k_len); + next += k_len; + *next++ = '='; + memcpy(next, val_text, v_len); + next += v_len; + *next++ = '\n'; + *next = 0; + tmp_buck = apr_bucket_pool_create(key_val, kv_length - 1, + r->pool, + r->connection->bucket_alloc); + APR_BUCKET_INSERT_BEFORE(head_ptr, tmp_buck); + if (*inserted_head == NULL) { + *inserted_head = tmp_buck; + } + } + return 0; + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "printenv directive does not take tags in %s", + r->filename); + CREATE_ERROR_BUCKET(ctx, tmp_buck, head_ptr, *inserted_head); + return -1; + } + } + return 0; +} + +/* -------------------------- The main function --------------------------- */ + +/* + * returns the index position of the first byte of start_seq (or the len of + * the buffer as non-match) + */ +static apr_size_t find_start_sequence(ssi_ctx_t *ctx, const char *data, + apr_size_t len) +{ + apr_size_t slen = ctx->ctx->start_seq_len; + apr_size_t index; + const char *p, *ep; + + if (len < slen) { + p = data; /* try partial match at the end of the buffer (below) */ + } + else { + /* try fast bndm search over the buffer + * (hopefully the whole start sequence can be found in this buffer) + */ + index = bndm(ctx->ctx->start_seq, ctx->ctx->start_seq_len, data, len, + ctx->ctx->start_seq_pat); + + /* wow, found it. ready. */ + if (index < len) { + ctx->state = PARSE_DIRECTIVE; + return index; + } + else { + /* ok, the pattern can't be found as whole in the buffer, + * check the end for a partial match + */ + p = data + len - slen + 1; + } + } + + ep = data + len; + do { + while (p < ep && *p != *ctx->ctx->start_seq) { + ++p; + } + + index = p - data; + + /* found a possible start_seq start */ + if (p < ep) { + apr_size_t pos = 1; + + ++p; + while (p < ep && *p == ctx->ctx->start_seq[pos]) { + ++p; + ++pos; + } + + /* partial match found. Store the info for the next round */ + if (p == ep) { + ctx->state = PARSE_HEAD; + ctx->ctx->parse_pos = pos; + return index; + } + } + + /* we must try all combinations; consider (e.g.) SSIStartTag "--->" + * and a string data of "--.-" and the end of the buffer + */ + p = data + index + 1; + } while (p < ep); + + /* no match */ + return len; +} + +/* + * returns the first byte *after* the partial (or final) match. + * + * If we had to trick with the start_seq start, 'release' returns the + * number of chars of the start_seq which appeared not to be part of a + * full tag and may have to be passed down the filter chain. + */ +static apr_size_t find_partial_start_sequence(ssi_ctx_t *ctx, + const char *data, + apr_size_t len, + apr_size_t *release) +{ + apr_size_t pos, spos = 0; + apr_size_t slen = ctx->ctx->start_seq_len; + const char *p, *ep; + + pos = ctx->ctx->parse_pos; + ep = data + len; + *release = 0; + + do { + p = data; + + while (p < ep && pos < slen && *p == ctx->ctx->start_seq[pos]) { + ++p; + ++pos; + } + + /* full match */ + if (pos == slen) { + ctx->state = PARSE_DIRECTIVE; + return (p - data); + } + + /* the whole buffer is a partial match */ + if (p == ep) { + ctx->ctx->parse_pos = pos; + return (p - data); + } + + /* No match so far, but again: + * We must try all combinations, since the start_seq is a random + * user supplied string + * + * So: look if the first char of start_seq appears somewhere within + * the current partial match. If it does, try to start a match that + * begins with this offset. (This can happen, if a strange + * start_seq like "---->" spans buffers) + */ + if (spos < ctx->ctx->parse_pos) { + do { + ++spos; + ++*release; + p = ctx->ctx->start_seq + spos; + pos = ctx->ctx->parse_pos - spos; + + while (pos && *p != *ctx->ctx->start_seq) { + ++p; + ++spos; + ++*release; + --pos; + } + + /* if a matching beginning char was found, try to match the + * remainder of the old buffer. + */ + if (pos > 1) { + apr_size_t t = 1; + + ++p; + while (t < pos && *p == ctx->ctx->start_seq[t]) { + ++p; + ++t; + } + + if (t == pos) { + /* yeah, another partial match found in the *old* + * buffer, now test the *current* buffer for + * continuing match + */ + break; + } + } + } while (pos > 1); + + if (pos) { + continue; + } + } + + break; + } while (1); /* work hard to find a match ;-) */ + + /* no match at all, release all (wrongly) matched chars so far */ + *release = ctx->ctx->parse_pos; + ctx->state = PARSE_PRE_HEAD; + return 0; +} + +/* + * returns the position after the directive + */ +static apr_size_t find_directive(ssi_ctx_t *ctx, const char *data, + apr_size_t len, char ***store, + apr_size_t **store_len) +{ + const char *p = data; + const char *ep = data + len; + apr_size_t pos; + + switch (ctx->state) { + case PARSE_DIRECTIVE: + while (p < ep && !apr_isspace(*p)) { + /* we have to consider the case of missing space between directive + * and end_seq (be somewhat lenient), e.g. <!--#printenv--> + */ + if (*p == *ctx->ctx->end_seq) { + ctx->state = PARSE_DIRECTIVE_TAIL; + ctx->ctx->parse_pos = 1; + ++p; + return (p - data); + } + ++p; + } + + if (p < ep) { /* found delimiter whitespace */ + ctx->state = PARSE_DIRECTIVE_POSTNAME; + *store = &ctx->directive; + *store_len = &ctx->ctx->directive_length; + } + + break; + + case PARSE_DIRECTIVE_TAIL: + pos = ctx->ctx->parse_pos; + + while (p < ep && pos < ctx->end_seq_len && + *p == ctx->ctx->end_seq[pos]) { + ++p; + ++pos; + } + + /* full match, we're done */ + if (pos == ctx->end_seq_len) { + ctx->state = PARSE_DIRECTIVE_POSTTAIL; + *store = &ctx->directive; + *store_len = &ctx->ctx->directive_length; + break; + } + + /* partial match, the buffer is too small to match fully */ + if (p == ep) { + ctx->ctx->parse_pos = pos; + break; + } + + /* no match. continue normal parsing */ + ctx->state = PARSE_DIRECTIVE; + return 0; + + case PARSE_DIRECTIVE_POSTTAIL: + ctx->state = PARSE_EXECUTE; + ctx->ctx->directive_length -= ctx->end_seq_len; + /* continue immediately with the next state */ + + case PARSE_DIRECTIVE_POSTNAME: + if (PARSE_DIRECTIVE_POSTNAME == ctx->state) { + ctx->state = PARSE_PRE_ARG; + } + ctx->argc = 0; + ctx->argv = NULL; + + if (!ctx->ctx->directive_length) { + ctx->error = 1; + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->r, "missing directive " + "name in parsed document %s", ctx->r->filename); + } + else { + char *sp = ctx->directive; + char *sep = ctx->directive + ctx->ctx->directive_length; + + /* normalize directive name */ + for (; sp < sep; ++sp) { + *sp = apr_tolower(*sp); + } + } + + return 0; + + default: + /* get a rid of a gcc warning about unhandled enumerations */ + break; + } + + return (p - data); +} + +/* + * find out whether the next token is (a possible) end_seq or an argument + */ +static apr_size_t find_arg_or_tail(ssi_ctx_t *ctx, const char *data, + apr_size_t len) +{ + const char *p = data; + const char *ep = data + len; + + /* skip leading WS */ + while (p < ep && apr_isspace(*p)) { + ++p; + } + + /* buffer doesn't consist of whitespaces only */ + if (p < ep) { + ctx->state = (*p == *ctx->ctx->end_seq) ? PARSE_TAIL : PARSE_ARG; + } + + return (p - data); +} + +/* + * test the stream for end_seq. If it doesn't match at all, it must be an + * argument + */ +static apr_size_t find_tail(ssi_ctx_t *ctx, const char *data, + apr_size_t len) +{ + const char *p = data; + const char *ep = data + len; + apr_size_t pos = ctx->ctx->parse_pos; + + if (PARSE_TAIL == ctx->state) { + ctx->state = PARSE_TAIL_SEQ; + pos = ctx->ctx->parse_pos = 0; + } + + while (p < ep && pos < ctx->end_seq_len && *p == ctx->ctx->end_seq[pos]) { + ++p; + ++pos; + } + + /* bingo, full match */ + if (pos == ctx->end_seq_len) { + ctx->state = PARSE_EXECUTE; + return (p - data); + } + + /* partial match, the buffer is too small to match fully */ + if (p == ep) { + ctx->ctx->parse_pos = pos; + return (p - data); + } + + /* no match. It must be an argument string then */ + ctx->state = PARSE_ARG; + return 0; +} + +/* + * extract name=value from the buffer + * A pcre-pattern could look (similar to): + * name\s*(?:=\s*(["'`]?)value\1(?>\s*))? + */ +static apr_size_t find_argument(ssi_ctx_t *ctx, const char *data, + apr_size_t len, char ***store, + apr_size_t **store_len) +{ + const char *p = data; + const char *ep = data + len; + + switch (ctx->state) { + case PARSE_ARG: + /* + * create argument structure and append it to the current list + */ + ctx->current_arg = apr_palloc(ctx->dpool, + sizeof(*ctx->current_arg)); + ctx->current_arg->next = NULL; + + ++(ctx->argc); + if (!ctx->argv) { + ctx->argv = ctx->current_arg; + } + else { + ssi_arg_item_t *newarg = ctx->argv; + + while (newarg->next) { + newarg = newarg->next; + } + newarg->next = ctx->current_arg; + } + + /* check whether it's a valid one. If it begins with a quote, we + * can safely assume, someone forgot the name of the argument + */ + switch (*p) { + case '"': case '\'': case '`': + *store = NULL; + + ctx->state = PARSE_ARG_VAL; + ctx->quote = *p++; + ctx->current_arg->name = NULL; + ctx->current_arg->name_len = 0; + ctx->error = 1; + + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->r, "missing argument " + "name for value to tag %s in %s", + apr_pstrmemdup(ctx->r->pool, ctx->directive, + ctx->ctx->directive_length), + ctx->r->filename); + + return (p - data); + + default: + ctx->state = PARSE_ARG_NAME; + } + /* continue immediately with next state */ + + case PARSE_ARG_NAME: + while (p < ep && !apr_isspace(*p) && *p != '=') { + ++p; + } + + if (p < ep) { + ctx->state = PARSE_ARG_POSTNAME; + *store = &ctx->current_arg->name; + *store_len = &ctx->current_arg->name_len; + return (p - data); + } + break; + + case PARSE_ARG_POSTNAME: + ctx->current_arg->name = apr_pstrmemdup(ctx->dpool, + ctx->current_arg->name, + ctx->current_arg->name_len); + if (!ctx->current_arg->name_len) { + ctx->error = 1; + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, ctx->r, "missing argument " + "name for value to tag %s in %s", + apr_pstrmemdup(ctx->r->pool, ctx->directive, + ctx->ctx->directive_length), + ctx->r->filename); + } + else { + char *sp = ctx->current_arg->name; + + /* normalize the name */ + while (*sp) { + *sp = apr_tolower(*sp); + ++sp; + } + } + + ctx->state = PARSE_ARG_EQ; + /* continue with next state immediately */ + + case PARSE_ARG_EQ: + *store = NULL; + + while (p < ep && apr_isspace(*p)) { + ++p; + } + + if (p < ep) { + if (*p == '=') { + ctx->state = PARSE_ARG_PREVAL; + ++p; + } + else { /* no value */ + ctx->current_arg->value = NULL; + ctx->state = PARSE_PRE_ARG; + } + + return (p - data); + } + break; + + case PARSE_ARG_PREVAL: + *store = NULL; + + while (p < ep && apr_isspace(*p)) { + ++p; + } + + /* buffer doesn't consist of whitespaces only */ + if (p < ep) { + ctx->state = PARSE_ARG_VAL; + switch (*p) { + case '"': case '\'': case '`': + ctx->quote = *p++; + break; + default: + ctx->quote = '\0'; + break; + } + + return (p - data); + } + break; + + case PARSE_ARG_VAL_ESC: + if (*p == ctx->quote) { + ++p; + } + ctx->state = PARSE_ARG_VAL; + /* continue with next state immediately */ + + case PARSE_ARG_VAL: + for (; p < ep; ++p) { + if (ctx->quote && *p == '\\') { + ++p; + if (p == ep) { + ctx->state = PARSE_ARG_VAL_ESC; + break; + } + + if (*p != ctx->quote) { + --p; + } + } + else if (ctx->quote && *p == ctx->quote) { + ++p; + *store = &ctx->current_arg->value; + *store_len = &ctx->current_arg->value_len; + ctx->state = PARSE_ARG_POSTVAL; + break; + } + else if (!ctx->quote && apr_isspace(*p)) { + ++p; + *store = &ctx->current_arg->value; + *store_len = &ctx->current_arg->value_len; + ctx->state = PARSE_ARG_POSTVAL; + break; + } + } + + return (p - data); + + case PARSE_ARG_POSTVAL: + /* + * The value is still the raw input string. Finally clean it up. + */ + --(ctx->current_arg->value_len); + + /* strip quote escaping \ from the string */ + if (ctx->quote) { + apr_size_t shift = 0; + char *sp; + + sp = ctx->current_arg->value; + ep = ctx->current_arg->value + ctx->current_arg->value_len; + while (sp < ep && *sp != '\\') { + ++sp; + } + for (; sp < ep; ++sp) { + if (*sp == '\\' && sp[1] == ctx->quote) { + ++sp; + ++shift; + } + if (shift) { + *(sp-shift) = *sp; + } + } + + ctx->current_arg->value_len -= shift; + } + + ctx->current_arg->value[ctx->current_arg->value_len] = '\0'; + ctx->state = PARSE_PRE_ARG; + + return 0; + + default: + /* get a rid of a gcc warning about unhandled enumerations */ + break; + } + + return len; /* partial match of something */ +} + +/* + * This is the main loop over the current bucket brigade. + */ +static apr_status_t send_parsed_content(ap_filter_t *f, apr_bucket_brigade *bb) +{ + ssi_ctx_t *ctx = f->ctx; + request_rec *r = f->r; + apr_bucket *b = APR_BRIGADE_FIRST(bb); + apr_bucket_brigade *pass_bb; + apr_status_t rv = APR_SUCCESS; + char *magic; /* magic pointer for sentinel use */ + + /* fast exit */ + if (APR_BRIGADE_EMPTY(bb)) { + return APR_SUCCESS; + } + + /* we may crash, since already cleaned up; hand over the responsibility + * to the next filter;-) + */ + if (ctx->seen_eos) { + return ap_pass_brigade(f->next, bb); + } + + /* All stuff passed along has to be put into that brigade */ + pass_bb = apr_brigade_create(ctx->ctx->pool, f->c->bucket_alloc); + ctx->ctx->bytes_parsed = 0; + ctx->ctx->output_now = 0; + ctx->error = 0; + + /* loop over the current bucket brigade */ + while (b != APR_BRIGADE_SENTINEL(bb)) { + const char *data = NULL; + apr_size_t len, index, release; + apr_bucket *newb = NULL; + char **store = &magic; + apr_size_t *store_len; + + /* handle meta buckets before reading any data */ + if (APR_BUCKET_IS_METADATA(b)) { + newb = APR_BUCKET_NEXT(b); + + APR_BUCKET_REMOVE(b); + + if (APR_BUCKET_IS_EOS(b)) { + ctx->seen_eos = 1; + + /* Hit end of stream, time for cleanup ... But wait! + * Perhaps we're not ready yet. We may have to loop one or + * two times again to finish our work. In that case, we + * just re-insert the EOS bucket to allow for an extra loop. + * + * PARSE_EXECUTE means, we've hit a directive just before the + * EOS, which is now waiting for execution. + * + * PARSE_DIRECTIVE_POSTTAIL means, we've hit a directive with + * no argument and no space between directive and end_seq + * just before the EOS. (consider <!--#printenv--> as last + * or only string within the stream). This state, however, + * just cleans up and turns itself to PARSE_EXECUTE, which + * will be passed through within the next (and actually + * last) round. + */ + if (PARSE_EXECUTE == ctx->state || + PARSE_DIRECTIVE_POSTTAIL == ctx->state) { + APR_BUCKET_INSERT_BEFORE(newb, b); + } + else { + break; /* END OF STREAM */ + } + } + else { + APR_BRIGADE_INSERT_TAIL(pass_bb, b); + + if (APR_BUCKET_IS_FLUSH(b)) { + ctx->ctx->output_now = 1; + } + + b = newb; + continue; + } + } + + /* enough is enough ... */ + if (ctx->ctx->output_now || + ctx->ctx->bytes_parsed > AP_MIN_BYTES_TO_WRITE) { + + if (!APR_BRIGADE_EMPTY(pass_bb)) { + rv = ap_pass_brigade(f->next, pass_bb); + if (!APR_STATUS_IS_SUCCESS(rv)) { + apr_brigade_destroy(pass_bb); + return rv; + } + } + + ctx->ctx->output_now = 0; + ctx->ctx->bytes_parsed = 0; + } + + /* read the current bucket data */ + len = 0; + if (!ctx->seen_eos) { + if (ctx->ctx->bytes_parsed > 0) { + rv = apr_bucket_read(b, &data, &len, APR_NONBLOCK_READ); + if (APR_STATUS_IS_EAGAIN(rv)) { + ctx->ctx->output_now = 1; + continue; + } + } + + if (!len || !APR_STATUS_IS_SUCCESS(rv)) { + rv = apr_bucket_read(b, &data, &len, APR_BLOCK_READ); + } + + if (!APR_STATUS_IS_SUCCESS(rv)) { + apr_brigade_destroy(pass_bb); + return rv; + } + + ctx->ctx->bytes_parsed += len; + } + + /* zero length bucket, fetch next one */ + if (!len && !ctx->seen_eos) { + b = APR_BUCKET_NEXT(b); + continue; + } + + /* + * it's actually a data containing bucket, start/continue parsing + */ + + switch (ctx->state) { + /* no current tag; search for start sequence */ + case PARSE_PRE_HEAD: + index = find_start_sequence(ctx, data, len); + + if (index < len) { + apr_bucket_split(b, index); + } + + newb = APR_BUCKET_NEXT(b); + if (ctx->ctx->flags & FLAG_PRINTING) { + APR_BUCKET_REMOVE(b); + APR_BRIGADE_INSERT_TAIL(pass_bb, b); + } + else { + apr_bucket_delete(b); + } + + if (index < len) { + /* now delete the start_seq stuff from the remaining bucket */ + if (PARSE_DIRECTIVE == ctx->state) { /* full match */ + apr_bucket_split(newb, ctx->ctx->start_seq_len); + ctx->ctx->output_now = 1; /* pass pre-tag stuff */ + } + + b = APR_BUCKET_NEXT(newb); + apr_bucket_delete(newb); + } + else { + b = newb; + } + + break; + + /* we're currently looking for the end of the start sequence */ + case PARSE_HEAD: + index = find_partial_start_sequence(ctx, data, len, &release); + + /* check if we mismatched earlier and have to release some chars */ + if (release && (ctx->ctx->flags & FLAG_PRINTING)) { + char *to_release = apr_palloc(ctx->ctx->pool, release); + + memcpy(to_release, ctx->ctx->start_seq, release); + newb = apr_bucket_pool_create(to_release, release, + ctx->ctx->pool, + f->c->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(pass_bb, newb); + } + + if (index) { /* any match */ + /* now delete the start_seq stuff from the remaining bucket */ + if (PARSE_DIRECTIVE == ctx->state) { /* final match */ + apr_bucket_split(b, index); + ctx->ctx->output_now = 1; /* pass pre-tag stuff */ + } + newb = APR_BUCKET_NEXT(b); + apr_bucket_delete(b); + b = newb; + } + + break; + + /* we're currently grabbing the directive name */ + case PARSE_DIRECTIVE: + case PARSE_DIRECTIVE_POSTNAME: + case PARSE_DIRECTIVE_TAIL: + case PARSE_DIRECTIVE_POSTTAIL: + index = find_directive(ctx, data, len, &store, &store_len); + + if (index) { + apr_bucket_split(b, index); + newb = APR_BUCKET_NEXT(b); + } + + if (store) { + if (index) { + APR_BUCKET_REMOVE(b); + APR_BRIGADE_INSERT_TAIL(ctx->tmp_bb, b); + b = newb; + } + + /* time for cleanup? */ + if (store != &magic) { + apr_brigade_pflatten(ctx->tmp_bb, store, store_len, + ctx->dpool); + apr_brigade_cleanup(ctx->tmp_bb); + } + } + else if (index) { + apr_bucket_delete(b); + b = newb; + } + + break; + + /* skip WS and find out what comes next (arg or end_seq) */ + case PARSE_PRE_ARG: + index = find_arg_or_tail(ctx, data, len); + + if (index) { /* skipped whitespaces */ + if (index < len) { + apr_bucket_split(b, index); + } + newb = APR_BUCKET_NEXT(b); + apr_bucket_delete(b); + b = newb; + } + + break; + + /* currently parsing name[=val] */ + case PARSE_ARG: + case PARSE_ARG_NAME: + case PARSE_ARG_POSTNAME: + case PARSE_ARG_EQ: + case PARSE_ARG_PREVAL: + case PARSE_ARG_VAL: + case PARSE_ARG_VAL_ESC: + case PARSE_ARG_POSTVAL: + index = find_argument(ctx, data, len, &store, &store_len); + + if (index) { + apr_bucket_split(b, index); + newb = APR_BUCKET_NEXT(b); + } + + if (store) { + if (index) { + APR_BUCKET_REMOVE(b); + APR_BRIGADE_INSERT_TAIL(ctx->tmp_bb, b); + b = newb; + } + + /* time for cleanup? */ + if (store != &magic) { + apr_brigade_pflatten(ctx->tmp_bb, store, store_len, + ctx->dpool); + apr_brigade_cleanup(ctx->tmp_bb); + } + } + else if (index) { + apr_bucket_delete(b); + b = newb; + } + + break; + + /* try to match end_seq at current pos. */ + case PARSE_TAIL: + case PARSE_TAIL_SEQ: + index = find_tail(ctx, data, len); + + switch (ctx->state) { + case PARSE_EXECUTE: /* full match */ + apr_bucket_split(b, index); + newb = APR_BUCKET_NEXT(b); + apr_bucket_delete(b); + b = newb; + break; + + case PARSE_ARG: /* no match */ + /* PARSE_ARG must reparse at the beginning */ + APR_BRIGADE_PREPEND(bb, ctx->tmp_bb); + b = APR_BRIGADE_FIRST(bb); + break; + + default: /* partial match */ + newb = APR_BUCKET_NEXT(b); + APR_BUCKET_REMOVE(b); + APR_BRIGADE_INSERT_TAIL(ctx->tmp_bb, b); + b = newb; + break; + } + + break; + + /* now execute the parsed directive, cleanup the space and + * start again with PARSE_PRE_HEAD + */ + case PARSE_EXECUTE: + /* if there was an error, it was already logged; just stop here */ + if (ctx->error) { + if (ctx->ctx->flags & FLAG_PRINTING) { + SSI_CREATE_ERROR_BUCKET(ctx->ctx, f, pass_bb); + ctx->error = 0; + } + } + else { + include_handler_fn_t *handle_func; + + handle_func = + (include_handler_fn_t *) apr_hash_get(include_hash, + ctx->directive, + ctx->ctx->directive_length); + if (handle_func) { + apr_bucket *dummy; + char *tag; + apr_size_t tag_len = 0; + ssi_arg_item_t *carg = ctx->argv; + + /* legacy wrapper code */ + while (carg) { + /* +1 \0 byte (either after tag or value) + * +1 = byte (before value) + */ + tag_len += (carg->name ? carg->name_len : 0) + + (carg->value ? carg->value_len + 1 : 0) + 1; + carg = carg->next; + } + + tag = ctx->ctx->combined_tag = ctx->ctx->curr_tag_pos = + apr_palloc(ctx->dpool, tag_len); + + carg = ctx->argv; + while (carg) { + if (carg->name) { + memcpy(tag, carg->name, carg->name_len); + tag += carg->name_len; + } + if (carg->value) { + *tag++ = '='; + memcpy(tag, carg->value, carg->value_len); + tag += carg->value_len; + } + *tag++ = '\0'; + carg = carg->next; + } + ctx->ctx->tag_length = tag_len; + + /* create dummy buckets for backards compat */ + ctx->ctx->head_start_bucket = + apr_bucket_pool_create(apr_pmemdup(ctx->ctx->pool, + ctx->ctx->start_seq, + ctx->ctx->start_seq_len), + ctx->ctx->start_seq_len, + ctx->ctx->pool, + f->c->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(ctx->ctx->ssi_tag_brigade, + ctx->ctx->head_start_bucket); + ctx->ctx->tag_start_bucket = + apr_bucket_pool_create(apr_pmemdup(ctx->ctx->pool, + ctx->ctx->combined_tag, + ctx->ctx->tag_length), + ctx->ctx->tag_length, + ctx->ctx->pool, + f->c->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(ctx->ctx->ssi_tag_brigade, + ctx->ctx->tag_start_bucket); + ctx->ctx->tail_start_bucket = + apr_bucket_pool_create(apr_pmemdup(ctx->ctx->pool, + ctx->ctx->end_seq, + ctx->end_seq_len), + ctx->end_seq_len, + ctx->ctx->pool, + f->c->bucket_alloc); + APR_BRIGADE_INSERT_TAIL(ctx->ctx->ssi_tag_brigade, + ctx->ctx->tail_start_bucket); + + rv = handle_func(ctx->ctx, &bb, r, f, b, &dummy); + + apr_brigade_cleanup(ctx->ctx->ssi_tag_brigade); + + if (rv != 0 && rv != 1 && rv != -1) { + apr_brigade_destroy(pass_bb); + return rv; + } + + if (dummy) { + apr_bucket_brigade *remain; + + remain = apr_brigade_split(bb, b); + APR_BRIGADE_CONCAT(pass_bb, bb); + bb = remain; + } + } + else { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "unknown directive \"%s\" in parsed doc %s", + apr_pstrmemdup(r->pool, ctx->directive, + ctx->ctx->directive_length), + r->filename); + if (ctx->ctx->flags & FLAG_PRINTING) { + SSI_CREATE_ERROR_BUCKET(ctx->ctx, f, pass_bb); + } + } + } + + /* cleanup */ + apr_pool_clear(ctx->dpool); + apr_brigade_cleanup(ctx->tmp_bb); + + /* Oooof. Done here, start next round */ + ctx->state = PARSE_PRE_HEAD; + break; + } + + } /* while (brigade) */ + + /* End of stream. Final cleanup */ + if (ctx->seen_eos) { + if (PARSE_HEAD == ctx->state) { + if (ctx->ctx->flags & FLAG_PRINTING) { + char *to_release = apr_palloc(ctx->ctx->pool, + ctx->ctx->parse_pos); + + memcpy(to_release, ctx->ctx->start_seq, ctx->ctx->parse_pos); + APR_BRIGADE_INSERT_TAIL(pass_bb, + apr_bucket_pool_create(to_release, + ctx->ctx->parse_pos, ctx->ctx->pool, + f->c->bucket_alloc)); + } + } + else if (PARSE_PRE_HEAD != ctx->state) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, + "SSI directive was not properly finished at the end " + "of parsed document %s", r->filename); + if (ctx->ctx->flags & FLAG_PRINTING) { + SSI_CREATE_ERROR_BUCKET(ctx->ctx, f, pass_bb); + } + } + + if (!(ctx->ctx->flags & FLAG_PRINTING)) { + ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, + "missing closing endif directive in parsed document" + " %s", r->filename); + } + + /* cleanup our temporary memory */ + apr_brigade_destroy(ctx->tmp_bb); + apr_pool_destroy(ctx->dpool); + + /* don't forget to finally insert the EOS bucket */ + APR_BRIGADE_INSERT_TAIL(pass_bb, b); + } + + /* if something's left over, pass it along */ + if (!APR_BRIGADE_EMPTY(pass_bb)) { + rv = ap_pass_brigade(f->next, pass_bb); + } + else { + rv = APR_SUCCESS; + } + + apr_brigade_destroy(pass_bb); + return rv; +} + +static void *create_includes_dir_config(apr_pool_t *p, char *dummy) +{ + include_dir_config *result = + (include_dir_config *)apr_palloc(p, sizeof(include_dir_config)); + enum xbithack *xbh = (enum xbithack *) apr_palloc(p, sizeof(enum xbithack)); + *xbh = DEFAULT_XBITHACK; + result->default_error_msg = DEFAULT_ERROR_MSG; + result->default_time_fmt = DEFAULT_TIME_FORMAT; + result->xbithack = xbh; + return result; +} + +static void *create_includes_server_config(apr_pool_t*p, server_rec *server) +{ + include_server_config *result = + (include_server_config *)apr_palloc(p, sizeof(include_server_config)); + result->default_end_tag = ENDING_SEQUENCE; + result->default_start_tag =STARTING_SEQUENCE; + result->start_tag_len = sizeof(STARTING_SEQUENCE)-1; + /* compile the pattern used by find_start_sequence */ + bndm_compile(&result->start_seq_pat, result->default_start_tag, + result->start_tag_len); + + result->undefinedEcho = apr_pstrdup(p,"(none)"); + result->undefinedEchoLen = strlen( result->undefinedEcho); + return result; +} +static const char *set_xbithack(cmd_parms *cmd, void *xbp, const char *arg) +{ + include_dir_config *conf = (include_dir_config *)xbp; + + if (!strcasecmp(arg, "off")) { + *conf->xbithack = xbithack_off; + } + else if (!strcasecmp(arg, "on")) { + *conf->xbithack = xbithack_on; + } + else if (!strcasecmp(arg, "full")) { + *conf->xbithack = xbithack_full; + } + else { + return "XBitHack must be set to Off, On, or Full"; + } + + return NULL; +} + +static int includes_setup(ap_filter_t *f) +{ + include_dir_config *conf = + (include_dir_config *)ap_get_module_config(f->r->per_dir_config, + &include_module); + + /* When our xbithack value isn't set to full or our platform isn't + * providing group-level protection bits or our group-level bits do not + * have group-execite on, we will set the no_local_copy value to 1 so + * that we will not send 304s. + */ + if ((*conf->xbithack != xbithack_full) + || !(f->r->finfo.valid & APR_FINFO_GPROT) + || !(f->r->finfo.protection & APR_GEXECUTE)) { + f->r->no_local_copy = 1; + } + + /* Don't allow ETag headers to be generated - see RFC2616 - 13.3.4. + * We don't know if we are going to be including a file or executing + * a program - in either case a strong ETag header will likely be invalid. + */ + apr_table_setn(f->r->notes, "no-etag", ""); + + return OK; +} + +static apr_status_t includes_filter(ap_filter_t *f, apr_bucket_brigade *b) +{ + request_rec *r = f->r; + ssi_ctx_t *ctx = f->ctx; + request_rec *parent; + include_dir_config *conf = + (include_dir_config *)ap_get_module_config(r->per_dir_config, + &include_module); + + include_server_config *sconf= ap_get_module_config(r->server->module_config, + &include_module); + + if (!(ap_allow_options(r) & OPT_INCLUDES)) { + ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, + "mod_include: Options +Includes (or IncludesNoExec) " + "wasn't set, INCLUDES filter removed"); + ap_remove_output_filter(f); + return ap_pass_brigade(f->next, b); + } + + if (!f->ctx) { + /* create context for this filter */ + f->ctx = ctx = apr_palloc(f->c->pool, sizeof(*ctx)); + ctx->ctx = apr_pcalloc(f->c->pool, sizeof(*ctx->ctx)); + ctx->ctx->pool = f->r->pool; + apr_pool_create(&ctx->dpool, ctx->ctx->pool); + + /* configuration data */ + ctx->end_seq_len = strlen(sconf->default_end_tag); + ctx->r = f->r; + + /* runtime data */ + ctx->tmp_bb = apr_brigade_create(ctx->ctx->pool, f->c->bucket_alloc); + ctx->seen_eos = 0; + ctx->state = PARSE_PRE_HEAD; + ctx->ctx->flags = (FLAG_PRINTING | FLAG_COND_TRUE); + if (ap_allow_options(f->r) & OPT_INCNOEXEC) { + ctx->ctx->flags |= FLAG_NO_EXEC; + } + ctx->ctx->if_nesting_level = 0; + ctx->ctx->re_string = NULL; + ctx->ctx->error_str_override = NULL; + ctx->ctx->time_str_override = NULL; + + ctx->ctx->error_str = conf->default_error_msg; + ctx->ctx->time_str = conf->default_time_fmt; + ctx->ctx->start_seq_pat = &sconf->start_seq_pat; + ctx->ctx->start_seq = sconf->default_start_tag; + ctx->ctx->start_seq_len = sconf->start_tag_len; + ctx->ctx->end_seq = sconf->default_end_tag; + + /* legacy compat stuff */ + ctx->ctx->state = PARSED; /* dummy */ + ctx->ctx->ssi_tag_brigade = apr_brigade_create(f->c->pool, + f->c->bucket_alloc); + ctx->ctx->status = APR_SUCCESS; + ctx->ctx->head_start_index = 0; + ctx->ctx->tag_start_index = 0; + ctx->ctx->tail_start_index = 0; + } + else { + ctx->ctx->bytes_parsed = 0; + } + + if ((parent = ap_get_module_config(r->request_config, &include_module))) { + /* Kludge --- for nested includes, we want to keep the subprocess + * environment of the base document (for compatibility); that means + * torquing our own last_modified date as well so that the + * LAST_MODIFIED variable gets reset to the proper value if the + * nested document resets <!--#config timefmt -->. + */ + r->subprocess_env = r->main->subprocess_env; + apr_pool_join(r->main->pool, r->pool); + r->finfo.mtime = r->main->finfo.mtime; + } + else { + /* we're not a nested include, so we create an initial + * environment */ + ap_add_common_vars(r); + ap_add_cgi_vars(r); + add_include_vars(r, conf->default_time_fmt); + } + /* Always unset the content-length. There is no way to know if + * the content will be modified at some point by send_parsed_content. + * It is very possible for us to not find any content in the first + * 9k of the file, but still have to modify the content of the file. + * If we are going to pass the file through send_parsed_content, then + * the content-length should just be unset. + */ + apr_table_unset(f->r->headers_out, "Content-Length"); + + /* Always unset the Last-Modified field - see RFC2616 - 13.3.4. + * We don't know if we are going to be including a file or executing + * a program which may change the Last-Modified header or make the + * content completely dynamic. Therefore, we can't support these + * headers. + * Exception: XBitHack full means we *should* set the Last-Modified field. + */ + + /* Assure the platform supports Group protections */ + if ((*conf->xbithack == xbithack_full) + && (r->finfo.valid & APR_FINFO_GPROT) + && (r->finfo.protection & APR_GEXECUTE)) { + ap_update_mtime(r, r->finfo.mtime); + ap_set_last_modified(r); + } + else { + apr_table_unset(f->r->headers_out, "Last-Modified"); + } + + /* add QUERY stuff to env cause it ain't yet */ + if (r->args) { + char *arg_copy = apr_pstrdup(r->pool, r->args); + + apr_table_setn(r->subprocess_env, "QUERY_STRING", r->args); + ap_unescape_url(arg_copy); + apr_table_setn(r->subprocess_env, "QUERY_STRING_UNESCAPED", + ap_escape_shell_cmd(r->pool, arg_copy)); + } + + return send_parsed_content(f, b); +} + +static void ap_register_include_handler(char *tag, include_handler_fn_t *func) +{ + apr_hash_set(include_hash, tag, strlen(tag), (const void *)func); +} + +static int include_post_config(apr_pool_t *p, apr_pool_t *plog, + apr_pool_t *ptemp, server_rec *s) +{ + include_hash = apr_hash_make(p); + + ssi_pfn_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_include_handler); + + if(ssi_pfn_register) { + ssi_pfn_register("if", handle_if); + ssi_pfn_register("set", handle_set); + ssi_pfn_register("else", handle_else); + ssi_pfn_register("elif", handle_elif); + ssi_pfn_register("echo", handle_echo); + ssi_pfn_register("endif", handle_endif); + ssi_pfn_register("fsize", handle_fsize); + ssi_pfn_register("config", handle_config); + ssi_pfn_register("include", handle_include); + ssi_pfn_register("flastmod", handle_flastmod); + ssi_pfn_register("printenv", handle_printenv); + } + return OK; +} + +static const char *set_default_error_msg(cmd_parms *cmd, void *mconfig, const char *msg) +{ + include_dir_config *conf = (include_dir_config *)mconfig; + conf->default_error_msg = apr_pstrdup(cmd->pool, msg); + return NULL; +} + +static const char *set_default_start_tag(cmd_parms *cmd, void *mconfig, const char *msg) +{ + include_server_config *conf; + conf= ap_get_module_config(cmd->server->module_config , &include_module); + conf->default_start_tag = apr_pstrdup(cmd->pool, msg); + conf->start_tag_len = strlen(conf->default_start_tag ); + bndm_compile(&conf->start_seq_pat, conf->default_start_tag, + conf->start_tag_len); + + return NULL; +} +static const char *set_undefined_echo(cmd_parms *cmd, void *mconfig, const char *msg) +{ + include_server_config *conf; + conf = ap_get_module_config(cmd->server->module_config, &include_module); + conf->undefinedEcho = apr_pstrdup(cmd->pool, msg); + conf->undefinedEchoLen = strlen(msg); + + return NULL; +} + + +static const char *set_default_end_tag(cmd_parms *cmd, void *mconfig, const char *msg) +{ + include_server_config *conf; + conf= ap_get_module_config(cmd->server->module_config , &include_module); + conf->default_end_tag = apr_pstrdup(cmd->pool, msg); + + return NULL; +} + +static const char *set_default_time_fmt(cmd_parms *cmd, void *mconfig, const char *fmt) +{ + include_dir_config *conf = (include_dir_config *)mconfig; + conf->default_time_fmt = apr_pstrdup(cmd->pool, fmt); + return NULL; +} + +/* + * Module definition and configuration data structs... + */ +static const command_rec includes_cmds[] = +{ + AP_INIT_TAKE1("XBitHack", set_xbithack, NULL, OR_OPTIONS, + "Off, On, or Full"), + AP_INIT_TAKE1("SSIErrorMsg", set_default_error_msg, NULL, OR_ALL, + "a string"), + AP_INIT_TAKE1("SSITimeFormat", set_default_time_fmt, NULL, OR_ALL, + "a strftime(3) formatted string"), + AP_INIT_TAKE1("SSIStartTag", set_default_start_tag, NULL, RSRC_CONF, + "SSI Start String Tag"), + AP_INIT_TAKE1("SSIEndTag", set_default_end_tag, NULL, RSRC_CONF, + "SSI End String Tag"), + AP_INIT_TAKE1("SSIUndefinedEcho", set_undefined_echo, NULL, RSRC_CONF, + "SSI Start String Tag"), + + {NULL} +}; + +static int include_fixup(request_rec *r) +{ + include_dir_config *conf; + + conf = (include_dir_config *) ap_get_module_config(r->per_dir_config, + &include_module); + + if (r->handler && (strcmp(r->handler, "server-parsed") == 0)) + { + if (!r->content_type || !*r->content_type) { + ap_set_content_type(r, "text/html"); + } + r->handler = "default-handler"; + } + else +#if defined(OS2) || defined(WIN32) || defined(NETWARE) + /* These OS's don't support xbithack. This is being worked on. */ + { + return DECLINED; + } +#else + { + if (*conf->xbithack == xbithack_off) { + return DECLINED; + } + + if (!(r->finfo.protection & APR_UEXECUTE)) { + return DECLINED; + } + + if (!r->content_type || strcmp(r->content_type, "text/html")) { + return DECLINED; + } + } +#endif + + /* We always return declined, because the default handler actually + * serves the file. All we have to do is add the filter. + */ + ap_add_output_filter("INCLUDES", NULL, r, r->connection); + return DECLINED; +} + +static void register_hooks(apr_pool_t *p) +{ + APR_REGISTER_OPTIONAL_FN(ap_ssi_get_tag_and_value); + APR_REGISTER_OPTIONAL_FN(ap_ssi_parse_string); + APR_REGISTER_OPTIONAL_FN(ap_register_include_handler); + ap_hook_post_config(include_post_config, NULL, NULL, APR_HOOK_REALLY_FIRST); + ap_hook_fixups(include_fixup, NULL, NULL, APR_HOOK_LAST); + ap_register_output_filter("INCLUDES", includes_filter, includes_setup, + AP_FTYPE_RESOURCE); +} + +module AP_MODULE_DECLARE_DATA include_module = +{ + STANDARD20_MODULE_STUFF, + create_includes_dir_config, /* dir config creater */ + NULL, /* dir merger --- default is to override */ + create_includes_server_config,/* server config */ + NULL, /* merge server config */ + includes_cmds, /* command apr_table_t */ + register_hooks /* register hooks */ +}; |