library/Zend/Validate/File/Size.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category  Zend
  16  * @package   Zend_Validate
  17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license   http://framework.zend.com/license/new-bsd     New BSD License
  19  * @version   $Id$
  20  */
  21
  22 /**
  23  * @see Zend_Validate_Abstract
  24  */
  25 require_once 'Zend/Validate/Abstract.php';
  26
  27 /**
  28  * Validator for the maximum size of a file up to a max of 2GB
  29  *
  30  * @category  Zend
  31  * @package   Zend_Validate
  32  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  33  * @license   http://framework.zend.com/license/new-bsd     New BSD License
  34  */
  35 class Zend_Validate_File_Size extends Zend_Validate_Abstract
  36 {
  37     /**#@+
  38      * @const string Error constants
  39      */
  40     const TOO_BIG   = 'fileSizeTooBig';
  41     const TOO_SMALL = 'fileSizeTooSmall';
  42     const NOT_FOUND = 'fileSizeNotFound';
  43     /**#@-*/
  44
  45     /**
  46      * @var array Error message templates
  47      */
  48     protected $_messageTemplates = array(
  49         self::TOO_BIG   => "Maximum allowed size for file '%value%' is '%max%' but '%size%' detected",
  50         self::TOO_SMALL => "Minimum expected size for file '%value%' is '%min%' but '%size%' detected",
  51         self::NOT_FOUND => "File '%value%' could not be found",
  52     );
  53
  54     /**
  55      * @var array Error message template variables
  56      */
  57     protected $_messageVariables = array(
  58         'min'  => '_min',
  59         'max'  => '_max',
  60         'size' => '_size',
  61     );
  62
  63     /**
  64      * Minimum filesize
  65      * @var integer
  66      */
  67     protected $_min;
  68
  69     /**
  70      * Maximum filesize
  71      *
  72      * If null, there is no maximum filesize
  73      *
  74      * @var integer|null
  75      */
  76     protected $_max;
  77
  78     /**
  79      * Detected size
  80      *
  81      * @var integer
  82      */
  83     protected $_size;
  84
  85     /**
  86      * Use bytestring ?
  87      *
  88      * @var boolean
  89      */
  90     protected $_useByteString = true;
  91
  92     /**
  93      * Sets validator options
  94      *
  95      * If $options is a integer, it will be used as maximum filesize
  96      * As Array is accepts the following keys:
  97      * 'min': Minimum filesize
  98      * 'max': Maximum filesize
  99      * 'bytestring': Use bytestring or real size for messages
 100      *
 101      * @param  integer|array $options Options for the adapter
 102      */
 103     public function __construct($options)
 104     {
 105         if ($options instanceof Zend_Config) {
 106             $options = $options->toArray();
 107         } elseif (is_string($options) || is_numeric($options)) {
 108             $options = array('max' => $options);
 109         } elseif (!is_array($options)) {
 110             require_once 'Zend/Validate/Exception.php';
 111             throw new Zend_Validate_Exception ('Invalid options to validator provided');
 112         }
 113
 114         if (1 < func_num_args()) {
 115             $argv = func_get_args();
 116             array_shift($argv);
 117             $options['max'] = array_shift($argv);
 118             if (!empty($argv)) {
 119                 $options['bytestring'] = array_shift($argv);
 120             }
 121         }
 122
 123         if (isset($options['bytestring'])) {
 124             $this->setUseByteString($options['bytestring']);
 125         }
 126
 127         if (isset($options['min'])) {
 128             $this->setMin($options['min']);
 129         }
 130
 131         if (isset($options['max'])) {
 132             $this->setMax($options['max']);
 133         }
 134     }
 135
 136     /**
 137      * Returns the minimum filesize
 138      *
 139      * @param  boolean $byteString Use bytestring ?
 140      * @return integer
 141      */
 142     public function setUseByteString($byteString = true)
 143     {
 144         $this->_useByteString = (bool) $byteString;
 145         return $this;
 146     }
 147
 148     /**
 149      * Will bytestring be used?
 150      *
 151      * @return boolean
 152      */
 153     public function useByteString()
 154     {
 155         return $this->_useByteString;
 156     }
 157
 158     /**
 159      * Returns the minimum filesize
 160      *
 161      * @param  bool $raw Whether or not to force return of the raw value (defaults off)
 162      * @return integer|string
 163      */
 164     public function getMin($raw = false)
 165     {
 166         $min = $this->_min;
 167         if (!$raw && $this->useByteString()) {
 168             $min = $this->_toByteString($min);
 169         }
 170
 171         return $min;
 172     }
 173
 174     /**
 175      * Sets the minimum filesize
 176      *
 177      * @param  integer $min The minimum filesize
 178      * @throws Zend_Validate_Exception When min is greater than max
 179      * @return Zend_Validate_File_Size Provides a fluent interface
 180      */
 181     public function setMin($min)
 182     {
 183         if (!is_string($min) and !is_numeric($min)) {
 184             require_once 'Zend/Validate/Exception.php';
 185             throw new Zend_Validate_Exception ('Invalid options to validator provided');
 186         }
 187
 188         $min = (integer) $this->_fromByteString($min);
 189         $max = $this->getMax(true);
 190         if (($max !== null) && ($min > $max)) {
 191             require_once 'Zend/Validate/Exception.php';
 192             throw new Zend_Validate_Exception("The minimum must be less than or equal to the maximum filesize, but $min >"
 193                                             . " $max");
 194         }
 195
 196         $this->_min = $min;
 197         return $this;
 198     }
 199
 200     /**
 201      * Returns the maximum filesize
 202      *
 203      * @param  bool $raw Whether or not to force return of the raw value (defaults off)
 204      * @return integer|string
 205      */
 206     public function getMax($raw = false)
 207     {
 208         $max = $this->_max;
 209         if (!$raw && $this->useByteString()) {
 210             $max = $this->_toByteString($max);
 211         }
 212
 213         return $max;
 214     }
 215
 216     /**
 217      * Sets the maximum filesize
 218      *
 219      * @param  integer $max The maximum filesize
 220      * @throws Zend_Validate_Exception When max is smaller than min
 221      * @return Zend_Validate_StringLength Provides a fluent interface
 222      */
 223     public function setMax($max)
 224     {
 225         if (!is_string($max) && !is_numeric($max)) {
 226             require_once 'Zend/Validate/Exception.php';
 227             throw new Zend_Validate_Exception ('Invalid options to validator provided');
 228         }
 229
 230         $max = (integer) $this->_fromByteString($max);
 231         $min = $this->getMin(true);
 232         if (($min !== null) && ($max < $min)) {
 233             require_once 'Zend/Validate/Exception.php';
 234             throw new Zend_Validate_Exception("The maximum must be greater than or equal to the minimum filesize, but "
 235                                             . "$max < $min");
 236         }
 237
 238         $this->_max = $max;
 239         return $this;
 240     }
 241
 242     /**
 243      * Retrieve current detected file size
 244      *
 245      * @return int
 246      */
 247     protected function _getSize()
 248     {
 249         return $this->_size;
 250     }
 251
 252     /**
 253      * Set current size
 254      *
 255      * @param  int $size
 256      * @return Zend_Validate_File_Size
 257      */
 258     protected function _setSize($size)
 259     {
 260         $this->_size = $size;
 261         return $this;
 262     }
 263
 264     /**
 265      * Defined by Zend_Validate_Interface
 266      *
 267      * Returns true if and only if the filesize of $value is at least min and
 268      * not bigger than max (when max is not null).
 269      *
 270      * @param  string $value Real file to check for size
 271      * @param  array  $file  File data from Zend_File_Transfer
 272      * @return boolean
 273      */
 274     public function isValid($value, $file = null)
 275     {
 276         // Is file readable ?
 277         require_once 'Zend/Loader.php';
 278         if (!Zend_Loader::isReadable($value)) {
 279             return $this->_throw($file, self::NOT_FOUND);
 280         }
 281
 282         // limited to 4GB files
 283         $size        = sprintf("%u", @filesize($value));
 284         $this->_size = $size;
 285
 286         // Check to see if it's smaller than min size
 287         $min = $this->getMin(true);
 288         $max = $this->getMax(true);
 289         if (($min !== null) && ($size < $min)) {
 290             if ($this->useByteString()) {
 291                 $this->_min  = $this->_toByteString($min);
 292                 $this->_size = $this->_toByteString($size);
 293                 $this->_throw($file, self::TOO_SMALL);
 294                 $this->_min  = $min;
 295                 $this->_size = $size;
 296             } else {
 297                 $this->_throw($file, self::TOO_SMALL);
 298             }
 299         }
 300
 301         // Check to see if it's larger than max size
 302         if (($max !== null) && ($max < $size)) {
 303             if ($this->useByteString()) {
 304                 $this->_max  = $this->_toByteString($max);
 305                 $this->_size = $this->_toByteString($size);
 306                 $this->_throw($file, self::TOO_BIG);
 307                 $this->_max  = $max;
 308                 $this->_size = $size;
 309             } else {
 310                 $this->_throw($file, self::TOO_BIG);
 311             }
 312         }
 313
 314         if (count($this->_messages) > 0) {
 315             return false;
 316         }
 317
 318         return true;
 319     }
 320
 321     /**
 322      * Returns the formatted size
 323      *
 324      * @param  integer $size
 325      * @return string
 326      */
 327     protected function _toByteString($size)
 328     {
 329         $sizes = array('B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB');
 330         for ($i=0; $size >= 1024 && $i < 9; $i++) {
 331             $size /= 1024;
 332         }
 333
 334         return round($size, 2) . $sizes[$i];
 335     }
 336
 337     /**
 338      * Returns the unformatted size
 339      *
 340      * @param  string $size
 341      * @return integer
 342      */
 343     protected function _fromByteString($size)
 344     {
 345         if (is_numeric($size)) {
 346             return (integer) $size;
 347         }
 348
 349         $type  = trim(substr($size, -2, 1));
 350
 351         $value = substr($size, 0, -1);
 352         if (!is_numeric($value)) {
 353             $value = substr($value, 0, -1);
 354         }
 355
 356         switch (strtoupper($type)) {
 357             case 'Y':
 358                 $value *= (1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024);
 359                 break;
 360             case 'Z':
 361                 $value *= (1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024);
 362                 break;
 363             case 'E':
 364                 $value *= (1024 * 1024 * 1024 * 1024 * 1024 * 1024);
 365                 break;
 366             case 'P':
 367                 $value *= (1024 * 1024 * 1024 * 1024 * 1024);
 368                 break;
 369             case 'T':
 370                 $value *= (1024 * 1024 * 1024 * 1024);
 371                 break;
 372             case 'G':
 373                 $value *= (1024 * 1024 * 1024);
 374                 break;
 375             case 'M':
 376                 $value *= (1024 * 1024);
 377                 break;
 378             case 'K':
 379                 $value *= 1024;
 380                 break;
 381             default:
 382                 break;
 383         }
 384
 385         return $value;
 386     }
 387
 388     /**
 389      * Throws an error of the given type
 390      *
 391      * @param  string $file
 392      * @param  string $errorType
 393      * @return false
 394      */
 395     protected function _throw($file, $errorType)
 396     {
 397         if ($file !== null) {
 398             $this->_value = $file['name'];
 399         }
 400
 401         $this->_error($errorType);
 402         return false;
 403     }
 404 }