granicus.if.org Git - apache/blob - modules/mappers/mod_rewrite.c

   1 /* ====================================================================
   2  * The Apache Software License, Version 1.1
   3  *
   4  * Copyright (c) 2000 The Apache Software Foundation.  All rights
   5  * reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * 3. The end-user documentation included with the redistribution,
  20  *    if any, must include the following acknowledgment:
  21  *       "This product includes software developed by the
  22  *        Apache Software Foundation (http://www.apache.org/)."
  23  *    Alternately, this acknowledgment may appear in the software itself,
  24  *    if and wherever such third-party acknowledgments normally appear.
  25  *
  26  * 4. The names "Apache" and "Apache Software Foundation" must
  27  *    not be used to endorse or promote products derived from this
  28  *    software without prior written permission. For written
  29  *    permission, please contact apache@apache.org.
  30  *
  31  * 5. Products derived from this software may not be called "Apache",
  32  *    nor may "Apache" appear in their name, without prior written
  33  *    permission of the Apache Software Foundation.
  34  *
  35  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46  * SUCH DAMAGE.
  47  * ====================================================================
  48  *
  49  * This software consists of voluntary contributions made by many
  50  * individuals on behalf of the Apache Software Foundation.  For more
  51  * information on the Apache Software Foundation, please see
  52  * <http://www.apache.org/>.
  53  *
  54  * Portions of this software are based upon public domain software
  55  * originally written at the National Center for Supercomputing Applications,
  56  * University of Illinois, Urbana-Champaign.
  57  */
  58
  59 /*                       _                            _ _
  60 **   _ __ ___   ___   __| |    _ __ _____      ___ __(_) |_ ___
  61 **  | '_ ` _ \ / _ \ / _` |   | '__/ _ \ \ /\ / / '__| | __/ _ \
  62 **  | | | | | | (_) | (_| |   | | |  __/\ V  V /| |  | | ||  __/
  63 **  |_| |_| |_|\___/ \__,_|___|_|  \___| \_/\_/ |_|  |_|\__\___|
  64 **                       |_____|
  65 **
  66 **  URL Rewriting Module
  67 **
  68 **  This module uses a rule-based rewriting engine (based on a
  69 **  regular-expression parser) to rewrite requested URLs on the fly.
  70 **
  71 **  It supports an unlimited number of additional rule conditions (which can
  72 **  operate on a lot of variables, even on HTTP headers) for granular
  73 **  matching and even external database lookups (either via plain text
  74 **  tables, DBM hash files or even external processes) for advanced URL
  75 **  substitution.
  76 **
  77 **  It operates on the full URLs (including the PATH_INFO part) both in
  78 **  per-server context (httpd.conf) and per-dir context (.htaccess) and even
  79 **  can generate QUERY_STRING parts on result.   The rewriting result finally
  80 **  can lead to internal subprocessing, external request redirection or even
  81 **  to internal proxy throughput.
  82 **
  83 **  This module was originally written in April 1996 and
  84 **  gifted exclusively to the The Apache Software Foundation in July 1997 by
  85 **
  86 **      Ralf S. Engelschall
  87 **      rse@engelschall.com
  88 **      www.engelschall.com
  89 */
  90
  91 #include "ap_config.h"
  92 #include "httpd.h"
  93 #include "http_config.h"
  94 #include "http_request.h"
  95 #include "http_core.h"
  96 #include "http_log.h"
  97 #include "http_protocol.h"
  98 #include "mod_rewrite.h"
  99 #include "apr_strings.h"
 100
 101 #if !defined(OS2) && !defined(WIN32)
 102 #include "unixd.h"
 103 #endif
 104
 105 #ifndef NO_WRITEV
 106 #ifndef NETWARE
 107 #ifdef HAVE_SYS_TYPES_H
 108 #include <sys/types.h>
 109 #endif
 110 #endif
 111 #ifdef HAVE_SYS_UIO_H
 112 #include <sys/uio.h>
 113 #endif
 114 #endif
 115 #ifdef HAVE_PWD_H
 116 #include <pwd.h>
 117 #endif
 118 #ifdef HAVE_GRP_H
 119 #include <grp.h>
 120 #endif
 121 #ifdef HAVE_UNISTD_H
 122 #include <unistd.h>
 123 #endif
 124
 125 /*
 126 ** +-------------------------------------------------------+
 127 ** |                                                       |
 128 ** |             static module configuration
 129 ** |                                                       |
 130 ** +-------------------------------------------------------+
 131 */
 132
 133
 134 /*
 135 **  Our interface to the Apache server kernel:
 136 **
 137 **  o  Runtime logic of a request is as following:
 138 **       while(request or subrequest)
 139 **           foreach(stage #0...#9)
 140 **               foreach(module) (**)
 141 **                   try to run hook
 142 **
 143 **  o  the order of modules at (**) is the inverted order as
 144 **     given in the "Configuration" file, i.e. the last module
 145 **     specified is the first one called for each hook!
 146 **     The core module is always the last!
 147 **
 148 **  o  there are two different types of result checking and
 149 **     continue processing:
 150 **     for hook #0,#1,#4,#5,#6,#8:
 151 **         hook run loop stops on first modules which gives
 152 **         back a result != DECLINED, i.e. it usually returns OK
 153 **         which says "OK, module has handled this _stage_" and for #1
 154 **         this have not to mean "Ok, the filename is now valid".
 155 **     for hook #2,#3,#7,#9:
 156 **         all hooks are run, independend of result
 157 **
 158 **  o  at the last stage, the core module always
 159 **       - says "HTTP_BAD_REQUEST" if r->filename does not begin with "/"
 160 **       - prefix URL with document_root or replaced server_root
 161 **         with document_root and sets r->filename
 162 **       - always return a "OK" independed if the file really exists
 163 **         or not!
 164 */
 165
 166     /* The section for the Configure script:
 167     * XXX: this needs updating for apache-2.0 configuration method
 168      * MODULE-DEFINITION-START
 169      * Name: rewrite_module
 170      * ConfigStart
 171     . ./helpers/find-dbm-lib
 172     if [ "x$found_dbm" = "x1" ]; then
 173         echo "      enabling DBM support for mod_rewrite"
 174     else
 175         echo "      disabling DBM support for mod_rewrite"
 176         echo "      (perhaps you need to add -ldbm, -lndbm or -lgdbm to EXTRA_LIBS)"
 177         CFLAGS="$CFLAGS -DNO_DBM_REWRITEMAP"
 178     fi
 179      * ConfigEnd
 180      * MODULE-DEFINITION-END
 181      */
 182
 183     /* the apr_table_t of commands we provide */
 184 static const command_rec command_table[] = {
 185     AP_INIT_FLAG(    "RewriteEngine",   cmd_rewriteengine,  NULL, OR_FILEINFO,
 186                      "On or Off to enable or disable (default) the whole "
 187                      "rewriting engine"),
 188     AP_INIT_ITERATE( "RewriteOptions",  cmd_rewriteoptions,  NULL, OR_FILEINFO,
 189                      "List of option strings to set"),
 190     AP_INIT_TAKE1(   "RewriteBase",     cmd_rewritebase,     NULL, OR_FILEINFO,
 191                      "the base URL of the per-directory context"),
 192     AP_INIT_RAW_ARGS("RewriteCond",     cmd_rewritecond,     NULL, OR_FILEINFO,
 193                      "an input string and a to be applied regexp-pattern"),
 194     AP_INIT_RAW_ARGS("RewriteRule",     cmd_rewriterule,     NULL, OR_FILEINFO,
 195                      "an URL-applied regexp-pattern and a substitution URL"),
 196     AP_INIT_TAKE2(   "RewriteMap",      cmd_rewritemap,      NULL, RSRC_CONF,
 197                      "a mapname and a filename"),
 198     AP_INIT_TAKE1(   "RewriteLock",     cmd_rewritelock,     NULL, RSRC_CONF,
 199                      "the filename of a lockfile used for inter-process "
 200                      "synchronization"),
 201     AP_INIT_TAKE1(   "RewriteLog",      cmd_rewritelog,      NULL, RSRC_CONF,
 202                      "the filename of the rewriting logfile"),
 203     AP_INIT_TAKE1(   "RewriteLogLevel", cmd_rewriteloglevel, NULL, RSRC_CONF,
 204                      "the level of the rewriting logfile verbosity "
 205                      "(0=none, 1=std, .., 9=max)"),
 206     { NULL }
 207 };
 208
 209     /* the apr_table_t of content handlers we provide */
 210 static const handler_rec handler_table[] = {
 211     { "redirect-handler", handler_redirect },
 212     { NULL }
 213 };
 214
 215 static void register_hooks(void)
 216 {
 217     ap_hook_post_config(init_module,NULL,NULL,AP_HOOK_MIDDLE);
 218     ap_hook_child_init(init_child,NULL,NULL,AP_HOOK_MIDDLE);
 219
 220     ap_hook_fixups(hook_fixup,NULL,NULL,AP_HOOK_FIRST);
 221     ap_hook_translate_name(hook_uri2file,NULL,NULL,AP_HOOK_FIRST);
 222     ap_hook_type_checker(hook_mimetype,NULL,NULL,AP_HOOK_MIDDLE);
 223 }
 224
 225     /* the main config structure */
 226 module AP_MODULE_DECLARE_DATA rewrite_module = {
 227    STANDARD20_MODULE_STUFF,
 228    config_perdir_create,        /* create per-dir    config structures */
 229    config_perdir_merge,         /* merge  per-dir    config structures */
 230    config_server_create,        /* create per-server config structures */
 231    config_server_merge,         /* merge  per-server config structures */
 232    command_table,               /* apr_table_t of config file commands  */
 233    handler_table,               /* [#8] MIME-typed-dispatched handlers */
 234    register_hooks               /* register hooks                      */
 235 };
 236
 237     /* the cache */
 238 static cache *cachep;
 239
 240     /* whether proxy module is available or not */
 241 static int proxy_available;
 242 static int once_through = 0;
 243
 244 static const char *lockname;
 245 static apr_lock_t *rewrite_mapr_lock = NULL;
 246 static apr_lock_t *rewrite_log_lock = NULL;
 247
 248 /*
 249 ** +-------------------------------------------------------+
 250 ** |                                                       |
 251 ** |           configuration directive handling
 252 ** |                                                       |
 253 ** +-------------------------------------------------------+
 254 */
 255
 256 /*
 257 **
 258 **  per-server configuration structure handling
 259 **
 260 */
 261
 262 static void *config_server_create(apr_pool_t *p, server_rec *s)
 263 {
 264     rewrite_server_conf *a;
 265
 266     a = (rewrite_server_conf *)apr_pcalloc(p, sizeof(rewrite_server_conf));
 267
 268     a->state           = ENGINE_DISABLED;
 269     a->options         = OPTION_NONE;
 270     a->rewritelogfile  = NULL;
 271     a->rewritelogfp    = NULL;
 272     a->rewriteloglevel = 0;
 273     a->rewritemaps     = apr_make_array(p, 2, sizeof(rewritemap_entry));
 274     a->rewriteconds    = apr_make_array(p, 2, sizeof(rewritecond_entry));
 275     a->rewriterules    = apr_make_array(p, 2, sizeof(rewriterule_entry));
 276     a->server          = s;
 277
 278     return (void *)a;
 279 }
 280
 281 static void *config_server_merge(apr_pool_t *p, void *basev, void *overridesv)
 282 {
 283     rewrite_server_conf *a, *base, *overrides;
 284
 285     a         = (rewrite_server_conf *)apr_pcalloc(p, sizeof(rewrite_server_conf));
 286     base      = (rewrite_server_conf *)basev;
 287     overrides = (rewrite_server_conf *)overridesv;
 288
 289     a->state   = overrides->state;
 290     a->options = overrides->options;
 291     a->server  = overrides->server;
 292
 293     if (a->options & OPTION_INHERIT) {
 294         /*
 295          *  local directives override
 296          *  and anything else is inherited
 297          */
 298         a->rewriteloglevel = overrides->rewriteloglevel != 0
 299                              ? overrides->rewriteloglevel
 300                              : base->rewriteloglevel;
 301         a->rewritelogfile  = overrides->rewritelogfile != NULL
 302                              ? overrides->rewritelogfile
 303                              : base->rewritelogfile;
 304         a->rewritelogfp    = overrides->rewritelogfp != NULL
 305                              ? overrides->rewritelogfp
 306                              : base->rewritelogfp;
 307         a->rewritemaps     = apr_append_arrays(p, overrides->rewritemaps,
 308                                               base->rewritemaps);
 309         a->rewriteconds    = apr_append_arrays(p, overrides->rewriteconds,
 310                                               base->rewriteconds);
 311         a->rewriterules    = apr_append_arrays(p, overrides->rewriterules,
 312                                               base->rewriterules);
 313     }
 314     else {
 315         /*
 316          *  local directives override
 317          *  and anything else gets defaults
 318          */
 319         a->rewriteloglevel = overrides->rewriteloglevel;
 320         a->rewritelogfile  = overrides->rewritelogfile;
 321         a->rewritelogfp    = overrides->rewritelogfp;
 322         a->rewritemaps     = overrides->rewritemaps;
 323         a->rewriteconds    = overrides->rewriteconds;
 324         a->rewriterules    = overrides->rewriterules;
 325     }
 326
 327     return (void *)a;
 328 }
 329
 330
 331 /*
 332 **
 333 **  per-directory configuration structure handling
 334 **
 335 */
 336
 337 static void *config_perdir_create(apr_pool_t *p, char *path)
 338 {
 339     rewrite_perdir_conf *a;
 340
 341     a = (rewrite_perdir_conf *)apr_pcalloc(p, sizeof(rewrite_perdir_conf));
 342
 343     a->state           = ENGINE_DISABLED;
 344     a->options         = OPTION_NONE;
 345     a->baseurl         = NULL;
 346     a->rewriteconds    = apr_make_array(p, 2, sizeof(rewritecond_entry));
 347     a->rewriterules    = apr_make_array(p, 2, sizeof(rewriterule_entry));
 348
 349     if (path == NULL) {
 350         a->directory = NULL;
 351     }
 352     else {
 353         /* make sure it has a trailing slash */
 354         if (path[strlen(path)-1] == '/') {
 355             a->directory = apr_pstrdup(p, path);
 356         }
 357         else {
 358             a->directory = apr_pstrcat(p, path, "/", NULL);
 359         }
 360     }
 361
 362     return (void *)a;
 363 }
 364
 365 static void *config_perdir_merge(apr_pool_t *p, void *basev, void *overridesv)
 366 {
 367     rewrite_perdir_conf *a, *base, *overrides;
 368
 369     a         = (rewrite_perdir_conf *)apr_pcalloc(p,
 370                                                   sizeof(rewrite_perdir_conf));
 371     base      = (rewrite_perdir_conf *)basev;
 372     overrides = (rewrite_perdir_conf *)overridesv;
 373
 374     a->state     = overrides->state;
 375     a->options   = overrides->options;
 376     a->directory = overrides->directory;
 377     a->baseurl   = overrides->baseurl;
 378
 379     if (a->options & OPTION_INHERIT) {
 380         a->rewriteconds = apr_append_arrays(p, overrides->rewriteconds,
 381                                            base->rewriteconds);
 382         a->rewriterules = apr_append_arrays(p, overrides->rewriterules,
 383                                            base->rewriterules);
 384     }
 385     else {
 386         a->rewriteconds = overrides->rewriteconds;
 387         a->rewriterules = overrides->rewriterules;
 388     }
 389
 390     return (void *)a;
 391 }
 392
 393
 394 /*
 395 **
 396 **  the configuration commands
 397 **
 398 */
 399
 400 static const char *cmd_rewriteengine(cmd_parms *cmd,
 401                                      void *in_dconf, int flag)
 402 {
 403     rewrite_perdir_conf *dconf = in_dconf;
 404     rewrite_server_conf *sconf;
 405
 406     sconf =
 407         (rewrite_server_conf *)ap_get_module_config(cmd->server->module_config,
 408                                                     &rewrite_module);
 409
 410     if (cmd->path == NULL) { /* is server command */
 411         sconf->state = (flag ? ENGINE_ENABLED : ENGINE_DISABLED);
 412     }
 413     else                   /* is per-directory command */ {
 414         dconf->state = (flag ? ENGINE_ENABLED : ENGINE_DISABLED);
 415     }
 416
 417     return NULL;
 418 }
 419
 420 static const char *cmd_rewriteoptions(cmd_parms *cmd,
 421                                       void *in_dconf, const char *option)
 422 {
 423     rewrite_perdir_conf *dconf = in_dconf;
 424     rewrite_server_conf *sconf;
 425     const char *err;
 426
 427     sconf = (rewrite_server_conf *)
 428             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 429
 430     if (cmd->path == NULL) { /* is server command */
 431         err = cmd_rewriteoptions_setoption(cmd->pool,
 432                                            &(sconf->options), option);
 433     }
 434     else {                 /* is per-directory command */
 435         err = cmd_rewriteoptions_setoption(cmd->pool,
 436                                            &(dconf->options), option);
 437     }
 438
 439     return err;
 440 }
 441
 442 static const char *cmd_rewriteoptions_setoption(apr_pool_t *p, int *options,
 443                                                 const char *name)
 444 {
 445     if (strcasecmp(name, "inherit") == 0) {
 446         *options |= OPTION_INHERIT;
 447     }
 448     else {
 449         return apr_pstrcat(p, "RewriteOptions: unknown option '",
 450                           name, "'", NULL);
 451     }
 452     return NULL;
 453 }
 454
 455 static const char *cmd_rewritelog(cmd_parms *cmd, void *dconf, const char *a1)
 456 {
 457     rewrite_server_conf *sconf;
 458
 459     sconf = (rewrite_server_conf *)
 460             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 461
 462     sconf->rewritelogfile = a1;
 463
 464     return NULL;
 465 }
 466
 467 static const char *cmd_rewriteloglevel(cmd_parms *cmd, void *dconf, const char *a1)
 468 {
 469     rewrite_server_conf *sconf;
 470
 471     sconf = (rewrite_server_conf *)
 472             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 473
 474     sconf->rewriteloglevel = atoi(a1);
 475
 476     return NULL;
 477 }
 478
 479 static const char *cmd_rewritemap(cmd_parms *cmd, void *dconf, const char *a1,
 480                                   const char *a2)
 481 {
 482     rewrite_server_conf *sconf;
 483     rewritemap_entry *newmap;
 484     apr_finfo_t st;
 485
 486     sconf = (rewrite_server_conf *)
 487             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 488
 489     newmap = apr_push_array(sconf->rewritemaps);
 490
 491     newmap->name = a1;
 492     newmap->func = NULL;
 493     if (strncmp(a2, "txt:", 4) == 0) {
 494         newmap->type      = MAPTYPE_TXT;
 495         newmap->datafile  = a2+4;
 496         newmap->checkfile = a2+4;
 497     }
 498     else if (strncmp(a2, "rnd:", 4) == 0) {
 499         newmap->type      = MAPTYPE_RND;
 500         newmap->datafile  = a2+4;
 501         newmap->checkfile = a2+4;
 502     }
 503     else if (strncmp(a2, "dbm:", 4) == 0) {
 504 #ifndef NO_DBM_REWRITEMAP
 505         newmap->type      = MAPTYPE_DBM;
 506         newmap->datafile  = a2+4;
 507         newmap->checkfile = apr_pstrcat(cmd->pool, a2+4, NDBM_FILE_SUFFIX, NULL);
 508 #else
 509         return apr_pstrdup(cmd->pool, "RewriteMap: cannot use NDBM mapfile, "
 510                           "because no NDBM support is compiled in");
 511 #endif
 512     }
 513     else if (strncmp(a2, "prg:", 4) == 0) {
 514         newmap->type = MAPTYPE_PRG;
 515         newmap->datafile = a2+4;
 516         newmap->checkfile = a2+4;
 517     }
 518     else if (strncmp(a2, "int:", 4) == 0) {
 519         newmap->type      = MAPTYPE_INT;
 520         newmap->datafile  = NULL;
 521         newmap->checkfile = NULL;
 522         if (strcmp(a2+4, "tolower") == 0) {
 523             newmap->func = rewrite_mapfunc_tolower;
 524         }
 525         else if (strcmp(a2+4, "toupper") == 0) {
 526             newmap->func = rewrite_mapfunc_toupper;
 527         }
 528         else if (strcmp(a2+4, "escape") == 0) {
 529             newmap->func = rewrite_mapfunc_escape;
 530         }
 531         else if (strcmp(a2+4, "unescape") == 0) {
 532             newmap->func = rewrite_mapfunc_unescape;
 533         }
 534         else if (sconf->state == ENGINE_ENABLED) {
 535             return apr_pstrcat(cmd->pool, "RewriteMap: internal map not found:",
 536                               a2+4, NULL);
 537         }
 538     }
 539     else {
 540         newmap->type      = MAPTYPE_TXT;
 541         newmap->datafile  = a2;
 542         newmap->checkfile = a2;
 543     }
 544     newmap->fpin  = NULL;
 545     newmap->fpout = NULL;
 546
 547     if (newmap->checkfile && (sconf->state == ENGINE_ENABLED)
 548         && (apr_stat(&st, newmap->checkfile, cmd->pool) != APR_SUCCESS)) {
 549         return apr_pstrcat(cmd->pool,
 550                           "RewriteMap: map file or program not found:",
 551                           newmap->checkfile, NULL);
 552     }
 553
 554     return NULL;
 555 }
 556
 557 static const char *cmd_rewritelock(cmd_parms *cmd, void *dconf, const char *a1)
 558 {
 559     const char *error;
 560
 561     if ((error = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
 562         return error;
 563
 564     lockname = a1;
 565
 566     return NULL;
 567 }
 568
 569 static const char *cmd_rewritebase(cmd_parms *cmd, void *in_dconf,
 570                                    const char *a1)
 571 {
 572     rewrite_perdir_conf *dconf = in_dconf;
 573
 574     if (cmd->path == NULL || dconf == NULL) {
 575         return "RewriteBase: only valid in per-directory config files";
 576     }
 577     if (a1[0] == '\0') {
 578         return "RewriteBase: empty URL not allowed";
 579     }
 580     if (a1[0] != '/') {
 581         return "RewriteBase: argument is not a valid URL";
 582     }
 583
 584     dconf->baseurl = a1;
 585
 586     return NULL;
 587 }
 588
 589 static const char *cmd_rewritecond(cmd_parms *cmd, void *in_dconf,
 590                                    const char *in_str)
 591 {
 592     rewrite_perdir_conf *dconf = in_dconf;
 593     char *str = apr_pstrdup(cmd->pool, in_str);
 594     rewrite_server_conf *sconf;
 595     rewritecond_entry *newcond;
 596     regex_t *regexp;
 597     char *a1;
 598     char *a2;
 599     char *a3;
 600     char *cp;
 601     const char *err;
 602     int rc;
 603
 604     sconf = (rewrite_server_conf *)
 605             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 606
 607     /*  make a new entry in the internal temporary rewrite rule list */
 608     if (cmd->path == NULL) {   /* is server command */
 609         newcond = apr_push_array(sconf->rewriteconds);
 610     }
 611     else {                     /* is per-directory command */
 612         newcond = apr_push_array(dconf->rewriteconds);
 613     }
 614
 615     /*  parse the argument line ourself */
 616     if (parseargline(str, &a1, &a2, &a3)) {
 617         return apr_pstrcat(cmd->pool, "RewriteCond: bad argument line '", str,
 618                           "'", NULL);
 619     }
 620
 621     /*  arg1: the input string */
 622     newcond->input = apr_pstrdup(cmd->pool, a1);
 623
 624     /* arg3: optional flags field
 625        (this have to be first parsed, because we need to
 626         know if the regex should be compiled with ICASE!) */
 627     newcond->flags = CONDFLAG_NONE;
 628     if (a3 != NULL) {
 629         if ((err = cmd_rewritecond_parseflagfield(cmd->pool, newcond,
 630                                                   a3)) != NULL) {
 631             return err;
 632         }
 633     }
 634
 635     /*  arg2: the pattern
 636         try to compile the regexp to test if is ok */
 637     cp = a2;
 638     if (cp[0] == '!') {
 639         newcond->flags |= CONDFLAG_NOTMATCH;
 640         cp++;
 641     }
 642
 643     /* now be careful: Under the POSIX regex library
 644        we can compile the pattern for case insensitive matching,
 645        under the old V8 library we have to do it self via a hack */
 646     if (newcond->flags & CONDFLAG_NOCASE) {
 647         rc = ((regexp = ap_pregcomp(cmd->pool, cp, REG_EXTENDED|REG_ICASE))
 648               == NULL);
 649     }
 650     else {
 651         rc = ((regexp = ap_pregcomp(cmd->pool, cp, REG_EXTENDED)) == NULL);
 652     }
 653     if (rc) {
 654         return apr_pstrcat(cmd->pool,
 655                           "RewriteCond: cannot compile regular expression '",
 656                           a2, "'", NULL);
 657     }
 658
 659     newcond->pattern = apr_pstrdup(cmd->pool, cp);
 660     newcond->regexp  = regexp;
 661
 662     return NULL;
 663 }
 664
 665 static const char *cmd_rewritecond_parseflagfield(apr_pool_t *p,
 666                                                   rewritecond_entry *cfg,
 667                                                   char *str)
 668 {
 669     char *cp;
 670     char *cp1;
 671     char *cp2;
 672     char *cp3;
 673     char *key;
 674     char *val;
 675     const char *err;
 676
 677     if (str[0] != '[' || str[strlen(str)-1] != ']') {
 678         return "RewriteCond: bad flag delimiters";
 679     }
 680
 681     cp = str+1;
 682     str[strlen(str)-1] = ','; /* for simpler parsing */
 683     for ( ; *cp != '\0'; ) {
 684         /* skip whitespaces */
 685         for ( ; (*cp == ' ' || *cp == '\t') && *cp != '\0'; cp++)
 686             ;
 687         if (*cp == '\0') {
 688             break;
 689         }
 690         cp1 = cp;
 691         if ((cp2 = strchr(cp, ',')) != NULL) {
 692             cp = cp2+1;
 693             for ( ; (*(cp2-1) == ' ' || *(cp2-1) == '\t'); cp2--)
 694                 ;
 695             *cp2 = '\0';
 696             if ((cp3 = strchr(cp1, '=')) != NULL) {
 697                 *cp3 = '\0';
 698                 key = cp1;
 699                 val = cp3+1;
 700             }
 701             else {
 702                 key = cp1;
 703                 val = "";
 704             }
 705             if ((err = cmd_rewritecond_setflag(p, cfg, key, val)) != NULL) {
 706                 return err;
 707             }
 708         }
 709         else {
 710             break;
 711         }
 712     }
 713
 714     return NULL;
 715 }
 716
 717 static const char *cmd_rewritecond_setflag(apr_pool_t *p, rewritecond_entry *cfg,
 718                                            char *key, char *val)
 719 {
 720     if (   strcasecmp(key, "nocase") == 0
 721         || strcasecmp(key, "NC") == 0    ) {
 722         cfg->flags |= CONDFLAG_NOCASE;
 723     }
 724     else if (   strcasecmp(key, "ornext") == 0
 725              || strcasecmp(key, "OR") == 0    ) {
 726         cfg->flags |= CONDFLAG_ORNEXT;
 727     }
 728     else {
 729         return apr_pstrcat(p, "RewriteCond: unknown flag '", key, "'", NULL);
 730     }
 731     return NULL;
 732 }
 733
 734 static const char *cmd_rewriterule(cmd_parms *cmd, void *in_dconf,
 735                                    const char *in_str)
 736 {
 737     rewrite_perdir_conf *dconf = in_dconf;
 738     char *str = apr_pstrdup(cmd->pool, in_str);
 739     rewrite_server_conf *sconf;
 740     rewriterule_entry *newrule;
 741     regex_t *regexp;
 742     char *a1;
 743     char *a2;
 744     char *a3;
 745     char *cp;
 746     const char *err;
 747     int mode;
 748
 749     sconf = (rewrite_server_conf *)
 750             ap_get_module_config(cmd->server->module_config, &rewrite_module);
 751
 752     /*  make a new entry in the internal rewrite rule list */
 753     if (cmd->path == NULL) {   /* is server command */
 754         newrule = apr_push_array(sconf->rewriterules);
 755     }
 756     else {                     /* is per-directory command */
 757         newrule = apr_push_array(dconf->rewriterules);
 758     }
 759
 760     /*  parse the argument line ourself */
 761     if (parseargline(str, &a1, &a2, &a3)) {
 762         return apr_pstrcat(cmd->pool, "RewriteRule: bad argument line '", str,
 763                           "'", NULL);
 764     }
 765
 766     /* arg3: optional flags field */
 767     newrule->forced_mimetype     = NULL;
 768     newrule->forced_responsecode = HTTP_MOVED_TEMPORARILY;
 769     newrule->flags  = RULEFLAG_NONE;
 770     newrule->env[0] = NULL;
 771     newrule->skip   = 0;
 772     if (a3 != NULL) {
 773         if ((err = cmd_rewriterule_parseflagfield(cmd->pool, newrule,
 774                                                   a3)) != NULL) {
 775             return err;
 776         }
 777     }
 778
 779     /*  arg1: the pattern
 780      *  try to compile the regexp to test if is ok
 781      */
 782     cp = a1;
 783     if (cp[0] == '!') {
 784         newrule->flags |= RULEFLAG_NOTMATCH;
 785         cp++;
 786     }
 787     mode = REG_EXTENDED;
 788     if (newrule->flags & RULEFLAG_NOCASE) {
 789         mode |= REG_ICASE;
 790     }
 791     if ((regexp = ap_pregcomp(cmd->pool, cp, mode)) == NULL) {
 792         return apr_pstrcat(cmd->pool,
 793                           "RewriteRule: cannot compile regular expression '",
 794                           a1, "'", NULL);
 795     }
 796     newrule->pattern = apr_pstrdup(cmd->pool, cp);
 797     newrule->regexp  = regexp;
 798
 799     /*  arg2: the output string
 800      *  replace the $<N> by \<n> which is needed by the currently
 801      *  used Regular Expression library
 802      *
 803      * TODO: Is this still required for PCRE?  If not, does it *work* with PCRE?
 804      */
 805     newrule->output = apr_pstrdup(cmd->pool, a2);
 806
 807     /* now, if the server or per-dir config holds an
 808      * array of RewriteCond entries, we take it for us
 809      * and clear the array
 810      */
 811     if (cmd->path == NULL) {  /* is server command */
 812         newrule->rewriteconds   = sconf->rewriteconds;
 813         sconf->rewriteconds = apr_make_array(cmd->pool, 2,
 814                                             sizeof(rewritecond_entry));
 815     }
 816     else {                    /* is per-directory command */
 817         newrule->rewriteconds   = dconf->rewriteconds;
 818         dconf->rewriteconds = apr_make_array(cmd->pool, 2,
 819                                             sizeof(rewritecond_entry));
 820     }
 821
 822     return NULL;
 823 }
 824
 825 static const char *cmd_rewriterule_parseflagfield(apr_pool_t *p,
 826                                                   rewriterule_entry *cfg,
 827                                                   char *str)
 828 {
 829     char *cp;
 830     char *cp1;
 831     char *cp2;
 832     char *cp3;
 833     char *key;
 834     char *val;
 835     const char *err;
 836
 837     if (str[0] != '[' || str[strlen(str)-1] != ']') {
 838         return "RewriteRule: bad flag delimiters";
 839     }
 840
 841     cp = str+1;
 842     str[strlen(str)-1] = ','; /* for simpler parsing */
 843     for ( ; *cp != '\0'; ) {
 844         /* skip whitespaces */
 845         for ( ; (*cp == ' ' || *cp == '\t') && *cp != '\0'; cp++)
 846             ;
 847         if (*cp == '\0') {
 848             break;
 849         }
 850         cp1 = cp;
 851         if ((cp2 = strchr(cp, ',')) != NULL) {
 852             cp = cp2+1;
 853             for ( ; (*(cp2-1) == ' ' || *(cp2-1) == '\t'); cp2--)
 854                 ;
 855             *cp2 = '\0';
 856             if ((cp3 = strchr(cp1, '=')) != NULL) {
 857                 *cp3 = '\0';
 858                 key = cp1;
 859                 val = cp3+1;
 860             }
 861             else {
 862                 key = cp1;
 863                 val = "";
 864             }
 865             if ((err = cmd_rewriterule_setflag(p, cfg, key, val)) != NULL) {
 866                 return err;
 867             }
 868         }
 869         else {
 870             break;
 871         }
 872     }
 873
 874     return NULL;
 875 }
 876
 877 static const char *cmd_rewriterule_setflag(apr_pool_t *p, rewriterule_entry *cfg,
 878                                            char *key, char *val)
 879 {
 880     int status = 0;
 881     int i;
 882
 883     if (   strcasecmp(key, "redirect") == 0
 884         || strcasecmp(key, "R") == 0       ) {
 885         cfg->flags |= RULEFLAG_FORCEREDIRECT;
 886         if (strlen(val) > 0) {
 887             if (strcasecmp(val, "permanent") == 0) {
 888                 status = HTTP_MOVED_PERMANENTLY;
 889             }
 890             else if (strcasecmp(val, "temp") == 0) {
 891                 status = HTTP_MOVED_TEMPORARILY;
 892             }
 893             else if (strcasecmp(val, "seeother") == 0) {
 894                 status = HTTP_SEE_OTHER;
 895             }
 896             else if (apr_isdigit(*val)) {
 897                 status = atoi(val);
 898             }
 899             if (!ap_is_HTTP_REDIRECT(status)) {
 900                 return "RewriteRule: invalid HTTP response code "
 901                        "for flag 'R'";
 902             }
 903             cfg->forced_responsecode = status;
 904         }
 905     }
 906     else if (   strcasecmp(key, "last") == 0
 907              || strcasecmp(key, "L") == 0   ) {
 908         cfg->flags |= RULEFLAG_LASTRULE;
 909     }
 910     else if (   strcasecmp(key, "next") == 0
 911              || strcasecmp(key, "N") == 0   ) {
 912         cfg->flags |= RULEFLAG_NEWROUND;
 913     }
 914     else if (   strcasecmp(key, "chain") == 0
 915              || strcasecmp(key, "C") == 0    ) {
 916         cfg->flags |= RULEFLAG_CHAIN;
 917     }
 918     else if (   strcasecmp(key, "type") == 0
 919              || strcasecmp(key, "T") == 0   ) {
 920         cfg->forced_mimetype = apr_pstrdup(p, val);
 921         ap_str_tolower(cfg->forced_mimetype);
 922     }
 923     else if (   strcasecmp(key, "env") == 0
 924              || strcasecmp(key, "E") == 0   ) {
 925         for (i = 0; (cfg->env[i] != NULL) && (i < MAX_ENV_FLAGS); i++)
 926             ;
 927         if (i < MAX_ENV_FLAGS) {
 928             cfg->env[i] = apr_pstrdup(p, val);
 929             cfg->env[i+1] = NULL;
 930         }
 931         else {
 932             return "RewriteRule: too many environment flags 'E'";
 933         }
 934     }
 935     else if (   strcasecmp(key, "nosubreq") == 0
 936              || strcasecmp(key, "NS") == 0      ) {
 937         cfg->flags |= RULEFLAG_IGNOREONSUBREQ;
 938     }
 939     else if (   strcasecmp(key, "proxy") == 0
 940              || strcasecmp(key, "P") == 0      ) {
 941         cfg->flags |= RULEFLAG_PROXY;
 942     }
 943     else if (   strcasecmp(key, "passthrough") == 0
 944              || strcasecmp(key, "PT") == 0      ) {
 945         cfg->flags |= RULEFLAG_PASSTHROUGH;
 946     }
 947     else if (   strcasecmp(key, "skip") == 0
 948              || strcasecmp(key, "S") == 0   ) {
 949         cfg->skip = atoi(val);
 950     }
 951     else if (   strcasecmp(key, "forbidden") == 0
 952              || strcasecmp(key, "F") == 0   ) {
 953         cfg->flags |= RULEFLAG_FORBIDDEN;
 954     }
 955     else if (   strcasecmp(key, "gone") == 0
 956              || strcasecmp(key, "G") == 0   ) {
 957         cfg->flags |= RULEFLAG_GONE;
 958     }
 959     else if (   strcasecmp(key, "qsappend") == 0
 960              || strcasecmp(key, "QSA") == 0   ) {
 961         cfg->flags |= RULEFLAG_QSAPPEND;
 962     }
 963     else if (   strcasecmp(key, "nocase") == 0
 964              || strcasecmp(key, "NC") == 0    ) {
 965         cfg->flags |= RULEFLAG_NOCASE;
 966     }
 967     else {
 968         return apr_pstrcat(p, "RewriteRule: unknown flag '", key, "'", NULL);
 969     }
 970     return NULL;
 971 }
 972
 973
 974 /*
 975 **
 976 **  Global Module Initialization
 977 **  [called from read_config() after all
 978 **  config commands were already called]
 979 **
 980 */
 981
 982 static void init_module(apr_pool_t *p,
 983                         apr_pool_t *plog,
 984                         apr_pool_t *ptemp,
 985                         server_rec *s)
 986 {
 987     apr_status_t rv;
 988
 989     /* check if proxy module is available */
 990     proxy_available = (ap_find_linked_module("mod_proxy.c") != NULL);
 991
 992     /* create the rewriting lockfiles in the parent */
 993     if ((rv = apr_create_lock (&rewrite_log_lock, APR_MUTEX, APR_LOCKALL,
 994                                NULL, NULL)) != APR_SUCCESS) {
 995         ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
 996                      "mod_rewrite: could not create rewrite_log_lock");
 997         exit(1);
 998     }
 999
1000     rewritelock_create(s, p);
1001     apr_register_cleanup(p, (void *)s, rewritelock_remove, apr_null_cleanup);
1002
1003     /* step through the servers and
1004      * - open each rewriting logfile
1005      * - open the RewriteMap prg:xxx programs
1006      */
1007     for (; s; s = s->next) {
1008         open_rewritelog(s, p);
1009         if (once_through > 0)
1010            run_rewritemap_programs(s, p);
1011     }
1012
1013     once_through++;
1014 }
1015
1016
1017 /*
1018 **
1019 **  Per-Child Module Initialization
1020 **  [called after a child process is spawned]
1021 **
1022 */
1023
1024 static void init_child(apr_pool_t *p, server_rec *s)
1025 {
1026     apr_status_t rv;
1027
1028     if (lockname != NULL && *(lockname) != '\0')
1029     {
1030         rv = apr_child_init_lock (&rewrite_mapr_lock, lockname, p);
1031         if (rv != APR_SUCCESS) {
1032             ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
1033                          "mod_rewrite: could not init rewrite_mapr_lock "
1034                          "in child");
1035         }
1036     }
1037
1038     /* create the lookup cache */
1039     cachep = init_cache(p);
1040 }
1041
1042
1043 /*
1044 ** +-------------------------------------------------------+
1045 ** |                                                       |
1046 ** |                     runtime hooks
1047 ** |                                                       |
1048 ** +-------------------------------------------------------+
1049 */
1050
1051 /*
1052 **
1053 **  URI-to-filename hook
1054 **
1055 **  [used for the rewriting engine triggered by
1056 **  the per-server 'RewriteRule' directives]
1057 **
1058 */
1059
1060 static int hook_uri2file(request_rec *r)
1061 {
1062     void *sconf;
1063     rewrite_server_conf *conf;
1064     const char *var;
1065     const char *thisserver;
1066     char *thisport;
1067     const char *thisurl;
1068     char buf[512];
1069     char docroot[512];
1070     char *cp, *cp2;
1071     const char *ccp;
1072     apr_finfo_t finfo;
1073     unsigned int port;
1074     int n;
1075     int l;
1076
1077     /*
1078      *  retrieve the config structures
1079      */
1080     sconf = r->server->module_config;
1081     conf  = (rewrite_server_conf *)ap_get_module_config(sconf,
1082                                                         &rewrite_module);
1083
1084     /*
1085      *  only do something under runtime if the engine is really enabled,
1086      *  else return immediately!
1087      */
1088     if (conf->state == ENGINE_DISABLED) {
1089         return DECLINED;
1090     }
1091
1092     /*
1093      *  check for the ugly API case of a virtual host section where no
1094      *  mod_rewrite directives exists. In this situation we became no chance
1095      *  by the API to setup our default per-server config so we have to
1096      *  on-the-fly assume we have the default config. But because the default
1097      *  config has a disabled rewriting engine we are lucky because can
1098      *  just stop operating now.
1099      */
1100     if (conf->server != r->server) {
1101         return DECLINED;
1102     }
1103
1104     /*
1105      *  add the SCRIPT_URL variable to the env. this is a bit complicated
1106      *  due to the fact that apache uses subrequests and internal redirects
1107      */
1108
1109     if (r->main == NULL) {
1110          var = apr_pstrcat(r->pool, "REDIRECT_", ENVVAR_SCRIPT_URL, NULL);
1111          var = apr_table_get(r->subprocess_env, var);
1112          if (var == NULL) {
1113              apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, r->uri);
1114          }
1115          else {
1116              apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, var);
1117          }
1118     }
1119     else {
1120          var = apr_table_get(r->main->subprocess_env, ENVVAR_SCRIPT_URL);
1121          apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, var);
1122     }
1123
1124     /*
1125      *  create the SCRIPT_URI variable for the env
1126      */
1127
1128     /* add the canonical URI of this URL */
1129     thisserver = ap_get_server_name(r);
1130     port = ap_get_server_port(r);
1131     if (ap_is_default_port(port, r)) {
1132         thisport = "";
1133     }
1134     else {
1135         apr_snprintf(buf, sizeof(buf), ":%u", port);
1136         thisport = buf;
1137     }
1138     thisurl = apr_table_get(r->subprocess_env, ENVVAR_SCRIPT_URL);
1139
1140     /* set the variable */
1141     var = apr_pstrcat(r->pool, ap_http_method(r), "://", thisserver, thisport,
1142                      thisurl, NULL);
1143     apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URI, var);
1144
1145     /* if filename was not initially set,
1146      * we start with the requested URI
1147      */
1148     if (r->filename == NULL) {
1149         r->filename = apr_pstrdup(r->pool, r->uri);
1150         rewritelog(r, 2, "init rewrite engine with requested uri %s",
1151                    r->filename);
1152     }
1153
1154     /*
1155      *  now apply the rules ...
1156      */
1157     if (apply_rewrite_list(r, conf->rewriterules, NULL)) {
1158
1159         if (strlen(r->filename) > 6 &&
1160             strncmp(r->filename, "proxy:", 6) == 0) {
1161             /* it should be go on as an internal proxy request */
1162
1163             /* check if the proxy module is enabled, so
1164              * we can actually use it!
1165              */
1166             if (!proxy_available) {
1167                 ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, r,
1168                              "attempt to make remote request from mod_rewrite "
1169                              "without proxy enabled: %s", r->filename);
1170                 return HTTP_FORBIDDEN;
1171             }
1172
1173             /* make sure the QUERY_STRING and
1174              * PATH_INFO parts get incorporated
1175              */
1176             if (r->path_info != NULL) {
1177                 r->filename = apr_pstrcat(r->pool, r->filename,
1178                                          r->path_info, NULL);
1179             }
1180             if (r->args != NULL &&
1181                 r->uri == r->unparsed_uri) {
1182                 /* see proxy_http:proxy_http_canon() */
1183                 r->filename = apr_pstrcat(r->pool, r->filename,
1184                                          "?", r->args, NULL);
1185             }
1186
1187             /* now make sure the request gets handled by the proxy handler */
1188             r->proxyreq = 1;
1189             r->handler  = "proxy-server";
1190
1191             rewritelog(r, 1, "go-ahead with proxy request %s [OK]",
1192                        r->filename);
1193             return OK;
1194         }
1195         else if (is_absolute_uri(r->filename)) {
1196             /* it was finally rewritten to a remote URL */
1197
1198             /* skip 'scheme:' */
1199             for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
1200                 ;
1201             /* skip '://' */
1202             cp += 3;
1203             /* skip host part */
1204             for ( ; *cp != '/' && *cp != '\0'; cp++)
1205                 ;
1206             if (*cp != '\0') {
1207                 rewritelog(r, 1, "escaping %s for redirect", r->filename);
1208                 cp2 = ap_escape_uri(r->pool, cp);
1209                 *cp = '\0';
1210                 r->filename = apr_pstrcat(r->pool, r->filename, cp2, NULL);
1211             }
1212
1213             /* append the QUERY_STRING part */
1214             if (r->args != NULL) {
1215                 r->filename = apr_pstrcat(r->pool, r->filename, "?",
1216                                          ap_escape_uri(r->pool, r->args), NULL);
1217             }
1218
1219             /* determine HTTP redirect response code */
1220             if (ap_is_HTTP_REDIRECT(r->status)) {
1221                 n = r->status;
1222                 r->status = HTTP_OK; /* make Apache kernel happy */
1223             }
1224             else {
1225                 n = HTTP_MOVED_TEMPORARILY;
1226             }
1227
1228             /* now do the redirection */
1229             apr_table_setn(r->headers_out, "Location", r->filename);
1230             rewritelog(r, 1, "redirect to %s [REDIRECT/%d]", r->filename, n);
1231             return n;
1232         }
1233         else if (strlen(r->filename) > 10 &&
1234                  strncmp(r->filename, "forbidden:", 10) == 0) {
1235             /* This URLs is forced to be forbidden for the requester */
1236             return HTTP_FORBIDDEN;
1237         }
1238         else if (strlen(r->filename) > 5 &&
1239                  strncmp(r->filename, "gone:", 5) == 0) {
1240             /* This URLs is forced to be gone */
1241             return HTTP_GONE;
1242         }
1243         else if (strlen(r->filename) > 12 &&
1244                  strncmp(r->filename, "passthrough:", 12) == 0) {
1245             /*
1246              * Hack because of underpowered API: passing the current
1247              * rewritten filename through to other URL-to-filename handlers
1248              * just as it were the requested URL. This is to enable
1249              * post-processing by mod_alias, etc.  which always act on
1250              * r->uri! The difference here is: We do not try to
1251              * add the document root
1252              */
1253             r->uri = apr_pstrdup(r->pool, r->filename+12);
1254             return DECLINED;
1255         }
1256         else {
1257             /* it was finally rewritten to a local path */
1258
1259             /* expand "/~user" prefix */
1260 #if !defined(WIN32) && !defined(NETWARE)
1261             r->filename = expand_tildepaths(r, r->filename);
1262 #endif
1263             rewritelog(r, 2, "local path result: %s", r->filename);
1264
1265             /* the filename has to start with a slash! */
1266             if (r->filename[0] != '/') {
1267                 return HTTP_BAD_REQUEST;
1268             }
1269
1270             /* if there is no valid prefix, we have
1271              * to emulate the translator from the core and
1272              * prefix the filename with document_root
1273              *
1274              * NOTICE:
1275              * We cannot leave out the prefix_stat because
1276              * - when we always prefix with document_root
1277              *   then no absolute path can be created, e.g. via
1278              *   emulating a ScriptAlias directive, etc.
1279              * - when we always NOT prefix with document_root
1280              *   then the files under document_root have to
1281              *   be references directly and document_root
1282              *   gets never used and will be a dummy parameter -
1283              *   this is also bad
1284              *
1285              * BUT:
1286              * Under real Unix systems this is no problem,
1287              * because we only do stat() on the first directory
1288              * and this gets cached by the kernel for along time!
1289              */
1290             n = prefix_stat(r->filename, &finfo);
1291             if (n == 0) {
1292                 if ((ccp = ap_document_root(r)) != NULL) {
1293                     l = apr_cpystrn(docroot, ccp, sizeof(docroot)) - docroot;
1294
1295                     /* always NOT have a trailing slash */
1296                     if (docroot[l-1] == '/') {
1297                         docroot[l-1] = '\0';
1298                     }
1299                     if (r->server->path
1300                         && !strncmp(r->filename, r->server->path,
1301                                     r->server->pathlen)) {
1302                         r->filename = apr_pstrcat(r->pool, docroot,
1303                                                  (r->filename +
1304                                                   r->server->pathlen), NULL);
1305                     }
1306                     else {
1307                         r->filename = apr_pstrcat(r->pool, docroot,
1308                                                  r->filename, NULL);
1309                     }
1310                     rewritelog(r, 2, "prefixed with document_root to %s",
1311                                r->filename);
1312                 }
1313             }
1314
1315             rewritelog(r, 1, "go-ahead with %s [OK]", r->filename);
1316             return OK;
1317         }
1318     }
1319     else {
1320         rewritelog(r, 1, "pass through %s", r->filename);
1321         return DECLINED;
1322     }
1323 }
1324
1325
1326 /*
1327 **
1328 **  MIME-type hook
1329 **
1330 **  [used to support the forced-MIME-type feature]
1331 **
1332 */
1333
1334 static int hook_mimetype(request_rec *r)
1335 {
1336     const char *t;
1337
1338     /* now check if we have to force a MIME-type */
1339     t = apr_table_get(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR);
1340     if (t == NULL) {
1341         return DECLINED;
1342     }
1343     else {
1344         rewritelog(r, 1, "force filename %s to have MIME-type '%s'",
1345                    r->filename, t);
1346         r->content_type = t;
1347         return OK;
1348     }
1349 }
1350
1351
1352 /*
1353 **
1354 **  Fixup hook
1355 **
1356 **  [used for the rewriting engine triggered by
1357 **  the per-directory 'RewriteRule' directives]
1358 **
1359 */
1360
1361 static int hook_fixup(request_rec *r)
1362 {
1363     rewrite_perdir_conf *dconf;
1364     char *cp;
1365     char *cp2;
1366     const char *ccp;
1367     char *prefix;
1368     int l;
1369     int n;
1370     char *ofilename;
1371
1372     dconf = (rewrite_perdir_conf *)ap_get_module_config(r->per_dir_config,
1373                                                         &rewrite_module);
1374
1375     /* if there is no per-dir config we return immediately */
1376     if (dconf == NULL) {
1377         return DECLINED;
1378     }
1379
1380     /* we shouldn't do anything in subrequests */
1381     if (r->main != NULL) {
1382         return DECLINED;
1383     }
1384
1385     /* if there are no real (i.e. no RewriteRule directives!)
1386        per-dir config of us, we return also immediately */
1387     if (dconf->directory == NULL) {
1388         return DECLINED;
1389     }
1390
1391     /*
1392      *  only do something under runtime if the engine is really enabled,
1393      *  for this directory, else return immediately!
1394      */
1395     if (!(ap_allow_options(r) & (OPT_SYM_LINKS | OPT_SYM_OWNER))) {
1396         /* FollowSymLinks is mandatory! */
1397         ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, r,
1398                      "Options FollowSymLinks or SymLinksIfOwnerMatch is off "
1399                      "which implies that RewriteRule directive is forbidden: "
1400                      "%s", r->filename);
1401         return HTTP_FORBIDDEN;
1402     }
1403     else {
1404         /* FollowSymLinks is given, but the user can
1405          * still turn off the rewriting engine
1406          */
1407         if (dconf->state == ENGINE_DISABLED) {
1408             return DECLINED;
1409         }
1410     }
1411
1412     /*
1413      *  remember the current filename before rewriting for later check
1414      *  to prevent deadlooping because of internal redirects
1415      *  on final URL/filename which can be equal to the inital one.
1416      */
1417     ofilename = r->filename;
1418
1419     /*
1420      *  now apply the rules ...
1421      */
1422     if (apply_rewrite_list(r, dconf->rewriterules, dconf->directory)) {
1423
1424         if (strlen(r->filename) > 6 &&
1425             strncmp(r->filename, "proxy:", 6) == 0) {
1426             /* it should go on as an internal proxy request */
1427
1428             /* make sure the QUERY_STRING and
1429              * PATH_INFO parts get incorporated
1430              * (r->path_info was already appended by the
1431              * rewriting engine because of the per-dir context!)
1432              */
1433             if (r->args != NULL) {
1434                 r->filename = apr_pstrcat(r->pool, r->filename,
1435                                          "?", r->args, NULL);
1436             }
1437
1438             /* now make sure the request gets handled by the proxy handler */
1439             r->proxyreq = 1;
1440             r->handler  = "proxy-server";
1441
1442             rewritelog(r, 1, "[per-dir %s] go-ahead with proxy request "
1443                        "%s [OK]", dconf->directory, r->filename);
1444             return OK;
1445         }
1446         else if (is_absolute_uri(r->filename)) {
1447             /* it was finally rewritten to a remote URL */
1448
1449             /* because we are in a per-dir context
1450              * first try to replace the directory with its base-URL
1451              * if there is a base-URL available
1452              */
1453             if (dconf->baseurl != NULL) {
1454                 /* skip 'scheme:' */
1455                 for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
1456                     ;
1457                 /* skip '://' */
1458                 cp += 3;
1459                 if ((cp = strchr(cp, '/')) != NULL) {
1460                     rewritelog(r, 2,
1461                                "[per-dir %s] trying to replace "
1462                                "prefix %s with %s",
1463                                dconf->directory, dconf->directory,
1464                                dconf->baseurl);
1465                     cp2 = subst_prefix_path(r, cp, dconf->directory,
1466                                             dconf->baseurl);
1467                     if (strcmp(cp2, cp) != 0) {
1468                         *cp = '\0';
1469                         r->filename = apr_pstrcat(r->pool, r->filename,
1470                                                  cp2, NULL);
1471                     }
1472                 }
1473             }
1474
1475             /* now prepare the redirect... */
1476
1477             /* skip 'scheme:' */
1478             for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
1479                 ;
1480             /* skip '://' */
1481             cp += 3;
1482             /* skip host part */
1483             for ( ; *cp != '/' && *cp != '\0'; cp++)
1484                 ;
1485             if (*cp != '\0') {
1486                 rewritelog(r, 1, "[per-dir %s] escaping %s for redirect",
1487                            dconf->directory, r->filename);
1488                 cp2 = ap_escape_uri(r->pool, cp);
1489                 *cp = '\0';
1490                 r->filename = apr_pstrcat(r->pool, r->filename, cp2, NULL);
1491             }
1492
1493             /* append the QUERY_STRING part */
1494             if (r->args != NULL) {
1495                 r->filename = apr_pstrcat(r->pool, r->filename, "?",
1496                                          ap_escape_uri(r->pool, r->args), NULL);
1497             }
1498
1499             /* determine HTTP redirect response code */
1500             if (ap_is_HTTP_REDIRECT(r->status)) {
1501                 n = r->status;
1502                 r->status = HTTP_OK; /* make Apache kernel happy */
1503             }
1504             else {
1505                 n = HTTP_MOVED_TEMPORARILY;
1506             }
1507
1508             /* now do the redirection */
1509             apr_table_setn(r->headers_out, "Location", r->filename);
1510             rewritelog(r, 1, "[per-dir %s] redirect to %s [REDIRECT/%d]",
1511                        dconf->directory, r->filename, n);
1512             return n;
1513         }
1514         else if (strlen(r->filename) > 10 &&
1515                  strncmp(r->filename, "forbidden:", 10) == 0) {
1516             /* This URL is forced to be forbidden for the requester */
1517             return HTTP_FORBIDDEN;
1518         }
1519         else if (strlen(r->filename) > 5 &&
1520                  strncmp(r->filename, "gone:", 5) == 0) {
1521             /* This URL is forced to be gone */
1522             return HTTP_GONE;
1523         }
1524         else {
1525             /* it was finally rewritten to a local path */
1526
1527             /* if someone used the PASSTHROUGH flag in per-dir
1528              * context we just ignore it. It is only useful
1529              * in per-server context
1530              */
1531             if (strlen(r->filename) > 12 &&
1532                 strncmp(r->filename, "passthrough:", 12) == 0) {
1533                 r->filename = apr_pstrdup(r->pool, r->filename+12);
1534             }
1535
1536             /* the filename has to start with a slash! */
1537             if (r->filename[0] != '/') {
1538                 return HTTP_BAD_REQUEST;
1539             }
1540
1541             /* Check for deadlooping:
1542              * At this point we KNOW that at least one rewriting
1543              * rule was applied, but when the resulting URL is
1544              * the same as the initial URL, we are not allowed to
1545              * use the following internal redirection stuff because
1546              * this would lead to a deadloop.
1547              */
1548             if (strcmp(r->filename, ofilename) == 0) {
1549                 rewritelog(r, 1, "[per-dir %s] initial URL equal rewritten "
1550                            "URL: %s [IGNORING REWRITE]",
1551                            dconf->directory, r->filename);
1552                 return OK;
1553             }
1554
1555             /* if there is a valid base-URL then substitute
1556              * the per-dir prefix with this base-URL if the
1557              * current filename still is inside this per-dir
1558              * context. If not then treat the result as a
1559              * plain URL
1560              */
1561             if (dconf->baseurl != NULL) {
1562                 rewritelog(r, 2,
1563                            "[per-dir %s] trying to replace prefix %s with %s",
1564                            dconf->directory, dconf->directory, dconf->baseurl);
1565                 r->filename = subst_prefix_path(r, r->filename,
1566                                                 dconf->directory,
1567                                                 dconf->baseurl);
1568             }
1569             else {
1570                 /* if no explicit base-URL exists we assume
1571                  * that the directory prefix is also a valid URL
1572                  * for this webserver and only try to remove the
1573                  * document_root if it is prefix
1574                  */
1575                 if ((ccp = ap_document_root(r)) != NULL) {
1576                     prefix = apr_pstrdup(r->pool, ccp);
1577                     /* always NOT have a trailing slash */
1578                     l = strlen(prefix);
1579                     if (prefix[l-1] == '/') {
1580                         prefix[l-1] = '\0';
1581                         l--;
1582                     }
1583                     if (strncmp(r->filename, prefix, l) == 0) {
1584                         rewritelog(r, 2,
1585                                    "[per-dir %s] strip document_root "
1586                                    "prefix: %s -> %s",
1587                                    dconf->directory, r->filename,
1588                                    r->filename+l);
1589                         r->filename = apr_pstrdup(r->pool, r->filename+l);
1590                     }
1591                 }
1592             }
1593
1594             /* now initiate the internal redirect */
1595             rewritelog(r, 1, "[per-dir %s] internal redirect with %s "
1596                        "[INTERNAL REDIRECT]", dconf->directory, r->filename);
1597             r->filename = apr_pstrcat(r->pool, "redirect:", r->filename, NULL);
1598             r->handler = "redirect-handler";
1599             return OK;
1600         }
1601     }
1602     else {
1603         rewritelog(r, 1, "[per-dir %s] pass through %s",
1604                    dconf->directory, r->filename);
1605         return DECLINED;
1606     }
1607 }
1608
1609
1610 /*
1611 **
1612 **  Content-Handlers
1613 **
1614 **  [used for redirect support]
1615 **
1616 */
1617
1618 static int handler_redirect(request_rec *r)
1619 {
1620     /* just make sure that we are really meant! */
1621     if (strncmp(r->filename, "redirect:", 9) != 0) {
1622         return DECLINED;
1623     }
1624
1625     /* now do the internal redirect */
1626     ap_internal_redirect(apr_pstrcat(r->pool, r->filename+9,
1627                                     r->args ? "?" : NULL, r->args, NULL), r);
1628
1629     /* and return gracefully */
1630     return OK;
1631 }
1632
1633
1634 /*
1635 ** +-------------------------------------------------------+
1636 ** |                                                       |
1637 ** |                  the rewriting engine
1638 ** |                                                       |
1639 ** +-------------------------------------------------------+
1640 */
1641
1642 /*
1643  *  Apply a complete rule set,
1644  *  i.e. a list of rewrite rules
1645  */
1646 static int apply_rewrite_list(request_rec *r, apr_array_header_t *rewriterules,
1647                               char *perdir)
1648 {
1649     rewriterule_entry *entries;
1650     rewriterule_entry *p;
1651     int i;
1652     int changed;
1653     int rc;
1654     int s;
1655
1656     /*
1657      *  Iterate over all existing rules
1658      */
1659     entries = (rewriterule_entry *)rewriterules->elts;
1660     changed = 0;
1661     loop:
1662     for (i = 0; i < rewriterules->nelts; i++) {
1663         p = &entries[i];
1664
1665         /*
1666          *  Ignore this rule on subrequests if we are explicitly
1667          *  asked to do so or this is a proxy-throughput or a
1668          *  forced redirect rule.
1669          */
1670         if (r->main != NULL &&
1671             (p->flags & RULEFLAG_IGNOREONSUBREQ ||
1672              p->flags & RULEFLAG_PROXY          ||
1673              p->flags & RULEFLAG_FORCEREDIRECT    )) {
1674             continue;
1675         }
1676
1677         /*
1678          *  Apply the current rule.
1679          */
1680         rc = apply_rewrite_rule(r, p, perdir);
1681         if (rc) {
1682             /*
1683              *  Indicate a change if this was not a match-only rule.
1684              */
1685             if (rc != 2) {
1686                 changed = 1;
1687             }
1688
1689             /*
1690              *  Pass-Through Feature (`RewriteRule .. .. [PT]'):
1691              *  Because the Apache 1.x API is very limited we
1692              *  need this hack to pass the rewritten URL to other
1693              *  modules like mod_alias, mod_userdir, etc.
1694              */
1695             if (p->flags & RULEFLAG_PASSTHROUGH) {
1696                 rewritelog(r, 2, "forcing '%s' to get passed through "
1697                            "to next API URI-to-filename handler", r->filename);
1698                 r->filename = apr_pstrcat(r->pool, "passthrough:",
1699                                          r->filename, NULL);
1700                 changed = 1;
1701                 break;
1702             }
1703
1704             /*
1705              *  Rule has the "forbidden" flag set which means that
1706              *  we stop processing and indicate this to the caller.
1707              */
1708             if (p->flags & RULEFLAG_FORBIDDEN) {
1709                 rewritelog(r, 2, "forcing '%s' to be forbidden", r->filename);
1710                 r->filename = apr_pstrcat(r->pool, "forbidden:",
1711                                          r->filename, NULL);
1712                 changed = 1;
1713                 break;
1714             }
1715
1716             /*
1717              *  Rule has the "gone" flag set which means that
1718              *  we stop processing and indicate this to the caller.
1719              */
1720             if (p->flags & RULEFLAG_GONE) {
1721                 rewritelog(r, 2, "forcing '%s' to be gone", r->filename);
1722                 r->filename = apr_pstrcat(r->pool, "gone:", r->filename, NULL);
1723                 changed = 1;
1724                 break;
1725             }
1726
1727             /*
1728              *  Stop processing also on proxy pass-through and
1729              *  last-rule and new-round flags.
1730              */
1731             if (p->flags & RULEFLAG_PROXY) {
1732                 break;
1733             }
1734             if (p->flags & RULEFLAG_LASTRULE) {
1735                 break;
1736             }
1737
1738             /*
1739              *  On "new-round" flag we just start from the top of
1740              *  the rewriting ruleset again.
1741              */
1742             if (p->flags & RULEFLAG_NEWROUND) {
1743                 goto loop;
1744             }
1745
1746             /*
1747              *  If we are forced to skip N next rules, do it now.
1748              */
1749             if (p->skip > 0) {
1750                 s = p->skip;
1751                 while (   i < rewriterules->nelts
1752                        && s > 0) {
1753                     i++;
1754                     p = &entries[i];
1755                     s--;
1756                 }
1757             }
1758         }
1759         else {
1760             /*
1761              *  If current rule is chained with next rule(s),
1762              *  skip all this next rule(s)
1763              */
1764             while (   i < rewriterules->nelts
1765                    && p->flags & RULEFLAG_CHAIN) {
1766                 i++;
1767                 p = &entries[i];
1768             }
1769         }
1770     }
1771     return changed;
1772 }
1773
1774 /*
1775  *  Apply a single(!) rewrite rule
1776  */
1777 static int apply_rewrite_rule(request_rec *r, rewriterule_entry *p,
1778                               char *perdir)
1779 {
1780     char *uri;
1781     char *output;
1782     const char *vary;
1783     char newuri[MAX_STRING_LEN];
1784     regex_t *regexp;
1785     regmatch_t regmatch[MAX_NMATCH];
1786     backrefinfo *briRR = NULL;
1787     backrefinfo *briRC = NULL;
1788     int prefixstrip;
1789     int failed;
1790     apr_array_header_t *rewriteconds;
1791     rewritecond_entry *conds;
1792     rewritecond_entry *c;
1793     int i;
1794     int rc;
1795
1796     /*
1797      *  Initialisation
1798      */
1799     uri     = r->filename;
1800     regexp  = p->regexp;
1801     output  = p->output;
1802
1803     /*
1804      *  Add (perhaps splitted away) PATH_INFO postfix to URL to
1805      *  make sure we really match against the complete URL.
1806      */
1807     if (perdir != NULL && r->path_info != NULL && r->path_info[0] != '\0') {
1808         rewritelog(r, 3, "[per-dir %s] add path info postfix: %s -> %s%s",
1809                    perdir, uri, uri, r->path_info);
1810         uri = apr_pstrcat(r->pool, uri, r->path_info, NULL);
1811     }
1812
1813     /*
1814      *  On per-directory context (.htaccess) strip the location
1815      *  prefix from the URL to make sure patterns apply only to
1816      *  the local part.  Additionally indicate this special
1817      *  threatment in the logfile.
1818      */
1819     prefixstrip = 0;
1820     if (perdir != NULL) {
1821         if (   strlen(uri) >= strlen(perdir)
1822             && strncmp(uri, perdir, strlen(perdir)) == 0) {
1823             rewritelog(r, 3, "[per-dir %s] strip per-dir prefix: %s -> %s",
1824                        perdir, uri, uri+strlen(perdir));
1825             uri = uri+strlen(perdir);
1826             prefixstrip = 1;
1827         }
1828     }
1829
1830     /*
1831      *  Try to match the URI against the RewriteRule pattern
1832      *  and exit immeddiately if it didn't apply.
1833      */
1834     if (perdir == NULL) {
1835         rewritelog(r, 3, "applying pattern '%s' to uri '%s'",
1836                    p->pattern, uri);
1837     }
1838     else {
1839         rewritelog(r, 3, "[per-dir %s] applying pattern '%s' to uri '%s'",
1840                    perdir, p->pattern, uri);
1841     }
1842     rc = (ap_regexec(regexp, uri, regexp->re_nsub+1, regmatch, 0) == 0);
1843     if (! (( rc && !(p->flags & RULEFLAG_NOTMATCH)) ||
1844            (!rc &&  (p->flags & RULEFLAG_NOTMATCH))   ) ) {
1845         return 0;
1846     }
1847
1848     /*
1849      *  Else create the RewriteRule `regsubinfo' structure which
1850      *  holds the substitution information.
1851      */
1852     briRR = (backrefinfo *)apr_palloc(r->pool, sizeof(backrefinfo));
1853     if (!rc && (p->flags & RULEFLAG_NOTMATCH)) {
1854         /*  empty info on negative patterns  */
1855         briRR->source = "";
1856         briRR->nsub   = 0;
1857     }
1858     else {
1859         briRR->source = apr_pstrdup(r->pool, uri);
1860         briRR->nsub   = regexp->re_nsub;
1861         memcpy((void *)(briRR->regmatch), (void *)(regmatch),
1862                sizeof(regmatch));
1863     }
1864
1865     /*
1866      *  Initiallally create the RewriteCond backrefinfo with
1867      *  empty backrefinfo, i.e. not subst parts
1868      *  (this one is adjusted inside apply_rewrite_cond() later!!)
1869      */
1870     briRC = (backrefinfo *)apr_pcalloc(r->pool, sizeof(backrefinfo));
1871     briRC->source = "";
1872     briRC->nsub   = 0;
1873
1874     /*
1875      *  Ok, we already know the pattern has matched, but we now
1876      *  additionally have to check for all existing preconditions
1877      *  (RewriteCond) which have to be also true. We do this at
1878      *  this very late stage to avoid unnessesary checks which
1879      *  would slow down the rewriting engine!!
1880      */
1881     rewriteconds = p->rewriteconds;
1882     conds = (rewritecond_entry *)rewriteconds->elts;
1883     failed = 0;
1884     for (i = 0; i < rewriteconds->nelts; i++) {
1885         c = &conds[i];
1886         rc = apply_rewrite_cond(r, c, perdir, briRR, briRC);
1887         if (c->flags & CONDFLAG_ORNEXT) {
1888             /*
1889              *  The "OR" case
1890              */
1891             if (rc == 0) {
1892                 /*  One condition is false, but another can be
1893                  *  still true, so we have to continue...
1894                  */
1895                 apr_table_unset(r->notes, VARY_KEY_THIS);
1896                 continue;
1897             }
1898             else {
1899                 /*  One true condition is enough in "or" case, so
1900                  *  skip the other conditions which are "ornext"
1901                  *  chained
1902                  */
1903                 while (   i < rewriteconds->nelts
1904                        && c->flags & CONDFLAG_ORNEXT) {
1905                     i++;
1906                     c = &conds[i];
1907                 }
1908                 continue;
1909             }
1910         }
1911         else {
1912             /*
1913              *  The "AND" case, i.e. no "or" flag,
1914              *  so a single failure means total failure.
1915              */
1916             if (rc == 0) {
1917                 failed = 1;
1918                 break;
1919             }
1920         }
1921         vary = apr_table_get(r->notes, VARY_KEY_THIS);
1922         if (vary != NULL) {
1923             apr_table_merge(r->notes, VARY_KEY, vary);
1924             apr_table_unset(r->notes, VARY_KEY_THIS);
1925         }
1926     }
1927     /*  if any condition fails the complete rule fails  */
1928     if (failed) {
1929         apr_table_unset(r->notes, VARY_KEY);
1930         apr_table_unset(r->notes, VARY_KEY_THIS);
1931         return 0;
1932     }
1933
1934     /*
1935      * Regardless of what we do next, we've found a match.  Check to see
1936      * if any of the request header fields were involved, and add them
1937      * to the Vary field of the response.
1938      */
1939     if ((vary = apr_table_get(r->notes, VARY_KEY)) != NULL) {
1940         apr_table_merge(r->headers_out, "Vary", vary);
1941         apr_table_unset(r->notes, VARY_KEY);
1942     }
1943
1944     /*
1945      *  If this is a pure matching rule (`RewriteRule <pat> -')
1946      *  we stop processing and return immediately. The only thing
1947      *  we have not to forget are the environment variables
1948      *  (`RewriteRule <pat> - [E=...]')
1949      */
1950     if (strcmp(output, "-") == 0) {
1951         do_expand_env(r, p->env, briRR, briRC);
1952         if (p->forced_mimetype != NULL) {
1953             if (perdir == NULL) {
1954                 /* In the per-server context we can force the MIME-type
1955                  * the correct way by notifying our MIME-type hook handler
1956                  * to do the job when the MIME-type API stage is reached.
1957                  */
1958                 rewritelog(r, 2, "remember %s to have MIME-type '%s'",
1959                            r->filename, p->forced_mimetype);
1960                 apr_table_setn(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR,
1961                               p->forced_mimetype);
1962             }
1963             else {
1964                 /* In per-directory context we operate in the Fixup API hook
1965                  * which is after the MIME-type hook, so our MIME-type handler
1966                  * has no chance to set r->content_type. And because we are
1967                  * in the situation where no substitution takes place no
1968                  * sub-request will happen (which could solve the
1969                  * restriction). As a workaround we do it ourself now
1970                  * immediately although this is not strictly API-conforming.
1971                  * But it's the only chance we have...
1972                  */
1973                 rewritelog(r, 1, "[per-dir %s] force %s to have MIME-type "
1974                            "'%s'", perdir, r->filename, p->forced_mimetype);
1975                 r->content_type = p->forced_mimetype;
1976             }
1977         }
1978         return 2;
1979     }
1980
1981     /*
1982      *  Ok, now we finally know all patterns have matched and
1983      *  that there is something to replace, so we create the
1984      *  substitution URL string in `newuri'.
1985      */
1986     do_expand(r, output, newuri, sizeof(newuri), briRR, briRC);
1987     if (perdir == NULL) {
1988         rewritelog(r, 2, "rewrite %s -> %s", uri, newuri);
1989     }
1990     else {
1991         rewritelog(r, 2, "[per-dir %s] rewrite %s -> %s", perdir, uri, newuri);
1992     }
1993
1994     /*
1995      *  Additionally do expansion for the environment variable
1996      *  strings (`RewriteRule .. .. [E=<string>]').
1997      */
1998     do_expand_env(r, p->env, briRR, briRC);
1999
2000     /*
2001      *  Now replace API's knowledge of the current URI:
2002      *  Replace r->filename with the new URI string and split out
2003      *  an on-the-fly generated QUERY_STRING part into r->args
2004      */
2005     r->filename = apr_pstrdup(r->pool, newuri);
2006     splitout_queryargs(r, p->flags & RULEFLAG_QSAPPEND);
2007
2008     /*
2009      *   Again add the previously stripped per-directory location
2010      *   prefix if the new URI is not a new one for this
2011      *   location, i.e. if it's not starting with either a slash
2012      *   or a fully qualified URL scheme.
2013      */
2014     if (prefixstrip && r->filename[0] != '/'
2015         && !is_absolute_uri(r->filename)) {
2016         rewritelog(r, 3, "[per-dir %s] add per-dir prefix: %s -> %s%s",
2017                    perdir, r->filename, perdir, r->filename);
2018         r->filename = apr_pstrcat(r->pool, perdir, r->filename, NULL);
2019     }
2020
2021     /*
2022      *  If this rule is forced for proxy throughput
2023      *  (`RewriteRule ... ... [P]') then emulate mod_proxy's
2024      *  URL-to-filename handler to be sure mod_proxy is triggered
2025      *  for this URL later in the Apache API. But make sure it is
2026      *  a fully-qualified URL. (If not it is qualified with
2027      *  ourself).
2028      */
2029     if (p->flags & RULEFLAG_PROXY) {
2030         fully_qualify_uri(r);
2031         if (perdir == NULL) {
2032             rewritelog(r, 2, "forcing proxy-throughput with %s", r->filename);
2033         }
2034         else {
2035             rewritelog(r, 2, "[per-dir %s] forcing proxy-throughput with %s",
2036                        perdir, r->filename);
2037         }
2038         r->filename = apr_pstrcat(r->pool, "proxy:", r->filename, NULL);
2039         return 1;
2040     }
2041
2042     /*
2043      *  If this rule is explicitly forced for HTTP redirection
2044      *  (`RewriteRule .. .. [R]') then force an external HTTP
2045      *  redirect. But make sure it is a fully-qualified URL. (If
2046      *  not it is qualified with ourself).
2047      */
2048     if (p->flags & RULEFLAG_FORCEREDIRECT) {
2049         fully_qualify_uri(r);
2050         if (perdir == NULL) {
2051             rewritelog(r, 2,
2052                        "explicitly forcing redirect with %s", r->filename);
2053         }
2054         else {
2055             rewritelog(r, 2,
2056                        "[per-dir %s] explicitly forcing redirect with %s",
2057                        perdir, r->filename);
2058         }
2059         r->status = p->forced_responsecode;
2060         return 1;
2061     }
2062
2063     /*
2064      *  Special Rewriting Feature: Self-Reduction
2065      *  We reduce the URL by stripping a possible
2066      *  http[s]://<ourhost>[:<port>] prefix, i.e. a prefix which
2067      *  corresponds to ourself. This is to simplify rewrite maps
2068      *  and to avoid recursion, etc. When this prefix is not a
2069      *  coincidence then the user has to use [R] explicitly (see
2070      *  above).
2071      */
2072     reduce_uri(r);
2073
2074     /*
2075      *  If this rule is still implicitly forced for HTTP
2076      *  redirection (`RewriteRule .. <scheme>://...') then
2077      *  directly force an external HTTP redirect.
2078      */
2079     if (is_absolute_uri(r->filename)) {
2080         if (perdir == NULL) {
2081             rewritelog(r, 2,
2082                        "implicitly forcing redirect (rc=%d) with %s",
2083                        p->forced_responsecode, r->filename);
2084         }
2085         else {
2086             rewritelog(r, 2, "[per-dir %s] implicitly forcing redirect "
2087                        "(rc=%d) with %s", perdir, p->forced_responsecode,
2088                        r->filename);
2089         }
2090         r->status = p->forced_responsecode;
2091         return 1;
2092     }
2093
2094     /*
2095      *  Now we are sure it is not a fully qualified URL.  But
2096      *  there is still one special case left: A local rewrite in
2097      *  per-directory context, i.e. a substitution URL which does
2098      *  not start with a slash. Here we add again the initially
2099      *  stripped per-directory prefix.
2100      */
2101     if (prefixstrip && r->filename[0] != '/') {
2102         rewritelog(r, 3, "[per-dir %s] add per-dir prefix: %s -> %s%s",
2103                    perdir, r->filename, perdir, r->filename);
2104         r->filename = apr_pstrcat(r->pool, perdir, r->filename, NULL);
2105     }
2106
2107     /*
2108      *  Finally we had to remember if a MIME-type should be
2109      *  forced for this URL (`RewriteRule .. .. [T=<type>]')
2110      *  Later in the API processing phase this is forced by our
2111      *  MIME API-hook function. This time its no problem even for
2112      *  the per-directory context (where the MIME-type hook was
2113      *  already processed) because a sub-request happens ;-)
2114      */
2115     if (p->forced_mimetype != NULL) {
2116         apr_table_setn(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR,
2117                       p->forced_mimetype);
2118         if (perdir == NULL) {
2119             rewritelog(r, 2, "remember %s to have MIME-type '%s'",
2120                        r->filename, p->forced_mimetype);
2121         }
2122         else {
2123             rewritelog(r, 2,
2124                        "[per-dir %s] remember %s to have MIME-type '%s'",
2125                        perdir, r->filename, p->forced_mimetype);
2126         }
2127     }
2128
2129     /*
2130      *  Puuhhhhhhhh... WHAT COMPLICATED STUFF ;_)
2131      *  But now we're done for this particular rule.
2132      */
2133     return 1;
2134 }
2135
2136 static int apply_rewrite_cond(request_rec *r, rewritecond_entry *p,
2137                               char *perdir, backrefinfo *briRR,
2138                               backrefinfo *briRC)
2139 {
2140     char input[MAX_STRING_LEN];
2141     apr_finfo_t sb;
2142     request_rec *rsub;
2143     regmatch_t regmatch[MAX_NMATCH];
2144     int rc;
2145
2146     /*
2147      *   Construct the string we match against
2148      */
2149
2150     do_expand(r, p->input, input, sizeof(input), briRR, briRC);
2151
2152     /*
2153      *   Apply the patterns
2154      */
2155
2156     rc = 0;
2157     if (strcmp(p->pattern, "-f") == 0) {
2158         if (apr_stat(&sb, input, r->pool) == APR_SUCCESS) {
2159             if (sb.filetype == APR_REG) {
2160                 rc = 1;
2161             }
2162         }
2163     }
2164     else if (strcmp(p->pattern, "-s") == 0) {
2165         if (apr_stat(&sb, input, r->pool) == APR_SUCCESS) {
2166             if ((sb.filetype == APR_REG) && sb.size > 0) {
2167                 rc = 1;
2168             }
2169         }
2170     }
2171     else if (strcmp(p->pattern, "-l") == 0) {
2172 #if !defined(OS2) && !defined(WIN32)
2173         if (apr_lstat(&sb, input, r->pool) == APR_SUCCESS) {
2174             if (sb.filetype == APR_LNK) {
2175                 rc = 1;
2176             }
2177         }
2178 #endif
2179     }
2180     else if (strcmp(p->pattern, "-d") == 0) {
2181         if (apr_stat(&sb, input, r->pool) == APR_SUCCESS) {
2182             if (sb.filetype == APR_DIR) {
2183                 rc = 1;
2184             }
2185         }
2186     }
2187     else if (strcmp(p->pattern, "-U") == 0) {
2188         /* avoid infinite subrequest recursion */
2189         if (strlen(input) > 0 && subreq_ok(r)) {
2190
2191             /* run a URI-based subrequest */
2192             rsub = ap_sub_req_lookup_uri(input, r);
2193
2194             /* URI exists for any result up to 3xx, redirects allowed */
2195             if (rsub->status < 400)
2196                 rc = 1;
2197
2198             /* log it */
2199             rewritelog(r, 5, "RewriteCond URI (-U) check: "
2200                        "path=%s -> status=%d", input, rsub->status);
2201
2202             /* cleanup by destroying the subrequest */
2203             ap_destroy_sub_req(rsub);
2204         }
2205     }
2206     else if (strcmp(p->pattern, "-F") == 0) {
2207         /* avoid infinite subrequest recursion */
2208         if (strlen(input) > 0 && subreq_ok(r)) {
2209
2210             /* process a file-based subrequest:
2211              * this differs from -U in that no path translation is done.
2212              */
2213             rsub = ap_sub_req_lookup_file(input, r);
2214
2215             /* file exists for any result up to 2xx, no redirects */
2216             if (rsub->status < 300 &&
2217                 /* double-check that file exists since default result is 200 */
2218                 apr_stat(&sb, rsub->filename, r->pool) == APR_SUCCESS) {
2219                 rc = 1;
2220             }
2221
2222             /* log it */
2223             rewritelog(r, 5, "RewriteCond file (-F) check: path=%s "
2224                        "-> file=%s status=%d", input, rsub->filename,
2225                        rsub->status);
2226
2227             /* cleanup by destroying the subrequest */
2228             ap_destroy_sub_req(rsub);
2229         }
2230     }
2231     else if (strlen(p->pattern) > 1 && *(p->pattern) == '>') {
2232         rc = (compare_lexicography(input, p->pattern+1) == 1 ? 1 : 0);
2233     }
2234     else if (strlen(p->pattern) > 1 && *(p->pattern) == '<') {
2235         rc = (compare_lexicography(input, p->pattern+1) == -1 ? 1 : 0);
2236     }
2237     else if (strlen(p->pattern) > 1 && *(p->pattern) == '=') {
2238         if (strcmp(p->pattern+1, "\"\"") == 0) {
2239             rc = (*input == '\0');
2240         }
2241         else {
2242             rc = (strcmp(input, p->pattern+1) == 0 ? 1 : 0);
2243         }
2244     }
2245     else {
2246         /* it is really a regexp pattern, so apply it */
2247         rc = (ap_regexec(p->regexp, input,
2248                          p->regexp->re_nsub+1, regmatch,0) == 0);
2249
2250         /* if it isn't a negated pattern and really matched
2251            we update the passed-through regex subst info structure */
2252         if (rc && !(p->flags & CONDFLAG_NOTMATCH)) {
2253             briRC->source = apr_pstrdup(r->pool, input);
2254             briRC->nsub   = p->regexp->re_nsub;
2255             memcpy((void *)(briRC->regmatch), (void *)(regmatch),
2256                    sizeof(regmatch));
2257         }
2258     }
2259
2260     /* if this is a non-matching regexp, just negate the result */
2261     if (p->flags & CONDFLAG_NOTMATCH) {
2262         rc = !rc;
2263     }
2264
2265     rewritelog(r, 4, "RewriteCond: input='%s' pattern='%s%s' => %s",
2266                input, (p->flags & CONDFLAG_NOTMATCH ? "!" : ""),
2267                p->pattern, rc ? "matched" : "not-matched");
2268
2269     /* end just return the result */
2270     return rc;
2271 }
2272
2273
2274 /*
2275 ** +-------------------------------------------------------+
2276 ** |                                                       |
2277 ** |              URL transformation functions
2278 ** |                                                       |
2279 ** +-------------------------------------------------------+
2280 */
2281
2282
2283 /*
2284 **
2285 **  perform all the expansions on the input string
2286 **  leaving the result in the supplied buffer
2287 **
2288 */
2289
2290 static void do_expand(request_rec *r, char *input, char *buffer, int nbuf,
2291                        backrefinfo *briRR, backrefinfo *briRC)
2292 {
2293     char *inp, *outp;
2294     size_t span, space;
2295
2296     /*
2297      * for security reasons this expansion must be perfomed in a
2298      * single pass, otherwise an attacker can arrange for the result
2299      * of an earlier expansion to include expansion specifiers that
2300      * are interpreted by a later expansion, producing results that
2301      * were not intended by the administrator.
2302      */
2303
2304     inp = input;
2305     outp = buffer;
2306     space = nbuf - 1; /* room for '\0' */
2307
2308     for (;;) {
2309         span = strcspn(inp, "$%");
2310         if (span > space) {
2311             span = space;
2312         }
2313         memcpy(outp, inp, span);
2314         inp += span;
2315         outp += span;
2316         space -= span;
2317         if (space == 0 || *inp == '\0') {
2318             break;
2319         }
2320         /* now we have a '$' or a '%' */
2321         if (inp[1] == '{') {
2322             char *endp;
2323             endp = find_closing_bracket(inp+2, '{', '}');
2324             if (endp == NULL) {
2325                 goto skip;
2326             }
2327             *endp = '\0';
2328             if (inp[0] == '$') {
2329                 /* ${...} map lookup expansion */
2330                 /*
2331                  * To make rewrite maps useful the lookup key and
2332                  * default values must be expanded, so we make
2333                  * recursive calls to do the work. For security
2334                  * reasons we must never expand a string that includes
2335                  * verbatim data from the network. The recursion here
2336                  * isn't a problem because the result of expansion is
2337                  * only passed to lookup_map() so it cannot be
2338                  * re-expanded, only re-looked-up. Another way of
2339                  * looking at it is that the recursion is entirely
2340                  * driven by the syntax of the nested curly brackets.
2341                  */
2342                 char *key, *dflt, *result;
2343                 char xkey[MAX_STRING_LEN];
2344                 char xdflt[MAX_STRING_LEN];
2345                 char *empty = "";
2346                 key = strchr(inp, ':');
2347                 if (key == NULL) {
2348                     *endp = '}';
2349                     goto skip;
2350                 }
2351                 *key++ = '\0';
2352                 dflt = strchr(key, '|');
2353                 if (dflt == NULL) {
2354                     dflt = empty;
2355                 }
2356                 else {
2357                     *dflt++ = '\0';
2358                 }
2359                 do_expand(r, key,  xkey,  sizeof(xkey),  briRR, briRC);
2360                 do_expand(r, dflt, xdflt, sizeof(xdflt), briRR, briRC);
2361                 result = lookup_map(r, inp+2, xkey);
2362                 if (result == NULL) {
2363                     result = xdflt;
2364                 }
2365                 span = apr_cpystrn(outp, result, space) - outp;
2366                 key[-1] = ':';
2367                 if (dflt != empty) {
2368                     dflt[-1] = '|';
2369                 }
2370             }
2371             else if (inp[0] == '%') {
2372                 /* %{...} variable lookup expansion */
2373                 span = apr_cpystrn(outp, lookup_variable(r, inp+2), space) - outp;
2374             }
2375             else {
2376                 span = 0;
2377             }
2378             *endp = '}';
2379             inp = endp+1;
2380             outp += span;
2381             space -= span;
2382             continue;
2383         }
2384         else if (apr_isdigit(inp[1])) {
2385             int n = inp[1] - '0';
2386             backrefinfo *bri = NULL;
2387             if (inp[0] == '$') {
2388                 /* $N RewriteRule regexp backref expansion */
2389                 bri = briRR;
2390             }
2391             else if (inp[0] == '%') {
2392                 /* %N RewriteCond regexp backref expansion */
2393                 bri = briRC;
2394             }
2395             /* see ap_pregsub() in src/main/util.c */
2396             if (bri && n <= bri->nsub &&
2397                 bri->regmatch[n].rm_eo > bri->regmatch[n].rm_so) {
2398                 span = bri->regmatch[n].rm_eo - bri->regmatch[n].rm_so;
2399                 if (span > space) {
2400                     span = space;
2401                 }
2402                 memcpy(outp, bri->source + bri->regmatch[n].rm_so, span);
2403                 outp += span;
2404                 space -= span;
2405             }
2406             inp += 2;
2407             continue;
2408         }
2409     skip:
2410         *outp++ = *inp++;
2411         space--;
2412     }
2413     *outp++ = '\0';
2414 }
2415
2416
2417 /*
2418 **
2419 **  perform all the expansions on the environment variables
2420 **
2421 */
2422
2423 static void do_expand_env(request_rec *r, char *env[],
2424                           backrefinfo *briRR, backrefinfo *briRC)
2425 {
2426     int i;
2427     char buf[MAX_STRING_LEN];
2428
2429     for (i = 0; env[i] != NULL; i++) {
2430         do_expand(r, env[i], buf, sizeof(buf), briRR, briRC);
2431         add_env_variable(r, buf);
2432     }
2433 }
2434
2435
2436 /*
2437 **
2438 **  split out a QUERY_STRING part from
2439 **  the current URI string
2440 **
2441 */
2442
2443 static void splitout_queryargs(request_rec *r, int qsappend)
2444 {
2445     char *q;
2446     char *olduri;
2447
2448     q = strchr(r->filename, '?');
2449     if (q != NULL) {
2450         olduri = apr_pstrdup(r->pool, r->filename);
2451         *q++ = '\0';
2452         if (qsappend) {
2453             r->args = apr_pstrcat(r->pool, q, "&", r->args, NULL);
2454         }
2455         else {
2456             r->args = apr_pstrdup(r->pool, q);
2457         }
2458         if (strlen(r->args) == 0) {
2459             r->args = NULL;
2460             rewritelog(r, 3, "split uri=%s -> uri=%s, args=<none>", olduri,
2461                        r->filename);
2462         }
2463         else {
2464             if (r->args[strlen(r->args)-1] == '&') {
2465                 r->args[strlen(r->args)-1] = '\0';
2466             }
2467             rewritelog(r, 3, "split uri=%s -> uri=%s, args=%s", olduri,
2468                        r->filename, r->args);
2469         }
2470     }
2471     return;
2472 }
2473
2474
2475 /*
2476 **
2477 **  strip 'http[s]://ourhost/' from URI
2478 **
2479 */
2480
2481 static void reduce_uri(request_rec *r)
2482 {
2483     char *cp;
2484     unsigned short port;
2485     char *portp;
2486     char *hostp;
2487     char *url;
2488     char c;
2489     char host[LONG_STRING_LEN];
2490     char buf[MAX_STRING_LEN];
2491     char *olduri;
2492     int l;
2493
2494     cp = (char *)ap_http_method(r);
2495     l  = strlen(cp);
2496     if (   strlen(r->filename) > l+3
2497         && strncasecmp(r->filename, cp, l) == 0
2498         && r->filename[l]   == ':'
2499         && r->filename[l+1] == '/'
2500         && r->filename[l+2] == '/'             ) {
2501         /* there was really a rewrite to a remote path */
2502
2503         olduri = apr_pstrdup(r->pool, r->filename); /* save for logging */
2504
2505         /* cut the hostname and port out of the URI */
2506         apr_cpystrn(buf, r->filename+(l+3), sizeof(buf));
2507         hostp = buf;
2508         for (cp = hostp; *cp != '\0' && *cp != '/' && *cp != ':'; cp++)
2509             ;
2510         if (*cp == ':') {
2511             /* set host */
2512             *cp++ = '\0';
2513             apr_cpystrn(host, hostp, sizeof(host));
2514             /* set port */
2515             portp = cp;
2516             for (; *cp != '\0' && *cp != '/'; cp++)
2517                 ;
2518             c = *cp;
2519             *cp = '\0';
2520             port = atoi(portp);
2521             *cp = c;
2522             /* set remaining url */
2523             url = cp;
2524         }
2525         else if (*cp == '/') {
2526             /* set host */
2527             *cp = '\0';
2528             apr_cpystrn(host, hostp, sizeof(host));
2529             *cp = '/';
2530             /* set port */
2531             port = ap_default_port(r);
2532             /* set remaining url */
2533             url = cp;
2534         }
2535         else {
2536             /* set host */
2537             apr_cpystrn(host, hostp, sizeof(host));
2538             /* set port */
2539             port = ap_default_port(r);
2540             /* set remaining url */
2541             url = "/";
2542         }
2543
2544         /* now check whether we could reduce it to a local path... */
2545         if (ap_matches_request_vhost(r, host, port)) {
2546             /* this is our host, so only the URL remains */
2547             r->filename = apr_pstrdup(r->pool, url);
2548             rewritelog(r, 3, "reduce %s -> %s", olduri, r->filename);
2549         }
2550     }
2551     return;
2552 }
2553
2554
2555 /*
2556 **
2557 **  add 'http[s]://ourhost[:ourport]/' to URI
2558 **  if URI is still not fully qualified
2559 **
2560 */
2561
2562 static void fully_qualify_uri(request_rec *r)
2563 {
2564     char buf[32];
2565     const char *thisserver;
2566     char *thisport;
2567     int port;
2568
2569     if (!is_absolute_uri(r->filename)) {
2570
2571         thisserver = ap_get_server_name(r);
2572         port = ap_get_server_port(r);
2573         if (ap_is_default_port(port,r)) {
2574             thisport = "";
2575         }
2576         else {
2577             apr_snprintf(buf, sizeof(buf), ":%u", port);
2578             thisport = buf;
2579         }
2580
2581         if (r->filename[0] == '/') {
2582             r->filename = apr_psprintf(r->pool, "%s://%s%s%s",
2583                                       ap_http_method(r), thisserver,
2584                                       thisport, r->filename);
2585         }
2586         else {
2587             r->filename = apr_psprintf(r->pool, "%s://%s%s/%s",
2588                                       ap_http_method(r), thisserver,
2589                                       thisport, r->filename);
2590         }
2591     }
2592     return;
2593 }
2594
2595
2596 /*
2597 **
2598 **  return non-zero if the URI is absolute (includes a scheme etc.)
2599 **
2600 */
2601
2602 static int is_absolute_uri(char *uri)
2603 {
2604     int i = strlen(uri);
2605     if (   (i > 7 && strncasecmp(uri, "http://",   7) == 0)
2606         || (i > 8 && strncasecmp(uri, "https://",  8) == 0)
2607         || (i > 9 && strncasecmp(uri, "gopher://", 9) == 0)
2608         || (i > 6 && strncasecmp(uri, "ftp://",    6) == 0)
2609         || (i > 5 && strncasecmp(uri, "ldap:",     5) == 0)
2610         || (i > 5 && strncasecmp(uri, "news:",     5) == 0)
2611         || (i > 7 && strncasecmp(uri, "mailto:",   7) == 0) ) {
2612         return 1;
2613     }
2614     else {
2615         return 0;
2616     }
2617 }
2618
2619
2620 /*
2621 **
2622 **  Expand tilde-paths (/~user) through
2623 **  Unix /etc/passwd database information
2624 **
2625 */
2626 #if !defined(WIN32) && !defined(NETWARE)
2627 static char *expand_tildepaths(request_rec *r, char *uri)
2628 {
2629     char user[LONG_STRING_LEN];
2630     struct passwd *pw;
2631     char *newuri;
2632     int i, j;
2633 #if APR_HAS_THREADS && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
2634     struct passwd pwd;
2635     size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
2636     char *buf = apr_pcalloc(r->pool, buflen);
2637 #endif
2638
2639     newuri = uri;
2640     if (uri != NULL && strlen(uri) > 2 && uri[0] == '/' && uri[1] == '~') {
2641         /* cut out the username */
2642         for (j = 0, i = 2; j < sizeof(user)-1
2643                && uri[i] != '\0'
2644                && uri[i] != '/'  ; ) {
2645             user[j++] = uri[i++];
2646         }
2647         user[j] = '\0';
2648
2649         /* lookup username in systems passwd file */
2650 #if APR_HAS_THREADS && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
2651         if (!getpwnam_r(user, &pwd, buf, buflen, &pw)) {
2652 #else
2653         if ((pw = getpwnam(user)) != NULL) {
2654 #endif
2655             /* ok, user was found, so expand the ~user string */
2656             if (uri[i] != '\0') {
2657                 /* ~user/anything...  has to be expanded */
2658                 if (pw->pw_dir[strlen(pw->pw_dir)-1] == '/') {
2659                     pw->pw_dir[strlen(pw->pw_dir)-1] = '\0';
2660                 }
2661                 newuri = apr_pstrcat(r->pool, pw->pw_dir, uri+i, NULL);
2662             }
2663             else {
2664                 /* only ~user has to be expanded */
2665                 newuri = apr_pstrdup(r->pool, pw->pw_dir);
2666             }
2667         }
2668     }
2669     return newuri;
2670 }
2671 #endif
2672
2673
2674
2675 /*
2676 ** +-------------------------------------------------------+
2677 ** |                                                       |
2678 ** |              DBM hashfile support
2679 ** |                                                       |
2680 ** +-------------------------------------------------------+
2681 */
2682
2683
2684 static char *lookup_map(request_rec *r, char *name, char *key)
2685 {
2686     void *sconf;
2687     rewrite_server_conf *conf;
2688     apr_array_header_t *rewritemaps;
2689     rewritemap_entry *entries;
2690     rewritemap_entry *s;
2691     char *value;
2692     apr_finfo_t st;
2693     apr_status_t rv;
2694     int i;
2695
2696     /* get map configuration */
2697     sconf = r->server->module_config;
2698     conf  = (rewrite_server_conf *)ap_get_module_config(sconf,
2699                                                         &rewrite_module);
2700     rewritemaps = conf->rewritemaps;
2701
2702     entries = (rewritemap_entry *)rewritemaps->elts;
2703     for (i = 0; i < rewritemaps->nelts; i++) {
2704         s = &entries[i];
2705         if (strcmp(s->name, name) == 0) {
2706             if (s->type == MAPTYPE_TXT) {
2707                 if ((rv = apr_stat(&st, s->checkfile, r->pool)) != APR_SUCCESS) {
2708                     ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
2709                                  "mod_rewrite: can't access text RewriteMap "
2710                                  "file %s", s->checkfile);
2711                     rewritelog(r, 1, "can't open RewriteMap file, "
2712                                "see error log");
2713                     return NULL;
2714                 }
2715                 value = get_cache_string(cachep, s->name, CACHEMODE_TS,
2716                                          st.mtime, key);
2717                 if (value == NULL) {
2718                     rewritelog(r, 6, "cache lookup FAILED, forcing new "
2719                                "map lookup");
2720                     if ((value =
2721                          lookup_map_txtfile(r, s->datafile, key)) != NULL) {
2722                         rewritelog(r, 5, "map lookup OK: map=%s key=%s[txt] "
2723                                    "-> val=%s", s->name, key, value);
2724                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2725                                          st.mtime, key, value);
2726                         return value;
2727                     }
2728                     else {
2729                         rewritelog(r, 5, "map lookup FAILED: map=%s[txt] "
2730                                    "key=%s", s->name, key);
2731                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2732                                          st.mtime, key, "");
2733                         return NULL;
2734                     }
2735                 }
2736                 else {
2737                     rewritelog(r, 5, "cache lookup OK: map=%s[txt] key=%s "
2738                                "-> val=%s", s->name, key, value);
2739                     return value[0] != '\0' ? value : NULL;
2740                 }
2741             }
2742             else if (s->type == MAPTYPE_DBM) {
2743 #ifndef NO_DBM_REWRITEMAP
2744                 if ((rv = apr_stat(&st, s->checkfile, r->pool)) != APR_SUCCESS) {
2745                     ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
2746                                  "mod_rewrite: can't access DBM RewriteMap "
2747                                  "file %s", s->checkfile);
2748                     rewritelog(r, 1, "can't open DBM RewriteMap file, "
2749                                "see error log");
2750                     return NULL;
2751                 }
2752                 value = get_cache_string(cachep, s->name, CACHEMODE_TS,
2753                                          st.mtime, key);
2754                 if (value == NULL) {
2755                     rewritelog(r, 6,
2756                                "cache lookup FAILED, forcing new map lookup");
2757                     if ((value =
2758                          lookup_map_dbmfile(r, s->datafile, key)) != NULL) {
2759                         rewritelog(r, 5, "map lookup OK: map=%s[dbm] key=%s "
2760                                    "-> val=%s", s->name, key, value);
2761                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2762                                          st.mtime, key, value);
2763                         return value;
2764                     }
2765                     else {
2766                         rewritelog(r, 5, "map lookup FAILED: map=%s[dbm] "
2767                                    "key=%s", s->name, key);
2768                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2769                                          st.mtime, key, "");
2770                         return NULL;
2771                     }
2772                 }
2773                 else {
2774                     rewritelog(r, 5, "cache lookup OK: map=%s[dbm] key=%s "
2775                                "-> val=%s", s->name, key, value);
2776                     return value[0] != '\0' ? value : NULL;
2777                 }
2778 #else
2779                 return NULL;
2780 #endif
2781             }
2782             else if (s->type == MAPTYPE_PRG) {
2783                 if ((value =
2784                      lookup_map_program(r, s->fpin, s->fpout, key)) != NULL) {
2785                     rewritelog(r, 5, "map lookup OK: map=%s key=%s -> val=%s",
2786                                s->name, key, value);
2787                     return value;
2788                 }
2789                 else {
2790                     rewritelog(r, 5, "map lookup FAILED: map=%s key=%s",
2791                                s->name, key);
2792                 }
2793             }
2794             else if (s->type == MAPTYPE_INT) {
2795                 if ((value = lookup_map_internal(r, s->func, key)) != NULL) {
2796                     rewritelog(r, 5, "map lookup OK: map=%s key=%s -> val=%s",
2797                                s->name, key, value);
2798                     return value;
2799                 }
2800                 else {
2801                     rewritelog(r, 5, "map lookup FAILED: map=%s key=%s",
2802                                s->name, key);
2803                 }
2804             }
2805             else if (s->type == MAPTYPE_RND) {
2806                 if ((rv = apr_stat(&st, s->checkfile, r->pool)) != APR_SUCCESS) {
2807                     ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
2808                                  "mod_rewrite: can't access text RewriteMap "
2809                                  "file %s", s->checkfile);
2810                     rewritelog(r, 1, "can't open RewriteMap file, "
2811                                "see error log");
2812                     return NULL;
2813                 }
2814                 value = get_cache_string(cachep, s->name, CACHEMODE_TS,
2815                                          st.mtime, key);
2816                 if (value == NULL) {
2817                     rewritelog(r, 6, "cache lookup FAILED, forcing new "
2818                                "map lookup");
2819                     if ((value =
2820                          lookup_map_txtfile(r, s->datafile, key)) != NULL) {
2821                         rewritelog(r, 5, "map lookup OK: map=%s key=%s[txt] "
2822                                    "-> val=%s", s->name, key, value);
2823                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2824                                          st.mtime, key, value);
2825                     }
2826                     else {
2827                         rewritelog(r, 5, "map lookup FAILED: map=%s[txt] "
2828                                    "key=%s", s->name, key);
2829                         set_cache_string(cachep, s->name, CACHEMODE_TS,
2830                                          st.mtime, key, "");
2831                         return NULL;
2832                     }
2833                 }
2834                 else {
2835                     rewritelog(r, 5, "cache lookup OK: map=%s[txt] key=%s "
2836                                "-> val=%s", s->name, key, value);
2837                 }
2838                 if (value[0] != '\0') {
2839                    value = select_random_value_part(r, value);
2840                    rewritelog(r, 5, "randomly choosen the subvalue `%s'", value);
2841                 }
2842                 else {
2843                     value = NULL;
2844                 }
2845                 return value;
2846             }
2847         }
2848     }
2849     return NULL;
2850 }
2851
2852 static char *lookup_map_txtfile(request_rec *r, const char *file, char *key)
2853 {
2854     apr_file_t *fp = NULL;
2855     apr_status_t rc;
2856     char line[1024];
2857     char *value = NULL;
2858     char *cpT;
2859     size_t skip;
2860     char *curkey;
2861     char *curval;
2862
2863     rc = apr_open(&fp, file, APR_READ, APR_OS_DEFAULT, r->pool);
2864     if (rc != APR_SUCCESS) {
2865        return NULL;
2866     }
2867
2868     while (apr_fgets(line, sizeof(line), fp) == APR_SUCCESS) {
2869         if (line[0] == '#')
2870             continue; /* ignore comments */
2871         cpT = line;
2872         curkey = cpT;
2873         skip = strcspn(cpT," \t\r\n");
2874         if (skip == 0)
2875             continue; /* ignore lines that start with a space, tab, CR, or LF */
2876         cpT += skip;
2877         *cpT = '\0';
2878         if (strcmp(curkey, key) != 0)
2879             continue; /* key does not match... */
2880
2881         /* found a matching key; now extract and return the value */
2882         ++cpT;
2883         skip = strspn(cpT, " \t\r\n");
2884         cpT += skip;
2885         curval = cpT;
2886         skip = strcspn(cpT, " \t\r\n");
2887         if (skip == 0)
2888             continue; /* no value... */
2889         cpT += skip;
2890         *cpT = '\0';
2891         value = apr_pstrdup(r->pool, curval);
2892         break;
2893     }
2894     apr_close(fp);
2895     return value;
2896 }
2897
2898 #ifndef NO_DBM_REWRITEMAP
2899 static char *lookup_map_dbmfile(request_rec *r, const char *file, char *key)
2900 {
2901     DBM *dbmfp = NULL;
2902     datum dbmkey;
2903     datum dbmval;
2904     char *value = NULL;
2905     char buf[MAX_STRING_LEN];
2906
2907     dbmkey.dptr  = key;
2908     dbmkey.dsize = strlen(key);
2909     if ((dbmfp = dbm_open(file, O_RDONLY, 0666)) != NULL) {
2910         dbmval = dbm_fetch(dbmfp, dbmkey);
2911         if (dbmval.dptr != NULL) {
2912             memcpy(buf, dbmval.dptr,
2913                    dbmval.dsize < sizeof(buf)-1 ?
2914                    dbmval.dsize : sizeof(buf)-1  );
2915             buf[dbmval.dsize] = '\0';
2916             value = apr_pstrdup(r->pool, buf);
2917         }
2918         dbm_close(dbmfp);
2919     }
2920     return value;
2921 }
2922 #endif
2923
2924 static char *lookup_map_program(request_rec *r, apr_file_t *fpin,
2925                                 apr_file_t *fpout, char *key)
2926 {
2927     char buf[LONG_STRING_LEN];
2928     char c;
2929     int i;
2930     apr_size_t nbytes;
2931
2932 #ifndef NO_WRITEV
2933     struct iovec iova[2];
2934     apr_size_t niov;
2935 #endif
2936
2937     /* when `RewriteEngine off' was used in the per-server
2938      * context then the rewritemap-programs were not spawned.
2939      * In this case using such a map (usually in per-dir context)
2940      * is useless because it is not available.
2941      */
2942     if (fpin == NULL || fpout == NULL) {
2943         return NULL;
2944     }
2945
2946     /* take the lock */
2947
2948     if (rewrite_mapr_lock) {
2949         apr_lock(rewrite_mapr_lock);
2950     }
2951
2952     /* write out the request key */
2953 #ifdef NO_WRITEV
2954     nbytes = strlen(key);
2955     apr_write(fpin, key, &nbytes);
2956     nbytes = 1;
2957     apr_write(fpin, "\n", &nbytes);
2958 #else
2959     iova[0].iov_base = key;
2960     iova[0].iov_len = strlen(key);
2961     iova[1].iov_base = "\n";
2962     iova[1].iov_len = 1;
2963
2964     niov = 2;
2965     apr_writev(fpin, iova, niov, &nbytes);
2966 #endif
2967
2968     /* read in the response value */
2969     i = 0;
2970     nbytes = 1;
2971     apr_read(fpout, &c, &nbytes);
2972     while (nbytes == 1 && (i < LONG_STRING_LEN-1)) {
2973         if (c == '\n') {
2974             break;
2975         }
2976         buf[i++] = c;
2977
2978         apr_read(fpout, &c, &nbytes);
2979     }
2980     buf[i] = '\0';
2981
2982     /* give the lock back */
2983     if (rewrite_mapr_lock) {
2984         apr_unlock(rewrite_mapr_lock);
2985     }
2986
2987     if (strcasecmp(buf, "NULL") == 0) {
2988         return NULL;
2989     }
2990     else {
2991         return apr_pstrdup(r->pool, buf);
2992     }
2993 }
2994
2995 static char *lookup_map_internal(request_rec *r,
2996                                  char *(*func)(request_rec *, char *),
2997                                  char *key)
2998 {
2999     /* currently we just let the function convert
3000        the key to a corresponding value */
3001     return func(r, key);
3002 }
3003
3004 static char *rewrite_mapfunc_toupper(request_rec *r, char *key)
3005 {
3006     char *value, *cp;
3007
3008     for (cp = value = apr_pstrdup(r->pool, key); cp != NULL && *cp != '\0';
3009          cp++) {
3010         *cp = apr_toupper(*cp);
3011     }
3012     return value;
3013 }
3014
3015 static char *rewrite_mapfunc_tolower(request_rec *r, char *key)
3016 {
3017     char *value, *cp;
3018
3019     for (cp = value = apr_pstrdup(r->pool, key); cp != NULL && *cp != '\0';
3020          cp++) {
3021         *cp = apr_tolower(*cp);
3022     }
3023     return value;
3024 }
3025
3026 static char *rewrite_mapfunc_escape(request_rec *r, char *key)
3027 {
3028     char *value;
3029
3030     value = ap_escape_uri(r->pool, key);
3031     return value;
3032 }
3033
3034 static char *rewrite_mapfunc_unescape(request_rec *r, char *key)
3035 {
3036     char *value;
3037
3038     value = apr_pstrdup(r->pool, key);
3039     ap_unescape_url(value);
3040     return value;
3041 }
3042
3043 static int rewrite_rand_init_done = 0;
3044
3045 static void rewrite_rand_init(void)
3046 {
3047     if (!rewrite_rand_init_done) {
3048         srand((unsigned)(getpid()));
3049         rewrite_rand_init_done = 1;
3050     }
3051     return;
3052 }
3053
3054 static int rewrite_rand(int l, int h)
3055 {
3056     rewrite_rand_init();
3057
3058     /* Get [0,1) and then scale to the appropriate range. Note that using
3059      * a floating point value ensures that we use all bits of the rand()
3060      * result. Doing an integer modulus would only use the lower-order bits
3061      * which may not be as uniformly random.
3062      */
3063     return ((double)(rand() % RAND_MAX) / RAND_MAX) * (h - l + 1) + l;
3064 }
3065
3066 static char *select_random_value_part(request_rec *r, char *value)
3067 {
3068     char *buf;
3069     int n, i, k;
3070
3071     /*  count number of distinct values  */
3072     for (n = 1, i = 0; value[i] != '\0'; i++) {
3073         if (value[i] == '|') {
3074             n++;
3075         }
3076     }
3077
3078     /*  when only one value we have no option to choose  */
3079     if (n == 1) {
3080         return value;
3081     }
3082
3083     /*  else randomly select one  */
3084     k = rewrite_rand(1, n);
3085
3086     /*  and grep it out  */
3087     for (n = 1, i = 0; value[i] != '\0'; i++) {
3088         if (n == k) {
3089             break;
3090         }
3091         if (value[i] == '|') {
3092             n++;
3093         }
3094     }
3095     buf = apr_pstrdup(r->pool, &value[i]);
3096     for (i = 0; buf[i] != '\0' && buf[i] != '|'; i++)
3097         ;
3098     buf[i] = '\0';
3099     return buf;
3100 }
3101
3102
3103 /*
3104 ** +-------------------------------------------------------+
3105 ** |                                                       |
3106 ** |              rewriting logfile support
3107 ** |                                                       |
3108 ** +-------------------------------------------------------+
3109 */
3110
3111
3112 static void open_rewritelog(server_rec *s, apr_pool_t *p)
3113 {
3114     rewrite_server_conf *conf;
3115     const char *fname;
3116     apr_status_t rc;
3117     piped_log *pl;
3118     int    rewritelog_flags = ( APR_WRITE | APR_APPEND | APR_CREATE );
3119     mode_t rewritelog_mode  = ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD );
3120
3121     conf = ap_get_module_config(s->module_config, &rewrite_module);
3122
3123     if (conf->rewritelogfile == NULL) {
3124         return;
3125     }
3126     if (*(conf->rewritelogfile) == '\0') {
3127         return;
3128     }
3129     if (conf->rewritelogfp != NULL) {
3130         return; /* virtual log shared w/ main server */
3131     }
3132
3133     fname = ap_server_root_relative(p, conf->rewritelogfile);
3134
3135     if (*conf->rewritelogfile == '|') {
3136         if ((pl = ap_open_piped_log(p, conf->rewritelogfile+1)) == NULL) {
3137             ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, s,
3138                          "mod_rewrite: could not open reliable pipe "
3139                          "to RewriteLog filter %s", conf->rewritelogfile+1);
3140             exit(1);
3141         }
3142         conf->rewritelogfp = ap_piped_log_write_fd(pl);
3143     }
3144     else if (*conf->rewritelogfile != '\0') {
3145         rc = apr_open(&conf->rewritelogfp, fname, rewritelog_flags, rewritelog_mode, p);
3146         if (rc != APR_SUCCESS)  {
3147             ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
3148                          "mod_rewrite: could not open RewriteLog "
3149                          "file %s", fname);
3150             exit(1);
3151         }
3152     }
3153     return;
3154 }
3155
3156 static void rewritelog(request_rec *r, int level, const char *text, ...)
3157 {
3158     rewrite_server_conf *conf;
3159     conn_rec *conn;
3160     char *str1;
3161     char str2[512];
3162     char str3[1024];
3163     char type[20];
3164     char redir[20];
3165     va_list ap;
3166     int i;
3167     apr_size_t nbytes;
3168     request_rec *req;
3169     char *ruser;
3170     const char *rhost;
3171
3172     va_start(ap, text);
3173     conf = ap_get_module_config(r->server->module_config, &rewrite_module);
3174     conn = r->connection;
3175
3176     if (conf->rewritelogfp == NULL) {
3177         return;
3178     }
3179     if (conf->rewritelogfile == NULL) {
3180         return;
3181     }
3182     if (*(conf->rewritelogfile) == '\0') {
3183         return;
3184     }
3185
3186     if (level > conf->rewriteloglevel) {
3187         return;
3188     }
3189
3190     if (r->user == NULL) {
3191         ruser = "-";
3192     }
3193     else if (strlen(r->user) != 0) {
3194         ruser = r->user;
3195     }
3196     else {
3197         ruser = "\"\"";
3198     }
3199
3200     rhost = ap_get_remote_host(conn, r->server->module_config,
3201                                REMOTE_NOLOOKUP);
3202     if (rhost == NULL) {
3203         rhost = "UNKNOWN-HOST";
3204     }
3205
3206     str1 = apr_pstrcat(r->pool, rhost, " ",
3207                       (conn->remote_logname != NULL ?
3208                       conn->remote_logname : "-"), " ",
3209                       ruser, NULL);
3210     apr_vsnprintf(str2, sizeof(str2), text, ap);
3211
3212     if (r->main == NULL) {
3213         strcpy(type, "initial");
3214     }
3215     else {
3216         strcpy(type, "subreq");
3217     }
3218
3219     for (i = 0, req = r; req->prev != NULL; req = req->prev) {
3220         i++;
3221     }
3222     if (i == 0) {
3223         redir[0] = '\0';
3224     }
3225     else {
3226         apr_snprintf(redir, sizeof(redir), "/redir#%d", i);
3227     }
3228
3229     apr_snprintf(str3, sizeof(str3),
3230                 "%s %s [%s/sid#%lx][rid#%lx/%s%s] (%d) %s\n", str1,
3231                 current_logtime(r), ap_get_server_name(r),
3232                 (unsigned long)(r->server), (unsigned long)r,
3233                 type, redir, level, str2);
3234
3235     apr_lock(rewrite_log_lock);
3236     nbytes = strlen(str3);
3237     apr_write(conf->rewritelogfp, str3, &nbytes);
3238     apr_unlock(rewrite_log_lock);
3239
3240     va_end(ap);
3241     return;
3242 }
3243
3244 static char *current_logtime(request_rec *r)
3245 {
3246     apr_exploded_time_t t;
3247     char tstr[80];
3248     apr_size_t len;
3249
3250     apr_explode_localtime(&t, apr_now());
3251
3252     apr_strftime(tstr, &len, 80, "[%d/%b/%Y:%H:%M:%S ", &t);
3253     apr_snprintf(tstr + strlen(tstr), 80-strlen(tstr), "%c%.2d%.2d]",
3254                 t.tm_gmtoff < 0 ? '-' : '+',
3255                 t.tm_gmtoff / (60*60), t.tm_gmtoff % (60*60));
3256     return apr_pstrdup(r->pool, tstr);
3257 }
3258
3259
3260
3261
3262 /*
3263 ** +-------------------------------------------------------+
3264 ** |                                                       |
3265 ** |              rewriting lockfile support
3266 ** |                                                       |
3267 ** +-------------------------------------------------------+
3268 */
3269
3270 #define REWRITELOCK_MODE ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD )
3271
3272 static void rewritelock_create(server_rec *s, apr_pool_t *p)
3273 {
3274     apr_status_t rc;
3275
3276     /* only operate if a lockfile is used */
3277     if (lockname == NULL || *(lockname) == '\0') {
3278         return;
3279     }
3280
3281     /* fixup the path, especially for rewritelock_remove() */
3282     lockname = ap_server_root_relative(p, lockname);
3283
3284     /* create the lockfile */
3285     rc = apr_create_lock (&rewrite_mapr_lock, APR_MUTEX, APR_LOCKALL, lockname, p);
3286     if (rc != APR_SUCCESS) {
3287         ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
3288                      "mod_rewrite: Parent could not create RewriteLock "
3289                      "file %s", lockname);
3290         exit(1);
3291     }
3292
3293     return;
3294 }
3295
3296 static apr_status_t rewritelock_remove(void *data)
3297 {
3298     /* only operate if a lockfile is used */
3299     if (lockname == NULL || *(lockname) == '\0') {
3300         return APR_SUCCESS;
3301     }
3302
3303     /* destroy the rewritelock */
3304     apr_destroy_lock (rewrite_mapr_lock);
3305     rewrite_mapr_lock = NULL;
3306     lockname = NULL;
3307     return(0);
3308 }
3309
3310
3311 /*
3312 ** +-------------------------------------------------------+
3313 ** |                                                       |
3314 ** |                  program map support
3315 ** |                                                       |
3316 ** +-------------------------------------------------------+
3317 */
3318
3319 static void run_rewritemap_programs(server_rec *s, apr_pool_t *p)
3320 {
3321     rewrite_server_conf *conf;
3322     apr_file_t *fpin = NULL;
3323     apr_file_t *fpout = NULL;
3324     apr_file_t *fperr = NULL;
3325     apr_array_header_t *rewritemaps;
3326     rewritemap_entry *entries;
3327     rewritemap_entry *map;
3328     int i;
3329     apr_status_t rc;
3330
3331     conf = ap_get_module_config(s->module_config, &rewrite_module);
3332
3333     /*  If the engine isn't turned on,
3334      *  don't even try to do anything.
3335      */
3336     if (conf->state == ENGINE_DISABLED) {
3337         return;
3338     }
3339
3340     rewritemaps = conf->rewritemaps;
3341     entries = (rewritemap_entry *)rewritemaps->elts;
3342     for (i = 0; i < rewritemaps->nelts; i++) {
3343         map = &entries[i];
3344         if (map->type != MAPTYPE_PRG) {
3345             continue;
3346         }
3347         if (map->datafile == NULL
3348             || *(map->datafile) == '\0'
3349             || map->fpin  != NULL
3350             || map->fpout != NULL        ) {
3351             continue;
3352         }
3353         fpin  = NULL;
3354         fpout = NULL;
3355         rc = rewritemap_program_child(p, map->datafile,
3356                                      &fpout, &fpin, &fperr);
3357         if (rc != APR_SUCCESS || fpin == NULL || fpout == NULL) {
3358             ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
3359                          "mod_rewrite: could not fork child for "
3360                          "RewriteMap process");
3361             exit(1);
3362         }
3363         map->fpin  = fpin;
3364         map->fpout = fpout;
3365         map->fperr = fperr;
3366     }
3367     return;
3368 }
3369
3370 /* child process code */
3371 static apr_status_t rewritemap_program_child(apr_pool_t *p, const char *progname,
3372                                              apr_file_t **fpout, apr_file_t **fpin,
3373                                              apr_file_t **fperr)
3374 {
3375     apr_status_t rc;
3376     apr_procattr_t *procattr;
3377     apr_proc_t *procnew;
3378
3379 #ifdef SIGHUP
3380     apr_signal(SIGHUP, SIG_IGN);
3381 #endif
3382
3383
3384     if (((rc = apr_createprocattr_init(&procattr, p)) != APR_SUCCESS) ||
3385         ((rc = apr_setprocattr_io(procattr, APR_FULL_BLOCK,
3386                                   APR_FULL_NONBLOCK,
3387                                   APR_FULL_NONBLOCK)) != APR_SUCCESS) ||
3388         ((rc = apr_setprocattr_dir(procattr,
3389                                    ap_make_dirstr_parent(p, progname)))
3390          != APR_SUCCESS) ||
3391         ((rc = apr_setprocattr_cmdtype(procattr, APR_PROGRAM)) != APR_SUCCESS)) {
3392         /* Something bad happened, give up and go away. */
3393     }
3394     else {
3395         procnew = apr_pcalloc(p, sizeof(*procnew));
3396         rc = apr_create_process(procnew, progname, NULL, NULL, procattr, p);
3397
3398         if (rc == APR_SUCCESS) {
3399             apr_note_subprocess(p, procnew, kill_after_timeout);
3400
3401             if (fpin) {
3402                 (*fpin) = procnew->in;
3403             }
3404
3405             if (fpout) {
3406                 (*fpout) = procnew->out;
3407             }
3408
3409             if (fperr) {
3410                 (*fperr) = procnew->err;
3411             }
3412         }
3413     }
3414
3415     return (rc);
3416 }
3417
3418
3419
3420
3421 /*
3422 ** +-------------------------------------------------------+
3423 ** |                                                       |
3424 ** |             environment variable support
3425 ** |                                                       |
3426 ** +-------------------------------------------------------+
3427 */
3428
3429
3430 static char *lookup_variable(request_rec *r, char *var)
3431 {
3432     const char *result;
3433     char resultbuf[LONG_STRING_LEN];
3434     apr_exploded_time_t tm;
3435     request_rec *rsub;
3436 #ifndef WIN32
3437     struct passwd *pw;
3438     struct group *gr;
3439     apr_finfo_t finfo;
3440 #endif
3441
3442     result = NULL;
3443
3444     /* HTTP headers */
3445     if (strcasecmp(var, "HTTP_USER_AGENT") == 0) {
3446         result = lookup_header(r, "User-Agent");
3447     }
3448     else if (strcasecmp(var, "HTTP_REFERER") == 0) {
3449         result = lookup_header(r, "Referer");
3450     }
3451     else if (strcasecmp(var, "HTTP_COOKIE") == 0) {
3452         result = lookup_header(r, "Cookie");
3453     }
3454     else if (strcasecmp(var, "HTTP_FORWARDED") == 0) {
3455         result = lookup_header(r, "Forwarded");
3456     }
3457     else if (strcasecmp(var, "HTTP_HOST") == 0) {
3458         result = lookup_header(r, "Host");
3459     }
3460     else if (strcasecmp(var, "HTTP_PROXY_CONNECTION") == 0) {
3461         result = lookup_header(r, "Proxy-Connection");
3462     }
3463     else if (strcasecmp(var, "HTTP_ACCEPT") == 0) {
3464         result = lookup_header(r, "Accept");
3465     }
3466     /* all other headers from which we are still not know about */
3467     else if (strlen(var) > 5 && strncasecmp(var, "HTTP:", 5) == 0) {
3468         result = lookup_header(r, var+5);
3469     }
3470
3471     /* connection stuff */
3472     else if (strcasecmp(var, "REMOTE_ADDR") == 0) {
3473         result = r->connection->remote_ip;
3474     }
3475     else if (strcasecmp(var, "REMOTE_HOST") == 0) {
3476         result = (char *)ap_get_remote_host(r->connection,
3477                                          r->per_dir_config, REMOTE_NAME);
3478     }
3479     else if (strcasecmp(var, "REMOTE_USER") == 0) {
3480         result = r->user;
3481     }
3482     else if (strcasecmp(var, "REMOTE_IDENT") == 0) {
3483         result = (char *)ap_get_remote_logname(r);
3484     }
3485
3486     /* request stuff */
3487     else if (strcasecmp(var, "THE_REQUEST") == 0) { /* non-standard */
3488         result = r->the_request;
3489     }
3490     else if (strcasecmp(var, "REQUEST_METHOD") == 0) {
3491         result = r->method;
3492     }
3493     else if (strcasecmp(var, "REQUEST_URI") == 0) { /* non-standard */
3494         result = r->uri;
3495     }
3496     else if (strcasecmp(var, "SCRIPT_FILENAME") == 0 ||
3497              strcasecmp(var, "REQUEST_FILENAME") == 0  ) {
3498         result = r->filename;
3499     }
3500     else if (strcasecmp(var, "PATH_INFO") == 0) {
3501         result = r->path_info;
3502     }
3503     else if (strcasecmp(var, "QUERY_STRING") == 0) {
3504         result = r->args;
3505     }
3506     else if (strcasecmp(var, "AUTH_TYPE") == 0) {
3507         result = r->ap_auth_type;
3508     }
3509     else if (strcasecmp(var, "IS_SUBREQ") == 0) { /* non-standard */
3510         result = (r->main != NULL ? "true" : "false");
3511     }
3512
3513     /* internal server stuff */
3514     else if (strcasecmp(var, "DOCUMENT_ROOT") == 0) {
3515         result = ap_document_root(r);
3516     }
3517     else if (strcasecmp(var, "SERVER_ADMIN") == 0) {
3518         result = r->server->server_admin;
3519     }
3520     else if (strcasecmp(var, "SERVER_NAME") == 0) {
3521         result = ap_get_server_name(r);
3522     }
3523     else if (strcasecmp(var, "SERVER_ADDR") == 0) { /* non-standard */
3524         result = r->connection->local_ip;
3525     }
3526     else if (strcasecmp(var, "SERVER_PORT") == 0) {
3527         apr_snprintf(resultbuf, sizeof(resultbuf), "%u", ap_get_server_port(r));
3528         result = resultbuf;
3529     }
3530     else if (strcasecmp(var, "SERVER_PROTOCOL") == 0) {
3531         result = r->protocol;
3532     }
3533     else if (strcasecmp(var, "SERVER_SOFTWARE") == 0) {
3534         result = ap_get_server_version();
3535     }
3536     else if (strcasecmp(var, "API_VERSION") == 0) { /* non-standard */
3537         apr_snprintf(resultbuf, sizeof(resultbuf), "%d:%d",
3538                     MODULE_MAGIC_NUMBER_MAJOR, MODULE_MAGIC_NUMBER_MINOR);
3539         result = resultbuf;
3540     }
3541
3542 /* XXX: wow this has gotta be slow if you actually use it for a lot, recalculates exploded time for each variable */
3543     /* underlaying Unix system stuff */
3544     else if (strcasecmp(var, "TIME_YEAR") == 0) {
3545         apr_explode_localtime(&tm, apr_now());
3546         apr_snprintf(resultbuf, sizeof(resultbuf), "%04d", tm.tm_year + 1900);
3547         result = resultbuf;
3548     }
3549 #define MKTIMESTR(format, tmfield) \
3550     apr_explode_localtime(&tm, apr_now()); \
3551     apr_snprintf(resultbuf, sizeof(resultbuf), format, tm.tmfield); \
3552     result = resultbuf;
3553     else if (strcasecmp(var, "TIME_MON") == 0) {
3554         MKTIMESTR("%02d", tm_mon+1)
3555     }
3556     else if (strcasecmp(var, "TIME_DAY") == 0) {
3557         MKTIMESTR("%02d", tm_mday)
3558     }
3559     else if (strcasecmp(var, "TIME_HOUR") == 0) {
3560         MKTIMESTR("%02d", tm_hour)
3561     }
3562     else if (strcasecmp(var, "TIME_MIN") == 0) {
3563         MKTIMESTR("%02d", tm_min)
3564     }
3565     else if (strcasecmp(var, "TIME_SEC") == 0) {
3566         MKTIMESTR("%02d", tm_sec)
3567     }
3568     else if (strcasecmp(var, "TIME_WDAY") == 0) {
3569         MKTIMESTR("%d", tm_wday)
3570     }
3571     else if (strcasecmp(var, "TIME") == 0) {
3572         apr_explode_localtime(&tm, apr_now());
3573         apr_snprintf(resultbuf, sizeof(resultbuf),
3574                     "%04d%02d%02d%02d%02d%02d", tm.tm_year + 1900,
3575                     tm.tm_mon+1, tm.tm_mday,
3576                     tm.tm_hour, tm.tm_min, tm.tm_sec);
3577         result = resultbuf;
3578         rewritelog(r, 1, "RESULT='%s'", result);
3579     }
3580
3581     /* all other env-variables from the parent Apache process */
3582     else if (strlen(var) > 4 && strncasecmp(var, "ENV:", 4) == 0) {
3583         /* first try the internal Apache notes structure */
3584         result = apr_table_get(r->notes, var+4);
3585         /* second try the internal Apache env structure  */
3586         if (result == NULL) {
3587             result = apr_table_get(r->subprocess_env, var+4);
3588         }
3589         /* third try the external OS env */
3590         if (result == NULL) {
3591             result = getenv(var+4);
3592         }
3593     }
3594
3595 #define LOOKAHEAD(subrecfunc) \
3596         if ( \
3597           /* filename is safe to use */ \
3598           r->filename != NULL \
3599               /* - and we're either not in a subrequest */ \
3600               && ( r->main == NULL \
3601                   /* - or in a subrequest where paths are non-NULL... */ \
3602                     || ( r->main->uri != NULL && r->uri != NULL \
3603                         /*   ...and sub and main paths differ */ \
3604                         && strcmp(r->main->uri, r->uri) != 0))) { \
3605             /* process a file-based subrequest */ \
3606             rsub = subrecfunc(r->filename, r); \
3607             /* now recursively lookup the variable in the sub_req */ \
3608             result = lookup_variable(rsub, var+5); \
3609             /* copy it up to our scope before we destroy sub_req's apr_pool_t */ \
3610             result = apr_pstrdup(r->pool, result); \
3611             /* cleanup by destroying the subrequest */ \
3612             ap_destroy_sub_req(rsub); \
3613             /* log it */ \
3614             rewritelog(r, 5, "lookahead: path=%s var=%s -> val=%s", \
3615                        r->filename, var+5, result); \
3616             /* return ourself to prevent re-pstrdup */ \
3617             return (char *)result; \
3618         }
3619
3620     /* look-ahead for parameter through URI-based sub-request */
3621     else if (strlen(var) > 5 && strncasecmp(var, "LA-U:", 5) == 0) {
3622         LOOKAHEAD(ap_sub_req_lookup_uri)
3623     }
3624     /* look-ahead for parameter through file-based sub-request */
3625     else if (strlen(var) > 5 && strncasecmp(var, "LA-F:", 5) == 0) {
3626         LOOKAHEAD(ap_sub_req_lookup_file)
3627     }
3628
3629 #if !defined(WIN32) && !defined(NETWARE)
3630     /* Win32 has a rather different view of file ownerships.
3631        For now, just forget it */
3632
3633     /* file stuff */
3634     else if (strcasecmp(var, "SCRIPT_USER") == 0) {
3635         result = "<unknown>";
3636         if (r->finfo.protection != 0) {
3637             if ((pw = getpwuid(r->finfo.user)) != NULL) {
3638                 result = pw->pw_name;
3639             }
3640         }
3641         else {
3642             if (apr_stat(&finfo, r->filename, r->pool) == APR_SUCCESS) {
3643                 if ((pw = getpwuid(finfo.user)) != NULL) {
3644                     result = pw->pw_name;
3645                 }
3646             }
3647         }
3648     }
3649     else if (strcasecmp(var, "SCRIPT_GROUP") == 0) {
3650         result = "<unknown>";
3651         if (r->finfo.protection != 0) {
3652             if ((gr = getgrgid(r->finfo.group)) != NULL) {
3653                 result = gr->gr_name;
3654             }
3655         }
3656         else {
3657             if (apr_stat(&finfo, r->filename, r->pool) == 0) {
3658                 if ((gr = getgrgid(finfo.group)) != NULL) {
3659                     result = gr->gr_name;
3660                 }
3661             }
3662         }
3663     }
3664 #endif /* ndef WIN32 && NETWARE*/
3665
3666     if (result == NULL) {
3667         return apr_pstrdup(r->pool, "");
3668     }
3669     else {
3670         return apr_pstrdup(r->pool, result);
3671     }
3672 }
3673
3674 static char *lookup_header(request_rec *r, const char *name)
3675 {
3676     apr_array_header_t *hdrs_arr;
3677     apr_table_entry_t *hdrs;
3678     int i;
3679
3680     hdrs_arr = apr_table_elts(r->headers_in);
3681     hdrs = (apr_table_entry_t *)hdrs_arr->elts;
3682     for (i = 0; i < hdrs_arr->nelts; ++i) {
3683         if (hdrs[i].key == NULL) {
3684             continue;
3685         }
3686         if (strcasecmp(hdrs[i].key, name) == 0) {
3687             apr_table_merge(r->notes, VARY_KEY_THIS, name);
3688             return hdrs[i].val;
3689         }
3690     }
3691     return NULL;
3692 }
3693
3694
3695
3696
3697 /*
3698 ** +-------------------------------------------------------+
3699 ** |                                                       |
3700 ** |                    caching support
3701 ** |                                                       |
3702 ** +-------------------------------------------------------+
3703 */
3704
3705
3706 static cache *init_cache(apr_pool_t *p)
3707 {
3708     cache *c;
3709
3710     c = (cache *)apr_palloc(p, sizeof(cache));
3711     if (apr_create_pool(&c->pool, p) != APR_SUCCESS)
3712                 return NULL;
3713     c->lists = apr_make_array(c->pool, 2, sizeof(cachelist));
3714     return c;
3715 }
3716
3717 static void set_cache_string(cache *c, const char *res, int mode, time_t t,
3718                              char *key, char *value)
3719 {
3720     cacheentry ce;
3721
3722     ce.time  = t;
3723     ce.key   = key;
3724     ce.value = value;
3725     store_cache_string(c, res, &ce);
3726     return;
3727 }
3728
3729 static char *get_cache_string(cache *c, const char *res, int mode,
3730                               time_t t, char *key)
3731 {
3732     cacheentry *ce;
3733
3734     ce = retrieve_cache_string(c, res, key);
3735     if (ce == NULL) {
3736         return NULL;
3737     }
3738     if (mode & CACHEMODE_TS) {
3739         if (t != ce->time) {
3740             return NULL;
3741         }
3742     }
3743     else if (mode & CACHEMODE_TTL) {
3744         if (t > ce->time) {
3745             return NULL;
3746         }
3747     }
3748     return apr_pstrdup(c->pool, ce->value);
3749 }
3750
3751 static int cache_tlb_hash(char *key)
3752 {
3753     unsigned long n;
3754     char *p;
3755
3756     n = 0;
3757     for (p = key; *p != '\0'; p++) {
3758         n = ((n << 5) + n) ^ (unsigned long)(*p++);
3759     }
3760
3761     return n % CACHE_TLB_ROWS;
3762 }
3763
3764 static cacheentry *cache_tlb_lookup(cachetlbentry *tlb, cacheentry *elt,
3765                                     char *key)
3766 {
3767     int ix = cache_tlb_hash(key);
3768     int i;
3769     int j;
3770
3771     for (i=0; i < CACHE_TLB_COLS; ++i) {
3772         j = tlb[ix].t[i];
3773         if (j < 0)
3774             return NULL;
3775         if (strcmp(elt[j].key, key) == 0)
3776             return &elt[j];
3777     }
3778     return NULL;
3779 }
3780
3781 static void cache_tlb_replace(cachetlbentry *tlb, cacheentry *elt,
3782                               cacheentry *e)
3783 {
3784     int ix = cache_tlb_hash(e->key);
3785     int i;
3786
3787     tlb = &tlb[ix];
3788
3789     for (i=1; i < CACHE_TLB_COLS; ++i)
3790         tlb->t[i] = tlb->t[i-1];
3791
3792     tlb->t[0] = e - elt;
3793 }
3794
3795 static void store_cache_string(cache *c, const char *res, cacheentry *ce)
3796 {
3797     int i;
3798     int j;
3799     cachelist *l;
3800     cacheentry *e;
3801     cachetlbentry *t;
3802     int found_list;
3803
3804     found_list = 0;
3805     /* first try to edit an existing entry */
3806     for (i = 0; i < c->lists->nelts; i++) {
3807         l = &(((cachelist *)c->lists->elts)[i]);
3808         if (strcmp(l->resource, res) == 0) {
3809             found_list = 1;
3810
3811             e = cache_tlb_lookup((cachetlbentry *)l->tlb->elts,
3812                                  (cacheentry *)l->entries->elts, ce->key);
3813             if (e != NULL) {
3814                 e->time  = ce->time;
3815                 e->value = apr_pstrdup(c->pool, ce->value);
3816                 return;
3817             }
3818
3819             for (j = 0; j < l->entries->nelts; j++) {
3820                 e = &(((cacheentry *)l->entries->elts)[j]);
3821                 if (strcmp(e->key, ce->key) == 0) {
3822                     e->time  = ce->time;
3823                     e->value = apr_pstrdup(c->pool, ce->value);
3824                   cache_tlb_replace((cachetlbentry *)l->tlb->elts,
3825                                     (cacheentry *)l->entries->elts, e);
3826                     return;
3827                 }
3828             }
3829         }
3830     }
3831
3832     /* create a needed new list */
3833     if (!found_list) {
3834         l = apr_push_array(c->lists);
3835         l->resource = apr_pstrdup(c->pool, res);
3836         l->entries  = apr_make_array(c->pool, 2, sizeof(cacheentry));
3837         l->tlb      = apr_make_array(c->pool, CACHE_TLB_ROWS,
3838                                     sizeof(cachetlbentry));
3839         for (i=0; i<CACHE_TLB_ROWS; ++i) {
3840             t = &((cachetlbentry *)l->tlb->elts)[i];
3841                 for (j=0; j<CACHE_TLB_COLS; ++j)
3842                     t->t[j] = -1;
3843         }
3844     }
3845
3846     /* create the new entry */
3847     for (i = 0; i < c->lists->nelts; i++) {
3848         l = &(((cachelist *)c->lists->elts)[i]);
3849         if (strcmp(l->resource, res) == 0) {
3850             e = apr_push_array(l->entries);
3851             e->time  = ce->time;
3852             e->key   = apr_pstrdup(c->pool, ce->key);
3853             e->value = apr_pstrdup(c->pool, ce->value);
3854             cache_tlb_replace((cachetlbentry *)l->tlb->elts,
3855                               (cacheentry *)l->entries->elts, e);
3856             return;
3857         }
3858     }
3859
3860     /* not reached, but when it is no problem... */
3861     return;
3862 }
3863
3864 static cacheentry *retrieve_cache_string(cache *c, const char *res, char *key)
3865 {
3866     int i;
3867     int j;
3868     cachelist *l;
3869     cacheentry *e;
3870
3871     for (i = 0; i < c->lists->nelts; i++) {
3872         l = &(((cachelist *)c->lists->elts)[i]);
3873         if (strcmp(l->resource, res) == 0) {
3874
3875             e = cache_tlb_lookup((cachetlbentry *)l->tlb->elts,
3876                                  (cacheentry *)l->entries->elts, key);
3877             if (e != NULL)
3878                 return e;
3879
3880             for (j = 0; j < l->entries->nelts; j++) {
3881                 e = &(((cacheentry *)l->entries->elts)[j]);
3882                 if (strcmp(e->key, key) == 0) {
3883                     return e;
3884                 }
3885             }
3886         }
3887     }
3888     return NULL;
3889 }
3890
3891
3892
3893
3894 /*
3895 ** +-------------------------------------------------------+
3896 ** |                                                       |
3897 ** |                    misc functions
3898 ** |                                                       |
3899 ** +-------------------------------------------------------+
3900 */
3901
3902 static char *subst_prefix_path(request_rec *r, char *input, char *match,
3903                                const char *subst)
3904 {
3905     char matchbuf[LONG_STRING_LEN];
3906     char substbuf[LONG_STRING_LEN];
3907     char *output;
3908     int l;
3909
3910     output = input;
3911
3912     /* first create a match string which always has a trailing slash */
3913     l = apr_cpystrn(matchbuf, match, sizeof(matchbuf)) - matchbuf;
3914     if (matchbuf[l-1] != '/') {
3915        matchbuf[l] = '/';
3916        matchbuf[l+1] = '\0';
3917        l++;
3918     }
3919     /* now compare the prefix */
3920     if (strncmp(input, matchbuf, l) == 0) {
3921         rewritelog(r, 5, "strip matching prefix: %s -> %s", output, output+l);
3922         output = apr_pstrdup(r->pool, output+l);
3923
3924         /* and now add the base-URL as replacement prefix */
3925         l = apr_cpystrn(substbuf, subst, sizeof(substbuf)) - substbuf;
3926         if (substbuf[l-1] != '/') {
3927            substbuf[l] = '/';
3928            substbuf[l+1] = '\0';
3929            l++;
3930         }
3931         if (output[0] == '/') {
3932             rewritelog(r, 4, "add subst prefix: %s -> %s%s",
3933                        output, substbuf, output+1);
3934             output = apr_pstrcat(r->pool, substbuf, output+1, NULL);
3935         }
3936         else {
3937             rewritelog(r, 4, "add subst prefix: %s -> %s%s",
3938                        output, substbuf, output);
3939             output = apr_pstrcat(r->pool, substbuf, output, NULL);
3940         }
3941     }
3942     return output;
3943 }
3944
3945
3946 /*
3947 **
3948 **  own command line parser which don't have the '\\' problem
3949 **
3950 */
3951
3952 static int parseargline(char *str, char **a1, char **a2, char **a3)
3953 {
3954     char *cp;
3955     int isquoted;
3956
3957 #define SKIP_WHITESPACE(cp) \
3958     for ( ; *cp == ' ' || *cp == '\t'; ) { \
3959         cp++; \
3960     };
3961
3962 #define CHECK_QUOTATION(cp,isquoted) \
3963     isquoted = 0; \
3964     if (*cp == '"') { \
3965         isquoted = 1; \
3966         cp++; \
3967     }
3968
3969 #define DETERMINE_NEXTSTRING(cp,isquoted) \
3970     for ( ; *cp != '\0'; cp++) { \
3971         if (   (isquoted    && (*cp     == ' ' || *cp     == '\t')) \
3972             || (*cp == '\\' && (*(cp+1) == ' ' || *(cp+1) == '\t'))) { \
3973             cp++; \
3974             continue; \
3975         } \
3976         if (   (!isquoted && (*cp == ' ' || *cp == '\t')) \
3977             || (isquoted  && *cp == '"')                  ) { \
3978             break; \
3979         } \
3980     }
3981
3982     cp = str;
3983     SKIP_WHITESPACE(cp);
3984
3985     /*  determine first argument */
3986     CHECK_QUOTATION(cp, isquoted);
3987     *a1 = cp;
3988     DETERMINE_NEXTSTRING(cp, isquoted);
3989     if (*cp == '\0') {
3990         return 1;
3991     }
3992     *cp++ = '\0';
3993
3994     SKIP_WHITESPACE(cp);
3995
3996     /*  determine second argument */
3997     CHECK_QUOTATION(cp, isquoted);
3998     *a2 = cp;
3999     DETERMINE_NEXTSTRING(cp, isquoted);
4000     if (*cp == '\0') {
4001         *cp++ = '\0';
4002         *a3 = NULL;
4003         return 0;
4004     }
4005     *cp++ = '\0';
4006
4007     SKIP_WHITESPACE(cp);
4008
4009     /* again check if there are only two arguments */
4010     if (*cp == '\0') {
4011         *cp++ = '\0';
4012         *a3 = NULL;
4013         return 0;
4014     }
4015
4016     /*  determine second argument */
4017     CHECK_QUOTATION(cp, isquoted);
4018     *a3 = cp;
4019     DETERMINE_NEXTSTRING(cp, isquoted);
4020     *cp++ = '\0';
4021
4022     return 0;
4023 }
4024
4025
4026 static void add_env_variable(request_rec *r, char *s)
4027 {
4028     char var[MAX_STRING_LEN];
4029     char val[MAX_STRING_LEN];
4030     char *cp;
4031     int n;
4032
4033     if ((cp = strchr(s, ':')) != NULL) {
4034         n = ((cp-s) > MAX_STRING_LEN-1 ? MAX_STRING_LEN-1 : (cp-s));
4035         memcpy(var, s, n);
4036         var[n] = '\0';
4037         apr_cpystrn(val, cp+1, sizeof(val));
4038         apr_table_set(r->subprocess_env, var, val);
4039         rewritelog(r, 5, "setting env variable '%s' to '%s'", var, val);
4040     }
4041 }
4042
4043
4044 /*
4045 **
4046 **  check that a subrequest won't cause infinite recursion
4047 **
4048 */
4049
4050 static int subreq_ok(request_rec *r)
4051 {
4052     /*
4053      * either not in a subrequest, or in a subrequest
4054      * and URIs aren't NULL and sub/main URIs differ
4055      */
4056     return (r->main == NULL ||
4057             (r->main->uri != NULL && r->uri != NULL &&
4058              strcmp(r->main->uri, r->uri) != 0));
4059 }
4060
4061
4062 /*
4063 **
4064 **  stat() for only the prefix of a path
4065 **
4066 */
4067
4068 static int prefix_stat(const char *path, apr_finfo_t *sb)
4069 {
4070     char curpath[LONG_STRING_LEN];
4071     char *cp;
4072
4073     apr_cpystrn(curpath, path, sizeof(curpath));
4074     if (curpath[0] != '/') {
4075         return 0;
4076     }
4077     if ((cp = strchr(curpath+1, '/')) != NULL) {
4078         *cp = '\0';
4079     }
4080     if (apr_stat(sb, curpath, NULL) == 0) {
4081         return 1;
4082     }
4083     else {
4084         return 0;
4085     }
4086 }
4087
4088
4089 /*
4090 **
4091 **  Lexicographic Compare
4092 **
4093 */
4094
4095 static int compare_lexicography(char *cpNum1, char *cpNum2)
4096 {
4097     int i;
4098     int n1, n2;
4099
4100     n1 = strlen(cpNum1);
4101     n2 = strlen(cpNum2);
4102     if (n1 > n2) {
4103         return 1;
4104     }
4105     if (n1 < n2) {
4106         return -1;
4107     }
4108     for (i = 0; i < n1; i++) {
4109         if (cpNum1[i] > cpNum2[i]) {
4110             return 1;
4111         }
4112         if (cpNum1[i] < cpNum2[i]) {
4113             return -1;
4114         }
4115     }
4116     return 0;
4117 }
4118
4119 /*
4120 **
4121 **  Find end of bracketed expression
4122 **  s points after the opening bracket
4123 **
4124 */
4125
4126 static char *find_closing_bracket(char *s, int left, int right)
4127 {
4128     int depth;
4129
4130     for (depth = 1; *s; ++s) {
4131         if (*s == right && --depth == 0) {
4132             return s;
4133         }
4134         else if (*s == left) {
4135             ++depth;
4136         }
4137     }
4138     return NULL;
4139 }
4140
4141 #ifdef NETWARE
4142 int main(int argc, char *argv[])
4143 {
4144     ExitThread(TSR_THREAD, 0);
4145 }
4146 #endif
4147
4148 /*EOF*/