PHP: POST yöntemi ile karşıya dosya yükleme

POST yöntemi ile karşıya dosya yükleme

Bu özellik metin ve ikil dosyaları yükleme imkanı verir. PHP'nin kimlik doğrulama ve dosya işletim işlevleri ile kimin karşıya dosya yükleme yetkisi olacağına ve yüklenen dosya ile ne yapılacağı hakkında tam denetime sahip olursunuz.

PHP, herhangi bir RFC 1867 uyumlu tarayıcıdan gelen dosya yüklemelerini alabilir.

Bilginize: İlgili Yapılandırmalar

Ayrıca php.ini içindeki file_uploads, upload_max_filesize, upload_tmp_dir, post_max_size ve max_input_time yönergelerine bakınız.

PHP ayrıca Netscape Composer ve W3C'nin Amaya istemcileri tarafından kullanılan PUT yöntemiyle dosya yüklemeleri de destekler. Ayrıntılı bilgi için PUT Yöntemi Desteği'ne bakınız.

Örnek 1 - Karşıya Dosya Yükleme Formu

Bir dosya yükleme ekranı aşağıdaki gibi özel bir form ile oluşturulabilir:

<!-- Veri kodlama türü, enctype, aşağıdaki gibi belirtilmek ZORUNDADIR -->
<form enctype="multipart/form-data" action="__URL__" method="POST">
    <!-- MAX_FILE_SIZE dosya giriş alanından önce bulunmak zorundadır -->
    <input type="hidden" name="MAX_FILE_SIZE" value="30000" />
    <!-- input elemanının adı $_FILES dizisinin içindeki ismi belirler -->
    Bu dosyayı gönder: <input name="kullanici_dosyasi" type="file" />
    <input type="submit" value="Dosyayı Gönder" />
</form>

Yukarıdaki örnekteki __URL__ bir PHP dosyası ile değiştirilmelidir.

MAX_FILE_SIZE gizli alanı (bayt cinsinden) dosya giriş alanından önce bulunmak zorundadır ve değeri PHP tarafından kabul edilecek azami dosya boyutudur. Bu form elemanı azami-büyüklüğü aşan bir dosyanın gönderilmesini baştan engelleyeceği için büyük dosyaları boşuna beklememek açısından kullanıcılara zaman kazandırır; bu nedenle her zaman kullanılmalıdır. Ancak unutmayın: Bu ayarı tarayıcı tarafında devre dışı bırakmak oldukça kolaydır, bu nedenle daha büyük boyuttaki dosyaların bu özellik tarafından engelleneceğine güvenmeyiniz. Bunula birlikte, PHP'nin azami-büyüklük ayarı devre dışı bırakılamaz.

Bilginize:
Dosya yükleme formunuzun enctype="multipart/form-data" özniteliğine sahip olduğundan emin olun, aksi takdirde dosya yükleme çalışmaz.

Küresel $_FILES karşıdan yüklenen tüm dosyaların bilgisini içerir. Örnek formdaki $_FILES içeriği aşağıda verilmiştir. Yukarıdaki örneğe göre yüklenen dosya adı kullanici_dosyasi'dır. Bu herhangi bir isim olabilir.

$_FILES['kullanici_dosyasi']['name']: İstemci makinasındaki asıl dosya adıdır.
$_FILES['kullanici_dosyasi']['type']: Eğer tarayıcı bu bilgiyi sağladıysa dosyanın MIME türüdür. Örneğin, "image/gif". Bu MIME türü PHP tarafında denetlenmez; bu bakımdan bu değeri dikkate almayın.
$_FILES['kullanici_dosyasi']['size']: Yüklenen dosyanın bayt cinsinden boyutudur.
$_FILES['kullanici_dosyasi']['tmp_name']: Yüklenen dosyanın sunucuda saklandığı sıradaki geçici dosya adıdır.
$_FILES['kullanici_dosyasi']['error']: Bu dosya yüklemesiyle ilişkili hata kodudur.
$_FILES['kullanici_dosyasi']['full_path']: Tam dosya yolu (full_path) tarayıcı tarafından gönderilir. Bu yol her zaman gerçek dizin yapısını içermediğinden güvenilmemelidir. PHP 8.1.0 ve sonrasında kullanılabilir.

