Witam!
Niedawno miałem za zadanie napisać mały panel administracyjny dla pewnej szkoły. Panel ten miał posiadać m. in. możliwość uploadu plików na serwer. Po krótkim zastanowieniu przyszła mi myśl napisania klasy uploadera - narzędzia do uploadowania plików. Klasa była pisana na szybko w związku z tym chciałbym poddać ją do konsultacji z wami.
Zastanawiam się czego jej jeszcze brakuje, jakie posiada błędy, co można poprawić. Zaznaczam, że chciałbym jej używać także w przyszłych projektach.
Przede wszystkim chodzi o bezpieczeństwo i elastyczność.
Oto kod:

[PHP] pobierz, plaintext 
class CUploader
{
	private $aFILES = array();	// Bufor plików
	private $AllowedEx;			// Dozwolone rozszerzenia
 
	private $path;
	private $MaxSize;			// Maksymalny rozmiar pliku
	private $nFiles = 0;		// Ilość plików w buforze
 
	//Modes
	private $mode_fip;			// Tryb tworzący ścieżkę z katalogiem o nazwie pliku
	private $mode_fun; 			// Tryb bez buforowania
	private $mode_cd;			// Tryb czyszczenia docelowego katalogu
 
	//Temp variables
	private $bTrueEx;			// Zgodność rozszerzenia dodawanego pliku
	private $uploadedFiles;		// Pliki wrzucone przez bufor na serwer
 
	public function __construct($sPath = UPLOAD_DIR, $Extensions = NULL, $nMaxSize = 1048576)
	{
		$this->path = $sPath;
		$this->MaxSize = $nMaxSize;
		if(is_array($Extensions) === TRUE)
			$this->AllowedEx = $Extensions;
	}
 
	public function config(array $config = array())
	{
		if(isset($config['MODE_FIP']))
			$this->mode_fip = (bool) $config['MODE_FIP'];
		if(isset($config['MODE_FUN']))
			$this->mode_fun = (bool) $config['MODE_FUN'];
		if(isset($config['MODE_CD']))
			$this->mode_cd = (bool) $config['MODE_CD'];
		return $this;
	}
 
	public function changeDir($sDir)
	{
		if($sDir !== NULL) {
			$this->path = $sDir;
			return $this;
		}
		else return false;
	}
 
	public function setAllowedEx($Extensions = NULL)
	{
		if(is_array($Extensions) == TRUE)
		{
			$this->AllowedEx = $Extensions;
			return $this;
		}
	}
 
	public function clearBuffer()
	{
		for($i=0; $i < count($aFILES); ++$i)
		{
			unset($aFILES[$i]);
		}
		return $this;
	}
 
	public function addFile($File)
	{
		if($this->checkEx($File['name']) === TRUE) // Sprawdzenie rozszerzenia
		{
			if($this->checkSize($File['size']) === TRUE) // Sprawdzenie rozmiaru
			{
				if($this->mode_fun === TRUE) // Tryb FILE_UP_NOW
					$this->upload($File);
				else {
					$this->aFILES[$this->nFiles] = $File;
					$this->nFiles++;
				}
				return true;
			} else return false;
		} else return false;
	}
 
	// Funkcja służąca upload'owi plików z bufora na serwer. Uchwyt FileHandle wykorzystywany w razie wyłączonego buforowania.
	// Domyślnie ustawiony na 0 (wyłączony).
	public function upload($FileHandle = 0)
	{
		if($FileHandle === 0 && $this->aFILES !== NULL)
		{
			for($i=0; $i < count($this->aFILES); ++$i)
			{	
				if(is_uploaded_file($this->aFILES[$i]['tmp_name']))
				{
					if ($this->mode_fip === true) // Tryb FILE_IN_PATH
						$this->path = $this->path.(pathinfo($this->aFILES[$i]['name'], PATHINFO_FILENAME)).'/';
 
					if($this->mode_cd === true)	// Tryb CLEAR_DIRECTION
						$this->clearDir($this->path); // W tym momencie $this->path wskazuje katalog docelowy
 
					$this->path = $this->path.$this->aFILES[$i]['name']; // Utworzenie pełnej ścieżki z nazwą pliku.
					if( move_uploaded_file($this->aFILES[$i]['tmp_name'], $this->path) )
					{
						$this->uploadedFiles++;
						chmod($this->path, 0600);
					}
				}
			}
			return ($this->nFiles === $this->uploadedFiles ? true : false);
		} elseif ($FileHandle !== 0) {
			if(is_uploaded_file($FileHandle['tmp_name']))
			{
				if($this->mode_fip === true) // Tryb FILE_IN_PATH
					$this->path = $this->path.(pathinfo($FileHandle['name'], PATHINFO_FILENAME)).'/';
 
				if($this->mode_cd === true) // Tryb CLEAR_DIRECTION
					$this->clearDir($this->path); // W tym momencie $this->path wskazuje katalog docelowy
 
				$this->path = $this->path.$this->$FileHandle['name'];
				if(move_uploaded_file($FileHandle['tmp_name'], $this->path))
				{
					chmod($this->path, 0600);
					return true;
				} else return false;
			} else return false;
		} else return false;
 
	}
 
