Code-Web.org - php

Getter et setter automatiques avec les méthodes magiques sous PHP 5

Thierry Geindre — Tue, 13 May 2008 17:17:00 +0200

L' objet sous PHP 5 introduit de nouvelles methodes, dites magiques. Elles permettent de s'affranchir de tâches parfois fastidieuses telles que l'écriture de getter et de setter. Nous allons voir comment employer deux de ces méthodes.

L'un des avantages de l'objet est la possibilité d'en capsuler les données dans un objet et ainsi de pouvoir exercer un certain contrôle sur les accès qui sont effectués. Cependant, lorsque ces données deviennent nombreuses, l'écriture de toutes les méthodes d'accès peut devenir fastidieuse. Prenons un exemple assez simple :

class foo()
{
   private $a;
   private $b;
   private $c;
   [...]
   private $z;
}

Il nous faudrait, en principe, pas moins de 26 getter et 26 setter (soit 52 méthodes) pour pouvoir accéder à tous les attributs de cette classe. Il existe bien des outils qui permettent l'écriture automatisée des ces méthodes, mais on assistera alors à une belle surcharge de code.

C'est là qu'interviennent les méthodes __get() et __set().

La méthode __set()

Cette méthode reçoit deux paramètres, le nom de l'attribut auquel on souhaite accéder et la valeur que l'on souhaite lui donner. Reprenons donc avec notre exemple de classe :

class foo()
{
   private $a;
   private $b;
   private $c;
   [...]
   private $z;
 
   public function __set($attr,$value)
   {
       if(isset($this->$attr)) $this->$attr = $value;
       else throw new Exception('Unknow attribute '.$attr);
   }
}

Si l'attribut demandé n'existe pas, on lance une exception.

La méthode __get()

Cette méthode ne reçoit qu'un seul paramètre, c'est le nom de l'attribut qui a été appelé. Reprenons donc avec notre exemple de classe :

class foo()
{
   private $a;
   private $b;
   private $c;
   [...]
   private $z;
 
   public function __get($attr)
   {
      if(isset($this->$attr)) return $this->$attr;
      else throw new Exception('Unknow attribute '.$attr);
   }
}

Si l'attribut demandé n'existe pas, on lance une exception.

Réinventons stdclass

Stdclass est une classe définit par php. Elle permet de stocker autant d'attributs que l'on souhaite. Il est donc possible d'écrire le code suivant sans aucun problème :

$a = new stdclass;
$a->foo = 10;
echo $a->foo; // Affiche bien 10

Voici donc, à partir de ce que nous venons de voir, de quelle manière nous pourrions implémenter une telle classe. Pour éviter les conflits, nous la nommerons MyStdclass :

class MyStdclass
{
  private $data;
 
  public function __construct()
  {
    $this->data = array();
  }
 
  public function __set($key,$value)
  {
    $this->data[$key] = $value;
  }
 
  public function __get($key)
  {
    return $this->data[$key];
  }
}

Je ne lance pas d'erreur ici, logiquement PHP s'en chargera selon sa configuration, comportement adopté par stdclass. Mais rien n'empêche de lancer des erreurs en cas d'attribut indéfini.

Conclusion

Personnellement, l'emploi d'un tableau me parait plus propre plutôt que de définir de nouveau attribut. Un tableau est une structure naturellement dynamique en PHP et on sait que, quoi qu'il contienne, il conservera toujours la même visibilité. Quel est la visibilité de nouveaux attributs définit durant l'exécution? Bonne question, public j'imagine...

J'en ai déjà vu certains dire (ou plutôt écrire) que l'utilisation de tableaux rendait les écritures moins simples dans les méthodes. Oui mais, le fait de définir les méthodes __get() et __set() tel qu'indiqué ci-dessus, rend possible l'emploi de $this->indiceDuTableau, les écritures restent donc rigoureusement les mêmes qu'avec des attributs classiques.

Plugin de coloration syntaxique

Thierry Geindre — Mon, 31 Mar 2008 14:14:00 +0000

La coloration syntaxique manquait sur Dotclear 2, je me suis donc lancé dans la réalisation d'un plugin remplissant cette fonction. A travers cette article, je vous propose de découvrir la création de plugin pour Dotclear 2.

Pour réaliser la coloration, nous utiliserons tout simplement GeShi, une classe qui remplit admirablement bien cette fonction. Il s'agit donc d'intégrer le travaille de cette classe à Dotclear sous la forme d'un plugin.

J'ai choisi de reprendre le nom de l'ancien plugin qui fournissait la coloration syntaxique ,SyntaxeHl pour syntaxe highlight je présume.