php.ini içindeki upload_tmp_dir yönergesi ile başka bir yer belirtilmediyse, dosyalar, öntanımlı olarak sunucunun öntanımlı geçici dizininde saklanır. Sunucunun öntanımlı geçici dizini PHP'nin içinde çalıştığı ortamdaki TMPDIR ortam değişkenine başka bir değer vererek değiştirilebilir. Buna PHP betiği içinden putenv() işlevi ile değer verirseniz çalışmaz. Bu ortam değişkeni diğer işlemlerin yüklenen dosyalar üzerinde çalıştığından emin olmak için de kullanılabilir.

Örnek 2 - Dosya yüklemelerinin doğrulanması

Daha fazla bilgi için is_uploaded_file() ve move_uploaded_file() işlev girdilerine de bakınız. Aşağıdaki örnek bir formdan gelen dosya yükleme isteğini işleyecektir.

<?php
$dizin = '/var/siteler/uploads/';
$yuklenecek_dosya = $dizin . basename($_FILES['kulldosyasi']['name']);

echo '<pre>';
if (move_uploaded_file($_FILES['kulldosyasi']['tmp_name'], $yuklenecek_dosya))
{
    echo "Dosya geçerli ve başarıyla yüklendi.\n";
} else {
    echo "Olası dosya yükleme saldırısı!\n";
}

echo 'Diğer hata ayıklama bilgileri:';
print_r($_FILES);

print "</pre>";

?>

Yüklenen dosyayı alan PHP betiği yüklenen dosya ile ne yapılacağını belirlemek için gerekli mantığı uygulamalıdır. Örneğin, $_FILES['kullanici_dosyasi']['size'] değişkenini çok küçük ve büyük dosyaları engellemek için kullanabilirsiniz. $_FILES['kullanici_dosyasi']['type'] değişkenini belirli türlere uymayan dosyaları engellemek için kullanabilirsiniz, fakat bunu sadece birincil denetimlerde kullanın, çünkü bu değer tamamen istemci kontrolündedir ve PHP tarafında denetlenmez. Ayrıca $_FILES['kullanici_dosyasi']['error'] kullanabileceği gibi mantığınızı da hata kodlarına göre planlayabilirsiniz. Her şartta dosyayı ya geçici dizinden silmeli ya da başka bir yere taşımalısınız.

Eğer formunuzda yüklemek için bir dosya seçilmediyse, PHP $_FILES['kullanici_dosyasi']['size'] değerini 0 ve $_FILES['kullanici_dosyasi']['tmp_name'] değerini boş döndürür.

İstemin sonunda dosya başka bir yere taşınmadı veya adı değiştirilmediyse geçici dizinden silinir.

Örnek 3 - Dosya dizisi yükleme

PHP HTML dizisi özelliğini dosyalar için de destekler.

<form action="" method="post" enctype="multipart/form-data">
<p>Resimler:
<input type="file" name="resimler[]" />
<input type="file" name="resimler[]" />
<input type="file" name="resimler[]" />
<input type="submit" value="Gönder" />
</p>
</form>

<?php
foreach ($_FILES["resimler"]["error"] as $anahtar => $hata) {
    if ($hata == UPLOAD_ERR_OK) {
        $tmp_name = $_FILES["resimler"]["tmp_name"][$anahtar];
        $name = $_FILES["resimler"]["name"][$anahtar];
        // basename() dosya sisteminin geçiş saldırılarını engelleyebilir;
        // dosya adının daha fazla doğrulanması/temizliği uygun olabilir
        $name = basename($_FILES["resimler"]["name"][$anahtar]);
        move_uploaded_file($tmp_name, "data/$name");
    }
}
?>

Dosya yükleme ilerleme çubuğu Dosya Yüklemeyi İzleme seçeneği kullanılarak gerçeklenebilir.

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 8 notes

down

daevid at daevid dot com ¶

