modules/mappers/mod_alias.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * http_alias.c: Stuff for dealing with directory aliases
  19  *
  20  * Original by Rob McCool, rewritten in succession by David Robinson
  21  * and rst.
  22  *
  23  */
  24
  25 #include "apr_strings.h"
  26 #include "apr_lib.h"
  27
  28 #define APR_WANT_STRFUNC
  29 #include "apr_want.h"
  30
  31 #include "ap_config.h"
  32 #include "httpd.h"
  33 #include "http_core.h"
  34 #include "http_config.h"
  35 #include "http_request.h"
  36 #include "http_log.h"
  37
  38
  39 typedef struct {
  40     const char *real;
  41     const char *fake;
  42     char *handler;
  43     ap_regex_t *regexp;
  44     int redir_status;                /* 301, 302, 303, 410, etc */
  45 } alias_entry;
  46
  47 typedef struct {
  48     apr_array_header_t *aliases;
  49     apr_array_header_t *redirects;
  50 } alias_server_conf;
  51
  52 typedef struct {
  53     apr_array_header_t *redirects;
  54 } alias_dir_conf;
  55
  56 module AP_MODULE_DECLARE_DATA alias_module;
  57
  58 static void *create_alias_config(apr_pool_t *p, server_rec *s)
  59 {
  60     alias_server_conf *a =
  61     (alias_server_conf *) apr_pcalloc(p, sizeof(alias_server_conf));
  62
  63     a->aliases = apr_array_make(p, 20, sizeof(alias_entry));
  64     a->redirects = apr_array_make(p, 20, sizeof(alias_entry));
  65     return a;
  66 }
  67
  68 static void *create_alias_dir_config(apr_pool_t *p, char *d)
  69 {
  70     alias_dir_conf *a =
  71     (alias_dir_conf *) apr_pcalloc(p, sizeof(alias_dir_conf));
  72     a->redirects = apr_array_make(p, 2, sizeof(alias_entry));
  73     return a;
  74 }
  75
  76 static void *merge_alias_config(apr_pool_t *p, void *basev, void *overridesv)
  77 {
  78     alias_server_conf *a =
  79     (alias_server_conf *) apr_pcalloc(p, sizeof(alias_server_conf));
  80     alias_server_conf *base = (alias_server_conf *) basev;
  81     alias_server_conf *overrides = (alias_server_conf *) overridesv;
  82
  83     a->aliases = apr_array_append(p, overrides->aliases, base->aliases);
  84     a->redirects = apr_array_append(p, overrides->redirects, base->redirects);
  85     return a;
  86 }
  87
  88 static void *merge_alias_dir_config(apr_pool_t *p, void *basev, void *overridesv)
  89 {
  90     alias_dir_conf *a =
  91     (alias_dir_conf *) apr_pcalloc(p, sizeof(alias_dir_conf));
  92     alias_dir_conf *base = (alias_dir_conf *) basev;
  93     alias_dir_conf *overrides = (alias_dir_conf *) overridesv;
  94     a->redirects = apr_array_append(p, overrides->redirects, base->redirects);
  95     return a;
  96 }
  97
  98 /* need prototype for overlap check */
  99 static int alias_matches(const char *uri, const char *alias_fakename);
 100
 101 static const char *add_alias_internal(cmd_parms *cmd, void *dummy,
 102                                       const char *f, const char *r,
 103                                       int use_regex)
 104 {
 105     server_rec *s = cmd->server;
 106     alias_server_conf *conf = ap_get_module_config(s->module_config,
 107                                                    &alias_module);
 108     alias_entry *new = apr_array_push(conf->aliases);
 109     alias_entry *entries = (alias_entry *)conf->aliases->elts;
 110     int i;
 111
 112     /* XX r can NOT be relative to DocumentRoot here... compat bug. */
 113
 114     if (use_regex) {
 115         new->regexp = ap_pregcomp(cmd->pool, f, AP_REG_EXTENDED);
 116         if (new->regexp == NULL)
 117             return "Regular expression could not be compiled.";
 118         new->real = r;
 119     }
 120     else {
 121         /* XXX This may be optimized, but we must know that new->real
 122          * exists.  If so, we can dir merge later, trusing new->real
 123          * and just canonicalizing the remainder.  Not till I finish
 124          * cleaning out the old ap_canonical stuff first.
 125          */
 126         new->real = r;
 127     }
 128     new->fake = f;
 129     new->handler = cmd->info;
 130
 131     /* check for overlapping (Script)Alias directives
 132      * and throw a warning if found one
 133      */
 134     if (!use_regex) {
 135         for (i = 0; i < conf->aliases->nelts - 1; ++i) {
 136             alias_entry *p = &entries[i];
 137
 138             if (  (!p->regexp &&  alias_matches(f, p->fake) > 0)
 139                 || (p->regexp && !ap_regexec(p->regexp, f, 0, NULL, 0))) {
 140                 ap_log_error(APLOG_MARK, APLOG_WARNING, 0, cmd->server,
 141                              "The %s directive in %s at line %d will probably "
 142                              "never match because it overlaps an earlier "
 143                              "%sAlias%s.",
 144                              cmd->cmd->name, cmd->directive->filename,
 145                              cmd->directive->line_num,
 146                              p->handler ? "Script" : "",
 147                              p->regexp ? "Match" : "");
 148
 149                 break; /* one warning per alias should be sufficient */
 150             }
 151         }
 152     }
 153
 154     return NULL;
 155 }
 156
 157 static const char *add_alias(cmd_parms *cmd, void *dummy, const char *f,
 158                              const char *r)
 159 {
 160     return add_alias_internal(cmd, dummy, f, r, 0);
 161 }
 162
 163 static const char *add_alias_regex(cmd_parms *cmd, void *dummy, const char *f,
 164                                    const char *r)
 165 {
 166     return add_alias_internal(cmd, dummy, f, r, 1);
 167 }
 168
 169 static const char *add_redirect_internal(cmd_parms *cmd,
 170                                          alias_dir_conf *dirconf,
 171                                          const char *arg1, const char *arg2,
 172                                          const char *arg3, int use_regex)
 173 {
 174     alias_entry *new;
 175     server_rec *s = cmd->server;
 176     alias_server_conf *serverconf = ap_get_module_config(s->module_config,
 177                                                          &alias_module);
 178     int status = (int) (long) cmd->info;
 179     ap_regex_t *r = NULL;
 180     const char *f = arg2;
 181     const char *url = arg3;
 182
 183     if (!strcasecmp(arg1, "gone"))
 184         status = HTTP_GONE;
 185     else if (!strcasecmp(arg1, "permanent"))
 186         status = HTTP_MOVED_PERMANENTLY;
 187     else if (!strcasecmp(arg1, "temp"))
 188         status = HTTP_MOVED_TEMPORARILY;
 189     else if (!strcasecmp(arg1, "seeother"))
 190         status = HTTP_SEE_OTHER;
 191     else if (apr_isdigit(*arg1))
 192         status = atoi(arg1);
 193     else {
 194         f = arg1;
 195         url = arg2;
 196     }
 197
 198     if (use_regex) {
 199         r = ap_pregcomp(cmd->pool, f, AP_REG_EXTENDED);
 200         if (r == NULL)
 201             return "Regular expression could not be compiled.";
 202     }
 203
 204     if (ap_is_HTTP_REDIRECT(status)) {
 205         if (!url)
 206             return "URL to redirect to is missing";
 207         /* PR#35314: we can allow path components here;
 208          * they get correctly resolved to full URLs.
 209          */
 210         if (!use_regex && !ap_is_url(url) && (url[0] != '/'))
 211             return "Redirect to non-URL";
 212     }
 213     else {
 214         if (url)
 215             return "Redirect URL not valid for this status";
 216     }
 217
 218     if (cmd->path)
 219         new = apr_array_push(dirconf->redirects);
 220     else
 221         new = apr_array_push(serverconf->redirects);
 222
 223     new->fake = f;
 224     new->real = url;
 225     new->regexp = r;
 226     new->redir_status = status;
 227     return NULL;
 228 }
 229
 230 static const char *add_redirect(cmd_parms *cmd, void *dirconf,
 231                                 const char *arg1, const char *arg2,
 232                                 const char *arg3)
 233 {
 234     return add_redirect_internal(cmd, dirconf, arg1, arg2, arg3, 0);
 235 }
 236
 237 static const char *add_redirect2(cmd_parms *cmd, void *dirconf,
 238                                  const char *arg1, const char *arg2)
 239 {
 240     return add_redirect_internal(cmd, dirconf, arg1, arg2, NULL, 0);
 241 }
 242
 243 static const char *add_redirect_regex(cmd_parms *cmd, void *dirconf,
 244                                       const char *arg1, const char *arg2,
 245                                       const char *arg3)
 246 {
 247     return add_redirect_internal(cmd, dirconf, arg1, arg2, arg3, 1);
 248 }
 249
 250 static const command_rec alias_cmds[] =
 251 {
 252     AP_INIT_TAKE2("Alias", add_alias, NULL, RSRC_CONF,
 253                   "a fakename and a realname"),
 254     AP_INIT_TAKE2("ScriptAlias", add_alias, "cgi-script", RSRC_CONF,
 255                   "a fakename and a realname"),
 256     AP_INIT_TAKE23("Redirect", add_redirect, (void *) HTTP_MOVED_TEMPORARILY,
 257                    OR_FILEINFO,
 258                    "an optional status, then document to be redirected and "
 259                    "destination URL"),
 260     AP_INIT_TAKE2("AliasMatch", add_alias_regex, NULL, RSRC_CONF,
 261                   "a regular expression and a filename"),
 262     AP_INIT_TAKE2("ScriptAliasMatch", add_alias_regex, "cgi-script", RSRC_CONF,
 263                   "a regular expression and a filename"),
 264     AP_INIT_TAKE23("RedirectMatch", add_redirect_regex,
 265                    (void *) HTTP_MOVED_TEMPORARILY, OR_FILEINFO,
 266                    "an optional status, then a regular expression and "
 267                    "destination URL"),
 268     AP_INIT_TAKE2("RedirectTemp", add_redirect2,
 269                   (void *) HTTP_MOVED_TEMPORARILY, OR_FILEINFO,
 270                   "a document to be redirected, then the destination URL"),
 271     AP_INIT_TAKE2("RedirectPermanent", add_redirect2,
 272                   (void *) HTTP_MOVED_PERMANENTLY, OR_FILEINFO,
 273                   "a document to be redirected, then the destination URL"),
 274     {NULL}
 275 };
 276
 277 static int alias_matches(const char *uri, const char *alias_fakename)
 278 {
 279     const char *aliasp = alias_fakename, *urip = uri;
 280
 281     while (*aliasp) {
 282         if (*aliasp == '/') {
 283             /* any number of '/' in the alias matches any number in
 284              * the supplied URI, but there must be at least one...
 285              */
 286             if (*urip != '/')
 287                 return 0;
 288
 289             do {
 290                 ++aliasp;
 291             } while (*aliasp == '/');
 292             do {
 293                 ++urip;
 294             } while (*urip == '/');
 295         }
 296         else {
 297             /* Other characters are compared literally */
 298             if (*urip++ != *aliasp++)
 299                 return 0;
 300         }
 301     }
 302
 303     /* Check last alias path component matched all the way */
 304
 305     if (aliasp[-1] != '/' && *urip != '\0' && *urip != '/')
 306         return 0;
 307
 308     /* Return number of characters from URI which matched (may be
 309      * greater than length of alias, since we may have matched
 310      * doubled slashes)
 311      */
 312
 313     return urip - uri;
 314 }
 315
 316 static char *try_alias_list(request_rec *r, apr_array_header_t *aliases,
 317                             int doesc, int *status)
 318 {
 319     alias_entry *entries = (alias_entry *) aliases->elts;
 320     ap_regmatch_t regm[AP_MAX_REG_MATCH];
 321     char *found = NULL;
 322     int i;
 323
 324     for (i = 0; i < aliases->nelts; ++i) {
 325         alias_entry *p = &entries[i];
 326         int l;
 327
 328         if (p->regexp) {
 329             if (!ap_regexec(p->regexp, r->uri, AP_MAX_REG_MATCH, regm, 0)) {
 330                 if (p->real) {
 331                     found = ap_pregsub(r->pool, p->real, r->uri,
 332                                        AP_MAX_REG_MATCH, regm);
 333                     if (found && doesc) {
 334                         apr_uri_t uri;
 335                         apr_uri_parse(r->pool, found, &uri);
 336                         /* Do not escape the query string or fragment. */
 337                         found = apr_uri_unparse(r->pool, &uri,
 338                                                 APR_URI_UNP_OMITQUERY);
 339                         found = ap_escape_uri(r->pool, found);
 340                         if (uri.query) {
 341                             found = apr_pstrcat(r->pool, found, "?",
 342                                                 uri.query, NULL);
 343                         }
 344                         if (uri.fragment) {
 345                             found = apr_pstrcat(r->pool, found, "#",
 346                                                 uri.fragment, NULL);
 347                         }
 348                     }
 349                 }
 350                 else {
 351                     /* need something non-null */
 352                     found = apr_pstrdup(r->pool, "");
 353                 }
 354             }
 355         }
 356         else {
 357             l = alias_matches(r->uri, p->fake);
 358
 359             if (l > 0) {
 360                 if (doesc) {
 361                     char *escurl;
 362                     escurl = ap_os_escape_path(r->pool, r->uri + l, 1);
 363
 364                     found = apr_pstrcat(r->pool, p->real, escurl, NULL);
 365                 }
 366                 else
 367                     found = apr_pstrcat(r->pool, p->real, r->uri + l, NULL);
 368             }
 369         }
 370
 371         if (found) {
 372             if (p->handler) {    /* Set handler, and leave a note for mod_cgi */
 373                 r->handler = p->handler;
 374                 apr_table_setn(r->notes, "alias-forced-type", r->handler);
 375             }
 376             /* XXX This is as SLOW as can be, next step, we optimize
 377              * and merge to whatever part of the found path was already
 378              * canonicalized.  After I finish eliminating os canonical.
 379              * Better fail test for ap_server_root_relative needed here.
 380              */
 381             if (!doesc) {
 382                 found = ap_server_root_relative(r->pool, found);
 383             }
 384             if (found) {
 385                 *status = p->redir_status;
 386             }
 387             return found;
 388         }
 389
 390     }
 391
 392     return NULL;
 393 }
 394
 395 static int translate_alias_redir(request_rec *r)
 396 {
 397     ap_conf_vector_t *sconf = r->server->module_config;
 398     alias_server_conf *serverconf = ap_get_module_config(sconf, &alias_module);
 399     char *ret;
 400     int status;
 401
 402     if (r->uri[0] != '/' && r->uri[0] != '\0') {
 403         return DECLINED;
 404     }
 405
 406     if ((ret = try_alias_list(r, serverconf->redirects, 1, &status)) != NULL) {
 407         if (ap_is_HTTP_REDIRECT(status)) {
 408             /* include QUERY_STRING if any */
 409             if (r->args) {
 410                 ret = apr_pstrcat(r->pool, ret, "?", r->args, NULL);
 411             }
 412             apr_table_setn(r->headers_out, "Location", ret);
 413         }
 414         return status;
 415     }
 416
 417     if ((ret = try_alias_list(r, serverconf->aliases, 0, &status)) != NULL) {
 418         r->filename = ret;
 419         return OK;
 420     }
 421
 422     return DECLINED;
 423 }
 424
 425 static int fixup_redir(request_rec *r)
 426 {
 427     void *dconf = r->per_dir_config;
 428     alias_dir_conf *dirconf =
 429     (alias_dir_conf *) ap_get_module_config(dconf, &alias_module);
 430     char *ret;
 431     int status;
 432
 433     /* It may have changed since last time, so try again */
 434
 435     if ((ret = try_alias_list(r, dirconf->redirects, 1, &status)) != NULL) {
 436         if (ap_is_HTTP_REDIRECT(status)) {
 437             if (ret[0] == '/') {
 438                 char *orig_target = ret;
 439
 440                 ret = ap_construct_url(r->pool, ret, r);
 441                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
 442                               "incomplete redirection target of '%s' for "
 443                               "URI '%s' modified to '%s'",
 444                               orig_target, r->uri, ret);
 445             }
 446             if (!ap_is_url(ret)) {
 447                 status = HTTP_INTERNAL_SERVER_ERROR;
 448                 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 449                               "cannot redirect '%s' to '%s'; "
 450                               "target is not a valid absoluteURI or abs_path",
 451                               r->uri, ret);
 452             }
 453             else {
 454                 /* append requested query only, if the config didn't
 455                  * supply its own.
 456                  */
 457                 if (r->args && !ap_strchr(ret, '?')) {
 458                     ret = apr_pstrcat(r->pool, ret, "?", r->args, NULL);
 459                 }
 460                 apr_table_setn(r->headers_out, "Location", ret);
 461             }
 462         }
 463         return status;
 464     }
 465
 466     return DECLINED;
 467 }
 468
 469 static void register_hooks(apr_pool_t *p)
 470 {
 471     static const char * const aszSucc[]={ "mod_userdir.c",
 472                                           "mod_vhost_alias.c",NULL };
 473
 474     ap_hook_translate_name(translate_alias_redir,NULL,aszSucc,APR_HOOK_MIDDLE);
 475     ap_hook_fixups(fixup_redir,NULL,NULL,APR_HOOK_MIDDLE);
 476 }
 477
 478 module AP_MODULE_DECLARE_DATA alias_module =
 479 {
 480     STANDARD20_MODULE_STUFF,
 481     create_alias_dir_config,       /* dir config creater */
 482     merge_alias_dir_config,        /* dir merger --- default is to override */
 483     create_alias_config,           /* server config */
 484     merge_alias_config,            /* merge server configs */
 485     alias_cmds,                    /* command apr_table_t */
 486     register_hooks                 /* register hooks */
 487 };