Code-Web.org - apache

De belles URL sous Dotclear 2

Thierry Geindre — Tue, 01 Apr 2008 07:10:00 +0200

On sait aujourd'hui que, pour un meilleur référencement, il est important d'utiliser des URL human friendly. Vos visiteurs en seront ravis également. Pour cela, Dotclear vous propose les URL au format PATH_INFO. Nous allons voir dans ce petit billet comment activer les URL au format PATH_INFO et se débarrasser du vilain index.php.

Réécriture d'URL

Ce premier paragraphe ne vous intéressera que si vous souhaitez utiliser la réécriture d'URL, c'est à dire faire disparaître le vilain index.php de vos URL. Si ce n'est pas le cas, vous pouvez sauter au second paragraphe.

Dans le répertoire contenant votre Dotclear 2, créez un fichier nommé .htaccess. Placez-y le contenu suivant :

# Activation du moteur de réécriture
RewriteEngine on

# Si le fichier demandé n'existe pas physiquement
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

# On envoie la demande à l'index de Dotclear
RewriteRule (.*) /index.php/$1 [L]

Si votre Dotclear est situé dans un sous répertoire et que vous souhaitez que votre site soit accessible par un répertoire de plus haut niveau, vous devrez placer le fichier .htaccess que vous venez de créer dans ce répertoire de plus haut niveau puis remplacer la dernière ligne par ces deux lignes :

RewriteRule (.*) /sous-repertoire/index.php/$1 [L]
RewriteRule ^$ /sous-repertoire/index.php   [L]

Enfin, pour que cela fonctionne, vous devrez également activer les URL au format PATH_INFO.

Activer les URL au format PATH_INFO

La première étape consiste tout naturellement à activer ce format d'URL. Pour ce faire, rendez-vous dans les paramètres du blog accessibles via le tableau de bord. Pour l'option Méthode de lecture de l'URL, choisissez bien sur PATH_INFO. Comme vous pourrez le voir dans l'aide, l'activation de cette option nécessite également que l'URL de votre blog, définit dans la même page de configuration, se termine par un /.

Pour ce dernier paramètre, tout dépend de si vous souhaitez utiliser la réécriture d'URL ou pas. Si c'est la cas, vous pouvez indiquer une URL comme suit : http://www.mon-site.com/ suivit d'un éventuel sous répertoire mais toujours terminé par un /.Si vous n'utiliserez pas de réécriture d'URL, saisissez une URL comme suit : http://www.mon-site.com/index.php/ ou avec un sous répertoire : http://www.mon-site.com/sous-repertoire/index.php/.

Une fois cette nouvelle configuration enregistrée, vous devrez éditer le fichier /inc/config.php de Dotclear et y dé commenter les dernières lignes suivant les indications que vous trouverez dans ce même fichier.

Des problèmes?

Assurez-vous d'avoir bien suivit toutes les indications données dans ce billet. Si c'est bien le cas, vous devrez aussi vous assurer que la réécriture d'URL (aussi appelé URL Rewriting) est disponible et active chez votre hébergeur. Vérifiez également que l'emploi de fichiers .htaccess est permis.

Évitez les URL multiples et le contenu dupliqué

Thierry Geindre — Sun, 09 Mar 2008 16:12:00 +0000

L'un des points nuisant au référencement est le contenu dupliqué ou duplicate content dans le jargon. En effet, plusieurs pages ayant le même contenu sur un même site pénalisent le référencement de ce site. Malheureusement, on trouve très souvent sur un seule site plusieurs URL permettant d'accéder à la page d'accueil. Comme http://www.lesite.com/, http://lesite.com/ ou encore http://www.lesite.come/index.php etc. Nous allons voir comment régler ce problème.

Plusieurs solutions sont disponibles pour régler ce problème mais toujours du côté du serveur. Nous allons voir le cas d'apache.

Il est généralement possible de personnaliser le fonctionnement d'Apache pour un répertoire en particulier en plaçant un fichier .htaccess dans ce répertoire. Il suffira alors d'indiquer dans ce fichier de rediriger le visiteur vers la bonne URL lorsque celle qu'il utilise ne nous satisfait pas.

