Updated lighttpd.

1 files changed, 795 insertions, 0 deletions

diff --git a/data/lighttpd/lighttpd-1.4.53/src/configparser.y b/data/lighttpd/lighttpd-1.4.53/src/configparser.y
new file mode 100644
index 000000000..9e49ad733
--- /dev/null
+++ b/data/lighttpd/lighttpd-1.4.53/src/configparser.y
@@ -0,0 +1,795 @@
+%token_prefix TK_
+%extra_argument {config_t *ctx}
+%name configparser
+
+%include {
+#include "first.h"
+#include "base.h"
+#include "configfile.h"
+#include "buffer.h"
+#include "array.h"
+#include "request.h" /* http_request_host_normalize() */
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+static void configparser_push(config_t *ctx, data_config *dc, int isnew) {
+  if (isnew) {
+    dc->context_ndx = ctx->all_configs->used;
+    force_assert(dc->context_ndx > ctx->current->context_ndx);
+    array_insert_unique(ctx->all_configs, (data_unset *)dc);
+    dc->parent = ctx->current;
+    vector_config_weak_push(&dc->parent->children, dc);
+  }
+  if (ctx->configs_stack.used > 0 && ctx->current->context_ndx == 0) {
+    fprintf(stderr, "Cannot use conditionals inside a global { ... } block\n");
+    exit(-1);
+  }
+  vector_config_weak_push(&ctx->configs_stack, ctx->current);
+  ctx->current = dc;
+}
+
+static data_config *configparser_pop(config_t *ctx) {
+  data_config *old = ctx->current;
+  ctx->current = vector_config_weak_pop(&ctx->configs_stack);
+  return old;
+}
+
+/* return a copied variable */
+static data_unset *configparser_get_variable(config_t *ctx, const buffer *key) {
+  data_unset *du;
+  data_config *dc;
+
+#if 0
+  fprintf(stderr, "get var %s\n", key->ptr);
+#endif
+  for (dc = ctx->current; dc; dc = dc->parent) {
+#if 0
+    fprintf(stderr, "get var on block: %s\n", dc->key->ptr);
+    array_print(dc->value, 0);
+#endif
+    if (NULL != (du = array_get_element_klen(dc->value, CONST_BUF_LEN(key)))) {
+      du = du->fn->copy(du);
+      buffer_clear(du->key);
+      return du;
+    }
+  }
+  return NULL;
+}
+
+/* op1 is to be eat/return by this function if success, op1->key is not cared
+   op2 is left untouch, unreferenced
+ */
+data_unset *configparser_merge_data(data_unset *op1, const data_unset *op2) {
+  /* type mismatch */
+  if (op1->type != op2->type) {
+    if (op1->type == TYPE_STRING && op2->type == TYPE_INTEGER) {
+      data_string *ds = (data_string *)op1;
+      buffer_append_int(ds->value, ((data_integer*)op2)->value);
+      return op1;
+    } else if (op1->type == TYPE_INTEGER && op2->type == TYPE_STRING) {
+      data_string *ds = data_string_init();
+      buffer_append_int(ds->value, ((data_integer*)op1)->value);
+      buffer_append_string_buffer(ds->value, ((data_string*)op2)->value);
+      op1->fn->free(op1);
+      return (data_unset *)ds;
+    } else {
+      fprintf(stderr, "data type mismatch, cannot merge\n");
+      op1->fn->free(op1);
+      return NULL;
+    }
+  }
+
+  switch (op1->type) {
+    case TYPE_STRING:
+      buffer_append_string_buffer(((data_string *)op1)->value, ((data_string *)op2)->value);
+      break;
+    case TYPE_INTEGER:
+      ((data_integer *)op1)->value += ((data_integer *)op2)->value;
+      break;
+    case TYPE_ARRAY: {
+      array *dst = ((data_array *)op1)->value;
+      array *src = ((data_array *)op2)->value;
+      data_unset *du;
+      size_t i;
+
+      for (i = 0; i < src->used; i ++) {
+        du = (data_unset *)src->data[i];
+        if (du) {
+          if (du->is_index_key || buffer_is_empty(du->key) || !array_get_element_klen(dst, CONST_BUF_LEN(du->key))) {
+            array_insert_unique(dst, du->fn->copy(du));
+          } else {
+            fprintf(stderr, "Duplicate array-key '%s'\n", du->key->ptr);
+            op1->fn->free(op1);
+            return NULL;
+          }
+        }
+      }
+      break;
+    default:
+      force_assert(0);
+      break;
+    }
+  }
+  return op1;
+}
+
+static int configparser_remoteip_normalize_compat(buffer *rvalue) {
+  /* $HTTP["remoteip"] IPv6 accepted with or without '[]' for config compat
+   * http_request_host_normalize() expects IPv6 with '[]',
+   * and config processing at runtime expects COMP_HTTP_REMOTE_IP
+   * compared without '[]', so strip '[]' after normalization */
+  buffer *b = buffer_init();
+  int rc;
+
+  if (rvalue->ptr[0] != '[') {
+      buffer_append_string_len(b, CONST_STR_LEN("["));
+      buffer_append_string_buffer(b, rvalue);
+      buffer_append_string_len(b, CONST_STR_LEN("]"));
+  } else {
+      buffer_append_string_buffer(b, rvalue);
+  }
+
+  rc = http_request_host_normalize(b, 0);
+
+  if (0 == rc) {
+    /* remove surrounding '[]' */
+    size_t blen = buffer_string_length(b);
+    if (blen > 1) buffer_copy_string_len(rvalue, b->ptr+1, blen-2);
+  }
+
+  buffer_free(b);
+  return rc;
+}
+
+}
+
+%parse_failure {
+  ctx->ok = 0;
+}
+
+input ::= metalines.
+metalines ::= metalines metaline.
+metalines ::= .
+metaline ::= varline.
+metaline ::= global.
+metaline ::= condlines(A) EOL. { A = NULL; }
+metaline ::= include.
+metaline ::= include_shell.
+metaline ::= EOL.
+
+%type       value                  {data_unset *}
+%type       expression             {data_unset *}
+%type       aelement               {data_unset *}
+%type       condline               {data_config *}
+%type       cond_else              {data_config *}
+%type       condlines              {data_config *}
+%type       aelements              {array *}
+%type       array                  {array *}
+%type       key                    {buffer *}
+%type       stringop               {buffer *}
+
+%type       cond                   {config_cond_t }
+
+%destructor value                  { if ($$) $$->fn->free($$); }
+%destructor expression             { if ($$) $$->fn->free($$); }
+%destructor aelement               { if ($$) $$->fn->free($$); }
+%destructor aelements              { array_free($$); }
+%destructor array                  { array_free($$); }
+%destructor key                    { buffer_free($$); }
+%destructor stringop               { buffer_free($$); }
+
+%token_type                        {buffer *}
+%token_destructor                  { buffer_free($$); }
+
+varline ::= key(A) ASSIGN expression(B). {
+  if (ctx->ok) {
+    buffer_copy_buffer(B->key, A);
+    if (strncmp(A->ptr, "env.", sizeof("env.") - 1) == 0) {
+      fprintf(stderr, "Setting env variable is not supported in conditional %d %s: %s\n",
+          ctx->current->context_ndx,
+          ctx->current->key->ptr, A->ptr);
+      ctx->ok = 0;
+    } else if (NULL == array_get_element_klen(ctx->current->value, CONST_BUF_LEN(B->key))) {
+      array_insert_unique(ctx->current->value, B);
+      B = NULL;
+    } else {
+      fprintf(stderr, "Duplicate config variable in conditional %d %s: %s\n",
+              ctx->current->context_ndx,
+              ctx->current->key->ptr, B->key->ptr);
+      ctx->ok = 0;
+    }
+  }
+  buffer_free(A);
+  A = NULL;
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+varline ::= key(A) FORCE_ASSIGN expression(B). {
+  if (ctx->ok) {
+    if (strncmp(A->ptr, "env.", sizeof("env.") - 1) == 0) {
+      fprintf(stderr, "Setting env variable is not supported in conditional %d %s: %s\n",
+              ctx->current->context_ndx,
+              ctx->current->key->ptr, A->ptr);
+      ctx->ok = 0;
+    } else {
+      buffer_copy_buffer(B->key, A);
+      array_replace(ctx->current->value, B);
+      B = NULL;
+    }
+  }
+  buffer_free(A);
+  A = NULL;
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+varline ::= key(A) APPEND expression(B). {
+  if (ctx->ok) {
+    array *vars = ctx->current->value;
+    data_unset *du;
+
+    if (strncmp(A->ptr, "env.", sizeof("env.") - 1) == 0) {
+      fprintf(stderr, "Appending env variable is not supported in conditional %d %s: %s\n",
+          ctx->current->context_ndx,
+          ctx->current->key->ptr, A->ptr);
+      ctx->ok = 0;
+    } else if (NULL != (du = array_extract_element_klen(vars, CONST_BUF_LEN(A))) || NULL != (du = configparser_get_variable(ctx, A))) {
+      du = configparser_merge_data(du, B);
+      if (NULL == du) {
+        ctx->ok = 0;
+      }
+      else {
+        buffer_copy_buffer(du->key, A);
+        array_insert_unique(ctx->current->value, du);
+      }
+    } else {
+      buffer_copy_buffer(B->key, A);
+      array_insert_unique(ctx->current->value, B);
+      B = NULL;
+    }
+  }
+  buffer_free(A);
+  A = NULL;
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+key(A) ::= LKEY(B). {
+  if (strchr(B->ptr, '.') == NULL) {
+    A = buffer_init_string("var.");
+    buffer_append_string_buffer(A, B);
+  } else {
+    A = B;
+    B = NULL;
+  }
+  buffer_free(B);
+  B = NULL;
+}
+
+expression(A) ::= expression(B) PLUS value(C). {
+  A = NULL;
+  if (ctx->ok) {
+    A = configparser_merge_data(B, C);
+    B = NULL;
+    if (NULL == A) {
+      ctx->ok = 0;
+    }
+  }
+  if (B) B->fn->free(B);
+  B = NULL;
+  if (C) C->fn->free(C);
+  C = NULL;
+}
+
+expression(A) ::= value(B). {
+  A = B;
+  B = NULL;
+}
+
+value(A) ::= key(B). {
+  A = NULL;
+  if (ctx->ok) {
+    if (strncmp(B->ptr, "env.", sizeof("env.") - 1) == 0) {
+      char *env;
+
+      if (NULL != (env = getenv(B->ptr + 4))) {
+        data_string *ds;
+        ds = data_string_init();
+        buffer_append_string(ds->value, env);
+        A = (data_unset *)ds;
+      }
+      else {
+        fprintf(stderr, "Undefined env variable: %s\n", B->ptr + 4);
+        ctx->ok = 0;
+      }
+    } else if (NULL == (A = configparser_get_variable(ctx, B))) {
+      fprintf(stderr, "Undefined config variable: %s\n", B->ptr);
+      ctx->ok = 0;
+    }
+  }
+  buffer_free(B);
+  B = NULL;
+}
+
+value(A) ::= STRING(B). {
+  buffer *b;
+  A = (data_unset *)data_string_init();
+  b = ((data_string *)(A))->value;
+  buffer_free(b);
+  ((data_string *)(A))->value = B;
+  B = NULL;
+}
+
+value(A) ::= INTEGER(B). {
+  char *endptr;
+  A = (data_unset *)data_integer_init();
+  errno = 0;
+  ((data_integer *)(A))->value = strtol(B->ptr, &endptr, 10);
+  /* skip trailing whitespace */
+  if (endptr != B->ptr) while (isspace(*endptr)) endptr++;
+  if (0 != errno || *endptr != '\0') {
+    fprintf(stderr, "error parsing number: '%s'\n", B->ptr);
+    ctx->ok = 0;
+  }
+  buffer_free(B);
+  B = NULL;
+}
+value(A) ::= array(B). {
+  A = (data_unset *)data_array_init();
+  array_free(((data_array *)(A))->value);
+  ((data_array *)(A))->value = B;
+  B = NULL;
+}
+array(A) ::= LPARAN RPARAN. {
+  A = array_init();
+}
+array(A) ::= LPARAN aelements(B) RPARAN. {
+  A = B;
+  B = NULL;
+}
+
+aelements(A) ::= aelements(C) COMMA aelement(B). {
+  A = NULL;
+  if (ctx->ok) {
+    if (buffer_is_empty(B->key) ||
+        NULL == array_get_element_klen(C, CONST_BUF_LEN(B->key))) {
+      array_insert_unique(C, B);
+      B = NULL;
+    } else {
+      fprintf(stderr, "Error: duplicate array-key: %s. Please get rid of the duplicate entry.\n",
+              B->key->ptr);
+      ctx->ok = 0;
+    }
+
+    A = C;
+    C = NULL;
+  }
+  array_free(C);
+  C = NULL;
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+aelements(A) ::= aelements(C) COMMA. {
+  A = C;
+  C = NULL;
+}
+
+aelements(A) ::= aelement(B). {
+  A = NULL;
+  if (ctx->ok) {
+    A = array_init();
+    array_insert_unique(A, B);
+    B = NULL;
+  }
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+aelement(A) ::= expression(B). {
+  A = B;
+  B = NULL;
+}
+aelement(A) ::= stringop(B) ARRAY_ASSIGN expression(C). {
+  A = NULL;
+  if (ctx->ok) {
+    buffer_copy_buffer(C->key, B);
+
+    A = C;
+    C = NULL;
+  }
+  if (C) C->fn->free(C);
+  C = NULL;
+  buffer_free(B);
+  B = NULL;
+}
+
+eols ::= EOL.
+eols ::= .
+
+globalstart ::= GLOBAL. {
+  data_config *dc;
+  dc = (data_config *)array_get_element_klen(ctx->srv->config_context, CONST_STR_LEN("global"));
+  force_assert(dc);
+  configparser_push(ctx, dc, 0);
+}
+
+global ::= globalstart LCURLY metalines RCURLY. {
+  force_assert(ctx->current);
+  configparser_pop(ctx);
+  force_assert(ctx->current);
+}
+
+condlines(A) ::= condlines(B) eols ELSE condline(C). {
+  A = NULL;
+  if (ctx->ok) {
+    if (B->context_ndx >= C->context_ndx) {
+      fprintf(stderr, "unreachable else condition\n");
+      ctx->ok = 0;
+    }
+    if (B->cond == CONFIG_COND_ELSE) {
+      fprintf(stderr, "unreachable condition following else catch-all\n");
+      ctx->ok = 0;
+    }
+    C->prev = B;
+    B->next = C;
+    A = C;
+  }
+  B = NULL;
+  C = NULL;
+}
+
+condlines(A) ::= condlines(B) eols ELSE cond_else(C). {
+  A = NULL;
+  if (ctx->ok) {
+    if (B->context_ndx >= C->context_ndx) {
+      fprintf(stderr, "unreachable else condition\n");
+      ctx->ok = 0;
+    }
+    if (B->cond == CONFIG_COND_ELSE) {
+      fprintf(stderr, "unreachable condition following else catch-all\n");
+      ctx->ok = 0;
+    }
+  }
+  if (ctx->ok) {
+    size_t pos;
+    data_config *dc;
+    dc = (data_config *)array_extract_element_klen(ctx->all_configs, CONST_BUF_LEN(C->key));
+    force_assert(C == dc);
+    buffer_copy_buffer(C->key, B->key);
+    C->comp = B->comp;
+    /*buffer_copy_buffer(C->comp_key, B->comp_key);*/
+    /*C->string = buffer_init_buffer(B->string);*/
+    pos = buffer_string_length(C->key)-buffer_string_length(B->string)-2;
+    switch(B->cond) {
+    case CONFIG_COND_NE:
+      C->key->ptr[pos] = '='; /* opposite cond */
+      /*buffer_copy_string_len(C->op, CONST_STR_LEN("=="));*/
+      break;
+    case CONFIG_COND_EQ:
+      C->key->ptr[pos] = '!'; /* opposite cond */
+      /*buffer_copy_string_len(C->op, CONST_STR_LEN("!="));*/
+      break;
+    case CONFIG_COND_NOMATCH:
+      C->key->ptr[pos] = '='; /* opposite cond */
+      /*buffer_copy_string_len(C->op, CONST_STR_LEN("=~"));*/
+      break;
+    case CONFIG_COND_MATCH:
+      C->key->ptr[pos] = '!'; /* opposite cond */
+      /*buffer_copy_string_len(C->op, CONST_STR_LEN("!~"));*/
+      break;
+    default: /* should not happen; CONFIG_COND_ELSE checked further above */
+      force_assert(0);
+    }
+
+    if (NULL == (dc = (data_config *)array_get_element_klen(ctx->all_configs, CONST_BUF_LEN(C->key)))) {
+      /* re-insert into ctx->all_configs with new C->key */
+      array_insert_unique(ctx->all_configs, (data_unset *)C);
+      C->prev = B;
+      B->next = C;
+    } else {
+      fprintf(stderr, "unreachable else condition\n");
+      ctx->ok = 0;
+      C->fn->free((data_unset *)C);
+      C = dc;
+    }
+
+    A = C;
+  }
+  B = NULL;
+  C = NULL;
+}
+
+condlines(A) ::= condline(B). {
+  A = B;
+  B = NULL;
+}
+
+condline(A) ::= context LCURLY metalines RCURLY. {
+  A = NULL;
+  if (ctx->ok) {
+    data_config *cur;
+
+    cur = ctx->current;
+    configparser_pop(ctx);
+
+    force_assert(cur && ctx->current);
+
+    A = cur;
+  }
+}
+
+cond_else(A) ::= context_else LCURLY metalines RCURLY. {
+  A = NULL;
+  if (ctx->ok) {
+    data_config *cur;
+
+    cur = ctx->current;
+    configparser_pop(ctx);
+
+    force_assert(cur && ctx->current);
+
+    A = cur;
+  }
+}
+
+context ::= DOLLAR SRVVARNAME(B) LBRACKET stringop(C) RBRACKET cond(E) expression(D). {
+  data_config *dc;
+  buffer *b = NULL, *rvalue, *op = NULL;
+
+  if (ctx->ok && D->type != TYPE_STRING) {
+    fprintf(stderr, "rvalue must be string");
+    ctx->ok = 0;
+  }
+
+  if (ctx->ok) {
+    switch(E) {
+    case CONFIG_COND_NE:
+      op = buffer_init_string("!=");
+      break;
+    case CONFIG_COND_EQ:
+      op = buffer_init_string("==");
+      break;
+    case CONFIG_COND_NOMATCH:
+      op = buffer_init_string("!~");
+      break;
+    case CONFIG_COND_MATCH:
+      op = buffer_init_string("=~");
+      break;
+    default:
+      force_assert(0);
+      return; /* unreachable */
+    }
+
+    b = buffer_init();
+    buffer_copy_buffer(b, ctx->current->key);
+    buffer_append_string_len(b, CONST_STR_LEN("/"));
+    buffer_append_string_buffer(b, B);
+    buffer_append_string_buffer(b, C);
+    buffer_append_string_buffer(b, op);
+    rvalue = ((data_string*)D)->value;
+    buffer_append_string_buffer(b, rvalue);
+
+    if (NULL != (dc = (data_config *)array_get_element_klen(ctx->all_configs, CONST_BUF_LEN(b)))) {
+      configparser_push(ctx, dc, 0);
+    } else {
+      static const struct {
+        comp_key_t comp;
+        char *comp_key;
+        size_t len;
+      } comps[] = {
+        { COMP_SERVER_SOCKET,      CONST_STR_LEN("SERVER[\"socket\"]"   ) },
+        { COMP_HTTP_URL,           CONST_STR_LEN("HTTP[\"url\"]"        ) },
+        { COMP_HTTP_HOST,          CONST_STR_LEN("HTTP[\"host\"]"       ) },
+        { COMP_HTTP_REQUEST_HEADER,CONST_STR_LEN("HTTP[\"referer\"]"    ) },
+        { COMP_HTTP_USER_AGENT,    CONST_STR_LEN("HTTP[\"useragent\"]"  ) },
+        { COMP_HTTP_REQUEST_HEADER,CONST_STR_LEN("HTTP[\"user-agent\"]" ) },
+        { COMP_HTTP_LANGUAGE,      CONST_STR_LEN("HTTP[\"language\"]"   ) },
+        { COMP_HTTP_REQUEST_HEADER,CONST_STR_LEN("HTTP[\"cookie\"]"     ) },
+        { COMP_HTTP_REMOTE_IP,     CONST_STR_LEN("HTTP[\"remoteip\"]"   ) },
+        { COMP_HTTP_REMOTE_IP,     CONST_STR_LEN("HTTP[\"remote-ip\"]"   ) },
+        { COMP_HTTP_QUERY_STRING,  CONST_STR_LEN("HTTP[\"querystring\"]") },
+        { COMP_HTTP_QUERY_STRING,  CONST_STR_LEN("HTTP[\"query-string\"]") },
+        { COMP_HTTP_REQUEST_METHOD, CONST_STR_LEN("HTTP[\"request-method\"]") },
+        { COMP_HTTP_SCHEME,        CONST_STR_LEN("HTTP[\"scheme\"]"     ) },
+        { COMP_UNSET, NULL, 0 },
+      };
+      size_t i;
+
+      dc = data_config_init();
+
+      buffer_copy_buffer(dc->key, b);
+      buffer_copy_buffer(dc->op, op);
+      buffer_copy_buffer(dc->comp_tag, C);
+      buffer_copy_buffer(dc->comp_key, B);
+      buffer_append_string_len(dc->comp_key, CONST_STR_LEN("[\""));
+      buffer_append_string_buffer(dc->comp_key, C);
+      buffer_append_string_len(dc->comp_key, CONST_STR_LEN("\"]"));
+      dc->cond = E;
+
+      for (i = 0; comps[i].comp_key; i ++) {
+        if (buffer_is_equal_string(
+              dc->comp_key, comps[i].comp_key, comps[i].len)) {
+          dc->comp = comps[i].comp;
+          break;
+        }
+      }
+      if (COMP_UNSET == dc->comp) {
+        if (buffer_is_equal_string(B, CONST_STR_LEN("REQUEST_HEADER"))) {
+          dc->comp = COMP_HTTP_REQUEST_HEADER;
+        }
+        else {
+          fprintf(stderr, "error comp_key %s", dc->comp_key->ptr);
+          ctx->ok = 0;
+        }
+      }
+      else if (COMP_HTTP_LANGUAGE == dc->comp) {
+        dc->comp = COMP_HTTP_REQUEST_HEADER;
+        buffer_copy_string_len(dc->comp_tag, CONST_STR_LEN("Accept-Language"));
+      }
+      else if (COMP_HTTP_USER_AGENT == dc->comp) {
+        dc->comp = COMP_HTTP_REQUEST_HEADER;
+        buffer_copy_string_len(dc->comp_tag, CONST_STR_LEN("User-Agent"));
+      }
+      else if (COMP_HTTP_REMOTE_IP == dc->comp
+               && (dc->cond == CONFIG_COND_EQ || dc->cond == CONFIG_COND_NE)) {
+        char * const slash = strchr(rvalue->ptr, '/'); /* CIDR mask */
+        char * const colon = strchr(rvalue->ptr, ':'); /* IPv6 */
+        if (NULL != slash && slash == rvalue->ptr){/*(skip AF_UNIX /path/file)*/
+        }
+        else if (NULL != slash) {
+          char *nptr;
+          const unsigned long nm_bits = strtoul(slash + 1, &nptr, 10);
+          if (*nptr || 0 == nm_bits || nm_bits > (NULL != colon ? 128 : 32)) {
+            /*(also rejects (slash+1 == nptr) which results in nm_bits = 0)*/
+            fprintf(stderr, "invalid or missing netmask: %s\n", rvalue->ptr);
+            ctx->ok = 0;
+          }
+          else {
+            int rc;
+            buffer_string_set_length(rvalue, (size_t)(slash - rvalue->ptr)); /*(truncate)*/
+            rc = (NULL == colon)
+              ? http_request_host_normalize(rvalue, 0)
+              : configparser_remoteip_normalize_compat(rvalue);
+            buffer_append_string_len(rvalue, CONST_STR_LEN("/"));
+            buffer_append_int(rvalue, (int)nm_bits);
+            if (0 != rc) {
+              fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
+              ctx->ok = 0;
+            }
+          }
+        }
+        else {
+          int rc = (NULL == colon)
+            ? http_request_host_normalize(rvalue, 0)
+            : configparser_remoteip_normalize_compat(rvalue);
+          if (0 != rc) {
+            fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
+            ctx->ok = 0;
+          }
+        }
+      }
+      else if (COMP_SERVER_SOCKET == dc->comp) {
+        /*(redundant with parsing in network.c; not actually required here)*/
+        if (rvalue->ptr[0] != ':' /*(network.c special-cases ":" and "[]")*/
+            && !(rvalue->ptr[0] == '[' && rvalue->ptr[1] == ']')) {
+          if (http_request_host_normalize(rvalue, 0)) {
+            fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
+            ctx->ok = 0;
+          }
+        }
+      }
+      else if (COMP_HTTP_HOST == dc->comp) {
+        if (dc->cond == CONFIG_COND_EQ || dc->cond == CONFIG_COND_NE) {
+          if (http_request_host_normalize(rvalue, 0)) {
+            fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
+            ctx->ok = 0;
+          }
+        }
+      }
+
+      dc->string = buffer_init_buffer(rvalue);
+
+      if (ctx->ok) switch(E) {
+      case CONFIG_COND_NE:
+      case CONFIG_COND_EQ:
+        break;
+      case CONFIG_COND_NOMATCH:
+      case CONFIG_COND_MATCH: {
+        if (!data_config_pcre_compile(dc)) {
+          ctx->ok = 0;
+        }
+        break;
+      }
+
+      default:
+        fprintf(stderr, "unknown condition for $%s[%s]\n",
+                        B->ptr, C->ptr);
+        ctx->ok = 0;
+        break;
+      }
+
+      if (ctx->ok) {
+        configparser_push(ctx, dc, 1);
+      } else {
+        dc->fn->free((data_unset*) dc);
+      }
+    }
+  }
+
+  buffer_free(b);
+  buffer_free(op);
+  buffer_free(B);
+  B = NULL;
+  buffer_free(C);
+  C = NULL;
+  if (D) D->fn->free(D);
+  D = NULL;
+}
+
+context_else ::= . {
+  if (ctx->ok) {
+    data_config *dc = data_config_init();
+    buffer_copy_buffer(dc->key, ctx->current->key);
+    buffer_append_string_len(dc->key, CONST_STR_LEN("/"));
+    buffer_append_string_len(dc->key, CONST_STR_LEN("else_tmp_token"));
+    dc->cond = CONFIG_COND_ELSE;
+    configparser_push(ctx, dc, 1);
+  }
+}
+
+cond(A) ::= EQ. {
+  A = CONFIG_COND_EQ;
+}
+cond(A) ::= MATCH. {
+  A = CONFIG_COND_MATCH;
+}
+cond(A) ::= NE. {
+  A = CONFIG_COND_NE;
+}
+cond(A) ::= NOMATCH. {
+  A = CONFIG_COND_NOMATCH;
+}
+
+stringop(A) ::= expression(B). {
+  A = NULL;
+  if (ctx->ok) {
+    if (B->type == TYPE_STRING) {
+      A = ((data_string*)B)->value;
+      ((data_string*)B)->value = NULL;
+    } else if (B->type == TYPE_INTEGER) {
+      A = buffer_init();
+      buffer_copy_int(A, ((data_integer *)B)->value);
+    } else {
+      fprintf(stderr, "operand must be string");
+      ctx->ok = 0;
+    }
+  }
+  if (B) B->fn->free(B);
+  B = NULL;
+}
+
+include ::= INCLUDE stringop(A). {
+  if (ctx->ok) {
+    if (0 != config_parse_file(ctx->srv, ctx, A->ptr)) {
+      ctx->ok = 0;
+    }
+  }
+  buffer_free(A);
+  A = NULL;
+}
+
+include_shell ::= INCLUDE_SHELL stringop(A). {
+  if (ctx->ok) {
+    if (0 != config_parse_cmd(ctx->srv, ctx, A->ptr)) {
+      ctx->ok = 0;
+    }
+  }
+  buffer_free(A);
+  A = NULL;
+}