	private function checkEx ($sFileName)
	{
		if($this->AllowedEx !== NULL)
		{
			$this->bTrueEx = FALSE;
			for($i=0; $i < count($this->AllowedEx); ++$i)
			{
				if($this->AllowedEx[$i] === pathinfo($sFileName, PATHINFO_EXTENSION)) // Jeżeli rozszerzenie pliku znajduje się w tablicy dostępnych rozszerzeń - TRUE
					$this->bTrueEx = TRUE;
			}
			return ($this->bTrueEx === TRUE ? TRUE : FALSE);
		}
	}
 
	private function checkSize($nValue)
	{
		return ($nValue <= $this->MaxSize ? TRUE : FALSE);
	}
 
	private function clearDir($sDir)
	{
	      if($handle = opendir("$sDir"))
                   { 
			while(false !== ($file = readdir($handle)))
			{
			     if($file!='.' && $file!='..')
			     unlink("$sDir$file");
			} 
			closedir($handle); 
                    }
		return true;
	}
}
[PHP] pobierz, plaintext 

Jak widać klasa nie jest jeszcze ukończona i perfekcyjna, ale chciałbym się dowiedzieć czy w dobrym kierunku piszę ten kod.
Może pokrótce omówię jak to powinno działać.

Argumentami konstruktora są opcjonalnie ścieżka upload'u (domyślnie główny katalog), tablica zezwolonych rozszerzeń (możemy wybrać z dostępnych 'IMAGE', 'APPLICATION' itd., lub stworzyć własną $Ex = array('cokolwiek', 'cokolwiek2'); ) oraz maksymalny rozmiar przesyłanego pliku.
Cały upload przedstawię za pomocą schematu:

NOWY UPLOADER -> OKREŚLENIE GŁÓWNYCH PARAMETRÓW -> KONFIGURACJA TRYBÓW -> DODANIE PLIKU DO BUFORA (wielokrotne) -> UPLOAD PLIKÓW Z BUFORA

Za cel stawiałem sobie możliwość dodawania dowolnej ilości plików do bufora (tzw. multiupload).
Jeśli chodzi o tryby, jeszcze pozostawiłem ten moduł do dopracowania. Jak na razie dostępne są dwa tryby (nie wiem czy zbyt sensowne):
- MODE_FUN (FILE_UP_NOW) - tryb z wyłączonym buforowaniem. Pliki są od razu uploadowane z wywołaniem funkcji addFile();
- MODE_FIP (FILE_IN_PATH) - tryb z uploadowaniem pliku do katalogu o nazwie pliku, np. ./katalog/katalog2/podanie_11/podanie11.php

Z góry dzięki za uzasadnioną krytykę oraz uwagi.

Pozdrawiam

EDIT:
Uaktualniłem klasę, dodałem kilka poprawek oraz nowy mod MODE_CD (CLEAR_DIRECTION), który odpowiada za czyszczenie docelowego katalogu przed uploadowaniem plików. Planuję jeszcze dorobić obsługę wyjątków, a tym samym komunikatów i błędów. Już edytując ten post zauważyłem kilka niedopatrzeń, idę je poprawiać. ;-)

Wszytko pięknie, ładnie ale czy jest się męczyć? Ja używam uploadify, całkiem nieźle się spisuje, przejrzysty, łatwo się go zespala z całością, dobrze dopracowany. http://www.uploadify.com/documentation

Wiesz, ja mam nadmiar wolnego czasu ;-)

Po prostu chcę stworzyć coś bezpiecznego i elastycznego, co przyda mi się w takich małych projektach.
Jeśli chodzi o męczenie to może jestem odmianą jakiegoś nerda, ale mi to sprawia przyjemność i radochę. ^^

Pozdrawiam

