Apache Rewrite rules detailed

Source

http://logo32.iteye.com/blog/1312421

"Rewriteengine on" means that the rewrite engine is on, off, and the function is to conveniently turn the following statements on or off, so that no one comment statement is required.

"Rewritecond%{http_host} ^ (www\.)?" xxx\.com$ "
This is a rewrite condition, the previous%{http_host} represents the URL of the current visit, only refers to the prefix portion, the format is www.xxx.com does not include "http:/" and "/", ^ represents the beginning of the string, $ denotes the end of the string, \. Indicates escaped. , if not escaped, it is recommended to escape, to prevent some servers do not support,? Represents the front parenthesis www\. 0 or 1 occurrences, the rule means that if the URL visited is xxx.com or www.xxx.com executes the following statement, the non-conformance is skipped.

"Rewritecond%{request_uri}!^/blog/"
is also a rewrite condition,%{request_uri} means the relative address of the access, that is, the address of the relative root directory, is the domain name/back of the composition, the format includes the first "/", "!", which means the address of the access does not start with/blog/, just the beginning ^, no end $

"Rewritecond%{request_filename}!-f"
"Rewritecond%{request_filename}!-d"
These two sentences mean that the requested file or path does not exist, and if a file or path exists, it will return a file or path that already exists

The "Rewriterule ^ (. *) $/blog/$1" rewrite rule, the most important part, means that when the above rewritecond conditions are met, this rewrite rule will be executed, ^ (. *) $ is a regular expression match that matches the current requested url,^ (. * $ means match any character of the current URL,. Represents any single character, * indicates a match 0 or N times (n>0), and the latter/blog/$1 is an overriding ingredient, meaning that the previously matched word rename characters is written in/blog/$1, which represents a reverse match, The reference is the component of the first parenthesis above, that is ^ (. *) $. *, there will be a problem here, discussed later.

"Rewritecond%{http_host} ^ (www\.)?" xxx\.com$ "
"Rewriterule ^ (/)? $ blog/index.php [L]"
This means that the requested host address is www.xxx.com, if the end of the address is only 0 or 1 "/", will be rewritten to the subdirectory of the home page, I guess this is mainly because the rewritten address is not automatically find the home page, you need to specify.

Now that the problem arises, Rewriterule ^ (. *) $/blog/$1 The former part ^ (. *) $ will match the URL of the current request, for example: The request URL is http://www.xxx.com/a.html, exactly matches the entire HTTP/ Www.xxx.com/a.html, or just match the/a.html that is behind the backslash, or only the a.html.
The answer is: according to rewritebase rules, if the rewritebase is/, will match a.html, without the preceding backslash, so the last statement should be written rewriterule ^ (. *) $ blog/$1 (without/), However, the actual application with the front of the backslash, can also be used, may not take the line. Now the problem comes out, if not set Rewritebase to/, will match the entire URL http://www.xxx.com/a.html, obviously this is wrong, so should add this:
Rewitebase/

Another problem is that there is no guarantee that the URLs entered by everyone are lowercase, and if the input is uppercase, the Linux system is case-sensitive, so you should add [NC] to ignore the case after Rewritecond.
At this point, the complete statement should be:

# # # #start # #
Rewriteengine on
Rewitebase/
Rewritecond%{http_host} ^ (www\.)? xxx\.com$ [NC]
Rewritecond%{request_uri}!^/blog/
Rewritecond%{request_filename}!-f
Rewritecond%{request_filename}!-d
Rewriterule ^ (. *) $ blog/$1
# No default to enter the file name to the first page
Rewritecond%{http_host} ^ (www\.)? xxx\.com$ [NC]
Rewriterule ^ (/)? $ blog/index.php [L]
# # # #end # #

If you continue to have a statement later, you should not add the last [L], because it means the last statement

Anti-theft chain statements, also need to add rewitebase/, as follows:

Rewriteengine on
Rewitebase/
Rewritecond%{http_referer}!^$ [NC]
Rewritecond%{http_referer}!xxx.info [NC]
Rewriterule \. (jpg|gif|png|bmp|swf|jpeg) $/error/daolian.gif [r,nc,l]

If you continue to have a statement later, you should not add the last [l],/error/daolian.gif image that appears when someone hotlinking.

The following is a simple syntax rule and flags:
"Rewritecond Syntax:"
Rewritecond teststring Condpattern [flags]
Other uses of Rewritecond:
'-d ' (directory)
Treat TestString as a pathname and test whether it is a directory that exists.
'-f ' (regular file)
Treat teststring as a path name and test whether it is a regular file that exists.
'-S ' (non-empty regular file)
Treat TestString as a pathname and test whether it is an existing regular file with a size greater than 0.
'-l ' (symbolic Connection)
Treat TestString as a pathname and test whether it is an existing symbolic connection.
'-X ' (executable)
Treat TestString as a pathname and test whether it is an existing file with executable permissions. This permission is detected by the operating system.
'-f ' (Files that exist on a child request)
Check if teststring is a valid file and can be accessed under the current access control configuration of the server. It uses an internal sub-request to do the check, because it will reduce the performance of the server, so please use it carefully!
'-u ' (the URL that exists for a child request)
Check if teststring is a valid URL and can be accessed under the current access control configuration of the server. It uses an internal sub-request to do the check, because it will reduce the performance of the server, so please use it carefully!

"Rewriterule Syntax:"
Rewriterule Pattern Substitution [flags]

"Flags":

' Chain| C ' (link next rule)
This tag links the current rule to the next rule. It produces this effect: if a rule is matched, it continues to process its successor, that is, the tag does not work, and if the rule is not matched, its successor rule is skipped. For example, when performing an external redirect in a directory-level rule, you may need to delete ". www" (". www" should not appear here).

' cookie|co=name:val:domain[:lifetime[:p Ath]] ' (set cookies)
Set a cookie on the client. The name of the cookie is "name" and the value is Val. Domains are 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 cookie.

' Env| E=var:val ' (Setting environment variables)
This tag will have an environment variable var value of Val,val that can contain extensible regular expression inverse references ($N and%n). This tag can be used multiple times to set multiple variables. These variables can be indirectly referenced in many subsequent cases, usually in Xssi (<!– #echo var= "var" –>) or CGI ($ENV {' var '}). It can also be referenced by%{env:var} in the Condpattern parameter of the subsequent rewritecond instruction. Use it to remember the information that is stripped from the URL.

' Forbidden| F ' (Enforce forbidden URL)
Forces the current URL to be suppressed, that is, to immediately respond to an HTTP response code of 403 (forbidden). With this tag, you can link several rewriteconds to conditionally block certain URLs.

' Gone| G ' (Mandatory deprecated URL)
Forces the current URL to be deprecated, that is, immediately feedback an HTTP response code of 410 (deprecated). Using this tag, you can indicate that the page has been deprecated and does not exist.

' Handler| H=content-handler ' (enforces the specified content processor)
Changzi the content processor for the target file is Content-handler. For example, the Scriptalias directive used to emulate the Mod_alias module to force all files in the mapped folder to be handled by the "Cgi-script" processor.

' Last| L ' (end rule)
Stops the rewrite operation immediately and no longer applies another rewrite rule. It corresponds to the last command in Perl or the break command in the C language. This flag is used to prevent URLs that are currently overridden from being rewritten again by subsequent rules. For example, you can use it to override the URL of the root path ('/') to a URL that actually exists (for example: '/e/www/').

' Next| N ' (from scratch)
Re-executes the rewrite operation (starting with the first rule). The URL that was processed again at this point is not the original URL, but the URL that was processed by the last rewrite rule. It corresponds to the next command in Perl or the Continue command in the C language. This tag can restart the rewrite operation (immediately to the beginning of the loop). But be careful not to create a dead loop!

' Nocase| NC ' (ignoring case)
It makes the pattern ignore case, that is, ' A-Z ' and ' A-Z ' are not different when pattern matches the current URL.

' Noescape| NE ' (the URI is not escaped in the output)
This flag prevents Mod_rewrite from applying a general URI escape rule to the overridden result. In general, special characters ('% ', ' $ ', '; ') ('%25′, '%24′, '%3b ', etc.) will be escaped as equivalent hexadecimal codes. This flag prevents such escapes from allowing symbols such as percent signs to appear in the output, such as:
rewriterule/foo/(. *)/bar?arg=p1\%3d$1 [R,ne]
Can make '/foo/zed turn to a secure request '/bar?arg=p1=zed '.

' Nosubreq| NS ' (Do not process internal sub-requests)
This token forces the rewrite engine to skip the rewrite rule when the current request is an internal child request. For example, when Mod_include tries to search the directory default file (INDEX.XXX), Apache generates a child request internally. For a child request, the rewrite rule is not necessarily useful, and it may even throw an error if the entire rule set works. Therefore, you can use this tag to exclude certain rules.
Usage guidelines: If you add a CGI script prefix to a URL to force them to be handled by a CGI script, the error rate (or resource overhead) of the child request processing is high, in which case the token can be used.

' Proxy| P ' (Mandatory for proxy)
This token causes the replacement component to be internally forced to send as a proxy request, and immediately interrupts the rewrite process and then transfers the processing to the Mod_proxy module. You must make sure that this replacement string is a valid URI that can be processed by mod_proxy (for example, starting with http://hostname), or you will get an error returned by a proxy module. With this tag, some remote components can be mapped to the local server domain name space, thereby enhancing the functionality of the Proxypass directive.
Note: To use this feature, the Mod_proxy module must already be enabled.

' Passthrough| PT ' (hand over to the next processor)
This flag forces the rewrite engine to set the URI field in the internal REQUEST_REC structure to the value of the FileName field, a small modification that allows the output of the rewriterule instruction to be Alias, Scriptalias, from the URI to the file name, Redirect and other instructions for follow-up processing [original: This flag was just a hack to enable post-processing of the output of rewriterule directives, using Ali As, Scriptalias, Redirect, and other directives from various uri-to-filename translators. Give an example of what it means: if you want to rewrite/abc to/def, and then use Mod_alias to convert/def to/ghi, you can:
Rewriterule ^/abc (. *)/def$1 [PT]
Alias/def/ghi
If the PT mark is omitted, though the uri=/abc/... Rewrite for filename=/def/... Section works fine, but subsequent mod_alias are invalidated when attempting to convert a URI to a file name.
Note: You must use this tag if you need to mix multiple modules that convert URIs to file names: Mixed use of Mod_alias and mod_rewrite here is a typical example.

' Qsappend| QSA ' (append query string)
This flag forces the rewrite engine to append a query string to an existing replacement string, rather than a simple replacement. You can use this tag if you need to add information to the request string through a rewrite rule.

' Redirect| R [=code] ' (forced redirection)
If substitution begins with http://thishost[:thisport]/(making the new URL a URI), an external redirect can be enforced. If code is not specified, an HTTP response code of 302 (temporary move) is generated. If you need to use a different response code in the range of 300-400, just specify it here (or use one of the following symbol names: Temp (default), Permanent, seeother). You can use it to feed the normalized URL back to the client, such as "/~" to "/u/", or always to/u/user with a slash, and so on.
Note: When you use this tag, you must make sure that the replacement field is a valid URL. Otherwise, it will point to an invalid location! And keep in mind that this tag itself simply adds a http://thishost[:thisport]/prefix to the URL, and the rewrite operation continues. In general, you will also want to stop the rewrite operation and immediately redirect, then you need to use the ' L ' tag.

' Skip| S=num ' (skip the successor rule)
This flag forces the rewrite engine to skip NUM rules after the current matching rule. It simulates the IF-THEN-ELSE structure: The last rule is the then clause, and the skip=n rule that is skipped is the ELSE clause. Note: it and ' chain| The C ' tag is different!

' Type| T=mime-type ' (Force MIME type)
The force target file has a MIME type of mime-type and can be used to force the content type to be set based on certain conditions. For example, the following instruction allows a. php file to be displayed by mod_php according to the MIME type of the PHP source code (APPLICATION/X-HTTPD-PHP-SOURCE) in the case of a. Phps extension:
Rewriterule ^ (. +\.php) S $ $ [T=application/x-httpd-php-source]

Other

RewriteCond %{REQUEST_FILENAME} !-f   //如果文件存在，就直接访问文件，不进行下面的RewriteRule.(不是文件或文件不存在就执行重写) RewriteCond %{REQUEST_FILENAME} !-d   //#如果目录存在就直接访问目录不进行RewriteRule RewriteCond %{REQUEST_URI} !^.*(.css|.js|.gif|.png|.jpg|.jpeg)$ //#如果是这些后缀的文件，就直接访问文件，不进行Rewrite

Apache Rewrite rules detailed