SunshinePHP Developer Conference 2015

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

Note: 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.

Exemple #1 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 :

<!-- Le type d'encodage des données, enctype, DOIT être spécifié comme ce qui suit -->
<form enctype="multipart/form-data" action="_URL_" method="post">
  <!-- MAX_FILE_SIZE doit précéder le champ input de type file -->
  <input type="hidden" name="MAX_FILE_SIZE" value="30000" />
  <!-- Le nom de l'élément input détermine le nom dans le tableau $_FILES -->
  Envoyez ce fichier : <input name="userfile" type="file" />
  <input type="submit" value="Envoyer le fichier" />
</form>

_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 faîtes 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é.

Note:

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.

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.

Exemple #2 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.

<?php
// Dans les versions de PHP antiéreures à 4.1.0, la variable $HTTP_POST_FILES
// doit être utilisée à la place de la variable $_FILES.

$uploaddir '/var/www/uploads/';
$uploadfile $uploaddir basename($_FILES['userfile']['name']);

echo 
'<pre>';
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 
'</pre>';

?>

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 0 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é.

Exemple #3 Envoi d'un tableau de fichiers

PHP supporte les tableaux en HTML ainsi qu'avec les fichiers.

<form action="" method="post" enctype="multipart/form-data">
<p>Images:
<input type="file" name="pictures[]" />
<input type="file" name="pictures[]" />
<input type="file" name="pictures[]" />
<input type="submit" value="Send" />
</p>
</form>
<?php
foreach ($_FILES["pictures"]["error"] as $key => $error) {
    if (
$error == UPLOAD_ERR_OK) {
        
$tmp_name $_FILES["pictures"]["tmp_name"][$key];
        
$name $_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.

add a note add a note

User Contributed Notes 10 notes

up
19
daevid at daevid dot com
5 years ago
I think the way an array of attachments works is kind of cumbersome. Usually the PHP guys are right on the money, but this is just counter-intuitive. It should have been more like:

Array
(
    [0] => Array
        (
            [name] => facepalm.jpg
            [type] => image/jpeg
            [tmp_name] => /tmp/phpn3FmFr
            [error] => 0
            [size] => 15476
        )

    [1] => Array
        (
            [name] =>
            [type] =>
            [tmp_name] =>
            [error] => 4
            [size] =>
        )
)

and not this
Array
(
    [name] => Array
        (
            [0] => facepalm.jpg
            [1] =>
        )

    [type] => Array
        (
            [0] => image/jpeg
            [1] =>
        )

    [tmp_name] => Array
        (
            [0] => /tmp/phpn3FmFr
            [1] =>
        )

    [error] => Array
        (
            [0] => 0
            [1] => 4
        )

    [size] => Array
        (
            [0] => 15476
            [1] => 0
        )
)

Anyways, here is a fuller example than the sparce one in the documentation above:

<?php
foreach ($_FILES["attachment"]["error"] as $key => $error)
{
      
$tmp_name = $_FILES["attachment"]["tmp_name"][$key];
       if (!
$tmp_name) continue;

      
$name = basename($_FILES["attachment"]["name"][$key]);

    if (
$error == UPLOAD_ERR_OK)
    {
        if (
move_uploaded_file($tmp_name, "/tmp/".$name) )
           
$uploaded_array[] .= "Uploaded file '".$name."'.<br/>\n";
        else
           
$errormsg .= "Could not move uploaded file '".$tmp_name."' to '".$name."'<br/>\n";
    }
    else
$errormsg .= "Upload error. [".$error."] on file '".$name."'<br/>\n";
}
?>
up
13
michael
4 years ago
Just a little note, when I was trying to get this to work on my webserver I got error telling me the permissions were wrong, I checked and couldn't see anything wrong then I thought to try "./" for my upload directory instead of the full address which was something like "home/username/public_html/uploaddir". This will save it in the same directory as your script for the program above thats something like

<?php
// In PHP versions earlier than 4.1.0, $HTTP_POST_FILES should be used instead
// of $_FILES.

$uploaddir = './';//<----This is all I changed
$uploadfile = $uploaddir . basename($_FILES['userfile']['name']);

echo
'<pre>';
if (
move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) {
    echo
"File is valid, and was successfully uploaded.\n";
} else {
    echo
"Possible file upload attack!\n";
}

echo
'Here is some more debugging info:';
print_r($_FILES);

print
"</pre>";

?>

I know something trivial but when your new to this, those kind of things elude you.
up
5
eslindsey at gmail dot com
5 years ago
Also note that since MAX_FILE_SIZE hidden field is supplied by the browser doing the submitting, it is easily overridden from the clients' side.  You should always perform your own examination and error checking of the file after it reaches you, instead of relying on information submitted by the client.  This includes checks for file size (always check the length of the actual data versus the reported file size) as well as file type (the MIME type submitted by the browser can be inaccurate at best, and intentionally set to an incorrect value at worst).
up
1
Anonymous
1 year ago
Normalizing $_FILES structure:

<?php
    $files
= [];
   
$fix = function (&$files, $values, $prop) use (&$fix) {
        foreach (
$values as $key => $value) {
            if (
is_array($value)) {
               
$fix($files[$key], $value, $prop);
            } else {
               
$files[$key][$prop] = $value;
            }
        }
    };
    foreach (
$_FILES as $name => $props) {
        foreach (
$props as $prop => $value) {
            if (
is_array($value)) {
               
$fix($files[$name], $value, $prop);
            } else {
               
$files[$name][$prop] = $value;
            }
        }
    }
?>
up
1
Age Bosma
3 years ago
"If no file is selected for upload in your form, PHP will return $_FILES['userfile']['size'] as 0, and $_FILES['userfile']['tmp_name'] as none."

Note that the situation above is the same when a file exceeding the MAX_FILE_SIZE hidden field is being uploaded. In this case $_FILES['userfile']['size'] is also set to 0, and $_FILES['userfile']['tmp_name'] is also empty. The difference would only be the error code.
Simply checking for these two conditions and assuming no file upload has been attempted is incorrect.

Instead, check if $_FILES['userfile']['name'] is set or not. If it is, a file upload has at least been attempted (a failed attempt or not). If it is not set, no attempt has been made.
up
-4
Mark
4 years ago
$_FILES will be empty if a user attempts to upload a file greater than post_max_size in your php.ini

post_max_size should be >= upload_max_filesize in your php.ini.
up
-3
claude dot pache at gmail dot com
5 years ago
Note that the MAX_FILE_SIZE hidden field is only used by the PHP script which receives the request, as an instruction to reject files larger than the given bound. This field has no significance for the browser, it does not provide a client-side check of the file-size, and it has nothing to do with web standards or browser features.
up
-4
gustavo at roskus dot com
3 years ago
Some hosting does not have permission to use the move_uploaded_file function should replace the copy function
up
-12
zingaburga at hotmail dot com
3 years ago
The documentation is a little unclear about the MAX_FILE_SIZE value sent in the form with multiple file input fields.  The following is what I have found through testing - hopefully it may clarify it for others.

The MAX_FILE_SIZE is applied to each file (not the total size of all files) and to all file inputs which appear after it.  This means that it can be overridden for different file fields.  You can also disable it by sending no number, or sending 0 (probably anything that == '0' if you think about it).

Example:

<form enctype="multipart/form-data" action="." method="POST">
  <!-- no maximum size for userfile0 -->
  <input name="userfile0" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="1000" />
  <!-- maximum size for userfile1 is 1000 bytes -->
  <input name="userfile1" type="file" />
  <!-- maximum size for userfile2 is 1000 bytes -->
  <input name="userfile2" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="2000" />
  <!-- maximum size for userfile3 is 2000 bytes -->
  <input name="userfile3" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="0" />
  <!-- no maximum size for userfile4 -->
  <input name="userfile4" type="file" />
</form>
up
-12
mail at markuszeller dot com
3 years ago
If you want to increase the upload size, it could make sense to allow it only to a specified directory and not in the php.ini for the whole domain or server. In my case it worked very well placing that into the .htaccess file like this:

php_value    upload_max_filesize    100M
php_value    post_max_size    101M

Remember, post_max_size must be bigger than the upload_max_filesize.
To Top