Un répertoire avec GeShi pour le plugin

La première étape, très simple, consiste à créer un répertoire pour accueillir les fichiers de votre plugin. Pour cela, il suffit de créer un sous répertoire dans le répertoire plugins de votre Dotclear. Nommons le par exemple syntaxehl. Il vous faudra ensuite télécharger la dernière version de GeShi. Décompressez l'archive que vous venez de récupérer dans le répertoire que vous venez de créer. Ainsi vous devez obtenir un nouveau répertoire /plugins/syntaxehl/geshi/. Dans ce répertoire, vous pouvez supprimer les répertoires contrib et doc qui ne nous serons pas utile.

Informations relatives au plugin

Nous allons maintenant définir les différentes informations relatives à notre plugin. Pour cela, vous devez créer un fichier _define.php dans le répertoire /plugins/syntaxehl/. Le contenu de ce fichier sera le suivant :

<?php
$this->registerModule(
  /* Name */          "SyntaxeHl",
  /* Description*/    "Plugin de coloration syntaxique",
  /* Author */        "Votre Nom",
  /* Version */       '1',
  /* Permissions */   'usage,contentadmin'
);
?>

Les commentaires accompagnant chacun des paramètres sont suffisamment clair pour comprendre de quoi il s'agit. Nous ne nous arrêterons que sur le champ concernant les permissions. Il s'agit ici de définir quel type d'utilisateur peut activer le plugin. Dans cet exemple, nous avons choisit d'autoriser tous les utilisateurs mais on aurait également pu se limiter aux administrateurs en indiquant seulement admin.

Enregistrez les modifications puis rendez vous sur la page listant les plugin installés sur votre blog. Vous constaterez avec joie que le plugin que vous venez de créer apparaît bien dans la liste. Pour l'instant, ce plugin est totalement inutile puisqu'il ne fait absolument rien. Nous allons donc lui ajouter ses fonctionnalités.

Intercepter le code à mettre en forme

Pour mettre en forme le code inséré dans un billet, j'ai choisi d'exploiter la classe wiki2xhtml qui est employée, comme son nom l'indique, pour transformer la syntaxe Wiki d'un billet en (X)HTML.Ce choix peut être discutable puisqu'il ne permet pas de mettre en forme du code inséré dans un billet écrit directement en HTML.Cela-dit, je part du principe qu'un billet écrit en HTML directement ne devrait pas faire l'objet de modifications par un plugin puisqu'en principe il est déjà écrit dans sa version finale.

Pour mettre en forme les codes sources, nous allons exploiter une des fonctionnalités offertes par wiki2xhtml : les macros. Pour cela, nous utiliserons la fonction registerFunction de wiki2xhtml qui attend deux paramètres : le type de fonction que l'on souhaite enregistrer et la fonction en question. Pour le type, on indiquera simplement macro:nom_de_la_macro. Le fait d'enregistrer une fonction en tant que macro va déclencher l'appel à notre fonction lorsque la classe rencontrera dans le contenu du billet le texte suivant :

///nom_de_la_macro
du texte
///

Ici, notre fonction recevra du texte en paramètre, il nous suffira alors d'effectuer toutes les modifications souhaitées puis de retourner la version modifié du texte pour qu'elle remplace l'originale.

Enregistrer notre macro pour wiki2xhtml

Nous n'avons pour le moment qu'un bout de la solution finale. En effet, même si on sait comment procéder pour obtenir le code à mettre en forme, on ne sait pas vraiment comment procéder pour enregistrer notre fonction auprès de la classe wiki2xhtml aux bons moments.

Le système des behavior

Depuis la version 2, Dotclear intègre un tout nouveau système : les behavior. Terme qui peut être traduit littéralement par comportement. C'est un système très simple à utiliser qui propose une gestion événementielle. En fait, un plugin peut enregistrer une fonction pour tel ou tel événement. Lorsque cet événement se produit, Dotclear appel la ou les fonctions qui ont été enregistrées pour cet événement. En plus, ces fonctions recevront un certain nombre de paramètres différents en fonction du behavior concerné.

Parmi la liste des behavior diponibles, on trouve coreWikiPostInit qui est appelé lors de l'initialisation de la classe wiki2xhtml. La fonction qui sera enregistrée pour cette événement recevra une référence vers l'instance de wiki2xhtml en paramètre. Il sera donc très facile d'y enregistrer notre macro.

Quelques fichiers