Pour cela, il faudra d'abord déterminer l'URL que l'on souhaite utiliser. On choisira www.le-site.com, c'est à dire l'URL contenant le www car c'est la forme la plus connu et la plus employée.

Nous allons donc créer un fichier nommé .htaccess. Pour ce faire, il suffit d'ouvrir un éditeur de fichiers texte et d'enregistrer le fichier créé sous ce nom. A noter que sous Windows, il n'est pas possible de créer des fichiers portant ce nom. Vous pourrez le renommer une fois présent sur votre FTP ou exploiter la commande rename qui autorise ce genre de nom. Placez dans ce fichiers les lignes suivantes :

# Activation du moteur de réécriture d'URL
RewriteEngine On

# On insère une condition de réécriture
# Si le nom de serveur indiqué ne commence
# pas par www
RewriteCond %{SERVER_NAME} !^www

# Nous allons rediriger le visiteur vers le site avec
# les www
RewriteRule ^(.*)$  http://www.le-site.comg/$1 [R=301,L]

Avec ces lignes, n'importe quelle page à laquelle un client accède via un nom de serveur sans les www sera automatiquement redirigé vers la même page mais avec le bon nom de serveur. D'autre part, vous aurez peut être remarqué que l'erreur 301 est renvoyée au client. Elle signifie Has moved permanently, et indique aux clients, les moteurs de recherche en particulier, que la page demandée a définitivement été déplacé vers la nouvelle adresse indiquée.

Upload de fichiers via formulaire avec PHP

Thierry Geindre — Mon, 14 Jan 2008 16:10:00 +0000

L'utilisation d'un langage côté serveur permet d'automatiser ou de simplifier bon nombre de tâches d'administration. L'upload (envoi) de fichiers fait partie de ces tâches qui peuvent être simplifiées. En effet, il est possible d'envoyer vos fichiers via un formulaire sur une page web puis d'effectuer le traitement de celui-ci grâce à PHP. Il ne sera donc plus nécessaire d'utiliser à chaque fois un client FTP.

Ceci pourra être très pratique dans le cas de l'administration d'une galerie photo par exemple, ou encore simplement pour illustrer vos publications.

Pré requis

Droits d'écriture

Pour que l'upload de fichiers puisse fonctionner correctement, il est impératif que le répertoire dans lequel on souhaitera placer les fichiers soit accessible en écriture. Sur certains systèmes, les dossiers sont toujours accessibles en écriture, c'est le cas de Windows (< Vista). En revanche, sur d'autres, tel que les systèmes dérivés d'UNIX, il est possible d'interdire l'écriture dans certains répertoires.

Ce réglage ne sera donc nécessaire que si le système de la machine qui héberge votre site utilise un mécanisme de gestions de droits sur les fichiers et répertoires.

Pour autoriser l'écriture, vous avez plusieurs possibilités. Soit en utilisant votre client FTP, auquel cas vous pourrez modifier les droits en accédant aux attributs ou aux propriétés de votre répertoire. Vous pouvez également modifier les droits de votre répertoire grâce à la fonction chmod() de PHP (reportez-vous à la documentation). Enfin, si vous avez accès directement au système de la machine (par SSH par exemple), vous pourrez modifier les droits très facilement grâce aux commandes appropriées (reportez vous à la documentation de votre système).

Configuration de php (php.ini)

Pour que l'envoie de fichiers fonctionne, PHP doit être configuré de la bonne manière. Ainsi certaine directives doivent avoir certaines valeurs. Vous pouvez modifier ces valeurs dans le fichier php.ini ou grâce à la fonction ini_set().

file_uploads est la directive qui autorise ou interdit l'upload de fichier. Sa valeur doit donc être on (inverse de off).
upload_tmp_dir correspond au répertoire dans lequel seront placé les fichiers temporairement uploadés. Ce répertoire doit lui aussi être accessible en écriture. Sur les systèmes UNIX et dérivés il s'agira souvent du répertoire /tmp/ accessible en écriture pour tous les utilisateurs du système.
upload_max_filesize détermine la taille maximal de l'envoi d'un fichier. Il n'y a pas de valeur parfaite mais 2M est une valeur courante et satisfaisante dans la plupart des cas. Elle correspond à 2 méga octets.
post_max_size correspond au volume maximum d'informations qui peuvent être envoyées via la méthode POST. Cette directive prime sur la précédente et doit logiquement avoir une valeur au moins égale. C'est pourquoi, là encore, 2M est une valeur satisfaisante.

