Module Apache mod_rewrite

Directive RewriteBase

La directive RewriteBase permet de spécifier le préfixe d'URL à utiliser dans un contexte de répertoire (htaccess) pour les directives RewriteRule qui réécrivent vers un chemin relatif.

Cette directive est obligatoire 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 :

• La requête initiale, ainsi que la substitution, sont dans la DocumentRoot (c'est à dire que pour y accéder, il n'est pas nécessaire d'utiliser une directive telle qu'Alias).
• Le chemin du système de fichiers vers le répertoire contenant la RewriteRule, suffixé par la substitution relative est aussi valide en tant qu'URL sur le serveur (ce qui est rare).

Dans l'exemple ci-dessous, la directive RewriteBase 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.

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>

Directive RewriteCond

La directive RewriteCond définit une condition d'application d'une certaine règle. Une ou plusieurs directives RewriteCond peuvent précéder une directive RewriteRule. La règle qui suit n'est appliquée que si l'état actuel de l'URI correspond à son modèle, et si les conditions sont satisfaites.

chaîne_de_test est une chaîne de caractères qui peut contenir, en plus du plein texte, les constructions étendues suivantes :

• références arrières de règle de réécriture : ce sont des références arrières de la forme $N (0 <= N <= 9), qui donnent accès aux parties groupées (entre parenthèses) du modèle tiré de la RewriteRule assujettie au jeu de conditions concerné.
• Références arrières de condition de réécriture : ce sont des références arrières de la forme %N (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é.
• extensions de table de réécriture : ce sont des extensions de la forme ${nomTable:clé|défaut}. Voir la documentation de RewriteMap pour plus de détails.
• Variables du serveur : ce sont des variables de la forme %{ NOM_DE_VARIABLE } %{ NOM_DE_VARIABLE } où NOM_DE_VARIABLE peut être une chaîne de caractères faisant partie de la liste suivante :

  En-têtes HTTP :	connexion & requête:
  HTTP_USER_AGENT HTTP_REFERER HTTP_COOKIE HTTP_FORWARDED HTTP_HOST HTTP_PROXY_CONNECTION HTTP_ACCEPT	REMOTE_ADDR REMOTE_HOST REMOTE_PORT REMOTE_USER REMOTE_IDENT REQUEST_METHOD SCRIPT_FILENAME PATH_INFO QUERY_STRING AUTH_TYPE
  variables internes au serveur :	date et heure :	spéciaux :
  DOCUMENT_ROOT SERVER_ADMIN SERVER_NAME SERVER_ADDR SERVER_PORT SERVER_PROTOCOL SERVER_SOFTWARE	TIME_YEAR TIME_MON TIME_DAY TIME_HOUR TIME_MIN TIME_SEC TIME_WDAY TIME	API_VERSION THE_REQUEST REQUEST_URI REQUEST_FILENAME IS_SUBREQ HTTPS

  Toutes ces variables correspondent nom pour nom aux en-têtes MIME HTTP, aux variables C du serveur Apache ou aux champs struct tm du système Unix. La plupart sont documentées dans une autre partie du manuel ou dans la spécification CGI.

  SERVER_NAME et SERVER_PORT dépendent respectivement des valeurs des directives UseCanonicalName et UseCanonicalPhysicalPort.

  Parmi les variables spécifiques à mod_rewrite, ou trouve les suivantes :

  IS_SUBREQ

  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.

  API_VERSION

  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.

  THE_REQUEST

  La ligne de requête HTTP complète envoyée par le navigateur au serveur (par exemple, "GET /index.html HTTP/1.1"), à 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.

  REQUEST_URI

  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 QUERY_STRING.

  REQUEST_FILENAME

  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, REQUEST_FILENAME contient la valeur de REQUEST_URI.

  HTTPS

  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 mod_ssl soit chargé ou non).

Autres points à connaître :

1. Les variables SCRIPT_FILENAME et REQUEST_FILENAME ont la même valeur - celle du champ filename de la structure interne du serveur Apache request_rec. 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 uri de la structure request_rec).

   Si une substitution survient, et si la réécriture se poursuit, la valeur des deux variables est mise à jour en conséquence.

   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 %{LA-U:REQUEST_FILENAME} pour déterminer la valeur finale de REQUEST_FILENAME.

