From e21cdb93358110f749cf6cf7876526e8b9a1a889 Mon Sep 17 00:00:00 2001
From: Noirin Plunkett This module uses a rule-based rewriting engine (based on a
regular-expression parser) to rewrite requested URLs on the
fly. It supports an unlimited number of rules and an
- unlimited number of attached rule conditions for each rule to
+ unlimited number of attached rule conditions for each rule, to
provide a really flexible and powerful URL manipulation
mechanism. The URL manipulations can depend on various tests,
- for instance server variables, environment variables, HTTP
- headers, time stamps and even external database lookups in
- various formats can be used to achieve a really granular URL
+ of server variables, environment variables, HTTP
+ headers, or time stamps. Even external database lookups in
+ various formats can be used to achieve highly granular URL
matching. This module operates on the full URLs (including the
path-info part) both in per-server context
(httpd.conf
) and per-directory context
- (.htaccess
) and can even generate query-string
+ (.htaccess
) and can generate query-string
parts on result. The rewritten result can lead to internal
sub-processing, external request redirection or even to an
internal proxy throughput.
Notice: These variables hold the URI/URL as they were - initially requested, i.e., before any - rewriting. This is important because the rewriting process is + initially requested, that is, before any + rewriting. This is important to note because the rewriting process is primarily used to rewrite logical URLs to physical pathnames.
@@ -147,12 +147,13 @@ laterThe
inherit
}
- When such a construct occurs the map MapName is +
When such a construct occurs, the map MapName is
consulted and the key LookupKey is looked-up. If the
key is found, the map-function construct is substituted by
SubstValue. If the key is not found then it is
@@ -435,23 +436,23 @@ $ txt2dbm map.txt map.db
MapType: int
, MapSource: Internal Apache
function
-
Here the source is an internal Apache function. +
Here, the source is an internal Apache function. Currently you cannot create your own, but the following - functions already exists:
+ functions already exist:Here the source is a program, not a map file. To
- create it you can use the language of your choice, but
- the result has to be a executable (i.e., either
+ create it you can use a language of your choice, but
+ the result has to be an executable program (either
object-code or a script with the magic cookie trick
'#!/path/to/interpreter
' as the first
line).
This program is started once at startup of the Apache
- servers and then communicates with the rewriting engine
- over its stdin
and stdout
+
This program is started once, when the Apache server
+ is started, and then communicates with the rewriting engine
+ via its stdin
and stdout
file-handles. For each map-function lookup it will
receive the key to lookup as a newline-terminated string
on stdin
. It then has to give back the
@@ -495,18 +496,18 @@ while (<STDIN>) {
But be very careful:
stdout
! This will cause a deadloop! Hence
- the ``$|=1
'' in the above example...stdout
. Avoid this, as it will cause a deadloop!
+ ``$|=1
'' is used above, to prevent this..htaccess
). There it will act locally,
- i.e., the local directory prefix is stripped at this
- stage of processing and your rewriting rules act only on the
- remainder. At the end it is automatically added back to the
+ (.htaccess
). In such a case, it will act locally,
+ stripping the local directory prefix before processing, and applying
+ rewrite rules only to the remainder. When processing is complete, the
+ prefix is automatically added back to the
path. The default setting is; When a substitution occurs for a new URL, this module has
to re-inject the URL into the server processing. To be able
to do this it needs to know what the corresponding URL-prefix
or URL-base is. By default this prefix is the corresponding
- filepath itself. But at most websites URLs are NOT
+ filepath itself. However, for most websites, URLs are NOT
directly related to physical filename paths, so this
- assumption will usually be wrong! There you have to
+ assumption will often be wrong! Therefore, you can
use the RewriteBase
directive to specify the
correct URL-prefix.
.htaccess
-files where you want to use This seems very complicated but is - the correct Apache internal processing, because the - per-directory rewriting comes too late in the - process. So, when it occurs the (rewritten) request - has to be re-injected into the Apache kernel! BUT: - While this seems like a serious overhead, it really - isn't, because this re-injection happens fully - internally to the Apache server and the same - procedure is used by many other operations inside - Apache. So, you can be sure the design and - implementation is correct.
+This seems very complicated, but is in fact + correct Apache internal processing. Because the + per-directory rewriting comes late in the + process, the rewritten request + has to be re-injected into the Apache kernel. + This is not the serious overhead it may seem to be - + this re-injection is completely internal to the + Apache server (and the same procedure is used by + many other operations within Apache).
@@ -636,63 +635,44 @@ Result:The
TestString is a string which can contains the
+ rule condition. One or more
TestString is a string which can contain the following expanded constructs in addition to plain text:
- $N
-
RewriteRule
directive (the one
- following the current bunch of RewriteCond
- directives).
+ backreferences of the form $N
+ (0 <= N <= 9), which provide access to the grouped
+ parts (in parentheses) of the pattern, from the
+ RewriteRule
which is subject to the current
+ set of RewriteCond
conditions..
- %N
-
RewriteCond
directive in the current bunch
+ backreferences of the form %N
+ (1 <= N <= 9), which provide access to the grouped
+ parts (again, in parentheses) of the pattern, from the last matched
+ RewriteCond
in the current set
of conditions.
- ${mapname:key|default}
-
${mapname:key|default}
.
See the documentation for
RewriteMap for more details.
%{
NAME_OF_VARIABLE
}
-
These variables all
correspond to the similarly named HTTP
MIME-headers, C variables of the Apache server or
struct tm
fields of the Unix system.
Most are documented elsewhere in the Manual or in
the CGI specification. Those that are special to
- mod_rewrite include:
IS_SUBREQ
Special Notes:
+Other things you should be aware of:
filename
field of the internal
request_rec
structure of the Apache server.
- The first name is just the commonly known CGI variable name
- while the second is the consistent counterpart to
+ The first name is the commonly known CGI variable name
+ while the second is the appropriate counterpart of
REQUEST_URI (which contains the value of the
uri
field of request_rec
).%{ENV:variable}
where variable can be
- any environment variable. This is looked-up via internal
+ %{ENV:variable}
, where variable can be
+ any environment variable, is also available.
+ This is looked-up via internal
Apache structures and (if not found there) via
getenv()
from the Apache server process.%{SSL:variable}
where variable is the
+ %{SSL:variable}
, where variable is the
name of an SSL environment
- variable; this can be used whether or not
+ variable, can be used whether or not
%{SSL:SSL_CIPHER_USEKEYSIZE}
may expand to
128
.%{HTTP:header}
where header can be
- any HTTP MIME-header name. This is looked-up from the HTTP
- request. Example: %{HTTP:Proxy-Connection}
is
+ %{HTTP:header}
, where header can be
+ any HTTP MIME-header name, can always be used to obtain the
+ value of a header sent in the HTTP request.
+ Example: %{HTTP:Proxy-Connection}
is
the value of the HTTP header
``Proxy-Connection:
''.%{LA-U:variable}
for look-aheads which perform
+ %{LA-U:variable}
can be used for look-aheads which perform
an internal (URL-based) sub-request to determine the final
- value of variable. Use this when you want to use a
- variable for rewriting which is actually set later in an
- API phase and thus is not available at the current stage.
- For instance when you want to rewrite according to the
+ value of variable. This can be used to access
+ variable for rewriting which is not available at the current
+ stage, but will be set in a later phase.
+ For instance, to rewrite according to the
REMOTE_USER
variable from within the
- per-server context (httpd.conf
file) you have
- to use %{LA-U:REMOTE_USER}
because this
- variable is set by the authorization phases which come
- after the URL translation phase where mod_rewrite
- operates. On the other hand, because mod_rewrite implements
+ per-server context (httpd.conf
file) you must
+ use %{LA-U:REMOTE_USER}
- this
+ variable is set by the authorization phases, which come
+ after the URL translation phase (during which mod_rewrite
+ operates).
On the other hand, because mod_rewrite implements
its per-directory context (.htaccess
file) via
the Fixup phase of the API and because the authorization
phases come before this phase, you just can use
- %{REMOTE_USER}
there.
%{REMOTE_USER}
in that context.
- %{LA-F:variable}
which performs an internal
- (filename-based) sub-request to determine the final value
- of variable. Most of the time this is the same as
+ %{LA-F:variable}
can be used to perform an internal
+ (filename-based) sub-request, to determine the final value
+ of variable. Most of the time, this is the same as
LA-U above.CondPattern is the condition pattern, - i.e., a regular expression which is applied to the - current instance of the TestString, i.e., - TestString is evaluated and then matched against + a regular expression which is applied to the + current instance of the TestString. + TestString is first evaluated, before being matched against CondPattern.
Remember: CondPattern is a @@ -907,98 +889,94 @@ Result: use one of the following:
""
(two quotation marks) this
+ Treats the CondPattern as a plain string and
+ compares it lexicographically to TestString. True if
+ TestString is lexicographically equal to
+ CondPattern (the two strings are exactly
+ equal, character for character). If CondPattern
+ is ""
(two quotation marks) this
compares TestString to the empty string.Additionally you can set special flags for - CondPattern by appending
-+
[
flags]
-
-
- as the third argument to the RewriteCond
- directive. Flags is a comma-separated list of the
- following flags:
RewriteCond
+ directive, where flags is a comma-separated list of any of the
+ following flags:nocase|NC
'
(no case)ornext|OR
'
(or next condition)Example:
@@ -1042,13 +1021,16 @@ RewriteRule ^/$ /homepage.std.html [L] -Interpretation: If you use Netscape Navigator as your - browser (which identifies itself as 'Mozilla'), then you - get the max homepage, which includes Frames, etc. - If you use the Lynx browser (which is Terminal-based), then - you get the min homepage, which contains no images, no - tables, etc. If you use any other browser you get - the standard homepage.
+Explanation: If you use a browser which identifies itself + as 'Mozilla' (including Netscape Navigator, Mozilla etc), then you + get the max homepage (which could include frames, or other special + features). + If you use the Lynx browser (which is terminal-based), then + you get the min homepage (which could be a version designed for + easy, text-only browsing). + If neither of these conditions apply (you use any other browser, + or your browser identifies itself as something non-standard), you get + the std (standard) homepage.
The
Pattern is a perl compatible regular - expression which gets applied to the current URL. Here - ``current'' means the value of the URL when this rule gets + expression, which is applied to the current URL. + ``Current'' means the value of the URL when this rule is applied. This may not be the originally requested URL, - because any number of rules may already have matched and made - alterations to it.
+ which may already have matched a previous rule, and have been + altered. -Some hints about the syntax of Some hints on the syntax of For more information about regular expressions have a look at the
+ For more information about regular expressions, have a look at the
perl regular expression manpage ("perldoc
perlre"). If you are interested in more detailed
information about regular expressions and their variants
- (POSIX regex etc.) have a look at the
- following dedicated book on this topic:
Text:
.
Any single character
- [
chars]
Character class: One of chars
- [^
chars]
Character class: None of chars
+ [
chars]
Character class: Any character of the class ``chars''
+ [^
chars]
Character class: Not a character of the class ``chars''
text1|
text2 Alternative: text1 or text2
Quantifiers:
- ?
0 or 1 of the preceding text
- *
0 or N of the preceding text (N > 0)
- +
1 or N of the preceding text (N > 1)
+ ?
0 or 1 occurrences of the preceding text
+ *
0 or N occurrences of the preceding text (N > 0)
+ +
1 or N occurrences of the preceding text (N > 1)
Grouping:
(
text)
Grouping of text
- (either to set the borders of an alternative or
- for making backreferences where the Nth group can
- be used on the RHS of a RewriteRule with $
N)
+ (used either to set the borders of an alternative as above, or
+ to make backreferences, where the Nth group can
+ be referred to on the RHS of a RewriteRule as $
N)
Anchors:
- ^
Start of line anchor
- $
End of line anchor
+ ^
Start-of-line anchor
+ $
End-of-line anchor
Escaping:
- \
char escape that particular char
- (for instance to specify the chars ".[]()
" etc.)
+ \
char escape the given char
+ (for instance, to specify the chars ".[]()
" etc.)
Mastering Regular Expressions, 2nd Edition
@@ -1125,34 +1105,32 @@ RewriteRule ^/$ /homepage.std.html [L]
ISBN 0-596-00289-0
Additionally in mod_rewrite the NOT character
- ('!
') is a possible pattern prefix. This gives
- you the ability to negate a pattern; to say, for instance:
+
In mod_rewrite, the NOT character
+ ('!
') is also available as a possible pattern
+ prefix. This enables you to negate a pattern; to say, for instance:
``if the current URL does NOT match this
pattern''. This can be used for exceptional cases, where
it is easier to match the negative pattern, or as a last
default rule.
$N
in the substitution
- string!
+$N
in the substitution string!
Substitution of a - rewriting rule is the string which is substituted for (or - replaces) the original URL for which Pattern - matched. Beside plain text you can use
+The substitution of a + rewrite rule is the string which is substituted for (or + replaces) the original URL which Pattern + matched. In addition to plain text, it can include
$N
to the RewriteRule
+ $N
) to the RewriteRule
pattern%N
to the last matched
+ %N
) to the last matched
RewriteCond pattern${mapname:key|default}
)Back-references are $
N
- (N=0..9) identifiers which will be replaced
+
Back-references are identifiers of the form
+ $
N
+ (N=0..9), which will be replaced
by the contents of the Nth group of the
matched Pattern. The server-variables are the same
as for the TestString of a RewriteCond
directive. The mapping-functions come from the
RewriteMap
directive and are explained there.
- These three types of variables are expanded in the order of
- the above list.
As already mentioned above, all the rewriting rules are
- applied to the Substitution (in the order of
- definition in the config file). The URL is completely
+ As already mentioned, all rewrite rules are
+ applied to the Substitution (in the in which they are defined
+ in the config file). The URL is completely
replaced by the Substitution and the
- rewriting process goes on until there are no more rules
- unless explicitly terminated by a
+ rewriting process continues until all rules have been applied,
+ or it is explicitly terminated by a
There is a special substitution string named
' The Pattern will not match against the query string.
- Instead, you must use a L
flag - see below.-
' which means: NO
- substitution! Sounds silly? No, it is useful to
- provide rewriting rules which only match
- some URLs but do no substitution, e.g., in
- conjunction with the C (chain) flag to be
- able to have more than one pattern to be applied before a
- substitution occurs.%{QUERY_STRING}
variable. You can, however, create
- URLs in the substitution string containing a query string
- part. Just use a question mark inside the substitution string to
- indicate that the following stuff should be re-injected into the
- query string. When you want to erase an existing query string,
- end the substitution string with just the question mark. To
- combine a new query string with an old one, use the
- [QSA]
flag (see below).
There is a special feature:
- When you prefix a substitution field with
- http://
thishost[:thisport]
- then mod_rewrite automatically strips it
- out. This auto-reduction on implicit external redirect
- URLs is a useful and important feature when used in
- combination with a mapping-function which generates the
- hostname part. Have a look at the first example in the
- example section below to understand this.
Remember: An unconditional external
- redirect to your own server will not work with the prefix
- http://thishost
because of this feature. To
- achieve such a self-redirect, you have to use the
- R-flag (see below).
Additionally you can set special flags for Substitution by - appending
- -
- [
flags]
-
+ appending [
flags]
as the third argument to the RewriteRule
- directive. Flags is a comma-separated list of the
+ directive. Flags is a comma-separated list of any of the
following flags:
.www
'' part inside a per-directory rule set
+ rules are skipped. For instance, it can be used to remove the
+ ``.www
'' part, inside a per-directory rule set,
when you let an external redirect happen (where the
- ``.www
'' part should not to occur!).
+ ``.www
'' part should not occur!).
cookie|CO=
NAME:VAL:domain[:lifetime[:path]]'
(set cookie)env|E=
VAR:VAL'
(set environment variable)$N
and
- %N
which will be expanded. You can use this
- flag more than once to set more than one variable. The
- variables can be later dereferenced in many situations, but
- usually from within XSSI (via <!--#echo
- var="VAR"-->
) or CGI (e.g.
- $ENV{'VAR'}
). Additionally you can dereference
- it in a following RewriteCond pattern via
- %{ENV:VAR}
. Use this to strip but remember
- information from URLs.$N
and
+ %N
) which will be expanded. You can use this
+ flag more than once, to set more than one variable. The
+ variables can later be dereferenced in many situations, most commonly
+ from within XSSI (via <!--#echo
+ var="VAR"-->
) or CGI ($ENV{'VAR'}
).
+ You can also dereference the variable in a later RewriteCond pattern, using
+ %{ENV:VAR}
. Use this to strip
+ information from URLs, while maintaining a record of that information.
forbidden|F
' (force URL
to be forbidden)gone|G
' (force URL to be
gone)mod_alias
directive
- ScriptAlias
which internally forces all files
+ simulate the cgi-script
''.
last|L
'
(last rule)last
command or the break
command
- from the C language. Use this flag to prevent the currently
+ in C. Use this flag to prevent the currently
rewritten URL from being rewritten further by following
rules. For example, use it to rewrite the root-path URL
('/
') to a real one, e.g.,
@@ -1309,20 +1250,20 @@ When using the NOT character
next|N
'
(next round)next
command or
- the continue
command from the C language. Use
- this flag to restart the rewriting process, i.e.,
+ the continue
command in C. Use
+ this flag to restart the rewriting process -
to immediately go to the top of the loop.nocase|NC
'
(no case)noescape|NE
'
(no URI escaping of
output)/foo/zed
' into a safe
request for '/bar?arg=P1=zed
'.
nosubreq|NS
' (used only if
- no internal
- sub-request)nosubreq|NS
'
+ (not for internal
+ sub-requests)mod_include
tries to find out
+ in Apache when index.xxx
). On sub-requests it is not
- always useful and even sometimes causes a failure to if
+ (index.xxx
files). On sub-requests it is not
+ always useful, and can even cause errors, if
the complete set of rules are applied. Use this flag to
exclude some rules.Use the following rule for your decision: whenever you - prefix some URLs with CGI-scripts to force them to be - processed by the CGI-script, the chance is high that you - will run into problems (or even overhead) on - sub-requests. In these cases, use this flag.
+ To decide whether or not to use this rule: if you + prefix URLs with CGI-scripts, to force them to be + processed by the CGI-script, it's likely that you + will run into problems (or significant overhead) on + sub-requests. In these cases, use this flag.proxy|P
' (force
proxy)http://
hostname) which can be
- handled by the Apache proxy module. If not you get an
+ handled by the Apache proxy module. If not, you will get an
error from the proxy module. Use this flag to achieve a
more powerful implementation of the ProxyPass directive,
- to map some remote stuff into the namespace of the local
+ to map remote content into the namespace of the local
server.
- Notice:
Note:
passthrough|PT
'
(pass through to next
handler)uri
field of the internal
request_rec
structure to the value of the
filename
field. This flag is just a hack to
- be able to post-process the output of
- RewriteRule
directives by
+ enable post-processing of the output of
+ RewriteRule
directives, using
Alias
, ScriptAlias
,
- Redirect
, etc. directives from
- other URI-to-filename translators. A trivial example to
- show the semantics: If you want to rewrite
- /abc
to /def
via the rewriting
- engine of mod_rewrite
and then
- /def
to /ghi
with
- mod_alias
:
+ Redirect
, and other directives from
+ various URI-to-filename translators. For example, to rewrite
+ /abc
to /def
using
+ /def
to /ghi
using
+ PT
flag then
- mod_rewrite
will do its job fine,
- i.e., it rewrites uri=/abc/...
to
+ If you omit the PT
flag,
+ mod_rewrite
will rewrite
+ uri=/abc/...
to
filename=/def/...
as a full API-compliant
URI-to-filename translator should do. Then
- mod_alias
comes and tries to do a
- URI-to-filename transition which will not work.
+ mod_alias
will try to do a
+ URI-to-filename transition, which will fail.
- Note: You have to use this flag if you want to
- intermix directives of different modules which contain
+ Note: You must use this flag if you want to
+ mix directives from different modules which allow
URL-to-filename translators. The typical example
- is the use of mod_alias
and
- mod_rewrite
..
qsappend|QSA
'
(query string
append)redirect|R
[=code]' (force redirect)http://thishost[:thisport]/
(which makes the
new URL a URI) to force a external redirection. If no
- code is given a HTTP response of 302 (MOVED
- TEMPORARILY) is used. If you want to use other response
- codes in the range 300-400 just specify them as a number
+ code is given, a HTTP response of 302 (MOVED
+ TEMPORARILY) will be returned. If you want to use other response
+ codes in the range 300-400, simply specify the appropriate number
or use one of the following symbolic names:
temp
(default), permanent
,
- seeother
. Use it for rules which should
- canonicalize the URL and give it back to the client,
- e.g., translate ``/~
'' into
- ``/u/
'' or always append a slash to
+ seeother
. Use this for rules to
+ canonicalize the URL and return it to the client - to
+ translate ``/~
'' into
+ ``/u/
'', or to always append a slash to
/u/
user, etc.Note: When you use this flag, make
- sure that the substitution field is a valid URL! If not,
- you are redirecting to an invalid location! And remember
- that this flag itself only prefixes the URL with
- http://thishost[:thisport]/
, rewriting
- continues. Usually you also want to stop and do the
- redirection immediately. To stop the rewriting you also
- have to provide the 'L' flag.
http://thishost[:thisport]/
to the URL, and rewriting
+ will continue. Usually, you will want to stop rewriting at this point,
+ and redirect immediately. To stop rewriting, you should add
+ the 'L' flag.
skip|S
=num'
(skip next rule(s))skip=N
where N is the number of rules in the
+ skip=N
, where N is the number of rules in the
else-clause. (This is not the same as the
'chain|C' flag!)type|T
=MIME-type'
(force MIME type).php
files to
be displayed by mod_php
if they are called with
the .phps
extension:
@@ -1484,40 +1420,70 @@ When using the NOT character
RewriteRule ^(.+\.php)s$ $1 [T=application/x-httpd-php-source]
-
-
RewriteEngine On
'' in these files
+ and ``Options
+ FollowSymLinks
'' must be enabled. If your
+ administrator has disabled override of
+ FollowSymLinks
for a user's directory, then
+ you cannot use the rewrite engine. This restriction is
+ required for security reasons.
+There is one exception: If a substitution string
- starts with ``http://
'' then the directory
- prefix will not be added and an
- external redirect or proxy throughput (if flag
- P is used!) is forced!
http://
'', then the directory
+ prefix will not be added ,and an
+ external redirect (or proxy throughput, if using flag
+ P) is forced!
RewriteEngine On
'' in these files
- and ``Options
- FollowSymLinks
'' must be enabled. If your
- administrator has disabled override of
- FollowSymLinks
for a user's directory, then
- you cannot use the rewriting engine. This restriction is
- needed for security reasons.
+
+ When you prefix a substitution field with
+ http://thishost[:thisport]
,
Remember: An unconditional external
+ redirect to your own server will not work with the prefix
+ http://thishost
because of this feature. To
+ achieve such a self-redirect, you have to use the
+ R-flag (see below).
The Pattern will not be matched against the query string.
+ To do this, you must use a %{QUERY_STRING}
variable. You can, however, create
+ URLs in the substitution string, containing a query string
+ part. Simply use a question mark inside the substitution string, to
+ indicate that the following text should be re-injected into the
+ query string. When you want to erase an existing query string,
+ end the substitution string with just a question mark. To
+ combine new and old query strings, use the
+ [QSA]
flag (see above).
Here are all possible substitution combinations and their +
Here are all possible substitution combinations and their meanings:
Inside per-server configuration
@@ -1529,25 +1495,25 @@ directory which is not always possible.
Inside per-directory configuration for
Example: We want to rewrite URLs of the form
- into
- We take the rewrite mapfile from above and save it under
-
Given Rule Resulting Substitution
---------------------------------------------- ----------------------------------
-^/somepath(.*) otherpath$1 not supported, because invalid!
+^/somepath(.*) otherpath$1 invalid, not supported
-^/somepath(.*) otherpath$1 [R] not supported, because invalid!
+^/somepath(.*) otherpath$1 [R] invalid, not supported
-^/somepath(.*) otherpath$1 [P] not supported, because invalid!
+^/somepath(.*) otherpath$1 [P] invalid, not supported
---------------------------------------------- ----------------------------------
^/somepath(.*) /otherpath$1 /otherpath/pathinfo
^/somepath(.*) /otherpath$1 [R] http://thishost/otherpath/pathinfo
via external redirection
-^/somepath(.*) /otherpath$1 [P] not supported, because silly!
+^/somepath(.*) /otherpath$1 [P] doesn't make sense, not supported
---------------------------------------------- ----------------------------------
^/somepath(.*) http://thishost/otherpath$1 /otherpath/pathinfo
^/somepath(.*) http://thishost/otherpath$1 [R] http://thishost/otherpath/pathinfo
via external redirection
-^/somepath(.*) http://thishost/otherpath$1 [P] not supported, because silly!
+^/somepath(.*) http://thishost/otherpath$1 [P] doesn't make sense, not supported
---------------------------------------------- ----------------------------------
^/somepath(.*) http://otherhost/otherpath$1 http://otherhost/otherpath/pathinfo
via external redirection
@@ -1562,8 +1528,7 @@ directory which is not always possible.
/somepath
- (i.e., file .htaccess
in dir
- /physical/path/to/somepath
containing
+ (/physical/path/to/somepath/.htacccess
, with
RewriteBase /somepath
)
for request ``GET
/somepath/localpath/pathinfo
'':
@@ -1577,21 +1542,21 @@ directory which is not always possible.
^localpath(.*) otherpath$1 [R] http://thishost/somepath/otherpath/pathinfo
via external redirection
-^localpath(.*) otherpath$1 [P] not supported, because silly!
+^localpath(.*) otherpath$1 [P] doesn't make sense, not supported
---------------------------------------------- ----------------------------------
^localpath(.*) /otherpath$1 /otherpath/pathinfo
^localpath(.*) /otherpath$1 [R] http://thishost/otherpath/pathinfo
via external redirection
-^localpath(.*) /otherpath$1 [P] not supported, because silly!
+^localpath(.*) /otherpath$1 [P] doesn't make sense, not supported
---------------------------------------------- ----------------------------------
^localpath(.*) http://thishost/otherpath$1 /otherpath/pathinfo
^localpath(.*) http://thishost/otherpath$1 [R] http://thishost/otherpath/pathinfo
via external redirection
-^localpath(.*) http://thishost/otherpath$1 [P] not supported, because silly!
+^localpath(.*) http://thishost/otherpath$1 [P] doesn't make sense, not supported
---------------------------------------------- ----------------------------------
^localpath(.*) http://otherhost/otherpath$1 http://otherhost/otherpath/pathinfo
via external redirection
@@ -1603,35 +1568,6 @@ directory which is not always possible.
^localpath(.*) http://otherhost/otherpath$1 [P] http://otherhost/otherpath/pathinfo
via internal proxy
/
Language /~
- Realname /.../
File
- /u/
Username /.../
- File .
Language
- /path/to/file/map.txt
. Then we only have to
- add the following lines to the Apache server configuration
- file:
-RewriteLog /path/to/file/rewrite.log
-RewriteMap real-to-user txt:/path/to/file/map.txt
-RewriteRule ^/([^/]+)/~([^/]+)/(.*)$ /u/${real-to-user:$2|nobody}/$3.$1
-
-