Si vous rencontrez des difficultés dans l'upload de vos fichiers avec la méthodes que nous allons voir, c'est probablement à cause de votre configuration. SI vous ne pouvez pas y avoir accès (cas des hébergement mutualisés), utilisez la fonction phpinfo() qui vous donnera toutes les informations de configuration de php.

Le formulaire HTML

La première étape est de créer notre formulaire en HTML qui permettra l'envoie de fichiers au serveur. Pour cela, nous allons devoir préciser type de données qui sera envoyé via notre formulaire. Ce type est définit par défaut à application/x-www-form-urlencoded et ne permet pas l'envoie de fichiers. Nous allons le modifier au moyen de l'attribut enctype de la balise form et luis donner pour valeur multipart/form-data ce qui permettra l'envoie de n'importe quel type de données.

Enfin, pour permettre la sélection du fichier par le client, nous utiliserons un élément de formulaire de type file.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
 <head>
  <title>Formulaire d'upload</title>
 </head>
 <body>
  <form method="post" enctype="multipart/form-data" action="upload.php">
   <p>
    <label>S&eacute;lectionnez un fichier :
    <input type="file" name="fichier" />
    </label>
   </p>
   <p><input type="submit" value="Envoyer" /></p>
  </form>
 </body>
</html>

Cet exemple de formulaire permet d'envoyer un seul fichier sur le serveur. Ce fichier sera placé dans un répertoire contenant des fichiers temporaires et, s'il ne fait pas l'objet d'un traitement supplémentaire, il sera supprimé à la fin de l'exécution de la requête. C'est pourquoi nous allons devoir faire intervenir PHP.

Le script PHP

Passons maintenant au script chargé du traitement approprié. Nous allons dans un premier temps en voir une version simple qui autorise tout types de fichiers.

Lorsque qu'un script reçoit les informations transmises par un formulaire, on utilise habituellement la variable globale $_POST pour les lire. Cependant, pour les élément de type file, on devra récupérer les informations concernant le fichiers via la variable $_FILES. Il s'agit d'un tableau associatif contenant différentes informations concernant les fichiers envoyés. La structure de ce tableau est la suivante :

Array
(
    [nom_du_champ_file] => Array
        (
            [name] => "MaBelleImage.jpg" // Nom du fichier
            [type] => "image/jpg" // type de fichier
            [tmp_name] => "chemin_complet_du_fichier_uploadé" // Emplacement temporaire
            [error] => 0 // Code d'erreur si erreur il y a
            [size] => 1000 // Taille du fichier
        )
)

A partir de ces informations, nous pourrons effectuer différents contrôles que nous verrons un peu plus tard. Pour le moment, nous allons simplement sauvegarder le fichier envoyé.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$dstRep.$_FILES['fichier']['name']);
 
?>

Bien que ce script soit théoriquement fonctionnel, il est très imparfait. En effet, il ne contrôle pas le bon déroulement de l'envoie du fichier au moyen des codes d'erreur pouvant être indiqués dans le tableau $_FILES. En effet, la valeur de ce code nous indique le type d'erreur qui s'est produite durant l'envoie.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$dstRep.$_FILES['fichier']['name']);
 
?>

Ainsi, ce script ne devrait pas lever d'erreur. A noter que d'autres types d'erreurs ont été introduit avec les nouvelles versions de PHP. Cependant, il reste assez incomplet. Nous allons maintenant lui ajouter quelques fonctionnalités supplémentaires. Et pour commencer, une indispensable, éviter l'écrasement des fichiers.

Éviter l'écrasement de fichier

