mod_rewrite.c revision fbb0028b28e73d0a78b21a7e8f0b1d75f349274c
60a4b2c422dcbb08a554fb193105c08da592718bpoirier/* ====================================================================
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * The Apache Software License, Version 1.1
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * Copyright (c) 2000 The Apache Software Foundation. All rights
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * reserved.
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * Redistribution and use in source and binary forms, with or without
96ad5d81ee4a2cc66a4ae19893efc8aa6d06fae7jailletc * modification, are permitted provided that the following conditions
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * are met:
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
d29d9ab4614ff992b0e8de6e2b88d52b6f1f153erbowen * 1. Redistributions of source code must retain the above copyright
2e545ce2450a9953665f701bb05350f0d3f26275nd * notice, this list of conditions and the following disclaimer.
d29d9ab4614ff992b0e8de6e2b88d52b6f1f153erbowen *
d29d9ab4614ff992b0e8de6e2b88d52b6f1f153erbowen * 2. Redistributions in binary form must reproduce the above copyright
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * notice, this list of conditions and the following disclaimer in
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * the documentation and/or other materials provided with the
af33a4994ae2ff15bc67d19ff1a7feb906745bf8rbowen * distribution.
3f08db06526d6901aa08c110b5bc7dde6bc39905nd *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * 3. The end-user documentation included with the redistribution,
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * if any, must include the following acknowledgment:
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * "This product includes software developed by the
3f08db06526d6901aa08c110b5bc7dde6bc39905nd * Apache Software Foundation (http://www.apache.org/)."
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * Alternately, this acknowledgment may appear in the software itself,
f086b4b402fa9a2fefc7dda85de2a3cc1cd0a654rjung * if and wherever such third-party acknowledgments normally appear.
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * 4. The names "Apache" and "Apache Software Foundation" must
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * not be used to endorse or promote products derived from this
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * software without prior written permission. For written
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * permission, please contact apache@apache.org.
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick *
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar * 5. Products derived from this software may not be called "Apache",
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * nor may "Apache" appear in their name, without prior written
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * permission of the Apache Software Foundation.
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick *
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * SUCH DAMAGE.
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf * ====================================================================
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * This software consists of voluntary contributions made by many
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * individuals on behalf of the Apache Software Foundation. For more
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * information on the Apache Software Foundation, please see
30471a4650391f57975f60bbb6e4a90be7b284bfhumbedooh * <http://www.apache.org/>.
60a4b2c422dcbb08a554fb193105c08da592718bpoirier *
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * Portions of this software are based upon public domain software
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * originally written at the National Center for Supercomputing Applications,
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * University of Illinois, Urbana-Champaign.
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf */
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
60a4b2c422dcbb08a554fb193105c08da592718bpoirier/* _ _ _
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** _ __ ___ ___ __| | _ __ _____ ___ __(_) |_ ___
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** | '_ ` _ \ / _ \ / _` | | '__/ _ \ \ /\ / / '__| | __/ _ \
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** | | | | | | (_) | (_| | | | | __/\ V V /| | | | || __/
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** |_| |_| |_|\___/ \__,_|___|_| \___| \_/\_/ |_| |_|\__\___|
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** |_____|
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** URL Rewriting Module
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** This module uses a rule-based rewriting engine (based on a
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** regular-expression parser) to rewrite requested URLs on the fly.
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf**
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** It supports an unlimited number of additional rule conditions (which can
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** operate on a lot of variables, even on HTTP headers) for granular
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** matching and even external database lookups (either via plain text
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** tables, DBM hash files or even external processes) for advanced URL
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** substitution.
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf**
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** It operates on the full URLs (including the PATH_INFO part) both in
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** per-server context (httpd.conf) and per-dir context (.htaccess) and even
a04dcd330b05345681a4057702b2d43b2042e21dtrawick** can generate QUERY_STRING parts on result. The rewriting result finally
a04dcd330b05345681a4057702b2d43b2042e21dtrawick** can lead to internal subprocessing, external request redirection or even
a04dcd330b05345681a4057702b2d43b2042e21dtrawick** to internal proxy throughput.
a04dcd330b05345681a4057702b2d43b2042e21dtrawick**
f8b7daeb0e3f0ac4544fcc665de10c6b69a1ce0dsf** This module was originally written in April 1996 and
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** gifted exclusively to the The Apache Software Foundation in July 1997 by
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf**
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** Ralf S. Engelschall
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** rse@engelschall.com
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** www.engelschall.com
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick*/
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#include "apr.h"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#include "apr_strings.h"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#include "apr_user.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "apr_lib.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "apr_signal.h"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#define APR_WANT_STRFUNC
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#define APR_WANT_IOVEC
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "apr_want.h"
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#if APR_HAVE_UNISTD_H
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#include <unistd.h>
bed3c2e56e8f3328e780200466b9d009093db468sf#endif
bed3c2e56e8f3328e780200466b9d009093db468sf#if APR_HAVE_SYS_TYPES_H
bed3c2e56e8f3328e780200466b9d009093db468sf#include <sys/types.h>
bed3c2e56e8f3328e780200466b9d009093db468sf#endif
bed3c2e56e8f3328e780200466b9d009093db468sf
bed3c2e56e8f3328e780200466b9d009093db468sf#include "ap_config.h"
bed3c2e56e8f3328e780200466b9d009093db468sf#include "httpd.h"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf#include "http_config.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "http_request.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "http_core.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#include "http_log.h"
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick#include "http_protocol.h"
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick#include "mod_rewrite.h"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirier#if !defined(OS2) && !defined(WIN32) && !defined(BEOS)
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick#include "unixd.h"
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick#endif
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar/*
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar** +-------------------------------------------------------+
bcb2c4ef861e8f8260284631b6753e1088643c8asf** | |
bcb2c4ef861e8f8260284631b6753e1088643c8asf** | static module configuration
bcb2c4ef861e8f8260284631b6753e1088643c8asf** | |
bcb2c4ef861e8f8260284631b6753e1088643c8asf** +-------------------------------------------------------+
bcb2c4ef861e8f8260284631b6753e1088643c8asf*/
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf/*
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** Our interface to the Apache server kernel:
60a4b2c422dcbb08a554fb193105c08da592718bpoirier**
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** o Runtime logic of a request is as following:
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar** while(request or subrequest)
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** foreach(stage #0...#9)
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** foreach(module) (**)
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** try to run hook
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** o the order of modules at (**) is the inverted order as
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** given in the "Configuration" file, i.e. the last module
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** specified is the first one called for each hook!
57b31f30545668d28e895efe7f5c0eb15d37a03figalic** The core module is always the last!
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
d474d8ef01ec5c2a09341cd148851ed383c3287crbowen** o there are two different types of result checking and
d474d8ef01ec5c2a09341cd148851ed383c3287crbowen** continue processing:
d474d8ef01ec5c2a09341cd148851ed383c3287crbowen** for hook #0,#1,#4,#5,#6,#8:
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** hook run loop stops on first modules which gives
0236ede61169f34359c234625a1d792b97d7db12nd** back a result != DECLINED, i.e. it usually returns OK
0236ede61169f34359c234625a1d792b97d7db12nd** which says "OK, module has handled this _stage_" and for #1
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** this have not to mean "Ok, the filename is now valid".
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** for hook #2,#3,#7,#9:
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** all hooks are run, independend of result
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf**
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** o at the last stage, the core module always
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** - says "HTTP_BAD_REQUEST" if r->filename does not begin with "/"
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** - prefix URL with document_root or replaced server_root
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** with document_root and sets r->filename
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf** - always return a "OK" independed if the file really exists
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** or not!
60a4b2c422dcbb08a554fb193105c08da592718bpoirier*/
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar /* The section for the Configure script:
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * XXX: this needs updating for apache-2.0 configuration method
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * MODULE-DEFINITION-START
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick * Name: rewrite_module
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar * ConfigStart
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick . ./helpers/find-dbm-lib
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick if [ "x$found_dbm" = "x1" ]; then
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick echo " enabling DBM support for mod_rewrite"
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick else
60a4b2c422dcbb08a554fb193105c08da592718bpoirier echo " disabling DBM support for mod_rewrite"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf echo " (perhaps you need to add -ldbm, -lndbm or -lgdbm to EXTRA_LIBS)"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf CFLAGS="$CFLAGS -DNO_DBM_REWRITEMAP"
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf fi
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * ConfigEnd
60a4b2c422dcbb08a554fb193105c08da592718bpoirier * MODULE-DEFINITION-END
60a4b2c422dcbb08a554fb193105c08da592718bpoirier */
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick /* the module (predeclaration) */
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawickmodule AP_MODULE_DECLARE_DATA rewrite_module;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
60a4b2c422dcbb08a554fb193105c08da592718bpoirier /* the cache */
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawickstatic cache *cachep;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
60a4b2c422dcbb08a554fb193105c08da592718bpoirier /* whether proxy module is available or not */
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sfstatic int proxy_available;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sfstatic const char *lockname;
60a4b2c422dcbb08a554fb193105c08da592718bpoirierstatic apr_lock_t *rewrite_mapr_lock_aquire = NULL;
60a4b2c422dcbb08a554fb193105c08da592718bpoirierstatic apr_lock_t *rewrite_log_lock = NULL;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick/*
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** +-------------------------------------------------------+
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar** | |
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** | configuration directive handling
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar** | |
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick** +-------------------------------------------------------+
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar*/
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar/*
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar** per-server configuration structure handling
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar**
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick*/
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirierstatic void *config_server_create(apr_pool_t *p, server_rec *s)
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick{
60a4b2c422dcbb08a554fb193105c08da592718bpoirier rewrite_server_conf *a;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a = (rewrite_server_conf *)apr_pcalloc(p, sizeof(rewrite_server_conf));
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->state = ENGINE_DISABLED;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->options = OPTION_NONE;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewritelogfile = NULL;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewritelogfp = NULL;
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar a->rewriteloglevel = 0;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a->rewritemaps = apr_array_make(p, 2, sizeof(rewritemap_entry));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->rewriteconds = apr_array_make(p, 2, sizeof(rewritecond_entry));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->rewriterules = apr_array_make(p, 2, sizeof(rewriterule_entry));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->server = s;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirier return (void *)a;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf}
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
b6529ec5115d80b7dedcfd0935746015b2096084minfrinstatic void *config_server_merge(apr_pool_t *p, void *basev, void *overridesv)
b6529ec5115d80b7dedcfd0935746015b2096084minfrin{
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar rewrite_server_conf *a, *base, *overrides;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a = (rewrite_server_conf *)apr_pcalloc(p, sizeof(rewrite_server_conf));
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick base = (rewrite_server_conf *)basev;
b6529ec5115d80b7dedcfd0935746015b2096084minfrin overrides = (rewrite_server_conf *)overridesv;
b6529ec5115d80b7dedcfd0935746015b2096084minfrin
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->state = overrides->state;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->options = overrides->options;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->server = overrides->server;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf if (a->options & OPTION_INHERIT) {
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf /*
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin * local directives override
b6529ec5115d80b7dedcfd0935746015b2096084minfrin * and anything else is inherited
b6529ec5115d80b7dedcfd0935746015b2096084minfrin */
b6529ec5115d80b7dedcfd0935746015b2096084minfrin a->rewriteloglevel = overrides->rewriteloglevel != 0
b6529ec5115d80b7dedcfd0935746015b2096084minfrin ? overrides->rewriteloglevel
b6529ec5115d80b7dedcfd0935746015b2096084minfrin : base->rewriteloglevel;
b6529ec5115d80b7dedcfd0935746015b2096084minfrin a->rewritelogfile = overrides->rewritelogfile != NULL
b6529ec5115d80b7dedcfd0935746015b2096084minfrin ? overrides->rewritelogfile
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin : base->rewritelogfile;
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin a->rewritelogfp = overrides->rewritelogfp != NULL
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin ? overrides->rewritelogfp
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin : base->rewritelogfp;
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin a->rewritemaps = apr_array_append(p, overrides->rewritemaps,
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin base->rewritemaps);
78f97ce162b66a0dbfd7af4dcd9984f162569b04minfrin a->rewriteconds = apr_array_append(p, overrides->rewriteconds,
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf base->rewriteconds);
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewriterules = apr_array_append(p, overrides->rewriterules,
60a4b2c422dcbb08a554fb193105c08da592718bpoirier base->rewriterules);
60a4b2c422dcbb08a554fb193105c08da592718bpoirier }
60a4b2c422dcbb08a554fb193105c08da592718bpoirier else {
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf /*
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * local directives override
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf * and anything else gets defaults
60a4b2c422dcbb08a554fb193105c08da592718bpoirier */
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewriteloglevel = overrides->rewriteloglevel;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a->rewritelogfile = overrides->rewritelogfile;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a->rewritelogfp = overrides->rewritelogfp;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewritemaps = overrides->rewritemaps;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->rewriteconds = overrides->rewriteconds;
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar a->rewriterules = overrides->rewriterules;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick }
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar return (void *)a;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick}
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf/*
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf**
60a4b2c422dcbb08a554fb193105c08da592718bpoirier** per-directory configuration structure handling
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick**
60a4b2c422dcbb08a554fb193105c08da592718bpoirier*/
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sfstatic void *config_perdir_create(apr_pool_t *p, char *path)
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf{
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf rewrite_perdir_conf *a;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a = (rewrite_perdir_conf *)apr_pcalloc(p, sizeof(rewrite_perdir_conf));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->state = ENGINE_DISABLED;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->options = OPTION_NONE;
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->baseurl = NULL;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a->rewriteconds = apr_array_make(p, 2, sizeof(rewritecond_entry));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->rewriterules = apr_array_make(p, 2, sizeof(rewriterule_entry));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf if (path == NULL) {
60a4b2c422dcbb08a554fb193105c08da592718bpoirier a->directory = NULL;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick }
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick else {
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick /* make sure it has a trailing slash */
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf if (path[strlen(path)-1] == '/') {
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->directory = apr_pstrdup(p, path);
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf }
60a4b2c422dcbb08a554fb193105c08da592718bpoirier else {
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick a->directory = apr_pstrcat(p, path, "/", NULL);
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf }
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf }
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
60a4b2c422dcbb08a554fb193105c08da592718bpoirier return (void *)a;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick}
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sfstatic void *config_perdir_merge(apr_pool_t *p, void *basev, void *overridesv)
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf{
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf rewrite_perdir_conf *a, *base, *overrides;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a = (rewrite_perdir_conf *)apr_pcalloc(p,
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf sizeof(rewrite_perdir_conf));
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf base = (rewrite_perdir_conf *)basev;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf overrides = (rewrite_perdir_conf *)overridesv;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->state = overrides->state;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->options = overrides->options;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->directory = overrides->directory;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->baseurl = overrides->baseurl;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf if (a->options & OPTION_INHERIT) {
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf a->rewriteconds = apr_array_append(p, overrides->rewriteconds,
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf base->rewriteconds);
50c04f297d76a57ead2fa6b73845f7563b1fc788sf a->rewriterules = apr_array_append(p, overrides->rewriterules,
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf base->rewriterules);
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf }
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen else {
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen a->rewriteconds = overrides->rewriteconds;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen a->rewriterules = overrides->rewriterules;
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf }
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick return (void *)a;
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick}
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick/*
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick**
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick** the configuration commands
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick**
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick*/
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawickstatic const char *cmd_rewriteengine(cmd_parms *cmd,
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick void *in_dconf, int flag)
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick{
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf rewrite_perdir_conf *dconf = in_dconf;
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick rewrite_server_conf *sconf;
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick sconf =
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick (rewrite_server_conf *)ap_get_module_config(cmd->server->module_config,
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick &rewrite_module);
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick if (cmd->path == NULL) { /* is server command */
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick sconf->state = (flag ? ENGINE_ENABLED : ENGINE_DISABLED);
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick }
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick else /* is per-directory command */ {
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick dconf->state = (flag ? ENGINE_ENABLED : ENGINE_DISABLED);
33e4ab6c78a779cb3f72f7afed0fef9068f1b822trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
5effc8b39fae5cd169d17f342bfc265705840014rbowen return NULL;
5effc8b39fae5cd169d17f342bfc265705840014rbowen}
5effc8b39fae5cd169d17f342bfc265705840014rbowen
5effc8b39fae5cd169d17f342bfc265705840014rbowenstatic const char *cmd_rewriteoptions(cmd_parms *cmd,
5effc8b39fae5cd169d17f342bfc265705840014rbowen void *in_dconf, const char *option)
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf{
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick rewrite_perdir_conf *dconf = in_dconf;
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick rewrite_server_conf *sconf;
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick const char *err;
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick sconf = (rewrite_server_conf *)
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick ap_get_module_config(cmd->server->module_config, &rewrite_module);
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick if (cmd->path == NULL) { /* is server command */
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick err = cmd_rewriteoptions_setoption(cmd->pool,
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf &(sconf->options), option);
68e7d4f7d80c3e5ed94185cb28100bc786e4304atrawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else { /* is per-directory command */
2509f1cd3be884abbe4852e15b8da00bebaad5b1poirier err = cmd_rewriteoptions_setoption(cmd->pool,
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick &(dconf->options), option);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return err;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick}
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawickstatic const char *cmd_rewriteoptions_setoption(apr_pool_t *p, int *options,
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick const char *name)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (strcasecmp(name, "inherit") == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick *options |= OPTION_INHERIT;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2509f1cd3be884abbe4852e15b8da00bebaad5b1poirier else {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return apr_pstrcat(p, "RewriteOptions: unknown option '",
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick name, "'", NULL);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick}
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawickstatic const char *cmd_rewritelog(cmd_parms *cmd, void *dconf, const char *a1)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_server_conf *sconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf = (rewrite_server_conf *)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick ap_get_module_config(cmd->server->module_config, &rewrite_module);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf->rewritelogfile = a1;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick}
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawickstatic const char *cmd_rewriteloglevel(cmd_parms *cmd, void *dconf, const char *a1)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_server_conf *sconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf = (rewrite_server_conf *)
9a58dc6a2b26ec128b1270cf48810e705f1a90dbsf ap_get_module_config(cmd->server->module_config, &rewrite_module);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf->rewriteloglevel = atoi(a1);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick}
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawickstatic const char *cmd_rewritemap(cmd_parms *cmd, void *dconf, const char *a1,
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick const char *a2)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_server_conf *sconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewritemap_entry *newmap;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick apr_finfo_t st;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf = (rewrite_server_conf *)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick ap_get_module_config(cmd->server->module_config, &rewrite_module);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap = apr_array_push(sconf->rewritemaps);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->name = a1;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->func = NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (strncmp(a2, "txt:", 4) == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->type = MAPTYPE_TXT;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newmap->datafile = a2+4;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newmap->checkfile = a2+4;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick }
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick else if (strncmp(a2, "rnd:", 4) == 0) {
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newmap->type = MAPTYPE_RND;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newmap->datafile = a2+4;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newmap->checkfile = a2+4;
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strncmp(a2, "dbm:", 4) == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick#ifndef NO_DBM_REWRITEMAP
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->type = MAPTYPE_DBM;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->datafile = a2+4;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->checkfile = apr_pstrcat(cmd->pool, a2+4, NDBM_FILE_SUFFIX, NULL);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick#else
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return apr_pstrdup(cmd->pool, "RewriteMap: cannot use NDBM mapfile, "
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick "because no NDBM support is compiled in");
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick#endif
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strncmp(a2, "prg:", 4) == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->type = MAPTYPE_PRG;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->datafile = a2+4;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->checkfile = a2+4;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strncmp(a2, "int:", 4) == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->type = MAPTYPE_INT;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->datafile = NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->checkfile = NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (strcmp(a2+4, "tolower") == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->func = rewrite_mapfunc_tolower;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strcmp(a2+4, "toupper") == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->func = rewrite_mapfunc_toupper;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strcmp(a2+4, "escape") == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->func = rewrite_mapfunc_escape;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (strcmp(a2+4, "unescape") == 0) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newmap->func = rewrite_mapfunc_unescape;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else if (sconf->state == ENGINE_ENABLED) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return apr_pstrcat(cmd->pool, "RewriteMap: internal map not found:",
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick a2+4, NULL);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick else {
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen newmap->type = MAPTYPE_TXT;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen newmap->datafile = a2;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen newmap->checkfile = a2;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen }
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen newmap->fpin = NULL;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen newmap->fpout = NULL;
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen if (newmap->checkfile && (sconf->state == ENGINE_ENABLED)
8cef90cad1b259d4a94f6095aa30439c60549a5drbowen && (apr_stat(&st, newmap->checkfile, APR_FINFO_MIN,
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick cmd->pool) != APR_SUCCESS)) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return apr_pstrcat(cmd->pool,
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrin "RewriteMap: map file or program not found:",
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar newmap->checkfile, NULL);
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick }
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick return NULL;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick}
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawickstatic const char *cmd_rewritelock(cmd_parms *cmd, void *dconf, const char *a1)
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrin{
9cb641b95a976f28161ff3eb5dc71105a8f75ddeminfrin const char *error;
9cb641b95a976f28161ff3eb5dc71105a8f75ddeminfrin
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrin if ((error = ap_check_cmd_context(cmd, GLOBAL_ONLY)) != NULL)
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick return error;
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
c8ea2fd531ec56b7969ee48fc05655b503fa57a3minfrin lockname = a1;
c8ea2fd531ec56b7969ee48fc05655b503fa57a3minfrin
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrin return NULL;
a99c5d4cc3cab6a62b04d52000dbc22ce1fa2d94coar}
b97ba9a0b0f1bdad0bd7b4c5cb32319c2976b0aftrawick
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrinstatic const char *cmd_rewritebase(cmd_parms *cmd, void *in_dconf,
46fc29754beed5aa71b9dd9a69a85cc840b307f8minfrin const char *a1)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_perdir_conf *dconf = in_dconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (cmd->path == NULL || dconf == NULL) {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return "RewriteBase: only valid in per-directory config files";
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (a1[0] == '\0') {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return "RewriteBase: empty URL not allowed";
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (a1[0] != '/') {
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return "RewriteBase: argument is not a valid URL";
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick dconf->baseurl = a1;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick return NULL;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick}
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawickstatic const char *cmd_rewritecond(cmd_parms *cmd, void *in_dconf,
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick const char *in_str)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick{
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_perdir_conf *dconf = in_dconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick char *str = apr_pstrdup(cmd->pool, in_str);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewrite_server_conf *sconf;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick rewritecond_entry *newcond;
2509f1cd3be884abbe4852e15b8da00bebaad5b1poirier regex_t *regexp;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick char *a1;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick char *a2;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick char *a3;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick char *cp;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick const char *err;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick int rc;
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick sconf = (rewrite_server_conf *)
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick ap_get_module_config(cmd->server->module_config, &rewrite_module);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick /* make a new entry in the internal temporary rewrite rule list */
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick if (cmd->path == NULL) { /* is server command */
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick newcond = apr_array_push(sconf->rewriteconds);
2d5f033e0b60accdc5c92470a71c6e9cd6c90803trawick }
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick else { /* is per-directory command */
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick newcond = apr_array_push(dconf->rewriteconds);
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick }
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick /* parse the argument line ourself */
1bdd1f8b0e04d77152f52f7cff0480613c6ffd96trawick if (parseargline(str, &a1, &a2, &a3)) {
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick return apr_pstrcat(cmd->pool, "RewriteCond: bad argument line '", str,
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick "'", NULL);
4e3e4fcc70d6f02d1b8bbda4f7155f9b103773a6trawick }
2509f1cd3be884abbe4852e15b8da00bebaad5b1poirier
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf /* arg1: the input string */
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf newcond->input = apr_pstrdup(cmd->pool, a1);
5cd08ee4a8f5a665e656f70048a1268a02bc0e73sf
60a4b2c422dcbb08a554fb193105c08da592718bpoirier /* arg3: optional flags field
f086b4b402fa9a2fefc7dda85de2a3cc1cd0a654rjung (this have to be first parsed, because we need to
727872d18412fc021f03969b8641810d8896820bhumbedooh know if the regex should be compiled with ICASE!) */
0d0ba3a410038e179b695446bb149cce6264e0abnd newcond->flags = CONDFLAG_NONE;
727872d18412fc021f03969b8641810d8896820bhumbedooh if (a3 != NULL) {
cc7e1025de9ac63bd4db6fe7f71c158b2cf09fe4humbedooh if ((err = cmd_rewritecond_parseflagfield(cmd->pool, newcond,
0d0ba3a410038e179b695446bb149cce6264e0abnd a3)) != NULL) {
cc7e1025de9ac63bd4db6fe7f71c158b2cf09fe4humbedooh return err;
727872d18412fc021f03969b8641810d8896820bhumbedooh }
0d0ba3a410038e179b695446bb149cce6264e0abnd }
0d0ba3a410038e179b695446bb149cce6264e0abnd
0d0ba3a410038e179b695446bb149cce6264e0abnd /* arg2: the pattern
ac082aefa89416cbdc9a1836eaf3bed9698201c8humbedooh try to compile the regexp to test if is ok */
0d0ba3a410038e179b695446bb149cce6264e0abnd cp = a2;
0d0ba3a410038e179b695446bb149cce6264e0abnd if (cp[0] == '!') {
0d0ba3a410038e179b695446bb149cce6264e0abnd newcond->flags |= CONDFLAG_NOTMATCH;
727872d18412fc021f03969b8641810d8896820bhumbedooh cp++;
0d0ba3a410038e179b695446bb149cce6264e0abnd }
0d0ba3a410038e179b695446bb149cce6264e0abnd
30471a4650391f57975f60bbb6e4a90be7b284bfhumbedooh /* now be careful: Under the POSIX regex library
205f749042ed530040a4f0080dbcb47ceae8a374rjung we can compile the pattern for case insensitive matching,
af33a4994ae2ff15bc67d19ff1a7feb906745bf8rbowen under the old V8 library we have to do it self via a hack */
0d0ba3a410038e179b695446bb149cce6264e0abnd if (newcond->flags & CONDFLAG_NOCASE) {
7fec19672a491661b2fe4b29f685bc7f4efa64d4nd rc = ((regexp = ap_pregcomp(cmd->pool, cp, REG_EXTENDED|REG_ICASE))
7fec19672a491661b2fe4b29f685bc7f4efa64d4nd == NULL);
7fec19672a491661b2fe4b29f685bc7f4efa64d4nd }
60a4b2c422dcbb08a554fb193105c08da592718bpoirier else {
rc = ((regexp = ap_pregcomp(cmd->pool, cp, REG_EXTENDED)) == NULL);
}
if (rc) {
return apr_pstrcat(cmd->pool,
"RewriteCond: cannot compile regular expression '",
a2, "'", NULL);
}
newcond->pattern = apr_pstrdup(cmd->pool, cp);
newcond->regexp = regexp;
return NULL;
}
static const char *cmd_rewritecond_parseflagfield(apr_pool_t *p,
rewritecond_entry *cfg,
char *str)
{
char *cp;
char *cp1;
char *cp2;
char *cp3;
char *key;
char *val;
const char *err;
if (str[0] != '[' || str[strlen(str)-1] != ']') {
return "RewriteCond: bad flag delimiters";
}
cp = str+1;
str[strlen(str)-1] = ','; /* for simpler parsing */
for ( ; *cp != '\0'; ) {
/* skip whitespaces */
for ( ; (*cp == ' ' || *cp == '\t') && *cp != '\0'; cp++)
;
if (*cp == '\0') {
break;
}
cp1 = cp;
if ((cp2 = strchr(cp, ',')) != NULL) {
cp = cp2+1;
for ( ; (*(cp2-1) == ' ' || *(cp2-1) == '\t'); cp2--)
;
*cp2 = '\0';
if ((cp3 = strchr(cp1, '=')) != NULL) {
*cp3 = '\0';
key = cp1;
val = cp3+1;
}
else {
key = cp1;
val = "";
}
if ((err = cmd_rewritecond_setflag(p, cfg, key, val)) != NULL) {
return err;
}
}
else {
break;
}
}
return NULL;
}
static const char *cmd_rewritecond_setflag(apr_pool_t *p, rewritecond_entry *cfg,
char *key, char *val)
{
if ( strcasecmp(key, "nocase") == 0
|| strcasecmp(key, "NC") == 0 ) {
cfg->flags |= CONDFLAG_NOCASE;
}
else if ( strcasecmp(key, "ornext") == 0
|| strcasecmp(key, "OR") == 0 ) {
cfg->flags |= CONDFLAG_ORNEXT;
}
else {
return apr_pstrcat(p, "RewriteCond: unknown flag '", key, "'", NULL);
}
return NULL;
}
static const char *cmd_rewriterule(cmd_parms *cmd, void *in_dconf,
const char *in_str)
{
rewrite_perdir_conf *dconf = in_dconf;
char *str = apr_pstrdup(cmd->pool, in_str);
rewrite_server_conf *sconf;
rewriterule_entry *newrule;
regex_t *regexp;
char *a1;
char *a2;
char *a3;
char *cp;
const char *err;
int mode;
sconf = (rewrite_server_conf *)
ap_get_module_config(cmd->server->module_config, &rewrite_module);
/* make a new entry in the internal rewrite rule list */
if (cmd->path == NULL) { /* is server command */
newrule = apr_array_push(sconf->rewriterules);
}
else { /* is per-directory command */
newrule = apr_array_push(dconf->rewriterules);
}
/* parse the argument line ourself */
if (parseargline(str, &a1, &a2, &a3)) {
return apr_pstrcat(cmd->pool, "RewriteRule: bad argument line '", str,
"'", NULL);
}
/* arg3: optional flags field */
newrule->forced_mimetype = NULL;
newrule->forced_responsecode = HTTP_MOVED_TEMPORARILY;
newrule->flags = RULEFLAG_NONE;
newrule->env[0] = NULL;
newrule->skip = 0;
if (a3 != NULL) {
if ((err = cmd_rewriterule_parseflagfield(cmd->pool, newrule,
a3)) != NULL) {
return err;
}
}
/* arg1: the pattern
* try to compile the regexp to test if is ok
*/
cp = a1;
if (cp[0] == '!') {
newrule->flags |= RULEFLAG_NOTMATCH;
cp++;
}
mode = REG_EXTENDED;
if (newrule->flags & RULEFLAG_NOCASE) {
mode |= REG_ICASE;
}
if ((regexp = ap_pregcomp(cmd->pool, cp, mode)) == NULL) {
return apr_pstrcat(cmd->pool,
"RewriteRule: cannot compile regular expression '",
a1, "'", NULL);
}
newrule->pattern = apr_pstrdup(cmd->pool, cp);
newrule->regexp = regexp;
/* arg2: the output string
* replace the $<N> by \<n> which is needed by the currently
* used Regular Expression library
*
* TODO: Is this still required for PCRE? If not, does it *work* with PCRE?
*/
newrule->output = apr_pstrdup(cmd->pool, a2);
/* now, if the server or per-dir config holds an
* array of RewriteCond entries, we take it for us
* and clear the array
*/
if (cmd->path == NULL) { /* is server command */
newrule->rewriteconds = sconf->rewriteconds;
sconf->rewriteconds = apr_array_make(cmd->pool, 2,
sizeof(rewritecond_entry));
}
else { /* is per-directory command */
newrule->rewriteconds = dconf->rewriteconds;
dconf->rewriteconds = apr_array_make(cmd->pool, 2,
sizeof(rewritecond_entry));
}
return NULL;
}
static const char *cmd_rewriterule_parseflagfield(apr_pool_t *p,
rewriterule_entry *cfg,
char *str)
{
char *cp;
char *cp1;
char *cp2;
char *cp3;
char *key;
char *val;
const char *err;
if (str[0] != '[' || str[strlen(str)-1] != ']') {
return "RewriteRule: bad flag delimiters";
}
cp = str+1;
str[strlen(str)-1] = ','; /* for simpler parsing */
for ( ; *cp != '\0'; ) {
/* skip whitespaces */
for ( ; (*cp == ' ' || *cp == '\t') && *cp != '\0'; cp++)
;
if (*cp == '\0') {
break;
}
cp1 = cp;
if ((cp2 = strchr(cp, ',')) != NULL) {
cp = cp2+1;
for ( ; (*(cp2-1) == ' ' || *(cp2-1) == '\t'); cp2--)
;
*cp2 = '\0';
if ((cp3 = strchr(cp1, '=')) != NULL) {
*cp3 = '\0';
key = cp1;
val = cp3+1;
}
else {
key = cp1;
val = "";
}
if ((err = cmd_rewriterule_setflag(p, cfg, key, val)) != NULL) {
return err;
}
}
else {
break;
}
}
return NULL;
}
static const char *cmd_rewriterule_setflag(apr_pool_t *p, rewriterule_entry *cfg,
char *key, char *val)
{
int status = 0;
int i;
if ( strcasecmp(key, "redirect") == 0
|| strcasecmp(key, "R") == 0 ) {
cfg->flags |= RULEFLAG_FORCEREDIRECT;
if (strlen(val) > 0) {
if (strcasecmp(val, "permanent") == 0) {
status = HTTP_MOVED_PERMANENTLY;
}
else if (strcasecmp(val, "temp") == 0) {
status = HTTP_MOVED_TEMPORARILY;
}
else if (strcasecmp(val, "seeother") == 0) {
status = HTTP_SEE_OTHER;
}
else if (apr_isdigit(*val)) {
status = atoi(val);
}
if (!ap_is_HTTP_REDIRECT(status)) {
return "RewriteRule: invalid HTTP response code "
"for flag 'R'";
}
cfg->forced_responsecode = status;
}
}
else if ( strcasecmp(key, "last") == 0
|| strcasecmp(key, "L") == 0 ) {
cfg->flags |= RULEFLAG_LASTRULE;
}
else if ( strcasecmp(key, "next") == 0
|| strcasecmp(key, "N") == 0 ) {
cfg->flags |= RULEFLAG_NEWROUND;
}
else if ( strcasecmp(key, "chain") == 0
|| strcasecmp(key, "C") == 0 ) {
cfg->flags |= RULEFLAG_CHAIN;
}
else if ( strcasecmp(key, "type") == 0
|| strcasecmp(key, "T") == 0 ) {
cfg->forced_mimetype = apr_pstrdup(p, val);
ap_str_tolower(cfg->forced_mimetype);
}
else if ( strcasecmp(key, "env") == 0
|| strcasecmp(key, "E") == 0 ) {
for (i = 0; (cfg->env[i] != NULL) && (i < MAX_ENV_FLAGS); i++)
;
if (i < MAX_ENV_FLAGS) {
cfg->env[i] = apr_pstrdup(p, val);
cfg->env[i+1] = NULL;
}
else {
return "RewriteRule: too many environment flags 'E'";
}
}
else if ( strcasecmp(key, "nosubreq") == 0
|| strcasecmp(key, "NS") == 0 ) {
cfg->flags |= RULEFLAG_IGNOREONSUBREQ;
}
else if ( strcasecmp(key, "proxy") == 0
|| strcasecmp(key, "P") == 0 ) {
cfg->flags |= RULEFLAG_PROXY;
}
else if ( strcasecmp(key, "passthrough") == 0
|| strcasecmp(key, "PT") == 0 ) {
cfg->flags |= RULEFLAG_PASSTHROUGH;
}
else if ( strcasecmp(key, "skip") == 0
|| strcasecmp(key, "S") == 0 ) {
cfg->skip = atoi(val);
}
else if ( strcasecmp(key, "forbidden") == 0
|| strcasecmp(key, "F") == 0 ) {
cfg->flags |= RULEFLAG_FORBIDDEN;
}
else if ( strcasecmp(key, "gone") == 0
|| strcasecmp(key, "G") == 0 ) {
cfg->flags |= RULEFLAG_GONE;
}
else if ( strcasecmp(key, "qsappend") == 0
|| strcasecmp(key, "QSA") == 0 ) {
cfg->flags |= RULEFLAG_QSAPPEND;
}
else if ( strcasecmp(key, "nocase") == 0
|| strcasecmp(key, "NC") == 0 ) {
cfg->flags |= RULEFLAG_NOCASE;
}
else {
return apr_pstrcat(p, "RewriteRule: unknown flag '", key, "'", NULL);
}
return NULL;
}
/*
**
** Global Module Initialization
** [called from read_config() after all
** config commands were already called]
**
*/
static void init_module(apr_pool_t *p,
apr_pool_t *plog,
apr_pool_t *ptemp,
server_rec *s)
{
apr_status_t rv;
void *data;
int first_time = 0;
const char *userdata_key = "rewrite_init_module";
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if (!data) {
first_time = 1;
apr_pool_userdata_set((const void *)1, userdata_key,
apr_pool_cleanup_null, s->process->pool);
}
/* check if proxy module is available */
proxy_available = (ap_find_linked_module("mod_proxy.c") != NULL);
/* create the rewriting lockfiles in the parent */
if ((rv = apr_lock_create (&rewrite_log_lock, APR_MUTEX, APR_LOCKALL,
NULL, p)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
"mod_rewrite: could not create rewrite_log_lock");
exit(1);
}
rewritelock_create(s, p);
apr_pool_cleanup_register(p, (void *)s, rewritelock_remove, apr_pool_cleanup_null);
/* step through the servers and
* - open each rewriting logfile
* - open the RewriteMap prg:xxx programs
*/
for (; s; s = s->next) {
open_rewritelog(s, p);
if (!first_time)
run_rewritemap_programs(s, p);
}
}
/*
**
** Per-Child Module Initialization
** [called after a child process is spawned]
**
*/
static void init_child(apr_pool_t *p, server_rec *s)
{
apr_status_t rv;
if (lockname != NULL && *(lockname) != '\0')
{
rv = apr_lock_child_init (&rewrite_mapr_lock_aquire, lockname, p);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s,
"mod_rewrite: could not init rewrite_mapr_lock_aquire "
"in child");
}
}
/* create the lookup cache */
cachep = init_cache(p);
}
/*
** +-------------------------------------------------------+
** | |
** | runtime hooks
** | |
** +-------------------------------------------------------+
*/
/*
**
** URI-to-filename hook
**
** [used for the rewriting engine triggered by
** the per-server 'RewriteRule' directives]
**
*/
static int hook_uri2file(request_rec *r)
{
void *sconf;
rewrite_server_conf *conf;
const char *var;
const char *thisserver;
char *thisport;
const char *thisurl;
char buf[512];
char docroot[512];
char *cp, *cp2;
const char *ccp;
apr_finfo_t finfo;
unsigned int port;
int n;
int l;
/*
* retrieve the config structures
*/
sconf = r->server->module_config;
conf = (rewrite_server_conf *)ap_get_module_config(sconf,
&rewrite_module);
/*
* only do something under runtime if the engine is really enabled,
* else return immediately!
*/
if (conf->state == ENGINE_DISABLED) {
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.
*/
if (conf->server != r->server) {
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
*/
if (r->main == NULL) {
var = apr_pstrcat(r->pool, "REDIRECT_", ENVVAR_SCRIPT_URL, NULL);
var = apr_table_get(r->subprocess_env, var);
if (var == NULL) {
apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, r->uri);
}
else {
apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, var);
}
}
else {
var = apr_table_get(r->main->subprocess_env, ENVVAR_SCRIPT_URL);
apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URL, var);
}
/*
* 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 {
apr_snprintf(buf, sizeof(buf), ":%u", port);
thisport = buf;
}
thisurl = apr_table_get(r->subprocess_env, ENVVAR_SCRIPT_URL);
/* set the variable */
var = apr_pstrcat(r->pool, ap_http_method(r), "://", thisserver, thisport,
thisurl, NULL);
apr_table_setn(r->subprocess_env, ENVVAR_SCRIPT_URI, var);
/* if filename was not initially set,
* we start with the requested URI
*/
if (r->filename == NULL) {
r->filename = apr_pstrdup(r->pool, r->uri);
rewritelog(r, 2, "init rewrite engine with requested uri %s",
r->filename);
}
/*
* now apply the rules ...
*/
if (apply_rewrite_list(r, conf->rewriterules, NULL)) {
if (strlen(r->filename) > 6 &&
strncmp(r->filename, "proxy:", 6) == 0) {
/* 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) {
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, r,
"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
*/
if (r->path_info != NULL) {
r->filename = apr_pstrcat(r->pool, r->filename,
r->path_info, NULL);
}
if (r->args != NULL &&
r->uri == r->unparsed_uri) {
/* see proxy_http:proxy_http_canon() */
r->filename = apr_pstrcat(r->pool, r->filename,
"?", r->args, NULL);
}
/* now make sure the request gets handled by the proxy handler */
r->proxyreq = 1;
r->handler = "proxy-server";
rewritelog(r, 1, "go-ahead with proxy request %s [OK]",
r->filename);
return OK;
}
else if (is_absolute_uri(r->filename)) {
/* it was finally rewritten to a remote URL */
/* skip 'scheme:' */
for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
;
/* skip '://' */
cp += 3;
/* skip host part */
for ( ; *cp != '/' && *cp != '\0'; cp++)
;
if (*cp != '\0') {
rewritelog(r, 1, "escaping %s for redirect", r->filename);
cp2 = ap_escape_uri(r->pool, cp);
*cp = '\0';
r->filename = apr_pstrcat(r->pool, r->filename, cp2, NULL);
}
/* append the QUERY_STRING part */
if (r->args != NULL) {
r->filename = apr_pstrcat(r->pool, r->filename, "?",
ap_escape_uri(r->pool, r->args), NULL);
}
/* determine HTTP redirect response code */
if (ap_is_HTTP_REDIRECT(r->status)) {
n = r->status;
r->status = HTTP_OK; /* make Apache kernel happy */
}
else {
n = HTTP_MOVED_TEMPORARILY;
}
/* now do the redirection */
apr_table_setn(r->headers_out, "Location", r->filename);
rewritelog(r, 1, "redirect to %s [REDIRECT/%d]", r->filename, n);
return n;
}
else if (strlen(r->filename) > 10 &&
strncmp(r->filename, "forbidden:", 10) == 0) {
/* This URLs is forced to be forbidden for the requester */
return HTTP_FORBIDDEN;
}
else if (strlen(r->filename) > 5 &&
strncmp(r->filename, "gone:", 5) == 0) {
/* This URLs is forced to be gone */
return HTTP_GONE;
}
else if (strlen(r->filename) > 12 &&
strncmp(r->filename, "passthrough:", 12) == 0) {
/*
* 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
*/
r->uri = apr_pstrdup(r->pool, r->filename+12);
return DECLINED;
}
else {
/* it was finally rewritten to a local path */
/* expand "/~user" prefix */
#if APR_HAS_USER
r->filename = expand_tildepaths(r, r->filename);
#endif
rewritelog(r, 2, "local path result: %s", r->filename);
/* the filename has to start with a slash! */
if (r->filename[0] != '/') {
return HTTP_BAD_REQUEST;
}
/* if there is no valid prefix, we have
* to emulate 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!
*/
n = prefix_stat(r->filename, &finfo);
if (n == 0) {
if ((ccp = ap_document_root(r)) != NULL) {
l = apr_cpystrn(docroot, ccp, sizeof(docroot)) - docroot;
/* always NOT have a trailing slash */
if (docroot[l-1] == '/') {
docroot[l-1] = '\0';
}
if (r->server->path
&& !strncmp(r->filename, r->server->path,
r->server->pathlen)) {
r->filename = apr_pstrcat(r->pool, docroot,
(r->filename +
r->server->pathlen), NULL);
}
else {
r->filename = apr_pstrcat(r->pool, docroot,
r->filename, NULL);
}
rewritelog(r, 2, "prefixed with document_root to %s",
r->filename);
}
}
rewritelog(r, 1, "go-ahead with %s [OK]", r->filename);
return OK;
}
}
else {
rewritelog(r, 1, "pass through %s", r->filename);
return DECLINED;
}
}
/*
**
** MIME-type hook
**
** [used to support the forced-MIME-type feature]
**
*/
static int hook_mimetype(request_rec *r)
{
const char *t;
/* now check if we have to force a MIME-type */
t = apr_table_get(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR);
if (t == NULL) {
return DECLINED;
}
else {
rewritelog(r, 1, "force filename %s to have MIME-type '%s'",
r->filename, t);
r->content_type = t;
return OK;
}
}
/*
**
** Fixup hook
**
** [used for the rewriting engine triggered by
** the per-directory 'RewriteRule' directives]
**
*/
static int hook_fixup(request_rec *r)
{
rewrite_perdir_conf *dconf;
char *cp;
char *cp2;
const char *ccp;
char *prefix;
int l;
int n;
char *ofilename;
dconf = (rewrite_perdir_conf *)ap_get_module_config(r->per_dir_config,
&rewrite_module);
/* if there is no per-dir config we return immediately */
if (dconf == NULL) {
return DECLINED;
}
/* we shouldn't do anything in subrequests */
if (r->main != NULL) {
return DECLINED;
}
/* if there are no real (i.e. no RewriteRule directives!)
per-dir config of us, we return also immediately */
if (dconf->directory == NULL) {
return DECLINED;
}
/*
* only do something under runtime if the engine is really enabled,
* for this directory, else return immediately!
*/
if (!(ap_allow_options(r) & (OPT_SYM_LINKS | OPT_SYM_OWNER))) {
/* FollowSymLinks is mandatory! */
ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, r,
"Options FollowSymLinks or SymLinksIfOwnerMatch is off "
"which implies that RewriteRule directive is forbidden: "
"%s", r->filename);
return HTTP_FORBIDDEN;
}
else {
/* FollowSymLinks is given, but the user can
* still turn off the rewriting engine
*/
if (dconf->state == ENGINE_DISABLED) {
return DECLINED;
}
}
/*
* remember the current filename before rewriting for later check
* to prevent deadlooping because of internal redirects
* on final URL/filename which can be equal to the inital one.
*/
ofilename = r->filename;
/*
* now apply the rules ...
*/
if (apply_rewrite_list(r, dconf->rewriterules, dconf->directory)) {
if (strlen(r->filename) > 6 &&
strncmp(r->filename, "proxy:", 6) == 0) {
/* 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!)
*/
if (r->args != NULL) {
r->filename = apr_pstrcat(r->pool, r->filename,
"?", r->args, NULL);
}
/* now make sure the request gets handled by the proxy handler */
r->proxyreq = 1;
r->handler = "proxy-server";
rewritelog(r, 1, "[per-dir %s] go-ahead with proxy request "
"%s [OK]", dconf->directory, r->filename);
return OK;
}
else if (is_absolute_uri(r->filename)) {
/* 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
*/
if (dconf->baseurl != NULL) {
/* skip 'scheme:' */
for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
;
/* skip '://' */
cp += 3;
if ((cp = strchr(cp, '/')) != NULL) {
rewritelog(r, 2,
"[per-dir %s] trying to replace "
"prefix %s with %s",
dconf->directory, dconf->directory,
dconf->baseurl);
cp2 = subst_prefix_path(r, cp, dconf->directory,
dconf->baseurl);
if (strcmp(cp2, cp) != 0) {
*cp = '\0';
r->filename = apr_pstrcat(r->pool, r->filename,
cp2, NULL);
}
}
}
/* now prepare the redirect... */
/* skip 'scheme:' */
for (cp = r->filename; *cp != ':' && *cp != '\0'; cp++)
;
/* skip '://' */
cp += 3;
/* skip host part */
for ( ; *cp != '/' && *cp != '\0'; cp++)
;
if (*cp != '\0') {
rewritelog(r, 1, "[per-dir %s] escaping %s for redirect",
dconf->directory, r->filename);
cp2 = ap_escape_uri(r->pool, cp);
*cp = '\0';
r->filename = apr_pstrcat(r->pool, r->filename, cp2, NULL);
}
/* append the QUERY_STRING part */
if (r->args != NULL) {
r->filename = apr_pstrcat(r->pool, r->filename, "?",
ap_escape_uri(r->pool, r->args), NULL);
}
/* determine HTTP redirect response code */
if (ap_is_HTTP_REDIRECT(r->status)) {
n = r->status;
r->status = HTTP_OK; /* make Apache kernel happy */
}
else {
n = HTTP_MOVED_TEMPORARILY;
}
/* now do the redirection */
apr_table_setn(r->headers_out, "Location", r->filename);
rewritelog(r, 1, "[per-dir %s] redirect to %s [REDIRECT/%d]",
dconf->directory, r->filename, n);
return n;
}
else if (strlen(r->filename) > 10 &&
strncmp(r->filename, "forbidden:", 10) == 0) {
/* This URL is forced to be forbidden for the requester */
return HTTP_FORBIDDEN;
}
else if (strlen(r->filename) > 5 &&
strncmp(r->filename, "gone:", 5) == 0) {
/* 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
*/
if (strlen(r->filename) > 12 &&
strncmp(r->filename, "passthrough:", 12) == 0) {
r->filename = apr_pstrdup(r->pool, r->filename+12);
}
/* the filename has to start with a slash! */
if (r->filename[0] != '/') {
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.
*/
if (strcmp(r->filename, ofilename) == 0) {
rewritelog(r, 1, "[per-dir %s] initial URL equal rewritten "
"URL: %s [IGNORING REWRITE]",
dconf->directory, r->filename);
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
*/
if (dconf->baseurl != NULL) {
rewritelog(r, 2,
"[per-dir %s] trying to replace prefix %s with %s",
dconf->directory, dconf->directory, dconf->baseurl);
r->filename = subst_prefix_path(r, r->filename,
dconf->directory,
dconf->baseurl);
}
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
*/
if ((ccp = ap_document_root(r)) != NULL) {
prefix = apr_pstrdup(r->pool, ccp);
/* always NOT have a trailing slash */
l = strlen(prefix);
if (prefix[l-1] == '/') {
prefix[l-1] = '\0';
l--;
}
if (strncmp(r->filename, prefix, l) == 0) {
rewritelog(r, 2,
"[per-dir %s] strip document_root "
"prefix: %s -> %s",
dconf->directory, r->filename,
r->filename+l);
r->filename = apr_pstrdup(r->pool, r->filename+l);
}
}
}
/* now initiate the internal redirect */
rewritelog(r, 1, "[per-dir %s] internal redirect with %s "
"[INTERNAL REDIRECT]", dconf->directory, r->filename);
r->filename = apr_pstrcat(r->pool, "redirect:", r->filename, NULL);
r->handler = "redirect-handler";
return OK;
}
}
else {
rewritelog(r, 1, "[per-dir %s] pass through %s",
dconf->directory, r->filename);
return DECLINED;
}
}
/*
**
** Content-Handlers
**
** [used for redirect support]
**
*/
static int handler_redirect(request_rec *r)
{
if (strcmp(r->handler, "redirect-handler")) {
return DECLINED;
}
/* just make sure that we are really meant! */
if (strncmp(r->filename, "redirect:", 9) != 0) {
return DECLINED;
}
/* now do the internal redirect */
ap_internal_redirect(apr_pstrcat(r->pool, r->filename+9,
r->args ? "?" : NULL, r->args, NULL), r);
/* and return gracefully */
return OK;
}
/*
** +-------------------------------------------------------+
** | |
** | the rewriting engine
** | |
** +-------------------------------------------------------+
*/
/*
* Apply a complete rule set,
* i.e. a list of rewrite rules
*/
static int apply_rewrite_list(request_rec *r, apr_array_header_t *rewriterules,
char *perdir)
{
rewriterule_entry *entries;
rewriterule_entry *p;
int i;
int changed;
int rc;
int s;
/*
* Iterate over all existing rules
*/
entries = (rewriterule_entry *)rewriterules->elts;
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.
*/
if (r->main != NULL &&
(p->flags & RULEFLAG_IGNOREONSUBREQ ||
p->flags & RULEFLAG_PROXY ||
p->flags & RULEFLAG_FORCEREDIRECT )) {
continue;
}
/*
* Apply the current rule.
*/
rc = apply_rewrite_rule(r, p, perdir);
if (rc) {
/*
* Indicate a change if this was not a match-only rule.
*/
if (rc != 2) {
changed = 1;
}
/*
* 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) {
rewritelog(r, 2, "forcing '%s' to get passed through "
"to next API URI-to-filename handler", r->filename);
r->filename = apr_pstrcat(r->pool, "passthrough:",
r->filename, NULL);
changed = 1;
break;
}
/*
* Rule has the "forbidden" flag set which means that
* we stop processing and indicate this to the caller.
*/
if (p->flags & RULEFLAG_FORBIDDEN) {
rewritelog(r, 2, "forcing '%s' to be forbidden", r->filename);
r->filename = apr_pstrcat(r->pool, "forbidden:",
r->filename, NULL);
changed = 1;
break;
}
/*
* Rule has the "gone" flag set which means that
* we stop processing and indicate this to the caller.
*/
if (p->flags & RULEFLAG_GONE) {
rewritelog(r, 2, "forcing '%s' to be gone", r->filename);
r->filename = apr_pstrcat(r->pool, "gone:", r->filename, NULL);
changed = 1;
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;
}
/*
* Apply a single(!) rewrite rule
*/
static int apply_rewrite_rule(request_rec *r, rewriterule_entry *p,
char *perdir)
{
char *uri;
char *output;
const char *vary;
char newuri[MAX_STRING_LEN];
regex_t *regexp;
regmatch_t regmatch[MAX_NMATCH];
backrefinfo *briRR = NULL;
backrefinfo *briRC = NULL;
int prefixstrip;
int failed;
apr_array_header_t *rewriteconds;
rewritecond_entry *conds;
rewritecond_entry *c;
int i;
int rc;
/*
* Initialisation
*/
uri = r->filename;
regexp = p->regexp;
output = p->output;
/*
* Add (perhaps splitted away) PATH_INFO postfix to URL to
* make sure we really match against the complete URL.
*/
if (perdir != NULL && r->path_info != NULL && r->path_info[0] != '\0') {
rewritelog(r, 3, "[per-dir %s] add path info postfix: %s -> %s%s",
perdir, uri, uri, r->path_info);
uri = apr_pstrcat(r->pool, uri, r->path_info, NULL);
}
/*
* 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;
if (perdir != NULL) {
if ( strlen(uri) >= strlen(perdir)
&& strncmp(uri, perdir, strlen(perdir)) == 0) {
rewritelog(r, 3, "[per-dir %s] strip per-dir prefix: %s -> %s",
perdir, uri, uri+strlen(perdir));
uri = uri+strlen(perdir);
prefixstrip = 1;
}
}
/*
* Try to match the URI against the RewriteRule pattern
* and exit immeddiately if it didn't apply.
*/
if (perdir == NULL) {
rewritelog(r, 3, "applying pattern '%s' to uri '%s'",
p->pattern, uri);
}
else {
rewritelog(r, 3, "[per-dir %s] applying pattern '%s' to uri '%s'",
perdir, p->pattern, uri);
}
rc = (ap_regexec(regexp, uri, regexp->re_nsub+1, regmatch, 0) == 0);
if (! (( rc && !(p->flags & RULEFLAG_NOTMATCH)) ||
(!rc && (p->flags & RULEFLAG_NOTMATCH)) ) ) {
return 0;
}
/*
* Else create the RewriteRule `regsubinfo' structure which
* holds the substitution information.
*/
briRR = (backrefinfo *)apr_palloc(r->pool, sizeof(backrefinfo));
if (!rc && (p->flags & RULEFLAG_NOTMATCH)) {
/* empty info on negative patterns */
briRR->source = "";
briRR->nsub = 0;
}
else {
briRR->source = apr_pstrdup(r->pool, uri);
briRR->nsub = regexp->re_nsub;
memcpy((void *)(briRR->regmatch), (void *)(regmatch),
sizeof(regmatch));
}
/*
* Initiallally create the RewriteCond backrefinfo with
* empty backrefinfo, i.e. not subst parts
* (this one is adjusted inside apply_rewrite_cond() later!!)
*/
briRC = (backrefinfo *)apr_pcalloc(r->pool, sizeof(backrefinfo));
briRC->source = "";
briRC->nsub = 0;
/*
* 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;
conds = (rewritecond_entry *)rewriteconds->elts;
failed = 0;
for (i = 0; i < rewriteconds->nelts; i++) {
c = &conds[i];
rc = apply_rewrite_cond(r, c, perdir, briRR, briRC);
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...
*/
apr_table_unset(r->notes, VARY_KEY_THIS);
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;
}
}
vary = apr_table_get(r->notes, VARY_KEY_THIS);
if (vary != NULL) {
apr_table_merge(r->notes, VARY_KEY, vary);
apr_table_unset(r->notes, VARY_KEY_THIS);
}
}
/* if any condition fails the complete rule fails */
if (failed) {
apr_table_unset(r->notes, VARY_KEY);
apr_table_unset(r->notes, VARY_KEY_THIS);
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 ((vary = apr_table_get(r->notes, VARY_KEY)) != NULL) {
apr_table_merge(r->headers_out, "Vary", vary);
apr_table_unset(r->notes, VARY_KEY);
}
/*
* 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
* (`RewriteRule <pat> - [E=...]')
*/
if (strcmp(output, "-") == 0) {
do_expand_env(r, p->env, briRR, briRC);
if (p->forced_mimetype != NULL) {
if (perdir == 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.
*/
rewritelog(r, 2, "remember %s to have MIME-type '%s'",
r->filename, p->forced_mimetype);
apr_table_setn(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR,
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...
*/
rewritelog(r, 1, "[per-dir %s] force %s to have MIME-type "
"'%s'", perdir, r->filename, p->forced_mimetype);
r->content_type = 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'.
*/
do_expand(r, output, newuri, sizeof(newuri), briRR, briRC);
if (perdir == NULL) {
rewritelog(r, 2, "rewrite %s -> %s", uri, newuri);
}
else {
rewritelog(r, 2, "[per-dir %s] rewrite %s -> %s", perdir, uri, newuri);
}
/*
* Additionally do expansion for the environment variable
* strings (`RewriteRule .. .. [E=<string>]').
*/
do_expand_env(r, p->env, briRR, briRC);
/*
* 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
*/
r->filename = apr_pstrdup(r->pool, newuri);
splitout_queryargs(r, p->flags & RULEFLAG_QSAPPEND);
/*
* Again 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 starting with either a slash
* or a fully qualified URL scheme.
*/
if (prefixstrip && r->filename[0] != '/'
&& !is_absolute_uri(r->filename)) {
rewritelog(r, 3, "[per-dir %s] add per-dir prefix: %s -> %s%s",
perdir, r->filename, perdir, r->filename);
r->filename = apr_pstrcat(r->pool, perdir, r->filename, NULL);
}
/*
* 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) {
fully_qualify_uri(r);
if (perdir == NULL) {
rewritelog(r, 2, "forcing proxy-throughput with %s", r->filename);
}
else {
rewritelog(r, 2, "[per-dir %s] forcing proxy-throughput with %s",
perdir, r->filename);
}
r->filename = apr_pstrcat(r->pool, "proxy:", r->filename, NULL);
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) {
fully_qualify_uri(r);
if (perdir == NULL) {
rewritelog(r, 2,
"explicitly forcing redirect with %s", r->filename);
}
else {
rewritelog(r, 2,
"[per-dir %s] explicitly forcing redirect with %s",
perdir, r->filename);
}
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)) {
if (perdir == NULL) {
rewritelog(r, 2,
"implicitly forcing redirect (rc=%d) with %s",
p->forced_responsecode, r->filename);
}
else {
rewritelog(r, 2, "[per-dir %s] implicitly forcing redirect "
"(rc=%d) with %s", perdir, p->forced_responsecode,
r->filename);
}
r->status = p->forced_responsecode;
return 1;
}
/*
* Now we are sure it is not a fully qualified URL. But
* there is still one special case left: A local rewrite in
* per-directory context, i.e. a substitution URL which does
* not start with a slash. Here we add again the initially
* stripped per-directory prefix.
*/
if (prefixstrip && r->filename[0] != '/') {
rewritelog(r, 3, "[per-dir %s] add per-dir prefix: %s -> %s%s",
perdir, r->filename, perdir, r->filename);
r->filename = apr_pstrcat(r->pool, perdir, r->filename, NULL);
}
/*
* 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 its 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) {
apr_table_setn(r->notes, REWRITE_FORCED_MIMETYPE_NOTEVAR,
p->forced_mimetype);
if (perdir == NULL) {
rewritelog(r, 2, "remember %s to have MIME-type '%s'",
r->filename, p->forced_mimetype);
}
else {
rewritelog(r, 2,
"[per-dir %s] remember %s to have MIME-type '%s'",
perdir, r->filename, p->forced_mimetype);
}
}
/*
* Puuhhhhhhhh... WHAT COMPLICATED STUFF ;_)
* But now we're done for this particular rule.
*/
return 1;
}
static int apply_rewrite_cond(request_rec *r, rewritecond_entry *p,
char *perdir, backrefinfo *briRR,
backrefinfo *briRC)
{
char input[MAX_STRING_LEN];
apr_finfo_t sb;
request_rec *rsub;
regmatch_t regmatch[MAX_NMATCH];
int rc;
/*
* Construct the string we match against
*/
do_expand(r, p->input, input, sizeof(input), briRR, briRC);
/*
* Apply the patterns
*/
rc = 0;
if (strcmp(p->pattern, "-f") == 0) {
if (apr_stat(&sb, input, APR_FINFO_MIN, r->pool) == APR_SUCCESS) {
if (sb.filetype == APR_REG) {
rc = 1;
}
}
}
else if (strcmp(p->pattern, "-s") == 0) {
if (apr_stat(&sb, input, APR_FINFO_MIN, r->pool) == APR_SUCCESS) {
if ((sb.filetype == APR_REG) && sb.size > 0) {
rc = 1;
}
}
}
else if (strcmp(p->pattern, "-l") == 0) {
#if !defined(OS2)
if (apr_lstat(&sb, input, APR_FINFO_MIN, r->pool) == APR_SUCCESS) {
if (sb.filetype == APR_LNK) {
rc = 1;
}
}
#endif
}
else if (strcmp(p->pattern, "-d") == 0) {
if (apr_stat(&sb, input, APR_FINFO_MIN, r->pool) == APR_SUCCESS) {
if (sb.filetype == APR_DIR) {
rc = 1;
}
}
}
else if (strcmp(p->pattern, "-U") == 0) {
/* avoid infinite subrequest recursion */
if (strlen(input) > 0 && subreq_ok(r)) {
/* run a URI-based subrequest */
rsub = ap_sub_req_lookup_uri(input, r, NULL);
/* URI exists for any result up to 3xx, redirects allowed */
if (rsub->status < 400)
rc = 1;
/* log it */
rewritelog(r, 5, "RewriteCond URI (-U) check: "
"path=%s -> status=%d", input, rsub->status);
/* cleanup by destroying the subrequest */
ap_destroy_sub_req(rsub);
}
}
else if (strcmp(p->pattern, "-F") == 0) {
/* avoid infinite subrequest recursion */
if (strlen(input) > 0 && subreq_ok(r)) {
/* process a file-based subrequest:
* this differs from -U in that no path translation is done.
*/
rsub = ap_sub_req_lookup_file(input, r, NULL);
/* file exists for any result up to 2xx, no redirects */
if (rsub->status < 300 &&
/* double-check that file exists since default result is 200 */
apr_stat(&sb, rsub->filename, APR_FINFO_MIN,
r->pool) == APR_SUCCESS) {
rc = 1;
}
/* log it */
rewritelog(r, 5, "RewriteCond file (-F) check: path=%s "
"-> file=%s status=%d", input, rsub->filename,
rsub->status);
/* cleanup by destroying the subrequest */
ap_destroy_sub_req(rsub);
}
}
else if (strlen(p->pattern) > 1 && *(p->pattern) == '>') {
rc = (compare_lexicography(input, p->pattern+1) == 1 ? 1 : 0);
}
else if (strlen(p->pattern) > 1 && *(p->pattern) == '<') {
rc = (compare_lexicography(input, p->pattern+1) == -1 ? 1 : 0);
}
else if (strlen(p->pattern) > 1 && *(p->pattern) == '=') {
if (strcmp(p->pattern+1, "\"\"") == 0) {
rc = (*input == '\0');
}
else {
rc = (strcmp(input, p->pattern+1) == 0 ? 1 : 0);
}
}
else {
/* it is really a regexp pattern, so apply it */
rc = (ap_regexec(p->regexp, input,
p->regexp->re_nsub+1, regmatch,0) == 0);
/* if it isn't a negated pattern and really matched
we update the passed-through regex subst info structure */
if (rc && !(p->flags & CONDFLAG_NOTMATCH)) {
briRC->source = apr_pstrdup(r->pool, input);
briRC->nsub = p->regexp->re_nsub;
memcpy((void *)(briRC->regmatch), (void *)(regmatch),
sizeof(regmatch));
}
}
/* if this is a non-matching regexp, just negate the result */
if (p->flags & CONDFLAG_NOTMATCH) {
rc = !rc;
}
rewritelog(r, 4, "RewriteCond: input='%s' pattern='%s%s' => %s",
input, (p->flags & CONDFLAG_NOTMATCH ? "!" : ""),
p->pattern, rc ? "matched" : "not-matched");
/* end just return the result */
return rc;
}
/*
** +-------------------------------------------------------+
** | |
** | URL transformation functions
** | |
** +-------------------------------------------------------+
*/
/*
**
** perform all the expansions on the input string
** leaving the result in the supplied buffer
**
*/
static void do_expand(request_rec *r, char *input, char *buffer, int nbuf,
backrefinfo *briRR, backrefinfo *briRC)
{
char *inp, *outp;
size_t span, space;
/*
* for security reasons this expansion must be perfomed 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.
*/
inp = input;
outp = buffer;
space = nbuf - 1; /* room for '\0' */
for (;;) {
span = strcspn(inp, "$%");
if (span > space) {
span = space;
}
memcpy(outp, inp, span);
inp += span;
outp += span;
space -= span;
if (space == 0 || *inp == '\0') {
break;
}
/* now we have a '$' or a '%' */
if (inp[1] == '{') {
char *endp;
endp = find_closing_bracket(inp+2, '{', '}');
if (endp == NULL) {
goto skip;
}
/*
* These lookups may be recursive in a very convoluted
* fashion -- see the LA-U and LA-F variable expansion
* prefixes -- so we copy lookup keys to a separate buffer
* rather than adding zero bytes in order to use them in
* place.
*/
if (inp[0] == '$') {
/* ${...} map lookup expansion */
/*
* 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.
*/
char *map, *key, *dflt, *result;
char xkey[MAX_STRING_LEN];
char xdflt[MAX_STRING_LEN];
key = find_char_in_brackets(inp+2, ':', '{', '}');
if (key == NULL)
goto skip;
map = apr_pstrndup(r->pool, inp+2, key-inp-2);
dflt = find_char_in_brackets(key+1, '|', '{', '}');
if (dflt == NULL) {
key = apr_pstrndup(r->pool, key+1, endp-key-1);
dflt = "";
} else {
key = apr_pstrndup(r->pool, key+1, dflt-key-1);
dflt = apr_pstrndup(r->pool, dflt+1, endp-dflt-1);
}
do_expand(r, key, xkey, sizeof(xkey), briRR, briRC);
result = lookup_map(r, map, xkey);
if (result) {
span = apr_cpystrn(outp, result, space) - outp;
} else {
do_expand(r, dflt, xdflt, sizeof(xdflt), briRR, briRC);
span = apr_cpystrn(outp, xdflt, space) - outp;
}
}
else if (inp[0] == '%') {
/* %{...} variable lookup expansion */
char *var;
var = apr_pstrndup(r->pool, inp+2, endp-inp-2);
span = apr_cpystrn(outp, lookup_variable(r, var), space) - outp;
}
else {
span = 0;
}
inp = endp+1;
outp += span;
space -= span;
continue;
}
else if (apr_isdigit(inp[1])) {
int n = inp[1] - '0';
backrefinfo *bri = NULL;
if (inp[0] == '$') {
/* $N RewriteRule regexp backref expansion */
bri = briRR;
}
else if (inp[0] == '%') {
/* %N RewriteCond regexp backref expansion */
bri = briRC;
}
/* see ap_pregsub() in src/main/util.c */
if (bri && n <= bri->nsub &&
bri->regmatch[n].rm_eo > bri->regmatch[n].rm_so) {
span = bri->regmatch[n].rm_eo - bri->regmatch[n].rm_so;
if (span > space) {
span = space;
}
memcpy(outp, bri->source + bri->regmatch[n].rm_so, span);
outp += span;
space -= span;
}
inp += 2;
continue;
}
skip:
*outp++ = *inp++;
space--;
}
*outp++ = '\0';
}
/*
**
** perform all the expansions on the environment variables
**
*/
static void do_expand_env(request_rec *r, char *env[],
backrefinfo *briRR, backrefinfo *briRC)
{
int i;
char buf[MAX_STRING_LEN];
for (i = 0; env[i] != NULL; i++) {
do_expand(r, env[i], buf, sizeof(buf), briRR, briRC);
add_env_variable(r, buf);
}
}
/*
**
** split out a QUERY_STRING part from
** the current URI string
**
*/
static void splitout_queryargs(request_rec *r, int qsappend)
{
char *q;
char *olduri;
q = strchr(r->filename, '?');
if (q != NULL) {
olduri = apr_pstrdup(r->pool, r->filename);
*q++ = '\0';
if (qsappend) {
r->args = apr_pstrcat(r->pool, q, "&", r->args, NULL);
}
else {
r->args = apr_pstrdup(r->pool, q);
}
if (strlen(r->args) == 0) {
r->args = NULL;
rewritelog(r, 3, "split uri=%s -> uri=%s, args=<none>", olduri,
r->filename);
}
else {
if (r->args[strlen(r->args)-1] == '&') {
r->args[strlen(r->args)-1] = '\0';
}
rewritelog(r, 3, "split uri=%s -> uri=%s, args=%s", olduri,
r->filename, r->args);
}
}
return;
}
/*
**
** strip 'http[s]://ourhost/' from URI
**
*/
static void reduce_uri(request_rec *r)
{
char *cp;
unsigned short port;
char *portp;
char *hostp;
char *url;
char c;
char host[LONG_STRING_LEN];
char buf[MAX_STRING_LEN];
char *olduri;
int l;
cp = (char *)ap_http_method(r);
l = strlen(cp);
if ( strlen(r->filename) > l+3
&& strncasecmp(r->filename, cp, l) == 0
&& r->filename[l] == ':'
&& r->filename[l+1] == '/'
&& r->filename[l+2] == '/' ) {
/* there was really a rewrite to a remote path */
olduri = apr_pstrdup(r->pool, r->filename); /* save for logging */
/* cut the hostname and port out of the URI */
apr_cpystrn(buf, r->filename+(l+3), sizeof(buf));
hostp = buf;
for (cp = hostp; *cp != '\0' && *cp != '/' && *cp != ':'; cp++)
;
if (*cp == ':') {
/* set host */
*cp++ = '\0';
apr_cpystrn(host, hostp, sizeof(host));
/* set port */
portp = cp;
for (; *cp != '\0' && *cp != '/'; cp++)
;
c = *cp;
*cp = '\0';
port = atoi(portp);
*cp = c;
/* set remaining url */
url = cp;
}
else if (*cp == '/') {
/* set host */
*cp = '\0';
apr_cpystrn(host, hostp, sizeof(host));
*cp = '/';
/* set port */
port = ap_default_port(r);
/* set remaining url */
url = cp;
}
else {
/* set host */
apr_cpystrn(host, hostp, sizeof(host));
/* set port */
port = ap_default_port(r);
/* set remaining url */
url = "/";
}
/* now check whether we could reduce it to a local path... */
if (ap_matches_request_vhost(r, host, port)) {
/* this is our host, so only the URL remains */
r->filename = apr_pstrdup(r->pool, url);
rewritelog(r, 3, "reduce %s -> %s", olduri, r->filename);
}
}
return;
}
/*
**
** add 'http[s]://ourhost[:ourport]/' to URI
** if URI is still not fully qualified
**
*/
static void fully_qualify_uri(request_rec *r)
{
char buf[32];
const char *thisserver;
char *thisport;
int port;
if (!is_absolute_uri(r->filename)) {
thisserver = ap_get_server_name(r);
port = ap_get_server_port(r);
if (ap_is_default_port(port,r)) {
thisport = "";
}
else {
apr_snprintf(buf, sizeof(buf), ":%u", port);
thisport = buf;
}
if (r->filename[0] == '/') {
r->filename = apr_psprintf(r->pool, "%s://%s%s%s",
ap_http_method(r), thisserver,
thisport, r->filename);
}
else {
r->filename = apr_psprintf(r->pool, "%s://%s%s/%s",
ap_http_method(r), thisserver,
thisport, r->filename);
}
}
return;
}
/*
**
** return non-zero if the URI is absolute (includes a scheme etc.)
**
*/
static int is_absolute_uri(char *uri)
{
int i = strlen(uri);
if ( (i > 7 && strncasecmp(uri, "http://", 7) == 0)
|| (i > 8 && strncasecmp(uri, "https://", 8) == 0)
|| (i > 9 && strncasecmp(uri, "gopher://", 9) == 0)
|| (i > 6 && strncasecmp(uri, "ftp://", 6) == 0)
|| (i > 5 && strncasecmp(uri, "ldap:", 5) == 0)
|| (i > 5 && strncasecmp(uri, "news:", 5) == 0)
|| (i > 7 && strncasecmp(uri, "mailto:", 7) == 0) ) {
return 1;
}
else {
return 0;
}
}
/*
**
** Expand tilde-paths (/~user) through Unix /etc/passwd
** database information (or other OS-specific database)
**
*/
#if APR_HAS_USER
static char *expand_tildepaths(request_rec *r, char *uri)
{
char user[LONG_STRING_LEN];
char *newuri;
int i, j;
char *homedir;
newuri = uri;
if (uri != NULL && strlen(uri) > 2 && uri[0] == '/' && uri[1] == '~') {
/* cut out the username */
for (j = 0, i = 2; j < sizeof(user)-1
&& uri[i] != '\0'
&& uri[i] != '/' ; ) {
user[j++] = uri[i++];
}
user[j] = '\0';
/* lookup username in systems passwd file */
if (apr_get_home_directory(&homedir, user, r->pool) == APR_SUCCESS) {
/* ok, user was found, so expand the ~user string */
if (uri[i] != '\0') {
/* ~user/anything... has to be expanded */
if (homedir[strlen(homedir)-1] == '/') {
homedir[strlen(homedir)-1] = '\0';
}
newuri = apr_pstrcat(r->pool, homedir, uri+i, NULL);
}
else {
/* only ~user has to be expanded */
newuri = homedir;
}
}
}
return newuri;
}
#endif /* if APR_HAS_USER */
/*
** +-------------------------------------------------------+
** | |
** | DBM hashfile support
** | |
** +-------------------------------------------------------+
*/
static char *lookup_map(request_rec *r, char *name, char *key)
{
void *sconf;
rewrite_server_conf *conf;
apr_array_header_t *rewritemaps;
rewritemap_entry *entries;
rewritemap_entry *s;
char *value;
apr_finfo_t st;
apr_status_t rv;
int i;
/* get map configuration */
sconf = r->server->module_config;
conf = (rewrite_server_conf *)ap_get_module_config(sconf,
&rewrite_module);
rewritemaps = conf->rewritemaps;
entries = (rewritemap_entry *)rewritemaps->elts;
for (i = 0; i < rewritemaps->nelts; i++) {
s = &entries[i];
if (strcmp(s->name, name) == 0) {
if (s->type == MAPTYPE_TXT) {
if ((rv = apr_stat(&st, s->checkfile,
APR_FINFO_MIN, r->pool)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"mod_rewrite: can't access text RewriteMap "
"file %s", s->checkfile);
rewritelog(r, 1, "can't open RewriteMap file, "
"see error log");
return NULL;
}
value = get_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key);
if (value == NULL) {
rewritelog(r, 6, "cache lookup FAILED, forcing new "
"map lookup");
if ((value =
lookup_map_txtfile(r, s->datafile, key)) != NULL) {
rewritelog(r, 5, "map lookup OK: map=%s key=%s[txt] "
"-> val=%s", s->name, key, value);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, value);
return value;
}
else {
rewritelog(r, 5, "map lookup FAILED: map=%s[txt] "
"key=%s", s->name, key);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, "");
return NULL;
}
}
else {
rewritelog(r, 5, "cache lookup OK: map=%s[txt] key=%s "
"-> val=%s", s->name, key, value);
return value[0] != '\0' ? value : NULL;
}
}
else if (s->type == MAPTYPE_DBM) {
#ifndef NO_DBM_REWRITEMAP
if ((rv = apr_stat(&st, s->checkfile,
APR_FINFO_MIN, r->pool)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"mod_rewrite: can't access DBM RewriteMap "
"file %s", s->checkfile);
rewritelog(r, 1, "can't open DBM RewriteMap file, "
"see error log");
return NULL;
}
value = get_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key);
if (value == NULL) {
rewritelog(r, 6,
"cache lookup FAILED, forcing new map lookup");
if ((value =
lookup_map_dbmfile(r, s->datafile, key)) != NULL) {
rewritelog(r, 5, "map lookup OK: map=%s[dbm] key=%s "
"-> val=%s", s->name, key, value);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, value);
return value;
}
else {
rewritelog(r, 5, "map lookup FAILED: map=%s[dbm] "
"key=%s", s->name, key);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, "");
return NULL;
}
}
else {
rewritelog(r, 5, "cache lookup OK: map=%s[dbm] key=%s "
"-> val=%s", s->name, key, value);
return value[0] != '\0' ? value : NULL;
}
#else
return NULL;
#endif
}
else if (s->type == MAPTYPE_PRG) {
if ((value =
lookup_map_program(r, s->fpin, s->fpout, key)) != NULL) {
rewritelog(r, 5, "map lookup OK: map=%s key=%s -> val=%s",
s->name, key, value);
return value;
}
else {
rewritelog(r, 5, "map lookup FAILED: map=%s key=%s",
s->name, key);
}
}
else if (s->type == MAPTYPE_INT) {
if ((value = lookup_map_internal(r, s->func, key)) != NULL) {
rewritelog(r, 5, "map lookup OK: map=%s key=%s -> val=%s",
s->name, key, value);
return value;
}
else {
rewritelog(r, 5, "map lookup FAILED: map=%s key=%s",
s->name, key);
}
}
else if (s->type == MAPTYPE_RND) {
if ((rv = apr_stat(&st, s->checkfile,
APR_FINFO_MIN, r->pool)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
"mod_rewrite: can't access text RewriteMap "
"file %s", s->checkfile);
rewritelog(r, 1, "can't open RewriteMap file, "
"see error log");
return NULL;
}
value = get_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key);
if (value == NULL) {
rewritelog(r, 6, "cache lookup FAILED, forcing new "
"map lookup");
if ((value =
lookup_map_txtfile(r, s->datafile, key)) != NULL) {
rewritelog(r, 5, "map lookup OK: map=%s key=%s[txt] "
"-> val=%s", s->name, key, value);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, value);
}
else {
rewritelog(r, 5, "map lookup FAILED: map=%s[txt] "
"key=%s", s->name, key);
set_cache_string(cachep, s->name, CACHEMODE_TS,
st.mtime, key, "");
return NULL;
}
}
else {
rewritelog(r, 5, "cache lookup OK: map=%s[txt] key=%s "
"-> val=%s", s->name, key, value);
}
if (value[0] != '\0') {
value = select_random_value_part(r, value);
rewritelog(r, 5, "randomly choosen the subvalue `%s'", value);
}
else {
value = NULL;
}
return value;
}
}
}
return NULL;
}
static char *lookup_map_txtfile(request_rec *r, const char *file, char *key)
{
apr_file_t *fp = NULL;
apr_status_t rc;
char line[1024];
char *value = NULL;
char *cpT;
size_t skip;
char *curkey;
char *curval;
rc = apr_file_open(&fp, file, APR_READ, APR_OS_DEFAULT, r->pool);
if (rc != APR_SUCCESS) {
return NULL;
}
while (apr_file_gets(line, sizeof(line), fp) == APR_SUCCESS) {
if (line[0] == '#')
continue; /* ignore comments */
cpT = line;
curkey = cpT;
skip = strcspn(cpT," \t\r\n");
if (skip == 0)
continue; /* ignore lines that start with a space, tab, CR, or LF */
cpT += skip;
*cpT = '\0';
if (strcmp(curkey, key) != 0)
continue; /* key does not match... */
/* found a matching key; now extract and return the value */
++cpT;
skip = strspn(cpT, " \t\r\n");
cpT += skip;
curval = cpT;
skip = strcspn(cpT, " \t\r\n");
if (skip == 0)
continue; /* no value... */
cpT += skip;
*cpT = '\0';
value = apr_pstrdup(r->pool, curval);
break;
}
apr_file_close(fp);
return value;
}
#ifndef NO_DBM_REWRITEMAP
static char *lookup_map_dbmfile(request_rec *r, const char *file, char *key)
{
DBM *dbmfp = NULL;
datum dbmkey;
datum dbmval;
char *value = NULL;
char buf[MAX_STRING_LEN];
dbmkey.dptr = key;
dbmkey.dsize = strlen(key);
if ((dbmfp = dbm_open(file, O_RDONLY, 0666)) != NULL) {
dbmval = dbm_fetch(dbmfp, dbmkey);
if (dbmval.dptr != NULL) {
memcpy(buf, dbmval.dptr,
dbmval.dsize < sizeof(buf)-1 ?
dbmval.dsize : sizeof(buf)-1 );
buf[dbmval.dsize] = '\0';
value = apr_pstrdup(r->pool, buf);
}
dbm_close(dbmfp);
}
return value;
}
#endif
static char *lookup_map_program(request_rec *r, apr_file_t *fpin,
apr_file_t *fpout, char *key)
{
char buf[LONG_STRING_LEN];
char c;
int i;
apr_size_t nbytes;
#ifndef NO_WRITEV
struct iovec iova[2];
apr_size_t niov;
#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.
*/
if (fpin == NULL || fpout == NULL) {
return NULL;
}
/* take the lock */
if (rewrite_mapr_lock_aquire) {
apr_lock_aquire(rewrite_mapr_lock_aquire);
}
/* write out the request key */
#ifdef NO_WRITEV
nbytes = strlen(key);
apr_file_write(fpin, key, &nbytes);
nbytes = 1;
apr_file_write(fpin, "\n", &nbytes);
#else
iova[0].iov_base = key;
iova[0].iov_len = strlen(key);
iova[1].iov_base = "\n";
iova[1].iov_len = 1;
niov = 2;
apr_file_writev(fpin, iova, niov, &nbytes);
#endif
/* read in the response value */
i = 0;
nbytes = 1;
apr_file_read(fpout, &c, &nbytes);
while (nbytes == 1 && (i < LONG_STRING_LEN-1)) {
if (c == '\n') {
break;
}
buf[i++] = c;
apr_file_read(fpout, &c, &nbytes);
}
buf[i] = '\0';
/* give the lock back */
if (rewrite_mapr_lock_aquire) {
apr_lock_release(rewrite_mapr_lock_aquire);
}
if (strcasecmp(buf, "NULL") == 0) {
return NULL;
}
else {
return apr_pstrdup(r->pool, buf);
}
}
static char *lookup_map_internal(request_rec *r,
char *(*func)(request_rec *, char *),
char *key)
{
/* currently we just let the function convert
the key to a corresponding value */
return func(r, key);
}
static char *rewrite_mapfunc_toupper(request_rec *r, char *key)
{
char *value, *cp;
for (cp = value = apr_pstrdup(r->pool, key); cp != NULL && *cp != '\0';
cp++) {
*cp = apr_toupper(*cp);
}
return value;
}
static char *rewrite_mapfunc_tolower(request_rec *r, char *key)
{
char *value, *cp;
for (cp = value = apr_pstrdup(r->pool, key); cp != NULL && *cp != '\0';
cp++) {
*cp = apr_tolower(*cp);
}
return value;
}
static char *rewrite_mapfunc_escape(request_rec *r, char *key)
{
char *value;
value = ap_escape_uri(r->pool, key);
return value;
}
static char *rewrite_mapfunc_unescape(request_rec *r, char *key)
{
char *value;
value = apr_pstrdup(r->pool, key);
ap_unescape_url(value);
return value;
}
static int rewrite_rand_init_done = 0;
static void rewrite_rand_init(void)
{
if (!rewrite_rand_init_done) {
srand((unsigned)(getpid()));
rewrite_rand_init_done = 1;
}
return;
}
static int rewrite_rand(int l, int h)
{
rewrite_rand_init();
/* Get [0,1) and then scale to the appropriate range. Note that using
* a floating point value ensures that we use all bits of the rand()
* result. Doing an integer modulus would only use the lower-order bits
* which may not be as uniformly random.
*/
return ((double)(rand() % RAND_MAX) / RAND_MAX) * (h - l + 1) + l;
}
static char *select_random_value_part(request_rec *r, char *value)
{
char *buf;
int n, i, k;
/* count number of distinct values */
for (n = 1, i = 0; value[i] != '\0'; i++) {
if (value[i] == '|') {
n++;
}
}
/* when only one value we have no option to choose */
if (n == 1) {
return value;
}
/* else randomly select one */
k = rewrite_rand(1, n);
/* and grep it out */
for (n = 1, i = 0; value[i] != '\0'; i++) {
if (n == k) {
break;
}
if (value[i] == '|') {
n++;
}
}
buf = apr_pstrdup(r->pool, &value[i]);
for (i = 0; buf[i] != '\0' && buf[i] != '|'; i++)
;
buf[i] = '\0';
return buf;
}
/*
** +-------------------------------------------------------+
** | |
** | rewriting logfile support
** | |
** +-------------------------------------------------------+
*/
static void open_rewritelog(server_rec *s, apr_pool_t *p)
{
rewrite_server_conf *conf;
const char *fname;
apr_status_t rc;
piped_log *pl;
int rewritelog_flags = ( APR_WRITE | APR_APPEND | APR_CREATE );
mode_t rewritelog_mode = ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD );
conf = ap_get_module_config(s->module_config, &rewrite_module);
if (conf->rewritelogfile == NULL) {
return;
}
if (*(conf->rewritelogfile) == '\0') {
return;
}
if (conf->rewritelogfp != NULL) {
return; /* virtual log shared w/ main server */
}
fname = ap_server_root_relative(p, conf->rewritelogfile);
if (*conf->rewritelogfile == '|') {
if ((pl = ap_open_piped_log(p, conf->rewritelogfile+1)) == NULL) {
ap_log_error(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, s,
"mod_rewrite: could not open reliable pipe "
"to RewriteLog filter %s", conf->rewritelogfile+1);
exit(1);
}
conf->rewritelogfp = ap_piped_log_write_fd(pl);
}
else if (*conf->rewritelogfile != '\0') {
rc = apr_file_open(&conf->rewritelogfp, fname, rewritelog_flags, rewritelog_mode, p);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
"mod_rewrite: could not open RewriteLog "
"file %s", fname);
exit(1);
}
}
return;
}
static void rewritelog(request_rec *r, int level, const char *text, ...)
{
rewrite_server_conf *conf;
conn_rec *conn;
char *str1;
char str2[512];
char str3[1024];
char type[20];
char redir[20];
va_list ap;
int i;
apr_size_t nbytes;
request_rec *req;
char *ruser;
const char *rhost;
va_start(ap, text);
conf = ap_get_module_config(r->server->module_config, &rewrite_module);
conn = r->connection;
if (conf->rewritelogfp == NULL) {
return;
}
if (conf->rewritelogfile == NULL) {
return;
}
if (*(conf->rewritelogfile) == '\0') {
return;
}
if (level > conf->rewriteloglevel) {
return;
}
if (r->user == NULL) {
ruser = "-";
}
else if (strlen(r->user) != 0) {
ruser = r->user;
}
else {
ruser = "\"\"";
}
rhost = ap_get_remote_host(conn, r->server->module_config,
REMOTE_NOLOOKUP);
if (rhost == NULL) {
rhost = "UNKNOWN-HOST";
}
str1 = apr_pstrcat(r->pool, rhost, " ",
(conn->remote_logname != NULL ?
conn->remote_logname : "-"), " ",
ruser, NULL);
apr_vsnprintf(str2, sizeof(str2), text, ap);
if (r->main == NULL) {
strcpy(type, "initial");
}
else {
strcpy(type, "subreq");
}
for (i = 0, req = r; req->prev != NULL; req = req->prev) {
i++;
}
if (i == 0) {
redir[0] = '\0';
}
else {
apr_snprintf(redir, sizeof(redir), "/redir#%d", i);
}
apr_snprintf(str3, sizeof(str3),
"%s %s [%s/sid#%lx][rid#%lx/%s%s] (%d) %s\n", str1,
current_logtime(r), ap_get_server_name(r),
(unsigned long)(r->server), (unsigned long)r,
type, redir, level, str2);
apr_lock_aquire(rewrite_log_lock);
nbytes = strlen(str3);
apr_file_write(conf->rewritelogfp, str3, &nbytes);
apr_lock_release(rewrite_log_lock);
va_end(ap);
return;
}
static char *current_logtime(request_rec *r)
{
apr_exploded_time_t t;
char tstr[80];
apr_size_t len;
apr_explode_localtime(&t, apr_time_now());
apr_strftime(tstr, &len, 80, "[%d/%b/%Y:%H:%M:%S ", &t);
apr_snprintf(tstr + strlen(tstr), 80-strlen(tstr), "%c%.2d%.2d]",
t.tm_gmtoff < 0 ? '-' : '+',
t.tm_gmtoff / (60*60), t.tm_gmtoff % (60*60));
return apr_pstrdup(r->pool, tstr);
}
/*
** +-------------------------------------------------------+
** | |
** | rewriting lockfile support
** | |
** +-------------------------------------------------------+
*/
#define REWRITELOCK_MODE ( APR_UREAD | APR_UWRITE | APR_GREAD | APR_WREAD )
static void rewritelock_create(server_rec *s, apr_pool_t *p)
{
apr_status_t rc;
/* only operate if a lockfile is used */
if (lockname == NULL || *(lockname) == '\0') {
return;
}
/* fixup the path, especially for rewritelock_remove() */
lockname = ap_server_root_relative(p, lockname);
/* create the lockfile */
rc = apr_lock_create (&rewrite_mapr_lock_aquire, APR_MUTEX, APR_LOCKALL, lockname, p);
if (rc != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
"mod_rewrite: Parent could not create RewriteLock "
"file %s", lockname);
exit(1);
}
return;
}
static apr_status_t rewritelock_remove(void *data)
{
/* only operate if a lockfile is used */
if (lockname == NULL || *(lockname) == '\0') {
return APR_SUCCESS;
}
/* destroy the rewritelock */
apr_lock_destroy (rewrite_mapr_lock_aquire);
rewrite_mapr_lock_aquire = NULL;
lockname = NULL;
return(0);
}
/*
** +-------------------------------------------------------+
** | |
** | program map support
** | |
** +-------------------------------------------------------+
*/
static void run_rewritemap_programs(server_rec *s, apr_pool_t *p)
{
rewrite_server_conf *conf;
apr_file_t *fpin = NULL;
apr_file_t *fpout = NULL;
apr_file_t *fperr = NULL;
apr_array_header_t *rewritemaps;
rewritemap_entry *entries;
rewritemap_entry *map;
int i;
apr_status_t rc;
conf = ap_get_module_config(s->module_config, &rewrite_module);
/* If the engine isn't turned on,
* don't even try to do anything.
*/
if (conf->state == ENGINE_DISABLED) {
return;
}
rewritemaps = conf->rewritemaps;
entries = (rewritemap_entry *)rewritemaps->elts;
for (i = 0; i < rewritemaps->nelts; i++) {
map = &entries[i];
if (map->type != MAPTYPE_PRG) {
continue;
}
if (map->datafile == NULL
|| *(map->datafile) == '\0'
|| map->fpin != NULL
|| map->fpout != NULL ) {
continue;
}
fpin = NULL;
fpout = NULL;
rc = rewritemap_program_child(p, map->datafile,
&fpout, &fpin, &fperr);
if (rc != APR_SUCCESS || fpin == NULL || fpout == NULL) {
ap_log_error(APLOG_MARK, APLOG_ERR, rc, s,
"mod_rewrite: could not fork child for "
"RewriteMap process");
exit(1);
}
map->fpin = fpin;
map->fpout = fpout;
map->fperr = fperr;
}
return;
}
/* child process code */
static apr_status_t rewritemap_program_child(apr_pool_t *p, const char *progname,
apr_file_t **fpout, apr_file_t **fpin,
apr_file_t **fperr)
{
apr_status_t rc;
apr_procattr_t *procattr;
apr_proc_t *procnew;
#ifdef SIGHUP
apr_signal(SIGHUP, SIG_IGN);
#endif
if (((rc = apr_procattr_create(&procattr, p)) != APR_SUCCESS) ||
((rc = apr_procattr_io_set(procattr, APR_FULL_BLOCK,
APR_FULL_NONBLOCK,
APR_FULL_NONBLOCK)) != APR_SUCCESS) ||
((rc = apr_procattr_dir_set(procattr,
ap_make_dirstr_parent(p, progname)))
!= APR_SUCCESS) ||
((rc = apr_procattr_cmdtype_set(procattr, APR_PROGRAM)) != APR_SUCCESS)) {
/* Something bad happened, give up and go away. */
}
else {
procnew = apr_pcalloc(p, sizeof(*procnew));
rc = apr_proc_create(procnew, progname, NULL, NULL, procattr, p);
if (rc == APR_SUCCESS) {
apr_pool_note_subprocess(p, procnew, kill_after_timeout);
if (fpin) {
(*fpin) = procnew->in;
}
if (fpout) {
(*fpout) = procnew->out;
}
if (fperr) {
(*fperr) = procnew->err;
}
}
}
return (rc);
}
/*
** +-------------------------------------------------------+
** | |
** | environment variable support
** | |
** +-------------------------------------------------------+
*/
static char *lookup_variable(request_rec *r, char *var)
{
const char *result;
char resultbuf[LONG_STRING_LEN];
apr_exploded_time_t tm;
request_rec *rsub;
result = NULL;
/* HTTP headers */
if (strcasecmp(var, "HTTP_USER_AGENT") == 0) {
result = lookup_header(r, "User-Agent");
}
else if (strcasecmp(var, "HTTP_REFERER") == 0) {
result = lookup_header(r, "Referer");
}
else if (strcasecmp(var, "HTTP_COOKIE") == 0) {
result = lookup_header(r, "Cookie");
}
else if (strcasecmp(var, "HTTP_FORWARDED") == 0) {
result = lookup_header(r, "Forwarded");
}
else if (strcasecmp(var, "HTTP_HOST") == 0) {
result = lookup_header(r, "Host");
}
else if (strcasecmp(var, "HTTP_PROXY_CONNECTION") == 0) {
result = lookup_header(r, "Proxy-Connection");
}
else if (strcasecmp(var, "HTTP_ACCEPT") == 0) {
result = lookup_header(r, "Accept");
}
/* all other headers from which we are still not know about */
else if (strlen(var) > 5 && strncasecmp(var, "HTTP:", 5) == 0) {
result = lookup_header(r, var+5);
}
/* connection stuff */
else if (strcasecmp(var, "REMOTE_ADDR") == 0) {
result = r->connection->remote_ip;
}
else if (strcasecmp(var, "REMOTE_HOST") == 0) {
result = (char *)ap_get_remote_host(r->connection,
r->per_dir_config, REMOTE_NAME);
}
else if (strcasecmp(var, "REMOTE_USER") == 0) {
result = r->user;
}
else if (strcasecmp(var, "REMOTE_IDENT") == 0) {
result = (char *)ap_get_remote_logname(r);
}
/* request stuff */
else if (strcasecmp(var, "THE_REQUEST") == 0) { /* non-standard */
result = r->the_request;
}
else if (strcasecmp(var, "REQUEST_METHOD") == 0) {
result = r->method;
}
else if (strcasecmp(var, "REQUEST_URI") == 0) { /* non-standard */
result = r->uri;
}
else if (strcasecmp(var, "SCRIPT_FILENAME") == 0 ||
strcasecmp(var, "REQUEST_FILENAME") == 0 ) {
result = r->filename;
}
else if (strcasecmp(var, "PATH_INFO") == 0) {
result = r->path_info;
}
else if (strcasecmp(var, "QUERY_STRING") == 0) {
result = r->args;
}
else if (strcasecmp(var, "AUTH_TYPE") == 0) {
result = r->ap_auth_type;
}
else if (strcasecmp(var, "IS_SUBREQ") == 0) { /* non-standard */
result = (r->main != NULL ? "true" : "false");
}
/* internal server stuff */
else if (strcasecmp(var, "DOCUMENT_ROOT") == 0) {
result = ap_document_root(r);
}
else if (strcasecmp(var, "SERVER_ADMIN") == 0) {
result = r->server->server_admin;
}
else if (strcasecmp(var, "SERVER_NAME") == 0) {
result = ap_get_server_name(r);
}
else if (strcasecmp(var, "SERVER_ADDR") == 0) { /* non-standard */
result = r->connection->local_ip;
}
else if (strcasecmp(var, "SERVER_PORT") == 0) {
apr_snprintf(resultbuf, sizeof(resultbuf), "%u", ap_get_server_port(r));
result = resultbuf;
}
else if (strcasecmp(var, "SERVER_PROTOCOL") == 0) {
result = r->protocol;
}
else if (strcasecmp(var, "SERVER_SOFTWARE") == 0) {
result = ap_get_server_version();
}
else if (strcasecmp(var, "API_VERSION") == 0) { /* non-standard */
apr_snprintf(resultbuf, sizeof(resultbuf), "%d:%d",
MODULE_MAGIC_NUMBER_MAJOR, MODULE_MAGIC_NUMBER_MINOR);
result = resultbuf;
}
/* XXX: wow this has gotta be slow if you actually use it for a lot, recalculates exploded time for each variable */
/* underlaying Unix system stuff */
else if (strcasecmp(var, "TIME_YEAR") == 0) {
apr_explode_localtime(&tm, apr_time_now());
apr_snprintf(resultbuf, sizeof(resultbuf), "%04d", tm.tm_year + 1900);
result = resultbuf;
}
#define MKTIMESTR(format, tmfield) \
apr_explode_localtime(&tm, apr_time_now()); \
apr_snprintf(resultbuf, sizeof(resultbuf), format, tm.tmfield); \
result = resultbuf;
else if (strcasecmp(var, "TIME_MON") == 0) {
MKTIMESTR("%02d", tm_mon+1)
}
else if (strcasecmp(var, "TIME_DAY") == 0) {
MKTIMESTR("%02d", tm_mday)
}
else if (strcasecmp(var, "TIME_HOUR") == 0) {
MKTIMESTR("%02d", tm_hour)
}
else if (strcasecmp(var, "TIME_MIN") == 0) {
MKTIMESTR("%02d", tm_min)
}
else if (strcasecmp(var, "TIME_SEC") == 0) {
MKTIMESTR("%02d", tm_sec)
}
else if (strcasecmp(var, "TIME_WDAY") == 0) {
MKTIMESTR("%d", tm_wday)
}
else if (strcasecmp(var, "TIME") == 0) {
apr_explode_localtime(&tm, apr_time_now());
apr_snprintf(resultbuf, sizeof(resultbuf),
"%04d%02d%02d%02d%02d%02d", tm.tm_year + 1900,
tm.tm_mon+1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec);
result = resultbuf;
rewritelog(r, 1, "RESULT='%s'", result);
}
/* all other env-variables from the parent Apache process */
else if (strlen(var) > 4 && strncasecmp(var, "ENV:", 4) == 0) {
/* first try the internal Apache notes structure */
result = apr_table_get(r->notes, var+4);
/* second try the internal Apache env structure */
if (result == NULL) {
result = apr_table_get(r->subprocess_env, var+4);
}
/* third try the external OS env */
if (result == NULL) {
result = getenv(var+4);
}
}
#define LOOKAHEAD(subrecfunc) \
if ( \
/* filename is safe to use */ \
r->filename != NULL \
/* - and we're either not in a subrequest */ \
&& ( r->main == NULL \
/* - or in a subrequest where paths are non-NULL... */ \
|| ( r->main->uri != NULL && r->uri != NULL \
/* ...and sub and main paths differ */ \
&& strcmp(r->main->uri, r->uri) != 0))) { \
/* process a file-based subrequest */ \
rsub = subrecfunc(r->filename, r, NULL); \
/* now recursively lookup the variable in the sub_req */ \
result = lookup_variable(rsub, var+5); \
/* copy it up to our scope before we destroy sub_req's apr_pool_t */ \
result = apr_pstrdup(r->pool, result); \
/* cleanup by destroying the subrequest */ \
ap_destroy_sub_req(rsub); \
/* log it */ \
rewritelog(r, 5, "lookahead: path=%s var=%s -> val=%s", \
r->filename, var+5, result); \
/* return ourself to prevent re-pstrdup */ \
return (char *)result; \
}
/* look-ahead for parameter through URI-based sub-request */
else if (strlen(var) > 5 && strncasecmp(var, "LA-U:", 5) == 0) {
LOOKAHEAD(ap_sub_req_lookup_uri)
}
/* look-ahead for parameter through file-based sub-request */
else if (strlen(var) > 5 && strncasecmp(var, "LA-F:", 5) == 0) {
LOOKAHEAD(ap_sub_req_lookup_file)
}
/* file stuff */
else if (strcasecmp(var, "SCRIPT_USER") == 0) {
result = "<unknown>";
if (r->finfo.valid & APR_FINFO_USER) {
apr_get_username((char **)&result, r->finfo.user, r->pool);
}
}
else if (strcasecmp(var, "SCRIPT_GROUP") == 0) {
result = "<unknown>";
if (r->finfo.valid & APR_FINFO_GROUP) {
apr_get_groupname((char **)&result, r->finfo.group, r->pool);
}
}
if (result == NULL) {
return apr_pstrdup(r->pool, "");
}
else {
return apr_pstrdup(r->pool, result);
}
}
static char *lookup_header(request_rec *r, const char *name)
{
apr_array_header_t *hdrs_arr;
apr_table_entry_t *hdrs;
int i;
hdrs_arr = apr_table_elts(r->headers_in);
hdrs = (apr_table_entry_t *)hdrs_arr->elts;
for (i = 0; i < hdrs_arr->nelts; ++i) {
if (hdrs[i].key == NULL) {
continue;
}
if (strcasecmp(hdrs[i].key, name) == 0) {
apr_table_merge(r->notes, VARY_KEY_THIS, name);
return hdrs[i].val;
}
}
return NULL;
}
/*
** +-------------------------------------------------------+
** | |
** | caching support
** | |
** +-------------------------------------------------------+
*/
static cache *init_cache(apr_pool_t *p)
{
cache *c;
c = (cache *)apr_palloc(p, sizeof(cache));
if (apr_pool_create(&c->pool, p) != APR_SUCCESS)
return NULL;
c->lists = apr_array_make(c->pool, 2, sizeof(cachelist));
return c;
}
static void set_cache_string(cache *c, const char *res, int mode, time_t t,
char *key, char *value)
{
cacheentry ce;
ce.time = t;
ce.key = key;
ce.value = value;
store_cache_string(c, res, &ce);
return;
}
static char *get_cache_string(cache *c, const char *res, int mode,
time_t t, char *key)
{
cacheentry *ce;
ce = retrieve_cache_string(c, res, key);
if (ce == NULL) {
return NULL;
}
if (mode & CACHEMODE_TS) {
if (t != ce->time) {
return NULL;
}
}
else if (mode & CACHEMODE_TTL) {
if (t > ce->time) {
return NULL;
}
}
return apr_pstrdup(c->pool, ce->value);
}
static int cache_tlb_hash(char *key)
{
unsigned long n;
char *p;
n = 0;
for (p = key; *p != '\0'; p++) {
n = ((n << 5) + n) ^ (unsigned long)(*p++);
}
return n % CACHE_TLB_ROWS;
}
static cacheentry *cache_tlb_lookup(cachetlbentry *tlb, cacheentry *elt,
char *key)
{
int ix = cache_tlb_hash(key);
int i;
int j;
for (i=0; i < CACHE_TLB_COLS; ++i) {
j = tlb[ix].t[i];
if (j < 0)
return NULL;
if (strcmp(elt[j].key, key) == 0)
return &elt[j];
}
return NULL;
}
static void cache_tlb_replace(cachetlbentry *tlb, cacheentry *elt,
cacheentry *e)
{
int ix = cache_tlb_hash(e->key);
int i;
tlb = &tlb[ix];
for (i=1; i < CACHE_TLB_COLS; ++i)
tlb->t[i] = tlb->t[i-1];
tlb->t[0] = e - elt;
}
static void store_cache_string(cache *c, const char *res, cacheentry *ce)
{
int i;
int j;
cachelist *l;
cacheentry *e;
cachetlbentry *t;
int found_list;
found_list = 0;
/* first try to edit an existing entry */
for (i = 0; i < c->lists->nelts; i++) {
l = &(((cachelist *)c->lists->elts)[i]);
if (strcmp(l->resource, res) == 0) {
found_list = 1;
e = cache_tlb_lookup((cachetlbentry *)l->tlb->elts,
(cacheentry *)l->entries->elts, ce->key);
if (e != NULL) {
e->time = ce->time;
e->value = apr_pstrdup(c->pool, ce->value);
return;
}
for (j = 0; j < l->entries->nelts; j++) {
e = &(((cacheentry *)l->entries->elts)[j]);
if (strcmp(e->key, ce->key) == 0) {
e->time = ce->time;
e->value = apr_pstrdup(c->pool, ce->value);
cache_tlb_replace((cachetlbentry *)l->tlb->elts,
(cacheentry *)l->entries->elts, e);
return;
}
}
}
}
/* create a needed new list */
if (!found_list) {
l = apr_array_push(c->lists);
l->resource = apr_pstrdup(c->pool, res);
l->entries = apr_array_make(c->pool, 2, sizeof(cacheentry));
l->tlb = apr_array_make(c->pool, CACHE_TLB_ROWS,
sizeof(cachetlbentry));
for (i=0; i<CACHE_TLB_ROWS; ++i) {
t = &((cachetlbentry *)l->tlb->elts)[i];
for (j=0; j<CACHE_TLB_COLS; ++j)
t->t[j] = -1;
}
}
/* create the new entry */
for (i = 0; i < c->lists->nelts; i++) {
l = &(((cachelist *)c->lists->elts)[i]);
if (strcmp(l->resource, res) == 0) {
e = apr_array_push(l->entries);
e->time = ce->time;
e->key = apr_pstrdup(c->pool, ce->key);
e->value = apr_pstrdup(c->pool, ce->value);
cache_tlb_replace((cachetlbentry *)l->tlb->elts,
(cacheentry *)l->entries->elts, e);
return;
}
}
/* not reached, but when it is no problem... */
return;
}
static cacheentry *retrieve_cache_string(cache *c, const char *res, char *key)
{
int i;
int j;
cachelist *l;
cacheentry *e;
for (i = 0; i < c->lists->nelts; i++) {
l = &(((cachelist *)c->lists->elts)[i]);
if (strcmp(l->resource, res) == 0) {
e = cache_tlb_lookup((cachetlbentry *)l->tlb->elts,
(cacheentry *)l->entries->elts, key);
if (e != NULL)
return e;
for (j = 0; j < l->entries->nelts; j++) {
e = &(((cacheentry *)l->entries->elts)[j]);
if (strcmp(e->key, key) == 0) {
return e;
}
}
}
}
return NULL;
}
/*
** +-------------------------------------------------------+
** | |
** | misc functions
** | |
** +-------------------------------------------------------+
*/
static char *subst_prefix_path(request_rec *r, char *input, char *match,
const char *subst)
{
char matchbuf[LONG_STRING_LEN];
char substbuf[LONG_STRING_LEN];
char *output;
int l;
output = input;
/* first create a match string which always has a trailing slash */
l = apr_cpystrn(matchbuf, match, sizeof(matchbuf)) - matchbuf;
if (matchbuf[l-1] != '/') {
matchbuf[l] = '/';
matchbuf[l+1] = '\0';
l++;
}
/* now compare the prefix */
if (strncmp(input, matchbuf, l) == 0) {
rewritelog(r, 5, "strip matching prefix: %s -> %s", output, output+l);
output = apr_pstrdup(r->pool, output+l);
/* and now add the base-URL as replacement prefix */
l = apr_cpystrn(substbuf, subst, sizeof(substbuf)) - substbuf;
if (substbuf[l-1] != '/') {
substbuf[l] = '/';
substbuf[l+1] = '\0';
l++;
}
if (output[0] == '/') {
rewritelog(r, 4, "add subst prefix: %s -> %s%s",
output, substbuf, output+1);
output = apr_pstrcat(r->pool, substbuf, output+1, NULL);
}
else {
rewritelog(r, 4, "add subst prefix: %s -> %s%s",
output, substbuf, output);
output = apr_pstrcat(r->pool, substbuf, output, NULL);
}
}
return output;
}
/*
**
** own command line parser which don't have the '\\' problem
**
*/
static int parseargline(char *str, char **a1, char **a2, char **a3)
{
char *cp;
int isquoted;
#define SKIP_WHITESPACE(cp) \
for ( ; *cp == ' ' || *cp == '\t'; ) { \
cp++; \
};
#define CHECK_QUOTATION(cp,isquoted) \
isquoted = 0; \
if (*cp == '"') { \
isquoted = 1; \
cp++; \
}
#define DETERMINE_NEXTSTRING(cp,isquoted) \
for ( ; *cp != '\0'; cp++) { \
if ( (isquoted && (*cp == ' ' || *cp == '\t')) \
|| (*cp == '\\' && (*(cp+1) == ' ' || *(cp+1) == '\t'))) { \
cp++; \
continue; \
} \
if ( (!isquoted && (*cp == ' ' || *cp == '\t')) \
|| (isquoted && *cp == '"') ) { \
break; \
} \
}
cp = str;
SKIP_WHITESPACE(cp);
/* determine first argument */
CHECK_QUOTATION(cp, isquoted);
*a1 = cp;
DETERMINE_NEXTSTRING(cp, isquoted);
if (*cp == '\0') {
return 1;
}
*cp++ = '\0';
SKIP_WHITESPACE(cp);
/* determine second argument */
CHECK_QUOTATION(cp, isquoted);
*a2 = cp;
DETERMINE_NEXTSTRING(cp, isquoted);
if (*cp == '\0') {
*cp++ = '\0';
*a3 = NULL;
return 0;
}
*cp++ = '\0';
SKIP_WHITESPACE(cp);
/* again check if there are only two arguments */
if (*cp == '\0') {
*cp++ = '\0';
*a3 = NULL;
return 0;
}
/* determine second argument */
CHECK_QUOTATION(cp, isquoted);
*a3 = cp;
DETERMINE_NEXTSTRING(cp, isquoted);
*cp++ = '\0';
return 0;
}
static void add_env_variable(request_rec *r, char *s)
{
char var[MAX_STRING_LEN];
char val[MAX_STRING_LEN];
char *cp;
int n;
if ((cp = strchr(s, ':')) != NULL) {
n = ((cp-s) > MAX_STRING_LEN-1 ? MAX_STRING_LEN-1 : (cp-s));
memcpy(var, s, n);
var[n] = '\0';
apr_cpystrn(val, cp+1, sizeof(val));
apr_table_set(r->subprocess_env, var, val);
rewritelog(r, 5, "setting env variable '%s' to '%s'", var, 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
* and URIs aren't NULL and sub/main URIs differ
*/
return (r->main == NULL ||
(r->main->uri != NULL && r->uri != NULL &&
strcmp(r->main->uri, r->uri) != 0));
}
/*
**
** stat() for only the prefix of a path
**
*/
static int prefix_stat(const char *path, apr_finfo_t *sb)
{
char curpath[LONG_STRING_LEN];
char *cp;
apr_cpystrn(curpath, path, sizeof(curpath));
if (curpath[0] != '/') {
return 0;
}
if ((cp = strchr(curpath+1, '/')) != NULL) {
*cp = '\0';
}
if (apr_stat(sb, curpath, APR_FINFO_MIN, NULL) == APR_SUCCESS) {
return 1;
}
else {
return 0;
}
}
/*
**
** Lexicographic Compare
**
*/
static int compare_lexicography(char *cpNum1, char *cpNum2)
{
int i;
int n1, n2;
n1 = strlen(cpNum1);
n2 = strlen(cpNum2);
if (n1 > n2) {
return 1;
}
if (n1 < n2) {
return -1;
}
for (i = 0; i < n1; i++) {
if (cpNum1[i] > cpNum2[i]) {
return 1;
}
if (cpNum1[i] < cpNum2[i]) {
return -1;
}
}
return 0;
}
/*
**
** Bracketed expression handling
** s points after the opening bracket
**
*/
static char *find_closing_bracket(char *s, int left, int right)
{
int depth;
for (depth = 1; *s; ++s) {
if (*s == right && --depth == 0) {
return s;
}
else if (*s == left) {
++depth;
}
}
return NULL;
}
static char *find_char_in_brackets(char *s, int c, int left, int right)
{
int depth;
for (depth = 1; *s; ++s) {
if (*s == c && depth == 1) {
return s;
}
else if (*s == right && --depth == 0) {
return NULL;
}
else if (*s == left) {
++depth;
}
}
return NULL;
}
/*
**
** Module paraphernalia
**
*/
#ifdef NETWARE
int main(int argc, char *argv[])
{
ExitThread(TSR_THREAD, 0);
}
#endif
/* the apr_table_t of commands we provide */
static const command_rec command_table[] = {
AP_INIT_FLAG( "RewriteEngine", cmd_rewriteengine, NULL, OR_FILEINFO,
"On or Off to enable or disable (default) the whole "
"rewriting engine"),
AP_INIT_ITERATE( "RewriteOptions", cmd_rewriteoptions, NULL, OR_FILEINFO,
"List of option strings to set"),
AP_INIT_TAKE1( "RewriteBase", cmd_rewritebase, NULL, OR_FILEINFO,
"the base URL of the per-directory context"),
AP_INIT_RAW_ARGS("RewriteCond", cmd_rewritecond, NULL, OR_FILEINFO,
"an input string and a to be applied regexp-pattern"),
AP_INIT_RAW_ARGS("RewriteRule", cmd_rewriterule, NULL, OR_FILEINFO,
"an URL-applied regexp-pattern and a substitution URL"),
AP_INIT_TAKE2( "RewriteMap", cmd_rewritemap, NULL, RSRC_CONF,
"a mapname and a filename"),
AP_INIT_TAKE1( "RewriteLock", cmd_rewritelock, NULL, RSRC_CONF,
"the filename of a lockfile used for inter-process "
"synchronization"),
AP_INIT_TAKE1( "RewriteLog", cmd_rewritelog, NULL, RSRC_CONF,
"the filename of the rewriting logfile"),
AP_INIT_TAKE1( "RewriteLogLevel", cmd_rewriteloglevel, NULL, RSRC_CONF,
"the level of the rewriting logfile verbosity "
"(0=none, 1=std, .., 9=max)"),
{ NULL }
};
static void register_hooks(apr_pool_t *p)
{
ap_hook_handler(handler_redirect, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_post_config(init_module,NULL,NULL,APR_HOOK_MIDDLE);
ap_hook_child_init(init_child,NULL,NULL,APR_HOOK_MIDDLE);
ap_hook_fixups(hook_fixup,NULL,NULL,APR_HOOK_FIRST);
ap_hook_translate_name(hook_uri2file,NULL,NULL,APR_HOOK_FIRST);
ap_hook_type_checker(hook_mimetype,NULL,NULL,APR_HOOK_MIDDLE);
}
/* the main config structure */
module AP_MODULE_DECLARE_DATA rewrite_module = {
STANDARD20_MODULE_STUFF,
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, /* apr_table_t of config file commands */
register_hooks /* register hooks */
};
/*EOF*/