src/configparser.y

   1 %token_prefix TK_
   2 %extra_argument {config_t *ctx}
   3 %name configparser
   4
   5 %include {
   6 #include "first.h"
   7 #include "configfile.h"
   8 #include "buffer.h"
   9 #include "array.h"
  10 #include "request.h" /* http_request_host_normalize() */
  11
  12 #include <assert.h>
  13 #include <ctype.h>
  14 #include <errno.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17
  18 static void configparser_push(config_t *ctx, data_config *dc, int isnew) {
  19   if (isnew) {
  20     dc->context_ndx = ctx->all_configs->used;
  21     force_assert(dc->context_ndx > ctx->current->context_ndx);
  22     array_insert_unique(ctx->all_configs, (data_unset *)dc);
  23     dc->parent = ctx->current;
  24     vector_config_weak_push(&dc->parent->children, dc);
  25   }
  26   if (ctx->configs_stack.used > 0 && ctx->current->context_ndx == 0) {
  27     fprintf(stderr, "Cannot use conditionals inside a global { ... } block\n");
  28     exit(-1);
  29   }
  30   vector_config_weak_push(&ctx->configs_stack, ctx->current);
  31   ctx->current = dc;
  32 }
  33
  34 static data_config *configparser_pop(config_t *ctx) {
  35   data_config *old = ctx->current;
  36   ctx->current = vector_config_weak_pop(&ctx->configs_stack);
  37   return old;
  38 }
  39
  40 /* return a copied variable */
  41 static data_unset *configparser_get_variable(config_t *ctx, const buffer *key) {
  42   data_unset *du;
  43   data_config *dc;
  44
  45 #if 0
  46   fprintf(stderr, "get var %s\n", key->ptr);
  47 #endif
  48   for (dc = ctx->current; dc; dc = dc->parent) {
  49 #if 0
  50     fprintf(stderr, "get var on block: %s\n", dc->key->ptr);
  51     array_print(dc->value, 0);
  52 #endif
  53     if (NULL != (du = array_get_element(dc->value, key->ptr))) {
  54       return du->copy(du);
  55     }
  56   }
  57   return NULL;
  58 }
  59
  60 /* op1 is to be eat/return by this function if success, op1->key is not cared
  61    op2 is left untouch, unreferenced
  62  */
  63 data_unset *configparser_merge_data(data_unset *op1, const data_unset *op2) {
  64   /* type mismatch */
  65   if (op1->type != op2->type) {
  66     if (op1->type == TYPE_STRING && op2->type == TYPE_INTEGER) {
  67       data_string *ds = (data_string *)op1;
  68       buffer_append_int(ds->value, ((data_integer*)op2)->value);
  69       return op1;
  70     } else if (op1->type == TYPE_INTEGER && op2->type == TYPE_STRING) {
  71       data_string *ds = data_string_init();
  72       buffer_append_int(ds->value, ((data_integer*)op1)->value);
  73       buffer_append_string_buffer(ds->value, ((data_string*)op2)->value);
  74       op1->free(op1);
  75       return (data_unset *)ds;
  76     } else {
  77       fprintf(stderr, "data type mismatch, cannot merge\n");
  78       op1->free(op1);
  79       return NULL;
  80     }
  81   }
  82
  83   switch (op1->type) {
  84     case TYPE_STRING:
  85       buffer_append_string_buffer(((data_string *)op1)->value, ((data_string *)op2)->value);
  86       break;
  87     case TYPE_INTEGER:
  88       ((data_integer *)op1)->value += ((data_integer *)op2)->value;
  89       break;
  90     case TYPE_ARRAY: {
  91       array *dst = ((data_array *)op1)->value;
  92       array *src = ((data_array *)op2)->value;
  93       data_unset *du;
  94       size_t i;
  95
  96       for (i = 0; i < src->used; i ++) {
  97         du = (data_unset *)src->data[i];
  98         if (du) {
  99           if (du->is_index_key || buffer_is_empty(du->key) || !array_get_element(dst, du->key->ptr)) {
 100             array_insert_unique(dst, du->copy(du));
 101           } else {
 102             fprintf(stderr, "Duplicate array-key '%s'\n", du->key->ptr);
 103             op1->free(op1);
 104             return NULL;
 105           }
 106         }
 107       }
 108       break;
 109     default:
 110       force_assert(0);
 111       break;
 112     }
 113   }
 114   return op1;
 115 }
 116
 117 static int configparser_remoteip_normalize_compat(buffer *rvalue) {
 118   /* $HTTP["remoteip"] IPv6 accepted with or without '[]' for config compat
 119    * http_request_host_normalize() expects IPv6 with '[]',
 120    * and config processing at runtime expects COMP_HTTP_REMOTE_IP
 121    * compared without '[]', so strip '[]' after normalization */
 122   buffer *b = buffer_init();
 123   int rc;
 124
 125   if (rvalue->ptr[0] != '[') {
 126       buffer_append_string_len(b, CONST_STR_LEN("["));
 127       buffer_append_string_buffer(b, rvalue);
 128       buffer_append_string_len(b, CONST_STR_LEN("]"));
 129   } else {
 130       buffer_append_string_buffer(b, rvalue);
 131   }
 132
 133   rc = http_request_host_normalize(b);
 134
 135   if (0 == rc) {
 136     /* remove surrounding '[]' */
 137     size_t blen = buffer_string_length(b);
 138     if (blen > 1) buffer_copy_string_len(rvalue, b->ptr+1, blen-2);
 139   }
 140
 141   buffer_free(b);
 142   return rc;
 143 }
 144
 145 }
 146
 147 %parse_failure {
 148   ctx->ok = 0;
 149 }
 150
 151 input ::= metalines.
 152 metalines ::= metalines metaline.
 153 metalines ::= .
 154 metaline ::= varline.
 155 metaline ::= global.
 156 metaline ::= condlines(A) EOL. { A = NULL; }
 157 metaline ::= include.
 158 metaline ::= include_shell.
 159 metaline ::= EOL.
 160
 161 %type       value                  {data_unset *}
 162 %type       expression             {data_unset *}
 163 %type       aelement               {data_unset *}
 164 %type       condline               {data_config *}
 165 %type       cond_else              {data_config *}
 166 %type       condlines              {data_config *}
 167 %type       aelements              {array *}
 168 %type       array                  {array *}
 169 %type       key                    {buffer *}
 170 %type       stringop               {buffer *}
 171
 172 %type       cond                   {config_cond_t }
 173
 174 %destructor value                  { if ($$) $$->free($$); }
 175 %destructor expression             { if ($$) $$->free($$); }
 176 %destructor aelement               { if ($$) $$->free($$); }
 177 %destructor aelements              { array_free($$); }
 178 %destructor array                  { array_free($$); }
 179 %destructor key                    { buffer_free($$); }
 180 %destructor stringop               { buffer_free($$); }
 181
 182 %token_type                        {buffer *}
 183 %token_destructor                  { buffer_free($$); }
 184
 185 varline ::= key(A) ASSIGN expression(B). {
 186   if (ctx->ok) {
 187     buffer_copy_buffer(B->key, A);
 188     if (strncmp(A->ptr, "env.", sizeof("env.") - 1) == 0) {
 189       fprintf(stderr, "Setting env variable is not supported in conditional %d %s: %s\n",
 190           ctx->current->context_ndx,
 191           ctx->current->key->ptr, A->ptr);
 192       ctx->ok = 0;
 193     } else if (NULL == array_get_element(ctx->current->value, B->key->ptr)) {
 194       array_insert_unique(ctx->current->value, B);
 195       B = NULL;
 196     } else {
 197       fprintf(stderr, "Duplicate config variable in conditional %d %s: %s\n",
 198               ctx->current->context_ndx,
 199               ctx->current->key->ptr, B->key->ptr);
 200       ctx->ok = 0;
 201       B->free(B);
 202       B = NULL;
 203     }
 204   }
 205   buffer_free(A);
 206   A = NULL;
 207 }
 208
 209 varline ::= key(A) APPEND expression(B). {
 210   if (ctx->ok) {
 211     array *vars = ctx->current->value;
 212     data_unset *du;
 213
 214     if (strncmp(A->ptr, "env.", sizeof("env.") - 1) == 0) {
 215       fprintf(stderr, "Appending env variable is not supported in conditional %d %s: %s\n",
 216           ctx->current->context_ndx,
 217           ctx->current->key->ptr, A->ptr);
 218       ctx->ok = 0;
 219     } else if (NULL != (du = array_extract_element(vars, A->ptr)) || NULL != (du = configparser_get_variable(ctx, A))) {
 220       du = configparser_merge_data(du, B);
 221       if (NULL == du) {
 222         ctx->ok = 0;
 223       }
 224       else {
 225         buffer_copy_buffer(du->key, A);
 226         array_insert_unique(ctx->current->value, du);
 227       }
 228       B->free(B);
 229     } else {
 230       buffer_copy_buffer(B->key, A);
 231       array_insert_unique(ctx->current->value, B);
 232     }
 233     buffer_free(A);
 234     A = NULL;
 235     B = NULL;
 236   }
 237 }
 238
 239 key(A) ::= LKEY(B). {
 240   if (strchr(B->ptr, '.') == NULL) {
 241     A = buffer_init_string("var.");
 242     buffer_append_string_buffer(A, B);
 243     buffer_free(B);
 244     B = NULL;
 245   } else {
 246     A = B;
 247     B = NULL;
 248   }
 249 }
 250
 251 expression(A) ::= expression(B) PLUS value(C). {
 252   A = NULL;
 253   if (ctx->ok) {
 254     A = configparser_merge_data(B, C);
 255     if (NULL == A) {
 256       ctx->ok = 0;
 257     }
 258     B = NULL;
 259     C->free(C);
 260     C = NULL;
 261   }
 262 }
 263
 264 expression(A) ::= value(B). {
 265   A = B;
 266   B = NULL;
 267 }
 268
 269 value(A) ::= key(B). {
 270   A = NULL;
 271   if (ctx->ok) {
 272     if (strncmp(B->ptr, "env.", sizeof("env.") - 1) == 0) {
 273       char *env;
 274
 275       if (NULL != (env = getenv(B->ptr + 4))) {
 276         data_string *ds;
 277         ds = data_string_init();
 278         buffer_append_string(ds->value, env);
 279         A = (data_unset *)ds;
 280       }
 281       else {
 282         fprintf(stderr, "Undefined env variable: %s\n", B->ptr + 4);
 283         ctx->ok = 0;
 284       }
 285     } else if (NULL == (A = configparser_get_variable(ctx, B))) {
 286       fprintf(stderr, "Undefined config variable: %s\n", B->ptr);
 287       ctx->ok = 0;
 288     }
 289     buffer_free(B);
 290     B = NULL;
 291   }
 292 }
 293
 294 value(A) ::= STRING(B). {
 295   A = (data_unset *)data_string_init();
 296   buffer_copy_buffer(((data_string *)(A))->value, B);
 297   buffer_free(B);
 298   B = NULL;
 299 }
 300
 301 value(A) ::= INTEGER(B). {
 302   char *endptr;
 303   A = (data_unset *)data_integer_init();
 304   errno = 0;
 305   ((data_integer *)(A))->value = strtol(B->ptr, &endptr, 10);
 306   /* skip trailing whitespace */
 307   if (endptr != B->ptr) while (isspace(*endptr)) endptr++;
 308   if (0 != errno || *endptr != '\0') {
 309     fprintf(stderr, "error parsing number: '%s'\n", B->ptr);
 310     ctx->ok = 0;
 311   }
 312   buffer_free(B);
 313   B = NULL;
 314 }
 315 value(A) ::= array(B). {
 316   A = (data_unset *)data_array_init();
 317   array_free(((data_array *)(A))->value);
 318   ((data_array *)(A))->value = B;
 319   B = NULL;
 320 }
 321 array(A) ::= LPARAN RPARAN. {
 322   A = array_init();
 323 }
 324 array(A) ::= LPARAN aelements(B) RPARAN. {
 325   A = B;
 326   B = NULL;
 327 }
 328
 329 aelements(A) ::= aelements(C) COMMA aelement(B). {
 330   A = NULL;
 331   if (ctx->ok) {
 332     if (buffer_is_empty(B->key) ||
 333         NULL == array_get_element(C, B->key->ptr)) {
 334       array_insert_unique(C, B);
 335       B = NULL;
 336     } else {
 337       fprintf(stderr, "Error: duplicate array-key: %s. Please get rid of the duplicate entry.\n",
 338               B->key->ptr);
 339       ctx->ok = 0;
 340       B->free(B);
 341       B = NULL;
 342     }
 343
 344     A = C;
 345     C = NULL;
 346   }
 347 }
 348
 349 aelements(A) ::= aelements(C) COMMA. {
 350   A = C;
 351   C = NULL;
 352 }
 353
 354 aelements(A) ::= aelement(B). {
 355   A = NULL;
 356   if (ctx->ok) {
 357     A = array_init();
 358     array_insert_unique(A, B);
 359     B = NULL;
 360   }
 361 }
 362
 363 aelement(A) ::= expression(B). {
 364   A = B;
 365   B = NULL;
 366 }
 367 aelement(A) ::= stringop(B) ARRAY_ASSIGN expression(C). {
 368   A = NULL;
 369   if (ctx->ok) {
 370     buffer_copy_buffer(C->key, B);
 371     buffer_free(B);
 372     B = NULL;
 373
 374     A = C;
 375     C = NULL;
 376   }
 377 }
 378
 379 eols ::= EOL.
 380 eols ::= .
 381
 382 globalstart ::= GLOBAL. {
 383   data_config *dc;
 384   dc = (data_config *)array_get_element(ctx->srv->config_context, "global");
 385   force_assert(dc);
 386   configparser_push(ctx, dc, 0);
 387 }
 388
 389 global ::= globalstart LCURLY metalines RCURLY. {
 390   force_assert(ctx->current);
 391   configparser_pop(ctx);
 392   force_assert(ctx->current);
 393 }
 394
 395 condlines(A) ::= condlines(B) eols ELSE condline(C). {
 396   A = NULL;
 397   if (ctx->ok) {
 398     if (B->context_ndx >= C->context_ndx) {
 399       fprintf(stderr, "unreachable else condition\n");
 400       ctx->ok = 0;
 401     }
 402     if (B->cond == CONFIG_COND_ELSE) {
 403       fprintf(stderr, "unreachable condition following else catch-all\n");
 404       ctx->ok = 0;
 405     }
 406     C->prev = B;
 407     B->next = C;
 408     A = C;
 409     B = NULL;
 410     C = NULL;
 411   }
 412 }
 413
 414 condlines(A) ::= condlines(B) eols ELSE cond_else(C). {
 415   A = NULL;
 416   if (ctx->ok) {
 417     if (B->context_ndx >= C->context_ndx) {
 418       fprintf(stderr, "unreachable else condition\n");
 419       ctx->ok = 0;
 420     }
 421     if (B->cond == CONFIG_COND_ELSE) {
 422       fprintf(stderr, "unreachable condition following else catch-all\n");
 423       ctx->ok = 0;
 424     }
 425   }
 426   if (ctx->ok) {
 427     size_t pos;
 428     data_config *dc;
 429     dc = (data_config *)array_extract_element(ctx->all_configs, C->key->ptr);
 430     force_assert(C == dc);
 431     buffer_copy_buffer(C->key, B->key);
 432     /*buffer_copy_buffer(C->comp_key, B->comp_key);*/
 433     /*C->string = buffer_init_buffer(B->string);*/
 434     pos = buffer_string_length(C->key)-buffer_string_length(B->string)-2;
 435     switch(B->cond) {
 436     case CONFIG_COND_NE:
 437       C->key->ptr[pos] = '='; /* opposite cond */
 438       /*buffer_copy_string_len(C->op, CONST_STR_LEN("=="));*/
 439       break;
 440     case CONFIG_COND_EQ:
 441       C->key->ptr[pos] = '!'; /* opposite cond */
 442       /*buffer_copy_string_len(C->op, CONST_STR_LEN("!="));*/
 443       break;
 444     case CONFIG_COND_NOMATCH:
 445       C->key->ptr[pos] = '='; /* opposite cond */
 446       /*buffer_copy_string_len(C->op, CONST_STR_LEN("=~"));*/
 447       break;
 448     case CONFIG_COND_MATCH:
 449       C->key->ptr[pos] = '!'; /* opposite cond */
 450       /*buffer_copy_string_len(C->op, CONST_STR_LEN("!~"));*/
 451       break;
 452     default: /* should not happen; CONFIG_COND_ELSE checked further above */
 453       force_assert(0);
 454     }
 455
 456     if (NULL == (dc = (data_config *)array_get_element(ctx->all_configs, C->key->ptr))) {
 457       /* re-insert into ctx->all_configs with new C->key */
 458       array_insert_unique(ctx->all_configs, (data_unset *)C);
 459       C->prev = B;
 460       B->next = C;
 461     } else {
 462       fprintf(stderr, "unreachable else condition\n");
 463       ctx->ok = 0;
 464       C->free((data_unset *)C);
 465       C = dc;
 466     }
 467
 468     A = C;
 469     B = NULL;
 470     C = NULL;
 471   }
 472 }
 473
 474 condlines(A) ::= condline(B). {
 475   A = B;
 476   B = NULL;
 477 }
 478
 479 condline(A) ::= context LCURLY metalines RCURLY. {
 480   A = NULL;
 481   if (ctx->ok) {
 482     data_config *cur;
 483
 484     cur = ctx->current;
 485     configparser_pop(ctx);
 486
 487     force_assert(cur && ctx->current);
 488
 489     A = cur;
 490   }
 491 }
 492
 493 cond_else(A) ::= context_else LCURLY metalines RCURLY. {
 494   A = NULL;
 495   if (ctx->ok) {
 496     data_config *cur;
 497
 498     cur = ctx->current;
 499     configparser_pop(ctx);
 500
 501     force_assert(cur && ctx->current);
 502
 503     A = cur;
 504   }
 505 }
 506
 507 context ::= DOLLAR SRVVARNAME(B) LBRACKET stringop(C) RBRACKET cond(E) expression(D). {
 508   data_config *dc;
 509   buffer *b, *rvalue, *op;
 510
 511   if (ctx->ok && D->type != TYPE_STRING) {
 512     fprintf(stderr, "rvalue must be string");
 513     ctx->ok = 0;
 514   }
 515
 516   if (ctx->ok) {
 517     switch(E) {
 518     case CONFIG_COND_NE:
 519       op = buffer_init_string("!=");
 520       break;
 521     case CONFIG_COND_EQ:
 522       op = buffer_init_string("==");
 523       break;
 524     case CONFIG_COND_NOMATCH:
 525       op = buffer_init_string("!~");
 526       break;
 527     case CONFIG_COND_MATCH:
 528       op = buffer_init_string("=~");
 529       break;
 530     default:
 531       force_assert(0);
 532       return; /* unreachable */
 533     }
 534
 535     b = buffer_init();
 536     buffer_copy_buffer(b, ctx->current->key);
 537     buffer_append_string(b, "/");
 538     buffer_append_string_buffer(b, B);
 539     buffer_append_string_buffer(b, C);
 540     buffer_append_string_buffer(b, op);
 541     rvalue = ((data_string*)D)->value;
 542     buffer_append_string_buffer(b, rvalue);
 543
 544     if (NULL != (dc = (data_config *)array_get_element(ctx->all_configs, b->ptr))) {
 545       configparser_push(ctx, dc, 0);
 546     } else {
 547       static const struct {
 548         comp_key_t comp;
 549         char *comp_key;
 550         size_t len;
 551       } comps[] = {
 552         { COMP_SERVER_SOCKET,      CONST_STR_LEN("SERVER[\"socket\"]"   ) },
 553         { COMP_HTTP_URL,           CONST_STR_LEN("HTTP[\"url\"]"        ) },
 554         { COMP_HTTP_HOST,          CONST_STR_LEN("HTTP[\"host\"]"       ) },
 555         { COMP_HTTP_REFERER,       CONST_STR_LEN("HTTP[\"referer\"]"    ) },
 556         { COMP_HTTP_USER_AGENT,    CONST_STR_LEN("HTTP[\"useragent\"]"  ) },
 557         { COMP_HTTP_USER_AGENT,    CONST_STR_LEN("HTTP[\"user-agent\"]"  ) },
 558         { COMP_HTTP_LANGUAGE,      CONST_STR_LEN("HTTP[\"language\"]"   ) },
 559         { COMP_HTTP_COOKIE,        CONST_STR_LEN("HTTP[\"cookie\"]"     ) },
 560         { COMP_HTTP_REMOTE_IP,     CONST_STR_LEN("HTTP[\"remoteip\"]"   ) },
 561         { COMP_HTTP_REMOTE_IP,     CONST_STR_LEN("HTTP[\"remote-ip\"]"   ) },
 562         { COMP_HTTP_QUERY_STRING,  CONST_STR_LEN("HTTP[\"querystring\"]") },
 563         { COMP_HTTP_QUERY_STRING,  CONST_STR_LEN("HTTP[\"query-string\"]") },
 564         { COMP_HTTP_REQUEST_METHOD, CONST_STR_LEN("HTTP[\"request-method\"]") },
 565         { COMP_HTTP_SCHEME,        CONST_STR_LEN("HTTP[\"scheme\"]"     ) },
 566         { COMP_UNSET, NULL, 0 },
 567       };
 568       size_t i;
 569
 570       dc = data_config_init();
 571
 572       buffer_copy_buffer(dc->key, b);
 573       buffer_copy_buffer(dc->op, op);
 574       buffer_copy_buffer(dc->comp_key, B);
 575       buffer_append_string_len(dc->comp_key, CONST_STR_LEN("[\""));
 576       buffer_append_string_buffer(dc->comp_key, C);
 577       buffer_append_string_len(dc->comp_key, CONST_STR_LEN("\"]"));
 578       dc->cond = E;
 579
 580       for (i = 0; comps[i].comp_key; i ++) {
 581         if (buffer_is_equal_string(
 582               dc->comp_key, comps[i].comp_key, comps[i].len)) {
 583           dc->comp = comps[i].comp;
 584           break;
 585         }
 586       }
 587       if (COMP_UNSET == dc->comp) {
 588         fprintf(stderr, "error comp_key %s", dc->comp_key->ptr);
 589         ctx->ok = 0;
 590       }
 591       else if (COMP_HTTP_REMOTE_IP == dc->comp
 592                && (dc->cond == CONFIG_COND_EQ || dc->cond == CONFIG_COND_NE)) {
 593         char * const slash = strchr(rvalue->ptr, '/'); /* CIDR mask */
 594         char * const colon = strchr(rvalue->ptr, ':'); /* IPv6 */
 595         if (NULL != slash && slash == rvalue->ptr){/*(skip AF_UNIX /path/file)*/
 596         }
 597         else if (NULL != slash) {
 598           char *nptr;
 599           const unsigned long nm_bits = strtoul(slash + 1, &nptr, 10);
 600           if (*nptr || 0 == nm_bits || nm_bits > (NULL != colon ? 128 : 32)) {
 601             /*(also rejects (slash+1 == nptr) which results in nm_bits = 0)*/
 602             fprintf(stderr, "invalid or missing netmask: %s\n", rvalue->ptr);
 603             ctx->ok = 0;
 604           }
 605           else {
 606             int rc;
 607             buffer_string_set_length(rvalue, (size_t)(slash - rvalue->ptr)); /*(truncate)*/
 608             rc = (NULL == colon)
 609               ? http_request_host_normalize(rvalue)
 610               : configparser_remoteip_normalize_compat(rvalue);
 611             buffer_append_string_len(rvalue, CONST_STR_LEN("/"));
 612             buffer_append_int(rvalue, (int)nm_bits);
 613             if (0 != rc) {
 614               fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
 615               ctx->ok = 0;
 616             }
 617           }
 618         }
 619         else {
 620           int rc = (NULL == colon)
 621             ? http_request_host_normalize(rvalue)
 622             : configparser_remoteip_normalize_compat(rvalue);
 623           if (0 != rc) {
 624             fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
 625             ctx->ok = 0;
 626           }
 627         }
 628       }
 629       else if (COMP_SERVER_SOCKET == dc->comp) {
 630         /*(redundant with parsing in network.c; not actually required here)*/
 631         if (rvalue->ptr[0] != ':' /*(network.c special-cases ":" and "[]")*/
 632             && !(rvalue->ptr[0] == '[' && rvalue->ptr[1] == ']')) {
 633           if (http_request_host_normalize(rvalue)) {
 634             fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
 635             ctx->ok = 0;
 636           }
 637         }
 638       }
 639       else if (COMP_HTTP_HOST == dc->comp) {
 640         if (dc->cond == CONFIG_COND_EQ || dc->cond == CONFIG_COND_NE) {
 641           if (http_request_host_normalize(rvalue)) {
 642             fprintf(stderr, "invalid IP addr: %s\n", rvalue->ptr);
 643             ctx->ok = 0;
 644           }
 645         }
 646       }
 647
 648       if (ctx->ok) switch(E) {
 649       case CONFIG_COND_NE:
 650       case CONFIG_COND_EQ:
 651         dc->string = buffer_init_buffer(rvalue);
 652         break;
 653       case CONFIG_COND_NOMATCH:
 654       case CONFIG_COND_MATCH: {
 655 #ifdef HAVE_PCRE_H
 656         const char *errptr;
 657         int erroff, captures;
 658
 659         if (NULL == (dc->regex =
 660             pcre_compile(rvalue->ptr, 0, &errptr, &erroff, NULL))) {
 661           dc->string = buffer_init_string(errptr);
 662           dc->cond = CONFIG_COND_UNSET;
 663
 664           fprintf(stderr, "parsing regex failed: %s -> %s at offset %d\n",
 665               rvalue->ptr, errptr, erroff);
 666
 667           ctx->ok = 0;
 668         } else if (NULL == (dc->regex_study =
 669             pcre_study(dc->regex, 0, &errptr)) &&
 670                    errptr != NULL) {
 671           fprintf(stderr, "studying regex failed: %s -> %s\n",
 672               rvalue->ptr, errptr);
 673           ctx->ok = 0;
 674         } else if (0 != (pcre_fullinfo(dc->regex, dc->regex_study, PCRE_INFO_CAPTURECOUNT, &captures))) {
 675           fprintf(stderr, "getting capture count for regex failed: %s\n",
 676               rvalue->ptr);
 677           ctx->ok = 0;
 678         } else if (captures > 9) {
 679           fprintf(stderr, "Too many captures in regex, use (?:...) instead of (...): %s\n",
 680               rvalue->ptr);
 681           ctx->ok = 0;
 682         } else {
 683           dc->string = buffer_init_buffer(rvalue);
 684         }
 685 #else
 686         fprintf(stderr, "can't handle '$%s[%s] =~ ...' as you compiled without pcre support. \n"
 687                         "(perhaps just a missing pcre-devel package ?) \n",
 688                         B->ptr, C->ptr);
 689         ctx->ok = 0;
 690  #endif
 691         break;
 692       }
 693
 694       default:
 695         fprintf(stderr, "unknown condition for $%s[%s]\n",
 696                         B->ptr, C->ptr);
 697         ctx->ok = 0;
 698         break;
 699       }
 700
 701       if (ctx->ok) {
 702         configparser_push(ctx, dc, 1);
 703       } else {
 704         dc->free((data_unset*) dc);
 705       }
 706     }
 707
 708     buffer_free(b);
 709     buffer_free(op);
 710     buffer_free(B);
 711     B = NULL;
 712     buffer_free(C);
 713     C = NULL;
 714     D->free(D);
 715     D = NULL;
 716   }
 717 }
 718
 719 context_else ::= . {
 720   if (ctx->ok) {
 721     data_config *dc = data_config_init();
 722     buffer_copy_buffer(dc->key, ctx->current->key);
 723     buffer_append_string_len(dc->key, CONST_STR_LEN("/"));
 724     buffer_append_string_len(dc->key, CONST_STR_LEN("else_tmp_token"));
 725     dc->cond = CONFIG_COND_ELSE;
 726     configparser_push(ctx, dc, 1);
 727   }
 728 }
 729
 730 cond(A) ::= EQ. {
 731   A = CONFIG_COND_EQ;
 732 }
 733 cond(A) ::= MATCH. {
 734   A = CONFIG_COND_MATCH;
 735 }
 736 cond(A) ::= NE. {
 737   A = CONFIG_COND_NE;
 738 }
 739 cond(A) ::= NOMATCH. {
 740   A = CONFIG_COND_NOMATCH;
 741 }
 742
 743 stringop(A) ::= expression(B). {
 744   A = NULL;
 745   if (ctx->ok) {
 746     if (B->type == TYPE_STRING) {
 747       A = buffer_init_buffer(((data_string*)B)->value);
 748     } else if (B->type == TYPE_INTEGER) {
 749       A = buffer_init();
 750       buffer_copy_int(A, ((data_integer *)B)->value);
 751     } else {
 752       fprintf(stderr, "operand must be string");
 753       ctx->ok = 0;
 754     }
 755   }
 756   B->free(B);
 757   B = NULL;
 758 }
 759
 760 include ::= INCLUDE stringop(A). {
 761   if (ctx->ok) {
 762     if (0 != config_parse_file(ctx->srv, ctx, A->ptr)) {
 763       ctx->ok = 0;
 764     }
 765     buffer_free(A);
 766     A = NULL;
 767   }
 768 }
 769
 770 include_shell ::= INCLUDE_SHELL stringop(A). {
 771   if (ctx->ok) {
 772     if (0 != config_parse_cmd(ctx->srv, ctx, A->ptr)) {
 773       ctx->ok = 0;
 774     }
 775     buffer_free(A);
 776     A = NULL;
 777   }
 778 }