[PHP] pobierz, plaintext 
if($Extensions == 'IMAGE')
$this->AllowedEx = array("gif", "jpg", "png", "bmp", "tiff", "rgb", "ras", "ico");
if($Extensions == 'AUDIO')
$this->AllowedEx = array("wav", "mp3", "mp2", "mid", "rpm", "ra");
if($Extensions == 'APPLICATION')
$this->AllowedEx = array("pdf", "zip", "mdb", "xls", "swf", "ppt", "doc", "tar");
if($Extensions == 'VIDEO')
$this->AllowedEx = array("avi", "movie", "qt", "mpeg");
if($Extensions == 'TEXT')
$this->AllowedEx = array("css", "html", "htm", "txt", "xml", "rtf", "sgml");
if($Extensions == 'MODEL')
$this->AllowedEx = array("igs", "mesh" ,"wrl", "msh");
if(is_array($Extensions) == TRUE)
$this->AllowedEx = $Extensions;
[PHP] pobierz, plaintext 

Po co ci ten wycinek. Gdy tworzysz obiekt klasy upload dodajesz właściwość z rozszerzeniami plików jakie możesz wysłać.

[PHP] pobierz, plaintext 
$upload = new upload($_FILES['upload']);
$ext = $upload->ext(array('jpg', 'png', 'gif');
$filesize = $upload->filesize(20);
[PHP] pobierz, plaintext 

Dodatkowo jakbyś jeszcze miał możliwość sprawdzania typów mime. Zauważ, że nie masz takiego czegoś jak zwracanie błędów tudzież komunikatów.
Również możesz ustawić sobie opcję, gdy będzie taki sam plik już wysłany to czy mu zmieniać automatycznie nazwę dodając do końca np _2, _3, przy wyłączonej opcji będzie go zastępować. I ważna opcja: wywalanie z nazwy plików dziwnych znaków, zostawiasz tylko litery, liczbym _ . itd.

Dzięki za cenną poradę.

Myślałem już nad sprawdzaniem typów MIME, lecz jak wiadomo pochodzą one od użytkownika, a wszystko co otrzymujemy od użytkownika należy uważać za niebezpieczne. ;-)
Czytałem o FileInfo i funkcji finfo_file(), niestety mam problem co do instalacji tego rozszerzenia PHP.

Błędy i komunikaty - aktualnie nad nimi pracuję, zastanawiam się w jakiej postaci je zwracać, jednak tutaj jestem na dobrej drodze.
Jestem bardzo wdzięczny za propozycje kolejnych 'trybów' uploadu, już niedługo dodam je do klasy, logiczne propozycje.
Wpadł mi do głowy taki pomysł trybu, w którym katalog do którego dodawany jest plik byłby czyszczony przez skrypt (taka jakby aktualizacja).

Czekam na kolejne propozycje.

Pozdrawiam

Małe sugestie:)
1) Staraj się używać === zamiast == oraz !== zamiast !=, te pierwsze porównują również typ zmiennej
2) Usuń wszystkie wywołania funkcji echo(). Ta klasa ma służyć do uploadu plików, więc echo nie ma tam racji bytu. Zamiast tego albo wyrzucaj wyjątek (może być twój własny np. CUploader_Exception) albo zwracaj kod błędu lub false, czy co tam innego wymyślisz:)
3) Do metod config() i changeDir() możesz sobie dodać na końcu: return $this; Dzięki temu będziesz mógł zrobić tak:

[PHP] pobierz, plaintext 
$cuploader->config(/*params*/)->changeDir(/*params*/);
[PHP] pobierz, plaintext 

zamiasta

[PHP] pobierz, plaintext 
$cuploader->config(/*params*/);
$cuploader->changeDir(/*params*/);
[PHP] pobierz, plaintext 

W sumie to samo możesz zrobić w clearBuffer().
4) addFile() mogłoby zwracać true w przypadku, gdy wszystko się udało.
5) metoda upload():
a) masz if ... elseif ..., więc może na samym końcu dodaj return false (true? exception?), bo teraz jak dojdzie do końca, a nie wejdzie do bloków instrukcji, to się nic nie stanie.
pętla for wykona się tylko dla jednego elementu, bo zwracasz false lub true wewnątrz niej. Powinieneś mieć jakąś zmienną $uploadAll = true i każdy swój return wewnątrz pętli zastąp $uploadAll = $uploadAll && (boolean)
6) Dodaj sobie komentarze do metod publicznych, bo z doświadczenia wiem, że po pewnym czasie zapomina się od czego był ten cudowny parametr $FileHandle i dlaczego defaultowo jest ustawiony na zero:)
7)

[PHP] pobierz, plaintext 
config($sModeFirst = NULL, $sModeSecond = NULL, $sModeThird = NULL, $sModeFourth = NULL, $sModeFifth = NULL)
[PHP] pobierz, plaintext 

