| <?xml version="1.0" ?> |
| <!DOCTYPE modulesynopsis SYSTEM "../style/modulesynopsis.dtd"> |
| <?xml-stylesheet type="text/xsl" href="../style/manual.fr.xsl"?> |
| <!-- English Revision: 1725069 --> |
| <!-- French translation : Lucien GENTIS --> |
| <!-- Reviewed by : Vincent Deffontaines --> |
| |
| <!-- |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| --> |
| |
| <modulesynopsis metafile="mod_rewrite.xml.meta"> |
| |
| <name>mod_rewrite</name> |
| |
| <description>Ce module fournit un moteur de réécriture à base de |
| règles permettant de réécrire les URLs des requêtes |
| à la volée</description> |
| |
| <status>Extension</status> |
| <sourcefile>mod_rewrite.c</sourcefile> |
| <identifier>rewrite_module</identifier> |
| <compatibility>Disponible à partir de la version 1.3 |
| d'Apache</compatibility> |
| |
| <summary> |
| <p>Ce module utilise un moteur de réécriture à base de règles |
| (basé sur un interpréteur d'expressions rationnelles) pour |
| réécrire les URLs des requêtes à la volée. Il accepte un nombre |
| illimité de règles, ainsi q'un nombre illimité de conditions |
| attachées à chaque règle, fournissant ainsi un mécanisme de |
| manipulation d'URL vraiment souple et puissant. Les manipulations |
| d'URL peuvent dépendre de nombreux tests, des variables du |
| serveur, des variables d'environnement, des en-têtes HTTP ou de |
| l'horodatage. On peut même lancer des requêtes vers une base de |
| données externe sous divers formats, afin d'obtenir une |
| sélection d'URL très fine.</p> |
| |
| <p>Ce module agit sur l'ensemble de l'URL (la partie concernant |
| le chemin incluse) au niveau du serveur |
| (<code>httpd.conf</code>) mais aussi au niveau du répertoire |
| (<code>.htaccess</code>), et peut générer des parties de chaîne |
| de requête comme résultat. Le résultat de la réécriture peut |
| renvoyer vers un sous-traitement interne, une redirection vers |
| une requête externe, ou même vers le flux d'un proxy interne.</p> |
| |
| <p>Vous trouverez d'avantage de détails, discussions et exemples |
| dans la |
| <a href="../rewrite/">documentation détaillée |
| sur mod_rewrite</a>.</p> |
| </summary> |
| |
| <seealso><a href="#rewriteflags">Drapeaux des règles de réécriture</a></seealso> |
| |
| |
| <section id="quoting"><title>Marquage des caractères spéciaux</title> |
| |
| <p>Depuis Apache 1.3.20, les caractères spéciaux dans les |
| <em>chaînes de test</em> et les chaînes de <em>Substitution</em> |
| peuvent être échappés (c'est à dire traités comme des caractères |
| normaux sans tenir compte de leur signification en tant que |
| caractère spécial), en les faisant précéder d'un caractère |
| anti-slash ('\'). En d'autres termes, vous pouvez inclure un |
| véritable signe "dollar" dans une chaîne de <em>Substitution</em> |
| en utilisant '<code>\$</code>' ; ceci empêche mod_rewrite de le |
| traiter comme une référence arrière.</p> |
| </section> |
| |
| <section id="EnvVar"><title>Variables d'environnement</title> |
| |
| <p>Ce module conserve le contenu de deux variables d'environnement |
| CGI/SSI additionnelles (non standards) nommées |
| <code>SCRIPT_URL</code> et <code>SCRIPT_URI</code>. Celles-ci |
| contiennent l'adresse <em>logique</em> vue du Web |
| de la ressource concernée, tandis que les variables CGI/SSI |
| standards <code>SCRIPT_NAME</code> et |
| <code>SCRIPT_FILENAME</code> contiennent l'adresse |
| <em>physique</em> de la ressource vue du système. </p> |
| |
| <p>Note : ces variables conservent l'URI/URL <em>telle qu'elle |
| était à l'arrivée de la requête</em>, c'est à dire |
| <em>avant</em> tout processus de réécriture. Il est important de |
| le savoir car le processus de réécriture est principalement |
| utilisé pour réécrire des URLs logiques en chemins physiques.</p> |
| |
| <example><title>Exemple</title> |
| <pre> |
| SCRIPT_NAME=/sw/lib/w3s/tree/global/u/rse/.www/index.html |
| SCRIPT_FILENAME=/u/rse/.www/index.html |
| SCRIPT_URL=/u/rse/ |
| SCRIPT_URI=http://en1.engelschall.com/u/rse/ |
| </pre> |
| </example> |
| |
| </section> |
| |
| <section id="vhosts"><title>Réécriture et hôtes virtuels</title> |
| |
| <p>Par défaut, les hôtes virtuels n'héritent pas de la |
| configuration de <module>mod_rewrite</module> telle qu'elle est |
| définie dans le contexte du serveur principal. Pour que la |
| configuration du serveur principal s'applique aux hôtes virtuels, |
| vous devez insérez les directives suivantes dans chaque section |
| <directive |
| module="core" type="section">VirtualHost</directive> :</p> |
| |
| <example> |
| RewriteEngine On<br /> |
| RewriteOptions Inherit |
| </example> |
| </section> |
| |
| <section id="Solutions"><title>Solutions pratiques</title> |
| |
| <p>Vous trouverez de nombreux exemples d'utilisation courante (et |
| moins courante) de mod_rewrite dans la <a |
| href="../rewrite/">documentation spécifique à la réécriture.</a></p> |
| |
| </section> |
| |
| <directivesynopsis> |
| <name>RewriteEngine</name> |
| <description>Active ou désactive l'exécution du |
| moteur de réécriture</description> |
| <syntax>RewriteEngine on|off</syntax> |
| <default>RewriteEngine off</default> |
| <contextlist><context>server config</context><context>virtual host</context> |
| <context>directory</context><context>.htaccess</context></contextlist> |
| <override>FileInfo</override> |
| |
| <usage> |
| |
| <p>La directive <directive>RewriteEngine</directive> active ou |
| désactive l'exécution du moteur de réécriture. Si sa valeur est |
| <code>off</code>, ce module n'exécutera aucun traitement et ne |
| mettra pas à jour les variables d'environnement |
| <code>SCRIPT_URx</code>.</p> |
| |
| <p>Pour désactiver le module, il vaut mieux utiliser cette |
| directive que commenter toutes les directives <directive |
| module="mod_rewrite">RewriteRule</directive> !</p> |
| |
| <p>Notez que les hôtes virtuels n'héritent pas des |
| configurations de réécriture. Ceci implique que vous devez |
| insérer une directive <code>RewriteEngine on</code> dans chaque |
| hôte virtuel pour lequel vous souhaitez utiliser des règles |
| de réécriture.</p> |
| |
| <p>Les directives <directive>RewriteMap</directive> du type |
| <code>prg</code> ne sont pas prises en compte au cours de |
| l'initialisation du serveur si elle ont été définies dans un |
| contexte où la directive <directive>RewriteEngine</directive> n'a |
| pas été définie à <code>on</code>.</p> |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteOptions</name> |
| <description>Configure certaines options spéciales |
| pour le moteur de réécriture</description> |
| <syntax>RewriteOptions <var>Options</var></syntax> |
| <contextlist><context>server config</context><context>virtual host</context> |
| <context>directory</context><context>.htaccess</context></contextlist> |
| <override>FileInfo</override> |
| <compatibility><code>MaxRedirects</code> n'est plus disponible depuis |
| la version version 2.1</compatibility> |
| <usage> |
| |
| <p>La directive <directive>RewriteOptions</directive> définit |
| certaines options spéciales pour la configuration au niveau du |
| serveur ou du répertoire. La chaîne de caractères <em>Option</em> |
| ne peut actuellement prendre qu'une des valeurs suivantes :</p> |
| |
| <dl> |
| <dt><code>inherit</code></dt> |
| <dd> |
| |
| <p>Ceci force la configuration locale à hériter de la |
| configuration du niveau supérieur. Dans le contexte des hôtes |
| virtuels, cela signifie que les correspondances, conditions et |
| règles du serveur principal sont héritées. Dans le contexte des |
| répertoires, cela signifie que les conditions et règles de la |
| configuration <code>.htaccess</code> du répertoire parent sont |
| héritées.</p> |
| |
| <note type="warning"> |
| Les règles héritées du niveau parent sont appliquées |
| <strong>after</strong> après les règles spécifiées dans le niveau |
| enfant. |
| </note> |
| |
| </dd> |
| |
| <dt><code>AllowAnyURI</code></dt> |
| <dd> |
| |
| <p>A partir de la version 2.2.23 de httpd, lorsqu'une directive |
| <directive module="mod_rewrite">RewriteRule</directive> est |
| utilisée dans un contexte de <code>serveur virtuel</code> ou de |
| serveur principal, <module>mod_rewrite</module> ne la traitera que |
| si l'URI de la requête correspond à un <a |
| href="./directive-dict.html#Syntax">chemin d'URL</a>. Ceci permet |
| d'éviter certains problèmes de sécurité où certaines règles |
| peuvent permettre l'expansion de modèles inattendus (voir <a |
| href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2011-3368">CVE-2011-3368</a> |
| et <a |
| href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2011-4317">CVE-2011-4317</a>). |
| Pour lever cette restriction, on peut activer l'option |
| <code>AllowAnyURI</code>, et <module>mod_rewrite</module> va alors |
| appliquer le jeu de règles à tout URI de requête, sans vérifier si |
| la chaîne respecte la grammaire des chemins d'URL définie dans la |
| spécification HTTP.</p> |
| |
| <note type="warning"> |
| <title>Avertissement en matière de sécurité</title> |
| |
| <p>L'activation de cette option expose le serveur à des |
| problèmes de sécurité si les règles de réécriture n'ont pas été |
| rédigées avec soin. Il est donc <strong>fortement |
| recommandé</strong> de ne pas utiliser cette option. En |
| particulier, prenez garde aux chaînes d'entrée contenant le |
| caractère '<code>@</code>' qui peut modifier l'interprétation de |
| l'URI transformé, comme indiqué dans les CVE ci-dessus.</p> |
| </note> |
| </dd> |
| |
| <dt><code>MergeBase</code></dt> |
| <dd> |
| |
| <p>Avec cette option, la valeur de <directive |
| module="mod_rewrite">RewriteBase</directive> est copiée depuis une |
| origine explicitement définie dans tout sous-répertoire qui ne |
| définit pas sa propre <directive |
| module="mod_rewrite">RewriteBase</directive>. Par défaut, jusqu'à |
| la version 2.2.22, cette valeur n'était pas copiée, alors qu'elle |
| l'était avec la version 2.2.23 du serveur HTTP Apache. Le drapeau |
| permettant de contrôler explicitement ce comportement est |
| disponible depuis la version 2.2.24.</p> |
| </dd> |
| </dl> |
| |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteLog</name> |
| <description>Définit le nom du fichier utilisé pour la journalisation |
| des traitements du moteur de réécriture</description> |
| <syntax>RewriteLog <em>chemin du fichier journal|redirection vers un pipe</em></syntax> |
| <contextlist><context>server config</context><context>virtual host</context> |
| </contextlist> |
| |
| <usage> |
| <p>La directive <directive>RewriteLog</directive> définit le nom |
| du fichier dans lequel le serveur journalise tout processus de |
| réécriture qu'il effectue. Si le nom ne commence pas par un |
| slash ('<code>/</code>'), il est considéré comme relatif à la |
| <em>Racine du serveur</em>. Cette directive ne doit apparaître |
| qu'une seule fois dans la configuration du serveur.</p> |
| |
| <note> Il est déconseillé de positionner |
| <em>chemin du fichier journal</em> à <code>/dev/null</code> |
| pour désactiver la journalisation des processus de réécriture, |
| car même si le moteur de réécriture n'envoie plus sa sortie |
| dans un fichier, il continue à créer un fichier journal en |
| interne, <strong>ce qui va avoir pour effet de ralentir le |
| serveur sans fournir aucun avantage à l'administrateur ! |
| </strong> Pour désactiver la journalisation, vous pouvez |
| soit supprimer ou commenter la directive |
| <directive>RewriteLog</directive>, soit utiliser |
| <code>RewriteLogLevel 0</code> ! |
| </note> |
| |
| <p>Le format de fichier journal <directive>RewriteLog</directive> se |
| présente comme suit :</p> |
| |
| <table> |
| <tr><th>Description</th><th> Exemple</th></tr> |
| <tr> |
| <td>Adresse IP de l'hôte distant</td> |
| <td>192.168.200.166</td></tr> |
| <tr><td>Nom de login didtant</td><td>en général "-"</td></tr> |
| <tr><td>nom d'authentification de l'utilisateur HTTP</td><td>nom |
| d'utilisateur, ou "-" si non authentifié</td></tr> |
| <tr><td>Date et heure de la requête</td><td>[28/Aug/2009:13:09:09 --0400]</td></tr> |
| <tr><td>Serveur virtuel et son identifiant</td><td>[www.example.com/sid#84a650]</td></tr> |
| <tr><td>Identifiant de la requête et indication éventuelle qu'il s'agit |
| d'une sous-requête</td><td>[rid#9f0e58/subreq]</td></tr> |
| <tr><td>Niveau de sévérité de l'entrée du journal</td><td>(2)</td></tr> |
| <tr><td>Message d'erreur au format texte</td><td>forcing proxy-throughput with http://127.0.0.1:8080/index.html</td></tr> |
| </table> |
| |
| |
| <note type="securitywarning"><title>Sécurité</title> |
| |
| Se référer au document |
| <a href="../misc/security_tips.html">Conseils à propos |
| de la sécurité dans Apache</a> pour plus de détails sur la manière |
| dont votre sécurité pourrait être compromise si le répertoire où se |
| trouvent les fichiers journaux est inscriptible par quiconque |
| autre que l'utilisateur qui démarre le serveur. |
| </note> |
| |
| <example><title>Exemple</title> |
| # Journalisation dans un fichier :<br/> |
| RewriteLog "/usr/local/var/apache/logs/rewrite.log"<br/> |
| <br/> |
| # Journalisation redirigée vers un pipe:<br/> |
| RewriteLog "|/path/to/parser.pl" |
| </example> |
| |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteLogLevel</name> |
| <description>Définit la verbosité du fichier journal utilisé |
| par le moteur de réécriture</description> |
| <syntax>RewriteLogLevel <em>niveau</em></syntax> |
| <default>RewriteLogLevel 0</default> |
| <contextlist><context>server config</context><context>virtual host</context> |
| </contextlist> |
| |
| <usage> |
| <p>La directive <directive>RewriteLogLevel</directive> définit |
| le niveau de verbosité du fichier journal de réécriture. Le |
| niveau par défaut 0 signifie aucune journalisation, tandis que |
| 9 ou plus signifie que pratiquement toutes les actions sont |
| journalisées.</p> |
| |
| <p>Pour désactiver la journalisation des actions de réécriture, |
| positionnez simplement <em>niveau</em> à 0. Ceci désactive |
| toute journalisation des actions de réécriture.</p> |
| |
| <note> Utiliser une valeur élevée pour <em>niveau</em> va ralentir |
| considérablement votre serveur Apache ! N'utilisez une |
| journalisation de la réécriture à un <em>niveau</em> |
| supérieur à 2 qu'à des fins de débogage ! |
| </note> |
| |
| <example><title>Exemple</title> |
| RewriteLogLevel 3 |
| </example> |
| |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteLock</name> |
| <description>Définit le nom du fichier verrou utilisé pour la |
| synchronisation de <directive |
| module="mod_rewrite">RewriteMap</directive></description> |
| <syntax>RewriteLock <em>chemin du fichier verrou</em></syntax> |
| <contextlist><context>server config</context></contextlist> |
| |
| <usage> |
| <p>Cette directive définit le nom du fichier utilisé comme |
| fichier verrou de synchronisation nécessaire à mod_rewrite pour |
| communiquer avec les <em>programmes</em> liés à <directive |
| module="mod_rewrite">RewriteMap</directive>. Définissez ce |
| fichier verrou dans un chemin local (et non sur un montage NFS) |
| si vous voulez utiliser un programme de comparaison pour la |
| réécriture. Il n'est pas nécessaire pour les autres types de |
| comparaison pour la réécriture.</p> |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteMap</name> |
| <description>Définit une fonction de mise en correspondance pour la |
| recherche de mots-clés</description> |
| <syntax>RewriteMap <em>nom_de_la_correspondance</em> <em>type_de_correspondance</em>:<em>source_de_la_correspondance</em> |
| </syntax> |
| <contextlist><context>server config</context><context>virtual host</context> |
| </contextlist> |
| <compatibility>Il est possible de choisir entre plusieurs types de |
| bases de données depuis la version 2.0.41 d'Apache</compatibility> |
| |
| <usage> |
| <p>La directive <directive>RewriteMap</directive> définit une |
| <em>Table de correspondance pour la réécriture</em> que les |
| fonctions de mise en correspondance |
| peuvent utiliser dans les chaînes de substitution des règles |
| pour insérer/substituer des champs en recherchant des mots-clés. |
| La source utilisée pour cette recherche peut être de plusieurs |
| types.</p> |
| |
| <p><a id="mapfunc" name="mapfunc"><em>nom de la |
| correspondance</em></a> est le nom de la table de correspondance |
| et servira à spécifier une fonction de mise en correspondance |
| pour les chaînes de substitution d'une règle de réécriture selon |
| une des constructions suivantes :</p> |
| |
| <p class="indent"> |
| <strong><code>${</code> <em>nom de la |
| correspondance</em> <code>:</code> |
| <em>mot-clé</em> <code>}</code><br /> |
| <code>${</code> <em>nom de la |
| correspondance</em> <code>:</code> |
| <em>mot-clé</em> <code>|</code> <em>valeur par défaut</em> |
| <code>}</code></strong> |
| </p> |
| |
| <p>Lorsqu'une telle construction est rencontrée, la table de |
| correspondance <em>Nom de la correspondance</em> est consultée |
| et la clé <em>mot-clé</em> recherchée. Si la clé est trouvée, la |
| construction est remplacée par |
| la <em>valeur de remplacement</em>. Si la clé n'est pas trouvée, |
| elle est remplacée par la <em>valeur par défaut</em>, ou par une |
| chaîne vide si aucune <em>valeur par défaut</em> n'est |
| spécifiée. La valeur vide se comporte comme si la |
| clé était absente ; il est donc impossible de distinguer une |
| valeur vide d'une absence de clé.</p> |
| |
| <p>Par exemple, vous pouvez définir une directive |
| <directive>RewriteMap</directive> comme suit </p> |
| |
| <example> |
| RewriteMap map-exemple txt:/chemin/vers/fichier/map.txt |
| </example> |
| |
| <p>Vous pourrez ensuite utiliser cette table dans une |
| directive <directive>RewriteRule</directive> comme suit :</p> |
| |
| <example> |
| RewriteRule ^/ex/(.*) ${map-exemple:$1} |
| </example> |
| |
| <p>Les combinaisons suivantes pour <em>type_de_correspondance</em> |
| et <em>source_de_la_correspondance</em> |
| peuvent être utilisées :</p> |
| |
| <ul> |
| <li> |
| <strong>Format texte standard</strong><br /> |
| type de correspondance : <code>txt</code>, source de la |
| correspondance : chemin du système de fichiers Unix vers un |
| fichier régulier valide |
| |
| <p>Il s'agit de la mise en oeuvre standard de la table de |
| correspondance pour la réécriture où |
| <em>source_de_la_correspondance</em> est un fichier ASCII |
| dont les différentes lignes sont soit des lignes vides, soit |
| des lignes de commentaires (commençant par un caractère "#"), |
| soit des paires de valeurs (une seule paire |
| par ligne) comme suit :</p> |
| |
| <p class="indent"> |
| <strong><em>mot-clé</em> |
| <em>valeur de remplacement</em></strong> |
| </p> |
| |
| <example><title>Exemple</title> |
| <pre> |
| ## |
| ## map.txt -- table de correspondance pour la réécriture |
| ## |
| |
| Ralf.S.Engelschall rse # Bastard Operator From Hell |
| (traduction à votre convenance) |
| Mr.Joe.Average joe # Mr. Average |
| </pre> |
| </example> |
| |
| <example> |
| RewriteMap real-to-user txt:/chemin/vers/fichier/map.txt |
| </example> |
| </li> |
| |
| <li> |
| <strong>Format texte avec valeurs aléatoires</strong><br /> |
| type de correspondance: <code>rnd</code>, |
| source de la correspondance : chemin du système de fichiers |
| Unix vers un fichier régulier valide |
| |
| <p>Ce format se différencie du format texte standard |
| précédent par l'ajout d'un traitement supplémentaire : en |
| plus de la recherche de clés, le fichier est interprété en |
| tenant compte de la présence éventuelle dans les valeurs de |
| remplacement de caractères ``<code>|</code>'' signifiant |
| ``ou''. En d'autres termes, ces caractères ``<code>|</code>'' |
| permettent de spécifier un jeu de valeurs parmi lesquelles |
| la valeur de retour sera choisie aléatoirement. Par exemple, |
| vous pouvez utiliser les fichier de correspondance et |
| directives suivants pour mettre en oeuvre une répartition de |
| charge aléatoire entre plusieurs serveurs en arrière-plan, |
| via un mandataire inverse. Les images sont envoyées à un des |
| serveurs de l'ensemble "statique", tandis que tout le |
| reste est envoyé à un des serveurs de l'ensemble |
| "dynamique".</p> |
| <p>Exemple:</p> |
| |
| <example><title>Fichier de correspondances pour la réécriture</title> |
| <pre> |
| ## |
| ## map.txt -- correspondances pour la réécriture |
| ## |
| |
| static www1|www2|www3|www4 |
| dynamic www5|www6 |
| </pre> |
| </example> |
| |
| <example><title>Directives de configuration</title> |
| RewriteMap serveurs rnd:/chemin/vers/fichier/map.txt<br /> |
| <br /> |
| RewriteRule ^/(.*\.(png|gif|jpg)) http://${serveurs:static}/$1 |
| [NC,P,L]<br /> |
| RewriteRule ^/(.*) http://${serveurs:dynamic}/$1 [P,L] |
| </example> |
| </li> |
| |
| <li> |
| <strong>Fichier à accès direct (Hash file)</strong><br /> |
| type de correspondance : |
| <code>dbm[=<em>type</em>]</code>, source de la |
| correspondance : chemin du système de fichiers Unix vers un |
| fichier régulier valide |
| |
| <p>Ici, la source de la correspondance est un fichier binaire |
| au format DBM contenant les mêmes données qu'un fichier au |
| format <em>Plein texte</em>, mais selon une représentation |
| particulière optimisée en vue d'une recherche très rapide. |
| Le <em>type</em> peut être sdbm, gdbm, ndbm, ou db selon la |
| configuration à la <a href="../install.html#dbm">compilation |
| </a>. Si <em>type</em> est omis, la valeur retenue |
| sera la valeur par défaut définie à la compilation.</p> |
| |
| <p>La création du fichier dbm à partir d'un fichier texte |
| s'effectue à l'aide de l'utilitaire <a |
| href="../programs/httxt2dbm.html">httxt2dbm</a>.</p> |
| |
| <example> |
| $ httxt2dbm -i fichier-source.txt -o fichier-dbm.map |
| </example> |
| </li> |
| |
| <li> |
| <strong>Fonction interne</strong><br /> |
| type de la correspondance : <code>int</code>, |
| source de la correspondance : fonction interne à Apache |
| |
| <p>Ici, la source de la correspondance est une fonction |
| interne à Apache. Les développeurs de modules peuvent |
| fournir des fonctions internes supplémentaires en les |
| enregistrant via l'API |
| <code>ap_register_rewrite_mapfunc</code>. Les fonctions |
| fournies par défaut sont :</p> |
| |
| <ul> |
| <li><strong>toupper</strong>:<br /> |
| Convertit tous les caractères de la clé en majuscules.</li> |
| |
| <li><strong>tolower</strong>:<br /> |
| Convertit tous les caractères de la clé en minuscules.</li> |
| |
| <li><strong>escape</strong>:<br /> |
| Traduit les caractères spéciaux que contient la clé en |
| séquences hexadécimales.</li> |
| |
| <li><strong>unescape</strong>:<br /> |
| Reconvertit les séquences hexadécimales que contient la |
| clé en caractères spéciaux.</li> |
| </ul> |
| </li> |
| |
| <li> |
| <strong>Programme de réécriture externe</strong><br /> |
| type de la correspondance : <code>prg</code>, |
| source de la correspondance : |
| chemin du système de fichiers Unix vers un |
| fichier régulier valide |
| |
| <p>Ici, la source n'est pas un fichier de correspondances, |
| mais un programme. Pour le créer, vous pouvez utiliser le |
| langage de votre choix, mais le programme doit être un |
| exécutable (soit du code objet, soit un script |
| contenant le fameux |
| "<code>#!/chemin/vers/interpréteur</code>" au début de sa |
| première ligne).</p> |
| |
| <p>Ce programme est lancé une seule fois au démarrage du |
| serveur Apache, puis communique avec le moteur de réécriture |
| via ses entrée et sortie standards (<code>stdin</code> |
| et <code>stdout</code>). A chaque recherche effectuée par la |
| fonction de correspondance, il reçoit sur son entrée standard |
| la clé à rechercher sous la forme d'une chaîne de caractères |
| terminée par le caractère "nouvelle ligne". Il doit ensuite |
| renvoyer sur sa sortie standard la valeur recherchée sous |
| la forme d'une chaîne de caractères terminée par le caractère |
| "nouvelle ligne", ou la chaîne de quatre |
| caractères ``<code>NULL</code>'' en cas d'échec |
| (<em>c'est à dire</em> |
| si aucune valeur ne correspond à la clé fournie). Voici un |
| exemple de ce pourrait être un programme trivial qui |
| implémenterait une correspondance 1:1 (<em>c'est à dire</em>, |
| clé == valeur) :</p> |
| |
| <p>Les programmes de réécriture externes ne seront pas lancés |
| s'ils ont été définis dans un contexte où la directive |
| <directive>RewriteEngine</directive> n'a pas été définie à |
| <code>on</code>.</p> |
| |
| <example> |
| <pre> |
| #!/usr/bin/perl |
| $| = 1; |
| while (<STDIN>) { |
| # ...insérer ici le code de transformation ou de recherche... |
| print $_; |
| } |
| </pre> |
| </example> |
| |
| <p>Mais soyez très prudent :</p> |
| |
| <ol> |
| <li>``<em>Ce programme doit être simple, basique</em>'' |
| (MERCI). |
| Si ce programme se bloque, il bloquera aussi Apache |
| lorsqu'il tentera d'utiliser la règle de réécriture |
| correspondante.</li> |
| |
| <li>L'utilisation d'entrées/sorties avec tampon sur |
| <code>stdout</code> est une erreur courante. Ceci est à |
| proscrire sous peine de créer une boucle infernale ! Pour |
| éviter ceci, on utilise ``<code>$|=1</code>'' comme dans |
| l'exemple ci-dessus.</li> |
| |
| <li>On peut définir la directive <directive |
| module="mod_rewrite">RewriteLock</directive> pour spécifier |
| un fichier verrou que mod_rewrite pourra utiliser pour |
| synchroniser les communications avec le programme de |
| correspondance. Par défaut, aucune synchronisation de ce |
| type n'est mise en oeuvre.</li> |
| </ol> |
| </li> |
| |
| |
| </ul> |
| <p>La directive <directive>RewriteMap</directive> peut |
| apparaître plusieurs fois. Utilisez une directive |
| <directive>RewriteMap</directive> par fonction de correspondance |
| pour déclarer son fichier de correspondance pour la réécriture. |
| Bien que vous ne puissiez pas <strong>déclarer</strong> une |
| table de correspondance dans un contexte de répertoire, vous |
| pouvez bien entendu <strong>utiliser</strong> cette table dans un |
| contexte de répertoire. </p> |
| |
| <note><title>Note</title> En ce qui concerne les fichiers au format DBM |
| et plein texte, les clés de recherches sont mises en cache en interne |
| jusqu'à ce que le <code>mtime (date de modification)</code> du fichier |
| soit modifié, ou que le serveur soit redémarré. Ainsi, certaines |
| fonctions de correspondance dans les règles peuvent être utilisées pour |
| <strong>chaque</strong> requête. Cela ne pose pas problème, car la |
| recherche externe n'intervient qu'une seule fois ! |
| </note> |
| |
| </usage> |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteBase</name> |
| <description>Définit l'URL de base pour les réécritures au niveau |
| répertoire</description> |
| <syntax>RewriteBase <em>chemin_URL</em></syntax> |
| <default>None</default> |
| <contextlist><context>directory</context><context>.htaccess</context> |
| </contextlist> |
| <override>FileInfo</override> |
| |
| <usage> |
| <p>La directive <directive>RewriteBase</directive> permet de |
| spécifier le préfixe d'URL à utiliser dans un contexte de |
| répertoire (htaccess) pour les directives |
| <directive>RewriteRule</directive> qui réécrivent vers un chemin |
| relatif.</p> |
| <p>Cette directive est <em>obligatoire</em> si vous utilisez un |
| chemin relatif dans une substitution, et dans un contexte de |
| répertoire (htaccess), sauf si au moins une de ces conditions est |
| vérifiée :</p> |
| <ul> |
| <li>La requête initiale, ainsi que la substitution, sont dans |
| la <directive module="core">DocumentRoot</directive> (c'est à |
| dire que pour y accéder, il n'est pas nécessaire d'utiliser |
| une directive telle qu'<directive |
| module="mod_alias">Alias</directive>).</li> |
| <li>Le chemin du système de fichiers vers le répertoire |
| contenant la <directive>RewriteRule</directive>, suffixé par |
| la substitution relative est aussi valide en tant qu'URL sur |
| le serveur (ce qui est rare).</li> |
| </ul> |
| |
| <p>Dans l'exemple ci-dessous, la directive |
| <directive>RewriteBase</directive> est nécessaire afin d'éviter une |
| réécriture en http://example.com/opt/myapp-1.2.3/welcome.html car la |
| ressource n'était pas relative à la racine des documents. Cette erreur |
| de configuration aurait conduit le serveur à rechercher un répertoire |
| "opt" à la racine des documents.</p> |
| |
| <example> |
| <pre> |
| DocumentRoot /var/www/example.com |
| Alias /myapp /opt/myapp-1.2.3 |
| <Directory /opt/myapp-1.2.3> |
| RewriteEngine On |
| RewriteBase /myapp/ |
| RewriteRule ^index\.html$ welcome.html |
| </Directory> |
| </pre> |
| </example> |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteCond</name> |
| <description>Définit une condition qui devra être satisfaite pour que |
| la réécriture soit effectuée |
| </description> |
| <syntax> RewriteCond |
| <em>chaîne_de_test</em> <em>expression_de_comparaison</em></syntax> |
| <contextlist><context>server config</context><context>virtual host</context> |
| <context>directory</context><context>.htaccess</context></contextlist> |
| <override>FileInfo</override> |
| |
| <usage> |
| <p>La directive <directive>RewriteCond</directive> définit une |
| condition d'application d'une certaine règle. Une ou plusieurs |
| directives <directive>RewriteCond</directive> peuvent précéder |
| une directive |
| <directive module="mod_rewrite">RewriteRule</directive>. La règle |
| qui suit n'est appliquée que si l'état actuel de l'URI |
| correspond à son modèle, <strong |
| >et</strong> si les conditions sont satisfaites.</p> |
| |
| <p><em>chaîne_de_test</em> est une chaîne de caractères qui peut |
| contenir, en plus du plein texte, les constructions étendues |
| suivantes :</p> |
| |
| <ul> |
| <li> |
| <strong>références arrières de règle de réécriture</strong> : |
| ce sont des références arrières de la forme |
| <strong><code>$N</code></strong> (0 <= N <= 9), qui |
| donnent accès aux parties groupées (entre parenthèses) du |
| modèle tiré de la <code>RewriteRule</code> assujettie au |
| jeu de conditions concerné. |
| </li> |
| <li> |
| <strong>Références arrières de condition de réécriture |
| </strong> : ce sont des références arrières de la forme |
| <strong><code>%N</code></strong> (1 <= N <= 9), qui |
| donnent accès aux parties groupées (là aussi entre |
| parenthèses) du modèle de la dernière condition satisfaite |
| du jeu de conditions concerné. |
| </li> |
| <li> |
| <strong>extensions de table de réécriture</strong> : |
| ce sont des extensions de la forme <strong><code |
| >${nomTable:clé|défaut}</code></strong>. Voir |
| <a href="#mapfunc">la documentation de |
| RewriteMap</a> pour plus de détails. |
| </li> |
| <li> |
| <strong>Variables du serveur</strong> : |
| ce sont des variables de la forme |
| <strong><code>%{</code> <em>NOM_DE_VARIABLE</em> |
| <code>}</code></strong> |
| <strong><code>%{</code> <em>NOM_DE_VARIABLE</em> |
| <code>}</code></strong> où <em>NOM_DE_VARIABLE</em> |
| peut être une chaîne de caractères faisant partie de la |
| liste suivante : |
| |
| <table> |
| <columnspec><column width=".3"/><column width=".3"/> |
| <column width=".3"/></columnspec> |
| <tr> |
| <th>En-têtes HTTP :</th> <th>connexion & requête:</th> <th></th> |
| </tr> |
| |
| <tr> |
| <td> |
| HTTP_USER_AGENT<br /> |
| HTTP_REFERER<br /> |
| HTTP_COOKIE<br /> |
| HTTP_FORWARDED<br /> |
| HTTP_HOST<br /> |
| HTTP_PROXY_CONNECTION<br /> |
| HTTP_ACCEPT<br /> |
| </td> |
| |
| <td> |
| REMOTE_ADDR<br /> |
| REMOTE_HOST<br /> |
| REMOTE_PORT<br /> |
| REMOTE_USER<br /> |
| REMOTE_IDENT<br /> |
| REQUEST_METHOD<br /> |
| SCRIPT_FILENAME<br /> |
| PATH_INFO<br /> |
| QUERY_STRING<br /> |
| AUTH_TYPE<br /> |
| </td> |
| |
| <td></td> |
| </tr> |
| |
| <tr> |
| <th>variables internes au serveur :</th> <th>date et heure :</th> <th>spéciaux :</th> |
| </tr> |
| |
| <tr> |
| <td> |
| DOCUMENT_ROOT<br /> |
| SERVER_ADMIN<br /> |
| SERVER_NAME<br /> |
| SERVER_ADDR<br /> |
| SERVER_PORT<br /> |
| SERVER_PROTOCOL<br /> |
| SERVER_SOFTWARE<br /> |
| </td> |
| |
| <td> |
| TIME_YEAR<br /> |
| TIME_MON<br /> |
| TIME_DAY<br /> |
| TIME_HOUR<br /> |
| TIME_MIN<br /> |
| TIME_SEC<br /> |
| TIME_WDAY<br /> |
| TIME<br /> |
| </td> |
| |
| <td> |
| API_VERSION<br /> |
| THE_REQUEST<br /> |
| REQUEST_URI<br /> |
| REQUEST_FILENAME<br /> |
| IS_SUBREQ<br /> |
| HTTPS<br /> |
| </td> |
| </tr> |
| </table> |
| |
| <p>Toutes ces variables correspondent nom pour nom aux |
| en-têtes MIME HTTP, aux variables C du serveur Apache |
| ou aux champs <code>struct tm</code> du système Unix. |
| La plupart sont documentées dans une autre partie du |
| manuel ou dans la spécification CGI.</p> |
| |
| <p>SERVER_NAME et SERVER_PORT dépendent respectivement |
| des valeurs des directives <directive |
| module="core">UseCanonicalName</directive> et <directive |
| module="core">UseCanonicalPhysicalPort</directive>.</p> |
| |
| <p>Parmi les variables |
| spécifiques à mod_rewrite, ou trouve les suivantes :</p> |
| <note> |
| <dl> |
| <dt><code>IS_SUBREQ</code></dt> |
| |
| <dd>Contiendra le texte "true" si la requête en cours |
| de traitement est une sous-requête, "false" dans le |
| cas contraire. Une sous-requête est générée quand un |
| module a besoin de se référer à des fichiers ou URIs |
| addidionnels pour pouvoir mener à bien sa tâche.</dd> |
| |
| <dt><code>API_VERSION</code></dt> |
| |
| <dd>Il s'agit de la version de l'API des modules |
| Apache (l'interface interne entre le serveur et les |
| modules) dans la construction actuelle de httpd, |
| telle qu'elle est définie dans include/ap_mmn.h. La |
| version de l'API des modules correspond à la version |
| d'Apache utilisée (pour Apache 1.3.14, par exemple, |
| la version de l'API sera 19990320:10), mais cette |
| information intéresse principalement les |
| développeurs de modules.</dd> |
| |
| <dt><code>THE_REQUEST</code></dt> |
| |
| <dd>La ligne de requête HTTP complète envoyée par le |
| navigateur au serveur (par exemple, "<code>GET |
| /index.html HTTP/1.1</code>"), à l'exclusion de tout |
| en-tête ajouté par le navigateur. Cette |
| valeur n'a pas été déséchappée (décodée), à la |
| différence de la plupart des variables suivantes.</dd> |
| |
| <dt><code>REQUEST_URI</code></dt> |
| |
| <dd>La partie chemin de l'URI de la requête, comme |
| "/index.html". En particulier, ceci exclut la chaîne |
| de paramètres qui est quant à elle disponible via sa |
| propre variable <code>QUERY_STRING</code>.</dd> |
| |
| <dt><code>REQUEST_FILENAME</code></dt> |
| |
| <dd>Le chemin complet local au système de fichiers |
| du fichier ou du script correspondant |
| à la requête, s'il a déjà été déterminé par le serveur |
| au moment où on y fait référence. Dans le cas |
| contraire, et en particulier dans le cas d'un serveur |
| virtuel, <code>REQUEST_FILENAME</code> contient la |
| valeur de <code>REQUEST_URI</code>.</dd> |
| |
| <dt><code>HTTPS</code></dt> |
| |
| <dd>Contiendra le texte "on" si la connexion |
| utilise SSL/TLS, "off" dans le cas contraire |
| (L'utilisation de cette variable est pertinente, |
| indépendamment du fait que <module>mod_ssl</module> |
| soit chargé ou non).</dd> |
| |
| </dl> |
| </note> |
| </li> |
| </ul> |
| |
| <p>Autres points à connaître :</p> |
| |
| <ol> |
| <li><p>Les variables SCRIPT_FILENAME et REQUEST_FILENAME ont la |
| même valeur - celle du champ <code>filename</code> de la |
| structure interne du serveur Apache <code>request_rec</code>. |
| Le premier nom est bien connu en tant que variable CGI, |
| alors que le second est équivalent à REQUEST_URI (qui contient |
| la valeur du champ <code>uri</code> de la structure |
| <code>request_rec</code>).</p> |
| <p>Si une substitution survient, et si la réécriture se |
| poursuit, la valeur des deux variables est mise à jour en |
| conséquence.</p> |
| <p>Dans un contexte de serveur principal (c'est à dire avant que |
| la requête n'ait été mise en relation avec le système de |
| fichiers), SCRIPT_FILENAME et REQUEST_FILENAME ne peuvent pas |
| contenir le chemin local entier dans le système de fichiers, car |
| celui-ci n'a pas encore été déterminé à ce stade du traitement. |
| Les deux variables contiennent alors la valeur de REQUEST_URI. |
| Pour obtenir le chemin local entier associé à la requête dans le |
| système de fichiers |
| dans un contexte de serveur principal, utilisez une recherche |
| avant <code>%{LA-U:REQUEST_FILENAME}</code> pour déterminer la |
| valeur finale de REQUEST_FILENAME.</p></li> |
| |
| |
| <li>On peut aussi utiliser <code>%{ENV:variable}</code>, où |
| <em>variable</em> peut être remplacé par toute variable |
| d'environnement. Ces variables sont recherchées dans les |
| structures internes d'Apache, et (si elles n'y figurent pas) |
| via <code>getenv()</code> depuis le processus du serveur |
| Apache.</li> |
| |
| <li>Que <module>mod_ssl</module> soit chargé ou non, on peut |
| utiliser <code>%{SSL:variable}</code>, où <em>variable</em> |
| peut être remplacé par le nom d'une |
| <a href="mod_ssl.html#envvars">variable |
| d'environnement SSL</a>, mais la valeur produite sera toujours |
| une chaîne de caractères vide si <module>mod_ssl</module> n'est |
| pas chargé. Exemple : |
| <code>%{SSL:SSL_CIPHER_USEKEYSIZE}</code> peut correspondre |
| à <code>128</code>. Ces variables sont |
| disponibles même si l'option <code>StdEnvVars</code> de la |
| directive <directive module="mod_ssl">SSLOptions</directive> n'a |
| pas été définie.</li> |
| |
| <li>Pour obtenir la valeur d'un en-tête contenu dans une requête |
| HTTP, on peut toujours utiliser <code>%{HTTP:header}</code>, |
| où <em>header</em> peut être remplacé par tout nom d'en-tête |
| MIME HTTP. Exemple : <code>%{HTTP:Proxy-Connection}</code> est |
| la valeur de l'en-tête HTTP ``<code>Proxy-Connection:</code>''. |
| <p>Si une condition contient un en-tête HTTP, il est ajouté à |
| l'en-tête Vary de la réponse dans le cas où la condition est |
| évaluée à true pour la requête. Dans le cas contraire, il n'est |
| <strong>pas</strong> ajouté. L'ajout de l'en-tête HTTP à |
| l'en-tête Vary de la réponse s'avère nécessaire pour une mise |
| en cache correcte.</p> |
| <p>Il faut garder à l'esprit que les conditions suivent une |
| logique de court-circuit en cas de présence du drapeau |
| '<strong><code>ornext|OR</code></strong>', si bien que |
| certaines d'entre elles sont susceptibles de ne pas être |
| évaluées du tout.</p></li> |
| |
| <li>On peut utiliser <code>%{LA-U:variable}</code> pour les |
| recherches en avant qui effectuent une sous-requête interne |
| (basée sur l'URL), pour déterminer la valeur finale de |
| <em>variable</em>. Cela peut servir à accéder à une variable |
| (nécessaire pour une réécriture) qui n'est pas disponible dans |
| la situation présente, mais le sera dans une phase ultérieure. |
| <p>Par exemple, pour effectuer une réécriture qui tient compte |
| de la variable <code>REMOTE_USER</code> dans un contexte |
| niveau serveur (fichier <code>httpd.conf</code>), vous devez |
| utiliser <code>%{LA-U:REMOTE_USER}</code> ; cette variable est |
| définie au cours des phases d'autorisation, qui interviennent |
| <em>après</em> la phase de traduction de l'URL (pendant |
| laquelle agit mod_rewrite).</p> |
| <p>Par contre, comme mod_rewrite implémente son contexte |
| niveau répertoire (fichier <code>.htaccess</code>) via la |
| phase Fixup de l'API, et comme les phases d'autorisation |
| interviennent <em>avant</em> cette phase, vous ne pouvez |
| utiliser <code>%{REMOTE_USER}</code> que |
| dans le contexte niveau serveur.</p></li> |
| |
| <li>On peut utiliser <code>%{LA-F:variable}</code> pour |
| effectuer une sous-requête interne (basée sur un nom de |
| fichier), pour déterminer la valeur finale de |
| <em>variable</em>. La plupart du temps, elle est identique à |
| LA-U vue précédemment.</li> |
| </ol> |
| |
| <p><em>expression_de_comparaison</em> est une expression |
| rationnelle qui est appliquée à l'instance actuelle de |
| <em>chaîne_de_test</em>. <em>chaîne_de_test</em> est d'abord |
| évaluée, puis comparée à |
| l'<em>expression_de_comparaison</em>.</p> |
| |
| <p><strong>A savoir :</strong> |
| <em>expression_de_comparaison</em> est une |
| <em>expression rationnelle compatible perl</em> avec |
| quelques extensions :</p> |
| |
| <ol> |
| <li>Vous pouvez préfixer l'expression avec un caractère |
| '<code>!</code>' (point d'exclamation) pour indiquer une |
| expression de <strong>non</strong>-correspondance.</li> |
| |
| <li>Il existe certaines variantes spéciales |
| d'<em>expressions de comparaison</em>. A la place d'une |
| expression rationnelle, vous pouvez utiliser : |
| |
| <ul> |
| <li>'<strong><expression</strong>' (inférieur au sens |
| lexicographique)<br /> |
| Traite l'<em>expression</em> comme une chaîne de |
| caractères et la compare lexicographiquement à |
| <em>chaîne_de_test</em>. La condition est satisfaite si |
| <em>chaîne_de_test</em> est inférieure au sens |
| lexicographique à l'<em>expression</em>.</li> |
| |
| <li>'<strong>>expression</strong>' (supérieur au sens |
| lexicographique)<br /> |
| Traite l'<em>expression</em> comme une chaîne de |
| caractères et la compare lexicographiquement à |
| <em>chaîne_de_test</em>. La condition est satisfaite si |
| <em>chaîne_de_test</em> est supérieure au sens |
| lexicographique à l'<em>expression</em>.</li> |
| |
| <li>'<strong>=expression</strong>' (égal au sens |
| lexicographique)<br /> |
| Traite l'<em>expression</em> comme une chaîne de |
| caractères et la compare lexicographiquement à |
| <em>chaîne_de_test</em>. La condition est satisfaite si |
| <em>chaîne_de_test</em> est égale au sens |
| lexicographique à l'<em>expression</em> (les deux chaînes |
| sont exactement identiques, caractère pour caractère). Si |
| <em>expression</em> est <code>""</code> (deux guillemets), |
| <em>chaîne_de_test</em> est comparée à la chaîne vide.</li> |
| |
| <li>'<strong>-d</strong>' (est un |
| <strong>r</strong>épertoire)<br /> |
| Traite <em>chaîne_de_test</em> comme un chemin et vérifie |
| s'il existe ou pas, et s'il s'agit d'un répertoire.</li> |
| |
| <li>'<strong>-f</strong>' (est un |
| <strong>f</strong>ichier régulier)<br /> |
| Traite <em>chaîne_de_test</em> comme un chemin et vérifie |
| s'il existe ou pas, et s'il s'agit d'un fichier régulier.</li> |
| |
| <li>'<strong>-s</strong>' (est un fichier régulier d'une |
| certaine <strong>t</strong>aille)<br /> |
| Traite <em>chaîne_de_test</em> comme un chemin et vérifie |
| s'il existe ou pas, et s'il s'agit d'un fichier régulier |
| dont la taille est supérieure à zéro.</li> |
| |
| <li>'<strong>-l</strong>' (est un |
| <strong>l</strong>ien symbolique)<br /> |
| Traite <em>chaîne_de_test</em> comme un chemin et vérifie |
| s'il existe ou pas, et s'il s'agit d'un lien |
| symbolique.</li> |
| |
| <li>'<strong>-x</strong>' (a le droit |
| d'e<strong>x</strong>écussion)<br /> |
| Traite <em>chaîne_de_test</em> comme un chemin et vérifie |
| s'il existe ou pas, et a le droit d'exécution. Ce droit est |
| déterminé en accord avec le système d'exploitation |
| sous-jacent.</li> |
| |
| <li>'<strong>-F</strong>' (test de l'existence d'un fichier |
| via une sous-requête)<br /> |
| Vérifie si <em>chaîne_de_test</em> est un fichier valide, |
| accessible à travers tous les contrôles d'accès du serveur |
| actuellement configurés pour ce chemin. C'est une |
| sous-requête interne qui effectue cette vérification - à |
| utiliser avec précautions car les performances du serveur |
| peuvent s'en trouver affectées !</li> |
| |
| <li><p>'<strong>-U</strong>' (test de l'existence d'une URL |
| via une sous-requête)<br /> |
| Vérifie si <em>chaîne_de_test</em> est une URL valide, |
| accessible à travers tous les contrôles d'accès du serveur |
| actuellement configurés pour ce chemin. C'est une |
| sous-requête interne qui effectue cette vérification - à |
| utiliser avec précautions car les performances du serveur |
| peuvent s'en trouver affectées !</p> |
| <p>Ce drapeau ne renvoie <em>que</em> des informations |
| concernant le contrôle d'accès, l'authentification et |
| l'autorisation. Il ne renvoie <em>pas</em> d'informations |
| concernant le code d'état que le gestionnaire configuré |
| (static file, CGI, proxy, etc...) aurait, quant à lui, |
| retourné.</p></li> |
| </ul> |
| |
| <note><title>Note :</title> |
| Tous ces tests peuvent aussi être préfixés par un point |
| d'exclamation ('!') pour inverser leur signification. |
| </note> |
| </li> |
| |
| <li>Vous pouvez aussi définir certains drapeaux pour |
| l'<em>expression_de_comparaison</em> en ajoutant ces |
| <strong><code>[</code><em>drapeaux</em><code>]</code></strong> |
| comme troisième argument de la directive |
| <code>RewriteCond</code>, où <em>drapeaux</em> est un |
| sous-ensemble séparé par des virgules des drapeaux suivants : |
| |
| <ul> |
| <li>'<strong><code>nocase|NC</code></strong>' |
| (<strong>n</strong>o <strong>c</strong>ase)<br /> |
| Rend le test insensible à la casse - il n'est pas fait de |
| distinction entre majuscules et minuscules, à la fois dans le |
| développement de <em>chaîne_de_test</em> et dans |
| <em>expression_de_comparaison</em>. Ce drapeau n'est pris en |
| compte que lors d'une comparaison entre <em>chaîne_de_test</em> |
| et <em>expression_de_comparaison</em>. Il ne l'est pas pour les |
| vérification par sous-requêtes ou sur le système de |
| fichiers.</li> |
| |
| <li> |
| '<strong><code>ornext|OR</code></strong>' |
| (<strong>ou</strong> condition suivante)<br /> |
| Permet de chaîner les conditions de règles avec un OU au |
| lieu du AND implicite. Exemple typique : |
| |
| <example> |
| <pre> |
| RewriteCond %{REMOTE_HOST} ^hote1 [OR] |
| RewriteCond %{REMOTE_HOST} ^hote2 [OR] |
| RewriteCond %{REMOTE_HOST} ^hote3 |
| RewriteRule ...règles concernant tous ces hôtes... |
| </pre> |
| </example> |
| |
| Sans ce drapeau, les paires |
| condition/règle devraient être écrites trois fois. |
| </li> |
| |
| <li>'<strong><code>novary|NV</code></strong>' |
| (<strong>n</strong>o <strong>v</strong>ary)<br /> |
| Si la condition contient un en-tête HTTP, ce drapeau empêche |
| ce dernier d'être ajouté à l'en-tête Vary de la réponse. <br /> |
| L'utilisation de ce drapeau peut provoquer une mise en cache |
| incorrecte de la réponse, si la représentation de cette réponse |
| varie avec la valeur de l'en-tête considéré. Ce drapeau ne |
| devrait donc être utilisé que si l'on maîtrise parfaitement le |
| fonctionnement de l'en-tête Vary. |
| </li> |
| </ul> |
| </li> |
| </ol> |
| |
| <p><strong>Exemple :</strong></p> |
| |
| <p>Pour réécrire la page d'accueil d'un site en fonction de |
| l'en-tête ``<code>User-Agent:</code>'' de la requête, vous |
| pouvez utiliser ce qui suit : </p> |
| |
| <example> |
| <pre> |
| RewriteCond %{HTTP_USER_AGENT} ^Mozilla |
| RewriteRule ^/$ /homepage.max.html [L] |
| |
| RewriteCond %{HTTP_USER_AGENT} ^Lynx |
| RewriteRule ^/$ /homepage.min.html [L] |
| |
| RewriteRule ^/$ /homepage.std.html [L] |
| </pre> |
| </example> |
| |
| <p>Explications : si vous utilisez un navigateur |
| (Netscape Navigator, Mozilla etc) qui s'identifie comme |
| 'Mozilla', vous accèderez à la page d'accueil max (qui |
| peut contenir des frames, ou d'autres ressources |
| particulières). |
| Si vous utilisez le navigateur Lynx (qui est un navigateur |
| basé sur le texte), vous accèderez à une page d'accueil min |
| (qui peut être une version conçue pour une navigation simple |
| basée sur le texte). |
| Si aucune de ces conditions n'est satisfaite (vous utilisez tout |
| autre navigateur, ou votre navigateur s'identifie de manière non |
| standard), vous accèderez à la page d'accueil std |
| (standard).</p> |
| |
| </usage> |
| |
| </directivesynopsis> |
| |
| <directivesynopsis> |
| <name>RewriteRule</name> |
| <description>Définit les règles pour le moteur de réécriture</description> |
| <syntax>RewriteRule |
| <em>Modèle</em> <em>Substitution</em> [<em>drapeaux</em>]</syntax> |
| <contextlist><context>server config</context><context>virtual host</context> |
| <context>directory</context><context>.htaccess</context></contextlist> |
| <override>FileInfo</override> |
| |
| <usage> |
| <p>La directive <directive>RewriteRule</directive> est le |
| véritable cheval de trait de la réécriture. La directive peut |
| apparaître plusieurs fois, chaque instance définissant une |
| règle de réécriture particulière. L'ordre dans lequel ces règles |
| sont définies est important - il s'agit de l'ordre dans lequel |
| les règles seront appliquées au cours du processus de |
| réécriture.</p> |
| |
| <p><a id="patterns" name="patterns"><em>Modèle</em></a> est une |
| <a id="regexp" name="regexp">expression rationnelle</a> |
| compatible perl. Dans la première règle de réécriture, |
| l'expression est comparée au |
| <a href="./directive-dict.html#Syntax">chemin de l'URL</a> de la |
| requête (%-decoded) ; les expressions suivantes sont comparées à la sortie de |
| la dernière règle de réécriture qui a été appliquée.</p> |
| |
| <note><title>Qu'est-ce qui est comparé ?</title> |
| |
| <p>Dans un contexte de serveur virtuel <directive |
| module="core">VirtualHost</directive>, le <em>modèle</em> est tout |
| d'abord comparé à la portion de l'URL située entre le nom d'hôte |
| éventuellement accompagné du port, et la chaîne de paramètres (par |
| exemple "/app1/index.html").</p> |
| |
| <p>Dans les contextes de répertoire <directive |
| module="core">Directory</directive> et htaccess, le |
| <em>modèle</em> est tout d'abord comparé au chemin du <em>système |
| de fichiers</em>, après suppression du préfixe ou chemin de base |
| ayant conduit à la règle <directive>RewriteRule</directive> (par |
| exemple "app1/index.html" ou |
| "index.html" selon l'endroit où les directives sont définies).</p> |
| |
| <p>Si vous voulez effectuer une comparaison en tenant compte du |
| nom d'hôte, du port ou de la chaîne de paramètres, utilisez une |
| directive <directive module="mod_rewrite">RewriteCond</directive> |
| comportant les variables |
| <code>%{HTTP_HOST}</code>, <code>%{SERVER_PORT}</code>, ou |
| <code>%{QUERY_STRING}</code>.</p> |
| |
| </note> |
| |
| <note><title>Réécritures dans un contexte de répertoire</title> |
| <ul> |
| <li>L'utilisation du moteur de réécriture dans les |
| fichiers <a href="../howto/htaccess.html">.htaccess</a> et les sections |
| <directive |
| type="section" module="core">Directory</directive> est un peu plus |
| complexe.</li> |
| |
| <li>Pour activer le moteur de réécriture dans ces contextes, vous devez |
| définir "<code>RewriteEngine On</code>" <strong>et</strong> |
| "<code>Options FollowSymLinks</code>". Si l'administrateur a désactivé |
| la possibilité de modifier l'option <code>FollowSymLinks</code> au |
| niveau du répertoire d'un utilisateur, vous ne pouvez pas utiliser le |
| moteur de réécriture. Cette restriction a été instaurée à des fins de |
| sécurité.</li> |
| |
| <li>Lorsqu'on utilise le moteur de réécriture dans un fichier |
| <code>.htaccess</code>, le chemin de base du répertoire courant (qui est |
| toujours le même pour ce même répertoire) est automatiquement |
| <em>supprimé</em> au cours de la comparaison avec le modèle de la règle |
| de réécriture, et automatiquement <em>ajouté</em> lorsqu'une |
| substitution relative (ne débutant pas par un slash ou un nom de |
| protocole) arrive à la fin d'un jeu de règles. Voir la directive |
| <directive module="mod_rewrite">RewriteBase</directive> pour plus de |
| détails à propos de l'ajout du préfixe après les substitutions |
| relatives.</li> |
| |
| <li>Si vous souhaitez effectuer une comparaison en prenant en compte |
| l'intégralité du |
| chemin de l'URL dans un contexte de répertoire (htaccess), vous devez |
| utiliser la variable <code>%{REQUEST_URI}</code> dans la directive |
| <directive>RewriteCond</directive>.</li> |
| |
| <li>Le prefixe supprimé se termine toujours par un slash, ce qui |
| signifie que la comparaison s'effectue avec une chaîne qui ne comporte |
| <em>jamais</em> de slash de début. Ainsi, un <em>modèle</em> contenant |
| <code>^/</code> ne correspondra jamais dans un contexte de répertoire.</li> |
| |
| <li>Bien que les règles de réécriture soient permises du point de vue de |
| la syntaxe dans les sections <directive type="section" |
| module="core">Location</directive> et <directive type="section" |
| module="core">Files</directive>, elles n'y sont pas prises en compte, et |
| n'y sont à priori d'aucune utilité.</li> |
| </ul> |
| </note> |
| |
| <p>Pour quelques conseils à propos des <glossary |
| ref="regex">expressions rationnelles</glossary>, voir le |
| document <a |
| href="../rewrite/intro.html#regex">Introduction à |
| mod_rewrite</a>.</p> |
| |
| <p>Dans mod_rewrite, on peut aussi utiliser le caractère NON |
| ('<code>!</code>') comme préfixe de modèle. Ceci vous permet |
| d'inverser la signification d'un modèle, soit pour dire |
| ``<em>si l'URL considérée ne correspond <strong>PAS</strong> à |
| ce modèle</em>''. Le caractère NON peut donc être utilisé à |
| titre exceptionnel, lorsqu'il est plus simple d'effectuer une |
| comparaison avec le modèle inversé, ou dans la dernière règle |
| par défaut.</p> |
| |
| <note><title>Note</title> |
| Si vous utilisez le caractère NON pour inverser la signification d'un |
| modèle, vous ne pouvez pas inclure de parties génériques groupées dans |
| le modèle. Ceci est dû au fait que, lorsque le modèle ne correspond |
| pas (autrement dit, sa négation correspond), les groupes sont vides. |
| Ainsi, si vous utilisez des modèles inversés, vous ne pouvez |
| pas vous référer aux groupes par <code>$N</code> dans la chaîne de |
| substitution ! |
| </note> |
| |
| <p>Dans une règle de réécriture, |
| <a id="rhs" name="rhs"><em>Substitution</em></a> est la chaîne |
| de caractères qui remplace le chemin de l'URL original qui |
| correspondait au <em>Modèle</em>. <em>Substitution</em> peut |
| être :</p> |
| |
| <dl> |
| |
| <dt>un chemin du système de fichiers</dt> |
| |
| <dd>Il indique alors la localisation dans le système de |
| fichiers de la ressource qui doit être envoyée au |
| client. Les substitutions ne sont traitées en tant que chemin du |
| système de fichiers que si les règles sont définies dans un |
| contexte de serveur (virtualhost), et si le premier élément de ce |
| chemin existe dans le système de fichiers.</dd> |
| |
| <dt>chemin d'URL</dt> |
| |
| <dd>Un chemin relatif à la valeur de <directive |
| module="core">DocumentRoot</directive> vers la ressource qui |
| doit être servie. Notez que <module>mod_rewrite</module> |
| essaie de deviner si vous avez spécifié un chemin du système |
| de fichiers ou un chemin d'URL en vérifiant si la première |
| partie du chemin existe à la racine du système de fichiers. |
| Par exemple, si vous avez spécifié comme chaîne de |
| <em>Substitution</em> <code>/www/file.html</code>, cette |
| dernière sera traitée comme un chemin d'URL <em>à moins</em> |
| qu'un répertoire nommé <code>www</code> n'existe à la racine |
| de votre système de fichiers (ou dans le cas d'une |
| réécriture au sein d'un fichier <code>.htaccess</code>, |
| relativement à la racine des documents), auquel cas la chaîne de |
| substitution sera traitée comme un chemin du système de |
| fichiers. Si vous désirez que d'autres directives de |
| correspondance d'URL (comme la directive <directive |
| module="mod_alias">Alias</directive>) soient appliquées au |
| chemin d'URL résultant, utilisez le drapeau <code>[PT]</code> |
| comme décrit ci-dessous.</dd> |
| |
| <dt>URL absolue</dt> |
| |
| <dd>Si une URL absolue est spécifiée, |
| <module>mod_rewrite</module> vérifie si le nom d'hôte |
| correspond à celui de l'hôte local. Si c'est le cas, le |
| protocole et le nom d'hôte sont supprimés, et ce qui reste est |
| traité comme un chemin d'URL. Dans le cas contraire, une |
| redirection externe vers l'URL indiquée est effectuée. Pour |
| forcer une redirection externe vers l'hôte local, voir le |
| drapeau <code>[R]</code> ci-dessous.</dd> |
| |
| <dt><code>-</code> (tiret)</dt> |
| |
| <dd>Un tiret indique qu'aucune substitution ne doit être |
| effectuée (le chemin considéré est transmis sans changement). |
| Ceci est utile quand un drapeau doit être appliqué sans |
| modifier le chemin (voir ci-dessous).</dd> |
| |
| </dl> |
| |
| <p>En plus du texte, la chaîne <em>Substition</em> peut |
| comporter :</p> |
| |
| <ol> |
| <li>des références arrières (<code>$N</code>) vers le modèle |
| d'une directive RewriteRule</li> |
| |
| <li>des références arrières (<code>%N</code>) vers le dernier |
| modèle d'une directive RewriteCond qui correspondait</li> |
| |
| <li>des variables du serveur comme dans les chaînes de test de |
| condition d'une règle (<code>%{VARNAME}</code>)</li> |
| |
| <li>des appels de |
| <a href="#mapfunc">fonctions de comparaison</a> |
| (<code>${nom correspondance:clé|défaut}</code>)</li> |
| </ol> |
| |
| <p>Les références arrières sont des identificateurs de la forme |
| <code>$</code><strong>N</strong> (<strong>N</strong>=0..9), qui |
| seront remplacés par le contenu du <strong>N</strong>ème groupe |
| du <em>Modèle</em> qui correspondait. Les variables du serveur |
| sont les mêmes que dans la <em>Chaîne de test</em> d'une |
| directive <code>RewriteCond</code>. Les fonctions de comparaison |
| sont issues de la directive <code>RewriteMap</code> dans la |
| section de laquelle elles sont décrites. Ces trois types de |
| variables sont évaluées dans l'ordre ci-dessus.</p> |
| |
| <p>Chaque règle de réécriture s'applique au résultat de la règle |
| précédente, selon l'ordre dans lequel elles ont été définies dans |
| le fichier de configuration. L'URL est <strong>intégralement |
| remplacée</strong> par la chaîne de <em>Substitution</em> et le |
| processus de réécriture se poursuit jusqu'à ce que toutes les |
| règles aient été appliquées, ou qu'il soit explicitement stoppé |
| par un drapeau <a |
| href="../rewrite/flags.html#flag_l"><code><strong>L</strong></code></a>, |
| ou par un autre drapeau qui implique un arrêt immédiat, comme |
| <code><strong>F</strong></code>.</p> |
| |
| <note><title>Modifier la chaîne de requête</title> |
| <p>Par défaut, la chaîne de requête est transmise sans |
| modification. Vous pouvez cependant créer dans la chaîne de |
| substitution des URLs dont une partie constitue une chaîne de |
| requête. Pour cela, ajoutez simplement un point d'interrogation |
| dans la chaîne de substitution pour indiquer que le texte qui |
| suit doit être réinjecté dans la chaîne de requête. Pour |
| supprimer une chaîne de requête, terminez simplement la chaîne de |
| substitution par un point d'interrogation. Pour combiner les |
| nouvelles chaînes de requête avec les anciennes, utilisez le |
| drapeau <code>[QSA]</code>.</p> |
| </note> |
| |
| <p>En outre, vous pouvez spécifier des <a name="rewriteflags" |
| id="rewriteflags">actions</a> spéciales à effectuer en ajoutant |
| des |
| <strong><code>[</code><em>drapeaux</em><code>]</code></strong> |
| comme troisième argument de la directive |
| <code>RewriteRule</code>. <em>Flags</em> est une liste de valeurs |
| déparées par des virgules, délimitée par des crochets, choisies |
| parmi les drapeaux de la table suivante. Vous trouverez plus de |
| détails et d'exemples, pour chaque drapeau, dans la <a |
| href="../rewrite/flags.html">documentation sur les drapeaux de |
| réécriture</a>.</p> |
| |
| <table border="1"> |
| <tr><th>Drapeaux et syntaxe</th> |
| <th>Fonction</th> |
| </tr> |
| <tr> |
| <td>B</td> |
| <td>Echappe les caractères non-alphanumériques <em>avant</em> |
| d'appliquer la transformation. <em><a |
| href="../rewrite/flags.html#flag_b">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>chain|C</td> |
| <td>La règle est chaînée avec la règle suivante. Si la règle |
| échoue, la ou les règles avec lesquelles elle est est chaînée |
| seront sautées. <em><a |
| href="../rewrite/flags.html#flag_c">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>cookie|CO=<em>NAME</em>:<em>VAL</em></td> |
| <td>Définit un cookie au niveau du navigateur client. La syntaxe |
| complète est : |
| CO=<em>NAME</em>:<em>VAL</em>:<em>domain</em>[:<em>lifetime</em>[:<em>path</em>[:<em>secure</em>[:<em>httponly</em>]]]] <em><a href="../rewrite/flags.html#flag_co">details ...</a></em> |
| <em><a href="../rewrite/flags.html#flag_co">détails ...</a></em> |
| </td> |
| </tr> |
| <tr> |
| <td>discardpath|DPI</td> |
| <td>Supprime la partie PATH_INFO de l'URI réécrit. <em><a |
| href="../rewrite/flags.html#flag_dpi">détails |
| ...</a></em></td> |
| </tr> |
| <tr> |
| <td>env|E=[!]<em>VAR</em>[:<em>VAL</em>]</td> |
| <td>Définit la variable d'environnement <em>VAR</em> (à la valeur |
| <em>VAL</em> si elle est fournie). La variante !<em>VAR</em> |
| annule la définition de la variable <em>VAR</em>.<em><a |
| href="../rewrite/flags.html#flag_e">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>forbidden|F</td> |
| <td>Renvoie une réponse 403 FORBIDDEN au navigateur client. |
| <em><a href="../rewrite/flags.html#flag_f">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>gone|G</td> |
| <td>Renvoie un message d'erreur 410 GONE au navigateur client. <em><a |
| href="../rewrite/flags.html#flag_g">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>Handler|H=<em>Gestionnaire de contenu</em></td> |
| <td>L'URI résultant est envoyé au <em>Gestionnaire de |
| contenu</em> pour traitement. <em><a |
| href="../rewrite/flags.html#flag_h">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>last|L</td> |
| <td>Arrête le processus de réécriture immédiatement et n'applique |
| plus aucune règle. Prêtez une attention particulière aux mises |
| en garde concernant les contextes de niveau répertoire et |
| .htaccess. <em><a |
| href="../rewrite/flags.html#flag_l">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>next|N</td> |
| <td>Réexécute le processus de réécriture à partir de la première |
| règle, en utilisant le résultat du jeu de règles, sous réserve |
| qu'il y ait un point de départ. <em><a |
| href="../rewrite/flags.html#flag_n">détails |
| ...</a></em></td> |
| </tr> |
| <tr> |
| <td>nocase|NC</td> |
| <td>Rend la comparaison entre modèles insensible à la casse. |
| <em><a href="../rewrite/flags.html#flag_nc">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>noescape|NE</td> |
| <td>Empêche mod_rewrite d'effectuer un échappement hexadécimal |
| des caractères spéciaux dans le résultat de la réécriture. <em><a |
| href="../rewrite/flags.html#flag_ne">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>nosubreq|NS</td> |
| <td>La règle est sautée si la requête courante est une |
| sous-requête interne. <em><a |
| href="../rewrite/flags.html#flag_ns">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>proxy|P</td> |
| <td>Force l'envoi en interne de l'URL de substitution en tant |
| que requête mandataire. <em><a |
| href="../rewrite/flags.html#flag_p">détails |
| ...</a></em></td> |
| </tr> |
| <tr> |
| <td>passthrough|PT</td> |
| <td>L'URI résultant est repassé au moteur de mise en |
| correspondance des URLs pour y être traité par d'autres |
| traducteurs URI-vers-nom de fichier, comme <code>Alias</code> ou |
| <code>Redirect</code>. <em><a |
| href="../rewrite/flags.html#flag_pt">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>qsappend|QSA</td> |
| <td>Ajoute toute chaîne de paramètres présente dans l'URL de la |
| requête originale à toute chaîne de paramètres créée dans la |
| cible de réécriture. <em><a |
| href="../rewrite/flags.html#flag_qsa">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>qsdiscard|QSD</td> |
| <td>Supprime toute chaîne de paramètres de l'URI entrant. <em><a |
| href="../rewrite/flags.html#flag_qsd">détails |
| ...</a></em></td> |
| </tr> |
| <tr> |
| <td>redirect|R[=<em>code</em>]</td> |
| <td>Force une redirection externe, avec un code de statut HTTP |
| optionnel. <em><a |
| href="../rewrite/flags.html#flag_r">détails ...</a></em> |
| </td> |
| </tr> |
| <tr> |
| <td>skip|S=<em>nombre</em></td> |
| <td>Si la règle courante s'applique, le moteur de réécriture |
| doit sauter les <em>nombre</em> règles suivantes. <em><a |
| href="../rewrite/flags.html#flag_s">détails ...</a></em></td> |
| </tr> |
| <tr> |
| <td>type|T=<em>MIME-type</em></td> |
| <td>Force l'attribution du <glossary>Type-MIME</glossary> |
| spécifié au fichier cible. <em><a |
| href="../rewrite/flags.html#flag_t">détails ...</a></em></td> |
| </tr> |
| </table> |
| |
| <note><title>Développement du répertoire home</title> |
| <p> Quand la chaîne de substitution commence par quelque chose comme |
| "/~user" (de manière explicite ou par références arrières), mod_rewrite |
| développe le répertoire home sans tenir compte de la présence ou de la |
| configuration du module <module>mod_userdir</module>.</p> |
| |
| <p> Ce développement n'est pas effectué si le drapeau <em>PT</em> est |
| utilisé dans la directive <directive module="mod_rewrite">RewriteRule</directive></p> |
| </note> |
| |
| <p>Voici toutes les combinaisons de substitution et leurs |
| significations :</p> |
| |
| <p><strong>Dans la configuration au niveau du serveur principal |
| (<code>httpd.conf</code>)<br /> |
| pour la requête ``<code>GET |
| /chemin/infochemin</code>'':</strong><br /> |
| </p> |
| |
| <note><pre> |
| <strong>Règle</strong> <strong>Résultat de la substitution</strong> |
| ---------------------------------------------- ---------------------------------- |
| ^/chemin(.*) autre-chemin$1 non valide, non supporté |
| |
| ^/chemin(.*) autre-chemin$1 [R] non valide, non supporté |
| |
| ^/chemin(.*) autre-chemin$1 [P] non valide, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^/chemin(.*) /autre-chemin$1 /autre-chemin/infochemin |
| |
| ^/chemin(.*) /autre-chemin$1 [R] http://cet-hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^/chemin(.*) /autre-chemin$1 [P] n'a pas lieu d'être, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^/chemin(.*) http://cet-hôte/autre-chemin$1 /autre-chemin/infochemin |
| |
| ^/chemin(.*) http://cet-hôte/autre-chemin$1 [R] http://cet-hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^/chemin(.*) http://cet-hôte/autre-chemin$1 [P] n'a pas lieu d'être, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^/chemin(.*) http://autre hôte/autre-chemin$1 http://autre hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^/chemin(.*) http://autre hôte/autre-chemin$1 [R] http://autre hôte/autre-chemin/infochemin |
| via redirection externe |
| (le drapeau [R] est |
| redondant) |
| |
| ^/chemin(.*) http://autre hôte/autre-chemin$1 [P] http://autre hôte/autre-chemin/infochemin |
| via un mandataire interne |
| </pre></note> |
| |
| <p><strong>Dans une configuration de niveau répertoire pour |
| <code>/chemin</code><br /> |
| (<code>/chemin/physique/vers/chemin/.htacccess</code>, avec |
| <code>RewriteBase /chemin</code>)<br /> |
| pour la requête ``<code>GET |
| /chemin/chemin-local/infochemin</code>'':</strong><br /> |
| </p> |
| |
| <note><pre> |
| <strong>Règle</strong> <strong>Résultat de la substitution</strong> |
| ---------------------------------------------- ---------------------------------- |
| ^chemin-local(.*) autre-chemin$1 /chemin/autre-chemin/infochemin |
| |
| ^chemin-local(.*) autre-chemin$1 [R] http://cet-hôte/chemin/autre-chemin/infochemin |
| via redirection externe |
| |
| ^chemin-local(.*) autre-chemin$1 [P] n'a pas lieu d'être, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^chemin-local(.*) /autre-chemin$1 /autre-chemin/infochemin |
| |
| ^chemin-local(.*) /autre-chemin$1 [R] http://cet-hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^chemin-local(.*) /autre-chemin$1 [P] n'a pas lieu d'être, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^chemin-local(.*) http://cet-hôte/autre-chemin$1 /autre-chemin/infochemin |
| |
| ^chemin-local(.*) http://cet-hôte/autre-chemin$1 [R] http://cet-hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^chemin-local(.*) http://cet-hôte/autre-chemin$1 [P] n'a pas lieu d'être, non supporté |
| ---------------------------------------------- ---------------------------------- |
| ^chemin-local(.*) http://autre hôte/autre-chemin$1 http://autre hôte/autre-chemin/infochemin |
| via redirection externe |
| |
| ^chemin-local(.*) http://autre hôte/autre-chemin$1 [R] http://autre hôte/autre-chemin/infochemin |
| via redirection externe |
| (le drapeau [R] est |
| redondant) |
| |
| ^chemin-local(.*) http://autre hôte/autre-chemin$1 [P] http://autre hôte/autre-chemin/infochemin |
| via un mandataire interne |
| </pre></note> |
| </usage> |
| </directivesynopsis> |
| </modulesynopsis> |