Nous avons toutes les solutions en main pour la création de notre plugin. Nous allons maintenant pouvoir entamer le codage. Il faudra bien sur placer notre code dans certains fichiers. Comme vous pouvez l'imaginer, le fait de créer un fichier nommé n'importe comment ne sera pas forcément pris en compte par Dotclear. Le nommage est important pour le bon fonctionnement de notre plugin.

Ce qui va déterminer le nom du fichier que nous allons utiliser, c'est la partie de Dotclear dans laquelle on souhaite agir, la partie publique ou la partie administration. Pour agir sur la partie publique, on créera un fichier nommé _public.php ou alors un fichier _admin.php pour agir dans la partie administration.

Pour notre pugin, c'est dans la partie admin que nous voulons agir. En effet, les billets rédigés en syntaxe Wiki sont transformés en (X)HTML dans la partie administration. Nous allons donc créer un fichier _admin.php dans le répertoire /plugins/syntaxehl/.

Codage du plugin

Il ne nous reste maintenant plus qu'à coder notre plugin. Placez le code suivant dans le fichier _admin.php que nous venons de créer.

<?php
// Protège contre les accès directes au fichier
if (!defined('DC_CONTEXT_ADMIN')) exit;
 
// Require façon Dotclear
require(dirname(__FILE__).'/geshi/geshi.php');
 
// On enregistre notre behavior
$core->addBehavior('coreInitWikiPost',array('syntaxeHl','registerFunc'));
 
 
class syntaxeHl
{
        // Fonction correspondant à notre behavior
        public static function registerFunc(&$wiki2xhtml)
        {
                // On lit de répertoire de GeShi pour connaître
                // la liste des langages diponibles
                $dir = dirname(__FILE__).'/geshi/geshi/';
                $od = opendir($dir);
                while($f = readdir($od))
                {
                        // Si c'est bien un fichier portant l'extension .php
                        if(is_file($dir.$f) && substr($f,-4,4)=='.php')
                        {
                                // On enregistre une nouvelle macro pour ce langage
                                $lang = str_replace('.php','',$f);
                                $wiki2xhtml->registerFunction('macro:['.$lang.']',array('syntaxeHl','parse'));
                        }
                }
        }
 
        // Fonction appelée par Wiki2Xhtml
        public static function parse($text,$args)
        {
                // On supprime les caractères blancs en
                // en début et fin de chaîne (optionnel)
                $text = trim($text);
 
                // Création d'une instance de GeShi
                $geshi =& new GeSHi($text,$args);
 
                // On désactive les liens sur les mots clés (optionnel)
                $geshi->enable_keyword_links(false);
 
                // On retourne le code mis en forme, coloré
                return $geshi->parse_code();
        }
}
?>

Ayant déjà bien expliqué les solutions employées ci-dessus, je ne m'attarderais pas sur ce code. Vous pouvez consulter la documentation de Dotclear pour en savoir plus sur les méthodes utilisées.

Notez simplement que l'on utilise pas directement le nom du langage pour nommer nos macro, mais qu'on le place entre crochets ([ et ]). Il y a deux raisons à cela, d'une part le plugin qui assurait la coloration syntaxique pour Dotclear 1 utilisait lui aussi les crochets (rétro compatibilité) et d'autre part cela permet de ne pas interférer avec d'autres macros comme html par exemple qui permet d'insérer du code html dans un billet lorsqu'on est en syntaxe Wiki.

Un test ?

Si vous avez correctement suivit cet article, votre plugin est maintenant fonctionnel. Vous pouvez le tester en créant un nouveau billet et en insérant le code suivant (en syntaxe Wiki):

///[php]
<?php
  echo 'Hello world!';
?>
///

et vous obtiendrez normalement le résultat suivant :

<?php
  echo 'Hello world!';
?>

Vous remarquerez peut-être que ce plugin n'est pas rétro actif, c'est à dire que les anciens billets contenant du code sources ne seront pas colorés. Pour chacun d'entre eux, il vous faudra les éditer et enregistrer les modifications.

Packager votre plugin

Maintenant que votre plugin fonctionne, il pourrait être intéressant de le distribuer. Le meilleur moyen pour cela est de créer un package. Le moyen le plus simple est d'utiliser le plugin Packager dont c'est la seule et unique fonction.

Version finale

Pour ceux qui souhaitent simplement installer ce plugin sur leur blog, vous pouvez consulter le dépôt de plugin de Code-Web.org où vous trouverez les paquets directement installables sur Dotclear. Si vous avez des questions qui concernent ce plugin, rendez-vous sur le billet traitant de la dernière version disponible.

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.