2. On peut aussi utiliser %{ENV:variable}, où variable 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 getenv() depuis le processus du serveur Apache.
3. Que mod_ssl soit chargé ou non, on peut utiliser %{SSL:variable}, où variable peut être remplacé par le nom d'une variable d'environnement SSL, mais la valeur produite sera toujours une chaîne de caractères vide si mod_ssl n'est pas chargé. Exemple : %{SSL:SSL_CIPHER_USEKEYSIZE} peut correspondre à 128. Ces variables sont disponibles même si l'option StdEnvVars de la directive SSLOptions n'a pas été définie.
4. Pour obtenir la valeur d'un en-tête contenu dans une requête HTTP, on peut toujours utiliser %{HTTP:header}, où header peut être remplacé par tout nom d'en-tête MIME HTTP. Exemple : %{HTTP:Proxy-Connection} est la valeur de l'en-tête HTTP ``Proxy-Connection:''.

   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 pas 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.

   Il faut garder à l'esprit que les conditions suivent une logique de court-circuit en cas de présence du drapeau 'ornext|OR', si bien que certaines d'entre elles sont susceptibles de ne pas être évaluées du tout.

5. On peut utiliser %{LA-U:variable} pour les recherches en avant qui effectuent une sous-requête interne (basée sur l'URL), pour déterminer la valeur finale de variable. 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.

   Par exemple, pour effectuer une réécriture qui tient compte de la variable REMOTE_USER dans un contexte niveau serveur (fichier httpd.conf), vous devez utiliser %{LA-U:REMOTE_USER} ; cette variable est définie au cours des phases d'autorisation, qui interviennent après la phase de traduction de l'URL (pendant laquelle agit mod_rewrite).

   Par contre, comme mod_rewrite implémente son contexte niveau répertoire (fichier .htaccess) via la phase Fixup de l'API, et comme les phases d'autorisation interviennent avant cette phase, vous ne pouvez utiliser %{REMOTE_USER} que dans le contexte niveau serveur.

6. On peut utiliser %{LA-F:variable} pour effectuer une sous-requête interne (basée sur un nom de fichier), pour déterminer la valeur finale de variable. La plupart du temps, elle est identique à LA-U vue précédemment.

expression_de_comparaison est une expression rationnelle qui est appliquée à l'instance actuelle de chaîne_de_test. chaîne_de_test est d'abord évaluée, puis comparée à l'expression_de_comparaison.

A savoir : expression_de_comparaison est une expression rationnelle compatible perl avec quelques extensions :

1. Vous pouvez préfixer l'expression avec un caractère '!' (point d'exclamation) pour indiquer une expression de non-correspondance.
2. Il existe certaines variantes spéciales d'expressions de comparaison. A la place d'une expression rationnelle, vous pouvez utiliser :
   • '<expression' (inférieur au sens lexicographique)
     Traite l'expression comme une chaîne de caractères et la compare lexicographiquement à chaîne_de_test. La condition est satisfaite si chaîne_de_test est inférieure au sens lexicographique à l'expression.
   • '>expression' (supérieur au sens lexicographique)
     Traite l'expression comme une chaîne de caractères et la compare lexicographiquement à chaîne_de_test. La condition est satisfaite si chaîne_de_test est supérieure au sens lexicographique à l'expression.
   • '=expression' (égal au sens lexicographique)
     Traite l'expression comme une chaîne de caractères et la compare lexicographiquement à chaîne_de_test. La condition est satisfaite si chaîne_de_test est égale au sens lexicographique à l'expression (les deux chaînes sont exactement identiques, caractère pour caractère). Si expression est "" (deux guillemets), chaîne_de_test est comparée à la chaîne vide.
   • '-d' (est un répertoire)
     Traite chaîne_de_test comme un chemin et vérifie s'il existe ou pas, et s'il s'agit d'un répertoire.
   • '-f' (est un fichier régulier)
     Traite chaîne_de_test comme un chemin et vérifie s'il existe ou pas, et s'il s'agit d'un fichier régulier.
   • '-s' (est un fichier régulier d'une certaine taille)
     Traite chaîne_de_test 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.
   • '-l' (est un lien symbolique)
     Traite chaîne_de_test comme un chemin et vérifie s'il existe ou pas, et s'il s'agit d'un lien symbolique.
   • '-x' (a le droit d'exécussion)
     Traite chaîne_de_test 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.
   • '-F' (test de l'existence d'un fichier via une sous-requête)
     Vérifie si chaîne_de_test 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 !

   • '-U' (test de l'existence d'une URL via une sous-requête)
     Vérifie si chaîne_de_test 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 !

     Ce drapeau ne renvoie que des informations concernant le contrôle d'accès, l'authentification et l'autorisation. Il ne renvoie pas d'informations concernant le code d'état que le gestionnaire configuré (static file, CGI, proxy, etc...) aurait, quant à lui, retourné.

   Note :

   Tous ces tests peuvent aussi être préfixés par un point d'exclamation ('!') pour inverser leur signification.
3. Vous pouvez aussi définir certains drapeaux pour l'expression_de_comparaison en ajoutant ces [drapeaux] comme troisième argument de la directive RewriteCond, où drapeaux est un sous-ensemble séparé par des virgules des drapeaux suivants :
   • 'nocase|NC' (no case)
     Rend le test insensible à la casse - il n'est pas fait de distinction entre majuscules et minuscules, à la fois dans le développement de chaîne_de_test et dans expression_de_comparaison. Ce drapeau n'est pris en compte que lors d'une comparaison entre chaîne_de_test et expression_de_comparaison. Il ne l'est pas pour les vérification par sous-requêtes ou sur le système de fichiers.
   • 'ornext|OR' (ou condition suivante)
     Permet de chaîner les conditions de règles avec un OU au lieu du AND implicite. Exemple typique :

     RewriteCond %{REMOTE_HOST}  ^hote1  [OR]
     RewriteCond %{REMOTE_HOST}  ^hote2  [OR]
     RewriteCond %{REMOTE_HOST}  ^hote3
     RewriteRule ...règles concernant tous ces hôtes...

     Sans ce drapeau, les paires condition/règle devraient être écrites trois fois.
   • 'novary|NV' (no vary)
     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.
     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.

Exemple :

Pour réécrire la page d'accueil d'un site en fonction de l'en-tête ``User-Agent:'' de la requête, vous pouvez utiliser ce qui suit :

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]

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).