Le problème que risque de poser le script que nous avons vu est l'écrasement de fichiers déjà existant. En effet, si vous envoyez deux fichiers portant le même nom, le premier fichier sera écrasé par le second. Pour remédier à cela, je vous propose une solution assez simple qui consiste à préfixer le nom du fichier d'un chiffre. Il existe d'autres solutions mais celle-ci est assez efficace et durable.

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On vérifie si le fichier existe déjà dans le répertoire cible
  if(file_exists($dstRep.$_FILES['fichier']['name']))
  {
    // On utilise une boucle pour incrémenter notre préfixe
    $i = 0;
    while(file_exists($dstRep.$i.'_'.$_FILES['fichier']['name']) ) $i++
 
    // Arrivé ici, on a trouvé un nom disponible avec un préfixe numérique
    $cible = $dstRep.$i.'_'.$_FILES['fichier']['name'];
  }
  else
  {
    // Le fichier n'existe pas dans le répertoire cible,
    // Nous pouvons donc utiliser le nom original
    $cible = $dstRep.$_FILES['fichier']['name'];
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$cible);
 
?>

Avec cette nouvelle version, les fichiers ne pourront pas être écrasés. Nous allons maintenant voir comment limiter l'envoie à certains types de fichiers.

Limiter les types de fichiers autorisés

Pour instaurer cette limitation, on pourrait éventuellement se baser sur l'information de type (Type mime) contenue dans le tableau $_FILES. Cependant, cette information est fournit par le client, le navigateur. La règle d'or en matière de développement web est de ne jamais avoir confiance dans les données transmises par un tiers inconnu. D'autre part, cette information pourra être un peut différente pour un même type de fichier et des navigateurs différents. Pour ces raisons, on ne tiendra pas compte de cette information.

Idéalement, il faudrait utiliser une méthode consistant à rechercher le type mime à partir du contenu du fichier. Il existe, pour cela la, fonction mime_content_type() mais elle est désormais déprécier au profit de Fileinfo.

Pour faire simple ici, nous baserons notre test sur l'extension du fichier. Pour que cette méthode soit suffisamment sûr, il est important que votre serveur soit correctement configuré pour ne pas exécuter de code côté serveur dans des fichiers ne portant pas une extension propre au langage. On a pu voir, par exemple, des serveurs autorisant l'exécution de code PHP dans fichiers portant l'extension .jpg, ce qui est un peu douteu...

<?php
  // On définit notre répertoire cible
  $dstRep = './fichiers/';
 
  // On créé un tableau contenant les extensions autorisées
  $extOk = array('.jpg','.gif','.png');
 
  // On vérifie qu'il est accessible en écriture
  if(!is_writable($dstRep))
    die('Impossible d\'écrire dans le répertoire cible.');
 
  // On vérifie d'abord que des données ont bien été envoyées
  if(!isset($_FILES['fichier']))
    die('Aucune données');
 
  // Vérification du code d'erreur
  switch($_FILES['fichier']['error'])
  {
     case 1: // UPLOAD_ERR_INI_SIZE
        die("Le fichier dépasse la limite autorisée par le serveur (fichier php.ini) !");
        break;
      case 2: // UPLOAD_ERR_FORM_SIZE
        die("Le fichier dépasse la limite autorisée dans le formulaire HTML !");
        break;
      case 3: // UPLOAD_ERR_PARTIAL
        die("L'envoi du fichier a été interrompu pendant le transfert !");
        break;
      case 4: // UPLOAD_ERR_NO_FILE
        die("Le fichier que vous avez envoyé a une taille nulle !");
        break;
  }
 
  // On lit l'extension du fichier
  $fileExt = substr($_FILES['fichier']['name'],-4,4);
 
  // On vérifie que l'extension est dans le tableau
  // des extensions autorisées
  if(in_array($fileExt,$extOk))
    die("Type de fichier non autorisé.");
 
  // On vérifie si le fichier existe déjà dans le répertoire cible
  if(file_exists($dstRep.$_FILES['fichier']['name']))
  {
    // On utilise une boucle pour incrémenter notre préfixe
    $i = 0;
    while(file_exists($dstRep.$i.'_'.$_FILES['fichier']['name']) ) $i++
 
    // Arrivé ici, on a trouvé un nom disponible avec un préfixe numérique
    $cible = $dstRep.$i.'_'.$_FILES['fichier']['name'];
  }
  else
  {
    // Le fichier n'existe pas dans le répertoire cible,
    // Nous pouvons donc utiliser le nom original
    $cible = $dstRep.$_FILES['fichier']['name'];
  }
 
  // On finit par déplacer le fichier dans le répertoire cible
  move_uploaded_file($_FILES['fichier']['tmp_name'],$cible);
 