15 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";
}
?>

down

mpyw ¶

8 years ago

Do not use Coreywelch or Daevid's way, because their methods can handle only within two-dimensional structure. $_FILES can consist of any hierarchy, such as 3d or 4d structure.

The following example form breaks their codes:

<form action="" method="post" enctype="multipart/form-data">
    <input type="file" name="files[x][y][z]">
    <input type="submit">
</form>

As the solution, you should use PSR-7 based zendframework/zend-diactoros.

GitHub:

https://github.com/zendframework/zend-diactoros

Example:

<?php

use Psr\Http\Message\UploadedFileInterface;
use Zend\Diactoros\ServerRequestFactory;

$request = ServerRequestFactory::fromGlobals();

if ($request->getMethod() !== 'POST') {
    http_response_code(405);
    exit('Use POST method.');
}

$uploaded_files = $request->getUploadedFiles();

if (
    !isset($uploaded_files['files']['x']['y']['z']) ||
    !$uploaded_files['files']['x']['y']['z'] instanceof UploadedFileInterface
) {
    http_response_code(400);
    exit('Invalid request body.');
}

$file = $uploaded_files['files']['x']['y']['z'];

if ($file->getError() !== UPLOAD_ERR_OK) {
    http_response_code(400);
    exit('File uploading failed.');
}

$file->moveTo('/path/to/new/file');

?>

down

coreywelch+phpnet at gmail dot com ¶

8 years ago

down

fravadona at gmail dot com ¶

4 years ago

mpyw is right, PSR-7 is awesome but a little overkill for simple projects (in my opinion).

Here's an example of function that returns the file upload metadata in a (PSR-7 *like*) normalized tree. This function deals with whatever dimension of upload metadata.

I kept the code extremely simple, it doesn't validate anything in $_FILES, etc... AND MOST IMPORTANTLY, it calls array_walk_recursive in an *undefined behaviour* way!!!

You can test it against the examples of the PSR-7 spec ( https://www.php-fig.org/psr/psr-7/#16-uploaded-files ) and try to add your own checks that will detect the error in the last example ^^

<?php
/**
 *  THIS CODE IS ABSOLUTELY NOT MEANT FOR PRODUCTION !!! MAY ITS INSIGHTS HELP YOU !!!
 */
function getNormalizedFiles()
{
  $normalized = array();

  if ( isset($_FILES) ) { 
    
    foreach ( $_FILES as $field => $metadata ) {
      
      $normalized[$field] = array(); // needs initialization for array_replace_recursive
      
      foreach ( $metadata as $meta => $data ) { // $meta is 'tmp_name', 'error', etc...
        
        if ( is_array($data) ) {
          
          // insert the current meta just before each leaf !!! WRONG USE OF ARRAY_WALK_RECURSIVE !!!
          array_walk_recursive($data, function (&$v,$k) use ($meta) { $v = array( $meta => $v ); });
          
          // fuse the current metadata with the previous ones
          $normalized[$field] = array_replace_recursive($normalized[$field], $data);
        
        } else {
          $normalized[$field][$meta] = $data;
        }
      } 
    }
  } 
  return $normalized;
}
?>

down

anon ¶

9 years ago

For clarity; the reason you would NOT want to replace the example script with
$uploaddir = './';
is because if you have no coded file constraints a nerd could upload a php script with the same name of one of your scripts in the scripts directory.

Given the right settings and permissions php-cgi is capable of replacing even php files.

Imagine if it replaced the upload post processor file itself. The next "upload" could lead to some easy exploits.

Even when replacements are not possible; uploading an .htaccess file could cause some problems, especially if it is sent after the nerd throws in a devious script to use htaccess to redirect to his upload.

There are probably more ways of exploiting it. Don't let the nerds get you.

More sensible to use a fresh directory for uploads with some form of unique naming algorithm; maybe even a cron job for sanitizing the directory so older files do not linger for too long.

down

eslindsey at gmail dot com ¶

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

down

Mark ¶

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

down

claude dot pache at gmail dot com ¶

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

＋add a note