This flag chains the current rule with the next rule (which itself
can be chained with the following rule, etc.). This has the following
effect: if a rule matches, then processing continues as usual, i.e.,
the flag has no effect. If the rule does not match, then all following
chained rules are skipped. For instance, use it 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!).

This sets a cookie on the client's browser. The cookie's name is
specified by NAME and the value is VAL. The domain field is the domain
of the cookie, such as '.apache.org',the optional lifetime
is the lifetime of the cookie in minutes, and the optional path is the
path of the cookie

This forces the current URL to be forbidden, i.e., it immediately sends
back a HTTP response of 403 (FORBIDDEN). Use this flag in conjunction
with appropriate RewriteConds to conditionally block some URLs.

Stop the rewriting process here and don't apply any more rewriting
rules. This corresponds to the Perl last command or the break command
from the C language. 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., '/e/www/'.

Re-run the rewriting process (starting again with the first rewriting
rule). Here the URL to match is again not the original URL but the URL
from the last rewriting rule. This corresponds to the Perl next
command or the continue command from the C language. Use this flag to
restart the rewriting process, i.e., to immediately go to the top of
the loop. But be careful not to create an infinite loop!

This flag keeps mod_rewrite from applying the usual URI escaping rules
to the result of a rewrite. Ordinarily, special characters (such as
'%', '$', ';', and so on) will be escaped into their hexcode
equivalents ('%25', '%24', and '%3B', respectively); this flag
prevents this from being done. This allows percent symbols to appear
in the output, as in
RewriteRule /foo/(.*) /bar?arg=P1\%3d$1 [R,NE]
which would turn '/foo/zed' into a safe request for '/bar?arg=P1=zed'.

This flag forces the rewriting engine to skip a rewriting rule if the
current request is an internal sub-request. For instance, sub-requests
occur internally in Apache when mod_include tries to find out
information about possible directory default files (index.xxx). On
sub-requests it is not always useful and even sometimes causes a
failure to 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.

This flag forces the substitution part to be internally forced as a proxy
request and immediately (i.e., rewriting rule processing stops here) put
through the proxy module. You have to make sure that the substitution string
is a valid URI (e.g., typically starting with http://hostname) which can be
handled by the Apache proxy module. If not you 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 server.
Note: No proxy

This flag forces the rewriting engine to append a query string part in
the substitution string to the existing one instead of replacing it.
Use this when you want to add more data to the query string via
a rewrite rule.

Prefix Substitution with 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 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 /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.

This flag forces the rewriting engine to skip the next num rules in
sequence when the current rule matches. Use this to make pseudo
if-then-else constructs: The last rule of the then-clause becomes
skip=N where N is the number of rules in the else-clause.
(This is not the same as the 'chain|C' flag!)

Force the MIME-type of the target file to be MIME-type. For instance,
this can be used to setup the content-type based on some conditions.
For example, the following snippet allows .php files to be displayed
by mod_php if they are called with the .phps extension:
RewriteRule ^(.+\.php)s$ $1 [T=application/x-httpd-php-source]