Zend FR

<?php

require_once 'Zend/Loader.php';

Zend_Loader::registerAutoload();

try
{
    $path = dirname(__FILE__) . '/upload/';

    $file = new Seadragon_Upload(new Seadragon_Upload_File_Http('uploadedFile'));
    $driver = new Seadragon_Upload_Driver_Filesystem($path);
    $file->setDriver($driver);

    $file->save();
}
catch(Seadragon_Upload_Exception $e)
{
    header('Content-type: text/plain');
    echo 'Seadragon Upload Exception: ' . "\n";
    echo $e->getMessage();
    exit;
}
catch(Exception $e)
{
    header('Content-type: text/plain');
    echo 'Unknown Exception: ' . "\n";
    echo $e->getMessage();
    exit;
}

?>

class Seadragon_Upload
{
    private $fileInfo = NULL;
    private $driver = NULL;

    private static $defaultDriverHandle = NULL;

/**
 * Seadragon_Upload constructor
 *
 * @param file The POST parameter name.
 * @param driver The storage driver used for this file, a @a Seadragon_Upload_File instance
 * @throws Seadragon_Upload_Exception
 */
    public function __construct($fileInfo, &$driver = NULL)
    {
        if(isset($fileInfo) && !($fileInfo instanceof Seadragon_Upload_File))
        {
            throw new Seadragon_Upload_Exception(
                sprintf('Parameter $driver isn\'t a Seadragon_Upload_File instance'));
        }

        $this->fileInfo = $fileInfo;

        if(isset($driver) && !($driver instanceof Seadragon_Upload_Driver))
        {
            throw new Seadragon_Upload_Exception(
                sprintf('Parameter $driver isn\'t a Seadragon_Upload_Driver instance'));
        }

        $this->driver = $driver;
    }

/**
 * Worker method, lauches the file storage mechanism
 */
    public function save()
    {
        if(!isset($this->driver) && !($this->driver instanceof Seadragon_Upload_Driver))
        {
            $this->driver = self::loadDriver();
        }

        $this->driver->store($this->fileInfo);
    }

/**
 * Sets up the file's storage object driver
 *
 * @param driver The storage driver, a @a Seadragon_Upload_Driver instance
 */
    public function setDriver(&$driver)
    {
        $this->driver = &$driver;
    }

/**
 * Sets up the default file storage driver object
 *
 * @param driver The storage driver, a @a Seadragon_Upload_Driver instance
 * @throws Seadragon_Upload_Exception
 */
    public static function registerDriver(&$driver)
    {
        if(!isset($driver) || !($driver instanceof Seadragon_Upload_Driver))
        {
            throw new Seadragon_Upload_Exception(
                sprintf('Parameter $driver isn\'t a Seadragon_Upload_Driver instance'));
        }

        self::$defaultDriverHandle = &$driver;
    }

/**
 * Retrieves the default file storage driver object
 *
 * @return The default storage driver object
 * @throws Seadragon_Upload_Exception
 */
    public static function &loadDriver()
    {
        if(!isset(self::$defaultDriverHandle))
        {
            throw new Seadragon_Upload_Exception('No storage driver selected');
        }

        return self::$defaultDriverHandle;
    }
}

class Seadragon_Upload_Driver
{
    public function __construct()
    {
    }

    public function store($fileInfo)
    {
        if(!isset($fileInfo) || !($fileInfo instanceof Seadragon_Upload_File))
        {
            throw new Seadragon_Upload_Exception(
                sprintf('Parameter $fileInfo isn\'t a Seadragon_Upload_File instance'));
        }
    }
}

class Seadragon_Upload_Driver_Filesystem
    extends Seadragon_Upload_Driver
{
    protected $uploadDir = NULL;

    public function __construct($uploadDir = NULL)
    {
        parent::__construct();

        $this->setUploadDir($uploadDir);
    }

    public function setUploadDir($uploadDir)
    {
        if(!isset($uploadDir) || empty($uploadDir))
        {
            throw new Seadragon_Upload_Exception('Empty upload path');
        }

        if(!is_writable($uploadDir))
        {
            throw new Seadragon_Upload_Exception('Can\'t write data into specified upload directory');
        }

        $this->uploadDir = $uploadDir;
    }

    public function store($fileInfo)
    {
        parent::store($fileInfo);

        $newPath = $this->uploadDir . '/' . $fileInfo->fileName;

        if(file_exists($newPath))
        {
            throw new Seadragon_Upload_Exception('File already exists');
        }

        if(!move_uploaded_file($fileInfo->fileNameTmp, $newPath))
        {
            throw new Seadragon_Upload_Exception('File upload failed');
        }
    }
}

<?php
/**
 * Rewix extension for Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://www.rewix.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to contact@rewix.com so we can send you a copy immediately.
 *
 * @category   Rx
 * @package    Rx_Controller_Action_Helper_ViewRenderer
 * @copyright  Copyright (c) 2007 Rewix (http://www.rewix.com)
 * @license    http://www.rewix.com/license/new-bsd     New BSD License
 */

require_once 'Zend/Validate/Abstract.php';