Directive RewriteEngine

La directive RewriteEngine active ou désactive l'exécution du moteur de réécriture. Si sa valeur est off, ce module n'exécutera aucun traitement et ne mettra pas à jour les variables d'environnement SCRIPT_URx.

Pour désactiver le module, il vaut mieux utiliser cette directive que commenter toutes les directives RewriteRule !

Notez que les hôtes virtuels n'héritent pas des configurations de réécriture. Ceci implique que vous devez insérer une directive RewriteEngine on dans chaque hôte virtuel pour lequel vous souhaitez utiliser des règles de réécriture.

Les directives RewriteMap du type prg 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 RewriteEngine n'a pas été définie à on.

Directive RewriteLock

Cette directive définit le nom du fichier utilisé comme fichier verrou de synchronisation nécessaire à mod_rewrite pour communiquer avec les programmes liés à RewriteMap. 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.

Directive RewriteLog

La directive RewriteLog 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 ('/'), il est considéré comme relatif à la Racine du serveur. Cette directive ne doit apparaître qu'une seule fois dans la configuration du serveur.

Le format de fichier journal RewriteLog se présente comme suit :

Directive RewriteLogLevel

La directive RewriteLogLevel 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.

Pour désactiver la journalisation des actions de réécriture, positionnez simplement niveau à 0. Ceci désactive toute journalisation des actions de réécriture.

Directive RewriteMap

La directive RewriteMap définit une Table de correspondance pour la réécriture 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.

nom de la correspondance 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 :

${ nom de la correspondance : mot-clé }
${ nom de la correspondance : mot-clé | valeur par défaut }

Lorsqu'une telle construction est rencontrée, la table de correspondance Nom de la correspondance est consultée et la clé mot-clé recherchée. Si la clé est trouvée, la construction est remplacée par la valeur de remplacement. Si la clé n'est pas trouvée, elle est remplacée par la valeur par défaut, ou par une chaîne vide si aucune valeur par défaut 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é.

Par exemple, vous pouvez définir une directive RewriteMap comme suit

Vous pourrez ensuite utiliser cette table dans une directive RewriteRule comme suit :

Les combinaisons suivantes pour type_de_correspondance et source_de_la_correspondance peuvent être utilisées :

