Gestion des chargements de fichiersChargements de fichiers par méthode POST
Cette fonctionnalité permet aux personnes de télécharger à la fois du texte
et des fichiers binaires. Avec les fonctions d'identification et de
manipulation de fichiers de PHP, vous avez le contrôle total pour définir
qui a le droit de télécharger, mais aussi ce qui sera fait du fichier une
fois qu'il sera téléchargé.
PHP est capable de recevoir des fichiers émis par
un navigateur conforme à la norme RFC-1867.
Notes de configuration
Voir aussi les directives
file_uploads,
upload_max_filesize,
upload_tmp_dir,
post_max_size et
max_input_time dans &php.ini;
PHP supporte aussi le chargement par la méthode PUT comme dans le
navigateur Netscape Composer
et Amaya du W3C. Reportez-vous au chapitre sur le
support de la
méthode PUT.
Formulaire de chargement de fichier
Un formulaire de téléchargement de fichiers peut être construit
en créant un formulaire spécifique comme ceci :
]]>
_URL_ dans l'exemple précédent doit être remplacé et
pointé vers un fichier PHP.
Le champ caché MAX_FILE_SIZE (mesuré en octets) doit
précéder le champ input de type file et sa valeur représente la taille
maximale acceptée du fichier par PHP.
Cet élément de formulaire doit toujours être utilisé, car il permet
d'informer l'utilisateur que le transfert désiré est trop lourd
avant d'atteindre la fin du téléchargement. Gardez à l'esprit que
ce paramètre peut être "trompé" du côté du navigateur facilement, aussi
ne faites pas confiance à ce dernier, ne s'agissant finalement que d'une
fonctionnalité de convenance côté client. Le paramètre PHP (côté serveur)
à propos de la taille maximale d'un fichier téléchargé,
ne peut, lui, être trompé.
Assurez-vous que votre formulaire de téléchargement de fichier contienne
enctype="multipart/form-data", sinon,
le fichier se sera pas téléchargé.
La variable globale $_FILES va contenir toutes les
informations sur le fichier téléchargé. Son contenu est détaillé
dans notre exemple ci-dessous. Notez que l'on suppose que le nom
de la variable du fichier téléchargé est userfile, tel que
défini dans le formulaire ci-dessus, mais peut être n'importe quel nom.
$_FILES['userfile']['name']
Le nom original du fichier, tel que sur la machine du client web.
$_FILES['userfile']['type']
Le type MIME du fichier, si le navigateur a fourni cette information.
Par exemple, cela pourra être "image/gif".
Ce type mime n'est cependant pas vérifié du côté de PHP et, donc,
ne prend pas sa valeur pour se synchroniser.
$_FILES['userfile']['size']
La taille, en octets, du fichier téléchargé.
$_FILES['userfile']['tmp_name']
Le nom temporaire du fichier qui sera chargé sur la machine serveur.
$_FILES['userfile']['error']
Le code d'erreur
associé au téléchargement de fichier.
$_FILES['userfile']['full_path']
Le chemin entier tel que soumit par le navigateur.
Cette valeur ne contient pas toujours une vraie hiérarchie de dossier,
et il ne faut pas lui faire confiance.
Disponible à partir de PHP 8.1.0.
Le fichier téléchargé sera stocké temporairement dans le dossier
temporaire du système, à moins qu'un autre dossier soit fourni avec
la directive upload_tmp_dir du
&php.ini;. Le dossier par défaut du serveur peut être changé
dans l'environnement via la variable TMPDIR.
Modifier la valeur de cette variable avec la fonction putenv
dans un script PHP sera sans effet. Cette variable d'environnement
peut aussi être utilisée pour s'assurer que d'autres opérations
fonctionnent aussi sur les fichiers téléchargés.
Validation de téléchargement de fichiers
Voyez aussi les fonctions is_uploaded_file et
move_uploaded_file pour plus d'informations.
L'exemple suivant va télécharger un fichier venant d'un formulaire.
';
if (move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) {
echo "Le fichier est valide, et a été téléchargé
avec succès. Voici plus d'informations :\n";
} else {
echo "Attaque potentielle par téléchargement de fichiers.
Voici plus d'informations :\n";
}
echo 'Voici quelques informations de débogage :';
print_r($_FILES);
echo '';
?>
]]>
Le script PHP qui reçoit le fichier chargé doit pouvoir
gérer le fichier de manière appropriée. Vous
pouvez utiliser la variable $_FILES['userfile']['size'] pour recaler
tous les fichiers qui sont trop gros ou trop petits. Vous pouvez utiliser
la variable $_FILES['userfile']['type'] pour écarter
les fichiers qui n'ont pas le bon type, mais l'utiliser uniquement pour une série de
vérifications, car cette valeur est complètement sous le contrôle du client
et n'est pas vérifiée du côté de PHP.
Vous pouvez utiliser l'information dans
$_FILES['userfile']['error'] et adapter votre politique
en fonction des codes d'erreur.
Quelle que soit votre politique, vous devriez soit effacer le fichier du
dossier temporaire, soit le déplacer.
Si aucun fichier n'est sélectionné dans le formulaire, PHP retournera
&zero; dans $_FILES['userfile']['size']
et rien du tout dans $_FILES['userfile']['tmp_name'].
Le fichier sera automatiquement effacé du dossier temporaire
à la fin du script, s'il n'a pas été déplacé ou renommé.
Envoi d'un tableau de fichiers
PHP supporte les tableaux en HTML
ainsi qu'avec les fichiers.
Images:
]]>
$error) {
if ($error == UPLOAD_ERR_OK) {
$tmp_name = $_FILES["pictures"]["tmp_name"][$key];
// basename() peut empêcher les attaques "filesystem traversal";
// une autre validation/nettoyage du nom de fichier peux être appropriée
$name = basename($_FILES["pictures"]["name"][$key]);
move_uploaded_file($tmp_name, "data/$name");
}
}
?>
]]>
La barre de progression de téléchargement peut être implémentée en utilisant la progression du chargement via les sessions.
Explication sur les messages d'erreurs de chargement de fichiers
PHP retourne un code d'erreur approprié dans le
tableau de fichiers. Ce code d'erreur est accessible à l'index
['error'] du tableau, qui est créé durant
le téléchargement par PHP. En d'autres termes, le message d'erreur
est accessible dans la variable $_FILES['userfile']['error'].
UPLOAD_ERR_OK
Valeur : 0. Aucune erreur, le téléchargement est correct.
UPLOAD_ERR_INI_SIZE
Valeur : 1. La taille du fichier téléchargé excède la valeur de
upload_max_filesize,
configurée dans le &php.ini;.
UPLOAD_ERR_FORM_SIZE
Valeur : 2. La taille du fichier téléchargé excède la valeur de
MAX_FILE_SIZE, qui a été spécifiée dans
le formulaire HTML.
UPLOAD_ERR_PARTIAL
Valeur : 3. Le fichier n'a été que partiellement téléchargé.
UPLOAD_ERR_NO_FILE
Valeur : 4. Aucun fichier n'a été téléchargé.
UPLOAD_ERR_NO_TMP_DIR
Valeur : 6. Un dossier temporaire est manquant.
UPLOAD_ERR_CANT_WRITE
Valeur : 7. Échec de l'écriture du fichier sur le disque.
UPLOAD_ERR_EXTENSION
Valeur : 8. Une extension PHP a arrêté l'envoi de fichier. PHP ne propose aucun
moyen de déterminer quelle extension est en cause. L'examen du phpinfo peut aider.
Erreurs classiques
La variable MAX_FILE_SIZE ne peut pas spécifier une taille
de fichier plus grande que la taille qui a été
fixée par upload_max_filesize,
dans le &php.ini;. La valeur par défaut est 2 megaoctets.
Si une limite de mémoire est activée, une plus grande valeur de
memory_limit peut être nécessaire.
Assurez-vous d'avoir défini une valeur pour
memory_limit assez grande.
Si la valeur de
max_execution_time est trop
petite, le temps d'exécution du script peut excéder cette valeur.
Assurez-vous d'avoir défini une valeur pour
max_execution_time assez grande.
max_execution_time affecte
uniquement le temps d'exécution du script. Le temps passé sur l'activité
qui apparaît en dehors de l'exécution du script comme les appels systèmes
avec la fonction system, la fonction
sleep, les requêtes sur les bases de données, le temps
mis pour effectuer le téléchargement du fichier, etc. n'est pas inclus lors
du calcul du temps maximal de l'exécution du script.
max_input_time définit le temps
maximal, en secondes, au script pour recevoir les données ; cela inclut le
téléchargement du fichier. Pour les fichiers multiples, ou les gros
fichiers, ou encore pour les utilisateurs sur des connexions lentes,
la valeur par défaut de 60 secondes peut être dépassée.
Si post_max_size est défini de façon
trop faible, les gros fichiers ne pourront pas être téléchargés. Assurez-vous
de définir post_max_size avec une taille suffisante.
La configuration de
max_file_uploads contrôle le nombre
maximum de fichiers qui peuvent être envoyés en une requête. Si le nombre de fichiers
envoyés dépasse cette limite, alors $_FILES arrêtera la réception.
Par exemple, si max_file_uploads vaut
10, alors $_FILES ne contiendra jamais plus de
10 entités.
Ne pas valider les fichiers que vous manipulez peut donner l'accès
aux utilisateurs à des fichiers sensibles dans d'autres dossiers !
Attention : il semble que CERN httpd supprime
tout ce qui est après le premier caractère dans l'entête MIME.
Tant que c'est le cas, CERN httpd ne pourra pas
effectuer de chargements de fichiers.
Du fait de la grande diversité des systèmes, nous ne pouvons garantir que les fichiers
avec des noms exotiques (par exemple, ceux contenant des espaces) seront
traités correctement.
Le développeur ne doit pas mixer les champs input
normaux et les champs de téléchargement dans une même variable
(en utilisant un nom d'input comme
foo[]).
Télécharger plusieurs fichiers simultanément
Le téléchargement de plusieurs fichiers est possible
en utilisant des noms différents dans l'attribut
name de la balise input.
Il est aussi possible de télécharger plusieurs fichiers simultanément
et d'obtenir les informations sous forme de tableau. Pour cela, vous
devez utiliser la syntaxe de tableau dans les noms de balises
HTML, comme vous l'avez fait avec les sélections multiples
et les boîtes à cocher.
Télécharger plusieurs fichiers simultanément
Envoyez plusieurs fichiers :
]]>
Lorsque le formulaire ci-dessus a été envoyé, les
tableaux $_FILES['userfile'],
$_FILES['userfile']['name'], et
$_FILES['userfile']['size'] seront initialisés.
Par exemple, supposons que les fichiers
/home/test/review.html et
/home/test/xwp.out ont été téléchargés. Dans ce cas,
$_FILES['userfile']['name'][0]
contient review.html et
$_FILES['userfile']['name'][1] contient
xwp.out. Similairement,
$_FILES['userfile']['size'][0] va contenir
la taille du fichier review.html, etc.
$_FILES['userfile']['name'][0],
$_FILES['userfile']['tmp_name'][0],
$_FILES['userfile']['size'][0] et
$_FILES['userfile']['type'][0] sont aussi
créées.
Le paramètre
max_file_uploads limite le nombre
de fichiers qui peuvent être envoyés en une requête. Vous devrez vérifier que
votre formulaire ne tente pas d'envoyer plus de fichiers dans la requête que ne
le tolère cette limite.
Téléverser un dossier entier
Dans les champs de téléversement de fichier HTML, il est possible de
téléverser un dossier entier avec l'attribut webkitdirectory.
Cette fonctionnalité est supportée dans la plupart des navigateurs modernes.
Avec l'information full_path, il est possible de
stocker les chemins relatifs ou reconstruire la même hiérarchie de dossier sur le dossier.
Send this directory:
]]>
L'attribut webkitdirectory n'est pas standard et n'est
pas actuellement en cours de standardisation.
Ceci n'est pas à utiliser sur des sites de production tournés vers le Web :
ça ne fonctionnera pas pour tous les utilisateurs.
Il peut y avoir de grandes incompatibilités parmi les implémentations
et le comportement peut changer dans le futur.
PHP analyse uniquement les informations des chemins relatifs soumit par
le navigateur/user-agent et transmet les informations dans le tableau
$_FILES.
Il n'y a aucune garanties que les valeurs dans le tableau
full_path contienne une vraie structure de dossier
et l'application PHP ne doit pas faire confiance à cette information.
Chargement par méthode PUT
PHP supporte la méthode HTTP PUT utilisée par
les navigateurs pour y stocker des fichiers sur un serveur.
Les requêtes de type PUT sont beaucoup plus simples que
les chargements de fichiers en utilisant le type POST, et elles
ressemblent à :
Méthode PUT pour les chargements de fichiers
Normalement, cela signifie que le serveur distant va sauver
les données qui suivent dans le fichier : /path/filename.html
de son disque. Ce n'est évidemment pas très
sécurisé de laisser Apache ou PHP écraser n'importe
quel fichier de l'arborescence. Pour éviter ceci, il faut d'abord
dire au serveur que vous voulez qu'un script PHP donné gère
la requête. Avec Apache, il y a une directive pour cela :
Script. Elle peut être placée
n'importe où dans le fichier de configuration d'Apache.
En général, les webmestres la placent dans le bloc
<Directory>, ou peut-être dans le bloc
<VirtualHost>.
La ligne suivante fera très bien l'affaire :
Directive Apache pour le chargement par méthode PUT
Elle indique à Apache qu'il doit envoyer les requêtes
de chargement par méthode PUT au script
put.php. Bien entendu,
cela présuppose que vous avez activé PHP pour qu'il
prenne en charge les fichiers de type .php,
et que PHP est actif. La ressource de destination pour toutes les
requêtes PUT de ce script doit être le script lui-même, et non le
nom du fichier que le fichier téléchargé doit avoir.
Avec PHP, vous voudriez faire quelque chose comme ce qui suit
dans votre put.php. Ceci va copier le contenu
du fichier téléchargé dans le fichier
myputfile.ext sur le serveur.
Vous devez probablement vouloir effectuer quelques vérifications et/ou
identifier l'utilisateur avant d'effectuer cette copie de fichier.
Sauvegarde de fichiers HTTP PUT
]]>
&reftitle.seealso;
Sécurité des fichiers