Rozumiem, że tyle parametrów jest dlatego, że planujesz rozszerzyć listę ustawień
Proponuje zrobić tak:

[PHP] pobierz, plaintext 
config(array $config = array()) 
{
  if(isset($config['MOD_FLIP'])
      $this->MOD_FLIP = (bool) $config['MOD_FLIP'];
  //i tak dla każdej opcji
}
[PHP] pobierz, plaintext 

unikasz przekazywania setek parametrów, pętli for, switch'a. Dodanie kolejnej opcji, to też nie jest duża zmiana w kodzie klasy.
8) MODE_FIP i MODE_FUN powinny być pisane z małych liter. Wielkimi literami nazywa się stałe.

Nie wiem jak Ci się odwdzięczyć,
Ogromne dzięki, za pomoc w poprawie jakże istotnych spraw w klasie. Klasa jest teraz bardziej elastyczna w rozbudowie i samym użyciu.
Mam tylko pewne zastrzeżenie do punktu nr 7.

W owej radzie poleciłeś mi zastosowanie parametru jako tablicy, czyli tym samym konfiguracja klasy sprowadza się do tablicy:

[PHP] pobierz, plaintext 
$Uploader = new CUploader('./', $Ex = array("pdf"));
 
$aConfig = array();
$aConfig['MODE_FIP'] = true;
$aConfig['MODE_FUN'] = true;
 
$Uploader->config($aConfig);
[PHP] pobierz, plaintext 

Mam jednak pytanie i dążę do rozwiązania tego w taki sposób, aby efekt był podobny jak w funkcji wbudowanej unset(). Mam na myśli dowolną ilość podawanych zmiennych, bez wykorzystania tablicy. Chciałbym, aby konfiguracja klasy wyglądała mniej więcej tak:

[PHP] pobierz, plaintext 
$Uploader = new CUploader('./', $Ex = array("pdf"));
 
$Uploader->config(MODE_FIP, MODE_FUN, OTHER_MODE); // i tutaj kolejne 'mody'
[PHP] pobierz, plaintext 

Myślę, że takie rozwiązanie bardziej 'uprzyjemnia' samo korzystanie z klasy.

Pozdrawiam i dziękuję za dotychczasowe odpowiedzi

Nie wiem, czy przekazywanie do metody zbyt wielu parametrów, jest dobrym pomysłem.
Możesz dodać jedną metodę np. setMode, gdzie pierwszym parametrem byłaby nazwa trybu, a drugim - wartość (domyślnie true . Dla przyjemniejszego korzystania dodałbym tam (w ciele metody) jeszcze return $this;
I wtedy zamiast:

[PHP] pobierz, plaintext 
$Uploader->config(MODE_FIP, MODE_FUN, OTHER_MODE); 
[PHP] pobierz, plaintext 

Miałbyś:

[PHP] pobierz, plaintext 
$Uploader
   ->setMode(MODE_FIP)
   ->setMode(MODE_FUN)
   ->setMode(OTHER_MODE);
[PHP] pobierz, plaintext 

Dodatkowo te twoje tryby to był trochę przeprojektował na zasadzie:
1) Nazwy trybów zamieniłbym na consty (wewnątrz klasy):

[PHP] pobierz, plaintext 
const MODE_FIP = 1;
const MODE_FUN = 2;
const OTHER_MODE = 4;
[PHP] pobierz, plaintext 

2) Dodałbym tablice z ustawieniami trybów:

[PHP] pobierz, plaintext 
private $_config = array(
 MODE_FIP => false,
 MODE_FUN => false,
 OTHER_MODE => false
);
[PHP] pobierz, plaintext 

I tak ustawienie mode_fip na true wyglądałoby:

[PHP] pobierz, plaintext 
$Uploader->setMode(CUploader::MODE_FIP); //bez drugiego parametru, bo defaultowo jest true
[PHP] pobierz, plaintext 

Jeżeli oczywiście nadal chcesz przekazywać niesprecyzowaną (bo tak naprawdę nie wiesz ile trybów będziesz obsługiwał) ilość parametrów, to radzę się zainteresować funkcjami:
http://php.net/manual/en/function.func-get-args.php
http://www.php.net/manual/en/function.func-num-args.php
Dzięki nim unikniesz modyfikacji metody config() za każdym razem, gdy zmieni się liczba dostępnych trybów.

Możesz jeszcze użyć metody __call() do obsługi ustawiania trybów (setModeFip(), setModeFun(), setOtherMode(), etc.), ale osobiście staram się unikać magii w kodzie:P