home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 May / PCWorld_2003-05_cd.bin / Komunik / apache / apache_2.0.45-win32-x86-no_ssl.msi / Data.Cab / F232778_rewriteguide.xml < prev    next >
Extensible Markup Language  |  2003-02-13  |  72KB  |  2,203 lines
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE manualpage SYSTEM "../style/manualpage.dtd">
  3. <?xml-stylesheet type="text/xsl" href="../style/manual.en.xsl"?>
  4.  
  5. <manualpage>
  6.   <relativepath href=".." />
  7.   <parentdocument href="./">Miscellaneous Documentation</parentdocument>
  8.  
  9.   <title>URL Rewriting Guide</title>
  10.  
  11.   <summary>
  12.     <note>
  13.       <p>Originally written by<br />
  14.       <cite>Ralf S. Engelschall <rse@apache.org></cite><br />
  15.       December 1997</p>
  16.     </note>
  17.  
  18.     <p>This document supplements the <module>mod_rewrite</module>
  19.     <a href="../mod/mod_rewrite.html">reference documentation</a>.
  20.     It describes how one can use Apache's <module>mod_rewrite</module>
  21.     to solve typical URL-based problems webmasters are usually confronted
  22.     with in practice. I give detailed descriptions on how to
  23.     solve each problem by configuring URL rewriting rulesets.</p>
  24.  
  25.   </summary>
  26.  
  27.   <section id="ToC1">
  28.  
  29.     <title>Introduction to <code>mod_rewrite</code></title>
  30.  
  31.     <p>The Apache module <module>mod_rewrite</module> is a killer
  32.     one, i.e. it is a really sophisticated module which provides
  33.     a powerful way to do URL manipulations. With it you can nearly
  34.     do all types of URL manipulations you ever dreamed about.
  35.     The price you have to pay is to accept complexity, because
  36.     <module>mod_rewrite</module>'s major drawback is that it is
  37.     not easy to understand and use for the beginner. And even
  38.     Apache experts sometimes discover new aspects where
  39.     <module>mod_rewrite</module> can help.</p>
  40.  
  41.     <p>In other words: With <module>mod_rewrite</module> you either
  42.     shoot yourself in the foot the first time and never use it again
  43.     or love it for the rest of your life because of its power.
  44.     This paper tries to give you a few initial success events to
  45.     avoid the first case by presenting already invented solutions
  46.     to you.</p>
  47.  
  48.   </section>
  49.  
  50.   <section id="ToC2">
  51.  
  52.     <title>Practical Solutions</title>
  53.  
  54.     <p>Here come a lot of practical solutions I've either invented
  55.     myself or collected from other peoples solutions in the past.
  56.     Feel free to learn the black magic of URL rewriting from
  57.     these examples.</p>
  58.  
  59.     <note type="warning">ATTENTION: Depending on your server-configuration
  60.     it can be necessary to slightly change the examples for your
  61.     situation, e.g. adding the <code>[PT]</code> flag when
  62.     additionally using <module>mod_alias</module> and
  63.     <module>mod_userdir</module>, etc. Or rewriting a ruleset
  64.     to fit in <code>.htaccess</code> context instead
  65.     of per-server context. Always try to understand what a
  66.     particular ruleset really does before you use it. It
  67.     avoid problems.</note>
  68.  
  69.   </section>
  70.  
  71.   <section id="url">
  72.  
  73.     <title>URL Layout</title>
  74.  
  75.     <section>
  76.  
  77.       <title>Canonical URLs</title>
  78.  
  79.       <dl>
  80.         <dt>Description:</dt>
  81.  
  82.         <dd>
  83.           <p>On some webservers there are more than one URL for a
  84.           resource. Usually there are canonical URLs (which should be
  85.           actually used and distributed) and those which are just
  86.           shortcuts, internal ones, etc. Independent of which URL the
  87.           user supplied with the request he should finally see the
  88.           canonical one only.</p>
  89.         </dd>
  90.  
  91.         <dt>Solution:</dt>
  92.  
  93.         <dd>
  94.           <p>We do an external HTTP redirect for all non-canonical
  95.           URLs to fix them in the location view of the Browser and
  96.           for all subsequent requests. In the example ruleset below
  97.           we replace <code>/~user</code> by the canonical
  98.           <code>/u/user</code> and fix a missing trailing slash for
  99.           <code>/u/user</code>.</p>
  100.  
  101. <example><pre>
  102. RewriteRule   ^/<strong>~</strong>([^/]+)/?(.*)    /<strong>u</strong>/$1/$2  [<strong>R</strong>]
  103. RewriteRule   ^/([uge])/(<strong>[^/]+</strong>)$  /$1/$2<strong>/</strong>   [<strong>R</strong>]
  104. </pre></example>
  105.         </dd>
  106.       </dl>
  107.  
  108.     </section>
  109.  
  110.     <section>
  111.  
  112.       <title>Canonical Hostnames</title>
  113.  
  114.       <dl>
  115.         <dt>Description:</dt>
  116.  
  117.         <dd>...</dd>
  118.  
  119.         <dt>Solution:</dt>
  120.  
  121.         <dd>
  122. <example><pre>
  123. RewriteCond %{HTTP_HOST}   !^fully\.qualified\.domain\.name [NC]
  124. RewriteCond %{HTTP_HOST}   !^$
  125. RewriteCond %{SERVER_PORT} !^80$
  126. RewriteRule ^/(.*)         http://fully.qualified.domain.name:%{SERVER_PORT}/$1 [L,R]
  127. RewriteCond %{HTTP_HOST}   !^fully\.qualified\.domain\.name [NC]
  128. RewriteCond %{HTTP_HOST}   !^$
  129. RewriteRule ^/(.*)         http://fully.qualified.domain.name/$1 [L,R]
  130. </pre></example>
  131.         </dd>
  132.       </dl>
  133.  
  134.     </section>
  135.  
  136.     <section>
  137.  
  138.       <title>Moved <code>DocumentRoot</code></title>
  139.  
  140.       <dl>
  141.         <dt>Description:</dt>
  142.  
  143.         <dd>
  144.           <p>Usually the <directive module="core">DocumentRoot</directive>
  145.           of the webserver directly relates to the URL "<code>/</code>".
  146.           But often this data is not really of top-level priority, it is
  147.           perhaps just one entity of a lot of data pools. For instance at
  148.           our Intranet sites there are <code>/e/www/</code>
  149.           (the homepage for WWW), <code>/e/sww/</code> (the homepage for
  150.           the Intranet) etc. Now because the data of the <directive module="core"
  151.           >DocumentRoot</directive> stays at <code>/e/www/</code> we had
  152.           to make sure that all inlined images and other stuff inside this
  153.           data pool work for subsequent requests.</p>
  154.         </dd>
  155.  
  156.         <dt>Solution:</dt>
  157.  
  158.         <dd>
  159.           <p>We just redirect the URL <code>/</code> to
  160.           <code>/e/www/</code>. While is seems trivial it is
  161.           actually trivial with <module>mod_rewrite</module>, only.
  162.           Because the typical old mechanisms of URL <em>Aliases</em>
  163.           (as provides by <module>mod_alias</module> and friends)
  164.           only used <em>prefix</em> matching. With this you cannot
  165.           do such a redirection because the <directive module="core"
  166.           >DocumentRoot</directive> is a prefix of all URLs. With
  167.           <module>mod_rewrite</module> it is really trivial:</p>
  168.  
  169. <example><pre>
  170. RewriteEngine on
  171. RewriteRule   <strong>^/$</strong>  /e/www/  [<strong>R</strong>]
  172. </pre></example>
  173.         </dd>
  174.       </dl>
  175.  
  176.     </section>
  177.  
  178.     <section>
  179.  
  180.       <title>Trailing Slash Problem</title>
  181.  
  182.       <dl>
  183.         <dt>Description:</dt>
  184.  
  185.         <dd>
  186.           <p>Every webmaster can sing a song about the problem of
  187.           the trailing slash on URLs referencing directories. If they
  188.           are missing, the server dumps an error, because if you say
  189.           <code>/~quux/foo</code> instead of <code>/~quux/foo/</code>
  190.           then the server searches for a <em>file</em> named
  191.           <code>foo</code>. And because this file is a directory it
  192.           complains. Actually it tries to fix it itself in most of
  193.           the cases, but sometimes this mechanism need to be emulated
  194.           by you. For instance after you have done a lot of
  195.           complicated URL rewritings to CGI scripts etc.</p>
  196.         </dd>
  197.  
  198.         <dt>Solution:</dt>
  199.  
  200.         <dd>
  201.           <p>The solution to this subtle problem is to let the server
  202.           add the trailing slash automatically. To do this
  203.           correctly we have to use an external redirect, so the
  204.           browser correctly requests subsequent images etc. If we
  205.           only did a internal rewrite, this would only work for the
  206.           directory page, but would go wrong when any images are
  207.           included into this page with relative URLs, because the
  208.           browser would request an in-lined object. For instance, a
  209.           request for <code>image.gif</code> in
  210.           <code>/~quux/foo/index.html</code> would become
  211.           <code>/~quux/image.gif</code> without the external
  212.           redirect!</p>
  213.  
  214.           <p>So, to do this trick we write:</p>
  215.  
  216. <example><pre>
  217. RewriteEngine  on
  218. RewriteBase    /~quux/
  219. RewriteRule    ^foo<strong>$</strong>  foo<strong>/</strong>  [<strong>R</strong>]
  220. </pre></example>
  221.  
  222.           <p>The crazy and lazy can even do the following in the
  223.           top-level <code>.htaccess</code> file of their homedir.
  224.           But notice that this creates some processing
  225.           overhead.</p>
  226.  
  227. <example><pre>
  228. RewriteEngine  on
  229. RewriteBase    /~quux/
  230. RewriteCond    %{REQUEST_FILENAME}  <strong>-d</strong>
  231. RewriteRule    ^(.+<strong>[^/]</strong>)$           $1<strong>/</strong>  [R]
  232. </pre></example>
  233.         </dd>
  234.       </dl>
  235.  
  236.     </section>
  237.  
  238.     <section>
  239.  
  240.       <title>Webcluster through Homogeneous URL Layout</title>
  241.  
  242.       <dl>
  243.         <dt>Description:</dt>
  244.  
  245.         <dd>
  246.           <p>We want to create a homogeneous and consistent URL
  247.           layout over all WWW servers on a Intranet webcluster, i.e.
  248.           all URLs (per definition server local and thus server
  249.           dependent!) become actually server <em>independent</em>!
  250.           What we want is to give the WWW namespace a consistent
  251.           server-independent layout: no URL should have to include
  252.           any physically correct target server. The cluster itself
  253.           should drive us automatically to the physical target
  254.           host.</p>
  255.         </dd>
  256.  
  257.         <dt>Solution:</dt>
  258.  
  259.         <dd>
  260.           <p>First, the knowledge of the target servers come from
  261.           (distributed) external maps which contain information
  262.           where our users, groups and entities stay. The have the
  263.           form</p>
  264.  
  265. <example><pre>
  266. user1  server_of_user1
  267. user2  server_of_user2
  268. :      :
  269. </pre></example>
  270.  
  271.           <p>We put them into files <code>map.xxx-to-host</code>.
  272.           Second we need to instruct all servers to redirect URLs
  273.           of the forms</p>
  274.  
  275. <example><pre>
  276. /u/user/anypath
  277. /g/group/anypath
  278. /e/entity/anypath
  279. </pre></example>
  280.  
  281.           <p>to</p>
  282.  
  283. <example><pre>
  284. http://physical-host/u/user/anypath
  285. http://physical-host/g/group/anypath
  286. http://physical-host/e/entity/anypath
  287. </pre></example>
  288.  
  289.           <p>when the URL is not locally valid to a server. The
  290.           following ruleset does this for us by the help of the map
  291.           files (assuming that server0 is a default server which
  292.           will be used if a user has no entry in the map):</p>
  293.  
  294. <example><pre>
  295. RewriteEngine on
  296.  
  297. RewriteMap      user-to-host   txt:/path/to/map.user-to-host
  298. RewriteMap     group-to-host   txt:/path/to/map.group-to-host
  299. RewriteMap    entity-to-host   txt:/path/to/map.entity-to-host
  300.  
  301. RewriteRule   ^/u/<strong>([^/]+)</strong>/?(.*)   http://<strong>${user-to-host:$1|server0}</strong>/u/$1/$2
  302. RewriteRule   ^/g/<strong>([^/]+)</strong>/?(.*)  http://<strong>${group-to-host:$1|server0}</strong>/g/$1/$2
  303. RewriteRule   ^/e/<strong>([^/]+)</strong>/?(.*) http://<strong>${entity-to-host:$1|server0}</strong>/e/$1/$2
  304.  
  305. RewriteRule   ^/([uge])/([^/]+)/?$          /$1/$2/.www/
  306. RewriteRule   ^/([uge])/([^/]+)/([^.]+.+)   /$1/$2/.www/$3\
  307. </pre></example>
  308.         </dd>
  309.       </dl>
  310.  
  311.     </section>
  312.  
  313.     <section>
  314.  
  315.       <title>Move Homedirs to Different Webserver</title>
  316.  
  317.       <dl>
  318.         <dt>Description:</dt>
  319.  
  320.         <dd>
  321.           <p>Many webmasters have asked for a solution to the
  322.           following situation: They wanted to redirect just all
  323.           homedirs on a webserver to another webserver. They usually
  324.           need such things when establishing a newer webserver which
  325.           will replace the old one over time.</p>
  326.         </dd>
  327.  
  328.         <dt>Solution:</dt>
  329.  
  330.         <dd>
  331.           <p>The solution is trivial with <module>mod_rewrite</module>.
  332.           On the old webserver we just redirect all
  333.           <code>/~user/anypath</code> URLs to
  334.           <code>http://newserver/~user/anypath</code>.</p>
  335.  
  336. <example><pre>
  337. RewriteEngine on
  338. RewriteRule   ^/~(.+)  http://<strong>newserver</strong>/~$1  [R,L]
  339. </pre></example>
  340.         </dd>
  341.       </dl>
  342.  
  343.     </section>
  344.  
  345.     <section>
  346.  
  347.       <title>Structured Homedirs</title>
  348.  
  349.       <dl>
  350.         <dt>Description:</dt>
  351.  
  352.         <dd>
  353.           <p>Some sites with thousands of users usually use a
  354.           structured homedir layout, i.e. each homedir is in a
  355.           subdirectory which begins for instance with the first
  356.           character of the username. So, <code>/~foo/anypath</code>
  357.           is <code>/home/<strong>f</strong>/foo/.www/anypath</code>
  358.           while <code>/~bar/anypath</code> is
  359.           <code>/home/<strong>b</strong>/bar/.www/anypath</code>.</p>
  360.         </dd>
  361.  
  362.         <dt>Solution:</dt>
  363.  
  364.         <dd>
  365.           <p>We use the following ruleset to expand the tilde URLs
  366.           into exactly the above layout.</p>
  367.  
  368. <example><pre>
  369. RewriteEngine on
  370. RewriteRule   ^/~(<strong>([a-z])</strong>[a-z0-9]+)(.*)  /home/<strong>$2</strong>/$1/.www$3
  371. </pre></example>
  372.         </dd>
  373.       </dl>
  374.  
  375.     </section>
  376.  
  377.     <section>
  378.  
  379.       <title>Filesystem Reorganization</title>
  380.  
  381.       <dl>
  382.         <dt>Description:</dt>
  383.  
  384.         <dd>
  385.           <p>This really is a hardcore example: a killer application
  386.           which heavily uses per-directory
  387.           <code>RewriteRules</code> to get a smooth look and feel
  388.           on the Web while its data structure is never touched or
  389.           adjusted. Background: <strong><em>net.sw</em></strong> is
  390.           my archive of freely available Unix software packages,
  391.           which I started to collect in 1992. It is both my hobby
  392.           and job to to this, because while I'm studying computer
  393.           science I have also worked for many years as a system and
  394.           network administrator in my spare time. Every week I need
  395.           some sort of software so I created a deep hierarchy of
  396.           directories where I stored the packages:</p>
  397.  
  398. <example><pre>
  399. drwxrwxr-x   2 netsw  users    512 Aug  3 18:39 Audio/
  400. drwxrwxr-x   2 netsw  users    512 Jul  9 14:37 Benchmark/
  401. drwxrwxr-x  12 netsw  users    512 Jul  9 00:34 Crypto/
  402. drwxrwxr-x   5 netsw  users    512 Jul  9 00:41 Database/
  403. drwxrwxr-x   4 netsw  users    512 Jul 30 19:25 Dicts/
  404. drwxrwxr-x  10 netsw  users    512 Jul  9 01:54 Graphic/
  405. drwxrwxr-x   5 netsw  users    512 Jul  9 01:58 Hackers/
  406. drwxrwxr-x   8 netsw  users    512 Jul  9 03:19 InfoSys/
  407. drwxrwxr-x   3 netsw  users    512 Jul  9 03:21 Math/
  408. drwxrwxr-x   3 netsw  users    512 Jul  9 03:24 Misc/
  409. drwxrwxr-x   9 netsw  users    512 Aug  1 16:33 Network/
  410. drwxrwxr-x   2 netsw  users    512 Jul  9 05:53 Office/
  411. drwxrwxr-x   7 netsw  users    512 Jul  9 09:24 SoftEng/
  412. drwxrwxr-x   7 netsw  users    512 Jul  9 12:17 System/
  413. drwxrwxr-x  12 netsw  users    512 Aug  3 20:15 Typesetting/
  414. drwxrwxr-x  10 netsw  users    512 Jul  9 14:08 X11/
  415. </pre></example>
  416.  
  417.           <p>In July 1996 I decided to make this archive public to
  418.           the world via a nice Web interface. "Nice" means that I
  419.           wanted to offer an interface where you can browse
  420.           directly through the archive hierarchy. And "nice" means
  421.           that I didn't wanted to change anything inside this
  422.           hierarchy - not even by putting some CGI scripts at the
  423.           top of it. Why? Because the above structure should be
  424.           later accessible via FTP as well, and I didn't want any
  425.           Web or CGI stuff to be there.</p>
  426.         </dd>
  427.  
  428.         <dt>Solution:</dt>
  429.  
  430.         <dd>
  431.           <p>The solution has two parts: The first is a set of CGI
  432.           scripts which create all the pages at all directory
  433.           levels on-the-fly. I put them under
  434.           <code>/e/netsw/.www/</code> as follows:</p>
  435.  
  436. <example><pre>
  437. -rw-r--r--   1 netsw  users    1318 Aug  1 18:10 .wwwacl
  438. drwxr-xr-x  18 netsw  users     512 Aug  5 15:51 DATA/
  439. -rw-rw-rw-   1 netsw  users  372982 Aug  5 16:35 LOGFILE
  440. -rw-r--r--   1 netsw  users     659 Aug  4 09:27 TODO
  441. -rw-r--r--   1 netsw  users    5697 Aug  1 18:01 netsw-about.html
  442. -rwxr-xr-x   1 netsw  users     579 Aug  2 10:33 netsw-access.pl
  443. -rwxr-xr-x   1 netsw  users    1532 Aug  1 17:35 netsw-changes.cgi
  444. -rwxr-xr-x   1 netsw  users    2866 Aug  5 14:49 netsw-home.cgi
  445. drwxr-xr-x   2 netsw  users     512 Jul  8 23:47 netsw-img/
  446. -rwxr-xr-x   1 netsw  users   24050 Aug  5 15:49 netsw-lsdir.cgi
  447. -rwxr-xr-x   1 netsw  users    1589 Aug  3 18:43 netsw-search.cgi
  448. -rwxr-xr-x   1 netsw  users    1885 Aug  1 17:41 netsw-tree.cgi
  449. -rw-r--r--   1 netsw  users     234 Jul 30 16:35 netsw-unlimit.lst
  450. </pre></example>
  451.  
  452.           <p>The <code>DATA/</code> subdirectory holds the above
  453.           directory structure, i.e. the real
  454.           <strong><em>net.sw</em></strong> stuff and gets
  455.           automatically updated via <code>rdist</code> from time to
  456.           time. The second part of the problem remains: how to link
  457.           these two structures together into one smooth-looking URL
  458.           tree? We want to hide the <code>DATA/</code> directory
  459.           from the user while running the appropriate CGI scripts
  460.           for the various URLs. Here is the solution: first I put
  461.           the following into the per-directory configuration file
  462.           in the <directive module="core">DocumentRoot</directive>
  463.           of the server to rewrite the announced URL
  464.           <code>/net.sw/</code> to the internal path
  465.           <code>/e/netsw</code>:</p>
  466.  
  467. <example><pre>
  468. RewriteRule  ^net.sw$       net.sw/        [R]
  469. RewriteRule  ^net.sw/(.*)$  e/netsw/$1
  470. </pre></example>
  471.  
  472.           <p>The first rule is for requests which miss the trailing
  473.           slash! The second rule does the real thing. And then
  474.           comes the killer configuration which stays in the
  475.           per-directory config file
  476.           <code>/e/netsw/.www/.wwwacl</code>:</p>
  477.  
  478. <example><pre>
  479. Options       ExecCGI FollowSymLinks Includes MultiViews
  480.  
  481. RewriteEngine on
  482.  
  483. #  we are reached via /net.sw/ prefix
  484. RewriteBase   /net.sw/
  485.  
  486. #  first we rewrite the root dir to
  487. #  the handling cgi script
  488. RewriteRule   ^$                       netsw-home.cgi     [L]
  489. RewriteRule   ^index\.html$            netsw-home.cgi     [L]
  490.  
  491. #  strip out the subdirs when
  492. #  the browser requests us from perdir pages
  493. RewriteRule   ^.+/(netsw-[^/]+/.+)$    $1                 [L]
  494.  
  495. #  and now break the rewriting for local files
  496. RewriteRule   ^netsw-home\.cgi.*       -                  [L]
  497. RewriteRule   ^netsw-changes\.cgi.*    -                  [L]
  498. RewriteRule   ^netsw-search\.cgi.*     -                  [L]
  499. RewriteRule   ^netsw-tree\.cgi$        -                  [L]
  500. RewriteRule   ^netsw-about\.html$      -                  [L]
  501. RewriteRule   ^netsw-img/.*$           -                  [L]
  502.  
  503. #  anything else is a subdir which gets handled
  504. #  by another cgi script
  505. RewriteRule   !^netsw-lsdir\.cgi.*     -                  [C]
  506. RewriteRule   (.*)                     netsw-lsdir.cgi/$1
  507. </pre></example>
  508.  
  509.           <p>Some hints for interpretation:</p>
  510.  
  511.           <ol>
  512.             <li>Notice the <code>L</code> (last) flag and no
  513.             substitution field ('<code>-</code>') in the forth part</li>
  514.  
  515.             <li>Notice the <code>!</code> (not) character and
  516.             the <code>C</code> (chain) flag at the first rule
  517.             in the last part</li>
  518.  
  519.             <li>Notice the catch-all pattern in the last rule</li>
  520.           </ol>
  521.         </dd>
  522.       </dl>
  523.  
  524.     </section>
  525.  
  526.     <section>
  527.  
  528.       <title>NCSA imagemap to Apache <code>mod_imap</code></title>
  529.  
  530.       <dl>
  531.         <dt>Description:</dt>
  532.  
  533.         <dd>
  534.           <p>When switching from the NCSA webserver to the more
  535.           modern Apache webserver a lot of people want a smooth
  536.           transition. So they want pages which use their old NCSA
  537.           <code>imagemap</code> program to work under Apache with the
  538.           modern <module>mod_imap</module>. The problem is that there
  539.           are a lot of hyperlinks around which reference the
  540.           <code>imagemap</code> program via
  541.           <code>/cgi-bin/imagemap/path/to/page.map</code>. Under
  542.           Apache this has to read just
  543.           <code>/path/to/page.map</code>.</p>
  544.         </dd>
  545.  
  546.         <dt>Solution:</dt>
  547.  
  548.         <dd>
  549.           <p>We use a global rule to remove the prefix on-the-fly for
  550.           all requests:</p>
  551.  
  552. <example><pre>
  553. RewriteEngine  on
  554. RewriteRule    ^/cgi-bin/imagemap(.*)  $1  [PT]
  555. </pre></example>
  556.         </dd>
  557.       </dl>
  558.  
  559.     </section>
  560.  
  561.     <section>
  562.  
  563.       <title>Search pages in more than one directory</title>
  564.  
  565.       <dl>
  566.         <dt>Description:</dt>
  567.  
  568.         <dd>
  569.           <p>Sometimes it is necessary to let the webserver search
  570.           for pages in more than one directory. Here MultiViews or
  571.           other techniques cannot help.</p>
  572.         </dd>
  573.  
  574.         <dt>Solution:</dt>
  575.  
  576.         <dd>
  577.           <p>We program a explicit ruleset which searches for the
  578.           files in the directories.</p>
  579.  
  580. <example><pre>
  581. RewriteEngine on
  582.  
  583. #   first try to find it in custom/...
  584. #   ...and if found stop and be happy:
  585. RewriteCond         /your/docroot/<strong>dir1</strong>/%{REQUEST_FILENAME}  -f
  586. RewriteRule  ^(.+)  /your/docroot/<strong>dir1</strong>/$1  [L]
  587.  
  588. #   second try to find it in pub/...
  589. #   ...and if found stop and be happy:
  590. RewriteCond         /your/docroot/<strong>dir2</strong>/%{REQUEST_FILENAME}  -f
  591. RewriteRule  ^(.+)  /your/docroot/<strong>dir2</strong>/$1  [L]
  592.  
  593. #   else go on for other Alias or ScriptAlias directives,
  594. #   etc.
  595. RewriteRule   ^(.+)  -  [PT]
  596. </pre></example>
  597.         </dd>
  598.       </dl>
  599.  
  600.     </section>
  601.  
  602.     <section>
  603.  
  604.       <title>Set Environment Variables According To URL Parts</title>
  605.  
  606.       <dl>
  607.         <dt>Description:</dt>
  608.  
  609.         <dd>
  610.           <p>Perhaps you want to keep status information between
  611.           requests and use the URL to encode it. But you don't want
  612.           to use a CGI wrapper for all pages just to strip out this
  613.           information.</p>
  614.         </dd>
  615.  
  616.         <dt>Solution:</dt>
  617.  
  618.         <dd>
  619.           <p>We use a rewrite rule to strip out the status information
  620.           and remember it via an environment variable which can be
  621.           later dereferenced from within XSSI or CGI. This way a
  622.           URL <code>/foo/S=java/bar/</code> gets translated to
  623.           <code>/foo/bar/</code> and the environment variable named
  624.           <code>STATUS</code> is set to the value "java".</p>
  625.  
  626. <example><pre>
  627. RewriteEngine on
  628. RewriteRule   ^(.*)/<strong>S=([^/]+)</strong>/(.*)    $1/$3 [E=<strong>STATUS:$2</strong>]
  629. </pre></example>
  630.         </dd>
  631.       </dl>
  632.  
  633.     </section>
  634.  
  635.     <section>
  636.  
  637.       <title>Virtual User Hosts</title>
  638.  
  639.       <dl>
  640.         <dt>Description:</dt>
  641.  
  642.         <dd>
  643.           <p>Assume that you want to provide
  644.           <code>www.<strong>username</strong>.host.domain.com</code>
  645.           for the homepage of username via just DNS A records to the
  646.           same machine and without any virtualhosts on this
  647.           machine.</p>
  648.         </dd>
  649.  
  650.         <dt>Solution:</dt>
  651.  
  652.         <dd>
  653.           <p>For HTTP/1.0 requests there is no solution, but for
  654.           HTTP/1.1 requests which contain a Host: HTTP header we
  655.           can use the following ruleset to rewrite
  656.           <code>http://www.username.host.com/anypath</code>
  657.           internally to <code>/home/username/anypath</code>:</p>
  658.  
  659. <example><pre>
  660. RewriteEngine on
  661. RewriteCond   %{<strong>HTTP_HOST</strong>}                 ^www\.<strong>[^.]+</strong>\.host\.com$
  662. RewriteRule   ^(.+)                        %{HTTP_HOST}$1          [C]
  663. RewriteRule   ^www\.<strong>([^.]+)</strong>\.host\.com(.*) /home/<strong>$1</strong>$2
  664. </pre></example>
  665.         </dd>
  666.       </dl>
  667.  
  668.     </section>
  669.  
  670.     <section>
  671.  
  672.       <title>Redirect Homedirs For Foreigners</title>
  673.  
  674.       <dl>
  675.         <dt>Description:</dt>
  676.  
  677.         <dd>
  678.           <p>We want to redirect homedir URLs to another webserver
  679.           <code>www.somewhere.com</code> when the requesting user
  680.           does not stay in the local domain
  681.           <code>ourdomain.com</code>. This is sometimes used in
  682.           virtual host contexts.</p>
  683.         </dd>
  684.  
  685.         <dt>Solution:</dt>
  686.  
  687.         <dd>
  688.           <p>Just a rewrite condition:</p>
  689.  
  690. <example><pre>
  691. RewriteEngine on
  692. RewriteCond   %{REMOTE_HOST}  <strong>!^.+\.ourdomain\.com$</strong>
  693. RewriteRule   ^(/~.+)         http://www.somewhere.com/$1 [R,L]
  694. </pre></example>
  695.         </dd>
  696.       </dl>
  697.  
  698.     </section>
  699.  
  700.     <section>
  701.  
  702.       <title>Redirect Failing URLs To Other Webserver</title>
  703.  
  704.       <dl>
  705.         <dt>Description:</dt>
  706.  
  707.         <dd>
  708.           <p>A typical FAQ about URL rewriting is how to redirect
  709.           failing requests on webserver A to webserver B. Usually
  710.           this is done via <directive module="core"
  711.           >ErrorDocument</directive> CGI-scripts in Perl, but
  712.           there is also a <module>mod_rewrite</module> solution.
  713.           But notice that this performs more poorly than using an
  714.           <directive module="core">ErrorDocument</directive>
  715.           CGI-script!</p>
  716.         </dd>
  717.  
  718.         <dt>Solution:</dt>
  719.  
  720.         <dd>
  721.           <p>The first solution has the best performance but less
  722.           flexibility, and is less error safe:</p>
  723.  
  724. <example><pre>
  725. RewriteEngine on
  726. RewriteCond   /your/docroot/%{REQUEST_FILENAME} <strong>!-f</strong>
  727. RewriteRule   ^(.+)                             http://<strong>webserverB</strong>.dom/$1
  728. </pre></example>
  729.  
  730.           <p>The problem here is that this will only work for pages
  731.           inside the <directive module="core">DocumentRoot</directive>. While you can add more
  732.           Conditions (for instance to also handle homedirs, etc.)
  733.           there is better variant:</p>
  734.  
  735. <example><pre>
  736. RewriteEngine on
  737. RewriteCond   %{REQUEST_URI} <strong>!-U</strong>
  738. RewriteRule   ^(.+)          http://<strong>webserverB</strong>.dom/$1
  739. </pre></example>
  740.  
  741.           <p>This uses the URL look-ahead feature of <module>mod_rewrite</module>.
  742.           The result is that this will work for all types of URLs
  743.           and is a safe way. But it does a performance impact on
  744.           the webserver, because for every request there is one
  745.           more internal subrequest. So, if your webserver runs on a
  746.           powerful CPU, use this one. If it is a slow machine, use
  747.           the first approach or better a <directive module="core"
  748.           >ErrorDocument</directive> CGI-script.</p>
  749.         </dd>
  750.       </dl>
  751.  
  752.     </section>
  753.  
  754.     <section>
  755.  
  756.       <title>Extended Redirection</title>
  757.  
  758.       <dl>
  759.         <dt>Description:</dt>
  760.  
  761.         <dd>
  762.           <p>Sometimes we need more control (concerning the
  763.           character escaping mechanism) of URLs on redirects.
  764.           Usually the Apache kernels URL escape function also
  765.           escapes anchors, i.e. URLs like "<code>url#anchor</code>".
  766.           You cannot use this directly on redirects with
  767.           <module>mod_rewrite</module> because the
  768.           <code>uri_escape()</code> function of Apache
  769.           would also escape the hash character.
  770.           How can we redirect to such a URL?</p>
  771.         </dd>
  772.  
  773.         <dt>Solution:</dt>
  774.  
  775.         <dd>
  776.           <p>We have to use a kludge by the use of a NPH-CGI script
  777.           which does the redirect itself. Because here no escaping
  778.           is done (NPH=non-parseable headers). First we introduce a
  779.           new URL scheme <code>xredirect:</code> by the following
  780.           per-server config-line (should be one of the last rewrite
  781.           rules):</p>
  782.  
  783. <example><pre>
  784. RewriteRule ^xredirect:(.+) /path/to/nph-xredirect.cgi/$1 \
  785.             [T=application/x-httpd-cgi,L]
  786. </pre></example>
  787.  
  788.           <p>This forces all URLs prefixed with
  789.           <code>xredirect:</code> to be piped through the
  790.           <code>nph-xredirect.cgi</code> program. And this program
  791.           just looks like:</p>
  792.  
  793. <example><pre>
  794. #!/path/to/perl
  795. ##
  796. ##  nph-xredirect.cgi -- NPH/CGI script for extended redirects
  797. ##  Copyright (c) 1997 Ralf S. Engelschall, All Rights Reserved.
  798. ##
  799.  
  800. $| = 1;
  801. $url = $ENV{'PATH_INFO'};
  802.  
  803. print "HTTP/1.0 302 Moved Temporarily\n";
  804. print "Server: $ENV{'SERVER_SOFTWARE'}\n";
  805. print "Location: $url\n";
  806. print "Content-type: text/html\n";
  807. print "\n";
  808. print "<html>\n";
  809. print "<head>\n";
  810. print "<title>302 Moved Temporarily (EXTENDED)</title>\n";
  811. print "</head>\n";
  812. print "<body>\n";
  813. print "<h1>Moved Temporarily (EXTENDED)</h1>\n";
  814. print "The document has moved <a HREF=\"$url\">here</a>.<p>\n";
  815. print "</body>\n";
  816. print "</html>\n";
  817.  
  818. ##EOF##
  819. </pre></example>
  820.  
  821.           <p>This provides you with the functionality to do
  822.           redirects to all URL schemes, i.e. including the one
  823.           which are not directly accepted by <module>mod_rewrite</module>.
  824.           For instance you can now also redirect to
  825.           <code>news:newsgroup</code> via</p>
  826.  
  827. <example><pre>
  828. RewriteRule ^anyurl  xredirect:news:newsgroup
  829. </pre></example>
  830.  
  831.           <note>Notice: You have not to put <code>[R]</code> or
  832.           <code>[R,L]</code> to the above rule because the
  833.           <code>xredirect:</code> need to be expanded later
  834.           by our special "pipe through" rule above.</note>
  835.         </dd>
  836.       </dl>
  837.  
  838.     </section>
  839.  
  840.     <section>
  841.  
  842.       <title>Archive Access Multiplexer</title>
  843.  
  844.       <dl>
  845.         <dt>Description:</dt>
  846.  
  847.         <dd>
  848.           <p>Do you know the great CPAN (Comprehensive Perl Archive
  849.           Network) under <a href="http://www.perl.com/CPAN"
  850.           >http://www.perl.com/CPAN</a>?
  851.           This does a redirect to one of several FTP servers around
  852.           the world which carry a CPAN mirror and is approximately
  853.           near the location of the requesting client. Actually this
  854.           can be called an FTP access multiplexing service. While
  855.           CPAN runs via CGI scripts, how can a similar approach
  856.           implemented via <module>mod_rewrite</module>?</p>
  857.         </dd>
  858.  
  859.         <dt>Solution:</dt>
  860.  
  861.         <dd>
  862.           <p>First we notice that from version 3.0.0
  863.           <module>mod_rewrite</module> can
  864.           also use the "<code>ftp:</code>" scheme on redirects.
  865.           And second, the location approximation can be done by a
  866.           <directive module="mod_rewrite">RewriteMap</directive>
  867.           over the top-level domain of the client.
  868.           With a tricky chained ruleset we can use this top-level
  869.           domain as a key to our multiplexing map.</p>
  870.  
  871. <example><pre>
  872. RewriteEngine on
  873. RewriteMap    multiplex                txt:/path/to/map.cxan
  874. RewriteRule   ^/CxAN/(.*)              %{REMOTE_HOST}::$1                 [C]
  875. RewriteRule   ^.+\.<strong>([a-zA-Z]+)</strong>::(.*)$  ${multiplex:<strong>$1</strong>|ftp.default.dom}$2  [R,L]
  876. </pre></example>
  877.  
  878. <example><pre>
  879. ##
  880. ##  map.cxan -- Multiplexing Map for CxAN
  881. ##
  882.  
  883. de        ftp://ftp.cxan.de/CxAN/
  884. uk        ftp://ftp.cxan.uk/CxAN/
  885. com       ftp://ftp.cxan.com/CxAN/
  886.  :
  887. ##EOF##
  888. </pre></example>
  889.         </dd>
  890.       </dl>
  891.  
  892.     </section>
  893.  
  894.     <section>
  895.  
  896.       <title>Time-Dependent Rewriting</title>
  897.  
  898.       <dl>
  899.         <dt>Description:</dt>
  900.  
  901.         <dd>
  902.           <p>When tricks like time-dependent content should happen a
  903.           lot of webmasters still use CGI scripts which do for
  904.           instance redirects to specialized pages. How can it be done
  905.           via <module>mod_rewrite</module>?</p>
  906.         </dd>
  907.  
  908.         <dt>Solution:</dt>
  909.  
  910.         <dd>
  911.           <p>There are a lot of variables named <code>TIME_xxx</code>
  912.           for rewrite conditions. In conjunction with the special
  913.           lexicographic comparison patterns <code><STRING</code>,
  914.           <code>>STRING</code> and <code>=STRING</code> we can
  915.           do time-dependent redirects:</p>
  916.  
  917. <example><pre>
  918. RewriteEngine on
  919. RewriteCond   %{TIME_HOUR}%{TIME_MIN} >0700
  920. RewriteCond   %{TIME_HOUR}%{TIME_MIN} <1900
  921. RewriteRule   ^foo\.html$             foo.day.html
  922. RewriteRule   ^foo\.html$             foo.night.html
  923. </pre></example>
  924.  
  925.           <p>This provides the content of <code>foo.day.html</code>
  926.           under the URL <code>foo.html</code> from
  927.           <code>07:00-19:00</code> and at the remaining time the
  928.           contents of <code>foo.night.html</code>. Just a nice
  929.           feature for a homepage...</p>
  930.         </dd>
  931.       </dl>
  932.  
  933.     </section>
  934.  
  935.     <section>
  936.  
  937.       <title>Backward Compatibility for YYYY to XXXX migration</title>
  938.  
  939.       <dl>
  940.         <dt>Description:</dt>
  941.  
  942.         <dd>
  943.           <p>How can we make URLs backward compatible (still
  944.           existing virtually) after migrating <code>document.YYYY</code>
  945.           to <code>document.XXXX</code>, e.g. after translating a
  946.           bunch of <code>.html</code> files to <code>.phtml</code>?</p>
  947.         </dd>
  948.  
  949.         <dt>Solution:</dt>
  950.  
  951.         <dd>
  952.           <p>We just rewrite the name to its basename and test for
  953.           existence of the new extension. If it exists, we take
  954.           that name, else we rewrite the URL to its original state.</p>
  955.  
  956.  
  957. <example><pre>
  958. #   backward compatibility ruleset for
  959. #   rewriting document.html to document.phtml
  960. #   when and only when document.phtml exists
  961. #   but no longer document.html
  962. RewriteEngine on
  963. RewriteBase   /~quux/
  964. #   parse out basename, but remember the fact
  965. RewriteRule   ^(.*)\.html$              $1      [C,E=WasHTML:yes]
  966. #   rewrite to document.phtml if exists
  967. RewriteCond   %{REQUEST_FILENAME}.phtml -f
  968. RewriteRule   ^(.*)$ $1.phtml                   [S=1]
  969. #   else reverse the previous basename cutout
  970. RewriteCond   %{ENV:WasHTML}            ^yes$
  971. RewriteRule   ^(.*)$ $1.html
  972. </pre></example>
  973.         </dd>
  974.       </dl>
  975.  
  976.     </section>
  977.  
  978.   </section>
  979.  
  980.   <section id="content">
  981.  
  982.     <title>Content Handling</title>
  983.  
  984.     <section>
  985.  
  986.       <title>From Old to New (intern)</title>
  987.  
  988.       <dl>
  989.         <dt>Description:</dt>
  990.  
  991.         <dd>
  992.           <p>Assume we have recently renamed the page
  993.           <code>foo.html</code> to <code>bar.html</code> and now want
  994.           to provide the old URL for backward compatibility. Actually
  995.           we want that users of the old URL even not recognize that
  996.           the pages was renamed.</p>
  997.         </dd>
  998.  
  999.         <dt>Solution:</dt>
  1000.  
  1001.         <dd>
  1002.           <p>We rewrite the old URL to the new one internally via the
  1003.           following rule:</p>
  1004.  
  1005. <example><pre>
  1006. RewriteEngine  on
  1007. RewriteBase    /~quux/
  1008. RewriteRule    ^<strong>foo</strong>\.html$  <strong>bar</strong>.html
  1009. </pre></example>
  1010.         </dd>
  1011.       </dl>
  1012.  
  1013.     </section>
  1014.  
  1015.     <section>
  1016.  
  1017.       <title>From Old to New (extern)</title>
  1018.  
  1019.       <dl>
  1020.         <dt>Description:</dt>
  1021.  
  1022.         <dd>
  1023.           <p>Assume again that we have recently renamed the page
  1024.           <code>foo.html</code> to <code>bar.html</code> and now want
  1025.           to provide the old URL for backward compatibility. But this
  1026.           time we want that the users of the old URL get hinted to
  1027.           the new one, i.e. their browsers Location field should
  1028.           change, too.</p>
  1029.         </dd>
  1030.  
  1031.         <dt>Solution:</dt>
  1032.  
  1033.         <dd>
  1034.           <p>We force a HTTP redirect to the new URL which leads to a
  1035.           change of the browsers and thus the users view:</p>
  1036.  
  1037. <example><pre>
  1038. RewriteEngine  on
  1039. RewriteBase    /~quux/
  1040. RewriteRule    ^<strong>foo</strong>\.html$  <strong>bar</strong>.html  [<strong>R</strong>]
  1041. </pre></example>
  1042.         </dd>
  1043.       </dl>
  1044.  
  1045.     </section>
  1046.  
  1047.     <section>
  1048.  
  1049.       <title>Browser Dependent Content</title>
  1050.  
  1051.       <dl>
  1052.         <dt>Description:</dt>
  1053.  
  1054.         <dd>
  1055.           <p>At least for important top-level pages it is sometimes
  1056.           necessary to provide the optimum of browser dependent
  1057.           content, i.e. one has to provide a maximum version for the
  1058.           latest Netscape variants, a minimum version for the Lynx
  1059.           browsers and a average feature version for all others.</p>
  1060.         </dd>
  1061.  
  1062.         <dt>Solution:</dt>
  1063.  
  1064.         <dd>
  1065.           <p>We cannot use content negotiation because the browsers do
  1066.           not provide their type in that form. Instead we have to
  1067.           act on the HTTP header "User-Agent". The following condig
  1068.           does the following: If the HTTP header "User-Agent"
  1069.           begins with "Mozilla/3", the page <code>foo.html</code>
  1070.           is rewritten to <code>foo.NS.html</code> and and the
  1071.           rewriting stops. If the browser is "Lynx" or "Mozilla" of
  1072.           version 1 or 2 the URL becomes <code>foo.20.html</code>.
  1073.           All other browsers receive page <code>foo.32.html</code>.
  1074.           This is done by the following ruleset:</p>
  1075.  
  1076. <example><pre>
  1077. RewriteCond %{HTTP_USER_AGENT}  ^<strong>Mozilla/3</strong>.*
  1078. RewriteRule ^foo\.html$         foo.<strong>NS</strong>.html          [<strong>L</strong>]
  1079.  
  1080. RewriteCond %{HTTP_USER_AGENT}  ^<strong>Lynx/</strong>.*         [OR]
  1081. RewriteCond %{HTTP_USER_AGENT}  ^<strong>Mozilla/[12]</strong>.*
  1082. RewriteRule ^foo\.html$         foo.<strong>20</strong>.html          [<strong>L</strong>]
  1083.  
  1084. RewriteRule ^foo\.html$         foo.<strong>32</strong>.html          [<strong>L</strong>]
  1085. </pre></example>
  1086.         </dd>
  1087.       </dl>
  1088.  
  1089.     </section>
  1090.  
  1091.     <section>
  1092.  
  1093.       <title>Dynamic Mirror</title>
  1094.  
  1095.       <dl>
  1096.         <dt>Description:</dt>
  1097.  
  1098.         <dd>
  1099.           <p>Assume there are nice webpages on remote hosts we want
  1100.           to bring into our namespace. For FTP servers we would use
  1101.           the <code>mirror</code> program which actually maintains an
  1102.           explicit up-to-date copy of the remote data on the local
  1103.           machine. For a webserver we could use the program
  1104.           <code>webcopy</code> which acts similar via HTTP. But both
  1105.           techniques have one major drawback: The local copy is
  1106.           always just as up-to-date as often we run the program. It
  1107.           would be much better if the mirror is not a static one we
  1108.           have to establish explicitly. Instead we want a dynamic
  1109.           mirror with data which gets updated automatically when
  1110.           there is need (updated data on the remote host).</p>
  1111.         </dd>
  1112.  
  1113.         <dt>Solution:</dt>
  1114.  
  1115.         <dd>
  1116.           <p>To provide this feature we map the remote webpage or even
  1117.           the complete remote webarea to our namespace by the use
  1118.           of the <dfn>Proxy Throughput</dfn> feature
  1119.           (flag <code>[P]</code>):</p>
  1120.  
  1121. <example><pre>
  1122. RewriteEngine  on
  1123. RewriteBase    /~quux/
  1124. RewriteRule    ^<strong>hotsheet/</strong>(.*)$  <strong>http://www.tstimpreso.com/hotsheet/</strong>$1  [<strong>P</strong>]
  1125. </pre></example>
  1126.  
  1127. <example><pre>
  1128. RewriteEngine  on
  1129. RewriteBase    /~quux/
  1130. RewriteRule    ^<strong>usa-news\.html</strong>$   <strong>http://www.quux-corp.com/news/index.html</strong>  [<strong>P</strong>]
  1131. </pre></example>
  1132.         </dd>
  1133.       </dl>
  1134.  
  1135.     </section>
  1136.  
  1137.     <section>
  1138.  
  1139.       <title>Reverse Dynamic Mirror</title>
  1140.  
  1141.       <dl>
  1142.         <dt>Description:</dt>
  1143.  
  1144.         <dd>...</dd>
  1145.  
  1146.         <dt>Solution:</dt>
  1147.  
  1148.         <dd>
  1149. <example><pre>
  1150. RewriteEngine on
  1151. RewriteCond   /mirror/of/remotesite/$1           -U
  1152. RewriteRule   ^http://www\.remotesite\.com/(.*)$ /mirror/of/remotesite/$1
  1153. </pre></example>
  1154.         </dd>
  1155.       </dl>
  1156.  
  1157.     </section>
  1158.  
  1159.     <section>
  1160.  
  1161.       <title>Retrieve Missing Data from Intranet</title>
  1162.  
  1163.       <dl>
  1164.         <dt>Description:</dt>
  1165.  
  1166.         <dd>
  1167.           <p>This is a tricky way of virtually running a corporate
  1168.           (external) Internet webserver
  1169.           (<code>www.quux-corp.dom</code>), while actually keeping
  1170.           and maintaining its data on a (internal) Intranet webserver
  1171.           (<code>www2.quux-corp.dom</code>) which is protected by a
  1172.           firewall. The trick is that on the external webserver we
  1173.           retrieve the requested data on-the-fly from the internal
  1174.           one.</p>
  1175.         </dd>
  1176.  
  1177.         <dt>Solution:</dt>
  1178.  
  1179.         <dd>
  1180.           <p>First, we have to make sure that our firewall still
  1181.           protects the internal webserver and that only the
  1182.           external webserver is allowed to retrieve data from it.
  1183.           For a packet-filtering firewall we could for instance
  1184.           configure a firewall ruleset like the following:</p>
  1185.  
  1186. <example><pre>
  1187. <strong>ALLOW</strong> Host www.quux-corp.dom Port >1024 --> Host www2.quux-corp.dom Port <strong>80</strong>
  1188. <strong>DENY</strong>  Host *                 Port *     --> Host www2.quux-corp.dom Port <strong>80</strong>
  1189. </pre></example>
  1190.  
  1191.           <p>Just adjust it to your actual configuration syntax.
  1192.           Now we can establish the <module>mod_rewrite</module>
  1193.           rules which request the missing data in the background
  1194.           through the proxy throughput feature:</p>
  1195.  
  1196. <example><pre>
  1197. RewriteRule ^/~([^/]+)/?(.*)          /home/$1/.www/$2
  1198. RewriteCond %{REQUEST_FILENAME}       <strong>!-f</strong>
  1199. RewriteCond %{REQUEST_FILENAME}       <strong>!-d</strong>
  1200. RewriteRule ^/home/([^/]+)/.www/?(.*) http://<strong>www2</strong>.quux-corp.dom/~$1/pub/$2 [<strong>P</strong>]
  1201. </pre></example>
  1202.         </dd>
  1203.       </dl>
  1204.  
  1205.     </section>
  1206.  
  1207.     <section>
  1208.  
  1209.       <title>Load Balancing</title>
  1210.  
  1211.       <dl>
  1212.         <dt>Description:</dt>
  1213.  
  1214.         <dd>
  1215.           <p>Suppose we want to load balance the traffic to
  1216.           <code>www.foo.com</code> over <code>www[0-5].foo.com</code>
  1217.           (a total of 6 servers). How can this be done?</p>
  1218.         </dd>
  1219.  
  1220.         <dt>Solution:</dt>
  1221.  
  1222.         <dd>
  1223.           <p>There are a lot of possible solutions for this problem.
  1224.           We will discuss first a commonly known DNS-based variant
  1225.           and then the special one with <module>mod_rewrite</module>:</p>
  1226.  
  1227.           <ol>
  1228.             <li>
  1229.               <strong>DNS Round-Robin</strong>
  1230.  
  1231.               <p>The simplest method for load-balancing is to use
  1232.               the DNS round-robin feature of <code>BIND</code>.
  1233.               Here you just configure <code>www[0-9].foo.com</code>
  1234.               as usual in your DNS with A(address) records, e.g.</p>
  1235.  
  1236. <example><pre>
  1237. www0   IN  A       1.2.3.1
  1238. www1   IN  A       1.2.3.2
  1239. www2   IN  A       1.2.3.3
  1240. www3   IN  A       1.2.3.4
  1241. www4   IN  A       1.2.3.5
  1242. www5   IN  A       1.2.3.6
  1243. </pre></example>
  1244.  
  1245.               <p>Then you additionally add the following entry:</p>
  1246.  
  1247. <example><pre>
  1248. www    IN  CNAME   www0.foo.com.
  1249.        IN  CNAME   www1.foo.com.
  1250.        IN  CNAME   www2.foo.com.
  1251.        IN  CNAME   www3.foo.com.
  1252.        IN  CNAME   www4.foo.com.
  1253.        IN  CNAME   www5.foo.com.
  1254.        IN  CNAME   www6.foo.com.
  1255. </pre></example>
  1256.  
  1257.               <p>Notice that this seems wrong, but is actually an
  1258.               intended feature of <code>BIND</code> and can be used
  1259.               in this way. However, now when <code>www.foo.com</code> gets
  1260.               resolved, <code>BIND</code> gives out <code>www0-www6</code>
  1261.               - but in a slightly permutated/rotated order every time.
  1262.               This way the clients are spread over the various
  1263.               servers. But notice that this not a perfect load
  1264.               balancing scheme, because DNS resolve information
  1265.               gets cached by the other nameservers on the net, so
  1266.               once a client has resolved <code>www.foo.com</code>
  1267.               to a particular <code>wwwN.foo.com</code>, all
  1268.               subsequent requests also go to this particular name
  1269.               <code>wwwN.foo.com</code>. But the final result is
  1270.               ok, because the total sum of the requests are really
  1271.               spread over the various webservers.</p>
  1272.             </li>
  1273.  
  1274.             <li>
  1275.               <strong>DNS Load-Balancing</strong>
  1276.  
  1277.               <p>A sophisticated DNS-based method for
  1278.               load-balancing is to use the program
  1279.               <code>lbnamed</code> which can be found at <a
  1280.               href="http://www.stanford.edu/~schemers/docs/lbnamed/lbnamed.html">
  1281.               http://www.stanford.edu/~schemers/docs/lbnamed/lbnamed.html</a>.
  1282.               It is a Perl 5 program in conjunction with auxilliary
  1283.               tools which provides a real load-balancing for
  1284.               DNS.</p>
  1285.             </li>
  1286.  
  1287.             <li>
  1288.               <strong>Proxy Throughput Round-Robin</strong>
  1289.  
  1290.               <p>In this variant we use <module>mod_rewrite</module>
  1291.               and its proxy throughput feature. First we dedicate
  1292.               <code>www0.foo.com</code> to be actually
  1293.               <code>www.foo.com</code> by using a single</p>
  1294.  
  1295. <example><pre>
  1296. www    IN  CNAME   www0.foo.com.
  1297. </pre></example>
  1298.  
  1299.               <p>entry in the DNS. Then we convert
  1300.               <code>www0.foo.com</code> to a proxy-only server,
  1301.               i.e. we configure this machine so all arriving URLs
  1302.               are just pushed through the internal proxy to one of
  1303.               the 5 other servers (<code>www1-www5</code>). To
  1304.               accomplish this we first establish a ruleset which
  1305.               contacts a load balancing script <code>lb.pl</code>
  1306.               for all URLs.</p>
  1307.  
  1308. <example><pre>
  1309. RewriteEngine on
  1310. RewriteMap    lb      prg:/path/to/lb.pl
  1311. RewriteRule   ^/(.+)$ ${lb:$1}           [P,L]
  1312. </pre></example>
  1313.  
  1314.               <p>Then we write <code>lb.pl</code>:</p>
  1315.  
  1316. <example><pre>
  1317. #!/path/to/perl
  1318. ##
  1319. ##  lb.pl -- load balancing script
  1320. ##
  1321.  
  1322. $| = 1;
  1323.  
  1324. $name   = "www";     # the hostname base
  1325. $first  = 1;         # the first server (not 0 here, because 0 is myself)
  1326. $last   = 5;         # the last server in the round-robin
  1327. $domain = "foo.dom"; # the domainname
  1328.  
  1329. $cnt = 0;
  1330. while (<STDIN>) {
  1331.     $cnt = (($cnt+1) % ($last+1-$first));
  1332.     $server = sprintf("%s%d.%s", $name, $cnt+$first, $domain);
  1333.     print "http://$server/$_";
  1334. }
  1335.  
  1336. ##EOF##
  1337. </pre></example>
  1338.  
  1339.               <note>A last notice: Why is this useful? Seems like
  1340.               <code>www0.foo.com</code> still is overloaded? The
  1341.               answer is yes, it is overloaded, but with plain proxy
  1342.               throughput requests, only! All SSI, CGI, ePerl, etc.
  1343.               processing is completely done on the other machines.
  1344.               This is the essential point.</note>
  1345.             </li>
  1346.  
  1347.             <li>
  1348.               <strong>Hardware/TCP Round-Robin</strong>
  1349.  
  1350.               <p>There is a hardware solution available, too. Cisco
  1351.               has a beast called LocalDirector which does a load
  1352.               balancing at the TCP/IP level. Actually this is some
  1353.               sort of a circuit level gateway in front of a
  1354.               webcluster. If you have enough money and really need
  1355.               a solution with high performance, use this one.</p>
  1356.             </li>
  1357.           </ol>
  1358.         </dd>
  1359.       </dl>
  1360.  
  1361.     </section>
  1362.  
  1363.     <section>
  1364.  
  1365.       <title>Reverse Proxy</title>
  1366.  
  1367.       <dl>
  1368.         <dt>Description:</dt>
  1369.  
  1370.         <dd>...</dd>
  1371.  
  1372.         <dt>Solution:</dt>
  1373.  
  1374.         <dd>
  1375. <example><pre>
  1376. ##
  1377. ##  apache-rproxy.conf -- Apache configuration for Reverse Proxy Usage
  1378. ##
  1379.  
  1380. #   server type
  1381. ServerType           standalone
  1382. Listen               8000
  1383. MinSpareServers      16
  1384. StartServers         16
  1385. MaxSpareServers      16
  1386. MaxClients           16
  1387. MaxRequestsPerChild  100
  1388.  
  1389. #   server operation parameters
  1390. KeepAlive            on
  1391. MaxKeepAliveRequests 100
  1392. KeepAliveTimeout     15
  1393. Timeout              400
  1394. IdentityCheck        off
  1395. HostnameLookups      off
  1396.  
  1397. #   paths to runtime files
  1398. PidFile              /path/to/apache-rproxy.pid
  1399. LockFile             /path/to/apache-rproxy.lock
  1400. ErrorLog             /path/to/apache-rproxy.elog
  1401. CustomLog            /path/to/apache-rproxy.dlog "%{%v/%T}t %h -> %{SERVER}e URL: %U"
  1402.  
  1403. #   unused paths
  1404. ServerRoot           /tmp
  1405. DocumentRoot         /tmp
  1406. CacheRoot            /tmp
  1407. RewriteLog           /dev/null
  1408. TransferLog          /dev/null
  1409. TypesConfig          /dev/null
  1410. AccessConfig         /dev/null
  1411. ResourceConfig       /dev/null
  1412.  
  1413. #   speed up and secure processing
  1414. <Directory />
  1415. Options -FollowSymLinks -SymLinksIfOwnerMatch
  1416. AllowOverride None
  1417. </Directory>
  1418.  
  1419. #   the status page for monitoring the reverse proxy
  1420. <Location /apache-rproxy-status>
  1421. SetHandler server-status
  1422. </Location>
  1423.  
  1424. #   enable the URL rewriting engine
  1425. RewriteEngine        on
  1426. RewriteLogLevel      0
  1427.  
  1428. #   define a rewriting map with value-lists where
  1429. #   mod_rewrite randomly chooses a particular value
  1430. RewriteMap     server  rnd:/path/to/apache-rproxy.conf-servers
  1431.  
  1432. #   make sure the status page is handled locally
  1433. #   and make sure no one uses our proxy except ourself
  1434. RewriteRule    ^/apache-rproxy-status.*  -  [L]
  1435. RewriteRule    ^(http|ftp)://.*          -  [F]
  1436.  
  1437. #   now choose the possible servers for particular URL types
  1438. RewriteRule    ^/(.*\.(cgi|shtml))$  to://${server:dynamic}/$1  [S=1]
  1439. RewriteRule    ^/(.*)$               to://${server:static}/$1
  1440.  
  1441. #   and delegate the generated URL by passing it
  1442. #   through the proxy module
  1443. RewriteRule    ^to://([^/]+)/(.*)    http://$1/$2   [E=SERVER:$1,P,L]
  1444.  
  1445. #   and make really sure all other stuff is forbidden
  1446. #   when it should survive the above rules...
  1447. RewriteRule    .*                    -              [F]
  1448.  
  1449. #   enable the Proxy module without caching
  1450. ProxyRequests        on
  1451. NoCache              *
  1452.  
  1453. #   setup URL reverse mapping for redirect reponses
  1454. ProxyPassReverse  /  http://www1.foo.dom/
  1455. ProxyPassReverse  /  http://www2.foo.dom/
  1456. ProxyPassReverse  /  http://www3.foo.dom/
  1457. ProxyPassReverse  /  http://www4.foo.dom/
  1458. ProxyPassReverse  /  http://www5.foo.dom/
  1459. ProxyPassReverse  /  http://www6.foo.dom/
  1460. </pre></example>
  1461.  
  1462. <example><pre>
  1463. ##
  1464. ##  apache-rproxy.conf-servers -- Apache/mod_rewrite selection table
  1465. ##
  1466.  
  1467. #   list of backend servers which serve static
  1468. #   pages (HTML files and Images, etc.)
  1469. static    www1.foo.dom|www2.foo.dom|www3.foo.dom|www4.foo.dom
  1470.  
  1471. #   list of backend servers which serve dynamically
  1472. #   generated page (CGI programs or mod_perl scripts)
  1473. dynamic   www5.foo.dom|www6.foo.dom
  1474. </pre></example>
  1475.         </dd>
  1476.       </dl>
  1477.  
  1478.     </section>
  1479.  
  1480.     <section>
  1481.  
  1482.       <title>New MIME-type, New Service</title>
  1483.  
  1484.       <dl>
  1485.         <dt>Description:</dt>
  1486.  
  1487.         <dd>
  1488.           <p>On the net there are a lot of nifty CGI programs. But
  1489.           their usage is usually boring, so a lot of webmaster
  1490.           don't use them. Even Apache's Action handler feature for
  1491.           MIME-types is only appropriate when the CGI programs
  1492.           don't need special URLs (actually <code>PATH_INFO</code>
  1493.           and <code>QUERY_STRINGS</code>) as their input. First,
  1494.           let us configure a new file type with extension
  1495.           <code>.scgi</code> (for secure CGI) which will be processed
  1496.           by the popular <code>cgiwrap</code> program. The problem
  1497.           here is that for instance we use a Homogeneous URL Layout
  1498.           (see above) a file inside the user homedirs has the URL
  1499.           <code>/u/user/foo/bar.scgi</code>. But
  1500.           <code>cgiwrap</code> needs the URL in the form
  1501.           <code>/~user/foo/bar.scgi/</code>. The following rule
  1502.           solves the problem:</p>
  1503.  
  1504. <example><pre>
  1505. RewriteRule ^/[uge]/<strong>([^/]+)</strong>/\.www/(.+)\.scgi(.*) ...
  1506. ... /internal/cgi/user/cgiwrap/~<strong>$1</strong>/$2.scgi$3  [NS,<strong>T=application/x-http-cgi</strong>]
  1507. </pre></example>
  1508.  
  1509.           <p>Or assume we have some more nifty programs:
  1510.           <code>wwwlog</code> (which displays the
  1511.           <code>access.log</code> for a URL subtree and
  1512.           <code>wwwidx</code> (which runs Glimpse on a URL
  1513.           subtree). We have to provide the URL area to these
  1514.           programs so they know on which area they have to act on.
  1515.           But usually this ugly, because they are all the times
  1516.           still requested from that areas, i.e. typically we would
  1517.           run the <code>swwidx</code> program from within
  1518.           <code>/u/user/foo/</code> via hyperlink to</p>
  1519.  
  1520. <example><pre>
  1521. /internal/cgi/user/swwidx?i=/u/user/foo/
  1522. </pre></example>
  1523.  
  1524.           <p>which is ugly. Because we have to hard-code
  1525.           <strong>both</strong> the location of the area
  1526.           <strong>and</strong> the location of the CGI inside the
  1527.           hyperlink. When we have to reorganize the area, we spend a
  1528.           lot of time changing the various hyperlinks.</p>
  1529.         </dd>
  1530.  
  1531.         <dt>Solution:</dt>
  1532.  
  1533.         <dd>
  1534.           <p>The solution here is to provide a special new URL format
  1535.           which automatically leads to the proper CGI invocation.
  1536.           We configure the following:</p>
  1537.  
  1538. <example><pre>
  1539. RewriteRule   ^/([uge])/([^/]+)(/?.*)/\*  /internal/cgi/user/wwwidx?i=/$1/$2$3/
  1540. RewriteRule   ^/([uge])/([^/]+)(/?.*):log /internal/cgi/user/wwwlog?f=/$1/$2$3
  1541. </pre></example>
  1542.  
  1543.           <p>Now the hyperlink to search at
  1544.           <code>/u/user/foo/</code> reads only</p>
  1545.  
  1546. <example><pre>
  1547. HREF="*"
  1548. </pre></example>
  1549.  
  1550.           <p>which internally gets automatically transformed to</p>
  1551.  
  1552. <example><pre>
  1553. /internal/cgi/user/wwwidx?i=/u/user/foo/
  1554. </pre></example>
  1555.  
  1556.           <p>The same approach leads to an invocation for the
  1557.           access log CGI program when the hyperlink
  1558.           <code>:log</code> gets used.</p>
  1559.         </dd>
  1560.       </dl>
  1561.  
  1562.     </section>
  1563.  
  1564.     <section>
  1565.  
  1566.       <title>From Static to Dynamic</title>
  1567.  
  1568.       <dl>
  1569.         <dt>Description:</dt>
  1570.  
  1571.         <dd>
  1572.           <p>How can we transform a static page
  1573.           <code>foo.html</code> into a dynamic variant
  1574.           <code>foo.cgi</code> in a seamless way, i.e. without notice
  1575.           by the browser/user.</p>
  1576.         </dd>
  1577.  
  1578.         <dt>Solution:</dt>
  1579.  
  1580.         <dd>
  1581.           <p>We just rewrite the URL to the CGI-script and force the
  1582.           correct MIME-type so it gets really run as a CGI-script.
  1583.           This way a request to <code>/~quux/foo.html</code>
  1584.           internally leads to the invocation of
  1585.           <code>/~quux/foo.cgi</code>.</p>
  1586.  
  1587. <example><pre>
  1588. RewriteEngine  on
  1589. RewriteBase    /~quux/
  1590. RewriteRule    ^foo\.<strong>html</strong>$  foo.<strong>cgi</strong>  [T=<strong>application/x-httpd-cgi</strong>]
  1591. </pre></example>
  1592.         </dd>
  1593.       </dl>
  1594.  
  1595.     </section>
  1596.  
  1597.     <section>
  1598.  
  1599.       <title>On-the-fly Content-Regeneration</title>
  1600.  
  1601.       <dl>
  1602.         <dt>Description:</dt>
  1603.  
  1604.         <dd>
  1605.           <p>Here comes a really esoteric feature: Dynamically
  1606.           generated but statically served pages, i.e. pages should be
  1607.           delivered as pure static pages (read from the filesystem
  1608.           and just passed through), but they have to be generated
  1609.           dynamically by the webserver if missing. This way you can
  1610.           have CGI-generated pages which are statically served unless
  1611.           one (or a cronjob) removes the static contents. Then the
  1612.           contents gets refreshed.</p>
  1613.         </dd>
  1614.  
  1615.         <dt>Solution:</dt>
  1616.  
  1617.         <dd>
  1618.           This is done via the following ruleset:
  1619.  
  1620. <example><pre>
  1621. RewriteCond %{REQUEST_FILENAME}   <strong>!-s</strong>
  1622. RewriteRule ^page\.<strong>html</strong>$          page.<strong>cgi</strong>   [T=application/x-httpd-cgi,L]
  1623. </pre></example>
  1624.  
  1625.           <p>Here a request to <code>page.html</code> leads to a
  1626.           internal run of a corresponding <code>page.cgi</code> if
  1627.           <code>page.html</code> is still missing or has filesize
  1628.           null. The trick here is that <code>page.cgi</code> is a
  1629.           usual CGI script which (additionally to its <code>STDOUT</code>)
  1630.           writes its output to the file <code>page.html</code>.
  1631.           Once it was run, the server sends out the data of
  1632.           <code>page.html</code>. When the webmaster wants to force
  1633.           a refresh the contents, he just removes
  1634.           <code>page.html</code> (usually done by a cronjob).</p>
  1635.         </dd>
  1636.       </dl>
  1637.  
  1638.     </section>
  1639.  
  1640.     <section>
  1641.  
  1642.       <title>Document With Autorefresh</title>
  1643.  
  1644.       <dl>
  1645.         <dt>Description:</dt>
  1646.  
  1647.         <dd>
  1648.           <p>Wouldn't it be nice while creating a complex webpage if
  1649.           the webbrowser would automatically refresh the page every
  1650.           time we write a new version from within our editor?
  1651.           Impossible?</p>
  1652.         </dd>
  1653.  
  1654.         <dt>Solution:</dt>
  1655.  
  1656.         <dd>
  1657.           <p>No! We just combine the MIME multipart feature, the
  1658.           webserver NPH feature and the URL manipulation power of
  1659.           <module>mod_rewrite</module>. First, we establish a new
  1660.           URL feature: Adding just <code>:refresh</code> to any
  1661.           URL causes this to be refreshed every time it gets
  1662.           updated on the filesystem.</p>
  1663.  
  1664. <example><pre>
  1665. RewriteRule   ^(/[uge]/[^/]+/?.*):refresh  /internal/cgi/apache/nph-refresh?f=$1
  1666. </pre></example>
  1667.  
  1668.           <p>Now when we reference the URL</p>
  1669.  
  1670. <example><pre>
  1671. /u/foo/bar/page.html:refresh
  1672. </pre></example>
  1673.  
  1674.           <p>this leads to the internal invocation of the URL</p>
  1675.  
  1676. <example><pre>
  1677. /internal/cgi/apache/nph-refresh?f=/u/foo/bar/page.html
  1678. </pre></example>
  1679.  
  1680.           <p>The only missing part is the NPH-CGI script. Although
  1681.           one would usually say "left as an exercise to the reader"
  1682.           ;-) I will provide this, too.</p>
  1683.  
  1684. <example><pre>
  1685. #!/sw/bin/perl
  1686. ##
  1687. ##  nph-refresh -- NPH/CGI script for auto refreshing pages
  1688. ##  Copyright (c) 1997 Ralf S. Engelschall, All Rights Reserved.
  1689. ##
  1690. $| = 1;
  1691.  
  1692. #   split the QUERY_STRING variable
  1693. @pairs = split(/&/, $ENV{'QUERY_STRING'});
  1694. foreach $pair (@pairs) {
  1695.     ($name, $value) = split(/=/, $pair);
  1696.     $name =~ tr/A-Z/a-z/;
  1697.     $name = 'QS_' . $name;
  1698.     $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
  1699.     eval "\$$name = \"$value\"";
  1700. }
  1701. $QS_s = 1 if ($QS_s eq '');
  1702. $QS_n = 3600 if ($QS_n eq '');
  1703. if ($QS_f eq '') {
  1704.     print "HTTP/1.0 200 OK\n";
  1705.     print "Content-type: text/html\n\n";
  1706.     print "&lt;b&gt;ERROR&lt;/b&gt;: No file given\n";
  1707.     exit(0);
  1708. }
  1709. if (! -f $QS_f) {
  1710.     print "HTTP/1.0 200 OK\n";
  1711.     print "Content-type: text/html\n\n";
  1712.     print "&lt;b&gt;ERROR&lt;/b&gt;: File $QS_f not found\n";
  1713.     exit(0);
  1714. }
  1715.  
  1716. sub print_http_headers_multipart_begin {
  1717.     print "HTTP/1.0 200 OK\n";
  1718.     $bound = "ThisRandomString12345";
  1719.     print "Content-type: multipart/x-mixed-replace;boundary=$bound\n";
  1720.     &print_http_headers_multipart_next;
  1721. }
  1722.  
  1723. sub print_http_headers_multipart_next {
  1724.     print "\n--$bound\n";
  1725. }
  1726.  
  1727. sub print_http_headers_multipart_end {
  1728.     print "\n--$bound--\n";
  1729. }
  1730.  
  1731. sub displayhtml {
  1732.     local($buffer) = @_;
  1733.     $len = length($buffer);
  1734.     print "Content-type: text/html\n";
  1735.     print "Content-length: $len\n\n";
  1736.     print $buffer;
  1737. }
  1738.  
  1739. sub readfile {
  1740.     local($file) = @_;
  1741.     local(*FP, $size, $buffer, $bytes);
  1742.     ($x, $x, $x, $x, $x, $x, $x, $size) = stat($file);
  1743.     $size = sprintf("%d", $size);
  1744.     open(FP, "&lt;$file");
  1745.     $bytes = sysread(FP, $buffer, $size);
  1746.     close(FP);
  1747.     return $buffer;
  1748. }
  1749.  
  1750. $buffer = &readfile($QS_f);
  1751. &print_http_headers_multipart_begin;
  1752. &displayhtml($buffer);
  1753.  
  1754. sub mystat {
  1755.     local($file) = $_[0];
  1756.     local($time);
  1757.  
  1758.     ($x, $x, $x, $x, $x, $x, $x, $x, $x, $mtime) = stat($file);
  1759.     return $mtime;
  1760. }
  1761.  
  1762. $mtimeL = &mystat($QS_f);
  1763. $mtime = $mtime;
  1764. for ($n = 0; $n &lt; $QS_n; $n++) {
  1765.     while (1) {
  1766.         $mtime = &mystat($QS_f);
  1767.         if ($mtime ne $mtimeL) {
  1768.             $mtimeL = $mtime;
  1769.             sleep(2);
  1770.             $buffer = &readfile($QS_f);
  1771.             &print_http_headers_multipart_next;
  1772.             &displayhtml($buffer);
  1773.             sleep(5);
  1774.             $mtimeL = &mystat($QS_f);
  1775.             last;
  1776.         }
  1777.         sleep($QS_s);
  1778.     }
  1779. }
  1780.  
  1781. &print_http_headers_multipart_end;
  1782.  
  1783. exit(0);
  1784.  
  1785. ##EOF##
  1786. </pre></example>
  1787.         </dd>
  1788.       </dl>
  1789.  
  1790.     </section>
  1791.  
  1792.     <section>
  1793.  
  1794.       <title>Mass Virtual Hosting</title>
  1795.  
  1796.       <dl>
  1797.         <dt>Description:</dt>
  1798.  
  1799.         <dd>
  1800.           <p>The <directive type="section" module="core"
  1801.           >VirtualHost</directive> feature of Apache is nice
  1802.           and works great when you just have a few dozens
  1803.           virtual hosts. But when you are an ISP and have hundreds of
  1804.           virtual hosts to provide this feature is not the best
  1805.           choice.</p>
  1806.         </dd>
  1807.  
  1808.         <dt>Solution:</dt>
  1809.  
  1810.         <dd>
  1811.           <p>To provide this feature we map the remote webpage or even
  1812.           the complete remote webarea to our namespace by the use
  1813.           of the <dfn>Proxy Throughput</dfn> feature (flag <code>[P]</code>):</p>
  1814.  
  1815. <example><pre>
  1816. ##
  1817. ##  vhost.map
  1818. ##
  1819. www.vhost1.dom:80  /path/to/docroot/vhost1
  1820. www.vhost2.dom:80  /path/to/docroot/vhost2
  1821.      :
  1822. www.vhostN.dom:80  /path/to/docroot/vhostN
  1823. </pre></example>
  1824.  
  1825. <example><pre>
  1826. ##
  1827. ##  httpd.conf
  1828. ##
  1829.     :
  1830. #   use the canonical hostname on redirects, etc.
  1831. UseCanonicalName on
  1832.  
  1833.     :
  1834. #   add the virtual host in front of the CLF-format
  1835. CustomLog  /path/to/access_log  "%{VHOST}e %h %l %u %t \"%r\" %>s %b"
  1836.     :
  1837.  
  1838. #   enable the rewriting engine in the main server
  1839. RewriteEngine on
  1840.  
  1841. #   define two maps: one for fixing the URL and one which defines
  1842. #   the available virtual hosts with their corresponding
  1843. #   DocumentRoot.
  1844. RewriteMap    lowercase    int:tolower
  1845. RewriteMap    vhost        txt:/path/to/vhost.map
  1846.  
  1847. #   Now do the actual virtual host mapping
  1848. #   via a huge and complicated single rule:
  1849. #
  1850. #   1. make sure we don't map for common locations
  1851. RewriteCond   %{REQUEST_URL}  !^/commonurl1/.*
  1852. RewriteCond   %{REQUEST_URL}  !^/commonurl2/.*
  1853.     :
  1854. RewriteCond   %{REQUEST_URL}  !^/commonurlN/.*
  1855. #
  1856. #   2. make sure we have a Host header, because
  1857. #      currently our approach only supports
  1858. #      virtual hosting through this header
  1859. RewriteCond   %{HTTP_HOST}  !^$
  1860. #
  1861. #   3. lowercase the hostname
  1862. RewriteCond   ${lowercase:%{HTTP_HOST}|NONE}  ^(.+)$
  1863. #
  1864. #   4. lookup this hostname in vhost.map and
  1865. #      remember it only when it is a path
  1866. #      (and not "NONE" from above)
  1867. RewriteCond   ${vhost:%1}  ^(/.*)$
  1868. #
  1869. #   5. finally we can map the URL to its docroot location
  1870. #      and remember the virtual host for logging puposes
  1871. RewriteRule   ^/(.*)$   %1/$1  [E=VHOST:${lowercase:%{HTTP_HOST}}]
  1872.     :
  1873. </pre></example>
  1874.         </dd>
  1875.       </dl>
  1876.  
  1877.     </section>
  1878.  
  1879.   </section>
  1880.  
  1881.   <section id="access">
  1882.  
  1883.     <title>Access Restriction</title>
  1884.  
  1885.     <section>
  1886.  
  1887.       <title>Blocking of Robots</title>
  1888.  
  1889.       <dl>
  1890.         <dt>Description:</dt>
  1891.  
  1892.         <dd>
  1893.           <p>How can we block a really annoying robot from
  1894.           retrieving pages of a specific webarea? A
  1895.           <code>/robots.txt</code> file containing entries of the
  1896.           "Robot Exclusion Protocol" is typically not enough to get
  1897.           rid of such a robot.</p>
  1898.         </dd>
  1899.  
  1900.         <dt>Solution:</dt>
  1901.  
  1902.         <dd>
  1903.           <p>We use a ruleset which forbids the URLs of the webarea
  1904.           <code>/~quux/foo/arc/</code> (perhaps a very deep
  1905.           directory indexed area where the robot traversal would
  1906.           create big server load). We have to make sure that we
  1907.           forbid access only to the particular robot, i.e. just
  1908.           forbidding the host where the robot runs is not enough.
  1909.           This would block users from this host, too. We accomplish
  1910.           this by also matching the User-Agent HTTP header
  1911.           information.</p>
  1912.  
  1913. <example><pre>
  1914. RewriteCond %{HTTP_USER_AGENT}   ^<strong>NameOfBadRobot</strong>.*
  1915. RewriteCond %{REMOTE_ADDR}       ^<strong>123\.45\.67\.[8-9]</strong>$
  1916. RewriteRule ^<strong>/~quux/foo/arc/</strong>.+   -   [<strong>F</strong>]
  1917. </pre></example>
  1918.         </dd>
  1919.       </dl>
  1920.  
  1921.     </section>
  1922.  
  1923.     <section>
  1924.  
  1925.       <title>Blocked Inline-Images</title>
  1926.  
  1927.       <dl>
  1928.         <dt>Description:</dt>
  1929.  
  1930.         <dd>
  1931.           <p>Assume we have under <code>http://www.quux-corp.de/~quux/</code>
  1932.           some pages with inlined GIF graphics. These graphics are
  1933.           nice, so others directly incorporate them via hyperlinks to
  1934.           their pages. We don't like this practice because it adds
  1935.           useless traffic to our server.</p>
  1936.         </dd>
  1937.  
  1938.         <dt>Solution:</dt>
  1939.  
  1940.         <dd>
  1941.           <p>While we cannot 100% protect the images from inclusion,
  1942.           we can at least restrict the cases where the browser
  1943.           sends a HTTP Referer header.</p>
  1944.  
  1945. <example><pre>
  1946. RewriteCond %{HTTP_REFERER} <strong>!^$</strong>
  1947. RewriteCond %{HTTP_REFERER} !^http://www.quux-corp.de/~quux/.*$ [NC]
  1948. RewriteRule <strong>.*\.gif$</strong>        -                                    [F]
  1949. </pre></example>
  1950.  
  1951. <example><pre>
  1952. RewriteCond %{HTTP_REFERER}         !^$
  1953. RewriteCond %{HTTP_REFERER}         !.*/foo-with-gif\.html$
  1954. RewriteRule <strong>^inlined-in-foo\.gif$</strong>   -                        [F]
  1955. </pre></example>
  1956.         </dd>
  1957.       </dl>
  1958.  
  1959.     </section>
  1960.  
  1961.     <section>
  1962.  
  1963.       <title>Host Deny</title>
  1964.  
  1965.       <dl>
  1966.         <dt>Description:</dt>
  1967.  
  1968.         <dd>
  1969.           <p>How can we forbid a list of externally configured hosts
  1970.           from using our server?</p>
  1971.         </dd>
  1972.  
  1973.         <dt>Solution:</dt>
  1974.  
  1975.         <dd>
  1976.           <p>For Apache >= 1.3b6:</p>
  1977.  
  1978. <example><pre>
  1979. RewriteEngine on
  1980. RewriteMap    hosts-deny  txt:/path/to/hosts.deny
  1981. RewriteCond   ${hosts-deny:%{REMOTE_HOST}|NOT-FOUND} !=NOT-FOUND [OR]
  1982. RewriteCond   ${hosts-deny:%{REMOTE_ADDR}|NOT-FOUND} !=NOT-FOUND
  1983. RewriteRule   ^/.*  -  [F]
  1984. </pre></example>
  1985.  
  1986.           <p>For Apache <= 1.3b6:</p>
  1987.  
  1988. <example><pre>
  1989. RewriteEngine on
  1990. RewriteMap    hosts-deny  txt:/path/to/hosts.deny
  1991. RewriteRule   ^/(.*)$ ${hosts-deny:%{REMOTE_HOST}|NOT-FOUND}/$1
  1992. RewriteRule   !^NOT-FOUND/.* - [F]
  1993. RewriteRule   ^NOT-FOUND/(.*)$ ${hosts-deny:%{REMOTE_ADDR}|NOT-FOUND}/$1
  1994. RewriteRule   !^NOT-FOUND/.* - [F]
  1995. RewriteRule   ^NOT-FOUND/(.*)$ /$1
  1996. </pre></example>
  1997.  
  1998. <example><pre>
  1999. ##
  2000. ##  hosts.deny
  2001. ##
  2002. ##  ATTENTION! This is a map, not a list, even when we treat it as such.
  2003. ##             mod_rewrite parses it for key/value pairs, so at least a
  2004. ##             dummy value "-" must be present for each entry.
  2005. ##
  2006.  
  2007. 193.102.180.41 -
  2008. bsdti1.sdm.de  -
  2009. 192.76.162.40  -
  2010. </pre></example>
  2011.         </dd>
  2012.       </dl>
  2013.  
  2014.     </section>
  2015.  
  2016.     <section>
  2017.  
  2018.       <title>Proxy Deny</title>
  2019.  
  2020.       <dl>
  2021.         <dt>Description:</dt>
  2022.  
  2023.         <dd>
  2024.           <p>How can we forbid a certain host or even a user of a
  2025.           special host from using the Apache proxy?</p>
  2026.         </dd>
  2027.  
  2028.         <dt>Solution:</dt>
  2029.  
  2030.         <dd>
  2031.           <p>We first have to make sure <module>mod_rewrite</module>
  2032.           is below(!) <module>mod_proxy</module> in the Configuration
  2033.           file when compiling the Apache webserver. This way it gets
  2034.           called <em>before</em> <module>mod_proxy</module>. Then we
  2035.           configure the following for a host-dependent deny...</p>
  2036.  
  2037. <example><pre>
  2038. RewriteCond %{REMOTE_HOST} <strong>^badhost\.mydomain\.com$</strong>
  2039. RewriteRule !^http://[^/.]\.mydomain.com.*  - [F]
  2040. </pre></example>
  2041.  
  2042.           <p>...and this one for a user@host-dependent deny:</p>
  2043.  
  2044. <example><pre>
  2045. RewriteCond %{REMOTE_IDENT}@%{REMOTE_HOST}  <strong>^badguy@badhost\.mydomain\.com$</strong>
  2046. RewriteRule !^http://[^/.]\.mydomain.com.*  - [F]
  2047. </pre></example>
  2048.         </dd>
  2049.       </dl>
  2050.  
  2051.     </section>
  2052.  
  2053.     <section>
  2054.  
  2055.       <title>Special Authentication Variant</title>
  2056.  
  2057.       <dl>
  2058.         <dt>Description:</dt>
  2059.  
  2060.         <dd>
  2061.           <p>Sometimes a very special authentication is needed, for
  2062.           instance a authentication which checks for a set of
  2063.           explicitly configured users. Only these should receive
  2064.           access and without explicit prompting (which would occur
  2065.           when using the Basic Auth via <module>mod_auth</module>).</p>
  2066.         </dd>
  2067.  
  2068.         <dt>Solution:</dt>
  2069.  
  2070.         <dd>
  2071.           <p>We use a list of rewrite conditions to exclude all except
  2072.           our friends:</p>
  2073.  
  2074. <example><pre>
  2075. RewriteCond %{REMOTE_IDENT}@%{REMOTE_HOST} <strong>!^friend1@client1.quux-corp\.com$</strong>
  2076. RewriteCond %{REMOTE_IDENT}@%{REMOTE_HOST} <strong>!^friend2</strong>@client2.quux-corp\.com$
  2077. RewriteCond %{REMOTE_IDENT}@%{REMOTE_HOST} <strong>!^friend3</strong>@client3.quux-corp\.com$
  2078. RewriteRule ^/~quux/only-for-friends/      -                                 [F]
  2079. </pre></example>
  2080.         </dd>
  2081.       </dl>
  2082.  
  2083.     </section>
  2084.  
  2085.     <section>
  2086.  
  2087.       <title>Referer-based Deflector</title>
  2088.  
  2089.       <dl>
  2090.         <dt>Description:</dt>
  2091.  
  2092.         <dd>
  2093.           <p>How can we program a flexible URL Deflector which acts
  2094.           on the "Referer" HTTP header and can be configured with as
  2095.           many referring pages as we like?</p>
  2096.         </dd>
  2097.  
  2098.         <dt>Solution:</dt>
  2099.  
  2100.         <dd>
  2101.           <p>Use the following really tricky ruleset...</p>
  2102.  
  2103. <example><pre>
  2104. RewriteMap  deflector txt:/path/to/deflector.map
  2105.  
  2106. RewriteCond %{HTTP_REFERER} !=""
  2107. RewriteCond ${deflector:%{HTTP_REFERER}} ^-$
  2108. RewriteRule ^.* %{HTTP_REFERER} [R,L]
  2109.  
  2110. RewriteCond %{HTTP_REFERER} !=""
  2111. RewriteCond ${deflector:%{HTTP_REFERER}|NOT-FOUND} !=NOT-FOUND
  2112. RewriteRule ^.* ${deflector:%{HTTP_REFERER}} [R,L]
  2113. </pre></example>
  2114.  
  2115.           <p>... in conjunction with a corresponding rewrite
  2116.           map:</p>
  2117.  
  2118. <example><pre>
  2119. ##
  2120. ##  deflector.map
  2121. ##
  2122.  
  2123. http://www.badguys.com/bad/index.html    -
  2124. http://www.badguys.com/bad/index2.html   -
  2125. http://www.badguys.com/bad/index3.html   http://somewhere.com/
  2126. </pre></example>
  2127.  
  2128.           <p>This automatically redirects the request back to the
  2129.           referring page (when "<code>-</code>" is used as the value
  2130.           in the map) or to a specific URL (when an URL is specified
  2131.           in the map as the second argument).</p>
  2132.         </dd>
  2133.       </dl>
  2134.  
  2135.     </section>
  2136.  
  2137.   </section>
  2138.  
  2139.   <section id="other">
  2140.  
  2141.     <title>Other</title>
  2142.  
  2143.     <section>
  2144.  
  2145.       <title>External Rewriting Engine</title>
  2146.  
  2147.       <dl>
  2148.         <dt>Description:</dt>
  2149.  
  2150.         <dd>
  2151.           <p>A FAQ: How can we solve the FOO/BAR/QUUX/etc.
  2152.           problem? There seems no solution by the use of
  2153.           <module>mod_rewrite</module>...</p>
  2154.         </dd>
  2155.  
  2156.         <dt>Solution:</dt>
  2157.  
  2158.         <dd>
  2159.           <p>Use an external <directive module="mod_rewrite"
  2160.           >RewriteMap</directive>, i.e. a program which acts
  2161.           like a <directive module="mod_rewrite"
  2162.           >RewriteMap</directive>. It is run once on startup of Apache
  2163.           receives the requested URLs on <code>STDIN</code> and has
  2164.           to put the resulting (usually rewritten) URL on
  2165.           <code>STDOUT</code> (same order!).</p>
  2166.  
  2167. <example><pre>
  2168. RewriteEngine on
  2169. RewriteMap    quux-map       <strong>prg:</strong>/path/to/map.quux.pl
  2170. RewriteRule   ^/~quux/(.*)$  /~quux/<strong>${quux-map:$1}</strong>
  2171. </pre></example>
  2172.  
  2173. <example><pre>
  2174. #!/path/to/perl
  2175.  
  2176. #   disable buffered I/O which would lead
  2177. #   to deadloops for the Apache server
  2178. $| = 1;
  2179.  
  2180. #   read URLs one per line from stdin and
  2181. #   generate substitution URL on stdout
  2182. while (<>) {
  2183.     s|^foo/|bar/|;
  2184.     print $_;
  2185. }
  2186. </pre></example>
  2187.  
  2188.           <p>This is a demonstration-only example and just rewrites
  2189.           all URLs <code>/~quux/foo/...</code> to
  2190.           <code>/~quux/bar/...</code>. Actually you can program
  2191.           whatever you like. But notice that while such maps can be
  2192.           <strong>used</strong> also by an average user, only the
  2193.           system administrator can <strong>define</strong> it.</p>
  2194.         </dd>
  2195.       </dl>
  2196.  
  2197.     </section>
  2198.  
  2199.   </section>
  2200.  
  2201. </manualpage>
  2202.  
  2203.