• Format texte standard
  type de correspondance : txt, source de la correspondance : chemin du système de fichiers Unix vers un fichier régulier valide

  Il s'agit de la mise en oeuvre standard de la table de correspondance pour la réécriture où source_de_la_correspondance 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 :

  mot-clé valeur de remplacement

  Exemple

  ##
  ##  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

  RewriteMap real-to-user txt:/chemin/vers/fichier/map.txt

• Format texte avec valeurs aléatoires
  type de correspondance: rnd, source de la correspondance : chemin du système de fichiers Unix vers un fichier régulier valide

  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 ``|'' signifiant ``ou''. En d'autres termes, ces caractères ``|'' 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".

  Exemple:

  Fichier de correspondances pour la réécriture

  ##
  ##  map.txt -- correspondances pour la réécriture
  ##
  
  static   www1|www2|www3|www4
  dynamic  www5|www6

  Directives de configuration

  RewriteMap serveurs rnd:/chemin/vers/fichier/map.txt

RewriteRule ^/(.*\.(png|gif|jpg)) http://${serveurs:static}/$1 [NC,P,L]
RewriteRule ^/(.*) http://${serveurs:dynamic}/$1 [P,L]

• Fichier à accès direct (Hash file)
  type de correspondance : dbm[=type], source de la correspondance : chemin du système de fichiers Unix vers un fichier régulier valide

  Ici, la source de la correspondance est un fichier binaire au format DBM contenant les mêmes données qu'un fichier au format Plein texte, mais selon une représentation particulière optimisée en vue d'une recherche très rapide. Le type peut être sdbm, gdbm, ndbm, ou db selon la configuration à la compilation . Si type est omis, la valeur retenue sera la valeur par défaut définie à la compilation.

  La création du fichier dbm à partir d'un fichier texte s'effectue à l'aide de l'utilitaire httxt2dbm.

  $ httxt2dbm -i fichier-source.txt -o fichier-dbm.map

• Fonction interne
  type de la correspondance : int, source de la correspondance : fonction interne à Apache

  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 ap_register_rewrite_mapfunc. Les fonctions fournies par défaut sont :

  • toupper:
    Convertit tous les caractères de la clé en majuscules.
  • tolower:
    Convertit tous les caractères de la clé en minuscules.
  • escape:
    Traduit les caractères spéciaux que contient la clé en séquences hexadécimales.
  • unescape:
    Reconvertit les séquences hexadécimales que contient la clé en caractères spéciaux.