/**
 * Rx_Validate_UploadedFile
 * Validator for uploded file
 *
 * @category   Rx
 * @package    Rx_Validate_UploadedFile
 * @copyright  Copyright (c) 2007 Rewix (http://www.rewix.com)
 * @license    http://www.rewix.com/license/new-bsd     New BSD License
 */
class Rx_Validate_UploadedFile extends Zend_Validate_Abstract {

    const NO_FILE = 'noUploadedFile';
    const TOO_SMALL = 'FileSizeIsTooSmall';
    const TOO_BIG = 'FileSizeIsTooBig';
    const PARTIAL = 'uploadedPartially';
    const SERVER = 'serverError';
    const MIME_TYPE = 'mimeType';
    const EXTENSION = 'extension';

    /**
     * @var array
     */
    protected $_messageTemplates = array(
        self::NO_FILE => "There is no uploaded file",
        self::TOO_SMALL => "The file '%value%' is too small (minimum size is: %min%o)",
        self::TOO_BIG => "The file '%value%' is too big (maximum size is: %max%o)",
        self::PARTIAL => "The file '%value%' was uploaded partially.",
        self::SERVER  => "The server encounter a problem with the file '%value%'",
        self::MIME_TYPE  => "The file '%value%' is not authorized (wrong type)",
        self::EXTENSION  => "The file '%value%' has been stopped for security reason (extension not authorized)"
    );

    /**
     * @var array
     */
    protected $_messageVariables = array(
        'min' => '_minSize',
        'max' => '_maxSize'
    );

    protected $_pathToMove;
    protected $_minSize;
    protected $_maxSize;
    protected $_authorizedMimeType;
    protected $_authorizedExt;

    public function __construct($options=null) {
        //Building options
        $this->_pathToMove = $options['path'];
        $this->_minSize = $options['minsize'];
        $this->_maxSize = (isset($options['maxsize']))?$options['maxsize']:UPLOAD_MAX_FILE_SIZE;
        $this->_authorizedMimeType = $options['mime'];
        $this->_authorizedExt = $options['ext'];
    }

    public function isValid($file) {
        if (is_string($file)) {
            $file = $_FILES[$file];
        }

        $this->_setValue($file['name']);

        if ($file['error']) {
            switch($file['error']) {
            case UPLOAD_ERR_OK: //Aucune erreur, le téléchargement est correct
                break;
            case UPLOAD_ERR_INI_SIZE: //Le fichier téléchargé excède la taille de upload_max_filesize, configurée dans le php.ini.
            case UPLOAD_ERR_FORM_SIZE: //Le fichier téléchargé excède la taille de MAX_FILE_SIZE, qui a été spécifiée dans le formulaire HTML.
                $this->_error(self::TOO_BIG);
                break;
            case UPLOAD_ERR_PARTIAL: //Le fichier n'a été que partiellement téléchargé.
                $this->_error(self::PARTIAL);
                break;
            case UPLOAD_ERR_NO_FILE: //Aucun fichier n'a été téléchargé.
                $this->_error(self::NO_FILE);
                break;
            case UPLOAD_ERR_EXTENSION: //L'envoi de fichier est arrêté par l'extension. Introduit en PHP 5.2.0.
                $this->_error(self::EXTENSION);
                break;
            case UPLOAD_ERR_NO_TMP_DIR: //Un dossier temporaire est manquant. Introduit en PHP 4.3.10 et PHP 5.0.3.
            case UPLOAD_ERR_CANT_WRITE: //Échec de l'écriture du fichier sur le disque. Introduit en PHP 5.1.0.
            default:
                $this->_error(self::SERVER);
            }
        }

        if (!is_null($this->_authorizedMimeType)) {
            if (!in_array($file['type'],$this->_authorizedMimeType)) {
                $this->_error(self::MIME_TYPE);
            }
        }

        if (!is_null($this->_authorizedExt)) {
            if (!in_array($this->_getExtension($file),$this->_authorizedExt)) {
                $this->_error(self::EXTENSION);
            }
        }

        //Is it useless?
        if (!is_null($this->_minSize) && $file['size'] < $this->_minSize) {
            $this->_error(self::TOO_SMALL);
        }

        if (!is_null($this->_maxSize) && $file['size'] > $this->_maxSize) {
            $this->_error(self::TOO_BIG);
        }

        if (count($this->_messages)) {
            return false;
        } else {
            return true;
        }
    }

    private function _getExtension($file) {
        return array_pop(explode(".", $file['name']));
    }

    public function setMinSize($minsize) {
        $this->_minSize = (int) $minsize;
        return $this;
    }

    public function setMaxSize($maxsize) {
        $this->_maxSize = (int) $maxsize;
        return $this;
    }

    public function setAuthorizedMimeType($mimetypes) {
        $this->_authorizedMimeType = (is_string($mimetypes))?array($mimetypes):$mimetypes;
        return $this;
    }

    public function setAuthorizedExt($exts) {
        $this->_authorizedExt = (is_string($exts))?array($exts):$exts;
        return $this;
    }
}