mod_rewrite.c revision fa72e29f3fb2ba6e83ee013ad935d2e79fe92477
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
/* _ _ _
* _ __ ___ ___ __| | _ __ _____ ___ __(_) |_ ___
* | '_ ` _ \ / _ \ / _` | | '__/ _ \ \ /\ / / '__| | __/ _ \
* | | | | | | (_) | (_| | | | | __/\ V V /| | | | || __/
* |_| |_| |_|\___/ \__,_|___|_| \___| \_/\_/ |_| |_|\__\___|
* |_____|
*
* URL Rewriting Module
*
* This module uses a rule-based rewriting engine (based on a
* regular-expression parser) to rewrite requested URLs on the fly.
*
* It supports an unlimited number of additional rule conditions (which can
* operate on a lot of variables, even on HTTP headers) for granular
* matching and even external database lookups (either via plain text
* tables, DBM hash files or even external processes) for advanced URL
* substitution.
*
* It operates on the full URLs (including the PATH_INFO part) both in
* per-server context (httpd.conf) and per-dir context (.htaccess) and even
* can generate QUERY_STRING parts on result. The rewriting result finally
* can lead to internal subprocessing, external request redirection or even
* to internal proxy throughput.
*
* This module was originally written in April 1996 and
* gifted exclusively to the The Apache Software Foundation in July 1997 by
*
* Ralf S. Engelschall
* rse@engelschall.com
*/
#include "apr.h"
#include "apr_strings.h"
#include "apr_hash.h"
#include "apr_user.h"
#include "apr_lib.h"
#include "apr_signal.h"
#include "apr_global_mutex.h"
#include "apr_dbm.h"
#if APR_HAS_THREADS
#include "apr_thread_mutex.h"
#endif
#define APR_WANT_MEMFUNC
#define APR_WANT_STRFUNC
#define APR_WANT_IOVEC
#include "apr_want.h"
/* XXX: Do we really need these headers? */
#include <unistd.h>
#endif
#endif
#include <stdarg.h>
#endif
#include <stdlib.h>
#endif
#if APR_HAVE_CTYPE_H
#include <ctype.h>
#endif
#include "ap_config.h"
#include "httpd.h"
#include "http_config.h"
#include "http_request.h"
#include "http_core.h"
#include "http_log.h"
#include "http_protocol.h"
#include "http_vhost.h"
#include "mod_rewrite.h"
#include "unixd.h"
#define MOD_REWRITE_SET_MUTEX_PERMS /* XXX Apache should define something */
#endif
/*
* The key in the r->notes apr_table_t wherein we store our accumulated
* Vary values, and the one used for per-condition checks in a chain.
*/
#define VARY_KEY "rewrite-Vary"
#define VARY_KEY_THIS "rewrite-Vary-this"
/* remembered mime-type for [T=...] */
#define REWRITE_FORCED_MIMETYPE_NOTEVAR "rewrite-forced-mimetype"
#define ENVVAR_SCRIPT_URL "SCRIPT_URL"
#define ENVVAR_SCRIPT_URI "SCRIPT_URI"
#define CONDFLAG_NONE 1<<0
#define RULEFLAG_NONE 1<<0
/* return code of the rewrite rule
* the result may be escaped - or not
*/
#define ACTION_NORMAL 1<<0
#define MAPTYPE_TXT 1<<0
#define ENGINE_DISABLED 1<<0
#define OPTION_NONE 1<<0
#ifndef RAND_MAX
#define RAND_MAX 32767
#endif
#ifndef LONG_STRING_LEN
#define LONG_STRING_LEN 2048
#endif
#define MAX_ENV_FLAGS 15
#define MAX_COOKIE_FLAGS 15
/* max cookie size in rfc 2109 */
#define MAX_COOKIE_LEN 4096
/* max number of regex captures */
#define MAX_NMATCH 10
/* default maximum number of internal redirects */
#define REWRITE_REDIRECT_LIMIT 10
/* for rewrite log file */
/* max line length (incl.\n) in text rewrite maps */
#ifndef REWRITE_MAX_TXT_MAP_LINE
#define REWRITE_MAX_TXT_MAP_LINE 1024
#endif
/* max response length (incl.\n) in prg rewrite maps */
#ifndef REWRITE_MAX_PRG_MAP_LINE
#define REWRITE_MAX_PRG_MAP_LINE 2048
#endif
/*
* +-------------------------------------------------------+
* | |
* | Types and Structures
* | |
* +-------------------------------------------------------+
*/
typedef struct {
const char *datafile; /* filename for map data files */
const char *dbmtype; /* dbm type for dbm map data files */
const char *checkfile; /* filename to check for map existence */
int type; /* the type of the map */
char *);
char **argv; /* argv of the external rewrite map */
typedef struct {
char *input; /* Input string of RewriteCond */
char *pattern; /* the RegExp pattern string */
int flags; /* Flags which control the match */
typedef struct {
char *pattern; /* the RegExp pattern string */
char *output; /* the Substitution string */
int flags; /* Flags which control the substitution */
char *forced_mimetype; /* forced MIME type of substitution */
int forced_responsecode; /* forced HTTP redirect response status */
int skip; /* number of next rules to skip */
typedef struct {
int state; /* the RewriteEngine state */
int options; /* the RewriteOption state */
const char *rewritelogfile; /* the RewriteLog filename */
int rewriteloglevel; /* the RewriteLog level of verbosity */
int redirect_limit; /* max number of internal redirects */
typedef struct {
int state; /* the RewriteEngine state */
int options; /* the RewriteOption state */
char *directory; /* the directory where it applies */
const char *baseurl; /* the base-URL where it applies */
int redirect_limit; /* max. number of internal redirects */
typedef struct {
int redirects; /* current number of redirects */
int redirect_limit; /* maximum number of redirects */
/* the (per-child) cache structures.
*/
typedef struct cache {
#if APR_HAS_THREADS
#endif
} cache;
/* cached maps contain an mtime for the whole map and live in a subpool
* of the cachep->pool. That makes it easy to forget them if necessary.
*/
typedef struct {
} cachedmap;
/* the regex structure for the
* substitution of backreferences
*/
typedef struct backrefinfo {
char *source;
int nsub;
} backrefinfo;
/* single linked list used for
* variable expansion
*/
typedef struct result_list {
struct result_list *next;
const char *string;
} result_list;
/*
* +-------------------------------------------------------+
* | |
* | static module data
* | |
* +-------------------------------------------------------+
*/
/* the global module structure */
/* rewritemap int: handler function registry */
static apr_hash_t *mapfunc_hash;
/* the cache */
/* whether proxy module is available or not */
static int proxy_available;
/* whether random seed can be reaped */
static int rewrite_rand_init_done = 0;
static const char *lockname;
/*
* +-------------------------------------------------------+
* | |
* | rewriting logfile support
* | |
* +-------------------------------------------------------+
*/
static char *current_logtime(request_rec *r)
{
char tstr[80];
apr_time_exp_lt(&t, apr_time_now());
}
{
const char *fname;
/* - no logfile configured
* - logfilename empty
* - virtual log shared w/ main server
*/
return 1;
}
if (!fname) {
"mod_rewrite: Invalid RewriteLog "
return 0;
}
"mod_rewrite: could not open reliable pipe "
"to RewriteLog filter %s", fname);
return 0;
}
}
else {
if (!fname) {
"mod_rewrite: Invalid RewriteLog "
return 0;
}
!= APR_SUCCESS) {
"mod_rewrite: could not open RewriteLog "
"file %s", fname);
return 0;
}
}
return 1;
}
{
int redir;
return;
}
rname = ap_get_remote_logname(r);
++redir;
}
"(%d) %s" APR_EOL_STR,
current_logtime(r),
(void *)(r->server),
(void *)r,
if (rv != APR_SUCCESS) {
"apr_global_mutex_lock(rewrite_log_lock) failed");
/* XXX: Maybe this should be fatal? */
}
if (rv != APR_SUCCESS) {
"apr_global_mutex_unlock(rewrite_log_lock) failed");
/* XXX: Maybe this should be fatal? */
}
return;
}
/*
* +-------------------------------------------------------+
* | |
* | URI and path functions
* | |
* +-------------------------------------------------------+
*/
/* return number of chars of the scheme (incl. '://')
* if the URI is absolute (includes a scheme etc.)
* otherwise 0.
*
* NOTE: If you add new schemes here, please have a
* look at escape_absolute_uri and splitout_queryargs.
* Not every scheme takes query strings and some schemes
* may be handled in a special way.
*
* XXX: we may consider a scheme registry, perhaps with
* appropriate escape callbacks to allow other modules
* to extend mod_rewrite at runtime.
*/
static unsigned is_absolute_uri(char *uri)
{
/* fast exit */
return 0;
}
switch (*uri++) {
case 'f':
case 'F':
return 6;
}
break;
case 'g':
case 'G':
return 9;
}
break;
case 'h':
case 'H':
return 7;
}
return 8;
}
break;
case 'l':
case 'L':
return 7;
}
break;
case 'm':
case 'M':
return 7;
}
break;
case 'n':
case 'N':
return 5;
}
return 7;
}
break;
}
return 0;
}
/*
* escape absolute uri, which may or may not be path oriented.
* So let's handle them differently.
*/
{
char *cp;
/* be safe.
* NULL should indicate elsewhere, that something's wrong
*/
return NULL;
}
/* scheme with authority part? */
/* skip host part */
++cp;
}
/* nothing after the hostpart. ready! */
return apr_pstrdup(p, uri);
}
/* remember the hostname stuff */
/* special thing for ldap.
* The parts are separated by question marks. From RFC 2255:
* ldapurl = scheme "://" [hostport] ["/"
* [dn ["?" [attributes] ["?" [scope]
* ["?" [filter] ["?" extensions]]]]]]
*/
char *token[5];
int c = 0;
while (*cp && c < 5) {
if (*cp == '?') {
*cp = '\0';
}
++cp;
}
ap_escape_uri(p, token[0]),
NULL);
}
}
/* Nothing special here. Apply normal escaping. */
}
/*
* split out a QUERY_STRING part from
* the current URI string
*/
{
char *q;
/* don't touch, unless it's an http or mailto URL.
* See RFC 1738 and RFC 2368.
*/
if ( is_absolute_uri(r->filename)
return;
}
if (q != NULL) {
char *olduri;
*q++ = '\0';
if (qsappend) {
}
else {
}
if (!len) {
}
}
}
return;
}
/*
* strip 'http[s]://ourhost/' from URI
*/
static void reduce_uri(request_rec *r)
{
char *cp;
apr_size_t l;
cp = (char *)ap_http_method(r);
&& r->filename[l] == ':'
unsigned short port;
/* cut the hostname and port out of the URI */
++cp;
}
*cp++ = '\0';
++cp;
}
*cp = '\0';
if (!*url) {
url = "/";
}
}
*cp = '\0';
port = ap_default_port(r);
}
else {
port = ap_default_port(r);
url = "/";
}
/* now check whether we could reduce it to a local path... */
}
}
return;
}
/*
* add 'http[s]://ourhost[:ourport]/' to URI
* if URI is still not fully qualified
*/
static void fully_qualify_uri(request_rec *r)
{
if (!is_absolute_uri(r->filename)) {
const char *thisserver;
char *thisport;
int port;
thisserver = ap_get_server_name(r);
port = ap_get_server_port(r);
? ""
r->filename);
}
return;
}
/*
* stat() only the first segment of a path
*/
{
const char *root;
const char *slash;
char *statpath;
if (rv != APR_SUCCESS) {
return 0;
}
/* let's recognize slashes only, the mod_rewrite semantics are opaque
* enough.
*/
}
else {
}
if (rv == APR_SUCCESS) {
return 1;
}
}
return 0;
}
/*
* substitute the prefix path 'match' in 'input' with 'subst' (RewriteBase)
*/
const char *subst)
{
--len;
}
char *output;
++slen;
}
}
return output;
}
/* prefix didn't match */
return input;
}
/*
* +-------------------------------------------------------+
* | |
* | caching support
* | |
* +-------------------------------------------------------+
*/
char *val)
{
if (cachep) {
#if APR_HAS_THREADS
#endif
if (!map) {
apr_pool_t *p;
#if APR_HAS_THREADS
#endif
return;
}
}
}
/* Now we should have a valid map->entries hash, where we
* can store our value.
*
* We need to copy the key and the value into OUR pool,
* so that we don't leave it during the r->pool cleanup.
*/
#if APR_HAS_THREADS
#endif
}
return;
}
apr_pool_t *p)
{
if (cachep) {
#if APR_HAS_THREADS
#endif
if (map) {
/* if this map is outdated, forget it. */
}
else {
if (val) {
/* copy the cached value into the supplied pool,
* where it belongs (r->pool usually)
*/
}
}
}
#if APR_HAS_THREADS
#endif
}
return val;
}
static int init_cache(apr_pool_t *p)
{
return 0;
}
#if APR_HAS_THREADS
#endif
return 1;
}
/*
* +-------------------------------------------------------+
* | |
* | Map Functions
* | |
* +-------------------------------------------------------+
*/
/*
* General Note: key is already a fresh string, created (expanded) just
* for the purpose to be passed in here. So one can modify key itself.
*/
{
char *p;
for (p = key; *p; ++p) {
*p = apr_toupper(*p);
}
return key;
}
{
char *p;
for (p = key; *p; ++p) {
*p = apr_tolower(*p);
}
return key;
}
{
}
{
return key;
}
{
char *p = value;
unsigned n = 1;
/* count number of distinct values */
++n;
++p;
}
if (n > 1) {
/* initialize random generator
*
* XXX: Probably this should be wrapped into a thread mutex,
* shouldn't it? Is it worth the effort?
*/
if (!rewrite_rand_init_done) {
}
/* select a random subvalue */
/* extract it from the whole string */
++value;
}
if (value) { /* should not be NULL, but ... */
if (p) {
*p = '\0';
}
}
}
return value;
}
/* child process code */
const char *desc)
{
}
apr_file_t **fpout,
apr_file_t **fpin)
{
ap_make_dirstr_parent(p, argv[0])))
procattr, p);
if (rc == APR_SUCCESS) {
if (fpin) {
}
if (fpout) {
}
}
}
return (rc);
}
{
/* If the engine isn't turned on,
* don't even try to do anything.
*/
return APR_SUCCESS;
}
void *val;
continue;
}
continue;
}
"mod_rewrite: could not start RewriteMap "
return rc;
}
}
return APR_SUCCESS;
}
/*
* +-------------------------------------------------------+
* | |
* | Lookup functions
* | |
* +-------------------------------------------------------+
*/
{
r->pool) != APR_SUCCESS) {
return NULL;
}
char *p, *c;
/* ignore comments and lines starting with whitespaces */
continue;
}
p = line;
c = key;
while (c < keylast && *p == *c && !apr_isspace(*p)) {
++p;
++c;
}
/* key doesn't match - ignore. */
if (c != keylast || !apr_isspace(*p)) {
continue;
}
/* jump to the value */
while (*p && apr_isspace(*p)) {
++p;
}
/* no value? ignore */
if (!*p) {
continue;
}
/* extract the value and return. */
c = p;
while (*p && !apr_isspace(*p)) {
++p;
}
break;
}
return value;
}
{
char *value;
r->pool) != APR_SUCCESS) {
return NULL;
}
}
else {
}
return value;
}
{
char buf[REWRITE_MAX_PRG_MAP_LINE];
char c;
apr_size_t i;
#ifndef NO_WRITEV
#endif
/* when `RewriteEngine off' was used in the per-server
* context then the rewritemap-programs were not spawned.
* In this case using such a map (usually in per-dir context)
* is useless because it is not available.
*
* newlines in the key leave bytes in the pipe and cause
* bad things to happen (next map lookup will use the chars
* after the \n instead of the new key etc etc - in other words,
* the Rewritemap falls out of sync with the requests).
*/
return NULL;
}
/* take the lock */
if (rewrite_mapr_lock_acquire) {
if (rv != APR_SUCCESS) {
"apr_global_mutex_lock(rewrite_mapr_lock_acquire) "
"failed");
return NULL; /* Maybe this should be fatal? */
}
}
/* write out the request key */
#ifdef NO_WRITEV
nbytes = 1;
#else
niov = 2;
#endif
/* read in the response value */
i = 0;
nbytes = 1;
if (c == '\n') {
break;
}
buf[i++] = c;
}
/* give the lock back */
if (rewrite_mapr_lock_acquire) {
if (rv != APR_SUCCESS) {
"apr_global_mutex_unlock(rewrite_mapr_lock_acquire) "
"failed");
return NULL; /* Maybe this should be fatal? */
}
}
return NULL;
}
}
/*
* generic map lookup
*/
{
rewritemap_entry *s;
char *value;
/* get map configuration */
/* map doesn't exist */
if (!s) {
return NULL;
}
switch (s->type) {
/*
* Text file map (perhaps random)
*/
case MAPTYPE_RND:
case MAPTYPE_TXT:
if (rv != APR_SUCCESS) {
"mod_rewrite: can't access text RewriteMap file %s",
s->checkfile);
return NULL;
}
if (!value) {
if (!value) {
return NULL;
}
}
else {
}
}
/*
* DBM file map
*/
case MAPTYPE_DBM:
if (rv != APR_SUCCESS) {
"mod_rewrite: can't access DBM RewriteMap file %s",
s->checkfile);
return NULL;
}
if (!value) {
if (!value) {
return NULL;
}
return value;
}
/*
* Program file map
*/
case MAPTYPE_PRG:
if (!value) {
return NULL;
}
return value;
/*
* Internal Map
*/
case MAPTYPE_INT:
if (!value) {
return NULL;
}
return value;
}
return NULL;
}
/*
* lookup a HTTP header and set VARY note
*/
{
if (val) {
}
return val;
}
/* check that a subrequest won't cause infinite recursion */
static int subreq_ok(request_rec *r)
{
/*
* either not in a subrequest, or in a subrequest
*/
return (!r->main ||
}
/*
* generic variable lookup
*/
{
const char *result;
/* fast exit */
if (varlen < 4) {
}
/* fast tests for variable length variables (sic) first */
var += 4;
if (!result) {
}
if (!result) {
}
}
}
if (var[5]) {
}
return (char *)result;
}
}
return (char *)result;
}
}
}
}
/* well, do it the hard way */
else {
char *p;
/* can't do this above, because of the getenv call */
for (p = var; *p; ++p) {
*p = apr_toupper(*p);
}
switch (varlen) {
case 4:
return (char *)result;
}
break;
case 8:
switch (var[6]) {
case 'A':
}
break;
case 'E':
}
break;
case 'I':
}
break;
case 'O':
}
break;
}
break;
case 9:
switch (var[7]) {
case 'A':
}
}
break;
case 'E':
}
break;
case 'F':
}
break;
case 'P':
result = r->ap_auth_type;
}
break;
case 'S':
}
break;
case 'U':
}
break;
}
break;
case 11:
switch (var[8]) {
case 'A':
result = ap_get_server_name(r);
}
break;
case 'D':
}
}
break;
case 'E':
}
result = r->the_request;
}
break;
case 'I':
}
break;
case 'K':
}
break;
case 'O':
REMOTE_NAME, NULL);
}
}
break;
case 'S':
}
result = "<unknown>";
r->pool);
}
}
break;
case 'U':
}
break;
}
break;
case 12:
switch (var[3]) {
case 'I':
result = "<unknown>";
r->pool);
}
}
break;
case 'O':
result = ap_get_remote_logname(r);
}
break;
case 'P':
}
break;
case 'R':
}
break;
case 'V':
}
break;
}
break;
case 13:
result = ap_document_root(r);
}
break;
case 14:
}
}
break;
case 15:
switch (var[7]) {
case 'E':
}
break;
case 'F':
}
break;
case 'P':
}
break;
case 'S':
}
break;
}
break;
case 16:
}
break;
case 21:
}
break;
}
}
}
/*
* +-------------------------------------------------------+
* | |
* | Expansion functions
* | |
* +-------------------------------------------------------+
*/
/*
* Bracketed expression handling
* s points after the opening bracket
*/
{
int depth;
for (depth = 1; *s; ++s) {
return s;
}
else if (*s == left) {
++depth;
}
}
return NULL;
}
{
int depth;
for (depth = 1; *s; ++s) {
if (*s == c && depth == 1) {
return s;
}
return NULL;
}
else if (*s == left) {
++depth;
}
}
return NULL;
}
/* perform all the expansions on the input string
* putting the result into a new string
*
* for security reasons this expansion must be performed in a
* single pass, otherwise an attacker can arrange for the result
* of an earlier expansion to include expansion specifiers that
* are interpreted by a later expansion, producing results that
* were not intended by the administrator.
*/
{
char *p, *c;
/* fast exit */
}
/* well, actually something to do */
/* loop for specials */
do {
/* prepare next entry */
}
/* escaped character */
if (*p == '\\') {
++outlen;
if (!p[1]) {
break;
}
else {
++p;
}
}
/* variable or map lookup */
else if (p[1] == '{') {
char *endp;
if (!endp) {
outlen += 2;
p += 2;
}
/* variable lookup */
else if (*p == '%') {
p = endp + 1;
}
/* map lookup */
else { /* *p == '$' */
char *key;
/*
* To make rewrite maps useful, the lookup key and
* default values must be expanded, so we make
* recursive calls to do the work. For security
* reasons we must never expand a string that includes
* verbatim data from the network. The recursion here
* isn't a problem because the result of expansion is
* only passed to lookup_map() so it cannot be
* re-expanded, only re-looked-up. Another way of
* looking at it is that the recursion is entirely
* driven by the syntax of the nested curly brackets.
*/
if (!key) {
outlen += 2;
p += 2;
}
else {
*key++ = '\0';
if (dflt) {
*dflt++ = '\0';
}
else {
dflt = "";
}
/* reuse of key variable as result */
}
if (key) {
}
p = endp + 1;
}
}
}
/* backreference */
else if (apr_isdigit(p[1])) {
int n = p[1] - '0';
}
p += 2;
}
/* not for us, just copy it */
else {
++outlen;
}
/* check the remainder */
}
p += span;
}
/* assemble result */
do {
* extensive testing and
* review
*/
}
} while (result);
p[outlen] = '\0';
return p;
}
/*
* perform all the expansions on the environment variables
*/
static void add_env_variable(request_rec *r, char *s)
{
char *val;
*val++ = '\0';
}
}
{
int i;
}
}
/*
* perform all the expansions on the cookies
*/
static void add_cookie(request_rec *r, char *s)
{
char *var;
char *val;
char *domain;
char *expires;
char *path;
char *tok_cntx;
char *cookie;
if (s) {
/** the line below won't hit the token ever **/
if (expires) {
}
else {
}
/* FIX: use cached time similar to how logging does it */
request_rec *rmain = r;
char *notename;
void *data;
}
"; domain=", domain,
(expires)?
ap_ht_time(r->pool,
r->request_time +
apr_time_from_sec((60 *
"%a, %d-%b-%Y %T GMT", 1)
: NULL,
NULL);
/*
* XXX: should we add it to err_headers_out as well ?
* if we do we need to be careful that only ONE gets sent out
*/
}
else {
}
}
}
}
{
int i;
}
}
#if APR_HAS_USER
/*
* database information (or other OS-specific database)
*/
{
char user[LONG_STRING_LEN];
char *newuri;
int i, j;
char *homedir;
/* cut out the username */
&& uri[i] != '\0'
&& uri[i] != '/' ; ) {
}
user[j] = '\0';
/* lookup username in systems passwd file */
/* ok, user was found, so expand the ~user string */
if (uri[i] != '\0') {
}
}
else {
/* only ~user has to be expanded */
}
}
}
return newuri;
}
#endif /* if APR_HAS_USER */
/*
* +-------------------------------------------------------+
* | |
* | rewriting lockfile support
* | |
* +-------------------------------------------------------+
*/
{
/* only operate if a lockfile is used */
return APR_SUCCESS;
}
/* create the lockfile */
APR_LOCK_DEFAULT, p);
if (rc != APR_SUCCESS) {
"mod_rewrite: Parent could not create RewriteLock "
"file %s", lockname);
return rc;
}
#ifdef MOD_REWRITE_SET_MUTEX_PERMS
if (rc != APR_SUCCESS) {
"mod_rewrite: Parent could not set permissions "
"on RewriteLock; check User and Group directives");
return rc;
}
#endif
return APR_SUCCESS;
}
{
/* only operate if a lockfile is used */
return APR_SUCCESS;
}
/* destroy the rewritelock */
return(0);
}
/*
* +-------------------------------------------------------+
* | |
* | configuration directive handling
* | |
* +-------------------------------------------------------+
*/
/*
* own command line parser for RewriteRule and RewriteCond,
* which doesn't have the '\\' problem
*/
{
char *cp;
int isquoted;
#define SKIP_WHITESPACE(cp) \
cp++; \
};
isquoted = 0; \
if (*cp == '"') { \
isquoted = 1; \
cp++; \
}
cp++; \
continue; \
} \
break; \
} \
}
/* determine first argument */
if (*cp == '\0') {
return 1;
}
*cp++ = '\0';
/* determine second argument */
if (*cp == '\0') {
*cp++ = '\0';
return 0;
}
*cp++ = '\0';
/* again check if there are only two arguments */
if (*cp == '\0') {
*cp++ = '\0';
return 0;
}
/* determine second argument */
*cp = '\0';
return 0;
}
{
a->state = ENGINE_DISABLED;
a->options = OPTION_NONE;
a->rewritelogfile = NULL;
a->rewritelogfp = NULL;
a->rewriteloglevel = 0;
a->rewritemaps = apr_hash_make(p);
a->server = s;
a->redirect_limit = 0; /* unset (use default) */
return (void *)a;
}
{
a = (rewrite_server_conf *)apr_pcalloc(p,
sizeof(rewrite_server_conf));
: base->redirect_limit;
if (a->options & OPTION_INHERIT) {
/*
* local directives override
* and anything else is inherited
*/
: base->rewriteloglevel;
: base->rewritelogfile;
: base->rewritelogfp;
base->rewritemaps);
base->rewriteconds);
base->rewriterules);
}
else {
/*
* local directives override
* and anything else gets defaults
*/
}
return (void *)a;
}
{
a->state = ENGINE_DISABLED;
a->options = OPTION_NONE;
a->redirect_limit = 0; /* unset (use server config) */
}
else {
/* make sure it has a trailing slash */
}
else {
}
}
return (void *)a;
}
{
a = (rewrite_perdir_conf *)apr_pcalloc(p,
sizeof(rewrite_perdir_conf));
: base->redirect_limit;
if (a->options & OPTION_INHERIT) {
base->rewriteconds);
base->rewriterules);
}
else {
}
return (void *)a;
}
{
}
else /* is per-directory command */ {
}
return NULL;
}
{
char *w;
while (*option) {
if (!strcasecmp(w, "inherit")) {
}
if (limit <= 0) {
return "RewriteOptions: MaxRedirects takes a number greater "
"than zero.";
}
}
return "RewriteOptions: MaxRedirects has the format MaxRedirects"
"=n.";
}
else {
w, "'", NULL);
}
}
/* put it into the appropriate config */
}
else { /* is per-directory command */
}
return NULL;
}
{
return NULL;
}
const char *a1)
{
return NULL;
}
const char *a2)
{
}
}
const char *ignored_fname;
int bad = 0;
}
if (colon) {
}
else {
++bad;
}
}
else {
++bad;
}
if (bad) {
}
if (rv != APR_SUCCESS) {
}
}
}
}
}
else {
}
"RewriteMap: file for map ", a1,
}
return NULL;
}
{
const char *error;
return error;
/* fixup the path, especially for rewritelock_remove() */
if (!lockname) {
}
return NULL;
}
const char *a1)
{
return "RewriteBase: only valid in per-directory config files";
}
if (a1[0] == '\0') {
return "RewriteBase: empty URL not allowed";
}
if (a1[0] != '/') {
return "RewriteBase: argument is not a valid URL";
}
return NULL;
}
/*
* generic lexer for RewriteRule and RewriteCond flags.
* The parser will be passed in as a function pointer
* and called if a flag was found
*/
const char *(*parse)(apr_pool_t *,
void *,
char *, char *))
{
const char *err;
return "RewriteCond: bad flag delimiters";
}
++key;
while (*key) {
/* skip leading spaces */
while (apr_isspace(*key)) {
++key;
}
* happen, but ...
*/
break;
}
/* strip trailing spaces */
while (apr_isspace(*endp)) {
--endp;
}
*++endp = '\0';
/* split key and val */
if (val) {
*val++ = '\0';
}
else {
}
if (err) {
return err;
}
}
return NULL;
}
{
}
}
else {
}
return NULL;
}
const char *in_str)
{
char *a1;
char *a2;
char *a3;
const char *err;
/* make a new entry in the internal temporary rewrite rule list */
}
else { /* is per-directory command */
}
/* parse the argument line ourself */
"'", NULL);
}
/* arg1: the input string */
/* arg3: optional flags field
(this have to be first parsed, because we need to
know if the regex should be compiled with ICASE!) */
cmd_rewritecond_setflag)) != NULL) {
return err;
}
}
/* arg2: the pattern
try to compile the regexp to test if is ok */
if (*a2 == '!') {
++a2;
}
? REG_ICASE : 0));
if (!regexp) {
"RewriteCond: cannot compile regular expression '",
}
return NULL;
}
{
int status = 0;
int i = 0;
switch (*key++) {
case 'c':
case 'C':
}
++i;
}
if (i < MAX_COOKIE_FLAGS) {
}
else {
return "RewriteRule: too many cookie flags 'CO'";
}
}
break;
case 'e':
case 'E':
++i;
}
if (i < MAX_ENV_FLAGS) {
}
else {
return "RewriteRule: too many environment flags 'E'";
}
}
break;
case 'f':
case 'F':
}
break;
case 'g':
case 'G':
}
break;
case 'l':
case 'L':
}
break;
case 'n':
case 'N':
}
}
}
}
break;
case 'p':
case 'P':
}
}
break;
case 'q':
case 'Q':
}
break;
case 'r':
case 'R':
}
}
}
else if (apr_isdigit(*val)) {
if (!ap_is_HTTP_REDIRECT(status)) {
return "RewriteRule: invalid HTTP response code "
"for flag 'R'";
}
}
}
}
break;
case 's':
case 'S':
}
break;
case 't':
case 'T':
}
break;
default:
}
return NULL;
}
const char *in_str)
{
char *a1;
char *a2;
char *a3;
const char *err;
/* make a new entry in the internal rewrite rule list */
}
else { /* is per-directory command */
}
/* parse the argument line ourself */
"'", NULL);
}
/* arg3: optional flags field */
cmd_rewriterule_setflag)) != NULL) {
return err;
}
}
/* arg1: the pattern
* try to compile the regexp to test if is ok
*/
if (*a1 == '!') {
++a1;
}
? REG_ICASE : 0));
if (!regexp) {
"RewriteRule: cannot compile regular expression '",
}
/* arg2: the output string */
/* now, if the server or per-dir config holds an
* array of RewriteCond entries, we take it for us
* and clear the array
*/
sizeof(rewritecond_entry));
}
else { /* is per-directory command */
sizeof(rewritecond_entry));
}
return NULL;
}
/*
* +-------------------------------------------------------+
* | |
* | the rewriting engine
* | |
* +-------------------------------------------------------+
*/
/* Lexicographic Compare */
{
int i;
return 1;
}
return -1;
}
for (i = 0; i < n1; i++) {
return 1;
}
return -1;
}
}
return 0;
}
/*
* Apply a single rewriteCond
*/
{
char *input;
int rc;
/*
* Construct the string we match against
*/
/*
* Apply the patterns
*/
rc = 0;
rc = 1;
}
}
}
rc = 1;
}
}
}
#if !defined(OS2)
rc = 1;
}
}
#endif
}
rc = 1;
}
}
}
/* avoid infinite subrequest recursion */
/* run a URI-based subrequest */
/* URI exists for any result up to 3xx, redirects allowed */
rc = 1;
/* log it */
/* cleanup by destroying the subrequest */
}
}
/* avoid infinite subrequest recursion */
/* process a file-based subrequest:
* this differs from -U in that no path translation is done.
*/
/* file exists for any result up to 2xx, no redirects */
/* double-check that file exists since default result is 200 */
r->pool) == APR_SUCCESS) {
rc = 1;
}
/* log it */
/* cleanup by destroying the subrequest */
}
}
}
}
}
else {
}
}
else {
/* it is really a regexp pattern, so apply it */
/* if it isn't a negated pattern and really matched
we update the passed-through regex subst info structure */
sizeof(regmatch));
}
}
/* if this is a non-matching regexp, just negate the result */
if (p->flags & CONDFLAG_NOTMATCH) {
}
/* end just return the result */
return rc;
}
/*
* Apply a single RewriteRule
*/
char *perdir)
{
char *uri;
char *output;
const char *vary;
char *newuri;
int prefixstrip;
int failed;
int i;
int rc;
/*
* Initialisation
*/
/*
* Add (perhaps splitted away) PATH_INFO postfix to URL to
* make sure we really match against the complete URL.
*/
}
/*
* On per-directory context (.htaccess) strip the location
* prefix from the URL to make sure patterns apply only to
* the local part. Additionally indicate this special
* threatment in the logfile.
*/
prefixstrip = 0;
prefixstrip = 1;
}
}
/*
* Try to match the URI against the RewriteRule pattern
* and exit immeddiately if it didn't apply.
*/
}
else {
}
return 0;
}
/*
* Else create the RewriteRule `regsubinfo' structure which
* holds the substitution information.
*/
/* empty info on negative patterns */
}
else {
sizeof(regmatch));
}
/*
* Initiallally create the RewriteCond backrefinfo with
* empty backrefinfo, i.e. not subst parts
* (this one is adjusted inside apply_rewrite_cond() later!!)
*/
/*
* Ok, we already know the pattern has matched, but we now
* additionally have to check for all existing preconditions
* (RewriteCond) which have to be also true. We do this at
* this very late stage to avoid unnessesary checks which
* would slow down the rewriting engine!!
*/
rewriteconds = p->rewriteconds;
failed = 0;
for (i = 0; i < rewriteconds->nelts; i++) {
c = &conds[i];
if (c->flags & CONDFLAG_ORNEXT) {
/*
* The "OR" case
*/
if (rc == 0) {
/* One condition is false, but another can be
* still true, so we have to continue...
*/
continue;
}
else {
/* One true condition is enough in "or" case, so
* skip the other conditions which are "ornext"
* chained
*/
while ( i < rewriteconds->nelts
&& c->flags & CONDFLAG_ORNEXT) {
i++;
c = &conds[i];
}
continue;
}
}
else {
/*
* The "AND" case, i.e. no "or" flag,
* so a single failure means total failure.
*/
if (rc == 0) {
failed = 1;
break;
}
}
}
}
/* if any condition fails the complete rule fails */
if (failed) {
return 0;
}
/*
* Regardless of what we do next, we've found a match. Check to see
* if any of the request header fields were involved, and add them
* to the Vary field of the response.
*/
}
/*
* If this is a pure matching rule (`RewriteRule <pat> -')
* we stop processing and return immediately. The only thing
* we have not to forget are the environment variables and
* cookies:
* (`RewriteRule <pat> - [E=...,CO=...]')
*/
if (p->forced_mimetype != NULL) {
/* In the per-server context we can force the MIME-type
* the correct way by notifying our MIME-type hook handler
* to do the job when the MIME-type API stage is reached.
*/
r->filename, p->forced_mimetype);
p->forced_mimetype);
}
else {
/* In per-directory context we operate in the Fixup API hook
* which is after the MIME-type hook, so our MIME-type handler
* has no chance to set r->content_type. And because we are
* in the situation where no substitution takes place no
* sub-request will happen (which could solve the
* restriction). As a workaround we do it ourself now
* immediately although this is not strictly API-conforming.
* But it's the only chance we have...
*/
ap_set_content_type(r, p->forced_mimetype);
}
}
return 2;
}
/*
* Ok, now we finally know all patterns have matched and
* that there is something to replace, so we create the
* substitution URL string in `newuri'.
*/
}
else {
}
/*
* Additionally do expansion for the environment variable
* strings (`RewriteRule .. .. [E=<string>]').
*/
/*
* Also set cookies for any cookie strings
* (`RewriteRule .. .. [CO=<string>]').
*/
/*
* Now replace API's knowledge of the current URI:
* Replace r->filename with the new URI string and split out
* an on-the-fly generated QUERY_STRING part into r->args
*/
/*
* Add the previously stripped per-directory location
* prefix if the new URI is not a new one for this
* location, i.e. if it's not an absolute URL (!) path nor
* a fully qualified URL scheme.
*/
&& !is_absolute_uri(r->filename)) {
}
/*
* If this rule is forced for proxy throughput
* (`RewriteRule ... ... [P]') then emulate mod_proxy's
* URL-to-filename handler to be sure mod_proxy is triggered
* for this URL later in the Apache API. But make sure it is
* a fully-qualified URL. (If not it is qualified with
* ourself).
*/
if (p->flags & RULEFLAG_PROXY) {
}
else {
}
return 1;
}
/*
* If this rule is explicitly forced for HTTP redirection
* (`RewriteRule .. .. [R]') then force an external HTTP
* redirect. But make sure it is a fully-qualified URL. (If
* not it is qualified with ourself).
*/
if (p->flags & RULEFLAG_FORCEREDIRECT) {
rewritelog(r, 2,
"explicitly forcing redirect with %s", r->filename);
}
else {
rewritelog(r, 2,
"[per-dir %s] explicitly forcing redirect with %s",
}
r->status = p->forced_responsecode;
return 1;
}
/*
* Special Rewriting Feature: Self-Reduction
* We reduce the URL by stripping a possible
* http[s]://<ourhost>[:<port>] prefix, i.e. a prefix which
* corresponds to ourself. This is to simplify rewrite maps
* and to avoid recursion, etc. When this prefix is not a
* coincidence then the user has to use [R] explicitly (see
* above).
*/
reduce_uri(r);
/*
* If this rule is still implicitly forced for HTTP
* redirection (`RewriteRule .. <scheme>://...') then
* directly force an external HTTP redirect.
*/
if (is_absolute_uri(r->filename)) {
rewritelog(r, 2,
"implicitly forcing redirect (rc=%d) with %s",
p->forced_responsecode, r->filename);
}
else {
r->filename);
}
r->status = p->forced_responsecode;
return 1;
}
/*
* Finally we had to remember if a MIME-type should be
* forced for this URL (`RewriteRule .. .. [T=<type>]')
* Later in the API processing phase this is forced by our
* MIME API-hook function. This time it's no problem even for
* the per-directory context (where the MIME-type hook was
* already processed) because a sub-request happens ;-)
*/
if (p->forced_mimetype != NULL) {
p->forced_mimetype);
r->filename, p->forced_mimetype);
}
else {
rewritelog(r, 2,
"[per-dir %s] remember %s to have MIME-type '%s'",
}
}
/*
* Puuhhhhhhhh... WHAT COMPLICATED STUFF ;_)
* But now we're done for this particular rule.
*/
return 1;
}
/*
* Apply a complete rule set,
* i.e. a list of rewrite rules
*/
char *perdir)
{
int i;
int changed;
int rc;
int s;
/*
* Iterate over all existing rules
*/
changed = 0;
loop:
for (i = 0; i < rewriterules->nelts; i++) {
p = &entries[i];
/*
* Ignore this rule on subrequests if we are explicitly
* asked to do so or this is a proxy-throughput or a
* forced redirect rule.
*/
(p->flags & RULEFLAG_IGNOREONSUBREQ ||
p->flags & RULEFLAG_PROXY ||
p->flags & RULEFLAG_FORCEREDIRECT )) {
continue;
}
/*
* Apply the current rule.
*/
if (rc) {
/*
* Indicate a change if this was not a match-only rule.
*/
if (rc != 2) {
? ACTION_NOESCAPE : ACTION_NORMAL);
}
/*
* Pass-Through Feature (`RewriteRule .. .. [PT]'):
* Because the Apache 1.x API is very limited we
* need this hack to pass the rewritten URL to other
* modules like mod_alias, mod_userdir, etc.
*/
if (p->flags & RULEFLAG_PASSTHROUGH) {
"to next API URI-to-filename handler", r->filename);
break;
}
/*
* Rule has the "forbidden" flag set which means that
* we stop processing and indicate this to the caller.
*/
if (p->flags & RULEFLAG_FORBIDDEN) {
break;
}
/*
* Rule has the "gone" flag set which means that
* we stop processing and indicate this to the caller.
*/
if (p->flags & RULEFLAG_GONE) {
break;
}
/*
* Stop processing also on proxy pass-through and
* last-rule and new-round flags.
*/
if (p->flags & RULEFLAG_PROXY) {
break;
}
if (p->flags & RULEFLAG_LASTRULE) {
break;
}
/*
* On "new-round" flag we just start from the top of
* the rewriting ruleset again.
*/
if (p->flags & RULEFLAG_NEWROUND) {
goto loop;
}
/*
* If we are forced to skip N next rules, do it now.
*/
if (p->skip > 0) {
s = p->skip;
while ( i < rewriterules->nelts
&& s > 0) {
i++;
p = &entries[i];
s--;
}
}
}
else {
/*
* If current rule is chained with next rule(s),
* skip all this next rule(s)
*/
while ( i < rewriterules->nelts
&& p->flags & RULEFLAG_CHAIN) {
i++;
p = &entries[i];
}
}
}
return changed;
}
/*
* +-------------------------------------------------------+
* | |
* | Module Initialization Hooks
* | |
* +-------------------------------------------------------+
*/
{
/* register int: rewritemap handlers */
if (map_pfn_register) {
}
return OK;
}
static int post_config(apr_pool_t *p,
server_rec *s)
{
void *data;
int first_time = 0;
const char *userdata_key = "rewrite_init_module";
if (!data) {
first_time = 1;
}
/* check if proxy module is available */
/* create the rewriting lockfiles in the parent */
APR_LOCK_DEFAULT, p)) != APR_SUCCESS) {
"mod_rewrite: could not create rewrite_log_lock");
return HTTP_INTERNAL_SERVER_ERROR;
}
#ifdef MOD_REWRITE_SET_MUTEX_PERMS
if (rv != APR_SUCCESS) {
"mod_rewrite: Could not set permissions on "
"rewrite_log_lock; check User and Group directives");
return HTTP_INTERNAL_SERVER_ERROR;
}
#endif
rv = rewritelock_create(s, p);
if (rv != APR_SUCCESS) {
return HTTP_INTERNAL_SERVER_ERROR;
}
apr_pool_cleanup_register(p, (void *)s, rewritelock_remove,
/* step through the servers and
* - open each rewriting logfile
* - open the RewriteMap prg:xxx programs
*/
for (; s; s = s->next) {
if (!open_rewritelog(s, p)) {
return HTTP_INTERNAL_SERVER_ERROR;
}
if (!first_time) {
if (run_rewritemap_programs(s, p) != APR_SUCCESS) {
return HTTP_INTERNAL_SERVER_ERROR;
}
}
}
return OK;
}
{
lockname, p);
if (rv != APR_SUCCESS) {
"mod_rewrite: could not init rewrite_mapr_lock_acquire"
" in child");
}
}
if (rv != APR_SUCCESS) {
"mod_rewrite: could not init rewrite log lock in child");
}
/* create the lookup cache */
if (!init_cache(p)) {
"mod_rewrite: could not init map cache in child");
}
}
/*
* +-------------------------------------------------------+
* | |
* | runtime hooks
* | |
* +-------------------------------------------------------+
*/
/*
* URI-to-filename hook
* [deals with RewriteRules in server context]
*/
static int hook_uri2file(request_rec *r)
{
const char *saved_rulestatus;
const char *var;
const char *thisserver;
char *thisport;
const char *thisurl;
unsigned int port;
int rulestatus;
/*
* retrieve the config structures
*/
/*
* only do something under runtime if the engine is really enabled,
* else return immediately!
*/
return DECLINED;
}
/*
* check for the ugly API case of a virtual host section where no
* mod_rewrite directives exists. In this situation we became no chance
* by the API to setup our default per-server config so we have to
* on-the-fly assume we have the default config. But because the default
* config has a disabled rewriting engine we are lucky because can
* just stop operating now.
*/
return DECLINED;
}
/*
* add the SCRIPT_URL variable to the env. this is a bit complicated
* due to the fact that apache uses subrequests and internal redirects
*/
}
else {
}
}
else {
}
/*
* create the SCRIPT_URI variable for the env
*/
/* add the canonical URI of this URL */
thisserver = ap_get_server_name(r);
port = ap_get_server_port(r);
if (ap_is_default_port(port, r)) {
thisport = "";
}
else {
}
/* set the variable */
/* if filename was not initially set,
* we start with the requested URI
*/
r->filename);
}
else {
}
/*
* now apply the rules ...
*/
}
else {
rewritelog(r, 2,
"uri already rewritten. Status %s, Uri %s, r->filename %s",
}
if (rulestatus) {
unsigned skip;
/* it should be go on as an internal proxy request */
/* check if the proxy module is enabled, so
* we can actually use it!
*/
if (!proxy_available) {
"attempt to make remote request from mod_rewrite "
"without proxy enabled: %s", r->filename);
return HTTP_FORBIDDEN;
}
/* make sure the QUERY_STRING and
* PATH_INFO parts get incorporated
*/
}
r->uri == r->unparsed_uri) {
/* see proxy_http:proxy_http_canon() */
}
/* now make sure the request gets handled by the proxy handler */
r->proxyreq = PROXYREQ_REVERSE;
r->handler = "proxy-server";
r->filename);
return OK;
}
int n;
/* it was finally rewritten to a remote URL */
if (rulestatus != ACTION_NOESCAPE) {
}
/* append the QUERY_STRING part */
if (r->args) {
? r->args
NULL);
}
/* determine HTTP redirect response code */
if (ap_is_HTTP_REDIRECT(r->status)) {
n = r->status;
}
else {
}
/* now do the redirection */
return n;
}
/* This URLs is forced to be forbidden for the requester */
return HTTP_FORBIDDEN;
}
/* This URLs is forced to be gone */
return HTTP_GONE;
}
/*
* Hack because of underpowered API: passing the current
* rewritten filename through to other URL-to-filename handlers
* just as it were the requested URL. This is to enable
* post-processing by mod_alias, etc. which always act on
* r->uri! The difference here is: We do not try to
* add the document root
*/
return DECLINED;
}
else {
/* it was finally rewritten to a local path */
/* expand "/~user" prefix */
#if APR_HAS_USER
#endif
/* the filename must be either an absolute local path or an
* absolute local URL.
*/
if ( *r->filename != '/'
return HTTP_BAD_REQUEST;
}
/* if there is no valid prefix, we call
* the translator from the core and
* prefix the filename with document_root
*
* NOTICE:
* We cannot leave out the prefix_stat because
* - when we always prefix with document_root
* then no absolute path can be created, e.g. via
* emulating a ScriptAlias directive, etc.
* - when we always NOT prefix with document_root
* then the files under document_root have to
* be references directly and document_root
* gets never used and will be a dummy parameter -
* this is also bad
*
* BUT:
* Under real Unix systems this is no problem,
* because we only do stat() on the first directory
* and this gets cached by the kernel for along time!
*/
int res;
res = ap_core_translate(r);
"FAILED", r->filename);
return res;
}
r->filename);
}
return OK;
}
}
else {
return DECLINED;
}
}
/*
* Fixup hook
* [RewriteRules in directory context]
*/
static int hook_fixup(request_rec *r)
{
char *cp;
char *cp2;
const char *ccp;
apr_size_t l;
int rulestatus;
int n;
char *ofilename;
/* if there is no per-dir config we return immediately */
return DECLINED;
}
/* we shouldn't do anything in subrequests */
return DECLINED;
}
/* if there are no real (i.e. no RewriteRule directives!)
per-dir config of us, we return also immediately */
return DECLINED;
}
/*
* .htaccess file is called before really entering the directory, i.e.:
* URL: http://localhost/foo and .htaccess is located in foo directory
* Ignore such attempts, since they may lead to undefined behaviour.
*/
return DECLINED;
}
/*
* only do something under runtime if the engine is really enabled,
* for this directory, else return immediately!
*/
return DECLINED;
}
/*
* Do the Options check after engine check, so
* the user is able to explicitely turn RewriteEngine Off.
*/
/* FollowSymLinks is mandatory! */
"Options FollowSymLinks or SymLinksIfOwnerMatch is off "
"which implies that RewriteRule directive is forbidden: "
"%s", r->filename);
return HTTP_FORBIDDEN;
}
/*
* remember the current filename before rewriting for later check
* to prevent deadlooping because of internal redirects
*/
/*
* now apply the rules ...
*/
if (rulestatus) {
unsigned skip;
/* it should go on as an internal proxy request */
/* make sure the QUERY_STRING and
* PATH_INFO parts get incorporated
* (r->path_info was already appended by the
* rewriting engine because of the per-dir context!)
*/
}
/* now make sure the request gets handled by the proxy handler */
r->proxyreq = PROXYREQ_REVERSE;
r->handler = "proxy-server";
return OK;
}
/* it was finally rewritten to a remote URL */
/* because we are in a per-dir context
* first try to replace the directory with its base-URL
* if there is a base-URL available
*/
/* skip 'scheme://' */
rewritelog(r, 2,
"[per-dir %s] trying to replace "
"prefix %s with %s",
/* I think, that hack needs an explanation:
* well, here is it:
* mod_rewrite was written for unix systems, were
* absolute file-system paths start with a slash.
* URL-paths _also_ start with slashes, so they
* can be easily compared with system paths.
*
* the following assumes, that the actual url-path
* may be prefixed by the current directory path and
* tries to replace the system path with the RewriteBase
* URL.
* That assumption is true if we use a RewriteRule like
*
* RewriteRule ^foo bar [R]
*
* (see apply_rewrite_rule function)
* However on systems that don't have a / as system
* root this will never match, so we skip the / after the
* hostname and compare/substitute only the stuff after it.
*
* (note that cp was already increased to the right value)
*/
*cp = '\0';
}
}
}
/* now prepare the redirect... */
if (rulestatus != ACTION_NOESCAPE) {
}
/* append the QUERY_STRING part */
if (r->args) {
? r->args
NULL);
}
/* determine HTTP redirect response code */
if (ap_is_HTTP_REDIRECT(r->status)) {
n = r->status;
}
else {
}
/* now do the redirection */
return n;
}
/* This URL is forced to be forbidden for the requester */
return HTTP_FORBIDDEN;
}
/* This URL is forced to be gone */
return HTTP_GONE;
}
else {
/* it was finally rewritten to a local path */
/* if someone used the PASSTHROUGH flag in per-dir
* context we just ignore it. It is only useful
* in per-server context
*/
}
/* the filename must be either an absolute local path or an
* absolute local URL.
*/
if ( *r->filename != '/'
return HTTP_BAD_REQUEST;
}
/* Check for deadlooping:
* At this point we KNOW that at least one rewriting
* rule was applied, but when the resulting URL is
* the same as the initial URL, we are not allowed to
* use the following internal redirection stuff because
* this would lead to a deadloop.
*/
"URL: %s [IGNORING REWRITE]",
return OK;
}
/* if there is a valid base-URL then substitute
* the per-dir prefix with this base-URL if the
* current filename still is inside this per-dir
* context. If not then treat the result as a
* plain URL
*/
rewritelog(r, 2,
"[per-dir %s] trying to replace prefix %s with %s",
}
else {
/* if no explicit base-URL exists we assume
* that the directory prefix is also a valid URL
* for this webserver and only try to remove the
* document_root if it is prefix
*/
/* strip trailing slash */
--l;
}
r->filename[l] == '/') {
rewritelog(r, 2,
"[per-dir %s] strip document_root "
"prefix: %s -> %s",
r->filename+l);
}
}
}
/* now initiate the internal redirect */
r->handler = "redirect-handler";
return OK;
}
}
else {
return DECLINED;
}
}
/*
* MIME-type hook
* [T=...] in server-context
*/
static int hook_mimetype(request_rec *r)
{
const char *t;
/* now check if we have to force a MIME-type */
if (t == NULL) {
return DECLINED;
}
else {
r->filename, t);
ap_set_content_type(r, t);
return OK;
}
}
/* check whether redirect limit is reached */
static int is_redirect_limit_exceeded(request_rec *r)
{
request_rec *top = r;
/* we store it in the top request */
}
}
/* fetch our config */
/* no config there? create one. */
if (!reqc) {
/* associate it with this request */
}
/* allow to change the limit during redirects. */
/* 0 == unset; take server conf ... */
if (dconf->redirect_limit) {
}
"mod_rewrite's internal redirect status: %d/%d.",
/* and now give the caller a hint */
}
/*
* "content" handler for internal redirects
*/
static int handler_redirect(request_rec *r)
{
return DECLINED;
}
/* just make sure that we are really meant! */
return DECLINED;
}
if (is_redirect_limit_exceeded(r)) {
"mod_rewrite: maximum number of internal redirects "
"reached. Assuming configuration error. Use "
"'RewriteOptions MaxRedirects' to increase the limit "
"if neccessary.");
return HTTP_INTERNAL_SERVER_ERROR;
}
/* now do the internal redirect */
/* and return gracefully */
return OK;
}
/*
* +-------------------------------------------------------+
* | |
* | Module paraphernalia
* | |
* +-------------------------------------------------------+
*/
static const command_rec command_table[] = {
"On or Off to enable or disable (default) the whole "
"rewriting engine"),
"List of option strings to set"),
"the base URL of the per-directory context"),
"an input string and a to be applied regexp-pattern"),
"an URL-applied regexp-pattern and a substitution URL"),
"a mapname and a filename"),
"the filename of a lockfile used for inter-process "
"synchronization"),
"the filename of the rewriting logfile"),
"the level of the rewriting logfile verbosity "
"(0=none, 1=std, .., 9=max)"),
{ NULL }
};
{
}
static void register_hooks(apr_pool_t *p)
{
/* fixup after mod_proxy, so that the proxied url will not
* escaped accidentally by mod_proxy's fixup.
*/
* overridden by AddType definitions.
*/
}
/* the main config structure */
config_perdir_create, /* create per-dir config structures */
config_perdir_merge, /* merge per-dir config structures */
config_server_create, /* create per-server config structures */
config_server_merge, /* merge per-server config structures */
command_table, /* table of config file commands */
register_hooks /* register hooks */
};
/*EOF*/