Verzeichnisstruktur phpBB-3.0.0


Veröffentlicht
12.12.2007

So funktioniert es


Auf das letzte Element klicken. Dies geht jeweils ein Schritt zurück

Auf das Icon klicken, dies öffnet das Verzeichnis. Nochmal klicken schließt das Verzeichnis.
Auf den Verzeichnisnamen klicken, dies zeigt nur das Verzeichnis mit Inhalt an

(Beispiel Datei-Icons)

Auf das Icon klicken um den Quellcode anzuzeigen

functions_upload.php

Zuletzt modifiziert: 09.10.2024, 12:50 - Dateigröße: 22.14 KiB


001  <?php
002  /**
003  *
004  * @package phpBB3
005  * @version $Id$
006  * @copyright (c) 2005 phpBB Group
007  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
008  *
009  */
010   
011  /**
012  * @ignore
013  */
014  if (!defined('IN_PHPBB'))
015  {
016      exit;
017  }
018   
019  /**
020  * Responsible for holding all file relevant information, as well as doing file-specific operations.
021  * The {@link fileupload fileupload class} can be used to upload several files, each of them being this object to operate further on.
022  * @package phpBB3
023  */
024  class filespec
025  {
026      var $filename = '';
027      var $realname = '';
028      var $uploadname = '';
029      var $mimetype = '';
030      var $extension = '';
031      var $filesize = 0;
032      var $width = 0;
033      var $height = 0;
034      var $image_info = array();
035   
036      var $destination_file = '';
037      var $destination_path = '';
038   
039      var $file_moved = false;
040      var $init_error = false;
041      var $local = false;
042   
043      var $error = array();
044   
045      var $upload = '';
046   
047      /**
048      * File Class
049      * @access private
050      */
051      function filespec($upload_ary, $upload_namespace)
052      {
053          if (!isset($upload_ary))
054          {
055              $this->init_error = true;
056              return;
057          }
058   
059          $this->filename = $upload_ary['tmp_name'];
060          $this->filesize = $upload_ary['size'];
061          $name = trim(htmlspecialchars(basename($upload_ary['name'])));
062          $this->realname = $this->uploadname = (STRIP) ? stripslashes($name) : $name;
063          $this->mimetype = $upload_ary['type'];
064   
065          // Opera adds the name to the mime type
066          $this->mimetype    = (strpos($this->mimetype, '; name') !== false) ? str_replace(strstr($this->mimetype, '; name'), '', $this->mimetype) : $this->mimetype;
067   
068          if (!$this->mimetype)
069          {
070              $this->mimetype = 'application/octetstream';
071          }
072   
073          $this->extension = strtolower($this->get_extension($this->realname));
074   
075          // Try to get real filesize from temporary folder (not always working) ;)
076          $this->filesize = (@filesize($this->filename)) ? @filesize($this->filename) : $this->filesize;
077   
078          $this->width = $this->height = 0;
079          $this->file_moved = false;
080   
081          $this->local = (isset($upload_ary['local_mode'])) ? true : false;
082          $this->upload = $upload_namespace;
083      }
084   
085      /**
086      * Cleans destination filename
087      *
088      * @param real|unique|unique_ext $mode real creates a realname, filtering some characters, lowering every character. Unique creates an unique filename
089      * @param string $prefix Prefix applied to filename
090      * @access public
091      */
092      function clean_filename($mode = 'unique', $prefix = '', $user_id = '')
093      {
094          if ($this->init_error)
095          {
096              return;
097          }
098   
099          switch ($mode)
100          {
101              case 'real':
102                  // Remove every extension from filename (to not let the mime bug being exposed)
103                  if (strpos($this->realname, '.') !== false)
104                  {
105                      $this->realname = substr($this->realname, 0, strpos($this->realname, '.'));
106                  }
107   
108                  // Replace any chars which may cause us problems with _
109                  $bad_chars = array("'", "\\", ' ', '/', ':', '*', '?', '"', '<', '>', '|');
110   
111                  $this->realname = rawurlencode(str_replace($bad_chars, '_', strtolower($this->realname)));
112                  $this->realname = preg_replace("/%(\w{2})/", '_', $this->realname);
113   
114                  $this->realname = $prefix . $this->realname . '.' . $this->extension;
115              break;
116   
117              case 'unique':
118                  $this->realname = $prefix . md5(unique_id());
119              break;
120   
121              case 'avatar':
122                  $this->extension = strtolower($this->extension);
123                  $this->realname = $prefix . $user_id . '.' . $this->extension;
124                  
125              break;
126              
127              case 'unique_ext':
128              default:
129                  $this->realname = $prefix . md5(unique_id()) . '.' . $this->extension;
130              break;
131          }
132      }
133   
134      /**
135      * Get property from file object
136      */
137      function get($property)
138      {
139          if ($this->init_error || !isset($this->$property))
140          {
141              return false;
142          }
143   
144          return $this->$property;
145      }
146   
147      /**
148      * Check if file is an image (mimetype)
149      *
150      * @return true if it is an image, false if not
151      */
152      function is_image()
153      {
154          return (strpos($this->mimetype, 'image/') !== false) ? true : false;
155      }
156   
157      /**
158      * Check if the file got correctly uploaded
159      *
160      * @return true if it is a valid upload, false if not
161      */
162      function is_uploaded()
163      {
164          if (!$this->local && !is_uploaded_file($this->filename))
165          {
166              return false;
167          }
168   
169          if ($this->local && !file_exists($this->filename))
170          {
171              return false;
172          }
173   
174          return true;
175      }
176   
177      /**
178      * Remove file
179      */
180      function remove()
181      {
182          if ($this->file_moved)
183          {
184              @unlink($this->destination_file);
185          }
186      }
187   
188      /**
189      * Get file extension
190      */
191      function get_extension($filename)
192      {
193          if (strpos($filename, '.') === false)
194          {
195              return '';
196          }
197   
198          $filename = explode('.', $filename);
199          return array_pop($filename);
200      }
201   
202      /**
203      * Get mimetype. Utilize mime_content_type if the function exist.
204      * Not used at the moment...
205      */
206      function get_mimetype($filename)
207      {
208          $mimetype = '';
209   
210          if (function_exists('mime_content_type'))
211          {
212              $mimetype = mime_content_type($filename);
213          }
214   
215          // Some browsers choke on a mimetype of application/octet-stream
216          if (!$mimetype || $mimetype == 'application/octet-stream')
217          {
218              $mimetype = 'application/octetstream';
219          }
220   
221          return $mimetype;
222      }
223   
224      /**
225      * Get filesize
226      */
227      function get_filesize($filename)
228      {
229          return @filesize($filename);
230      }
231   
232      /**
233      * Move file to destination folder
234      * The phpbb_root_path variable will be applied to the destination path
235      *
236      * @param string $destination_path Destination path, for example $config['avatar_path']
237      * @param bool $overwrite If set to true, an already existing file will be overwritten
238      * @param octal $chmod Permission mask for chmodding the file after a successful move
239      * @access public
240      */
241      function move_file($destination, $overwrite = false, $skip_image_check = false, $chmod = 0666)
242      {
243          global $user, $phpbb_root_path;
244   
245          if (sizeof($this->error))
246          {
247              return false;
248          }
249   
250          // We need to trust the admin in specifying valid upload directories and an attacker not being able to overwrite it...
251          $this->destination_path = $phpbb_root_path . $destination;
252   
253          // Check if the destination path exist...
254          if (!file_exists($this->destination_path))
255          {
256              @unlink($this->filename);
257              return false;
258          }
259   
260          $upload_mode = (@ini_get('open_basedir') || @ini_get('safe_mode')) ? 'move' : 'copy';
261          $upload_mode = ($this->local) ? 'local' : $upload_mode;
262          $this->destination_file = $this->destination_path . '/' . basename($this->realname);
263   
264          // Check if the file already exist, else there is something wrong...
265          if (file_exists($this->destination_file) && !$overwrite)
266          {
267              @unlink($this->filename);
268          }
269          else
270          {
271              if (file_exists($this->destination_file))
272              {
273                  @unlink($this->destination_file);
274              }
275   
276              switch ($upload_mode)
277              {
278                  case 'copy':
279   
280                      if (!@copy($this->filename, $this->destination_file))
281                      {
282                          if (!@move_uploaded_file($this->filename, $this->destination_file))
283                          {
284                              $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
285                              return false;
286                          }
287                      }
288   
289                      @unlink($this->filename);
290   
291                  break;
292   
293                  case 'move':
294   
295                      if (!@move_uploaded_file($this->filename, $this->destination_file))
296                      {
297                          if (!@copy($this->filename, $this->destination_file))
298                          {
299                              $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
300                              return false;
301                          }
302                      }
303   
304                      @unlink($this->filename);
305   
306                  break;
307   
308                  case 'local':
309   
310                      if (!@copy($this->filename, $this->destination_file))
311                      {
312                          $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR'], $this->destination_file);
313                          return false;
314                      }
315                      @unlink($this->filename);
316   
317                  break;
318              }
319   
320              @chmod($this->destination_file, $chmod);
321          }
322   
323          // Try to get real filesize from destination folder
324          $this->filesize = (@filesize($this->destination_file)) ? @filesize($this->destination_file) : $this->filesize;
325   
326          if ($this->is_image() && !$skip_image_check)
327          {
328              $this->width = $this->height = 0;
329   
330              if (($this->image_info = @getimagesize($this->destination_file)) !== false)
331              {
332                  $this->width = $this->image_info[0];
333                  $this->height = $this->image_info[1];
334   
335                  if (!empty($this->image_info['mime']))
336                  {
337                      $this->mimetype = $this->image_info['mime'];
338                  }
339   
340                  // Check image type
341                  $types = $this->upload->image_types();
342   
343                  if (!isset($types[$this->image_info[2]]) || !in_array($this->extension, $types[$this->image_info[2]]))
344                  {
345                      if (!isset($types[$this->image_info[2]]))
346                      {
347                          $this->error[] = sprintf($user->lang['IMAGE_FILETYPE_INVALID'], $this->image_info[2], $this->mimetype);
348                      }
349                      else
350                      {
351                          $this->error[] = sprintf($user->lang['IMAGE_FILETYPE_MISMATCH'], $types[$this->image_info[2]][0], $this->extension);
352                      }
353                  }
354   
355                  // Make sure the dimensions match a valid image
356                  if (empty($this->width) || empty($this->height))
357                  {
358                      $this->error[] = $user->lang['ATTACHED_IMAGE_NOT_IMAGE'];
359                  }
360              }
361              else
362              {
363                  $this->error[] = $user->lang['UNABLE_GET_IMAGE_SIZE'];
364              }
365          }
366   
367          $this->file_moved = true;
368          $this->additional_checks();
369          unset($this->upload);
370   
371          return true;
372      }
373   
374      /**
375      * Performing additional checks
376      */
377      function additional_checks()
378      {
379          global $user;
380   
381          if (!$this->file_moved)
382          {
383              return false;
384          }
385   
386          // Filesize is too big or it's 0 if it was larger than the maxsize in the upload form
387          if ($this->upload->max_filesize && ($this->get('filesize') > $this->upload->max_filesize || $this->filesize == 0))
388          {
389              $size_lang = ($this->upload->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->upload->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
390              $max_filesize = ($this->upload->max_filesize >= 1048576) ? round($this->upload->max_filesize / 1048576 * 100) / 100 : (($this->upload->max_filesize >= 1024) ? round($this->upload->max_filesize / 1024 * 100) / 100 : $this->upload->max_filesize);
391      
392              $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
393   
394              return false;
395          }
396   
397          if (!$this->upload->valid_dimensions($this))
398          {
399              $this->error[] = sprintf($user->lang[$this->upload->error_prefix . 'WRONG_SIZE'], $this->upload->min_width, $this->upload->min_height, $this->upload->max_width, $this->upload->max_height, $this->width, $this->height);
400   
401              return false;
402          }
403   
404          return true;
405      }
406  }
407   
408  /**
409  * Class for assigning error messages before a real filespec class can be assigned
410  *
411  * @package phpBB3
412  */
413  class fileerror extends filespec
414  {
415      function fileerror($error_msg)
416      {
417          $this->error[] = $error_msg;
418      }
419  }
420   
421  /**
422  * File upload class
423  * Init class (all parameters optional and able to be set/overwritten separately) - scope is global and valid for all uploads
424  *
425  * @package phpBB3
426  */
427  class fileupload
428  {
429      var $allowed_extensions = array();
430      var $max_filesize = 0;
431      var $min_width = 0;
432      var $min_height = 0;
433      var $max_width = 0;
434      var $max_height = 0;
435      var $error_prefix = '';
436   
437      /**
438      * Init file upload class.
439      *
440      * @param string $error_prefix Used error messages will get prefixed by this string
441      * @param array $allowed_extensions Array of allowed extensions, for example array('jpg', 'jpeg', 'gif', 'png')
442      * @param int $max_filesize Maximum filesize
443      * @param int $min_width Minimum image width (only checked for images)
444      * @param int $min_height Minimum image height (only checked for images)
445      * @param int $max_width Maximum image width (only checked for images)
446      * @param int $max_height Maximum image height (only checked for images)
447      *
448      */
449      function fileupload($error_prefix = '', $allowed_extensions = false, $max_filesize = false, $min_width = false, $min_height = false, $max_width = false, $max_height = false)
450      {
451          $this->set_allowed_extensions($allowed_extensions);
452          $this->set_max_filesize($max_filesize);
453          $this->set_allowed_dimensions($min_width, $min_height, $max_width, $max_height);
454          $this->set_error_prefix($error_prefix);
455      }
456   
457      /**
458      * Reset vars
459      */
460      function reset_vars()
461      {
462          $this->max_filesize = 0;
463          $this->min_width = $this->min_height = $this->max_width = $this->max_height = 0;
464          $this->error_prefix = '';
465          $this->allowed_extensions = array();
466      }
467   
468      /**
469      * Set allowed extensions
470      */
471      function set_allowed_extensions($allowed_extensions)
472      {
473          if ($allowed_extensions !== false && is_array($allowed_extensions))
474          {
475              $this->allowed_extensions = $allowed_extensions;
476          }
477      }
478   
479      /**
480      * Set allowed dimensions
481      */
482      function set_allowed_dimensions($min_width, $min_height, $max_width, $max_height)
483      {
484          $this->min_width = (int) $min_width;
485          $this->min_height = (int) $min_height;
486          $this->max_width = (int) $max_width;
487          $this->max_height = (int) $max_height;
488      }
489   
490      /**
491      * Set maximum allowed filesize
492      */
493      function set_max_filesize($max_filesize)
494      {
495          if ($max_filesize !== false && (int) $max_filesize)
496          {
497              $this->max_filesize = (int) $max_filesize;
498          }
499      }
500   
501      /**
502      * Set error prefix
503      */
504      function set_error_prefix($error_prefix)
505      {
506          $this->error_prefix = $error_prefix;
507      }
508   
509      /**
510      * Form upload method
511      * Upload file from users harddisk
512      *
513      * @param string $form_name Form name assigned to the file input field (if it is an array, the key has to be specified)
514      * @return object $file Object "filespec" is returned, all further operations can be done with this object
515      * @access public
516      */
517      function form_upload($form_name)
518      {
519          global $user;
520   
521          unset($_FILES[$form_name]['local_mode']);
522          $file = new filespec($_FILES[$form_name], $this);
523   
524          if ($file->init_error)
525          {
526              $file->error[] = '';
527              return $file;
528          }
529   
530          // Error array filled?
531          if (isset($_FILES[$form_name]['error']))
532          {
533              $error = $this->assign_internal_error($_FILES[$form_name]['error']);
534   
535              if ($error !== false)
536              {
537                  $file->error[] = $error;
538                  return $file;
539              }
540          }
541   
542          // Check if empty file got uploaded (not catched by is_uploaded_file)
543          if (isset($_FILES[$form_name]['size']) && $_FILES[$form_name]['size'] == 0)
544          {
545              $file->error[] = $user->lang[$this->error_prefix . 'EMPTY_FILEUPLOAD'];
546              return $file;
547          }
548   
549          // PHP Upload filesize exceeded
550          if ($file->get('filename') == 'none')
551          {
552              $file->error[] = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
553              return $file;
554          }
555   
556          // Not correctly uploaded
557          if (!$file->is_uploaded())
558          {
559              $file->error[] = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
560              return $file;
561          }
562   
563          $this->common_checks($file);
564   
565          return $file;
566      }
567   
568      /**
569      * Move file from another location to phpBB
570      */
571      function local_upload($source_file, $filedata = false)
572      {
573          global $user;
574   
575          $form_name = 'local';
576   
577          $_FILES[$form_name]['local_mode'] = true;
578          $_FILES[$form_name]['tmp_name'] = $source_file;
579   
580          if ($filedata === false)
581          {
582              $_FILES[$form_name]['name'] = basename($source_file);
583              $_FILES[$form_name]['size'] = 0;
584              $mimetype = '';
585   
586              if (function_exists('mime_content_type'))
587              {
588                  $mimetype = mime_content_type($source_file);
589              }
590   
591              // Some browsers choke on a mimetype of application/octet-stream
592              if (!$mimetype || $mimetype == 'application/octet-stream')
593              {
594                  $mimetype = 'application/octetstream';
595              }
596   
597              $_FILES[$form_name]['type'] = $mimetype;
598          }
599          else
600          {
601              $_FILES[$form_name]['name'] = $filedata['realname'];
602              $_FILES[$form_name]['size'] = $filedata['size'];
603              $_FILES[$form_name]['type'] = $filedata['type'];
604          }
605   
606          $file = new filespec($_FILES[$form_name], $this);
607   
608          if ($file->init_error)
609          {
610              $file->error[] = '';
611              return $file;
612          }
613   
614          if (isset($_FILES[$form_name]['error']))
615          {
616              $error = $this->assign_internal_error($_FILES[$form_name]['error']);
617   
618              if ($error !== false)
619              {
620                  $file->error[] = $error;
621                  return $file;
622              }
623          }
624   
625          // PHP Upload filesize exceeded
626          if ($file->get('filename') == 'none')
627          {
628              $file->error[] = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
629              return $file;
630          }
631   
632          // Not correctly uploaded
633          if (!$file->is_uploaded())
634          {
635              $file->error[] = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
636              return $file;
637          }
638   
639          $this->common_checks($file);
640   
641          return $file;
642      }
643   
644      /**
645      * Remote upload method
646      * Uploads file from given url
647      *
648      * @param string $upload_url URL pointing to file to upload, for example http://www.foobar.com/example.gif
649      * @return object $file Object "filespec" is returned, all further operations can be done with this object
650      * @access public
651      */
652      function remote_upload($upload_url)
653      {
654          global $user, $phpbb_root_path;
655   
656          $upload_ary = array();
657          $upload_ary['local_mode'] = true;
658   
659          if (!preg_match('#^(https?://).*?\.(' . implode('|', $this->allowed_extensions) . ')$#i', $upload_url, $match))
660          {
661              $file = new fileerror($user->lang[$this->error_prefix . 'URL_INVALID']);
662              return $file;
663          }
664   
665          if (empty($match[2]))
666          {
667              $file = new fileerror($user->lang[$this->error_prefix . 'URL_INVALID']);
668              return $file;
669          }
670   
671          $url = parse_url($upload_url);
672   
673          $host = $url['host'];
674          $path = $url['path'];
675          $port = (!empty($url['port'])) ? (int) $url['port'] : 80;
676   
677          $upload_ary['type'] = 'application/octet-stream';
678   
679          $url['path'] = explode('.', $url['path']);
680          $ext = array_pop($url['path']);
681   
682          $url['path'] = implode('', $url['path']);
683          $upload_ary['name'] = basename($url['path']) . (($ext) ? '.' . $ext : '');
684          $filename = $url['path'];
685          $filesize = 0;
686   
687          $errno = 0;
688          $errstr = '';
689   
690          if (!($fsock = @fsockopen($host, $port, $errno, $errstr)))
691          {
692              $file = new fileerror($user->lang[$this->error_prefix . 'NOT_UPLOADED']);
693              return $file;
694          }
695   
696          // Make sure $path not beginning with /
697          if (strpos($path, '/') === 0)
698          {
699              $path = substr($path, 1);
700          }
701   
702          fputs($fsock, 'GET /' . $path . " HTTP/1.1\r\n");
703          fputs($fsock, "HOST: " . $host . "\r\n");
704          fputs($fsock, "Connection: close\r\n\r\n");
705   
706          $get_info = false;
707          $data = '';
708          while (!@feof($fsock))
709          {
710              if ($get_info)
711              {
712                  $data .= @fread($fsock, 1024);
713              }
714              else
715              {
716                  $line = @fgets($fsock, 1024);
717   
718                  if ($line == "\r\n")
719                  {
720                      $get_info = true;
721                  }
722                  else
723                  {
724                      if (stripos($line, 'content-type: ') !== false)
725                      {
726                          $upload_ary['type'] = rtrim(str_replace('content-type: ', '', strtolower($line)));
727                      }
728                      else if (stripos($line, '404 not found') !== false)
729                      {
730                          $file = new fileerror($user->lang[$this->error_prefix . 'URL_NOT_FOUND']);
731                          return $file;
732                      }
733                  }
734              }
735          }
736          @fclose($fsock);
737   
738          if (empty($data))
739          {
740              $file = new fileerror($user->lang[$this->error_prefix . 'EMPTY_REMOTE_DATA']);
741              return $file;
742          }
743   
744          $tmp_path = (!@ini_get('safe_mode')) ? false : $phpbb_root_path . 'cache';
745          $filename = tempnam($tmp_path, unique_id() . '-');
746   
747          if (!($fp = @fopen($filename, 'wb')))
748          {
749              $file = new fileerror($user->lang[$this->error_prefix . 'NOT_UPLOADED']);
750              return $file;
751          }
752   
753          $upload_ary['size'] = fwrite($fp, $data);
754          fclose($fp);
755          unset($data);
756   
757          $upload_ary['tmp_name'] = $filename;
758   
759          $file = new filespec($upload_ary, $this);
760          $this->common_checks($file);
761   
762          return $file;
763      }
764   
765      /**
766      * Assign internal error
767      * @access private
768      */
769      function assign_internal_error($errorcode)
770      {
771          global $user;
772   
773          switch ($errorcode)
774          {
775              case 1:
776                  $error = (@ini_get('upload_max_filesize') == '') ? $user->lang[$this->error_prefix . 'PHP_SIZE_NA'] : sprintf($user->lang[$this->error_prefix . 'PHP_SIZE_OVERRUN'], @ini_get('upload_max_filesize'));
777              break;
778   
779              case 2:
780                  $size_lang = ($this->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
781                  $max_filesize = ($this->max_filesize >= 1048576) ? round($this->max_filesize / 1048576 * 100) / 100 : (($this->max_filesize >= 1024) ? round($this->max_filesize / 1024 * 100) / 100 : $this->max_filesize);
782   
783                  $error = sprintf($user->lang[$this->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
784              break;
785   
786              case 3:
787                  $error = $user->lang[$this->error_prefix . 'PARTIAL_UPLOAD'];
788              break;
789   
790              case 4:
791                  $error = $user->lang[$this->error_prefix . 'NOT_UPLOADED'];
792              break;
793   
794              case 6:
795                  $error = 'Temporary folder could not be found. Please check your PHP installation.';
796              break;
797   
798              default:
799                  $error = false;
800              break;
801          }
802   
803          return $error;
804      }
805   
806      /**
807      * Perform common checks
808      */
809      function common_checks(&$file)
810      {
811          global $user;
812   
813          // Filesize is too big or it's 0 if it was larger than the maxsize in the upload form
814          if ($this->max_filesize && ($file->get('filesize') > $this->max_filesize || $file->get('filesize') == 0))
815          {
816              $size_lang = ($this->max_filesize >= 1048576) ? $user->lang['MB'] : (($this->max_filesize >= 1024) ? $user->lang['KB'] : $user->lang['BYTES'] );
817              $max_filesize = ($this->max_filesize >= 1048576) ? round($this->max_filesize / 1048576 * 100) / 100 : (($this->max_filesize >= 1024) ? round($this->max_filesize / 1024 * 100) / 100 : $this->max_filesize);
818   
819              $file->error[] = sprintf($user->lang[$this->error_prefix . 'WRONG_FILESIZE'], $max_filesize, $size_lang);
820          }
821   
822          // check Filename
823          if (preg_match("#[\\/:*?\"<>|]#i", $file->get('realname')))
824          {
825              $file->error[] = sprintf($user->lang[$this->error_prefix . 'INVALID_FILENAME'], $file->get('realname'));
826          }
827   
828          // Invalid Extension
829          if (!$this->valid_extension($file))
830          {
831              $file->error[] = sprintf($user->lang[$this->error_prefix . 'DISALLOWED_EXTENSION'], $file->get('extension'));
832          }
833      }
834   
835      /**
836      * Check for allowed extension
837      */
838      function valid_extension(&$file)
839      {
840          return (in_array($file->get('extension'), $this->allowed_extensions)) ? true : false;
841      }
842   
843      /**
844      * Check for allowed dimension
845      */
846      function valid_dimensions(&$file)
847      {
848          if (!$this->max_width && !$this->max_height && !$this->min_width && !$this->min_height)
849          {
850              return true;
851          }
852   
853          if (($file->get('width') > $this->max_width && $this->max_width) ||
854              ($file->get('height') > $this->max_height && $this->max_height) ||
855              ($file->get('width') < $this->min_width && $this->min_width) ||
856              ($file->get('height') < $this->min_height && $this->min_height))
857          {
858              return false;
859          }
860   
861          return true;
862      }
863   
864      /**
865      * Check if form upload is valid
866      */
867      function is_valid($form_name)
868      {
869          return (isset($_FILES[$form_name]) && $_FILES[$form_name]['name'] != 'none') ? true : false;
870      }
871   
872      /**
873      * Return image type/extension mapping
874      */
875      function image_types()
876      {
877          return array(
878              1 => array('gif'),
879              2 => array('jpg', 'jpeg'),
880              3 => array('png'),
881              4 => array('swf'),
882              5 => array('psd'),
883              6 => array('bmp'),
884              7 => array('tif', 'tiff'),
885              8 => array('tif', 'tiff'),
886              9 => array('jpg', 'jpeg'),
887              10 => array('jpg', 'jpeg'),
888              11 => array('jpg', 'jpeg'),
889              12 => array('jpg', 'jpeg'),
890              13 => array('swc'),
891              14 => array('iff'),
892              15 => array('wbmp'),
893              16 => array('xbm'),
894          );
895      }
896  }
897   
898  ?>