• Programme de réécriture externe
  type de la correspondance : prg, source de la correspondance : chemin du système de fichiers Unix vers un fichier régulier valide

  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 "#!/chemin/vers/interpréteur" au début de sa première ligne).

  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 (stdin et stdout). 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 ``NULL'' en cas d'échec (c'est à dire 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 (c'est à dire, clé == valeur) :

  Les programmes de réécriture externes ne seront pas lancés s'ils ont été définis dans un contexte où la directive RewriteEngine n'a pas été définie à on.

  #!/usr/bin/perl
  $| = 1;
  while (<STDIN>) {
      # ...insérer ici le code de transformation ou de recherche...
      print $_;
  }

  Mais soyez très prudent :

  1. ``Ce programme doit être simple, basique'' (MERCI). Si ce programme se bloque, il bloquera aussi Apache lorsqu'il tentera d'utiliser la règle de réécriture correspondante.
  2. L'utilisation d'entrées/sorties avec tampon sur stdout est une erreur courante. Ceci est à proscrire sous peine de créer une boucle infernale ! Pour éviter ceci, on utilise ``$|=1'' comme dans l'exemple ci-dessus.
  3. On peut définir la directive RewriteLock 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.

La directive RewriteMap peut apparaître plusieurs fois. Utilisez une directive RewriteMap par fonction de correspondance pour déclarer son fichier de correspondance pour la réécriture. Bien que vous ne puissiez pas déclarer une table de correspondance dans un contexte de répertoire, vous pouvez bien entendu utiliser cette table dans un contexte de répertoire.

Directive RewriteOptions

La directive RewriteOptions définit certaines options spéciales pour la configuration au niveau du serveur ou du répertoire. La chaîne de caractères Option ne peut actuellement prendre qu'une des valeurs suivantes :

inherit

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 .htaccess du répertoire parent sont héritées.

Les règles héritées du niveau parent sont appliquées after après les règles spécifiées dans le niveau enfant.

AllowAnyURI

A partir de la version 2.2.23 de httpd, lorsqu'une directive RewriteRule est utilisée dans un contexte de serveur virtuel ou de serveur principal, mod_rewrite ne la traitera que si l'URI de la requête correspond à un chemin d'URL. Ceci permet d'éviter certains problèmes de sécurité où certaines règles peuvent permettre l'expansion de modèles inattendus (voir CVE-2011-3368 et CVE-2011-4317). Pour lever cette restriction, on peut activer l'option AllowAnyURI, et mod_rewrite 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.

Avertissement en matière de sécurité

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 fortement recommandé de ne pas utiliser cette option. En particulier, prenez garde aux chaînes d'entrée contenant le caractère '@' qui peut modifier l'interprétation de l'URI transformé, comme indiqué dans les CVE ci-dessus.

MergeBase

Avec cette option, la valeur de RewriteBase est copiée depuis une origine explicitement définie dans tout sous-répertoire qui ne définit pas sa propre RewriteBase. 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.

Directive RewriteRule

La directive RewriteRule 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.

Modèle est une expression rationnelle compatible perl. Dans la première règle de réécriture, l'expression est comparée au chemin de l'URL 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.

Pour quelques conseils à propos des expressions rationnelles, voir le document Introduction à mod_rewrite.

Dans mod_rewrite, on peut aussi utiliser le caractère NON ('!') comme préfixe de modèle. Ceci vous permet d'inverser la signification d'un modèle, soit pour dire ``si l'URL considérée ne correspond PAS à ce modèle''. 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.

Dans une règle de réécriture, Substitution est la chaîne de caractères qui remplace le chemin de l'URL original qui correspondait au Modèle. Substitution peut être :

un chemin du système de fichiers

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.

chemin d'URL

Un chemin relatif à la valeur de DocumentRoot vers la ressource qui doit être servie. Notez que mod_rewrite 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 Substitution /www/file.html, cette dernière sera traitée comme un chemin d'URL à moins qu'un répertoire nommé www n'existe à la racine de votre système de fichiers (ou dans le cas d'une réécriture au sein d'un fichier .htaccess, 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 Alias) soient appliquées au chemin d'URL résultant, utilisez le drapeau [PT] comme décrit ci-dessous.

URL absolue

Si une URL absolue est spécifiée, mod_rewrite 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 [R] ci-dessous.

- (tiret)

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).

En plus du texte, la chaîne Substition peut comporter :

1. des références arrières ($N) vers le modèle d'une directive RewriteRule
2. des références arrières (%N) vers le dernier modèle d'une directive RewriteCond qui correspondait
3. des variables du serveur comme dans les chaînes de test de condition d'une règle (%{VARNAME})
4. des appels de fonctions de comparaison (${nom correspondance:clé|défaut})

Les références arrières sont des identificateurs de la forme $N (N=0..9), qui seront remplacés par le contenu du Nème groupe du Modèle qui correspondait. Les variables du serveur sont les mêmes que dans la Chaîne de test d'une directive RewriteCond. Les fonctions de comparaison sont issues de la directive RewriteMap dans la section de laquelle elles sont décrites. Ces trois types de variables sont évaluées dans l'ordre ci-dessus.

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 intégralement remplacée par la chaîne de Substitution 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 L, ou par un autre drapeau qui implique un arrêt immédiat, comme F.

En outre, vous pouvez spécifier des actions spéciales à effectuer en ajoutant des [drapeaux] comme troisième argument de la directive RewriteRule. Flags 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 documentation sur les drapeaux de réécriture.

Voici toutes les combinaisons de substitution et leurs significations :

Dans la configuration au niveau du serveur principal (httpd.conf)
pour la requête ``GET /chemin/infochemin'':

Règle                          Résultat de la substitution
----------------------------------------------  ----------------------------------
^/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

Dans une configuration de niveau répertoire pour /chemin
(/chemin/physique/vers/chemin/.htacccess, avec RewriteBase /chemin)
pour la requête ``GET /chemin/chemin-local/infochemin'':

Règle                          Résultat de la substitution
----------------------------------------------  ----------------------------------
^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