granicus.if.org Git - apache/blob - modules/metadata/mod_setenvif.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * mod_setenvif.c
  19  * Set environment variables based on matching request headers or
  20  * attributes against regex strings
  21  *
  22  * Paul Sutton <paul@ukweb.com> 27 Oct 1996
  23  * Based on mod_browser by Alexei Kosut <akosut@organic.com>
  24  */
  25
  26 /*
  27  * Used to set environment variables based on the incoming request headers,
  28  * or some selected other attributes of the request (e.g., the remote host
  29  * name).
  30  *
  31  * Usage:
  32  *
  33  *   SetEnvIf name regex var ...
  34  *
  35  * where name is either a HTTP request header name, or one of the
  36  * special values (see below). 'name' may be a regex when it is used
  37  * to specify an HTTP request header name. The 'value' of the header
  38  & (or the value of the special value from below) are compared against
  39  * the regex argument. If this is a simple string, a simple sub-string
  40  * match is performed. Otherwise, a request expression match is
  41  * done. If the value matches the string or regular expression, the
  42  * environment variables listed as var ... are set. Each var can
  43  * be in one of three formats: var, which sets the named variable
  44  * (the value value "1"); var=value, which sets the variable to
  45  * the given value; or !var, which unsets the variable is it has
  46  * been previously set.
  47  *
  48  * Normally the strings are compared with regard to case. To ignore
  49  * case, use the directive SetEnvIfNoCase instead.
  50  *
  51  * Special values for 'name' are:
  52  *
  53  *   server_addr        IP address of interface on which request arrived
  54  *                      (analogous to SERVER_ADDR set in ap_add_common_vars())
  55  *   remote_host        Remote host name (if available)
  56  *   remote_addr        Remote IP address
  57  *   request_method     Request method (GET, POST, etc)
  58  *   request_uri        Requested URI
  59  *
  60  * Examples:
  61  *
  62  * To set the environment variable LOCALHOST if the client is the local
  63  * machine:
  64  *
  65  *    SetEnvIf remote_addr 127.0.0.1 LOCALHOST
  66  *
  67  * To set LOCAL if the client is the local host, or within our company's
  68  * domain (192.168.10):
  69  *
  70  *    SetEnvIf remote_addr 192.168.10. LOCAL
  71  *    SetEnvIf remote_addr 127.0.0.1   LOCALHOST
  72  *
  73  * This could be written as:
  74  *
  75  *    SetEnvIf remote_addr (127.0.0.1|192.168.10.) LOCAL
  76  *
  77  * To set HAVE_TS if the client request contains any header beginning
  78  * with "TS" with a value beginning with a lower case alphabet:
  79  *
  80  *    SetEnvIf ^TS* ^[a-z].* HAVE_TS
  81  */
  82
  83 #include "apr.h"
  84 #include "apr_strings.h"
  85 #include "apr_strmatch.h"
  86
  87 #define APR_WANT_STRFUNC
  88 #include "apr_want.h"
  89
  90 #include "ap_config.h"
  91 #include "httpd.h"
  92 #include "http_config.h"
  93 #include "http_core.h"
  94 #include "http_log.h"
  95 #include "http_protocol.h"
  96
  97 enum special {
  98     SPECIAL_NOT,
  99     SPECIAL_REMOTE_ADDR,
 100     SPECIAL_REMOTE_HOST,
 101     SPECIAL_REQUEST_URI,
 102     SPECIAL_REQUEST_METHOD,
 103     SPECIAL_REQUEST_PROTOCOL,
 104     SPECIAL_SERVER_ADDR
 105 };
 106 typedef struct {
 107     char *name;                 /* header name */
 108     ap_regex_t *pnamereg;       /* compiled header name regex */
 109     char *regex;                /* regex to match against */
 110     ap_regex_t *preg;           /* compiled regex */
 111     const apr_strmatch_pattern *pattern; /* non-regex pattern to match */
 112     ap_expr_info_t *expr;       /* parsed expression */
 113     apr_table_t *features;      /* env vars to set (or unset) */
 114     enum special special_type;  /* is it a "special" header ? */
 115     int icase;                  /* ignoring case? */
 116 } sei_entry;
 117
 118 typedef struct {
 119     apr_array_header_t *conditionals;
 120 } sei_cfg_rec;
 121
 122 module AP_MODULE_DECLARE_DATA setenvif_module;
 123
 124 /*
 125  * These routines, the create- and merge-config functions, are called
 126  * for both the server-wide and the per-directory contexts.  This is
 127  * because the different definitions are used at different times; the
 128  * server-wide ones are used in the post-read-request phase, and the
 129  * per-directory ones are used during the header-parse phase (after
 130  * the URI has been mapped to a file and we have anything from the
 131  * .htaccess file and <Directory> and <Files> containers).
 132  */
 133 static void *create_setenvif_config(apr_pool_t *p)
 134 {
 135     sei_cfg_rec *new = (sei_cfg_rec *) apr_palloc(p, sizeof(sei_cfg_rec));
 136
 137     new->conditionals = apr_array_make(p, 20, sizeof(sei_entry));
 138     return (void *) new;
 139 }
 140
 141 static void *create_setenvif_config_svr(apr_pool_t *p, server_rec *dummy)
 142 {
 143     return create_setenvif_config(p);
 144 }
 145
 146 static void *create_setenvif_config_dir(apr_pool_t *p, char *dummy)
 147 {
 148     return create_setenvif_config(p);
 149 }
 150
 151 static void *merge_setenvif_config(apr_pool_t *p, void *basev, void *overridesv)
 152 {
 153     sei_cfg_rec *a = apr_pcalloc(p, sizeof(sei_cfg_rec));
 154     sei_cfg_rec *base = basev, *overrides = overridesv;
 155
 156     a->conditionals = apr_array_append(p, base->conditionals,
 157                                        overrides->conditionals);
 158     return a;
 159 }
 160
 161 /*
 162  * any non-NULL magic constant will do... used to indicate if AP_REG_ICASE should
 163  * be used
 164  */
 165 #define ICASE_MAGIC  ((void *)(&setenvif_module))
 166 #define SEI_MAGIC_HEIRLOOM "setenvif-phase-flag"
 167
 168 static int is_header_regex(apr_pool_t *p, const char* name)
 169 {
 170     /* If a Header name contains characters other than:
 171      *    -,_,[A-Z\, [a-z] and [0-9].
 172      * assume the header name is a regular expression.
 173      */
 174     ap_regex_t *preg = ap_pregcomp(p, "^[-A-Za-z0-9_]*$",
 175                                    (AP_REG_EXTENDED | AP_REG_NOSUB ));
 176     ap_assert(preg != NULL);
 177
 178     if (ap_regexec(preg, name, 0, NULL, 0)) {
 179         return 1;
 180     }
 181
 182     return 0;
 183 }
 184
 185 /* If the input string does not take advantage of regular
 186  * expression metacharacters, return a pointer to an equivalent
 187  * string that can be searched using apr_strmatch().  (The
 188  * returned string will often be the input string.  But if
 189  * the input string contains escaped characters, the returned
 190  * string will be a copy with the escapes removed.)
 191  */
 192 static const char *non_regex_pattern(apr_pool_t *p, const char *s)
 193 {
 194     const char *src = s;
 195     int escapes_found = 0;
 196     int in_escape = 0;
 197
 198     while (*src) {
 199         switch (*src) {
 200         case '^':
 201         case '.':
 202         case '$':
 203         case '|':
 204         case '(':
 205         case ')':
 206         case '[':
 207         case ']':
 208         case '*':
 209         case '+':
 210         case '?':
 211         case '{':
 212         case '}':
 213             if (!in_escape) {
 214                 return NULL;
 215             }
 216             in_escape = 0;
 217             break;
 218         case '\\':
 219             if (!in_escape) {
 220                 in_escape = 1;
 221                 escapes_found = 1;
 222             }
 223             else {
 224                 in_escape = 0;
 225             }
 226             break;
 227         default:
 228             if (in_escape) {
 229                 return NULL;
 230             }
 231             break;
 232         }
 233         src++;
 234     }
 235     if (!escapes_found) {
 236         return s;
 237     }
 238     else {
 239         char *unescaped = (char *)apr_palloc(p, src - s + 1);
 240         char *dst = unescaped;
 241         src = s;
 242         do {
 243             if (*src == '\\') {
 244                 src++;
 245             }
 246         } while ((*dst++ = *src++));
 247         return unescaped;
 248     }
 249 }
 250
 251 static const char *add_envvars(cmd_parms *cmd, const char *args, sei_entry *new)
 252 {
 253     const char *feature;
 254     int beenhere = 0;
 255     char *var;
 256
 257     for ( ; ; ) {
 258         feature = ap_getword_conf(cmd->pool, &args);
 259         if (!*feature) {
 260             break;
 261         }
 262         beenhere++;
 263
 264         var = ap_getword(cmd->pool, &feature, '=');
 265         if (*feature) {
 266             apr_table_setn(new->features, var, feature);
 267         }
 268         else if (*var == '!') {
 269             apr_table_setn(new->features, var + 1, "!");
 270         }
 271         else {
 272             apr_table_setn(new->features, var, "1");
 273         }
 274     }
 275
 276     if (!beenhere) {
 277         return apr_pstrcat(cmd->pool, "Missing envariable expression for ",
 278                            cmd->cmd->name, NULL);
 279     }
 280
 281     return NULL;
 282 }
 283
 284 static const char *add_setenvif_core(cmd_parms *cmd, void *mconfig,
 285                                      char *fname, const char *args)
 286 {
 287     char *regex;
 288     const char *simple_pattern;
 289     sei_cfg_rec *sconf;
 290     sei_entry *new;
 291     sei_entry *entries;
 292     int i;
 293     int icase;
 294
 295     /*
 296      * Determine from our context into which record to put the entry.
 297      * cmd->path == NULL means we're in server-wide context; otherwise,
 298      * we're dealing with a per-directory setting.
 299      */
 300     sconf = (cmd->path != NULL)
 301       ? (sei_cfg_rec *) mconfig
 302       : (sei_cfg_rec *) ap_get_module_config(cmd->server->module_config,
 303                                                &setenvif_module);
 304     entries = (sei_entry *) sconf->conditionals->elts;
 305     /* get regex */
 306     regex = ap_getword_conf(cmd->pool, &args);
 307     if (!*regex) {
 308         return apr_pstrcat(cmd->pool, "Missing regular expression for ",
 309                            cmd->cmd->name, NULL);
 310     }
 311
 312     /*
 313      * If we've already got a sei_entry with the same name we want to
 314      * just copy the name pointer... so that later on we can compare
 315      * two header names just by comparing the pointers.
 316      */
 317     for (i = 0; i < sconf->conditionals->nelts; ++i) {
 318         new = &entries[i];
 319         if (!strcasecmp(new->name, fname)) {
 320             fname = new->name;
 321             break;
 322         }
 323     }
 324
 325     /* if the last entry has an identical headername and regex then
 326      * merge with it
 327      */
 328     i = sconf->conditionals->nelts - 1;
 329     icase = cmd->info == ICASE_MAGIC;
 330     if (i < 0
 331         || entries[i].name != fname
 332         || entries[i].icase != icase
 333         || strcmp(entries[i].regex, regex)) {
 334
 335         /* no match, create a new entry */
 336         new = apr_array_push(sconf->conditionals);
 337         new->name = fname;
 338         new->regex = regex;
 339         new->icase = icase;
 340         if ((simple_pattern = non_regex_pattern(cmd->pool, regex))) {
 341             new->pattern = apr_strmatch_precompile(cmd->pool,
 342                                                    simple_pattern, !icase);
 343             if (new->pattern == NULL) {
 344                 return apr_pstrcat(cmd->pool, cmd->cmd->name,
 345                                    " pattern could not be compiled.", NULL);
 346             }
 347             new->preg = NULL;
 348         }
 349         else {
 350             new->preg = ap_pregcomp(cmd->pool, regex,
 351                                     (AP_REG_EXTENDED | (icase ? AP_REG_ICASE : 0)));
 352             if (new->preg == NULL) {
 353                 return apr_pstrcat(cmd->pool, cmd->cmd->name,
 354                                    " regex could not be compiled.", NULL);
 355             }
 356             new->pattern = NULL;
 357         }
 358         new->features = apr_table_make(cmd->pool, 2);
 359
 360         if (!strcasecmp(fname, "remote_addr")) {
 361             new->special_type = SPECIAL_REMOTE_ADDR;
 362         }
 363         else if (!strcasecmp(fname, "remote_host")) {
 364             new->special_type = SPECIAL_REMOTE_HOST;
 365         }
 366         else if (!strcasecmp(fname, "request_uri")) {
 367             new->special_type = SPECIAL_REQUEST_URI;
 368         }
 369         else if (!strcasecmp(fname, "request_method")) {
 370             new->special_type = SPECIAL_REQUEST_METHOD;
 371         }
 372         else if (!strcasecmp(fname, "request_protocol")) {
 373             new->special_type = SPECIAL_REQUEST_PROTOCOL;
 374         }
 375         else if (!strcasecmp(fname, "server_addr")) {
 376             new->special_type = SPECIAL_SERVER_ADDR;
 377         }
 378         else {
 379             new->special_type = SPECIAL_NOT;
 380             /* Handle fname as a regular expression.
 381              * If fname a simple header string, identify as such
 382              * (new->pnamereg = NULL) to avoid the overhead of searching
 383              * through headers_in for a regex match.
 384              */
 385             if (is_header_regex(cmd->temp_pool, fname)) {
 386                 new->pnamereg = ap_pregcomp(cmd->pool, fname,
 387                                             (AP_REG_EXTENDED | AP_REG_NOSUB
 388                                              | (icase ? AP_REG_ICASE : 0)));
 389                 if (new->pnamereg == NULL)
 390                     return apr_pstrcat(cmd->pool, cmd->cmd->name,
 391                                        "Header name regex could not be "
 392                                        "compiled.", NULL);
 393             }
 394             else {
 395                 new->pnamereg = NULL;
 396             }
 397         }
 398     }
 399     else {
 400         new = &entries[i];
 401     }
 402
 403     return add_envvars(cmd, args, new);
 404 }
 405
 406 static const char *add_setenvif(cmd_parms *cmd, void *mconfig,
 407                                 const char *args)
 408 {
 409     char *fname;
 410
 411     /* get header name */
 412     fname = ap_getword_conf(cmd->pool, &args);
 413     if (!*fname) {
 414         return apr_pstrcat(cmd->pool, "Missing header-field name for ",
 415                            cmd->cmd->name, NULL);
 416     }
 417     return add_setenvif_core(cmd, mconfig, fname, args);
 418 }
 419
 420 static const char *add_setenvifexpr(cmd_parms *cmd, void *mconfig,
 421                                     const char *args)
 422 {
 423     char *expr;
 424     sei_cfg_rec *sconf;
 425     sei_entry *new;
 426     const char *err;
 427
 428     /*
 429      * Determine from our context into which record to put the entry.
 430      * cmd->path == NULL means we're in server-wide context; otherwise,
 431      * we're dealing with a per-directory setting.
 432      */
 433     sconf = (cmd->path != NULL)
 434       ? (sei_cfg_rec *) mconfig
 435       : (sei_cfg_rec *) ap_get_module_config(cmd->server->module_config,
 436                                                &setenvif_module);
 437     /* get expr */
 438     expr = ap_getword_conf(cmd->pool, &args);
 439     if (!*expr) {
 440         return apr_pstrcat(cmd->pool, "Missing expression for ",
 441                            cmd->cmd->name, NULL);
 442     }
 443
 444     new = apr_array_push(sconf->conditionals);
 445     new->features = apr_table_make(cmd->pool, 2);
 446     new->name = NULL;
 447     new->regex = NULL;
 448     new->pattern = NULL;
 449     new->preg = NULL;
 450     new->expr = ap_expr_parse_cmd(cmd, expr, 0, &err, NULL);
 451     if (err)
 452         return apr_psprintf(cmd->pool, "Could not parse expression \"%s\": %s",
 453                             expr, err);
 454
 455     return add_envvars(cmd, args, new);
 456 }
 457
 458 /*
 459  * This routine handles the BrowserMatch* directives.  It simply turns around
 460  * and feeds them, with the appropriate embellishments, to the general-purpose
 461  * command handler.
 462  */
 463 static const char *add_browser(cmd_parms *cmd, void *mconfig, const char *args)
 464 {
 465     return add_setenvif_core(cmd, mconfig, "User-Agent", args);
 466 }
 467
 468 static const command_rec setenvif_module_cmds[] =
 469 {
 470     AP_INIT_RAW_ARGS("SetEnvIf", add_setenvif, NULL, OR_FILEINFO,
 471                      "A header-name, regex and a list of variables."),
 472     AP_INIT_RAW_ARGS("SetEnvIfNoCase", add_setenvif, ICASE_MAGIC, OR_FILEINFO,
 473                      "a header-name, regex and a list of variables."),
 474     AP_INIT_RAW_ARGS("SetEnvIfExpr", add_setenvifexpr, NULL, OR_FILEINFO,
 475                      "an expression and a list of variables."),
 476     AP_INIT_RAW_ARGS("BrowserMatch", add_browser, NULL, OR_FILEINFO,
 477                      "A browser regex and a list of variables."),
 478     AP_INIT_RAW_ARGS("BrowserMatchNoCase", add_browser, ICASE_MAGIC,
 479                      OR_FILEINFO,
 480                      "A browser regex and a list of variables."),
 481     { NULL },
 482 };
 483
 484 /*
 485  * This routine gets called at two different points in request processing:
 486  * once before the URI has been translated (during the post-read-request
 487  * phase) and once after (during the header-parse phase).  We use different
 488  * config records for the two different calls to reduce overhead (by not
 489  * re-doing the server-wide settings during directory processing), and
 490  * signal which call it is by having the earlier one pass a flag to the
 491  * later one.
 492  */
 493 static int match_headers(request_rec *r)
 494 {
 495     sei_cfg_rec *sconf;
 496     sei_entry *entries;
 497     const apr_table_entry_t *elts;
 498     const char *val, *err;
 499     apr_size_t val_len = 0;
 500     int i, j;
 501     char *last_name;
 502     ap_regmatch_t regm[AP_MAX_REG_MATCH];
 503
 504     if (!ap_get_module_config(r->request_config, &setenvif_module)) {
 505         ap_set_module_config(r->request_config, &setenvif_module,
 506                              SEI_MAGIC_HEIRLOOM);
 507         sconf  = (sei_cfg_rec *) ap_get_module_config(r->server->module_config,
 508                                                       &setenvif_module);
 509     }
 510     else {
 511         sconf = (sei_cfg_rec *) ap_get_module_config(r->per_dir_config,
 512                                                      &setenvif_module);
 513     }
 514     entries = (sei_entry *) sconf->conditionals->elts;
 515     last_name = NULL;
 516     val = NULL;
 517     for (i = 0; i < sconf->conditionals->nelts; ++i) {
 518         sei_entry *b = &entries[i];
 519
 520         if (!b->expr) {
 521             /* Optimize the case where a bunch of directives in a row use the
 522              * same header.  Remember we don't need to strcmp the two header
 523              * names because we made sure the pointers were equal during
 524              * configuration.
 525              */
 526             if (b->name != last_name) {
 527                 last_name = b->name;
 528                 switch (b->special_type) {
 529                 case SPECIAL_REMOTE_ADDR:
 530                     val = r->client_ip;
 531                     break;
 532                 case SPECIAL_SERVER_ADDR:
 533                     val = r->connection->local_ip;
 534                     break;
 535                 case SPECIAL_REMOTE_HOST:
 536                     val =  ap_get_remote_host(r->connection, r->per_dir_config,
 537                                               REMOTE_NAME, NULL);
 538                     break;
 539                 case SPECIAL_REQUEST_URI:
 540                     val = r->uri;
 541                     break;
 542                 case SPECIAL_REQUEST_METHOD:
 543                     val = r->method;
 544                     break;
 545                 case SPECIAL_REQUEST_PROTOCOL:
 546                     val = r->protocol;
 547                     break;
 548                 case SPECIAL_NOT:
 549                     if (b->pnamereg) {
 550                         /* Matching headers_in against a regex. Iterate through
 551                          * the headers_in until we find a match or run out of
 552                          * headers.
 553                          */
 554                         const apr_array_header_t
 555                             *arr = apr_table_elts(r->headers_in);
 556
 557                         elts = (const apr_table_entry_t *) arr->elts;
 558                         val = NULL;
 559                         for (j = 0; j < arr->nelts; ++j) {
 560                             if (!ap_regexec(b->pnamereg, elts[j].key, 0, NULL, 0)) {
 561                                 val = elts[j].val;
 562                             }
 563                         }
 564                     }
 565                     else {
 566                         /* Not matching against a regex */
 567                         val = apr_table_get(r->headers_in, b->name);
 568                         if (val == NULL) {
 569                             val = apr_table_get(r->subprocess_env, b->name);
 570                         }
 571                     }
 572                 }
 573                 val_len = val ? strlen(val) : 0;
 574             }
 575
 576         }
 577
 578         /*
 579          * A NULL value indicates that the header field or special entity
 580          * wasn't present or is undefined.  Represent that as an empty string
 581          * so that REs like "^$" will work and allow envariable setting
 582          * based on missing or empty field. This is also necessary to make
 583          * ap_pregsub work after evaluating an ap_expr_t which does set the
 584          * regexp backref data.
 585          */
 586         if (val == NULL) {
 587             val = "";
 588             val_len = 0;
 589         }
 590
 591         if ((b->pattern && apr_strmatch(b->pattern, val, val_len)) ||
 592             (b->preg && !ap_regexec(b->preg, val, AP_MAX_REG_MATCH, regm, 0)) ||
 593             (b->expr && ap_expr_exec_re(r, b->expr, AP_MAX_REG_MATCH, regm, &val, &err) > 0))
 594         {
 595             const apr_array_header_t *arr = apr_table_elts(b->features);
 596             elts = (const apr_table_entry_t *) arr->elts;
 597
 598             for (j = 0; j < arr->nelts; ++j) {
 599                 if (*(elts[j].val) == '!') {
 600                     apr_table_unset(r->subprocess_env, elts[j].key);
 601                 }
 602                 else {
 603                     if (!b->pattern) {
 604                         char *replaced = ap_pregsub(r->pool, elts[j].val, val,
 605                                                     AP_MAX_REG_MATCH, regm);
 606                         if (replaced) {
 607                             apr_table_setn(r->subprocess_env, elts[j].key,
 608                                            replaced);
 609                         }
 610                         else {
 611                             ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(01505)
 612                                           "Regular expression replacement "
 613                                           "failed for '%s', value too long?",
 614                                           elts[j].key);
 615                             return HTTP_INTERNAL_SERVER_ERROR;
 616                         }
 617                     }
 618                     else {
 619                         apr_table_setn(r->subprocess_env, elts[j].key,
 620                                        elts[j].val);
 621                     }
 622                 }
 623                 ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r, "Setting %s",
 624                               elts[j].key);
 625             }
 626         }
 627     }
 628
 629     return DECLINED;
 630 }
 631
 632 static void register_hooks(apr_pool_t *p)
 633 {
 634     ap_hook_header_parser(match_headers, NULL, NULL, APR_HOOK_MIDDLE);
 635     ap_hook_post_read_request(match_headers, NULL, NULL, APR_HOOK_MIDDLE);
 636 }
 637
 638 AP_DECLARE_MODULE(setenvif) =
 639 {
 640     STANDARD20_MODULE_STUFF,
 641     create_setenvif_config_dir, /* dir config creater */
 642     merge_setenvif_config,      /* dir merger --- default is to override */
 643     create_setenvif_config_svr, /* server config */
 644     merge_setenvif_config,      /* merge server configs */
 645     setenvif_module_cmds,       /* command apr_table_t */
 646     register_hooks              /* register hooks */
 647 };