?>

Le système que nous venons de voir ne permet que de tester les extensions d'une longueur de trois caractère et nécessitera quelques modifications pour tester des extensions plus longue. Cependant, par convention, on se limite à 3 caractères pour l'extension d'un fichier.

Conclusion

Nous avons vu l'upload de fichiers avec PHP et quelques test pour aller un peu plus loin. Permettez moi un conseil, restez prudent avec l'envoie de fichiers car ceci peu ouvrir d'énormes failles sur vos sites. N'hésitez donc pas mettre en œuvre le maximum de test de sécurité sur les données envoyées.

Déplacement de pages, utiliser l'erreur 301

Thierry Geindre — Tue, 13 Nov 2007 08:24:00 +0000

CodeWeb change d'ici quelques jours de nom de domaine et de serveur. Le site deviendra alors code-web.org. C'est justement l'occasion de faire le point sur les bonnes choses à faire en cas de déplacement de pages. Je pense notamment à l'erreur HTTP 301 et la redirection vers le nouvel emplacement. L'objectif étant bien sur de conserver le référencement acquis et surtout de ne pas créer de liens morts.

Nous prendrons pour exemple notre cas. Vous verrez donc les quelques éléments que nous avons préparés et que nous allons mettre en place dès que le nouveau nom de domaine sera opérationnel. Mais avant tout, voyons l'objectif à atteindre.

Objectif

Lorsque vous créez un site sur la toile, il est possible qu'avec le temps des liens externes existent vers vos pages. Les moteurs de recherche constituent l'exemple le plus évident de liens externes. Mais pensons aussi aux liens dans les favoris de vos visiteurs, etc. L'ennui lorsque vous souhaitez déplacer vos pages, c'est que vous n'avez pas le contrôle sur les liens dont nous venons de parler. Notre objectif sera donc de faire en sorte que ces liens fonctionnent toujours.

Redirection bien sur!

En effet, nous utiliserons une redirection. Ici à l'aide de la fonction header de PHP. Pour vos visiteurs, pas de problème ils pourront être redirigés avec ce seul code :

<?php
header('location: http://www.nouveau-domain.com/');
?>

En revanche, les moteurs de recherche ne vont certainement pas apprécier et vous risquez de perdre le référencement de vos pages. Pou remédier à cela, il faudra renvoyer une erreur 301 du protocole HTTP. Ce code correspond à l'erreur "Moved Permanently", comprenez "Déplacé définitivement". La redirection qui suivra cette erreur prendra donc tout son sens pour un moteur de recherche qui pourra ainsi mettre à jour son index.

L'exemple

Prenons donc CodeWeb comme exemple. Remarquez que les adresses de nos pages sont actuellement construites ainsi :

http://codeweb.free.fr/dotclear/index.php/2007/11/12/24-deplacement-de-pages-utiliser-l-erreur-301

Sur notre nouveau nom de domaine elles seront formées ainsi :

http://www.code-web.org/index.php/2007/11/12/24-deplacement-de-pages-utiliser-l-erreur-301

On peut donc constater qu'elle possède une partie commune. C'est la partie de l'URL qui est totalement indépendant du nom de domaine. C'est celle-ci que nous allons récupérer pour effectuer la redirection vers la bonne page. Nous remplacerons donc le fichiers index.php actuellement en place dans le répertoire /dotclear/ par le script suivant :

<?php
	// On créé la nouvelle URL à partir de l'ancienne que l'on vient de récupérer
	// via $_SERVER['REQUEST_URI']
	$link = 'http://www.code-web.org/'.str_replace('/dotclear/','',$_SERVER['REQUEST_URI']);
 
	// L'erreur 301
	header("HTTP/1.1 301 Moved Permanently");
 
	// La redirection
	header('location: '.$link);
 
	// On indique qu'il n'y a plus rien à voir ici
	header("Connection: close");
?>

Ainsi, lorsqu'un visiteur tentera de se rendre sur http://codeweb.free.fr/dotclear/index.php il sera automatiquement redirigé ver http://www.code-web.org/index.php. De même pour les moteurs de recherche qui pourront, en plus, mettre a jour leur index avec les nouvelles adresses.