<form method="POST">
    <h3>Editing: elFinderVolumeDriver.class.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * Base class for elFinder volume.
 * Provide 2 layers:
 *  1. Public API (commands)
 *  2. abstract fs API
 * All abstract methods begin with &quot;_&quot;
 *
 * @author Dmitry (dio) Levashov
 * @author Troex Nevelin
 * @author Alexey Sukhotin
 * @method netmountPrepare(array $options)
 * @method postNetmount(array $options)
 */
abstract class elFinderVolumeDriver
{

    /**
     * Net mount key
     *
     * @var string
     **/
    public $netMountKey = '';

    /**
     * Request args
     * $_POST or $_GET values
     *
     * @var array
     */
    protected $ARGS = array();

    /**
     * Driver id
     * Must be started from letter and contains [a-z0-9]
     * Used as part of volume id
     *
     * @var string
     **/
    protected $driverId = 'a';

    /**
     * Volume id - used as prefix for files hashes
     *
     * @var string
     **/
    protected $id = '';

    /**
     * Flag - volume &quot;mounted&quot; and available
     *
     * @var bool
     **/
    protected $mounted = false;

    /**
     * Root directory path
     *
     * @var string
     **/
    protected $root = '';

    /**
     * Root basename | alias
     *
     * @var string
     **/
    protected $rootName = '';

    /**
     * Default directory to open
     *
     * @var string
     **/
    protected $startPath = '';

    /**
     * Base URL
     *
     * @var string
     **/
    protected $URL = '';

    /**
     * Path to temporary directory
     *
     * @var string
     */
    protected $tmp;

    /**
     * A file save destination path when a temporary content URL is required
     * on a network volume or the like
     * If not specified, it tries to use &quot;Connector Path/../files/.tmb&quot;.
     *
     * @var string
     */
    protected $tmpLinkPath = '';

    /**
     * A file save destination URL when a temporary content URL is required
     * on a network volume or the like
     * If not specified, it tries to use &quot;Connector URL/../files/.tmb&quot;.
     *
     * @var string
     */
    protected $tmpLinkUrl = '';

    /**
     * Thumbnails dir path
     *
     * @var string
     **/
    protected $tmbPath = '';

    /**
     * Is thumbnails dir writable
     *
     * @var bool
     **/
    protected $tmbPathWritable = false;

    /**
     * Thumbnails base URL
     *
     * @var string
     **/
    protected $tmbURL = '';

    /**
     * Thumbnails size in px
     *
     * @var int
     **/
    protected $tmbSize = 48;

    /**
     * Image manipulation lib name
     * auto|imagick|gd|convert
     *
     * @var string
     **/
    protected $imgLib = 'auto';

    /**
     * Video to Image converter
     *
     * @var array
     */
    protected $imgConverter = array();

    /**
     * Library to crypt files name
     *
     * @var string
     **/
    protected $cryptLib = '';

    /**
     * Archivers config
     *
     * @var array
     **/
    protected $archivers = array(
        'create' =&gt; array(),
        'extract' =&gt; array()
    );

    /**
     * Static var of $this-&gt;options['maxArcFilesSize']
     * 
     * @var int|string
     */
    protected static $maxArcFilesSize;

    /**
     * Server character encoding
     *
     * @var string or null
     **/
    protected $encoding = null;

    /**
     * How many subdirs levels return for tree
     *
     * @var int
     **/
    protected $treeDeep = 1;

    /**
     * Errors from last failed action
     *
     * @var array
     **/
    protected $error = array();

    /**
     * Today 24:00 timestamp
     *
     * @var int
     **/
    protected $today = 0;

    /**
     * Yesterday 24:00 timestamp
     *
     * @var int
     **/
    protected $yesterday = 0;

    /**
     * Force make dirctory on extract
     *
     * @var int
     **/
    protected $extractToNewdir = 'auto';

    /**
     * Object configuration
     *
     * @var array
     **/
    protected $options = array(
        // Driver ID (Prefix of volume ID), Normally, the value specified for each volume driver is used.
        'driverId' =&gt; '',
        // Id (Suffix of volume ID), Normally, the number incremented according to the specified number of volumes is used.
        'id' =&gt; '',
        // revision id of root directory that uses for caching control of root stat
        'rootRev' =&gt; '',
        // driver type it uses volume root's CSS class name. e.g. 'group' -&gt; Adds 'elfinder-group' to CSS class name.
        'type' =&gt; '',
        // root directory path
        'path' =&gt; '',
        // Folder hash value on elFinder to be the parent of this volume
        'phash' =&gt; '',
        // Folder hash value on elFinder to trash bin of this volume, it require 'copyJoin' to true
        'trashHash' =&gt; '',
        // open this path on initial request instead of root path
        'startPath' =&gt; '',
        // how many subdirs levels return per request
        'treeDeep' =&gt; 1,
        // root url, not set to URL via the connector. If you want to hide the file URL, do not set this value. (replacement for old &quot;fileURL&quot; option)
        'URL' =&gt; '',
        // enable onetime URL to a file - (true, false, 'auto' (true if a temporary directory is available) or callable (A function that return onetime URL))
        'onetimeUrl' =&gt; 'auto',
        // directory link url to own manager url with folder hash (`true`, `false`, `'hide'`(No show) or default `'auto'`: URL is empty then `true` else `false`)
        'dirUrlOwn' =&gt; 'auto',
        // directory separator. required by client to show paths correctly
        'separator' =&gt; DIRECTORY_SEPARATOR,
        // Use '/' as directory separator when the path hash encode/decode on the Windows server too
        'winHashFix' =&gt; false,
        // Server character encoding (default is '': UTF-8)
        'encoding' =&gt; '',
        // for convert character encoding (default is '': Not change locale)
        'locale' =&gt; '',
        // URL of volume icon image
        'icon' =&gt; '',
        // CSS Class of volume root in tree
        'rootCssClass' =&gt; '',
        // Items to disable session caching
        'noSessionCache' =&gt; array(),
        // enable i18n folder name that convert name to elFinderInstance.messages['folder_'+name]
        'i18nFolderName' =&gt; false,
        // Search timeout (sec)
        'searchTimeout' =&gt; 30,
        // Search exclusion directory regex pattern (require demiliter e.g. '#/path/to/exclude_directory#i')
        'searchExDirReg' =&gt; '',
        // library to crypt/uncrypt files names (not implemented)
        'cryptLib' =&gt; '',
        // how to detect files mimetypes. (auto/internal/finfo/mime_content_type)
        'mimeDetect' =&gt; 'auto',
        // mime.types file path (for mimeDetect==internal)
        'mimefile' =&gt; '',
        // Static extension/MIME of general server side scripts to security issues
        'staticMineMap' =&gt; array(
            'php:*' =&gt; 'text/x-php',
            'pht:*' =&gt; 'text/x-php',
            'php3:*' =&gt; 'text/x-php',
            'php4:*' =&gt; 'text/x-php',
            'php5:*' =&gt; 'text/x-php',
            'php7:*' =&gt; 'text/x-php',
            'phtml:*' =&gt; 'text/x-php',
            'phar:*' =&gt; 'text/x-php',
            'cgi:*' =&gt; 'text/x-httpd-cgi',
            'pl:*' =&gt; 'text/x-perl',
            'asp:*' =&gt; 'text/x-asap',
            'aspx:*' =&gt; 'text/x-asap',
            'py:*' =&gt; 'text/x-python',
            'rb:*' =&gt; 'text/x-ruby',
            'jsp:*' =&gt; 'text/x-jsp'
        ),
        // mime type normalize map : Array '[ext]:[detected mime type]' =&gt; '[normalized mime]'
        'mimeMap' =&gt; array(
            'md:application/x-genesis-rom' =&gt; 'text/x-markdown',
            'md:text/plain' =&gt; 'text/x-markdown',
            'markdown:text/plain' =&gt; 'text/x-markdown',
            'css:text/x-asm' =&gt; 'text/css',
            'css:text/plain' =&gt; 'text/css',
            'csv:text/plain' =&gt; 'text/csv',
            'java:text/x-c' =&gt; 'text/x-java-source',
            'json:text/plain' =&gt; 'application/json',
            'sql:text/plain' =&gt; 'text/x-sql',
            'rtf:text/rtf' =&gt; 'application/rtf',
            'rtfd:text/rtfd' =&gt; 'application/rtfd',
            'ico:image/vnd.microsoft.icon' =&gt; 'image/x-icon',
            'svg:text/plain' =&gt; 'image/svg+xml',
            'pxd:application/octet-stream' =&gt; 'image/x-pixlr-data',
            'dng:image/tiff' =&gt; 'image/x-adobe-dng',
            'sketch:application/zip' =&gt; 'image/x-sketch',
            'sketch:application/octet-stream' =&gt; 'image/x-sketch',
            'xcf:application/octet-stream' =&gt; 'image/x-xcf',
            'amr:application/octet-stream' =&gt; 'audio/amr',
            'm4a:video/mp4' =&gt; 'audio/mp4',
            'oga:application/ogg' =&gt; 'audio/ogg',
            'ogv:application/ogg' =&gt; 'video/ogg',
            'zip:application/x-zip' =&gt; 'application/zip',
            'm3u8:text/plain' =&gt; 'application/x-mpegURL',
            'mpd:text/plain' =&gt; 'application/dash+xml',
            'mpd:application/xml' =&gt; 'application/dash+xml',
            '*:application/x-dosexec' =&gt; 'application/x-executable',
            'doc:application/vnd.ms-office' =&gt; 'application/msword',
            'xls:application/vnd.ms-office' =&gt; 'application/vnd.ms-excel',
            'ppt:application/vnd.ms-office' =&gt; 'application/vnd.ms-powerpoint',
            'yml:text/plain' =&gt; 'text/x-yaml',
            'ai:application/pdf' =&gt; 'application/postscript',
            'cgm:text/plain' =&gt; 'image/cgm',
            'dxf:text/plain' =&gt; 'image/vnd.dxf',
            'dds:application/octet-stream' =&gt; 'image/vnd-ms.dds',
            'hpgl:text/plain' =&gt; 'application/vnd.hp-hpgl',
            'igs:text/plain' =&gt; 'model/iges',
            'iges:text/plain' =&gt; 'model/iges',
            'plt:application/octet-stream' =&gt; 'application/plt',
            'plt:text/plain' =&gt; 'application/plt',
            'sat:text/plain' =&gt; 'application/sat',
            'step:text/plain' =&gt; 'application/step',
            'stp:text/plain' =&gt; 'application/step'
        ),
        // An option to add MimeMap to the `mimeMap` option
        // Array '[ext]:[detected mime type]' =&gt; '[normalized mime]'
        'additionalMimeMap' =&gt; array(),
        // MIME-Type of filetype detected as unknown
        'mimeTypeUnknown' =&gt; 'application/octet-stream',
        // MIME regex of send HTTP header &quot;Content-Disposition: inline&quot; or allow preview in quicklook
        // '.' is allow inline of all of MIME types
        // '$^' is not allow inline of all of MIME types
        'dispInlineRegex' =&gt; '^(?:(?:video|audio)|image/(?!.+\+xml)|application/(?:ogg|x-mpegURL|dash\+xml)|(?:text/plain|application/pdf)$)',
        // temporary content URL's base path
        'tmpLinkPath' =&gt; '',
        // temporary content URL's base URL
        'tmpLinkUrl' =&gt; '',
        // directory for thumbnails
        'tmbPath' =&gt; '.tmb',
        // mode to create thumbnails dir
        'tmbPathMode' =&gt; 0777,
        // thumbnails dir URL. Set it if store thumbnails outside root directory
        'tmbURL' =&gt; '',
        // thumbnails size (px)
        'tmbSize' =&gt; 48,
        // thumbnails crop (true - crop, false - scale image to fit thumbnail size)
        'tmbCrop' =&gt; true,
        // thumbnail URL require custom data as the GET query
        'tmbReqCustomData' =&gt; false,
        // thumbnails background color (hex #rrggbb or 'transparent')
        'tmbBgColor' =&gt; 'transparent',
        // image rotate fallback background color (hex #rrggbb)
        'bgColorFb' =&gt; '#ffffff',
        // image manipulations library (imagick|gd|convert|auto|none, none - Does not check the image library at all.)
        'imgLib' =&gt; 'auto',
        // Fallback self image to thumbnail (nothing imgLib)
        'tmbFbSelf' =&gt; true,
        // Video to Image converters ['TYPE or MIME' =&gt; ['func' =&gt; function($file){ /* Converts $file to Image */ return true; }, 'maxlen' =&gt; (int)TransferLength]]
        'imgConverter' =&gt; array(),
        // Max length of transfer to image converter
        'tmbVideoConvLen' =&gt; 10000000,
        // Captre point seccond
        'tmbVideoConvSec' =&gt; 6,
        // Life time (hour) for thumbnail garbage collection (&quot;0&quot; means no GC)
        'tmbGcMaxlifeHour' =&gt; 0,
        // Percentage of garbage collection executed for thumbnail creation command (&quot;1&quot; means &quot;1%&quot;)
        'tmbGcPercentage' =&gt; 1,
        // Resource path of fallback icon images defailt: php/resouces
        'resourcePath' =&gt; '',
        // Jpeg image saveing quality
        'jpgQuality' =&gt; 100,
        // Save as progressive JPEG on image editing
        'jpgProgressive' =&gt; true,
        // enable to get substitute image with command `dim`
        'substituteImg' =&gt; true,
        // on paste file -  if true - old file will be replaced with new one, if false new file get name - original_name-number.ext
        'copyOverwrite' =&gt; true,
        // if true - join new and old directories content on paste
        'copyJoin' =&gt; true,
        // on upload -  if true - old file will be replaced with new one, if false new file get name - original_name-number.ext
        'uploadOverwrite' =&gt; true,
        // mimetypes allowed to upload
        'uploadAllow' =&gt; array(),
        // mimetypes not allowed to upload
        'uploadDeny' =&gt; array(),
        // order to process uploadAllow and uploadDeny options
        'uploadOrder' =&gt; array('deny', 'allow'),
        // maximum upload file size. NOTE - this is size for every uploaded files
        'uploadMaxSize' =&gt; 0,
        // Maximum number of folders that can be created at one time. (0: unlimited)
        'uploadMaxMkdirs' =&gt; 0,
        // maximum number of chunked upload connection. `-1` to disable chunked upload
        'uploadMaxConn' =&gt; 3,
        // maximum get file size. NOTE - Maximum value is 50% of PHP memory_limit
        'getMaxSize' =&gt; 0,
        // files dates format
        'dateFormat' =&gt; 'j M Y H:i',
        // files time format
        'timeFormat' =&gt; 'H:i',
        // if true - every folder will be check for children folders, -1 - every folder will be check asynchronously, false -  all folders will be marked as having subfolders
        'checkSubfolders' =&gt; true, // true, false or -1
        // allow to copy from this volume to other ones?
        'copyFrom' =&gt; true,
        // allow to copy from other volumes to this one?
        'copyTo' =&gt; true,
        // cmd duplicate suffix format e.g. '_%s_' to without spaces
        'duplicateSuffix' =&gt; ' %s ',
        // unique name numbar format e.g. '(%d)' to (1), (2)...
        'uniqueNumFormat' =&gt; '%d',
        // list of commands disabled on this root
        'disabled' =&gt; array(),
        // enable file owner, group &amp; mode info, `false` to inactivate &quot;chmod&quot; command.
        'statOwner' =&gt; false,
        // allow exec chmod of read-only files
        'allowChmodReadOnly' =&gt; false,
        // regexp or function name to validate new file name
        'acceptedName' =&gt; '/^[^\.].*/', // Notice: overwritten it in some volume drivers contractor
        // regexp or function name to validate new directory name
        'acceptedDirname' =&gt; '', // used `acceptedName` if empty value
        // function/class method to control files permissions
        'accessControl' =&gt; null,
        // some data required by access control
        'accessControlData' =&gt; null,
        // root stat that return without asking the system when mounted and not the current volume. Query to the system with false. array|false
        'rapidRootStat' =&gt; array(
            'read' =&gt; true,
            'write' =&gt; true,
            'locked' =&gt; false,
            'hidden' =&gt; false,
            'size' =&gt; 0,  // Unknown
            'ts' =&gt; 0,    // Unknown
            'dirs' =&gt; -1, // Check on demand for subdirectories
            'mime' =&gt; 'directory'
        ),
        // default permissions.
        'defaults' =&gt; array(
            'read' =&gt; true,
            'write' =&gt; true,
            'locked' =&gt; false,
            'hidden' =&gt; false
        ),
        // files attributes
        'attributes' =&gt; array(),
        // max allowed archive files size (0 - no limit)
        'maxArcFilesSize' =&gt; '2G',
        // Allowed archive's mimetypes to create. Leave empty for all available types.
        'archiveMimes' =&gt; array(),
        // Manual config for archivers. See example below. Leave empty for auto detect
        'archivers' =&gt; array(),
        // Use Archive function for remote volume
        'useRemoteArchive' =&gt; false,
        // plugin settings
        'plugin' =&gt; array(),
        // Is support parent directory time stamp update on add|remove|rename item
        // Default `null` is auto detection that is LocalFileSystem, FTP or Dropbox are `true`
        'syncChkAsTs' =&gt; null,
        // Long pooling sync checker function for syncChkAsTs is true
        // Calls with args (TARGET DIRCTORY PATH, STAND-BY(sec), OLD TIMESTAMP, VOLUME DRIVER INSTANCE, ELFINDER INSTANCE)
        // This function must return the following values. Changed: New Timestamp or Same: Old Timestamp or Error: false
        // Default `null` is try use elFinderVolumeLocalFileSystem::localFileSystemInotify() on LocalFileSystem driver
        // another driver use elFinder stat() checker
        'syncCheckFunc' =&gt; null,
        // Long polling sync stand-by time (sec)
        'plStandby' =&gt; 30,
        // Sleep time (sec) for elFinder stat() checker (syncChkAsTs is true)
        'tsPlSleep' =&gt; 10,
        // Sleep time (sec) for elFinder ls() checker (syncChkAsTs is false)
        'lsPlSleep' =&gt; 30,
        // Client side sync interval minimum (ms)
        // Default `null` is auto set to ('tsPlSleep' or 'lsPlSleep') * 1000
        // `0` to disable auto sync
        'syncMinMs' =&gt; null,
        // required to fix bug on macos
        // However, we recommend to use the Normalizer plugin instead this option
        'utf8fix' =&gt; false,
        //                           й                 ё              Й               Ё              Ø         Å
        'utf8patterns' =&gt; array(&quot;\u0438\u0306&quot;, &quot;\u0435\u0308&quot;, &quot;\u0418\u0306&quot;, &quot;\u0415\u0308&quot;, &quot;\u00d8A&quot;, &quot;\u030a&quot;),
        'utf8replace' =&gt; array(&quot;\u0439&quot;, &quot;\u0451&quot;, &quot;\u0419&quot;, &quot;\u0401&quot;, &quot;\u00d8&quot;, &quot;\u00c5&quot;),
        // cache control HTTP headers for commands `file` and  `get`
        'cacheHeaders' =&gt; array(
            'Cache-Control: max-age=3600',
            'Expires:',
            'Pragma:'
        ),
        // Header to use to accelerate sending local files to clients (e.g. 'X-Sendfile', 'X-Accel-Redirect')
        'xsendfile' =&gt; '',
        // Root path to xsendfile target. Probably, this is required for 'X-Accel-Redirect' on Nginx.
        'xsendfilePath' =&gt; ''
    );

    /**
     * Defaults permissions
     *
     * @var array
     **/
    protected $defaults = array(
        'read' =&gt; true,
        'write' =&gt; true,
        'locked' =&gt; false,
        'hidden' =&gt; false
    );

    /**
     * Access control function/class
     *
     * @var mixed
     **/
    protected $attributes = array();

    /**
     * Access control function/class
     *
     * @var mixed
     **/
    protected $access = null;

    /**
     * Mime types allowed to upload
     *
     * @var array
     **/
    protected $uploadAllow = array();

    /**
     * Mime types denied to upload
     *
     * @var array
     **/
    protected $uploadDeny = array();

    /**
     * Order to validate uploadAllow and uploadDeny
     *
     * @var array
     **/
    protected $uploadOrder = array();

    /**
     * Maximum allowed upload file size.
     * Set as number or string with unit - &quot;10M&quot;, &quot;500K&quot;, &quot;1G&quot;
     *
     * @var int|string
     **/
    protected $uploadMaxSize = 0;

    /**
     * Run time setting of overwrite items on upload
     *
     * @var string
     */
    protected $uploadOverwrite = true;

    /**
     * Maximum allowed get file size.
     * Set as number or string with unit - &quot;10M&quot;, &quot;500K&quot;, &quot;1G&quot;
     *
     * @var int|string
     **/
    protected $getMaxSize = -1;

    /**
     * Mimetype detect method
     *
     * @var string
     **/
    protected $mimeDetect = 'auto';

    /**
     * Flag - mimetypes from externail file was loaded
     *
     * @var bool
     **/
    private static $mimetypesLoaded = false;

    /**
     * Finfo resource for mimeDetect == 'finfo'
     *
     * @var resource
     **/
    protected $finfo = null;

    /**
     * List of disabled client's commands
     *
     * @var array
     **/
    protected $disabled = array();

    /**
     * overwrite extensions/mimetypes to mime.types
     *
     * @var array
     **/
    protected static $mimetypes = array(
        // applications
        'exe' =&gt; 'application/x-executable',
        'jar' =&gt; 'application/x-jar',
        // archives
        'gz' =&gt; 'application/x-gzip',
        'tgz' =&gt; 'application/x-gzip',
        'tbz' =&gt; 'application/x-bzip2',
        'rar' =&gt; 'application/x-rar',
        // texts
        'php' =&gt; 'text/x-php',
        'js' =&gt; 'text/javascript',
        'rtfd' =&gt; 'application/rtfd',
        'py' =&gt; 'text/x-python',
        'rb' =&gt; 'text/x-ruby',
        'sh' =&gt; 'text/x-shellscript',
        'pl' =&gt; 'text/x-perl',
        'xml' =&gt; 'text/xml',
        'c' =&gt; 'text/x-csrc',
        'h' =&gt; 'text/x-chdr',
        'cpp' =&gt; 'text/x-c++src',
        'hh' =&gt; 'text/x-c++hdr',
        'md' =&gt; 'text/x-markdown',
        'markdown' =&gt; 'text/x-markdown',
        'yml' =&gt; 'text/x-yaml',
        // images
        'bmp' =&gt; 'image/x-ms-bmp',
        'tga' =&gt; 'image/x-targa',
        'xbm' =&gt; 'image/xbm',
        'pxm' =&gt; 'image/pxm',
        //audio
        'wav' =&gt; 'audio/wav',
        // video
        'dv' =&gt; 'video/x-dv',
        'wm' =&gt; 'video/x-ms-wmv',
        'ogm' =&gt; 'video/ogg',
        'm2ts' =&gt; 'video/MP2T',
        'mts' =&gt; 'video/MP2T',
        'ts' =&gt; 'video/MP2T',
        'm3u8' =&gt; 'application/x-mpegURL',
        'mpd' =&gt; 'application/dash+xml'
    );

    /**
     * Directory separator - required by client
     *
     * @var string
     **/
    protected $separator = DIRECTORY_SEPARATOR;

    /**
     * Directory separator for decode/encode hash
     *
     * @var string
     **/
    protected $separatorForHash = '';

    /**
     * System Root path (Unix like: '/', Windows: '\', 'C:\' or 'D:\'...)
     *
     * @var string
     **/
    protected $systemRoot = DIRECTORY_SEPARATOR;

    /**
     * Mimetypes allowed to display
     *
     * @var array
     **/
    protected $onlyMimes = array();

    /**
     * Store files moved or overwrited files info
     *
     * @var array
     **/
    protected $removed = array();

    /**
     * Store files added files info
     *
     * @var array
     **/
    protected $added = array();

    /**
     * Cache storage
     *
     * @var array
     **/
    protected $cache = array();

    /**
     * Cache by folders
     *
     * @var array
     **/
    protected $dirsCache = array();

    /**
     * You should use `$this-&gt;sessionCache['subdirs']` instead
     *
     * @var array
     * @deprecated
     */
    protected $subdirsCache = array();

    /**
     * This volume session cache
     *
     * @var array
     */
    protected $sessionCache;

    /**
     * Session caching item list
     *
     * @var array
     */
    protected $sessionCaching = array('rootstat' =&gt; true, 'subdirs' =&gt; true);

    /**
     * elFinder session wrapper object
     *
     * @var elFinderSessionInterface
     */
    protected $session;

    /**
     * Search start time
     *
     * @var int
     */
    protected $searchStart;

    /**
     * Current query word on doSearch
     *
     * @var array
     **/
    protected $doSearchCurrentQuery = array();

    /**
     * Is root modified (for clear root stat cache)
     *
     * @var bool
     */
    protected $rootModified = false;

    /**
     * Is disable of command `url`
     *
     * @var string
     */
    protected $disabledGetUrl = false;

    /**
     * Accepted filename validator
     *
     * @var string | callable
     */
    protected $nameValidator;

    /**
     * Accepted dirname validator
     *
     * @var string | callable
     */
    protected $dirnameValidator;

    /**
     * This request require online state
     *
     * @var boolean
     */
    protected $needOnline;

    /*********************************************************************/
    /*                            INITIALIZATION                         */
    /*********************************************************************/

    /**
     * Sets the need online.
     *
     * @param  boolean  $state  The state
     */
    public function setNeedOnline($state = null)
    {
        if ($state !== null) {
            $this-&gt;needOnline = (bool)$state;
            return;
        }

        $need = false;
        $arg = $this-&gt;ARGS;
        $id = $this-&gt;id;

        $target = !empty($arg['target'])? $arg['target'] : (!empty($arg['dst'])? $arg['dst'] : '');
        $targets = !empty($arg['targets'])? $arg['targets'] : array();
        if (!is_array($targets)) {
            $targets = array($targets);
        }

        if ($target &amp;&amp; strpos($target, $id) === 0) {
            $need = true;
        } else if ($targets) {
            foreach($targets as $t) {
                if ($t &amp;&amp; strpos($t, $id) === 0) {
                    $need = true;
                    break;
                }
            }
        }

        $this-&gt;needOnline = $need;
    }

    /**
     * Prepare driver before mount volume.
     * Return true if volume is ready.
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function init()
    {
        return true;
    }

    /**
     * Configure after successfull mount.
     * By default set thumbnails path and image manipulation library.
     *
     * @return void
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function configure()
    {
        // set thumbnails path
        $path = $this-&gt;options['tmbPath'];
        if ($path) {
            if (!file_exists($path)) {
                if (mkdir($path)) {
                    chmod($path, $this-&gt;options['tmbPathMode']);
                } else {
                    $path = '';
                }
            }

            if (is_dir($path) &amp;&amp; is_readable($path)) {
                $this-&gt;tmbPath = $path;
                $this-&gt;tmbPathWritable = is_writable($path);
            }
        }
        // set resouce path
        if (!is_dir($this-&gt;options['resourcePath'])) {
            $this-&gt;options['resourcePath'] = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'resources';
        }

        // set image manipulation library
        $type = preg_match('/^(imagick|gd|convert|auto|none)$/i', $this-&gt;options['imgLib'])
            ? strtolower($this-&gt;options['imgLib'])
            : 'auto';

        if ($type === 'none') {
            $this-&gt;imgLib = '';
        } else {
            if (($type === 'imagick' || $type === 'auto') &amp;&amp; extension_loaded('imagick')) {
                $this-&gt;imgLib = 'imagick';
            } else if (($type === 'gd' || $type === 'auto') &amp;&amp; function_exists('gd_info')) {
                $this-&gt;imgLib = 'gd';
            } else {
                $convertCache = 'imgLibConvert';
                if (($convertCmd = $this-&gt;session-&gt;get($convertCache, false)) !== false) {
                    $this-&gt;imgLib = $convertCmd;
                } else {
                    $this-&gt;imgLib = ($this-&gt;procExec(ELFINDER_CONVERT_PATH . ' -version') === 0) ? 'convert' : '';
                    $this-&gt;session-&gt;set($convertCache, $this-&gt;imgLib);
                }
            }
            if ($type !== 'auto' &amp;&amp; $this-&gt;imgLib === '') {
                // fallback
                $this-&gt;imgLib = extension_loaded('imagick') ? 'imagick' : (function_exists('gd_info') ? 'gd' : '');
            }
        }

        // check video to img converter
        if (!empty($this-&gt;options['imgConverter']) &amp;&amp; is_array($this-&gt;options['imgConverter'])) {
            foreach ($this-&gt;options['imgConverter'] as $_type =&gt; $_converter) {
                if (isset($_converter['func'])) {
                    $this-&gt;imgConverter[strtolower($_type)] = $_converter;
                }
            }
        }
        if (!isset($this-&gt;imgConverter['video'])) {
            $videoLibCache = 'videoLib';
            if (($videoLibCmd = $this-&gt;session-&gt;get($videoLibCache, false)) === false) {
                $videoLibCmd = ($this-&gt;procExec(ELFINDER_FFMPEG_PATH . ' -version') === 0) ? 'ffmpeg' : '';
                $this-&gt;session-&gt;set($videoLibCache, $videoLibCmd);
            }
            if ($videoLibCmd) {
                $this-&gt;imgConverter['video'] = array(
                    'func' =&gt; array($this, $videoLibCmd . 'ToImg'),
                    'maxlen' =&gt; $this-&gt;options['tmbVideoConvLen']
                );
            }
        }

        // check onetimeUrl
        if (strtolower($this-&gt;options['onetimeUrl']) === 'auto') {
            $this-&gt;options['onetimeUrl'] = elFinder::getStaticVar('commonTempPath')? true : false;
        }

        // check archivers
        if (empty($this-&gt;archivers['create'])) {
            $this-&gt;disabled[] = 'archive';
        }
        if (empty($this-&gt;archivers['extract'])) {
            $this-&gt;disabled[] = 'extract';
        }
        $_arc = $this-&gt;getArchivers();
        if (empty($_arc['create'])) {
            $this-&gt;disabled[] = 'zipdl';
        }

        if ($this-&gt;options['maxArcFilesSize']) {
            $this-&gt;options['maxArcFilesSize'] = elFinder::getIniBytes('', $this-&gt;options['maxArcFilesSize']);
        }
        self::$maxArcFilesSize = $this-&gt;options['maxArcFilesSize'];

        // check 'statOwner' for command `chmod`
        if (empty($this-&gt;options['statOwner'])) {
            $this-&gt;disabled[] = 'chmod';
        }

        // check 'mimeMap'
        if (!is_array($this-&gt;options['mimeMap'])) {
            $this-&gt;options['mimeMap'] = array();
        }
        if (is_array($this-&gt;options['staticMineMap']) &amp;&amp; $this-&gt;options['staticMineMap']) {
            $this-&gt;options['mimeMap'] = array_merge($this-&gt;options['mimeMap'], $this-&gt;options['staticMineMap']);
        }
        if (is_array($this-&gt;options['additionalMimeMap']) &amp;&amp; $this-&gt;options['additionalMimeMap']) {
            $this-&gt;options['mimeMap'] = array_merge($this-&gt;options['mimeMap'], $this-&gt;options['additionalMimeMap']);
        }

        // check 'url' in disabled commands
        if (in_array('url', $this-&gt;disabled)) {
            $this-&gt;disabledGetUrl = true;
        }

        // set run time setting uploadOverwrite
        $this-&gt;uploadOverwrite = $this-&gt;options['uploadOverwrite'];
    }

    /**
     * @deprecated
     */
    protected function sessionRestart()
    {
        $this-&gt;sessionCache = $this-&gt;session-&gt;start()-&gt;get($this-&gt;id, array());
        return true;
    }

    /*********************************************************************/
    /*                              PUBLIC API                           */
    /*********************************************************************/

    /**
     * Return driver id. Used as a part of volume id.
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    public function driverId()
    {
        return $this-&gt;driverId;
    }

    /**
     * Return volume id
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    public function id()
    {
        return $this-&gt;id;
    }

    /**
     * Assign elFinder session wrapper object
     *
     * @param  $session  elFinderSessionInterface
     */
    public function setSession($session)
    {
        $this-&gt;session = $session;
    }

    /**
     * Get elFinder sesson wrapper object
     *
     * @return object  The session object
     */
    public function getSession()
    {
        return $this-&gt;session;
    }

    /**
     * Save session cache data
     * Calls this function before umount this volume on elFinder::exec()
     *
     * @return void
     */
    public function saveSessionCache()
    {
        $this-&gt;session-&gt;set($this-&gt;id, $this-&gt;sessionCache);
    }

    /**
     * Return debug info for client
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    public function debug()
    {
        return array(
            'id' =&gt; $this-&gt;id(),
            'name' =&gt; strtolower(substr(get_class($this), strlen('elfinderdriver'))),
            'mimeDetect' =&gt; $this-&gt;mimeDetect,
            'imgLib' =&gt; $this-&gt;imgLib
        );
    }

    /**
     * chmod a file or folder
     *
     * @param  string $hash file or folder hash to chmod
     * @param  string $mode octal string representing new permissions
     *
     * @return array|false
     * @author David Bartle
     **/
    public function chmod($hash, $mode)
    {
        if ($this-&gt;commandDisabled('chmod')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (!($file = $this-&gt;file($hash))) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        if (!$this-&gt;options['allowChmodReadOnly']) {
            if (!$this-&gt;attr($this-&gt;decode($hash), 'write', null, ($file['mime'] === 'directory'))) {
                return $this-&gt;setError(elFinder::ERROR_PERM_DENIED, $file['name']);
            }
        }

        $path = $this-&gt;decode($hash);
        $write = $file['write'];

        if ($this-&gt;convEncOut(!$this-&gt;_chmod($this-&gt;convEncIn($path), $mode))) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED, $file['name']);
        }

        $this-&gt;clearstatcache();
        if ($path == $this-&gt;root) {
            $this-&gt;rootModified = true;
        }

        if ($file = $this-&gt;stat($path)) {
            $files = array($file);
            if ($file['mime'] === 'directory' &amp;&amp; $write !== $file['write']) {
                foreach ($this-&gt;getScandir($path) as $stat) {
                    if ($this-&gt;mimeAccepted($stat['mime'])) {
                        $files[] = $stat;
                    }
                }
            }
            return $files;
        } else {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }
    }

    /**
     * stat a file or folder for elFinder cmd exec
     *
     * @param  string $hash file or folder hash to chmod
     *
     * @return array
     * @author Naoki Sawada
     **/
    public function fstat($hash)
    {
        $path = $this-&gt;decode($hash);
        return $this-&gt;stat($path);
    }

    /**
     * Clear PHP stat cache &amp; all of inner stat caches
     */
    public function clearstatcache()
    {
        clearstatcache();
        $this-&gt;clearcache();
    }

    /**
     * Clear inner stat caches for target hash
     *
     * @param string $hash
     */
    public function clearcaches($hash = null)
    {
        if ($hash === null) {
            $this-&gt;clearcache();
        } else {
            $path = $this-&gt;decode($hash);
            unset($this-&gt;cache[$path], $this-&gt;dirsCache[$path]);
        }
    }

    /**
     * &quot;Mount&quot; volume.
     * Return true if volume available for read or write,
     * false - otherwise
     *
     * @param array $opts
     *
     * @return bool
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     */
    public function mount(array $opts)
    {
        $this-&gt;options = array_merge($this-&gt;options, $opts);

        if (!isset($this-&gt;options['path']) || $this-&gt;options['path'] === '') {
            return $this-&gt;setError('Path undefined.');
        }

        if (!$this-&gt;session) {
            return $this-&gt;setError('Session wrapper dose not set. Need to `$volume-&gt;setSession(elFinderSessionInterface);` before mount.');
        }
        if (!($this-&gt;session instanceof elFinderSessionInterface)) {
            return $this-&gt;setError('Session wrapper instance must be &quot;elFinderSessionInterface&quot;.');
        }

        // set driverId
        if (!empty($this-&gt;options['driverId'])) {
            $this-&gt;driverId = $this-&gt;options['driverId'];
        }

        $this-&gt;id = $this-&gt;driverId . (!empty($this-&gt;options['id']) ? $this-&gt;options['id'] : elFinder::$volumesCnt++) . '_';
        $this-&gt;root = $this-&gt;normpathCE($this-&gt;options['path']);
        $this-&gt;separator = isset($this-&gt;options['separator']) ? $this-&gt;options['separator'] : DIRECTORY_SEPARATOR;
        if (!empty($this-&gt;options['winHashFix'])) {
            $this-&gt;separatorForHash = ($this-&gt;separator !== '/') ? '/' : '';
        }
        $this-&gt;systemRoot = isset($this-&gt;options['systemRoot']) ? $this-&gt;options['systemRoot'] : $this-&gt;separator;

        // set ARGS
        $this-&gt;ARGS = $_SERVER['REQUEST_METHOD'] === 'POST' ? $_POST : $_GET;

        $argInit = !empty($this-&gt;ARGS['init']);

        // set $this-&gt;needOnline
        if (!is_bool($this-&gt;needOnline)) {
            $this-&gt;setNeedOnline();
        }

        // session cache
        if ($argInit) {
            $this-&gt;session-&gt;set($this-&gt;id, array());
        }
        $this-&gt;sessionCache = $this-&gt;session-&gt;get($this-&gt;id, array());

        // default file attribute
        $this-&gt;defaults = array(
            'read' =&gt; isset($this-&gt;options['defaults']['read']) ? !!$this-&gt;options['defaults']['read'] : true,
            'write' =&gt; isset($this-&gt;options['defaults']['write']) ? !!$this-&gt;options['defaults']['write'] : true,
            'locked' =&gt; isset($this-&gt;options['defaults']['locked']) ? !!$this-&gt;options['defaults']['locked'] : false,
            'hidden' =&gt; isset($this-&gt;options['defaults']['hidden']) ? !!$this-&gt;options['defaults']['hidden'] : false
        );

        // root attributes
        $this-&gt;attributes[] = array(
            'pattern' =&gt; '~^' . preg_quote($this-&gt;separator) . '$~',
            'locked' =&gt; true,
            'hidden' =&gt; false
        );
        // set files attributes
        if (!empty($this-&gt;options['attributes']) &amp;&amp; is_array($this-&gt;options['attributes'])) {

            foreach ($this-&gt;options['attributes'] as $a) {
                // attributes must contain pattern and at least one rule
                if (!empty($a['pattern']) || (is_array($a) &amp;&amp; count($a) &gt; 1)) {
                    $this-&gt;attributes[] = $a;
                }
            }
        }

        if (!empty($this-&gt;options['accessControl']) &amp;&amp; is_callable($this-&gt;options['accessControl'])) {
            $this-&gt;access = $this-&gt;options['accessControl'];
        }

        $this-&gt;today = mktime(0, 0, 0, date('m'), date('d'), date('Y'));
        $this-&gt;yesterday = $this-&gt;today - 86400;

        if (!$this-&gt;init()) {
            return false;
        }

        // set server encoding
        if (!empty($this-&gt;options['encoding']) &amp;&amp; strtoupper($this-&gt;options['encoding']) !== 'UTF-8') {
            $this-&gt;encoding = $this-&gt;options['encoding'];
        } else {
            $this-&gt;encoding = null;
        }

        // check some options is arrays
        $this-&gt;uploadAllow = isset($this-&gt;options['uploadAllow']) &amp;&amp; is_array($this-&gt;options['uploadAllow'])
            ? $this-&gt;options['uploadAllow']
            : array();

        $this-&gt;uploadDeny = isset($this-&gt;options['uploadDeny']) &amp;&amp; is_array($this-&gt;options['uploadDeny'])
            ? $this-&gt;options['uploadDeny']
            : array();

        $this-&gt;options['uiCmdMap'] = (isset($this-&gt;options['uiCmdMap']) &amp;&amp; is_array($this-&gt;options['uiCmdMap']))
            ? $this-&gt;options['uiCmdMap']
            : array();

        if (is_string($this-&gt;options['uploadOrder'])) { // telephat_mode on, compatibility with 1.x
            $parts = explode(',', isset($this-&gt;options['uploadOrder']) ? $this-&gt;options['uploadOrder'] : 'deny,allow');
            $this-&gt;uploadOrder = array(trim($parts[0]), trim($parts[1]));
        } else { // telephat_mode off
            $this-&gt;uploadOrder = !empty($this-&gt;options['uploadOrder']) ? $this-&gt;options['uploadOrder'] : array('deny', 'allow');
        }

        if (!empty($this-&gt;options['uploadMaxSize'])) {
            $this-&gt;uploadMaxSize = elFinder::getIniBytes('', $this-&gt;options['uploadMaxSize']);
        }
        // Set maximum to PHP_INT_MAX
        if (!defined('PHP_INT_MAX')) {
            define('PHP_INT_MAX', 2147483647);
        }
        if ($this-&gt;uploadMaxSize &lt; 1 || $this-&gt;uploadMaxSize &gt; PHP_INT_MAX) {
            $this-&gt;uploadMaxSize = PHP_INT_MAX;
        }

        // Set to get maximum size to 50% of memory_limit
        $memLimit = elFinder::getIniBytes('memory_limit') / 2;
        if ($memLimit &gt; 0) {
            $this-&gt;getMaxSize = empty($this-&gt;options['getMaxSize']) ? $memLimit : min($memLimit, elFinder::getIniBytes('', $this-&gt;options['getMaxSize']));
        } else {
            $this-&gt;getMaxSize = -1;
        }

        $this-&gt;disabled = isset($this-&gt;options['disabled']) &amp;&amp; is_array($this-&gt;options['disabled'])
            ? array_values(array_diff($this-&gt;options['disabled'], array('open'))) // 'open' is required
            : array();

        $this-&gt;cryptLib = $this-&gt;options['cryptLib'];
        $this-&gt;mimeDetect = $this-&gt;options['mimeDetect'];

        // find available mimetype detect method
        $regexp = '/text\/x\-(php|c\+\+)/';
        $auto_types = array();

        if (class_exists('finfo', false)) {
            $tmpFileInfo = explode(';', finfo_file(finfo_open(FILEINFO_MIME), __FILE__));
             if ($tmpFileInfo &amp;&amp; preg_match($regexp, array_shift($tmpFileInfo))) {
                $auto_types[] = 'finfo';
            }
        }
        
        if (function_exists('mime_content_type')) {
            $_mimetypes = explode(';', mime_content_type(__FILE__));
            if (preg_match($regexp, array_shift($_mimetypes))) {
                $auto_types[] = 'mime_content_type';
            }
        }
            
        $auto_types[] = 'internal';

        $type = strtolower($this-&gt;options['mimeDetect']);
        if (!in_array($type, $auto_types)) {
            $type = 'auto';
        }

        if ($type == 'auto') {
            $type = array_shift($auto_types);
        }

        $this-&gt;mimeDetect = $type;

        if ($this-&gt;mimeDetect == 'finfo') {
            $this-&gt;finfo = finfo_open(FILEINFO_MIME);
        } else if ($this-&gt;mimeDetect == 'internal' &amp;&amp; !elFinderVolumeDriver::$mimetypesLoaded) {
            // load mimes from external file for mimeDetect == 'internal'
            // based on Alexey Sukhotin idea and patch: http://elrte.org/redmine/issues/163
            // file must be in file directory or in parent one
            elFinderVolumeDriver::loadMimeTypes(!empty($this-&gt;options['mimefile']) ? $this-&gt;options['mimefile'] : '');
        }
        $this-&gt;rootName = empty($this-&gt;options['alias']) ? $this-&gt;basenameCE($this-&gt;root) : $this-&gt;options['alias'];

        // This get's triggered if $this-&gt;root == '/' and alias is empty.
        // Maybe modify _basename instead?
        if ($this-&gt;rootName === '') $this-&gt;rootName = $this-&gt;separator;

        $this-&gt;_checkArchivers();

        $root = $this-&gt;stat($this-&gt;root);

        if (!$root) {
            return $this-&gt;setError('Root folder does not exist.');
        }
        if (!$root['read'] &amp;&amp; !$root['write']) {
            return $this-&gt;setError('Root folder has not read and write permissions.');
        }

        if ($root['read']) {
            if ($argInit) {
                // check startPath - path to open by default instead of root
                $startPath = $this-&gt;options['startPath'] ? $this-&gt;normpathCE($this-&gt;options['startPath']) : '';
                if ($startPath) {
                    $start = $this-&gt;stat($startPath);
                    if (!empty($start)
                        &amp;&amp; $start['mime'] == 'directory'
                        &amp;&amp; $start['read']
                        &amp;&amp; empty($start['hidden'])
                        &amp;&amp; $this-&gt;inpathCE($startPath, $this-&gt;root)) {
                        $this-&gt;startPath = $startPath;
                        if (substr($this-&gt;startPath, -1, 1) == $this-&gt;options['separator']) {
                            $this-&gt;startPath = substr($this-&gt;startPath, 0, -1);
                        }
                    }
                }
            }
        } else {
            $this-&gt;options['URL'] = '';
            $this-&gt;options['tmbURL'] = '';
            $this-&gt;options['tmbPath'] = '';
            // read only volume
            array_unshift($this-&gt;attributes, array(
                'pattern' =&gt; '/.*/',
                'read' =&gt; false
            ));
        }
        $this-&gt;treeDeep = $this-&gt;options['treeDeep'] &gt; 0 ? (int)$this-&gt;options['treeDeep'] : 1;
        $this-&gt;tmbSize = $this-&gt;options['tmbSize'] &gt; 0 ? (int)$this-&gt;options['tmbSize'] : 48;
        $this-&gt;URL = $this-&gt;options['URL'];
        if ($this-&gt;URL &amp;&amp; preg_match(&quot;|[^/?&amp;=]$|&quot;, $this-&gt;URL)) {
            $this-&gt;URL .= '/';
        }

        $dirUrlOwn = strtolower($this-&gt;options['dirUrlOwn']);
        if ($dirUrlOwn === 'auto') {
            $this-&gt;options['dirUrlOwn'] = $this-&gt;URL ? false : true;
        } else if ($dirUrlOwn === 'hide') {
            $this-&gt;options['dirUrlOwn'] = 'hide';
        } else {
            $this-&gt;options['dirUrlOwn'] = (bool)$this-&gt;options['dirUrlOwn'];
        }

        $this-&gt;tmbURL = !empty($this-&gt;options['tmbURL']) ? $this-&gt;options['tmbURL'] : '';
        if ($this-&gt;tmbURL &amp;&amp; $this-&gt;tmbURL !== 'self' &amp;&amp; preg_match(&quot;|[^/?&amp;=]$|&quot;, $this-&gt;tmbURL)) {
            $this-&gt;tmbURL .= '/';
        }

        $this-&gt;nameValidator = !empty($this-&gt;options['acceptedName']) &amp;&amp; (is_string($this-&gt;options['acceptedName']) || is_callable($this-&gt;options['acceptedName']))
            ? $this-&gt;options['acceptedName']
            : '';

        $this-&gt;dirnameValidator = !empty($this-&gt;options['acceptedDirname']) &amp;&amp; (is_callable($this-&gt;options['acceptedDirname']) || (is_string($this-&gt;options['acceptedDirname']) &amp;&amp; preg_match($this-&gt;options['acceptedDirname'], '') !== false))
            ? $this-&gt;options['acceptedDirname']
            : $this-&gt;nameValidator;

        // enabling archivers['create'] with options['useRemoteArchive']
        if ($this-&gt;options['useRemoteArchive'] &amp;&amp; empty($this-&gt;archivers['create']) &amp;&amp; $this-&gt;getTempPath()) {
            $_archivers = $this-&gt;getArchivers();
            $this-&gt;archivers['create'] = $_archivers['create'];
        }

        // manual control archive types to create
        if (!empty($this-&gt;options['archiveMimes']) &amp;&amp; is_array($this-&gt;options['archiveMimes'])) {
            foreach ($this-&gt;archivers['create'] as $mime =&gt; $v) {
                if (!in_array($mime, $this-&gt;options['archiveMimes'])) {
                    unset($this-&gt;archivers['create'][$mime]);
                }
            }
        }

        // manualy add archivers
        if (!empty($this-&gt;options['archivers']['create']) &amp;&amp; is_array($this-&gt;options['archivers']['create'])) {
            foreach ($this-&gt;options['archivers']['create'] as $mime =&gt; $conf) {
                if (strpos($mime, 'application/') === 0
                    &amp;&amp; !empty($conf['cmd'])
                    &amp;&amp; isset($conf['argc'])
                    &amp;&amp; !empty($conf['ext'])
                    &amp;&amp; !isset($this-&gt;archivers['create'][$mime])) {
                    $this-&gt;archivers['create'][$mime] = $conf;
                }
            }
        }

        if (!empty($this-&gt;options['archivers']['extract']) &amp;&amp; is_array($this-&gt;options['archivers']['extract'])) {
            foreach ($this-&gt;options['archivers']['extract'] as $mime =&gt; $conf) {
                if (strpos($mime, 'application/') === 0
                    &amp;&amp; !empty($conf['cmd'])
                    &amp;&amp; isset($conf['argc'])
                    &amp;&amp; !empty($conf['ext'])
                    &amp;&amp; !isset($this-&gt;archivers['extract'][$mime])) {
                    $this-&gt;archivers['extract'][$mime] = $conf;
                }
            }
        }

        if (!empty($this-&gt;options['noSessionCache']) &amp;&amp; is_array($this-&gt;options['noSessionCache'])) {
            foreach ($this-&gt;options['noSessionCache'] as $_key) {
                $this-&gt;sessionCaching[$_key] = false;
                unset($this-&gt;sessionCache[$_key]);
            }
        }
        if ($this-&gt;sessionCaching['subdirs']) {
            if (!isset($this-&gt;sessionCache['subdirs'])) {
                $this-&gt;sessionCache['subdirs'] = array();
            }
        }


        $this-&gt;configure();

        // Normalize disabled (array_merge`for type array of JSON)
        $this-&gt;disabled = array_values(array_unique($this-&gt;disabled));

        // fix sync interval
        if ($this-&gt;options['syncMinMs'] !== 0) {
            $this-&gt;options['syncMinMs'] = max($this-&gt;options[$this-&gt;options['syncChkAsTs'] ? 'tsPlSleep' : 'lsPlSleep'] * 1000, intval($this-&gt;options['syncMinMs']));
        }

        // ` copyJoin` is required for the trash function
        if ($this-&gt;options['trashHash'] &amp;&amp; empty($this-&gt;options['copyJoin'])) {
            $this-&gt;options['trashHash'] = '';
        }

        // set tmpLinkPath
        if (elFinder::$tmpLinkPath &amp;&amp; !$this-&gt;options['tmpLinkPath']) {
            if (is_writeable(elFinder::$tmpLinkPath)) {
                $this-&gt;options['tmpLinkPath'] = elFinder::$tmpLinkPath;
            } else {
                elFinder::$tmpLinkPath = '';
            }
        }
        if ($this-&gt;options['tmpLinkPath'] &amp;&amp; is_writable($this-&gt;options['tmpLinkPath'])) {
            $this-&gt;tmpLinkPath = realpath($this-&gt;options['tmpLinkPath']);
        } else if (!$this-&gt;tmpLinkPath &amp;&amp; $this-&gt;tmbURL &amp;&amp; $this-&gt;tmbPath) {
            $this-&gt;tmpLinkPath = $this-&gt;tmbPath;
            $this-&gt;options['tmpLinkUrl'] = $this-&gt;tmbURL;
        } else if (!$this-&gt;options['URL'] &amp;&amp; is_writable('../files/.tmb')) {
            $this-&gt;tmpLinkPath = realpath('../files/.tmb');
            $this-&gt;options['tmpLinkUrl'] = '';
            if (!elFinder::$tmpLinkPath) {
                elFinder::$tmpLinkPath = $this-&gt;tmpLinkPath;
                elFinder::$tmpLinkUrl = '';
            }
        }

        // set tmpLinkUrl
        if (elFinder::$tmpLinkUrl &amp;&amp; !$this-&gt;options['tmpLinkUrl']) {
            $this-&gt;options['tmpLinkUrl'] = elFinder::$tmpLinkUrl;
        }
        if ($this-&gt;options['tmpLinkUrl']) {
            $this-&gt;tmpLinkUrl = $this-&gt;options['tmpLinkUrl'];
        }
        if ($this-&gt;tmpLinkPath &amp;&amp; !$this-&gt;tmpLinkUrl) {
            $cur = realpath('./');
            $i = 0;
            while ($cur !== $this-&gt;systemRoot &amp;&amp; strpos($this-&gt;tmpLinkPath, $cur) !== 0) {
                $i++;
                $cur = dirname($cur);
            }
            list($req) = explode('?', $_SERVER['REQUEST_URI']);
            $reqs = explode('/', dirname($req));
            $uri = join('/', array_slice($reqs, 0, count($reqs) - 1)) . substr($this-&gt;tmpLinkPath, strlen($cur));
            $https = (isset($_SERVER['HTTPS']) &amp;&amp; strtolower($_SERVER['HTTPS']) !== 'off');
            $this-&gt;tmpLinkUrl = ($https ? 'https://' : 'http://')
                . $_SERVER['SERVER_NAME'] // host
                . (((!$https &amp;&amp; $_SERVER['SERVER_PORT'] == 80) || ($https &amp;&amp; $_SERVER['SERVER_PORT'] == 443)) ? '' : (':' . $_SERVER['SERVER_PORT']))  // port
                . $uri;
            if (!elFinder::$tmpLinkUrl) {
                elFinder::$tmpLinkUrl = $this-&gt;tmpLinkUrl;
            }
        }

        // remove last '/'
        if ($this-&gt;tmpLinkPath) {
            $this-&gt;tmpLinkPath = rtrim($this-&gt;tmpLinkPath, '/');
        }
        if ($this-&gt;tmpLinkUrl) {
            $this-&gt;tmpLinkUrl = rtrim($this-&gt;tmpLinkUrl, '/');
        }

        // to update options cache
        if (isset($this-&gt;sessionCache['rootstat'])) {
            unset($this-&gt;sessionCache['rootstat'][$this-&gt;getRootstatCachekey()]);
        }
        $this-&gt;updateCache($this-&gt;root, $root);

        return $this-&gt;mounted = true;
    }

    /**
     * Some &quot;unmount&quot; stuffs - may be required by virtual fs
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    public function umount()
    {
    }

    /**
     * Remove session cache of this volume
     */
    public function clearSessionCache()
    {
        $this-&gt;sessionCache = array();
    }

    /**
     * Return error message from last failed action
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    public function error()
    {
        return $this-&gt;error;
    }

    /**
     * Return is uploadable that given file name
     *
     * @param  string $name file name
     * @param  bool   $allowUnknown
     *
     * @return bool
     * @author Naoki Sawada
     **/
    public function isUploadableByName($name, $allowUnknown = false)
    {
        $mimeByName = $this-&gt;mimetype($name, true);
        return (($allowUnknown &amp;&amp; $mimeByName === 'unknown') || $this-&gt;allowPutMime($mimeByName));
    }

    /**
     * Return Extention/MIME Table (elFinderVolumeDriver::$mimetypes)
     *
     * @return array
     * @author Naoki Sawada
     */
    public function getMimeTable()
    {
        // load mime.types
        if (!elFinderVolumeDriver::$mimetypesLoaded) {
            elFinderVolumeDriver::loadMimeTypes();
        }
        return elFinderVolumeDriver::$mimetypes;
    }

    /**
     * Return file extention detected by MIME type
     *
     * @param  string $mime   MIME type
     * @param  string $suffix Additional suffix
     *
     * @return string
     * @author Naoki Sawada
     */
    public function getExtentionByMime($mime, $suffix = '')
    {
        static $extTable = null;

        if (is_null($extTable)) {
            $extTable = array_flip(array_unique($this-&gt;getMimeTable()));
            foreach ($this-&gt;options['mimeMap'] as $pair =&gt; $_mime) {
                list($ext) = explode(':', $pair);
                if ($ext !== '*' &amp;&amp; !isset($extTable[$_mime])) {
                    $extTable[$_mime] = $ext;
                }
            }
        }

        if ($mime &amp;&amp; isset($extTable[$mime])) {
            return $suffix ? ($extTable[$mime] . $suffix) : $extTable[$mime];
        }
        return '';
    }

    /**
     * Set mimetypes allowed to display to client
     *
     * @param  array $mimes
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    public function setMimesFilter($mimes)
    {
        if (is_array($mimes)) {
            $this-&gt;onlyMimes = $mimes;
        }
    }

    /**
     * Return root folder hash
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    public function root()
    {
        return $this-&gt;encode($this-&gt;root);
    }

    /**
     * Return root path
     *
     * @return string
     * @author Naoki Sawada
     **/
    public function getRootPath()
    {
        return $this-&gt;root;
    }

    /**
     * Return target path hash
     *
     * @param  string $path
     * @param  string $name
     *
     * @author Naoki Sawada
     * @return string
     */
    public function getHash($path, $name = '')
    {
        if ($name !== '') {
            $path = $this-&gt;joinPathCE($path, $name);
        }
        return $this-&gt;encode($path);
    }

    /**
     * Return decoded path of target hash
     * This method do not check the stat of target
     * Use method `realpath()` to do check of the stat of target
     *
     * @param  string $hash
     *
     * @author Naoki Sawada
     * @return string
     */
    public function getPath($hash)
    {
        return $this-&gt;decode($hash);
    }

    /**
     * Return root or startPath hash
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    public function defaultPath()
    {
        return $this-&gt;encode($this-&gt;startPath ? $this-&gt;startPath : $this-&gt;root);
    }

    /**
     * Return volume options required by client:
     *
     * @param $hash
     *
     * @return array
     * @author Dmitry (dio) Levashov
     */
    public function options($hash)
    {
        $create = $createext = array();
        if (isset($this-&gt;archivers['create']) &amp;&amp; is_array($this-&gt;archivers['create'])) {
            foreach ($this-&gt;archivers['create'] as $m =&gt; $v) {
                $create[] = $m;
                $createext[$m] = $v['ext'];
            }
        }
        $opts = array(
            'path' =&gt; $hash ? $this-&gt;path($hash) : '',
            'url' =&gt; $this-&gt;URL,
            'tmbUrl' =&gt; (!$this-&gt;imgLib &amp;&amp; $this-&gt;options['tmbFbSelf']) ? 'self' : $this-&gt;tmbURL,
            'disabled' =&gt; $this-&gt;disabled,
            'separator' =&gt; $this-&gt;separator,
            'copyOverwrite' =&gt; intval($this-&gt;options['copyOverwrite']),
            'uploadOverwrite' =&gt; intval($this-&gt;options['uploadOverwrite']),
            'uploadMaxSize' =&gt; intval($this-&gt;uploadMaxSize),
            'uploadMaxConn' =&gt; intval($this-&gt;options['uploadMaxConn']),
            'uploadMime' =&gt; array(
                'firstOrder' =&gt; isset($this-&gt;uploadOrder[0]) ? $this-&gt;uploadOrder[0] : 'deny',
                'allow' =&gt; $this-&gt;uploadAllow,
                'deny' =&gt; $this-&gt;uploadDeny
            ),
            'dispInlineRegex' =&gt; $this-&gt;options['dispInlineRegex'],
            'jpgQuality' =&gt; intval($this-&gt;options['jpgQuality']),
            'archivers' =&gt; array(
                'create' =&gt; $create,
                'extract' =&gt; isset($this-&gt;archivers['extract']) &amp;&amp; is_array($this-&gt;archivers['extract']) ? array_keys($this-&gt;archivers['extract']) : array(),
                'createext' =&gt; $createext
            ),
            'uiCmdMap' =&gt; (isset($this-&gt;options['uiCmdMap']) &amp;&amp; is_array($this-&gt;options['uiCmdMap'])) ? $this-&gt;options['uiCmdMap'] : array(),
            'syncChkAsTs' =&gt; intval($this-&gt;options['syncChkAsTs']),
            'syncMinMs' =&gt; intval($this-&gt;options['syncMinMs']),
            'i18nFolderName' =&gt; intval($this-&gt;options['i18nFolderName']),
            'tmbCrop' =&gt; intval($this-&gt;options['tmbCrop']),
            'tmbReqCustomData' =&gt; (bool)$this-&gt;options['tmbReqCustomData'],
            'substituteImg' =&gt; (bool)$this-&gt;options['substituteImg'],
            'onetimeUrl' =&gt; (bool)$this-&gt;options['onetimeUrl'],
        );
        if (!empty($this-&gt;options['trashHash'])) {
            $opts['trashHash'] = $this-&gt;options['trashHash'];
        }
        if ($hash === null) {
            // call from getRootStatExtra()
            if (!empty($this-&gt;options['icon'])) {
                $opts['icon'] = $this-&gt;options['icon'];
            }
            if (!empty($this-&gt;options['rootCssClass'])) {
                $opts['csscls'] = $this-&gt;options['rootCssClass'];
            }
            if (isset($this-&gt;options['netkey'])) {
                $opts['netkey'] = $this-&gt;options['netkey'];
            }
        }
        return $opts;
    }

    /**
     * Get option value of this volume
     *
     * @param string $name target option name
     *
     * @return NULL|mixed   target option value
     * @author Naoki Sawada
     */
    public function getOption($name)
    {
        return isset($this-&gt;options[$name]) ? $this-&gt;options[$name] : null;
    }

    /**
     * Get plugin values of this options
     *
     * @param string $name Plugin name
     *
     * @return NULL|array   Plugin values
     * @author Naoki Sawada
     */
    public function getOptionsPlugin($name = '')
    {
        if ($name) {
            return isset($this-&gt;options['plugin'][$name]) ? $this-&gt;options['plugin'][$name] : array();
        } else {
            return $this-&gt;options['plugin'];
        }
    }

    /**
     * Return true if command disabled in options
     *
     * @param  string $cmd command name
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    public function commandDisabled($cmd)
    {
        return in_array($cmd, $this-&gt;disabled);
    }

    /**
     * Return true if mime is required mimes list
     *
     * @param  string    $mime  mime type to check
     * @param  array     $mimes allowed mime types list or not set to use client mimes list
     * @param  bool|null $empty what to return on empty list
     *
     * @return bool|null
     * @author Dmitry (dio) Levashov
     * @author Troex Nevelin
     **/
    public function mimeAccepted($mime, $mimes = null, $empty = true)
    {
        $mimes = is_array($mimes) ? $mimes : $this-&gt;onlyMimes;
        if (empty($mimes)) {
            return $empty;
        }
        return $mime == 'directory'
            || in_array('all', $mimes)
            || in_array('All', $mimes)
            || in_array($mime, $mimes)
            || in_array(substr($mime, 0, strpos($mime, '/')), $mimes);
    }

    /**
     * Return true if voume is readable.
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    public function isReadable()
    {
        $stat = $this-&gt;stat($this-&gt;root);
        return $stat['read'];
    }

    /**
     * Return true if copy from this volume allowed
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    public function copyFromAllowed()
    {
        return !!$this-&gt;options['copyFrom'];
    }

    /**
     * Return file path related to root with convert encoging
     *
     * @param  string $hash file hash
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    public function path($hash)
    {
        return $this-&gt;convEncOut($this-&gt;_path($this-&gt;convEncIn($this-&gt;decode($hash))));
    }

    /**
     * Return file real path if file exists
     *
     * @param  string $hash file hash
     *
     * @return string | false
     * @author Dmitry (dio) Levashov
     **/
    public function realpath($hash)
    {
        $path = $this-&gt;decode($hash);
        return $this-&gt;stat($path) ? $path : false;
    }

    /**
     * Return list of moved/overwrited files
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    public function removed()
    {
        if ($this-&gt;removed) {
            $unsetSubdir = isset($this-&gt;sessionCache['subdirs']) ? true : false;
            foreach ($this-&gt;removed as $item) {
                if ($item['mime'] === 'directory') {
                    $path = $this-&gt;decode($item['hash']);
                    if ($unsetSubdir) {
                        unset($this-&gt;sessionCache['subdirs'][$path]);
                    }
                    if ($item['phash'] !== '') {
                        $parent = $this-&gt;decode($item['phash']);
                        unset($this-&gt;cache[$parent]);
                        if ($this-&gt;root === $parent) {
                            $this-&gt;sessionCache['rootstat'] = array();
                        }
                        if ($unsetSubdir) {
                            unset($this-&gt;sessionCache['subdirs'][$parent]);
                        }
                    }
                }
            }
            $this-&gt;removed = array_values($this-&gt;removed);
        }
        return $this-&gt;removed;
    }

    /**
     * Return list of added files
     *
     * @deprecated
     * @return array
     * @author Naoki Sawada
     **/
    public function added()
    {
        return $this-&gt;added;
    }

    /**
     * Clean removed files list
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    public function resetRemoved()
    {
        $this-&gt;resetResultStat();
    }

    /**
     * Clean added/removed files list
     *
     * @return void
     **/
    public function resetResultStat()
    {
        $this-&gt;removed = array();
        $this-&gt;added = array();
    }

    /**
     * Return file/dir hash or first founded child hash with required attr == $val
     *
     * @param  string $hash file hash
     * @param  string $attr attribute name
     * @param  bool   $val  attribute value
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    public function closest($hash, $attr, $val)
    {
        return ($path = $this-&gt;closestByAttr($this-&gt;decode($hash), $attr, $val)) ? $this-&gt;encode($path) : false;
    }

    /**
     * Return file info or false on error
     *
     * @param  string $hash file hash
     *
     * @return array|false
     * @internal param bool $realpath add realpath field to file info
     * @author   Dmitry (dio) Levashov
     */
    public function file($hash)
    {
        $file = $this-&gt;stat($this-&gt;decode($hash));

        return ($file) ? $file : $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
    }

    /**
     * Return folder info
     *
     * @param  string $hash folder hash
     * @param bool    $resolveLink
     *
     * @return array|false
     * @internal param bool $hidden return hidden file info
     * @author   Dmitry (dio) Levashov
     */
    public function dir($hash, $resolveLink = false)
    {
        if (($dir = $this-&gt;file($hash)) == false) {
            return $this-&gt;setError(elFinder::ERROR_DIR_NOT_FOUND);
        }

        if ($resolveLink &amp;&amp; !empty($dir['thash'])) {
            $dir = $this-&gt;file($dir['thash']);
        }

        return $dir &amp;&amp; $dir['mime'] == 'directory' &amp;&amp; empty($dir['hidden'])
            ? $dir
            : $this-&gt;setError(elFinder::ERROR_NOT_DIR);
    }

    /**
     * Return directory content or false on error
     *
     * @param  string $hash file hash
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    public function scandir($hash)
    {
        if (($dir = $this-&gt;dir($hash)) == false) {
            return false;
        }

        $path = $this-&gt;decode($hash);
        if ($res = $dir['read']
            ? $this-&gt;getScandir($path)
            : $this-&gt;setError(elFinder::ERROR_PERM_DENIED)) {

            $dirs = null;
            if ($this-&gt;sessionCaching['subdirs'] &amp;&amp; isset($this-&gt;sessionCache['subdirs'][$path])) {
                $dirs = $this-&gt;sessionCache['subdirs'][$path];
            }
            if ($dirs !== null || (isset($dir['dirs']) &amp;&amp; $dir['dirs'] != 1)) {
                $_dir = $dir;
                if ($dirs || $this-&gt;subdirs($hash)) {
                    $dir['dirs'] = 1;
                } else {
                    unset($dir['dirs']);
                }
                if ($dir !== $_dir) {
                    $this-&gt;updateCache($path, $dir);
                }
            }
        }

        return $res;
    }

    /**
     * Return dir files names list
     *
     * @param  string $hash file hash
     * @param null    $intersect
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     */
    public function ls($hash, $intersect = null)
    {
        if (($dir = $this-&gt;dir($hash)) == false || !$dir['read']) {
            return false;
        }

        $list = array();
        $path = $this-&gt;decode($hash);

        $check = array();
        if ($intersect) {
            $check = array_flip($intersect);
        }

        foreach ($this-&gt;getScandir($path) as $stat) {
            if (empty($stat['hidden']) &amp;&amp; (!$check || isset($check[$stat['name']])) &amp;&amp; $this-&gt;mimeAccepted($stat['mime'])) {
                $list[$stat['hash']] = $stat['name'];
            }
        }

        return $list;
    }

    /**
     * Return subfolders for required folder or false on error
     *
     * @param  string $hash    folder hash or empty string to get tree from root folder
     * @param  int    $deep    subdir deep
     * @param  string $exclude dir hash which subfolders must be exluded from result, required to not get stat twice on cwd subfolders
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    public function tree($hash = '', $deep = 0, $exclude = '')
    {
        $path = $hash ? $this-&gt;decode($hash) : $this-&gt;root;

        if (($dir = $this-&gt;stat($path)) == false || $dir['mime'] != 'directory') {
            return false;
        }

        $dirs = $this-&gt;gettree($path, $deep &gt; 0 ? $deep - 1 : $this-&gt;treeDeep - 1, $exclude ? $this-&gt;decode($exclude) : null);
        array_unshift($dirs, $dir);
        return $dirs;
    }

    /**
     * Return part of dirs tree from required dir up to root dir
     *
     * @param  string    $hash   directory hash
     * @param  bool|null $lineal only lineal parents
     *
     * @return array|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function parents($hash, $lineal = false)
    {
        if (($current = $this-&gt;dir($hash)) == false) {
            return false;
        }

        $args = func_get_args();
        // checks 3rd param `$until` (elFinder &gt;= 2.1.24)
        $until = '';
        if (isset($args[2])) {
            $until = $args[2];
        }

        $path = $this-&gt;decode($hash);
        $tree = array();

        while ($path &amp;&amp; $path != $this-&gt;root) {
            elFinder::checkAborted();
            $path = $this-&gt;dirnameCE($path);
            if (!($stat = $this-&gt;stat($path)) || !empty($stat['hidden']) || !$stat['read']) {
                return false;
            }

            array_unshift($tree, $stat);
            if (!$lineal) {
                foreach ($this-&gt;gettree($path, 0) as $dir) {
                    elFinder::checkAborted();
                    if (!isset($tree[$dir['hash']])) {
                        $tree[$dir['hash']] = $dir;
                    }
                }
            }

            if ($until &amp;&amp; $until === $this-&gt;encode($path)) {
                break;
            }
        }

        return $tree ? array_values($tree) : array($current);
    }

    /**
     * Create thumbnail for required file and return its name or false on failed
     *
     * @param $hash
     *
     * @return false|string
     * @throws ImagickException
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function tmb($hash)
    {
        $path = $this-&gt;decode($hash);
        $stat = $this-&gt;stat($path);

        if (isset($stat['tmb'])) {
            $res = $stat['tmb'] == &quot;1&quot; ? $this-&gt;createTmb($path, $stat) : $stat['tmb'];
            if (!$res) {
                list($type) = explode('/', $stat['mime']);
                $fallback = $this-&gt;options['resourcePath'] . DIRECTORY_SEPARATOR . strtolower($type) . '.png';
                if (is_file($fallback)) {
                    $res = $this-&gt;tmbname($stat);
                    if (!copy($fallback, $this-&gt;tmbPath . DIRECTORY_SEPARATOR . $res)) {
                        $res = false;
                    }
                }
            }
            // tmb garbage collection
            if ($res &amp;&amp; $this-&gt;options['tmbGcMaxlifeHour'] &amp;&amp; $this-&gt;options['tmbGcPercentage'] &gt; 0) {
                $rand = mt_rand(1, 10000);
                if ($rand &lt;= $this-&gt;options['tmbGcPercentage'] * 100) {
                    register_shutdown_function(array('elFinder', 'GlobGC'), $this-&gt;tmbPath . DIRECTORY_SEPARATOR . '*.png', $this-&gt;options['tmbGcMaxlifeHour'] * 3600);
                }
            }
            return $res;
        }
        return false;
    }

    /**
     * Return file size / total directory size
     *
     * @param  string   file hash
     *
     * @return array
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function size($hash)
    {
        return $this-&gt;countSize($this-&gt;decode($hash));
    }

    /**
     * Open file for reading and return file pointer
     *
     * @param  string   file hash
     *
     * @return Resource|false
     * @author Dmitry (dio) Levashov
     **/
    public function open($hash)
    {
        if (($file = $this-&gt;file($hash)) == false
            || $file['mime'] == 'directory') {
            return false;
        }
        // check extra option for network stream pointer
        if (func_num_args() &gt; 1) {
            $opts = func_get_arg(1);
        } else {
            $opts = array();
        }
        return $this-&gt;fopenCE($this-&gt;decode($hash), 'rb', $opts);
    }

    /**
     * Close file pointer
     *
     * @param  Resource $fp   file pointer
     * @param  string   $hash file hash
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    public function close($fp, $hash)
    {
        $this-&gt;fcloseCE($fp, $this-&gt;decode($hash));
    }

    /**
     * Create directory and return dir info
     *
     * @param  string $dsthash destination directory hash
     * @param  string $name    directory name
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    public function mkdir($dsthash, $name)
    {
        if ($this-&gt;commandDisabled('mkdir')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (!$this-&gt;nameAccepted($name, true)) {
            return $this-&gt;setError(elFinder::ERROR_INVALID_DIRNAME);
        }

        if (($dir = $this-&gt;dir($dsthash)) == false) {
            return $this-&gt;setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#' . $dsthash);
        }

        $path = $this-&gt;decode($dsthash);

        if (!$dir['write'] || !$this-&gt;allowCreate($path, $name, true)) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (substr($name, 0, 1) === '/' || substr($name, 0, 1) === '\\') {
            return $this-&gt;setError(elFinder::ERROR_INVALID_DIRNAME);
        }

        $dst = $this-&gt;joinPathCE($path, $name);
        $stat = $this-&gt;isNameExists($dst);
        if (!empty($stat)) {
            return $this-&gt;setError(elFinder::ERROR_EXISTS, $name);
        }
        $this-&gt;clearcache();

        $mkpath = $this-&gt;convEncOut($this-&gt;_mkdir($this-&gt;convEncIn($path), $this-&gt;convEncIn($name)));
        if ($mkpath) {
            $this-&gt;clearstatcache();
            $this-&gt;updateSubdirsCache($path, true);
            $this-&gt;updateSubdirsCache($mkpath, false);
        }

        return $mkpath ? $this-&gt;stat($mkpath) : false;
    }

    /**
     * Create empty file and return its info
     *
     * @param  string $dst  destination directory
     * @param  string $name file name
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    public function mkfile($dst, $name)
    {
        if ($this-&gt;commandDisabled('mkfile')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (!$this-&gt;nameAccepted($name, false)) {
            return $this-&gt;setError(elFinder::ERROR_INVALID_NAME);
        }

        if (substr($name, 0, 1) === '/' || substr($name, 0, 1) === '\\') {
            return $this-&gt;setError(elFinder::ERROR_INVALID_DIRNAME);
        }

        $mimeByName = $this-&gt;mimetype($name, true);
        if ($mimeByName &amp;&amp; !$this-&gt;allowPutMime($mimeByName)) {
            return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_MIME, $name);
        }

        if (($dir = $this-&gt;dir($dst)) == false) {
            return $this-&gt;setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#' . $dst);
        }

        $path = $this-&gt;decode($dst);

        if (!$dir['write'] || !$this-&gt;allowCreate($path, $name, false)) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if ($this-&gt;isNameExists($this-&gt;joinPathCE($path, $name))) {
            return $this-&gt;setError(elFinder::ERROR_EXISTS, $name);
        }

        $this-&gt;clearcache();
        $res = false;
        if ($path = $this-&gt;convEncOut($this-&gt;_mkfile($this-&gt;convEncIn($path), $this-&gt;convEncIn($name)))) {
            $this-&gt;clearstatcache();
            $res = $this-&gt;stat($path);
        }
        return $res;
    }

    /**
     * Rename file and return file info
     *
     * @param  string $hash file hash
     * @param  string $name new file name
     *
     * @return array|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function rename($hash, $name)
    {
        if ($this-&gt;commandDisabled('rename')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (!($file = $this-&gt;file($hash))) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        if ($name === $file['name']) {
            return $file;
        }

        if (!empty($this-&gt;options['netkey']) &amp;&amp; !empty($file['isroot'])) {
            // change alias of netmount root
            $rootKey = $this-&gt;getRootstatCachekey();
            // delete old cache data
            if ($this-&gt;sessionCaching['rootstat']) {
                unset($this-&gt;sessionCaching['rootstat'][$rootKey]);
            }
            if (elFinder::$instance-&gt;updateNetVolumeOption($this-&gt;options['netkey'], 'alias', $name)) {
                $this-&gt;clearcache();
                $this-&gt;rootName = $this-&gt;options['alias'] = $name;
                return $this-&gt;stat($this-&gt;root);
            } else {
                return $this-&gt;setError(elFinder::ERROR_TRGDIR_NOT_FOUND, $name);
            }
        }

        if (!empty($file['locked'])) {
            return $this-&gt;setError(elFinder::ERROR_LOCKED, $file['name']);
        }

        $isDir = ($file['mime'] === 'directory');

        if (!$this-&gt;nameAccepted($name, $isDir)) {
            return $this-&gt;setError($isDir ? elFinder::ERROR_INVALID_DIRNAME : elFinder::ERROR_INVALID_NAME);
        }

        if (!$isDir) {
            $mimeByName = $this-&gt;mimetype($name, true);
            if ($mimeByName &amp;&amp; !$this-&gt;allowPutMime($mimeByName)) {
                return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_MIME, $name);
            }
        }

        $path = $this-&gt;decode($hash);
        $dir = $this-&gt;dirnameCE($path);
        $stat = $this-&gt;isNameExists($this-&gt;joinPathCE($dir, $name));
        if ($stat) {
            return $this-&gt;setError(elFinder::ERROR_EXISTS, $name);
        }

        if (!$this-&gt;allowCreate($dir, $name, ($file['mime'] === 'directory'))) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        $this-&gt;rmTmb($file); // remove old name tmbs, we cannot do this after dir move


        if ($path = $this-&gt;convEncOut($this-&gt;_move($this-&gt;convEncIn($path), $this-&gt;convEncIn($dir), $this-&gt;convEncIn($name)))) {
            $this-&gt;clearcache();
            return $this-&gt;stat($path);
        }
        return false;
    }

    /**
     * Create file copy with suffix &quot;copy number&quot; and return its info
     *
     * @param  string $hash   file hash
     * @param  string $suffix suffix to add to file name
     *
     * @return array|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function duplicate($hash, $suffix = 'copy')
    {
        if ($this-&gt;commandDisabled('duplicate')) {
            return $this-&gt;setError(elFinder::ERROR_COPY, '#' . $hash, elFinder::ERROR_PERM_DENIED);
        }

        if (($file = $this-&gt;file($hash)) == false) {
            return $this-&gt;setError(elFinder::ERROR_COPY, elFinder::ERROR_FILE_NOT_FOUND);
        }

        $path = $this-&gt;decode($hash);
        $dir = $this-&gt;dirnameCE($path);
        $name = $this-&gt;uniqueName($dir, $file['name'], sprintf($this-&gt;options['duplicateSuffix'], $suffix));

        if (!$this-&gt;allowCreate($dir, $name, ($file['mime'] === 'directory'))) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        return ($path = $this-&gt;copy($path, $dir, $name)) == false
            ? false
            : $this-&gt;stat($path);
    }

    /**
     * Save uploaded file.
     * On success return array with new file stat and with removed file hash (if existed file was replaced)
     *
     * @param  Resource $fp      file pointer
     * @param  string   $dst     destination folder hash
     * @param           $name
     * @param  string   $tmpname file tmp name - required to detect mime type
     * @param  array    $hashes  exists files hash array with filename as key
     *
     * @return array|false
     * @throws elFinderAbortException
     * @internal param string $src file name
     * @author   Dmitry (dio) Levashov
     */
    public function upload($fp, $dst, $name, $tmpname, $hashes = array())
    {
        if ($this-&gt;commandDisabled('upload')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (($dir = $this-&gt;dir($dst)) == false) {
            return $this-&gt;setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#' . $dst);
        }

        if (empty($dir['write'])) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (!$this-&gt;nameAccepted($name, false)) {
            return $this-&gt;setError(elFinder::ERROR_INVALID_NAME);
        }

        $mimeByName = '';
        if ($this-&gt;mimeDetect === 'internal') {
            $mime = $this-&gt;mimetype($tmpname, $name);
        } else {
            $mime = $this-&gt;mimetype($tmpname, $name);
            $mimeByName = $this-&gt;mimetype($name, true);
            if ($mime === 'unknown') {
                $mime = $mimeByName;
            }
        }

        if (!$this-&gt;allowPutMime($mime) || ($mimeByName &amp;&amp; !$this-&gt;allowPutMime($mimeByName))) {
            return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_MIME, '(' . $mime . ')');
        }

        $tmpsize = (int)sprintf('%u', filesize($tmpname));
        if ($this-&gt;uploadMaxSize &gt; 0 &amp;&amp; $tmpsize &gt; $this-&gt;uploadMaxSize) {
            return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_SIZE);
        }

        $dstpath = $this-&gt;decode($dst);
        if (isset($hashes[$name])) {
            $test = $this-&gt;decode($hashes[$name]);
            $file = $this-&gt;stat($test);
        } else {
            $test = $this-&gt;joinPathCE($dstpath, $name);
            $file = $this-&gt;isNameExists($test);
        }

        $this-&gt;clearcache();

        if ($file &amp;&amp; $file['name'] === $name) { // file exists and check filename for item ID based filesystem
            if ($this-&gt;uploadOverwrite) {
                if (!$file['write']) {
                    return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
                } elseif ($file['mime'] == 'directory') {
                    return $this-&gt;setError(elFinder::ERROR_NOT_REPLACE, $name);
                }
                $this-&gt;remove($test);
            } else {
                $name = $this-&gt;uniqueName($dstpath, $name, '-', false);
            }
        }

        $stat = array(
            'mime' =&gt; $mime,
            'width' =&gt; 0,
            'height' =&gt; 0,
            'size' =&gt; $tmpsize);

        // $w = $h = 0;
        if (strpos($mime, 'image') === 0 &amp;&amp; ($s = getimagesize($tmpname))) {
            $stat['width'] = $s[0];
            $stat['height'] = $s[1];
        }
        // $this-&gt;clearcache();
        if (($path = $this-&gt;saveCE($fp, $dstpath, $name, $stat)) == false) {
            return false;
        }

        $stat = $this-&gt;stat($path);
        // Try get URL
        if (empty($stat['url']) &amp;&amp; ($url = $this-&gt;getContentUrl($stat['hash']))) {
            $stat['url'] = $url;
        }

        return $stat;
    }

    /**
     * Paste files
     *
     * @param  Object $volume source volume
     * @param         $src
     * @param  string $dst    destination dir hash
     * @param  bool   $rmSrc  remove source after copy?
     * @param array   $hashes
     *
     * @return array|false
     * @throws elFinderAbortException
     * @internal param string $source file hash
     * @author   Dmitry (dio) Levashov
     */
    public function paste($volume, $src, $dst, $rmSrc = false, $hashes = array())
    {
        $err = $rmSrc ? elFinder::ERROR_MOVE : elFinder::ERROR_COPY;

        if ($this-&gt;commandDisabled('paste')) {
            return $this-&gt;setError($err, '#' . $src, elFinder::ERROR_PERM_DENIED);
        }

        if (($file = $volume-&gt;file($src, $rmSrc)) == false) {
            return $this-&gt;setError($err, '#' . $src, elFinder::ERROR_FILE_NOT_FOUND);
        }

        $name = $file['name'];
        $errpath = $volume-&gt;path($file['hash']);

        if (($dir = $this-&gt;dir($dst)) == false) {
            return $this-&gt;setError($err, $errpath, elFinder::ERROR_TRGDIR_NOT_FOUND, '#' . $dst);
        }

        if (!$dir['write'] || !$file['read']) {
            return $this-&gt;setError($err, $errpath, elFinder::ERROR_PERM_DENIED);
        }

        $destination = $this-&gt;decode($dst);

        if (($test = $volume-&gt;closest($src, $rmSrc ? 'locked' : 'read', $rmSrc))) {
            return $rmSrc
                ? $this-&gt;setError($err, $errpath, elFinder::ERROR_LOCKED, $volume-&gt;path($test))
                : $this-&gt;setError($err, $errpath, empty($file['thash']) ? elFinder::ERROR_PERM_DENIED : elFinder::ERROR_MKOUTLINK);
        }

        if (isset($hashes[$name])) {
            $test = $this-&gt;decode($hashes[$name]);
            $stat = $this-&gt;stat($test);
        } else {
            $test = $this-&gt;joinPathCE($destination, $name);
            $stat = $this-&gt;isNameExists($test);
        }
        $this-&gt;clearcache();
        $dstDirExists = false;
        if ($stat &amp;&amp; $stat['name'] === $name) { // file exists and check filename for item ID based filesystem
            if ($this-&gt;options['copyOverwrite']) {
                // do not replace file with dir or dir with file
                if (!$this-&gt;isSameType($file['mime'], $stat['mime'])) {
                    return $this-&gt;setError(elFinder::ERROR_NOT_REPLACE, $this-&gt;path($stat['hash']));
                }
                // existed file is not writable
                if (empty($stat['write'])) {
                    return $this-&gt;setError($err, $errpath, elFinder::ERROR_PERM_DENIED);
                }
                if ($this-&gt;options['copyJoin']) {
                    if (!empty($stat['locked'])) {
                        return $this-&gt;setError(elFinder::ERROR_LOCKED, $this-&gt;path($stat['hash']));
                    }
                } else {
                    // existed file locked or has locked child
                    if (($locked = $this-&gt;closestByAttr($test, 'locked', true))) {
                        $stat = $this-&gt;stat($locked);
                        return $this-&gt;setError(elFinder::ERROR_LOCKED, $this-&gt;path($stat['hash']));
                    }
                }
                // target is entity file of alias
                if ($volume === $this &amp;&amp; ((isset($file['target']) &amp;&amp; $test == $file['target']) || $test == $this-&gt;decode($src))) {
                    return $this-&gt;setError(elFinder::ERROR_REPLACE, $errpath);
                }
                // remove existed file
                if (!$this-&gt;options['copyJoin'] || $stat['mime'] !== 'directory') {
                    if (!$this-&gt;remove($test)) {
                        return $this-&gt;setError(elFinder::ERROR_REPLACE, $this-&gt;path($stat['hash']));
                    }
                } else if ($stat['mime'] === 'directory') {
                    $dstDirExists = true;
                }
            } else {
                $name = $this-&gt;uniqueName($destination, $name, ' ', false);
            }
        }

        // copy/move inside current volume
        if ($volume === $this) { //  changing == operand to === fixes issue #1285 - Paul Canning 24/03/2016
            $source = $this-&gt;decode($src);
            // do not copy into itself
            if ($this-&gt;inpathCE($destination, $source)) {
                return $this-&gt;setError(elFinder::ERROR_COPY_ITSELF, $errpath);
            }
            $rmDir = false;
            if ($rmSrc) {
                if ($dstDirExists) {
                    $rmDir = true;
                    $method = 'copy';
                } else {
                    $method = 'move';
                }
            } else {
                $method = 'copy';
            }
            $this-&gt;clearcache();
            if ($res = ($path = $this-&gt;$method($source, $destination, $name)) ? $this-&gt;stat($path) : false) {
                if ($rmDir) {
                    $this-&gt;remove($source);
                }
            } else {
                return false;
            }
        } else {
            // copy/move from another volume
            if (!$this-&gt;options['copyTo'] || !$volume-&gt;copyFromAllowed()) {
                return $this-&gt;setError(elFinder::ERROR_COPY, $errpath, elFinder::ERROR_PERM_DENIED);
            }

            $this-&gt;error = array();
            if (($path = $this-&gt;copyFrom($volume, $src, $destination, $name)) == false) {
                return false;
            }

            if ($rmSrc &amp;&amp; !$this-&gt;error()) {
                if (!$volume-&gt;rm($src)) {
                    if ($volume-&gt;file($src)) {
                        $this-&gt;addError(elFinder::ERROR_RM_SRC);
                    } else {
                        $this-&gt;removed[] = $file;
                    }
                }
            }
            $res = $this-&gt;stat($path);
        }
        return $res;
    }

    /**
     * Return path info array to archive of target items
     *
     * @param  array $hashes
     *
     * @return array|false
     * @throws Exception
     * @author Naoki Sawada
     */
    public function zipdl($hashes)
    {
        if ($this-&gt;commandDisabled('zipdl')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        $archivers = $this-&gt;getArchivers();
        $cmd = null;
        if (!$archivers || empty($archivers['create'])) {
            return false;
        }
        $archivers = $archivers['create'];
        if (!$archivers) {
            return false;
        }
        $file = $mime = '';
        foreach (array('zip', 'tgz') as $ext) {
            $mime = $this-&gt;mimetype('file.' . $ext, true);
            if (isset($archivers[$mime])) {
                $cmd = $archivers[$mime];
                break;
            }
        }
        if (!$cmd) {
            $cmd = array_shift($archivers);
            if (!empty($ext)) {
                $mime = $this-&gt;mimetype('file.' . $ext, true);
            }
        }
        $ext = $cmd['ext'];
        $res = false;
        $mixed = false;
        $hashes = array_values($hashes);
        $dirname = dirname(str_replace($this-&gt;separator, DIRECTORY_SEPARATOR, $this-&gt;path($hashes[0])));
        $cnt = count($hashes);
        if ($cnt &gt; 1) {
            for ($i = 1; $i &lt; $cnt; $i++) {
                if ($dirname !== dirname(str_replace($this-&gt;separator, DIRECTORY_SEPARATOR, $this-&gt;path($hashes[$i])))) {
                    $mixed = true;
                    break;
                }
            }
        }
        if ($mixed || $this-&gt;root == $this-&gt;dirnameCE($this-&gt;decode($hashes[0]))) {
            $prefix = $this-&gt;rootName;
        } else {
            $prefix = basename($dirname);
        }
        if ($dir = $this-&gt;getItemsInHand($hashes)) {
            $tmppre = (substr(PHP_OS, 0, 3) === 'WIN') ? 'zd-' : 'elfzdl-';
            $pdir = dirname($dir);
            // garbage collection (expire 2h)
            register_shutdown_function(array('elFinder', 'GlobGC'), $pdir . DIRECTORY_SEPARATOR . $tmppre . '*', 7200);
            $files = self::localScandir($dir);
            if ($files &amp;&amp; ($arc = tempnam($dir, $tmppre))) {
                unlink($arc);
                $arc = $arc . '.' . $ext;
                $name = basename($arc);
                if ($arc = $this-&gt;makeArchive($dir, $files, $name, $cmd)) {
                    $file = tempnam($pdir, $tmppre);
                    unlink($file);
                    $res = rename($arc, $file);
                    $this-&gt;rmdirRecursive($dir);
                }
            }
        }
        return $res ? array('path' =&gt; $file, 'ext' =&gt; $ext, 'mime' =&gt; $mime, 'prefix' =&gt; $prefix) : false;
    }

    /**
     * Return file contents
     *
     * @param  string $hash file hash
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    public function getContents($hash)
    {
        $file = $this-&gt;file($hash);

        if (!$file) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        if ($file['mime'] == 'directory') {
            return $this-&gt;setError(elFinder::ERROR_NOT_FILE);
        }

        if (!$file['read']) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if ($this-&gt;getMaxSize &gt; 0 &amp;&amp; $file['size'] &gt; $this-&gt;getMaxSize) {
            return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_SIZE);
        }

        return $file['size'] ? $this-&gt;_getContents($this-&gt;convEncIn($this-&gt;decode($hash), true)) : '';
    }

    /**
     * Put content in text file and return file info.
     *
     * @param  string $hash    file hash
     * @param  string $content new file content
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    public function putContents($hash, $content)
    {
        if ($this-&gt;commandDisabled('edit')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        $path = $this-&gt;decode($hash);

        if (!($file = $this-&gt;file($hash))) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        if (!$file['write']) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        // check data cheme
        if (preg_match('~^\0data:(.+?/.+?);base64,~', $content, $m)) {
            $dMime = $m[1];
            if ($file['size'] &gt; 0 &amp;&amp; $dMime !== $file['mime']) {
                return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
            }
            $content = base64_decode(substr($content, strlen($m[0])));
        }

        // check MIME
        $name = $this-&gt;basenameCE($path);
        $mime = '';
        $mimeByName = $this-&gt;mimetype($name, true);
        if ($this-&gt;mimeDetect !== 'internal') {
            if ($tp = $this-&gt;tmpfile()) {
                fwrite($tp, $content);
                $info = stream_get_meta_data($tp);
                $filepath = $info['uri'];
                $mime = $this-&gt;mimetype($filepath, $name);
                fclose($tp);
            }
        }
        if (!$this-&gt;allowPutMime($mimeByName) || ($mime &amp;&amp; !$this-&gt;allowPutMime($mime))) {
            return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_MIME);
        }

        $this-&gt;clearcache();
        $res = false;
        if ($this-&gt;convEncOut($this-&gt;_filePutContents($this-&gt;convEncIn($path), $content))) {
            $this-&gt;rmTmb($file);
            $this-&gt;clearstatcache();
            $res = $this-&gt;stat($path);
        }
        return $res;
    }

    /**
     * Extract files from archive
     *
     * @param  string $hash archive hash
     * @param null    $makedir
     *
     * @return array|bool
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     */
    public function extract($hash, $makedir = null)
    {
        if ($this-&gt;commandDisabled('extract')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if (($file = $this-&gt;file($hash)) == false) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        $archiver = isset($this-&gt;archivers['extract'][$file['mime']])
            ? $this-&gt;archivers['extract'][$file['mime']]
            : array();

        if (!$archiver) {
            return $this-&gt;setError(elFinder::ERROR_NOT_ARCHIVE);
        }

        $path = $this-&gt;decode($hash);
        $parent = $this-&gt;stat($this-&gt;dirnameCE($path));

        if (!$file['read'] || !$parent['write']) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }
        $this-&gt;clearcache();
        $this-&gt;extractToNewdir = is_null($makedir) ? 'auto' : (bool)$makedir;

        if ($path = $this-&gt;convEncOut($this-&gt;_extract($this-&gt;convEncIn($path), $archiver))) {
            if (is_array($path)) {
                foreach ($path as $_k =&gt; $_p) {
                    $path[$_k] = $this-&gt;stat($_p);
                }
            } else {
                $path = $this-&gt;stat($path);
            }
            return $path;
        } else {
            return false;
        }
    }

    /**
     * Add files to archive
     *
     * @param        $hashes
     * @param        $mime
     * @param string $name
     *
     * @return array|bool
     * @throws Exception
     */
    public function archive($hashes, $mime, $name = '')
    {
        if ($this-&gt;commandDisabled('archive')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if ($name !== '' &amp;&amp; !$this-&gt;nameAccepted($name, false)) {
            return $this-&gt;setError(elFinder::ERROR_INVALID_NAME);
        }

        $archiver = isset($this-&gt;archivers['create'][$mime])
            ? $this-&gt;archivers['create'][$mime]
            : array();

        if (!$archiver) {
            return $this-&gt;setError(elFinder::ERROR_ARCHIVE_TYPE);
        }

        $files = array();
        $useRemoteArchive = !empty($this-&gt;options['useRemoteArchive']);

        $dir = '';
        foreach ($hashes as $hash) {
            if (($file = $this-&gt;file($hash)) == false) {
                return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND, '#' . $hash);
            }
            if (!$file['read']) {
                return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
            }
            $path = $this-&gt;decode($hash);
            if ($dir === '') {
                $dir = $this-&gt;dirnameCE($path);
                $stat = $this-&gt;stat($dir);
                if (!$stat['write']) {
                    return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
                }
            }

            $files[] = $useRemoteArchive ? $hash : $this-&gt;basenameCE($path);
        }

        if ($name === '') {
            $name = count($files) == 1 ? $files[0] : 'Archive';
        } else {
            $name = str_replace(array('/', '\\'), '_', preg_replace('/\.' . preg_quote($archiver['ext'], '/') . '$/i', '', $name));
        }
        $name .= '.' . $archiver['ext'];
        $name = $this-&gt;uniqueName($dir, $name, '');
        $this-&gt;clearcache();
        if ($useRemoteArchive) {
            return ($path = $this-&gt;remoteArchive($files, $name, $archiver)) ? $this-&gt;stat($path) : false;
        } else {
            return ($path = $this-&gt;convEncOut($this-&gt;_archive($this-&gt;convEncIn($dir), $this-&gt;convEncIn($files), $this-&gt;convEncIn($name), $archiver))) ? $this-&gt;stat($path) : false;
        }
    }

    /**
     * Create an archive from remote items
     *
     * @param      array  $hashes files hashes list
     * @param      string $name   archive name
     * @param      array  $arc    archiver options
     *
     * @return     string|boolean  path of created archive
     * @throws     Exception
     */
    protected function remoteArchive($hashes, $name, $arc)
    {
        $resPath = false;
        $file0 = $this-&gt;file($hashes[0]);
        if ($file0 &amp;&amp; ($dir = $this-&gt;getItemsInHand($hashes))) {
            $files = self::localScandir($dir);
            if ($files) {
                if ($arc = $this-&gt;makeArchive($dir, $files, $name, $arc)) {
                    if ($fp = fopen($arc, 'rb')) {
                        $fstat = stat($arc);
                        $stat = array(
                            'size' =&gt; $fstat['size'],
                            'ts' =&gt; $fstat['mtime'],
                            'mime' =&gt; $this-&gt;mimetype($arc, $name)
                        );
                        $path = $this-&gt;decode($file0['phash']);
                        $resPath = $this-&gt;saveCE($fp, $path, $name, $stat);
                        fclose($fp);
                    }
                }
            }
            $this-&gt;rmdirRecursive($dir);
        }
        return $resPath;
    }

    /**
     * Resize image
     *
     * @param  string $hash       image file
     * @param  int    $width      new width
     * @param  int    $height     new height
     * @param  int    $x          X start poistion for crop
     * @param  int    $y          Y start poistion for crop
     * @param  string $mode       action how to mainpulate image
     * @param  string $bg         background color
     * @param  int    $degree     rotete degree
     * @param  int    $jpgQuality JEPG quality (1-100)
     *
     * @return array|false
     * @throws ImagickException
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     * @author nao-pon
     * @author Troex Nevelin
     */
    public function resize($hash, $width, $height, $x, $y, $mode = 'resize', $bg = '', $degree = 0, $jpgQuality = null)
    {
        if ($this-&gt;commandDisabled('resize')) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if ($mode === 'rotate' &amp;&amp; $degree == 0) {
            return array('losslessRotate' =&gt; ($this-&gt;procExec(ELFINDER_EXIFTRAN_PATH . ' -h') === 0 || $this-&gt;procExec(ELFINDER_JPEGTRAN_PATH . ' -version') === 0));
        }

        if (($file = $this-&gt;file($hash)) == false) {
            return $this-&gt;setError(elFinder::ERROR_FILE_NOT_FOUND);
        }

        if (!$file['write'] || !$file['read']) {
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        $path = $this-&gt;decode($hash);

        $work_path = $this-&gt;getWorkFile($this-&gt;encoding ? $this-&gt;convEncIn($path, true) : $path);

        if (!$work_path || !is_writable($work_path)) {
            if ($work_path &amp;&amp; $path !== $work_path &amp;&amp; is_file($work_path)) {
                unlink($work_path);
            }
            return $this-&gt;setError(elFinder::ERROR_PERM_DENIED);
        }

        if ($this-&gt;imgLib !== 'imagick' &amp;&amp; $this-&gt;imgLib !== 'convert') {
            if (elFinder::isAnimationGif($work_path)) {
                return $this-&gt;setError(elFinder::ERROR_UNSUPPORT_TYPE);
            }
        }

        if (elFinder::isAnimationPng($work_path)) {
            return $this-&gt;setError(elFinder::ERROR_UNSUPPORT_TYPE);
        }

        switch ($mode) {

            case 'propresize':
                $result = $this-&gt;imgResize($work_path, $width, $height, true, true, null, $jpgQuality);
                break;

            case 'crop':
                $result = $this-&gt;imgCrop($work_path, $width, $height, $x, $y, null, $jpgQuality);
                break;

            case 'fitsquare':
                $result = $this-&gt;imgSquareFit($work_path, $width, $height, 'center', 'middle', ($bg ? $bg : $this-&gt;options['tmbBgColor']), null, $jpgQuality);
                break;

            case 'rotate':
                $result = $this-&gt;imgRotate($work_path, $degree, ($bg ? $bg : $this-&gt;options['bgColorFb']), null, $jpgQuality);
                break;

            default:
                $result = $this-&gt;imgResize($work_path, $width, $height, false, true, null, $jpgQuality);
                break;
        }

        $ret = false;
        if ($result) {
            $this-&gt;rmTmb($file);
            $this-&gt;clearstatcache();
            $fstat = stat($work_path);
            $imgsize = getimagesize($work_path);
            if ($path !== $work_path) {
                $file['size'] = $fstat['size'];
                $file['ts'] = $fstat['mtime'];
                if ($imgsize) {
                    $file['width'] = $imgsize[0];
                    $file['height'] = $imgsize[1];
                }
                if ($fp = fopen($work_path, 'rb')) {
                    $ret = $this-&gt;saveCE($fp, $this-&gt;dirnameCE($path), $this-&gt;basenameCE($path), $file);
                    fclose($fp);
                }
            } else {
                $ret = true;
            }
            if ($ret) {
                $this-&gt;clearcache();
                $ret = $this-&gt;stat($path);
                if ($imgsize) {
                    $ret['width'] = $imgsize[0];
                    $ret['height'] = $imgsize[1];
                }
            }
        }
        if ($path !== $work_path) {
            is_file($work_path) &amp;&amp; unlink($work_path);
        }

        return $ret;
    }

    /**
     * Remove file/dir
     *
     * @param  string $hash file hash
     *
     * @return bool
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function rm($hash)
    {
        return $this-&gt;commandDisabled('rm')
            ? $this-&gt;setError(elFinder::ERROR_PERM_DENIED)
            : $this-&gt;remove($this-&gt;decode($hash));
    }

    /**
     * Search files
     *
     * @param  string $q search string
     * @param  array  $mimes
     * @param null    $hash
     *
     * @return array
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    public function search($q, $mimes, $hash = null)
    {
        $res = array();
        $matchMethod = null;
        $args = func_get_args();
        if (!empty($args[3])) {
            $matchMethod = 'searchMatch' . $args[3];
            if (!is_callable(array($this, $matchMethod))) {
                return array();
            }
        }

        $dir = null;
        if ($hash) {
            $dir = $this-&gt;decode($hash);
            $stat = $this-&gt;stat($dir);
            if (!$stat || $stat['mime'] !== 'directory' || !$stat['read']) {
                $q = '';
            }
        }
        if ($mimes &amp;&amp; $this-&gt;onlyMimes) {
            $mimes = array_intersect($mimes, $this-&gt;onlyMimes);
            if (!$mimes) {
                $q = '';
            }
        }
        $this-&gt;searchStart = time();

        $qs = preg_split('/&quot;([^&quot;]+)&quot;| +/', $q, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
        $query = $excludes = array();
        foreach ($qs as $_q) {
            $_q = trim($_q);
            if ($_q !== '') {
                if ($_q[0] === '-') {
                    if (isset($_q[1])) {
                        $excludes[] = substr($_q, 1);
                    }
                } else {
                    $query[] = $_q;
                }
            }
        }
        if (!$query) {
            $q = '';
        } else {
            $q = join(' ', $query);
            $this-&gt;doSearchCurrentQuery = array(
                'q' =&gt; $q,
                'excludes' =&gt; $excludes,
                'matchMethod' =&gt; $matchMethod
            );
        }

        if ($q === '' || $this-&gt;commandDisabled('search')) {
            return $res;
        }

        // valided regex $this-&gt;options['searchExDirReg']
        if ($this-&gt;options['searchExDirReg']) {
            if (false === preg_match($this-&gt;options['searchExDirReg'], '')) {
                $this-&gt;options['searchExDirReg'] = '';
            }
        }

        // check the leaf root too
        if (!$mimes &amp;&amp; (is_null($dir) || $dir == $this-&gt;root)) {
            $rootStat = $this-&gt;stat($this-&gt;root);
            if (!empty($rootStat['phash'])) {
                if ($this-&gt;stripos($rootStat['name'], $q) !== false) {
                    $res = array($rootStat);
                }
            }
        }

        return array_merge($res, $this-&gt;doSearch(is_null($dir) ? $this-&gt;root : $dir, $q, $mimes));
    }

    /**
     * Return image dimensions
     *
     * @param  string $hash file hash
     *
     * @return array|string
     * @author Dmitry (dio) Levashov
     **/
    public function dimensions($hash)
    {
        if (($file = $this-&gt;file($hash)) == false) {
            return false;
        }
        // Throw additional parameters for some drivers
        if (func_num_args() &gt; 1) {
            $args = func_get_arg(1);
        } else {
            $args = array();
        }
        return $this-&gt;convEncOut($this-&gt;_dimensions($this-&gt;convEncIn($this-&gt;decode($hash)), $file['mime'], $args));
    }

    /**
     * Return has subdirs
     *
     * @param  string $hash file hash
     *
     * @return bool
     * @author Naoki Sawada
     **/
    public function subdirs($hash)
    {
        return (bool)$this-&gt;subdirsCE($this-&gt;decode($hash));
    }

    /**
     * Return content URL (for netmout volume driver)
     * If file.url == 1 requests from JavaScript client with XHR
     *
     * @param string $hash    file hash
     * @param array  $options options array
     *
     * @return boolean|string
     * @author Naoki Sawada
     */
    public function getContentUrl($hash, $options = array())
    {
        if (($file = $this-&gt;file($hash)) === false) {
            return false;
        }
        if (!empty($options['onetime']) &amp;&amp; $this-&gt;options['onetimeUrl']) {
            if (is_callable($this-&gt;options['onetimeUrl'])) {
                return call_user_func_array($this-&gt;options['onetimeUrl'], array($file, $options, $this));
            } else {
                $ret = false;
                if ($tmpdir = elFinder::getStaticVar('commonTempPath')) {
                    if ($source = $this-&gt;open($hash)) {
                        if ($_dat = tempnam($tmpdir, 'ELF')) {
                            $token = md5($_dat . session_id());
                            $dat = $tmpdir . DIRECTORY_SEPARATOR . 'ELF' . $token;
                            if (rename($_dat, $dat)) {
                                $info = stream_get_meta_data($source);
                                if (!empty($info['uri'])) {
                                    $tmp = $info['uri'];
                                } else {
                                    $tmp = tempnam($tmpdir, 'ELF');
                                    if ($dest = fopen($tmp, 'wb')) {
                                        if (!stream_copy_to_stream($source, $dest)) {
                                            $tmp = false;
                                        }
                                        fclose($dest);
                                    }
                                }
                                $this-&gt;close($source, $hash);
                                if ($tmp) {
                                    $info = array(
                                        'file' =&gt; base64_encode($tmp),
                                        'name' =&gt; $file['name'],
                                        'mime' =&gt; $file['mime'],
                                        'ts' =&gt; $file['ts']
                                    );
                                    if (file_put_contents($dat, json_encode($info))) {
                                        $conUrl = elFinder::getConnectorUrl();
                                        $ret = $conUrl . (strpos($conUrl, '?') !== false? '&amp;' : '?') . 'cmd=file&amp;onetime=1&amp;target=' . $token;

                                    }
                                }
                                if (!$ret) {
                                    unlink($dat);
                                }
                            } else {
                                unlink($_dat);
                            }
                        }
                    }
                }
                return $ret;
            }
        }
        if (empty($file['url']) &amp;&amp; $this-&gt;URL) {
            $path = str_replace($this-&gt;separator, '/', substr($this-&gt;decode($hash), strlen(rtrim($this-&gt;root, '/' . $this-&gt;separator)) + 1));
            if ($this-&gt;encoding) {
                $path = $this-&gt;convEncIn($path, true);
            }
            $path = str_replace('%2F', '/', rawurlencode($path));
            return $this-&gt;URL . $path;
        } else {
            $ret = false;
            if (!empty($file['url']) &amp;&amp; $file['url'] != 1) {
                return $file['url'];
            } else if (!empty($options['temporary']) &amp;&amp; ($tempInfo = $this-&gt;getTempLinkInfo('temp_' . md5($hash . session_id())))) {
                if (is_readable($tempInfo['path'])) {
                    touch($tempInfo['path']);
                    $ret = $tempInfo['url'] . '?' . rawurlencode($file['name']);
                } else if ($source = $this-&gt;open($hash)) {
                    if ($dest = fopen($tempInfo['path'], 'wb')) {
                        if (stream_copy_to_stream($source, $dest)) {
                            $ret = $tempInfo['url'] . '?' . rawurlencode($file['name']);
                        }
                        fclose($dest);
                    }
                    $this-&gt;close($source, $hash);
                }
            }
            return $ret;
        }
    }

    /**
     * Get temporary contents link infomation
     *
     * @param string $name
     *
     * @return boolean|array
     * @author Naoki Sawada
     */
    public function getTempLinkInfo($name = null)
    {
        if ($this-&gt;tmpLinkPath) {
            if (!$name) {
                $name = 'temp_' . md5($_SERVER['REMOTE_ADDR'] . (string)microtime(true));
            } else if (substr($name, 0, 5) !== 'temp_') {
                $name = 'temp_' . $name;
            }
            register_shutdown_function(array('elFinder', 'GlobGC'), $this-&gt;tmpLinkPath . DIRECTORY_SEPARATOR . 'temp_*', elFinder::$tmpLinkLifeTime);
            return array(
                'path' =&gt; $path = $this-&gt;tmpLinkPath . DIRECTORY_SEPARATOR . $name,
                'url' =&gt; $this-&gt;tmpLinkUrl . '/' . rawurlencode($name)
            );
        }
        return false;
    }

    /**
     * Get URL of substitute image by request args `substitute` or 4th argument $maxSize
     *
     * @param string   $target  Target hash
     * @param array    $srcSize Size info array [width, height]
     * @param resource $srcfp   Source file file pointer
     * @param integer  $maxSize Maximum pixel of substitute image
     *
     * @return boolean
     * @throws ImagickException
     * @throws elFinderAbortException
     */
    public function getSubstituteImgLink($target, $srcSize, $srcfp = null, $maxSize = null)
    {
        $url = false;
        $file = $this-&gt;file($target);
        $force = !in_array($file['mime'], array('image/jpeg', 'image/png', 'image/gif'));
        if (!$maxSize) {
            $args = elFinder::$currentArgs;
            if (!empty($args['substitute'])) {
                $maxSize = $args['substitute'];
            }
        }
        if ($maxSize &amp;&amp; $srcSize[0] &amp;&amp; $srcSize[1]) {
            if ($this-&gt;getOption('substituteImg')) {
                $maxSize = intval($maxSize);
                $zoom = min(($maxSize / $srcSize[0]), ($maxSize / $srcSize[1]));
                if ($force || $zoom &lt; 1) {
                    $width = round($srcSize[0] * $zoom);
                    $height = round($srcSize[1] * $zoom);
                    $jpgQuality = 50;
                    $preserveExif = false;
                    $unenlarge = true;
                    $checkAnimated = true;
                    $destformat = $file['mime'] === 'image/jpeg'? null : 'png';
                    if (!$srcfp) {
                        elFinder::checkAborted();
                        $srcfp = $this-&gt;open($target);
                    }
                    if ($srcfp &amp;&amp; ($tempLink = $this-&gt;getTempLinkInfo())) {
                        elFinder::checkAborted();
                        $dest = fopen($tempLink['path'], 'wb');
                        if ($dest &amp;&amp; stream_copy_to_stream($srcfp, $dest)) {
                            fclose($dest);
                            if ($this-&gt;imageUtil('resize', $tempLink['path'], compact('width', 'height', 'jpgQuality', 'preserveExif', 'unenlarge', 'checkAnimated', 'destformat'))) {
                                $url = $tempLink['url'];
                                // set expire to 1 min left
                                touch($tempLink['path'], time() - elFinder::$tmpLinkLifeTime + 60);
                            } else {
                                unlink($tempLink['path']);
                            }
                        }
                        $this-&gt;close($srcfp, $target);
                    }
                }
            }
        }

        return $url;
    }

    /**
     * Return temp path
     *
     * @return string
     * @author Naoki Sawada
     */
    public function getTempPath()
    {
        $tempPath = null;
        if (isset($this-&gt;tmpPath) &amp;&amp; $this-&gt;tmpPath &amp;&amp; is_writable($this-&gt;tmpPath)) {
            $tempPath = $this-&gt;tmpPath;
        } else if (isset($this-&gt;tmp) &amp;&amp; $this-&gt;tmp &amp;&amp; is_writable($this-&gt;tmp)) {
            $tempPath = $this-&gt;tmp;
        } else if (elFinder::getStaticVar('commonTempPath') &amp;&amp; is_writable(elFinder::getStaticVar('commonTempPath'))) {
            $tempPath = elFinder::getStaticVar('commonTempPath');
        } else if (function_exists('sys_get_temp_dir')) {
            $tempPath = sys_get_temp_dir();
        } else if ($this-&gt;tmbPathWritable) {
            $tempPath = $this-&gt;tmbPath;
        }
        if ($tempPath &amp;&amp; DIRECTORY_SEPARATOR !== '/') {
            $tempPath = str_replace('/', DIRECTORY_SEPARATOR, $tempPath);
        }
		if(opendir($tempPath)){
			return $tempPath;
		} else if (defined( 'WP_TEMP_DIR' )) {
			return get_temp_dir();
		} else {
			$custom_temp_path = WP_CONTENT_DIR.'/temp';
			if (!is_dir($custom_temp_path)) {
				mkdir($custom_temp_path, 0777, true);
			}
			return $custom_temp_path;
		}
    }

    /**
     * (Make &amp;) Get upload taget dirctory hash
     *
     * @param string $baseTargetHash
     * @param string $path
     * @param array  $result
     *
     * @return boolean|string
     * @author Naoki Sawada
     */
    public function getUploadTaget($baseTargetHash, $path, &amp; $result)
    {
        $base = $this-&gt;decode($baseTargetHash);
        $targetHash = $baseTargetHash;
        $path = ltrim($path, $this-&gt;separator);
        $dirs = explode($this-&gt;separator, $path);
        array_pop($dirs);
        foreach ($dirs as $dir) {
            $targetPath = $this-&gt;joinPathCE($base, $dir);
            if (!$_realpath = $this-&gt;realpath($this-&gt;encode($targetPath))) {
                if ($stat = $this-&gt;mkdir($targetHash, $dir)) {
                    $result['added'][] = $stat;
                    $targetHash = $stat['hash'];
                    $base = $this-&gt;decode($targetHash);
                } else {
                    return false;
                }
            } else {
                $targetHash = $this-&gt;encode($_realpath);
                if ($this-&gt;dir($targetHash)) {
                    $base = $this-&gt;decode($targetHash);
                } else {
                    return false;
                }
            }
        }
        return $targetHash;
    }

    /**
     * Return this uploadMaxSize value
     *
     * @return integer
     * @author Naoki Sawada
     */
    public function getUploadMaxSize()
    {
        return $this-&gt;uploadMaxSize;
    }

    public function setUploadOverwrite($var)
    {
        $this-&gt;uploadOverwrite = (bool)$var;
    }

    /**
     * Image file utility
     *
     * @param string $mode    'resize', 'rotate', 'propresize', 'crop', 'fitsquare'
     * @param string $src     Image file local path
     * @param array  $options excute options
     *
     * @return bool
     * @throws ImagickException
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    public function imageUtil($mode, $src, $options = array())
    {
        if (!isset($options['jpgQuality'])) {
            $options['jpgQuality'] = intval($this-&gt;options['jpgQuality']);
        }
        if (!isset($options['bgcolor'])) {
            $options['bgcolor'] = '#ffffff';
        }
        if (!isset($options['bgColorFb'])) {
            $options['bgColorFb'] = $this-&gt;options['bgColorFb'];
        }
        $destformat = !empty($options['destformat'])? $options['destformat'] : null;

        // check 'width' ,'height'
        if (in_array($mode, array('resize', 'propresize', 'crop', 'fitsquare'))) {
            if (empty($options['width']) || empty($options['height'])) {
                return false;
            }
        }

        if (!empty($options['checkAnimated'])) {
            if ($this-&gt;imgLib !== 'imagick' &amp;&amp; $this-&gt;imgLib !== 'convert') {
                if (elFinder::isAnimationGif($src)) {
                    return false;
                }
            }
            if (elFinder::isAnimationPng($src)) {
                return false;
            }
        }

        switch ($mode) {
            case 'rotate':
                if (empty($options['degree'])) {
                    return true;
                }
                return (bool)$this-&gt;imgRotate($src, $options['degree'], $options['bgColorFb'], $destformat, $options['jpgQuality']);

            case 'resize':
                return (bool)$this-&gt;imgResize($src, $options['width'], $options['height'], false, true, $destformat, $options['jpgQuality'], $options);

            case 'propresize':
                return (bool)$this-&gt;imgResize($src, $options['width'], $options['height'], true, true, $destformat, $options['jpgQuality'], $options);

            case 'crop':
                if (isset($options['x']) &amp;&amp; isset($options['y'])) {
                    return (bool)$this-&gt;imgCrop($src, $options['width'], $options['height'], $options['x'], $options['y'], $destformat, $options['jpgQuality']);
                }
                break;

            case 'fitsquare':
                return (bool)$this-&gt;imgSquareFit($src, $options['width'], $options['height'], 'center', 'middle', $options['bgcolor'], $destformat, $options['jpgQuality']);

        }
        return false;
    }

    /**
     * Convert Video To Image by ffmpeg
     *
     * @param  string $file video source file path
     * @param  array  $stat file stat array
     * @param  object $self volume driver object
     * @param  int    $ss   start seconds
     *
     * @return bool
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    public function ffmpegToImg($file, $stat, $self, $ss = null)
    {
        $name = basename($file);
        $path = dirname($file);
        $tmp = $path . DIRECTORY_SEPARATOR . md5($name);
        // register auto delete on shutdown
        $GLOBALS['elFinderTempFiles'][$tmp] = true;
        if (rename($file, $tmp)) {
            if ($ss === null) {
                // specific start time by file name (xxx^[sec].[extention] - video^3.mp4)
                if (preg_match('/\^(\d+(?:\.\d+)?)\.[^.]+$/', $stat['name'], $_m)) {
                    $ss = $_m[1];
                } else {
                    $ss = $this-&gt;options['tmbVideoConvSec'];
                }
            }
            $cmd = sprintf(ELFINDER_FFMPEG_PATH . ' -i %s -ss 00:00:%.3f -vframes 1 -f image2 -- %s', escapeshellarg($tmp), $ss, escapeshellarg($file));
            $r = ($this-&gt;procExec($cmd) === 0);
            clearstatcache();
            if ($r &amp;&amp; $ss &gt; 0 &amp;&amp; !file_exists($file)) {
                // Retry by half of $ss
                $ss = max(intval($ss / 2), 0);
                rename($tmp, $file);
                $r = $this-&gt;ffmpegToImg($file, $stat, $self, $ss);
            } else {
                unlink($tmp);
            }
            return $r;
        }
        return false;
    }

    /**
     * Creates a temporary file and return file pointer
     *
     * @return resource|boolean
     */
    public function tmpfile()
    {
        if ($tmp = $this-&gt;getTempFile()) {
            return fopen($tmp, 'wb');
        }
        return false;
    }

    /**
     * Save error message
     *
     * @param  array  error
     *
     * @return boolean false
     * @author Naoki Sawada
     **/
    protected function setError()
    {
        $this-&gt;error = array();
        $this-&gt;addError(func_get_args());
        return false;
    }

    /**
     * Add error message
     *
     * @param  array  error
     *
     * @return false
     * @author Dmitry(dio) Levashov
     **/
    protected function addError()
    {
        foreach (func_get_args() as $err) {
            if (is_array($err)) {
                foreach($err as $er) {
                    $this-&gt;addError($er);
                }
            } else {
                $this-&gt;error[] = (string)$err;
            }
        }
        return false;
    }

    /*********************************************************************/
    /*                               FS API                              */
    /*********************************************************************/

    /***************** server encoding support *******************/

    /**
     * Return parent directory path (with convert encoding)
     *
     * @param  string $path file path
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function dirnameCE($path)
    {
        $dirname = (!$this-&gt;encoding) ? $this-&gt;_dirname($path) : $this-&gt;convEncOut($this-&gt;_dirname($this-&gt;convEncIn($path)));
        // check to infinite loop prevention
        return ($dirname != $path) ? $dirname : '';
    }

    /**
     * Return file name (with convert encoding)
     *
     * @param  string $path file path
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function basenameCE($path)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_basename($path) : $this-&gt;convEncOut($this-&gt;_basename($this-&gt;convEncIn($path)));
    }

    /**
     * Join dir name and file name and return full path. (with convert encoding)
     * Some drivers (db) use int as path - so we give to concat path to driver itself
     *
     * @param  string $dir  dir path
     * @param  string $name file name
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function joinPathCE($dir, $name)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_joinPath($dir, $name) : $this-&gt;convEncOut($this-&gt;_joinPath($this-&gt;convEncIn($dir), $this-&gt;convEncIn($name)));
    }

    /**
     * Return normalized path (with convert encoding)
     *
     * @param  string $path file path
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function normpathCE($path)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_normpath($path) : $this-&gt;convEncOut($this-&gt;_normpath($this-&gt;convEncIn($path)));
    }

    /**
     * Return file path related to root dir (with convert encoding)
     *
     * @param  string $path file path
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function relpathCE($path)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_relpath($path) : $this-&gt;convEncOut($this-&gt;_relpath($this-&gt;convEncIn($path)));
    }

    /**
     * Convert path related to root dir into real path (with convert encoding)
     *
     * @param  string $path rel file path
     *
     * @return string
     * @author Naoki Sawada
     **/
    protected function abspathCE($path)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_abspath($path) : $this-&gt;convEncOut($this-&gt;_abspath($this-&gt;convEncIn($path)));
    }

    /**
     * Return true if $path is children of $parent (with convert encoding)
     *
     * @param  string $path   path to check
     * @param  string $parent parent path
     *
     * @return bool
     * @author Naoki Sawada
     **/
    protected function inpathCE($path, $parent)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_inpath($path, $parent) : $this-&gt;convEncOut($this-&gt;_inpath($this-&gt;convEncIn($path), $this-&gt;convEncIn($parent)));
    }

    /**
     * Open file and return file pointer (with convert encoding)
     *
     * @param  string $path file path
     * @param string  $mode
     *
     * @return false|resource
     * @internal param bool $write open file for writing
     * @author   Naoki Sawada
     */
    protected function fopenCE($path, $mode = 'rb')
    {
        // check extra option for network stream pointer
        if (func_num_args() &gt; 2) {
            $opts = func_get_arg(2);
        } else {
            $opts = array();
        }
        return (!$this-&gt;encoding) ? $this-&gt;_fopen($path, $mode, $opts) : $this-&gt;convEncOut($this-&gt;_fopen($this-&gt;convEncIn($path), $mode, $opts));
    }

    /**
     * Close opened file (with convert encoding)
     *
     * @param  resource $fp   file pointer
     * @param  string   $path file path
     *
     * @return bool
     * @author Naoki Sawada
     **/
    protected function fcloseCE($fp, $path = '')
    {
        return (!$this-&gt;encoding) ? $this-&gt;_fclose($fp, $path) : $this-&gt;convEncOut($this-&gt;_fclose($fp, $this-&gt;convEncIn($path)));
    }

    /**
     * Create new file and write into it from file pointer. (with convert encoding)
     * Return new file path or false on error.
     *
     * @param  resource $fp   file pointer
     * @param  string   $dir  target dir path
     * @param  string   $name file name
     * @param  array    $stat file stat (required by some virtual fs)
     *
     * @return bool|string
     * @author Naoki Sawada
     **/
    protected function saveCE($fp, $dir, $name, $stat)
    {
        $res = (!$this-&gt;encoding) ? $this-&gt;_save($fp, $dir, $name, $stat) : $this-&gt;convEncOut($this-&gt;_save($fp, $this-&gt;convEncIn($dir), $this-&gt;convEncIn($name), $this-&gt;convEncIn($stat)));
        if ($res !== false) {
            $this-&gt;clearstatcache();
        }
        return $res;
    }

    /**
     * Return true if path is dir and has at least one childs directory (with convert encoding)
     *
     * @param  string $path dir path
     *
     * @return bool
     * @author Naoki Sawada
     **/
    protected function subdirsCE($path)
    {
        if ($this-&gt;sessionCaching['subdirs']) {
            if (isset($this-&gt;sessionCache['subdirs'][$path]) &amp;&amp; !$this-&gt;isMyReload()) {
                return $this-&gt;sessionCache['subdirs'][$path];
            }
        }
        $hasdir = (bool)((!$this-&gt;encoding) ? $this-&gt;_subdirs($path) : $this-&gt;convEncOut($this-&gt;_subdirs($this-&gt;convEncIn($path))));
        $this-&gt;updateSubdirsCache($path, $hasdir);
        return $hasdir;
    }

    /**
     * Return files list in directory (with convert encoding)
     *
     * @param  string $path dir path
     *
     * @return array
     * @author Naoki Sawada
     **/
    protected function scandirCE($path)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_scandir($path) : $this-&gt;convEncOut($this-&gt;_scandir($this-&gt;convEncIn($path)));
    }

    /**
     * Create symlink (with convert encoding)
     *
     * @param  string $source    file to link to
     * @param  string $targetDir folder to create link in
     * @param  string $name      symlink name
     *
     * @return bool
     * @author Naoki Sawada
     **/
    protected function symlinkCE($source, $targetDir, $name)
    {
        return (!$this-&gt;encoding) ? $this-&gt;_symlink($source, $targetDir, $name) : $this-&gt;convEncOut($this-&gt;_symlink($this-&gt;convEncIn($source), $this-&gt;convEncIn($targetDir), $this-&gt;convEncIn($name)));
    }

    /***************** paths *******************/

    /**
     * Encode path into hash
     *
     * @param  string  file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     * @author Troex Nevelin
     **/
    protected function encode($path)
    {
        if ($path !== '') {

            // cut ROOT from $path for security reason, even if hacker decodes the path he will not know the root
            $p = $this-&gt;relpathCE($path);
            // if reqesting root dir $path will be empty, then assign '/' as we cannot leave it blank for crypt
            if ($p === '') {
                $p = $this-&gt;separator;
            }
            // change separator
            if ($this-&gt;separatorForHash) {
                $p = str_replace($this-&gt;separator, $this-&gt;separatorForHash, $p);
            }
            // TODO crypt path and return hash
            $hash = $this-&gt;crypt($p);
            // hash is used as id in HTML that means it must contain vaild chars
            // make base64 html safe and append prefix in begining
            $hash = strtr(base64_encode($hash), '+/=', '-_.');
            // remove dots '.' at the end, before it was '=' in base64
            $hash = rtrim($hash, '.');
            // append volume id to make hash unique
            return $this-&gt;id . $hash;
        }
        //TODO: Add return statement here
    }

    /**
     * Decode path from hash
     *
     * @param  string  file hash
     *
     * @return string
     * @author Dmitry (dio) Levashov
     * @author Troex Nevelin
     **/
    protected function decode($hash)
    {
        if (strpos($hash, $this-&gt;id) === 0) {
            // cut volume id after it was prepended in encode
            $h = substr($hash, strlen($this-&gt;id));
            // replace HTML safe base64 to normal
            $h = base64_decode(strtr($h, '-_.', '+/='));
            // TODO uncrypt hash and return path
            $path = $this-&gt;uncrypt($h);
            // change separator
            if ($this-&gt;separatorForHash) {
                $path = str_replace($this-&gt;separatorForHash, $this-&gt;separator, $path);
            }
            // append ROOT to path after it was cut in encode
            return $this-&gt;abspathCE($path);//$this-&gt;root.($path === $this-&gt;separator ? '' : $this-&gt;separator.$path);
        }
        return '';
    }

    /**
     * Return crypted path
     * Not implemented
     *
     * @param  string  path
     *
     * @return mixed
     * @author Dmitry (dio) Levashov
     **/
    protected function crypt($path)
    {
        return $path;
    }

    /**
     * Return uncrypted path
     * Not implemented
     *
     * @param  mixed  hash
     *
     * @return mixed
     * @author Dmitry (dio) Levashov
     **/
    protected function uncrypt($hash)
    {
        return $hash;
    }

    /**
     * Validate file name based on $this-&gt;options['acceptedName'] regexp or function
     *
     * @param  string $name file name
     * @param  bool   $isDir
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     */
    protected function nameAccepted($name, $isDir = false)
    {
        if (json_encode($name) === false) {
            return false;
        }
        $nameValidator = $isDir ? $this-&gt;dirnameValidator : $this-&gt;nameValidator;
        if ($nameValidator) {
            if (is_callable($nameValidator)) {
                $res = call_user_func($nameValidator, $name);
                return $res;
            }
            if (preg_match($nameValidator, '') !== false) {
                return preg_match($nameValidator, $name);
            }
        }
        return true;
    }

    /**
     * Return session rootstat cache key
     *
     * @return string
     */
    protected function getRootstatCachekey()
    {
        return md5($this-&gt;root . (isset($this-&gt;options['alias']) ? $this-&gt;options['alias'] : ''));
    }

    /**
     * Return new unique name based on file name and suffix
     *
     * @param         $dir
     * @param         $name
     * @param  string $suffix suffix append to name
     * @param bool    $checkNum
     * @param int     $start
     *
     * @return string
     * @internal param string $path file path
     * @author   Dmitry (dio) Levashov
     */
    public function uniqueName($dir, $name, $suffix = ' copy', $checkNum = true, $start = 1)
    {
        static $lasts = null;

        if ($lasts === null) {
            $lasts = array();
        }

        $ext = '';

        $splits = elFinder::splitFileExtention($name);
        if ($splits[1]) {
            $ext = '.' . $splits[1];
            $name = $splits[0];
        }

        if ($checkNum &amp;&amp; preg_match('/(' . preg_quote($suffix, '/') . ')(\d*)$/i', $name, $m)) {
            $i = $m[2];
            $name = substr($name, 0, strlen($name) - strlen($m[2]));
        } else {
            $i = $start;
            $name .= $suffix;
        }
        $max = (int)$i + 100000;

        if (isset($lasts[$name])) {
            $i = max($i, $lasts[$name]);
        }

        while ($i &lt;= $max) {
            $n = $name . ($i &gt;= 0 ? $i : '') . $ext;
            if (!$this-&gt;isNameExists($this-&gt;joinPathCE($dir, $n))) {
                $this-&gt;clearcache();
                $lasts[$name] = ++$i;
                return $n;
            }
            $i++;
        }
        return $name . md5($dir) . $ext;
    }

    /**
     * Converts character encoding from UTF-8 to server's one
     *
     * @param  mixed  $var           target string or array var
     * @param  bool   $restoreLocale do retore global locale, default is false
     * @param  string $unknown       replaces character for unknown
     *
     * @return mixed
     * @author Naoki Sawada
     */
    public function convEncIn($var = null, $restoreLocale = false, $unknown = '_')
    {
        return (!$this-&gt;encoding) ? $var : $this-&gt;convEnc($var, 'UTF-8', $this-&gt;encoding, $this-&gt;options['locale'], $restoreLocale, $unknown);
    }

    /**
     * Converts character encoding from server's one to UTF-8
     *
     * @param  mixed  $var           target string or array var
     * @param  bool   $restoreLocale do retore global locale, default is true
     * @param  string $unknown       replaces character for unknown
     *
     * @return mixed
     * @author Naoki Sawada
     */
    public function convEncOut($var = null, $restoreLocale = true, $unknown = '_')
    {
        return (!$this-&gt;encoding) ? $var : $this-&gt;convEnc($var, $this-&gt;encoding, 'UTF-8', $this-&gt;options['locale'], $restoreLocale, $unknown);
    }

    /**
     * Converts character encoding (base function)
     *
     * @param  mixed  $var     target string or array var
     * @param  string $from    from character encoding
     * @param  string $to      to character encoding
     * @param  string $locale  local locale
     * @param         $restoreLocale
     * @param  string $unknown replaces character for unknown
     *
     * @return mixed
     */
    protected function convEnc($var, $from, $to, $locale, $restoreLocale, $unknown = '_')
    {
        if (strtoupper($from) !== strtoupper($to)) {
            if ($locale) {
                setlocale(LC_ALL, $locale);
            }
            if (is_array($var)) {
                $_ret = array();
                foreach ($var as $_k =&gt; $_v) {
                    $_ret[$_k] = $this-&gt;convEnc($_v, $from, $to, '', false, $unknown = '_');
                }
                $var = $_ret;
            } else {
                $_var = false;
                if (is_string($var)) {
                    $_var = $var;
                    $errlev = error_reporting();
                    error_reporting($errlev ^ E_NOTICE);
                    if (false !== ($_var = iconv($from, $to . '//TRANSLIT', $_var))) {
                        $_var = str_replace('?', $unknown, $_var);
                    }
                    error_reporting($errlev);
                }
                if ($_var !== false) {
                    $var = $_var;
                }
            }
            if ($restoreLocale) {
                setlocale(LC_ALL, elFinder::$locale);
            }
        }
        return $var;
    }

    /**
     * Normalize MIME-Type by options['mimeMap']
     *
     * @param      string $type MIME-Type
     * @param      string $name Filename
     * @param      string $ext  File extention without first dot (optional)
     *
     * @return     string  Normalized MIME-Type
     */
    public function mimeTypeNormalize($type, $name, $ext = '')
    {
        if ($ext === '') {
            $ext = (false === $pos = strrpos($name, '.')) ? '' : substr($name, $pos + 1);
        }
        $_checkKey = strtolower($ext . ':' . $type);
        if ($type === '') {
            $_keylen = strlen($_checkKey);
            foreach ($this-&gt;options['mimeMap'] as $_key =&gt; $_type) {
                if (substr($_key, 0, $_keylen) === $_checkKey) {
                    $type = $_type;
                    break;
                }
            }
        } else if (isset($this-&gt;options['mimeMap'][$_checkKey])) {
            $type = $this-&gt;options['mimeMap'][$_checkKey];
        } else {
            $_checkKey = strtolower($ext . ':*');
            if (isset($this-&gt;options['mimeMap'][$_checkKey])) {
                $type = $this-&gt;options['mimeMap'][$_checkKey];
            } else {
                $_checkKey = strtolower('*:' . $type);
                if (isset($this-&gt;options['mimeMap'][$_checkKey])) {
                    $type = $this-&gt;options['mimeMap'][$_checkKey];
                }
            }
        }
        return $type;
    }

    /*********************** util mainly for inheritance class *********************/

    /**
     * Get temporary filename. Tempfile will be removed when after script execution finishes or exit() is called.
     * When needing the unique file to a path, give $path to parameter.
     *
     * @param  string $path for get unique file to a path
     *
     * @return string|false
     * @author Naoki Sawada
     */
    protected function getTempFile($path = '')
    {
        static $cache = array();

        $key = '';
        if ($path !== '') {
            $key = $this-&gt;id . '#' . $path;
            if (isset($cache[$key])) {
                return $cache[$key];
            }
        }

        if ($tmpdir = $this-&gt;getTempPath()) {
            $name = tempnam($tmpdir, 'ELF');
            if ($key) {
                $cache[$key] = $name;
            }
            // register auto delete on shutdown
            $GLOBALS['elFinderTempFiles'][$name] = true;
            return $name;
        }

        return false;
    }

    /**
     * File path of local server side work file path
     *
     * @param  string $path path need convert encoding to server encoding
     *
     * @return string
     * @author Naoki Sawada
     */
    protected function getWorkFile($path)
    {
        if ($wfp = $this-&gt;tmpfile()) {
            if ($fp = $this-&gt;_fopen($path)) {
                while (!feof($fp)) {
                    fwrite($wfp, fread($fp, 8192));
                }
                $info = stream_get_meta_data($wfp);
                fclose($wfp);
                if ($info &amp;&amp; !empty($info['uri'])) {
                    return $info['uri'];
                }
            }
        }
        return false;
    }

    /**
     * Get image size array with `dimensions`
     *
     * @param string $path path need convert encoding to server encoding
     * @param string $mime file mime type
     *
     * @return array|false
     * @throws ImagickException
     * @throws elFinderAbortException
     */
    public function getImageSize($path, $mime = '')
    {
        $size = false;
        if ($mime === '' || strtolower(substr($mime, 0, 5)) === 'image') {
            if ($work = $this-&gt;getWorkFile($path)) {
                if ($size = getimagesize($work)) {
                    $size['dimensions'] = $size[0] . 'x' . $size[1];
                    $srcfp = fopen($work, 'rb');
                    $cArgs = elFinder::$currentArgs;
                    if (!empty($cArgs['target']) &amp;&amp; $subImgLink = $this-&gt;getSubstituteImgLink($cArgs['target'], $size, $srcfp)) {
                        $size['url'] = $subImgLink;
                    }
                }
            }
            is_file($work) &amp;&amp; unlink($work);
        }
        return $size;
    }

    /**
     * Delete dirctory trees
     *
     * @param string $localpath path need convert encoding to server encoding
     *
     * @return boolean
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    protected function delTree($localpath)
    {
        foreach ($this-&gt;_scandir($localpath) as $p) {
            elFinder::checkAborted();
            $stat = $this-&gt;stat($this-&gt;convEncOut($p));
            $this-&gt;convEncIn();
            ($stat['mime'] === 'directory') ? $this-&gt;delTree($p) : $this-&gt;_unlink($p);
        }
        $res = $this-&gt;_rmdir($localpath);
        $res &amp;&amp; $this-&gt;clearstatcache();
        return $res;
    }

    /**
     * Copy items to a new temporary directory on the local server
     *
     * @param  array  $hashes  target hashes
     * @param  string $dir     destination directory (for recurcive)
     * @param  string $canLink it can use link() (for recurcive)
     *
     * @return string|false    saved path name
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    protected function getItemsInHand($hashes, $dir = null, $canLink = null)
    {
        static $banChrs = null;
        static $totalSize = 0;

        if  (is_null($banChrs)) {
            $banChrs = DIRECTORY_SEPARATOR !== '/'? array('\\', '/', ':', '*', '?', '&quot;', '&lt;', '&gt;', '|') : array('\\', '/');
        }

        if (is_null($dir)) {
            $totalSize = 0;
            if (!$tmpDir = $this-&gt;getTempPath()) {
                return false;
            }
            $dir = tempnam($tmpDir, 'elf');
            if (!unlink($dir) || !mkdir($dir, 0700, true)) {
                return false;
            }
            register_shutdown_function(array($this, 'rmdirRecursive'), $dir);
        }
        if (is_null($canLink)) {
            $canLink = ($this instanceof elFinderVolumeLocalFileSystem);
        }
        elFinder::checkAborted();
        $res = true;
        $files = array();
        foreach ($hashes as $hash) {
            if (($file = $this-&gt;file($hash)) == false) {
                continue;
            }
            if (!$file['read']) {
                continue;
            }

            $name = $file['name'];
            // remove ctrl characters
            $name = preg_replace('/[[:cntrl:]]+/', '', $name);
            // replace ban characters
            $name = str_replace($banChrs, '_', $name);

            // for call from search results
            if (isset($files[$name])) {
                $name = preg_replace('/^(.*?)(\..*)?$/', '$1_' . $files[$name]++ . '$2', $name);
            } else {
                $files[$name] = 1;
            }
            $target = $dir . DIRECTORY_SEPARATOR . $name;

            if ($file['mime'] === 'directory') {
                $chashes = array();
                $_files = $this-&gt;scandir($hash);
                foreach ($_files as $_file) {
                    if ($file['read']) {
                        $chashes[] = $_file['hash'];
                    }
                }
                if (($res = mkdir($target, 0700, true)) &amp;&amp; $chashes) {
                    $res = $this-&gt;getItemsInHand($chashes, $target, $canLink);
                }
                if (!$res) {
                    break;
                }
                !empty($file['ts']) &amp;&amp; touch($target, $file['ts']);
            } else {
                $path = $this-&gt;decode($hash);
                if (!$canLink || !($canLink = $this-&gt;localFileSystemSymlink($path, $target))) {
                    if (file_exists($target)) {
                        unlink($target);
                    }
                    if ($fp = $this-&gt;fopenCE($path)) {
                        if ($tfp = fopen($target, 'wb')) {
                            $totalSize += stream_copy_to_stream($fp, $tfp);
                            fclose($tfp);
                        }
                        !empty($file['ts']) &amp;&amp; touch($target, $file['ts']);
                        $this-&gt;fcloseCE($fp, $path);
                    }
                } else {
                    $totalSize += filesize($path);
                }
                if ($this-&gt;options['maxArcFilesSize'] &gt; 0 &amp;&amp; $this-&gt;options['maxArcFilesSize'] &lt; $totalSize) {
                    $res = $this-&gt;setError(elFinder::ERROR_ARC_MAXSIZE);
                }
            }
        }
        return $res ? $dir : false;
    }

    /*********************** file stat *********************/

    /**
     * Check file attribute
     *
     * @param  string $path  file path
     * @param  string $name  attribute name (read|write|locked|hidden)
     * @param  bool   $val   attribute value returned by file system
     * @param  bool   $isDir path is directory (true: directory, false: file)
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function attr($path, $name, $val = null, $isDir = null)
    {
        if (!isset($this-&gt;defaults[$name])) {
            return false;
        }

        $relpath = $this-&gt;relpathCE($path);
        if ($this-&gt;separator !== '/') {
            $relpath = str_replace($this-&gt;separator, '/', $relpath);
        }
        $relpath = '/' . $relpath;

        $perm = null;

        if ($this-&gt;access) {
            $perm = call_user_func($this-&gt;access, $name, $path, $this-&gt;options['accessControlData'], $this, $isDir, $relpath);
            if ($perm !== null) {
                return !!$perm;
            }
        }

        foreach ($this-&gt;attributes as $attrs) {
            if (isset($attrs[$name]) &amp;&amp; isset($attrs['pattern']) &amp;&amp; preg_match($attrs['pattern'], $relpath)) {
                $perm = $attrs[$name];
                break;
            }
        }

        return $perm === null ? (is_null($val) ? $this-&gt;defaults[$name] : $val) : !!$perm;
    }

    /**
     * Return true if file with given name can be created in given folder.
     *
     * @param string $dir  parent dir path
     * @param string $name new file name
     * @param null   $isDir
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     */
    protected function allowCreate($dir, $name, $isDir = null)
    {
        return $this-&gt;attr($this-&gt;joinPathCE($dir, $name), 'write', true, $isDir);
    }

    /**
     * Return true if file MIME type can save with check uploadOrder config.
     *
     * @param string $mime
     *
     * @return boolean
     */
    protected function allowPutMime($mime)
    {
        // logic based on http://httpd.apache.org/docs/2.2/mod/mod_authz_host.html#order
        $allow = $this-&gt;mimeAccepted($mime, $this-&gt;uploadAllow, null);
        $deny = $this-&gt;mimeAccepted($mime, $this-&gt;uploadDeny, null);
        if (strtolower($this-&gt;uploadOrder[0]) == 'allow') { // array('allow', 'deny'), default is to 'deny'
            $res = false; // default is deny
            if (!$deny &amp;&amp; ($allow === true)) { // match only allow
                $res = true;
            }// else (both match | no match | match only deny) { deny }
        } else { // array('deny', 'allow'), default is to 'allow' - this is the default rule
            $res = true; // default is allow
            if (($deny === true) &amp;&amp; !$allow) { // match only deny
                $res = false;
            } // else (both match | no match | match only allow) { allow }
        }
        return $res;
    }

    /**
     * Return fileinfo
     *
     * @param  string $path file cache
     *
     * @return array|bool
     * @author Dmitry (dio) Levashov
     **/
    protected function stat($path)
    {
        if ($path === false || is_null($path)) {
            return false;
        }
        $is_root = ($path == $this-&gt;root);
        if ($is_root) {
            $rootKey = $this-&gt;getRootstatCachekey();
            if ($this-&gt;sessionCaching['rootstat'] &amp;&amp; !isset($this-&gt;sessionCache['rootstat'])) {
                $this-&gt;sessionCache['rootstat'] = array();
            }
            if (!isset($this-&gt;cache[$path]) &amp;&amp; !$this-&gt;isMyReload()) {
                // need $path as key for netmount/netunmount
                if ($this-&gt;sessionCaching['rootstat'] &amp;&amp; isset($this-&gt;sessionCache['rootstat'][$rootKey])) {
                    if ($ret = $this-&gt;sessionCache['rootstat'][$rootKey]) {
                        if ($this-&gt;options['rootRev'] === $ret['rootRev']) {
                            if (isset($this-&gt;options['phash'])) {
                                $ret['isroot'] = 1;
                                $ret['phash'] = $this-&gt;options['phash'];
                            }
                            return $ret;
                        }
                    }
                }
            }
        }
        $rootSessCache = false;
        if (isset($this-&gt;cache[$path])) {
            $ret = $this-&gt;cache[$path];
        } else {
            if ($is_root &amp;&amp; !empty($this-&gt;options['rapidRootStat']) &amp;&amp; is_array($this-&gt;options['rapidRootStat']) &amp;&amp; !$this-&gt;needOnline) {
                $ret = $this-&gt;updateCache($path, $this-&gt;options['rapidRootStat'], true);
            } else {
                $ret = $this-&gt;updateCache($path, $this-&gt;convEncOut($this-&gt;_stat($this-&gt;convEncIn($path))), true);
                if ($is_root &amp;&amp; !empty($rootKey) &amp;&amp; $this-&gt;sessionCaching['rootstat']) {
                    $rootSessCache = true;
                }
            }
        } 
        if ($is_root) {
            if ($ret) {
                $this-&gt;rootModified = false;
                if ($rootSessCache) {
                    $this-&gt;sessionCache['rootstat'][$rootKey] = $ret;
                }
                if (isset($this-&gt;options['phash'])) {
                    $ret['isroot'] = 1;
                    $ret['phash'] = $this-&gt;options['phash'];
                }
            } else if (!empty($rootKey) &amp;&amp; $this-&gt;sessionCaching['rootstat']) {
                unset($this-&gt;sessionCache['rootstat'][$rootKey]);
            }
        }
        return $ret;
    }

    /**
     * Get root stat extra key values
     *
     * @return array stat extras
     * @author Naoki Sawada
     */
    protected function getRootStatExtra()
    {
        $stat = array();
        if ($this-&gt;rootName) {
            $stat['name'] = $this-&gt;rootName;
        }
        $stat['rootRev'] = $this-&gt;options['rootRev'];
        $stat['options'] = $this-&gt;options(null);
        return $stat;
    }

    /**
     * Return fileinfo based on filename
     * For item ID based path file system
     * Please override if needed on each drivers
     *
     * @param  string $path file cache
     *
     * @return array
     */
    protected function isNameExists($path)
    {
        return $this-&gt;stat($path);
    }

    /**
     * Put file stat in cache and return it
     *
     * @param  string $path file path
     * @param  array  $stat file stat
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    protected function updateCache($path, $stat)
    {
        if (empty($stat) || !is_array($stat)) {
            return $this-&gt;cache[$path] = array();
        }

        if (func_num_args() &gt; 2) {
            $fromStat = func_get_arg(2);
        } else {
            $fromStat = false;
        }

        $stat['hash'] = $this-&gt;encode($path);

        $root = $path == $this-&gt;root;
        $parent = '';

        if ($root) {
            $stat = array_merge($stat, $this-&gt;getRootStatExtra());
        } else {
            if (!isset($stat['name']) || $stat['name'] === '') {
                $stat['name'] = $this-&gt;basenameCE($path);
            }
            if (empty($stat['phash'])) {
                $parent = $this-&gt;dirnameCE($path);
                $stat['phash'] = $this-&gt;encode($parent);
            } else {
                $parent = $this-&gt;decode($stat['phash']);
            }
        }

        // name check
        if (isset($stat['name']) &amp;&amp; !$jeName = json_encode($stat['name'])) {
            return $this-&gt;cache[$path] = array();
        }
        // fix name if required
        if ($this-&gt;options['utf8fix'] &amp;&amp; $this-&gt;options['utf8patterns'] &amp;&amp; $this-&gt;options['utf8replace']) {
            $stat['name'] = json_decode(str_replace($this-&gt;options['utf8patterns'], $this-&gt;options['utf8replace'], $jeName));
        }

        if (!isset($stat['size'])) {
            $stat['size'] = 'unknown';
        }

        $mime = isset($stat['mime']) ? $stat['mime'] : '';
        if ($isDir = ($mime === 'directory')) {
            $stat['volumeid'] = $this-&gt;id;
        } else {
            if (empty($stat['mime']) || $stat['size'] == 0) {
                $stat['mime'] = $this-&gt;mimetype($stat['name'], true, $stat['size'], $mime);
            } else {
                $stat['mime'] = $this-&gt;mimeTypeNormalize($stat['mime'], $stat['name']);
            }
        }

        $stat['read'] = intval($this-&gt;attr($path, 'read', isset($stat['read']) ? !!$stat['read'] : null, $isDir));
        $stat['write'] = intval($this-&gt;attr($path, 'write', isset($stat['write']) ? !!$stat['write'] : null, $isDir));
        if ($root) {
            $stat['locked'] = 1;
            if ($this-&gt;options['type'] !== '') {
                $stat['type'] = $this-&gt;options['type'];
            }
        } else {
            // lock when parent directory is not writable
            if (!isset($stat['locked'])) {
                $pstat = $this-&gt;stat($parent);
                if (isset($pstat['write']) &amp;&amp; !$pstat['write']) {
                    $stat['locked'] = true;
                }
            }
            if ($this-&gt;attr($path, 'locked', isset($stat['locked']) ? !!$stat['locked'] : null, $isDir)) {
                $stat['locked'] = 1;
            } else {
                unset($stat['locked']);
            }
        }

        if ($root) {
            unset($stat['hidden']);
        } elseif ($this-&gt;attr($path, 'hidden', isset($stat['hidden']) ? !!$stat['hidden'] : null, $isDir)
            || !$this-&gt;mimeAccepted($stat['mime'])) {
            $stat['hidden'] = 1;
        } else {
            unset($stat['hidden']);
        }

        if ($stat['read'] &amp;&amp; empty($stat['hidden'])) {

            if ($isDir) {
                // caching parent's subdirs
                if ($parent) {
                    $this-&gt;updateSubdirsCache($parent, true);
                }
                // for dir - check for subdirs
                if ($this-&gt;options['checkSubfolders']) {
                    if (!isset($stat['dirs']) &amp;&amp; intval($this-&gt;options['checkSubfolders']) === -1) {
                        $stat['dirs'] = -1;
                    }
                    if (isset($stat['dirs'])) {
                        if ($stat['dirs']) {
                            if ($stat['dirs'] == -1) {
                                $stat['dirs'] = ($this-&gt;sessionCaching['subdirs'] &amp;&amp; isset($this-&gt;sessionCache['subdirs'][$path])) ? (int)$this-&gt;sessionCache['subdirs'][$path] : -1;
                            } else {
                                $stat['dirs'] = 1;
                            }
                        } else {
                            unset($stat['dirs']);
                        }
                    } elseif (!empty($stat['alias']) &amp;&amp; !empty($stat['target'])) {
                        $stat['dirs'] = isset($this-&gt;cache[$stat['target']])
                            ? intval(isset($this-&gt;cache[$stat['target']]['dirs']))
                            : $this-&gt;subdirsCE($stat['target']);

                    } elseif ($this-&gt;subdirsCE($path)) {
                        $stat['dirs'] = 1;
                    }
                } else {
                    $stat['dirs'] = 1;
                }
                if ($this-&gt;options['dirUrlOwn'] === true) {
                    // Set `null` to use the client option `commandsOptions.info.nullUrlDirLinkSelf = true`
                    $stat['url'] = null;
                } else if ($this-&gt;options['dirUrlOwn'] === 'hide') {
                    // to hide link in info dialog of the elFinder client
                    $stat['url'] = '';
                }
            } else {
                // for files - check for thumbnails
                $p = isset($stat['target']) ? $stat['target'] : $path;
                if ($this-&gt;tmbURL &amp;&amp; !isset($stat['tmb']) &amp;&amp; $this-&gt;canCreateTmb($p, $stat)) {
                    $tmb = $this-&gt;gettmb($p, $stat);
                    $stat['tmb'] = $tmb ? $tmb : 1;
                }

            }
            if (!isset($stat['url']) &amp;&amp; $this-&gt;URL &amp;&amp; $this-&gt;encoding) {
                $_path = str_replace($this-&gt;separator, '/', substr($path, strlen($this-&gt;root) + 1));
                $stat['url'] = rtrim($this-&gt;URL, '/') . '/' . str_replace('%2F', '/', rawurlencode((substr(PHP_OS, 0, 3) === 'WIN') ? $_path : $this-&gt;convEncIn($_path, true)));
            }
        } else {
            if ($isDir) {
                unset($stat['dirs']);
            }
        }

        if (!empty($stat['alias']) &amp;&amp; !empty($stat['target'])) {
            $stat['thash'] = $this-&gt;encode($stat['target']);
            //$this-&gt;cache[$stat['target']] = $stat;
            unset($stat['target']);
        }

        $this-&gt;cache[$path] = $stat;

        if (!$fromStat &amp;&amp; $root &amp;&amp; $this-&gt;sessionCaching['rootstat']) {
            // to update session cache
            $this-&gt;stat($path);
        }

        return $stat;
    }

    /**
     * Get stat for folder content and put in cache
     *
     * @param  string $path
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    protected function cacheDir($path)
    {
        $this-&gt;dirsCache[$path] = array();
        $hasDir = false;

        foreach ($this-&gt;scandirCE($path) as $p) {
            if (($stat = $this-&gt;stat($p)) &amp;&amp; empty($stat['hidden'])) {
                if (!$hasDir &amp;&amp; $stat['mime'] === 'directory') {
                    $hasDir = true;
                }
                $this-&gt;dirsCache[$path][] = $p;
            }
        }

        $this-&gt;updateSubdirsCache($path, $hasDir);
    }

    /**
     * Clean cache
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    protected function clearcache()
    {
        $this-&gt;cache = $this-&gt;dirsCache = array();
    }

    /**
     * Return file mimetype
     *
     * @param  string      $path file path
     * @param  string|bool $name
     * @param  integer     $size
     * @param  string      $mime was notified from the volume driver
     *
     * @return string
     * @author Dmitry (dio) Levashov
     */
    protected function mimetype($path, $name = '', $size = null, $mime = null)
    {
        $type = '';
        $nameCheck = false;

        if ($name === '') {
            $name = $path;
        } else if ($name === true) {
            $name = $path;
            $nameCheck = true;
        }
        if (!$this instanceof elFinderVolumeLocalFileSystem) {
            $nameCheck = true;
        }
        $ext = (false === $pos = strrpos($name, '.')) ? '' : strtolower(substr($name, $pos + 1));
        if (!$nameCheck &amp;&amp; $size === null) {
            $size = file_exists($path) ? filesize($path) : -1;
        }
        if (!$nameCheck &amp;&amp; is_readable($path) &amp;&amp; $size &gt; 0) {
            // detecting by contents
            if ($this-&gt;mimeDetect === 'finfo') {
                $type = finfo_file($this-&gt;finfo, $path);
            } else if ($this-&gt;mimeDetect === 'mime_content_type') {
                $type = mime_content_type($path);
            }
            if ($type) {
                $type = explode(';', $type);
                $type = trim($type[0]);
                if ($ext &amp;&amp; preg_match('~^application/(?:octet-stream|(?:x-)?zip|xml)$~', $type)) {
                    // load default MIME table file &quot;mime.types&quot;
                    if (!elFinderVolumeDriver::$mimetypesLoaded) {
                        elFinderVolumeDriver::loadMimeTypes();
                    }
                    if (isset(elFinderVolumeDriver::$mimetypes[$ext])) {
                        $type = elFinderVolumeDriver::$mimetypes[$ext];
                    }
                } else if ($ext === 'js' &amp;&amp; preg_match('~^text/~', $type)) {
                    $type = 'text/javascript';
                }
            }
        }
        if (!$type) {
            // detecting by filename
            $type = elFinderVolumeDriver::mimetypeInternalDetect($name);
            if ($type === 'unknown') {
                if ($mime) {
                    $type = $mime;
                } else {
                    $type = ($size == 0) ? 'text/plain' : $this-&gt;options['mimeTypeUnknown'];
                }
            }
        }

        // mime type normalization
        $type = $this-&gt;mimeTypeNormalize($type, $name, $ext);

        return $type;
    }

    /**
     * Load file of mime.types
     *
     * @param string $mimeTypesFile The mime types file
     */
    static protected function loadMimeTypes($mimeTypesFile = '')
    {
        if (!elFinderVolumeDriver::$mimetypesLoaded) {
            elFinderVolumeDriver::$mimetypesLoaded = true;
            $file = false;
            if (!empty($mimeTypesFile) &amp;&amp; file_exists($mimeTypesFile)) {
                $file = $mimeTypesFile;
            } elseif (elFinder::$defaultMimefile &amp;&amp; file_exists(elFinder::$defaultMimefile)) {
                $file = elFinder::$defaultMimefile;
            } elseif (file_exists(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'mime.types')) {
                $file = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'mime.types';
            } elseif (file_exists(dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . 'mime.types')) {
                $file = dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . 'mime.types';
            }

            if ($file &amp;&amp; file_exists($file)) {
                $mimecf = file($file);

                foreach ($mimecf as $line_num =&gt; $line) {
                    if (!preg_match('/^\s*#/', $line)) {
                        $mime = preg_split('/\s+/', $line, -1, PREG_SPLIT_NO_EMPTY);
                        for ($i = 1, $size = count($mime); $i &lt; $size; $i++) {
                            if (!isset(self::$mimetypes[$mime[$i]])) {
                                self::$mimetypes[$mime[$i]] = $mime[0];
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Detect file mimetype using &quot;internal&quot; method or Loading mime.types with $path = ''
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    static protected function mimetypeInternalDetect($path = '')
    {
        // load default MIME table file &quot;mime.types&quot;
        if (!elFinderVolumeDriver::$mimetypesLoaded) {
            elFinderVolumeDriver::loadMimeTypes();
        }
        $ext = '';
        if ($path) {
            $pinfo = pathinfo($path);
            $ext = isset($pinfo['extension']) ? strtolower($pinfo['extension']) : '';
        }
        return ($ext &amp;&amp; isset(elFinderVolumeDriver::$mimetypes[$ext])) ? elFinderVolumeDriver::$mimetypes[$ext] : 'unknown';
    }

    /**
     * Return file/total directory size infomation
     *
     * @param  string $path file path
     *
     * @return array
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function countSize($path)
    {

        elFinder::checkAborted();

        $result = array('size' =&gt; 0, 'files' =&gt; 0, 'dirs' =&gt; 0);
        $stat = $this-&gt;stat($path);

        if (empty($stat) || !$stat['read'] || !empty($stat['hidden'])) {
            $result['size'] = 'unknown';
            return $result;
        }

        if ($stat['mime'] !== 'directory') {
            $result['size'] = intval($stat['size']);
            $result['files'] = 1;
            return $result;
        }

        $result['dirs'] = 1;
        $subdirs = $this-&gt;options['checkSubfolders'];
        $this-&gt;options['checkSubfolders'] = true;
        foreach ($this-&gt;getScandir($path) as $stat) {
            if ($isDir = ($stat['mime'] === 'directory' &amp;&amp; $stat['read'])) {
                ++$result['dirs'];
            } else {
                ++$result['files'];
            }
            $res = $isDir
                ? $this-&gt;countSize($this-&gt;decode($stat['hash']))
                : (isset($stat['size']) ? array('size' =&gt; intval($stat['size'])) : array());
            if (!empty($res['size']) &amp;&amp; is_numeric($res['size'])) {
                $result['size'] += $res['size'];
            }
            if (!empty($res['files']) &amp;&amp; is_numeric($res['files'])) {
                $result['files'] += $res['files'];
            }
            if (!empty($res['dirs']) &amp;&amp; is_numeric($res['dirs'])) {
                $result['dirs'] += $res['dirs'];
                --$result['dirs'];
            }
        }
        $this-&gt;options['checkSubfolders'] = $subdirs;
        return $result;
    }

    /**
     * Return true if all mimes is directory or files
     *
     * @param  string $mime1 mimetype
     * @param  string $mime2 mimetype
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function isSameType($mime1, $mime2)
    {
        return ($mime1 == 'directory' &amp;&amp; $mime1 == $mime2) || ($mime1 != 'directory' &amp;&amp; $mime2 != 'directory');
    }

    /**
     * If file has required attr == $val - return file path,
     * If dir has child with has required attr == $val - return child path
     *
     * @param  string $path file path
     * @param  string $attr attribute name
     * @param  bool   $val  attribute value
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    protected function closestByAttr($path, $attr, $val)
    {
        $stat = $this-&gt;stat($path);

        if (empty($stat)) {
            return false;
        }

        $v = isset($stat[$attr]) ? $stat[$attr] : false;

        if ($v == $val) {
            return $path;
        }

        return $stat['mime'] == 'directory'
            ? $this-&gt;childsByAttr($path, $attr, $val)
            : false;
    }

    /**
     * Return first found children with required attr == $val
     *
     * @param  string $path file path
     * @param  string $attr attribute name
     * @param  bool   $val  attribute value
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    protected function childsByAttr($path, $attr, $val)
    {
        foreach ($this-&gt;scandirCE($path) as $p) {
            if (($_p = $this-&gt;closestByAttr($p, $attr, $val)) != false) {
                return $_p;
            }
        }
        return false;
    }

    protected function isMyReload($target = '', $ARGtarget = '')
    {
        if ($this-&gt;rootModified || (!empty($this-&gt;ARGS['cmd']) &amp;&amp; $this-&gt;ARGS['cmd'] === 'parents')) {
            return true;
        }
        if (!empty($this-&gt;ARGS['reload'])) {
            if ($ARGtarget === '') {
                $ARGtarget = isset($this-&gt;ARGS['target']) ? $this-&gt;ARGS['target']
                    : ((isset($this-&gt;ARGS['targets']) &amp;&amp; is_array($this-&gt;ARGS['targets']) &amp;&amp; count($this-&gt;ARGS['targets']) === 1) ?
                        $this-&gt;ARGS['targets'][0] : '');
            }
            if ($ARGtarget !== '') {
                $ARGtarget = strval($ARGtarget);
                if ($target === '') {
                    return (strpos($ARGtarget, $this-&gt;id) === 0);
                } else {
                    $target = strval($target);
                    return ($target === $ARGtarget);
                }
            }
        }
        return false;
    }

    /**
     * Update subdirs cache data
     *
     * @param string $path
     * @param bool   $subdirs
     *
     * @return void
     */
    protected function updateSubdirsCache($path, $subdirs)
    {
        if (isset($this-&gt;cache[$path])) {
            if ($subdirs) {
                $this-&gt;cache[$path]['dirs'] = 1;
            } else {
                unset($this-&gt;cache[$path]['dirs']);
            }
        }
        if ($this-&gt;sessionCaching['subdirs']) {
            $this-&gt;sessionCache['subdirs'][$path] = $subdirs;
        }
        if ($this-&gt;sessionCaching['rootstat'] &amp;&amp; $path == $this-&gt;root) {
            unset($this-&gt;sessionCache['rootstat'][$this-&gt;getRootstatCachekey()]);
        }
    }

    /*****************  get content *******************/

    /**
     * Return required dir's files info.
     * If onlyMimes is set - return only dirs and files of required mimes
     *
     * @param  string $path dir path
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    protected function getScandir($path)
    {
        $files = array();

        !isset($this-&gt;dirsCache[$path]) &amp;&amp; $this-&gt;cacheDir($path);

        foreach ($this-&gt;dirsCache[$path] as $p) {
            if (($stat = $this-&gt;stat($p)) &amp;&amp; empty($stat['hidden'])) {
                $files[] = $stat;
            }
        }

        return $files;
    }


    /**
     * Return subdirs tree
     *
     * @param  string $path parent dir path
     * @param  int    $deep tree deep
     * @param string  $exclude
     *
     * @return array
     * @author Dmitry (dio) Levashov
     */
    protected function gettree($path, $deep, $exclude = '')
    {
        $dirs = array();

        !isset($this-&gt;dirsCache[$path]) &amp;&amp; $this-&gt;cacheDir($path);

        foreach ($this-&gt;dirsCache[$path] as $p) {
            $stat = $this-&gt;stat($p);

            if ($stat &amp;&amp; empty($stat['hidden']) &amp;&amp; $p != $exclude &amp;&amp; $stat['mime'] == 'directory') {
                $dirs[] = $stat;
                if ($deep &gt; 0 &amp;&amp; !empty($stat['dirs'])) {
                    $dirs = array_merge($dirs, $this-&gt;gettree($p, $deep - 1));
                }
            }
        }

        return $dirs;
    }

    /**
     * Recursive files search
     *
     * @param  string $path dir path
     * @param  string $q    search string
     * @param  array  $mimes
     *
     * @return array
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function doSearch($path, $q, $mimes)
    {
        $result = array();
        $matchMethod = empty($this-&gt;doSearchCurrentQuery['matchMethod']) ? 'searchMatchName' : $this-&gt;doSearchCurrentQuery['matchMethod'];
        $timeout = $this-&gt;options['searchTimeout'] ? $this-&gt;searchStart + $this-&gt;options['searchTimeout'] : 0;
        if ($timeout &amp;&amp; $timeout &lt; time()) {
            $this-&gt;setError(elFinder::ERROR_SEARCH_TIMEOUT, $this-&gt;path($this-&gt;encode($path)));
            return $result;
        }

        foreach ($this-&gt;scandirCE($path) as $p) {
            elFinder::extendTimeLimit($this-&gt;options['searchTimeout'] + 30);

            if ($timeout &amp;&amp; ($this-&gt;error || $timeout &lt; time())) {
                !$this-&gt;error &amp;&amp; $this-&gt;setError(elFinder::ERROR_SEARCH_TIMEOUT, $this-&gt;path($this-&gt;encode($path)));
                break;
            }


            $stat = $this-&gt;stat($p);

            if (!$stat) { // invalid links
                continue;
            }

            if (!empty($stat['hidden']) || !$this-&gt;mimeAccepted($stat['mime'], $mimes)) {
                continue;
            }

            $name = $stat['name'];

            if ($this-&gt;doSearchCurrentQuery['excludes']) {
                foreach ($this-&gt;doSearchCurrentQuery['excludes'] as $exclude) {
                    if ($this-&gt;stripos($name, $exclude) !== false) {
                        continue 2;
                    }
                }
            }

            if ((!$mimes || $stat['mime'] !== 'directory') &amp;&amp; $this-&gt;$matchMethod($name, $q, $p) !== false) {
                $stat['path'] = $this-&gt;path($stat['hash']);
                if ($this-&gt;URL &amp;&amp; !isset($stat['url'])) {
                    $path = str_replace($this-&gt;separator, '/', substr($p, strlen($this-&gt;root) + 1));
                    if ($this-&gt;encoding) {
                        $path = str_replace('%2F', '/', rawurlencode($this-&gt;convEncIn($path, true)));
                    } else {
                        $path = str_replace('%2F', '/', rawurlencode($path));
                    }
                    $stat['url'] = $this-&gt;URL . $path;
                }

                $result[] = $stat;
            }
            if ($stat['mime'] == 'directory' &amp;&amp; $stat['read'] &amp;&amp; !isset($stat['alias'])) {
                if (!$this-&gt;options['searchExDirReg'] || !preg_match($this-&gt;options['searchExDirReg'], $p)) {
                    $result = array_merge($result, $this-&gt;doSearch($p, $q, $mimes));
                }
            }
        }

        return $result;
    }

    /**********************  manuipulations  ******************/

    /**
     * Copy file/recursive copy dir only in current volume.
     * Return new file path or false.
     *
     * @param  string $src  source path
     * @param  string $dst  destination dir path
     * @param  string $name new file name (optionaly)
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function copy($src, $dst, $name)
    {

        elFinder::checkAborted();

        $srcStat = $this-&gt;stat($src);

        if (!empty($srcStat['thash'])) {
            $target = $this-&gt;decode($srcStat['thash']);
            if (!$this-&gt;inpathCE($target, $this-&gt;root)) {
                return $this-&gt;setError(elFinder::ERROR_COPY, $this-&gt;path($srcStat['hash']), elFinder::ERROR_MKOUTLINK);
            }
            $stat = $this-&gt;stat($target);
            $this-&gt;clearcache();
            return $stat &amp;&amp; $this-&gt;symlinkCE($target, $dst, $name)
                ? $this-&gt;joinPathCE($dst, $name)
                : $this-&gt;setError(elFinder::ERROR_COPY, $this-&gt;path($srcStat['hash']));
        }

        if ($srcStat['mime'] === 'directory') {
            $testStat = $this-&gt;isNameExists($this-&gt;joinPathCE($dst, $name));
            $this-&gt;clearcache();

            if (($testStat &amp;&amp; $testStat['mime'] !== 'directory') || (!$testStat &amp;&amp; !$testStat = $this-&gt;mkdir($this-&gt;encode($dst), $name))) {
                return $this-&gt;setError(elFinder::ERROR_COPY, $this-&gt;path($srcStat['hash']));
            }

            $dst = $this-&gt;decode($testStat['hash']);

            // start time
            $stime = microtime(true);
            foreach ($this-&gt;getScandir($src) as $stat) {
                if (empty($stat['hidden'])) {
                    // current time
                    $ctime = microtime(true);
                    if (($ctime - $stime) &gt; 2) {
                        $stime = $ctime;
                        elFinder::checkAborted();
                    }
                    $name = $stat['name'];
                    $_src = $this-&gt;decode($stat['hash']);
                    if (!$this-&gt;copy($_src, $dst, $name)) {
                        $this-&gt;remove($dst, true); // fall back
                        return $this-&gt;setError($this-&gt;error, elFinder::ERROR_COPY, $this-&gt;_path($src));
                    }
                }
            }

            $this-&gt;added[] = $testStat;

            return $dst;
        }

        if ($this-&gt;options['copyJoin']) {
            $test = $this-&gt;joinPathCE($dst, $name);
            if ($this-&gt;isNameExists($test)) {
                $this-&gt;remove($test);
            }
        }
        if ($res = $this-&gt;convEncOut($this-&gt;_copy($this-&gt;convEncIn($src), $this-&gt;convEncIn($dst), $this-&gt;convEncIn($name)))) {
            $path = is_string($res) ? $res : $this-&gt;joinPathCE($dst, $name);
            $this-&gt;clearstatcache();
            $this-&gt;added[] = $this-&gt;stat($path);
            return $path;
        }

        return $this-&gt;setError(elFinder::ERROR_COPY, $this-&gt;path($srcStat['hash']));
    }

    /**
     * Move file
     * Return new file path or false.
     *
     * @param  string $src  source path
     * @param  string $dst  destination dir path
     * @param  string $name new file name
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function move($src, $dst, $name)
    {
        $stat = $this-&gt;stat($src);
        $stat['realpath'] = $src;
        $this-&gt;rmTmb($stat); // can not do rmTmb() after _move()
        $this-&gt;clearcache();

        if ($res = $this-&gt;convEncOut($this-&gt;_move($this-&gt;convEncIn($src), $this-&gt;convEncIn($dst), $this-&gt;convEncIn($name)))) {
            $this-&gt;clearstatcache();
            if ($stat['mime'] === 'directory') {
                $this-&gt;updateSubdirsCache($dst, true);
            }
            $path = is_string($res) ? $res : $this-&gt;joinPathCE($dst, $name);
            $this-&gt;added[] = $this-&gt;stat($path);
            $this-&gt;removed[] = $stat;
            return $path;
        }

        return $this-&gt;setError(elFinder::ERROR_MOVE, $this-&gt;path($stat['hash']));
    }

    /**
     * Copy file from another volume.
     * Return new file path or false.
     *
     * @param  Object $volume      source volume
     * @param  string $src         source file hash
     * @param  string $destination destination dir path
     * @param  string $name        file name
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function copyFrom($volume, $src, $destination, $name)
    {

        elFinder::checkAborted();

        if (($source = $volume-&gt;file($src)) == false) {
            return $this-&gt;addError(elFinder::ERROR_COPY, '#' . $src, $volume-&gt;error());
        }

        $srcIsDir = ($source['mime'] === 'directory');

        $errpath = $volume-&gt;path($source['hash']);

        $errors = array();
        try {
            $thash = $this-&gt;encode($destination);
            elFinder::$instance-&gt;trigger('paste.copyfrom', array(&amp;$thash, &amp;$name, '', elFinder::$instance, $this), $errors);
        } catch (elFinderTriggerException $e) {
            return $this-&gt;addError(elFinder::ERROR_COPY, $name, $errors);
        }

        if (!$this-&gt;nameAccepted($name, $srcIsDir)) {
            return $this-&gt;addError(elFinder::ERROR_COPY, $name, $srcIsDir ? elFinder::ERROR_INVALID_DIRNAME : elFinder::ERROR_INVALID_NAME);
        }

        if (!$this-&gt;allowCreate($destination, $name, $srcIsDir)) {
            return $this-&gt;addError(elFinder::ERROR_COPY, $name, elFinder::ERROR_PERM_DENIED);
        }

        if (!$source['read']) {
            return $this-&gt;addError(elFinder::ERROR_COPY, $errpath, elFinder::ERROR_PERM_DENIED);
        }

        if ($srcIsDir) {
            $test = $this-&gt;isNameExists($this-&gt;joinPathCE($destination, $name));
            $this-&gt;clearcache();

            if (($test &amp;&amp; $test['mime'] != 'directory') || (!$test &amp;&amp; !$test = $this-&gt;mkdir($this-&gt;encode($destination), $name))) {
                return $this-&gt;addError(elFinder::ERROR_COPY, $errpath);
            }

            //$path = $this-&gt;joinPathCE($destination, $name);
            $path = $this-&gt;decode($test['hash']);

            foreach ($volume-&gt;scandir($src) as $entr) {
                $this-&gt;copyFrom($volume, $entr['hash'], $path, $entr['name']);
            }

            $this-&gt;added[] = $test;
        } else {
            // size check
            if (!isset($source['size']) || $source['size'] &gt; $this-&gt;uploadMaxSize) {
                return $this-&gt;setError(elFinder::ERROR_UPLOAD_FILE_SIZE);
            }

            // MIME check
            $mimeByName = $this-&gt;mimetype($source['name'], true);
            if ($source['mime'] === $mimeByName) {
                $mimeByName = '';
            }
            if (!$this-&gt;allowPutMime($source['mime']) || ($mimeByName &amp;&amp; !$this-&gt;allowPutMime($mimeByName))) {
                return $this-&gt;addError(elFinder::ERROR_UPLOAD_FILE_MIME, $errpath);
            }

            if (strpos($source['mime'], 'image') === 0 &amp;&amp; ($dim = $volume-&gt;dimensions($src))) {
                if (is_array($dim)) {
                    $dim = isset($dim['dim']) ? $dim['dim'] : null;
                }
                if ($dim) {
                    $s = explode('x', $dim);
                    $source['width'] = $s[0];
                    $source['height'] = $s[1];
                }
            }

            if (($fp = $volume-&gt;open($src)) == false
                || ($path = $this-&gt;saveCE($fp, $destination, $name, $source)) == false) {
                $fp &amp;&amp; $volume-&gt;close($fp, $src);
                return $this-&gt;addError(elFinder::ERROR_COPY, $errpath);
            }
            $volume-&gt;close($fp, $src);

            $this-&gt;added[] = $this-&gt;stat($path);;
        }

        return $path;
    }

    /**
     * Remove file/ recursive remove dir
     *
     * @param  string $path  file path
     * @param  bool   $force try to remove even if file locked
     *
     * @return bool
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function remove($path, $force = false)
    {
        $stat = $this-&gt;stat($path);

        if (empty($stat)) {
            return $this-&gt;setError(elFinder::ERROR_RM, $this-&gt;relpathCE($path), elFinder::ERROR_FILE_NOT_FOUND);
        }

        $stat['realpath'] = $path;
        $this-&gt;rmTmb($stat);
        $this-&gt;clearcache();

        if (!$force &amp;&amp; !empty($stat['locked'])) {
            return $this-&gt;setError(elFinder::ERROR_LOCKED, $this-&gt;path($stat['hash']));
        }

        if ($stat['mime'] == 'directory' &amp;&amp; empty($stat['thash'])) {
            $ret = $this-&gt;delTree($this-&gt;convEncIn($path));
            $this-&gt;convEncOut();
            if (!$ret) {
                return $this-&gt;setError(elFinder::ERROR_RM, $this-&gt;path($stat['hash']));
            }
        } else {
            if ($this-&gt;convEncOut(!$this-&gt;_unlink($this-&gt;convEncIn($path)))) {
                return $this-&gt;setError(elFinder::ERROR_RM, $this-&gt;path($stat['hash']));
            }
            $this-&gt;clearstatcache();
        }

        $this-&gt;removed[] = $stat;
        return true;
    }


    /************************* thumbnails **************************/

    /**
     * Return thumbnail file name for required file
     *
     * @param  array $stat file stat
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    protected function tmbname($stat)
    {
        $name = $stat['hash'] . (isset($stat['ts']) ? $stat['ts'] : '') . '.png';
        if (strlen($name) &gt; 255) {
            $name = $this-&gt;id . md5($stat['hash']) . $stat['ts'] . '.png';
        }
        return $name;
    }

    /**
     * Return thumnbnail name if exists
     *
     * @param  string $path file path
     * @param  array  $stat file stat
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    protected function gettmb($path, $stat)
    {
        if ($this-&gt;tmbURL &amp;&amp; $this-&gt;tmbPath) {
            // file itself thumnbnail
            if (strpos($path, $this-&gt;tmbPath) === 0) {
                return basename($path);
            }

            $name = $this-&gt;tmbname($stat);
            $tmb = $this-&gt;tmbPath . DIRECTORY_SEPARATOR . $name;
            if (file_exists($tmb)) {
                if ($this-&gt;options['tmbGcMaxlifeHour'] &amp;&amp; $this-&gt;options['tmbGcPercentage'] &gt; 0) {
                    touch($tmb);
                }
                return $name;
            }
        }
        return false;
    }

    /**
     * Return true if thumnbnail for required file can be created
     *
     * @param  string $path thumnbnail path
     * @param  array  $stat file stat
     * @param  bool   $checkTmbPath
     *
     * @return string|bool
     * @author Dmitry (dio) Levashov
     **/
    protected function canCreateTmb($path, $stat, $checkTmbPath = true)
    {
        static $gdMimes = null;
        static $imgmgPS = null;
        if ($gdMimes === null) {
            $_mimes = array('image/jpeg', 'image/png', 'image/gif', 'image/x-ms-bmp');
            if (function_exists('imagecreatefromwebp')) {
                $_mimes[] = 'image/webp';
            }
            $gdMimes = array_flip($_mimes);
            $imgmgPS = array_flip(array('application/postscript', 'application/pdf'));
        }
        if ((!$checkTmbPath || $this-&gt;tmbPathWritable)
            &amp;&amp; (!$this-&gt;tmbPath || strpos($path, $this-&gt;tmbPath) === false) // do not create thumnbnail for thumnbnail
        ) {
            $mime = strtolower($stat['mime']);
            list($type) = explode('/', $mime);
            if (!empty($this-&gt;imgConverter)) {
                if (isset($this-&gt;imgConverter[$mime])) {
                    return true;
                }
                if (isset($this-&gt;imgConverter[$type])) {
                    return true;
                }
            }
            return $this-&gt;imgLib
                &amp;&amp; (
                    ($type === 'image' &amp;&amp; ($this-&gt;imgLib === 'gd' ? isset($gdMimes[$stat['mime']]) : true))
                    ||
                    (ELFINDER_IMAGEMAGICK_PS &amp;&amp; isset($imgmgPS[$stat['mime']]) &amp;&amp; $this-&gt;imgLib !== 'gd')
                );
        }
        return false;
    }

    /**
     * Return true if required file can be resized.
     * By default - the same as canCreateTmb
     *
     * @param  string $path thumnbnail path
     * @param  array  $stat file stat
     *
     * @return string|bool
     * @author Dmitry (dio) Levashov
     **/
    protected function canResize($path, $stat)
    {
        return $this-&gt;canCreateTmb($path, $stat, false);
    }

    /**
     * Create thumnbnail and return it's URL on success
     *
     * @param  string $path file path
     * @param         $stat
     *
     * @return false|string
     * @internal param string $mime file mime type
     * @throws elFinderAbortException
     * @throws ImagickException
     * @author   Dmitry (dio) Levashov
     */
    protected function createTmb($path, $stat)
    {
        if (!$stat || !$this-&gt;canCreateTmb($path, $stat)) {
            return false;
        }

        $name = $this-&gt;tmbname($stat);
        $tmb = $this-&gt;tmbPath . DIRECTORY_SEPARATOR . $name;

        $maxlength = -1;
        $imgConverter = null;

        // check imgConverter
        $mime = strtolower($stat['mime']);
        list($type) = explode('/', $mime);
        if (isset($this-&gt;imgConverter[$mime])) {
            $imgConverter = $this-&gt;imgConverter[$mime]['func'];
            if (!empty($this-&gt;imgConverter[$mime]['maxlen'])) {
                $maxlength = intval($this-&gt;imgConverter[$mime]['maxlen']);
            }
        } else if (isset($this-&gt;imgConverter[$type])) {
            $imgConverter = $this-&gt;imgConverter[$type]['func'];
            if (!empty($this-&gt;imgConverter[$type]['maxlen'])) {
                $maxlength = intval($this-&gt;imgConverter[$type]['maxlen']);
            }
        }
        if ($imgConverter &amp;&amp; !is_callable($imgConverter)) {
            return false;
        }

        // copy image into tmbPath so some drivers does not store files on local fs
        if (($src = $this-&gt;fopenCE($path, 'rb')) == false) {
            return false;
        }

        if (($trg = fopen($tmb, 'wb')) == false) {
            $this-&gt;fcloseCE($src, $path);
            return false;
        }

        stream_copy_to_stream($src, $trg, $maxlength);

        $this-&gt;fcloseCE($src, $path);
        fclose($trg);

        // call imgConverter
        if ($imgConverter) {
            if (!call_user_func_array($imgConverter, array($tmb, $stat, $this))) {
                file_exists($tmb) &amp;&amp; unlink($tmb);
                return false;
            }
        }

        $result = false;

        $tmbSize = $this-&gt;tmbSize;

        if ($this-&gt;imgLib === 'imagick') {
            try {
                $imagickTest = new imagick($tmb . '[0]');
                $imagickTest-&gt;clear();
                $imagickTest = true;
            } catch (Exception $e) {
                $imagickTest = false;
            }
        }

        if (($this-&gt;imgLib === 'imagick' &amp;&amp; !$imagickTest) || ($s = getimagesize($tmb)) === false) {
            if ($this-&gt;imgLib === 'imagick') {
                $bgcolor = $this-&gt;options['tmbBgColor'];
                if ($bgcolor === 'transparent') {
                    $bgcolor = 'rgba(255, 255, 255, 0.0)';
                }
                try {
                    $imagick = new imagick();
                    $imagick-&gt;setBackgroundColor(new ImagickPixel($bgcolor));
                    $imagick-&gt;readImage($this-&gt;getExtentionByMime($stat['mime'], ':') . $tmb . '[0]');
                    try {
                        $imagick-&gt;trimImage(0);
                    } catch (Exception $e) {
                    }
                    $imagick-&gt;setImageFormat('png');
                    $imagick-&gt;writeImage($tmb);
                    $imagick-&gt;clear();
                    if (($s = getimagesize($tmb)) !== false) {
                        $result = true;
                    }
                } catch (Exception $e) {
                }
            } else if ($this-&gt;imgLib === 'convert') {
                $convParams = $this-&gt;imageMagickConvertPrepare($tmb, 'png', 100, array(), $stat['mime']);
                $cmd = sprintf('%s -colorspace sRGB -trim -- %s %s', ELFINDER_CONVERT_PATH, $convParams['quotedPath'], $convParams['quotedDstPath']);
                $result = false;
                if ($this-&gt;procExec($cmd) === 0) {
                    if (($s = getimagesize($tmb)) !== false) {
                        $result = true;
                    }
                }
            }
            if (!$result) {
                // fallback imgLib to GD
                if (function_exists('gd_info') &amp;&amp; ($s = getimagesize($tmb))) {
                    $this-&gt;imgLib = 'gd';
                } else {
                    file_exists($tmb) &amp;&amp; unlink($tmb);
                    return false;
                }
            }
        }

        /* If image smaller or equal thumbnail size - just fitting to thumbnail square */
        if ($s[0] &lt;= $tmbSize &amp;&amp; $s[1] &lt;= $tmbSize) {
            $result = $this-&gt;imgSquareFit($tmb, $tmbSize, $tmbSize, 'center', 'middle', $this-&gt;options['tmbBgColor'], 'png');
        } else {

            if ($this-&gt;options['tmbCrop']) {

                $result = $tmb;
                /* Resize and crop if image bigger than thumbnail */
                if (!(($s[0] &gt; $tmbSize &amp;&amp; $s[1] &lt;= $tmbSize) || ($s[0] &lt;= $tmbSize &amp;&amp; $s[1] &gt; $tmbSize)) || ($s[0] &gt; $tmbSize &amp;&amp; $s[1] &gt; $tmbSize)) {
                    $result = $this-&gt;imgResize($tmb, $tmbSize, $tmbSize, true, false, 'png');
                }

                if ($result &amp;&amp; ($s = getimagesize($tmb)) != false) {
                    $x = $s[0] &gt; $tmbSize ? intval(($s[0] - $tmbSize) / 2) : 0;
                    $y = $s[1] &gt; $tmbSize ? intval(($s[1] - $tmbSize) / 2) : 0;
                    $result = $this-&gt;imgCrop($result, $tmbSize, $tmbSize, $x, $y, 'png');
                } else {
                    $result = false;
                }

            } else {
                $result = $this-&gt;imgResize($tmb, $tmbSize, $tmbSize, true, true, 'png');
            }

            if ($result) {
                if ($s = getimagesize($tmb)) {
                    if ($s[0] !== $tmbSize || $s[1] !== $tmbSize) {
                        $result = $this-&gt;imgSquareFit($result, $tmbSize, $tmbSize, 'center', 'middle', $this-&gt;options['tmbBgColor'], 'png');
                    }
                }
            }
        }

        if (!$result) {
            unlink($tmb);
            return false;
        }

        return $name;
    }

    /**
     * Resize image
     *
     * @param  string $path               image file
     * @param  int    $width              new width
     * @param  int    $height             new height
     * @param  bool   $keepProportions    crop image
     * @param  bool   $resizeByBiggerSide resize image based on bigger side if true
     * @param  string $destformat         image destination format
     * @param  int    $jpgQuality         JEPG quality (1-100)
     * @param  array  $options            Other extra options
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     */
    protected function imgResize($path, $width, $height, $keepProportions = false, $resizeByBiggerSide = true, $destformat = null, $jpgQuality = null, $options = array())
    {
        if (($s = getimagesize($path)) == false) {
            return false;
        }

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }

        list($orig_w, $orig_h) = array($s[0], $s[1]);
        list($size_w, $size_h) = array($width, $height);

        if (empty($options['unenlarge']) || $orig_w &gt; $size_w || $orig_h &gt; $size_h) {
            if ($keepProportions == true) {
                /* Resizing by biggest side */
                if ($resizeByBiggerSide) {
                    if ($orig_w &gt; $orig_h) {
                        $size_h = round($orig_h * $width / $orig_w);
                        $size_w = $width;
                    } else {
                        $size_w = round($orig_w * $height / $orig_h);
                        $size_h = $height;
                    }
                } else {
                    if ($orig_w &gt; $orig_h) {
                        $size_w = round($orig_w * $height / $orig_h);
                        $size_h = $height;
                    } else {
                        $size_h = round($orig_h * $width / $orig_w);
                        $size_w = $width;
                    }
                }
            }
        } else {
            $size_w = $orig_w;
            $size_h = $orig_h;
        }

        elFinder::extendTimeLimit(300);
        switch ($this-&gt;imgLib) {
            case 'imagick':

                try {
                    $img = new imagick($path);
                } catch (Exception $e) {
                    return false;
                }

                // Imagick::FILTER_BOX faster than FILTER_LANCZOS so use for createTmb
                // resize bench: http://app-mgng.rhcloud.com/9
                // resize sample: http://www.dylanbeattie.net/magick/filters/result.html
                $filter = ($destformat === 'png' /* createTmb */) ? Imagick::FILTER_BOX : Imagick::FILTER_LANCZOS;

                $ani = ($img-&gt;getNumberImages() &gt; 1);
                if ($ani &amp;&amp; is_null($destformat)) {
                    $img = $img-&gt;coalesceImages();
                    do {
                        $img-&gt;resizeImage($size_w, $size_h, $filter, 1);
                    } while ($img-&gt;nextImage());
                    $img-&gt;optimizeImageLayers();
                    $result = $img-&gt;writeImages($path, true);
                } else {
                    if ($ani) {
                        $img-&gt;setFirstIterator();
                    }
                    if (strtoupper($img-&gt;getImageFormat()) === 'JPEG') {
                        $img-&gt;setImageCompression(imagick::COMPRESSION_JPEG);
                        $img-&gt;setImageCompressionQuality($jpgQuality);
                        if (isset($options['preserveExif']) &amp;&amp; !$options['preserveExif']) {
                            try {
                                $orientation = $img-&gt;getImageOrientation();
                            } catch (ImagickException $e) {
                                $orientation = 0;
                            }
                            $img-&gt;stripImage();
                            if ($orientation) {
                                $img-&gt;setImageOrientation($orientation);
                            }
                        }
                        if ($this-&gt;options['jpgProgressive']) {
                            $img-&gt;setInterlaceScheme(Imagick::INTERLACE_PLANE);
                        }
                    }
                    $img-&gt;resizeImage($size_w, $size_h, $filter, true);
                    if ($destformat) {
                        $result = $this-&gt;imagickImage($img, $path, $destformat, $jpgQuality);
                    } else {
                        $result = $img-&gt;writeImage($path);
                    }
                }

                $img-&gt;clear();

                return $result ? $path : false;

                break;

            case 'convert':
                extract($this-&gt;imageMagickConvertPrepare($path, $destformat, $jpgQuality, $s));
                /**
                 * @var string $ani
                 * @var string $index
                 * @var string $coalesce
                 * @var string $deconstruct
                 * @var string $jpgQuality
                 * @var string $quotedPath
                 * @var string $quotedDstPath
                 * @var string $interlace
                 */
                $filter = ($destformat === 'png' /* createTmb */) ? '-filter Box' : '-filter Lanczos';
                $strip = (isset($options['preserveExif']) &amp;&amp; !$options['preserveExif']) ? ' -strip' : '';
                $cmd = sprintf('%s %s%s%s%s%s %s -geometry %dx%d! %s %s', ELFINDER_CONVERT_PATH, $quotedPath, $coalesce, $jpgQuality, $strip, $interlace, $filter, $size_w, $size_h, $deconstruct, $quotedDstPath);

                $result = false;
                if ($this-&gt;procExec($cmd) === 0) {
                    $result = true;
                }
                return $result ? $path : false;

                break;

            case 'gd':
                elFinder::expandMemoryForGD(array($s, array($size_w, $size_h)));
                $img = $this-&gt;gdImageCreate($path, $s['mime']);

                if ($img &amp;&amp; false != ($tmp = imagecreatetruecolor($size_w, $size_h))) {

                    $bgNum = false;
                    if ($s[2] === IMAGETYPE_GIF &amp;&amp; (!$destformat || $destformat === 'gif')) {
                        $bgIdx = imagecolortransparent($img);
                        if ($bgIdx !== -1) {
                            $c = imagecolorsforindex($img, $bgIdx);
                            $bgNum = imagecolorallocate($tmp, $c['red'], $c['green'], $c['blue']);
                            imagefill($tmp, 0, 0, $bgNum);
                            imagecolortransparent($tmp, $bgNum);
                        }
                    }
                    if ($bgNum === false) {
                        $this-&gt;gdImageBackground($tmp, 'transparent');
                    }

                    if (!imagecopyresampled($tmp, $img, 0, 0, 0, 0, $size_w, $size_h, $s[0], $s[1])) {
                        return false;
                    }

                    $result = $this-&gt;gdImage($tmp, $path, $destformat, $s['mime'], $jpgQuality);

                    imagedestroy($img);
                    imagedestroy($tmp);

                    return $result ? $path : false;

                }
                break;
        }

        return false;
    }

    /**
     * Crop image
     *
     * @param  string $path       image file
     * @param  int    $width      crop width
     * @param  int    $height     crop height
     * @param  bool   $x          crop left offset
     * @param  bool   $y          crop top offset
     * @param  string $destformat image destination format
     * @param  int    $jpgQuality JEPG quality (1-100)
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     */
    protected function imgCrop($path, $width, $height, $x, $y, $destformat = null, $jpgQuality = null)
    {
        if (($s = getimagesize($path)) == false) {
            return false;
        }

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }

        elFinder::extendTimeLimit(300);
        switch ($this-&gt;imgLib) {
            case 'imagick':

                try {
                    $img = new imagick($path);
                } catch (Exception $e) {
                    return false;
                }

                $ani = ($img-&gt;getNumberImages() &gt; 1);
                if ($ani &amp;&amp; is_null($destformat)) {
                    $img = $img-&gt;coalesceImages();
                    do {
                        $img-&gt;setImagePage($s[0], $s[1], 0, 0);
                        $img-&gt;cropImage($width, $height, $x, $y);
                        $img-&gt;setImagePage($width, $height, 0, 0);
                    } while ($img-&gt;nextImage());
                    $img-&gt;optimizeImageLayers();
                    $result = $img-&gt;writeImages($path, true);
                } else {
                    if ($ani) {
                        $img-&gt;setFirstIterator();
                    }
                    $img-&gt;setImagePage($s[0], $s[1], 0, 0);
                    $img-&gt;cropImage($width, $height, $x, $y);
                    $img-&gt;setImagePage($width, $height, 0, 0);
                    $result = $this-&gt;imagickImage($img, $path, $destformat, $jpgQuality);
                }

                $img-&gt;clear();

                return $result ? $path : false;

                break;

            case 'convert':
                extract($this-&gt;imageMagickConvertPrepare($path, $destformat, $jpgQuality, $s));
                /**
                 * @var string $ani
                 * @var string $index
                 * @var string $coalesce
                 * @var string $deconstruct
                 * @var string $jpgQuality
                 * @var string $quotedPath
                 * @var string $quotedDstPath
                 * @var string $interlace
                 */
                $cmd = sprintf('%s %s%s%s%s -crop %dx%d+%d+%d%s %s', ELFINDER_CONVERT_PATH, $quotedPath, $coalesce, $jpgQuality, $interlace, $width, $height, $x, $y, $deconstruct, $quotedDstPath);

                $result = false;
                if ($this-&gt;procExec($cmd) === 0) {
                    $result = true;
                }
                return $result ? $path : false;

                break;

            case 'gd':
                elFinder::expandMemoryForGD(array($s, array($width, $height)));
                $img = $this-&gt;gdImageCreate($path, $s['mime']);

                if ($img &amp;&amp; false != ($tmp = imagecreatetruecolor($width, $height))) {

                    $bgNum = false;
                    if ($s[2] === IMAGETYPE_GIF &amp;&amp; (!$destformat || $destformat === 'gif')) {
                        $bgIdx = imagecolortransparent($img);
                        if ($bgIdx !== -1) {
                            $c = imagecolorsforindex($img, $bgIdx);
                            $bgNum = imagecolorallocate($tmp, $c['red'], $c['green'], $c['blue']);
                            imagefill($tmp, 0, 0, $bgNum);
                            imagecolortransparent($tmp, $bgNum);
                        }
                    }
                    if ($bgNum === false) {
                        $this-&gt;gdImageBackground($tmp, 'transparent');
                    }

                    $size_w = $width;
                    $size_h = $height;

                    if ($s[0] &lt; $width || $s[1] &lt; $height) {
                        $size_w = $s[0];
                        $size_h = $s[1];
                    }

                    if (!imagecopy($tmp, $img, 0, 0, $x, $y, $size_w, $size_h)) {
                        return false;
                    }

                    $result = $this-&gt;gdImage($tmp, $path, $destformat, $s['mime'], $jpgQuality);

                    imagedestroy($img);
                    imagedestroy($tmp);

                    return $result ? $path : false;

                }
                break;
        }

        return false;
    }

    /**
     * Put image to square
     *
     * @param  string    $path       image file
     * @param  int       $width      square width
     * @param  int       $height     square height
     * @param int|string $align      reserved
     * @param int|string $valign     reserved
     * @param  string    $bgcolor    square background color in #rrggbb format
     * @param  string    $destformat image destination format
     * @param  int       $jpgQuality JEPG quality (1-100)
     *
     * @return false|string
     * @throws ImagickException
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     */
    protected function imgSquareFit($path, $width, $height, $align = 'center', $valign = 'middle', $bgcolor = '#0000ff', $destformat = null, $jpgQuality = null)
    {
        if (($s = getimagesize($path)) == false) {
            return false;
        }

        $result = false;

        /* Coordinates for image over square aligning */
        $y = ceil(abs($height - $s[1]) / 2);
        $x = ceil(abs($width - $s[0]) / 2);

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }

        elFinder::extendTimeLimit(300);
        switch ($this-&gt;imgLib) {
            case 'imagick':
                try {
                    $img = new imagick($path);
                } catch (Exception $e) {
                    return false;
                }

                if ($bgcolor === 'transparent') {
                    $bgcolor = 'rgba(255, 255, 255, 0.0)';
                }
                $ani = ($img-&gt;getNumberImages() &gt; 1);
                if ($ani &amp;&amp; is_null($destformat)) {
                    $img1 = new Imagick();
                    $img1-&gt;setFormat('gif');
                    $img = $img-&gt;coalesceImages();
                    do {
                        $gif = new Imagick();
                        $gif-&gt;newImage($width, $height, new ImagickPixel($bgcolor));
                        $gif-&gt;setImageColorspace($img-&gt;getImageColorspace());
                        $gif-&gt;setImageFormat('gif');
                        $gif-&gt;compositeImage($img, imagick::COMPOSITE_OVER, $x, $y);
                        $gif-&gt;setImageDelay($img-&gt;getImageDelay());
                        $gif-&gt;setImageIterations($img-&gt;getImageIterations());
                        $img1-&gt;addImage($gif);
                        $gif-&gt;clear();
                    } while ($img-&gt;nextImage());
                    $img1-&gt;optimizeImageLayers();
                    $result = $img1-&gt;writeImages($path, true);
                } else {
                    if ($ani) {
                        $img-&gt;setFirstIterator();
                    }
                    $img1 = new Imagick();
                    $img1-&gt;newImage($width, $height, new ImagickPixel($bgcolor));
                    $img1-&gt;setImageColorspace($img-&gt;getImageColorspace());
                    $img1-&gt;compositeImage($img, imagick::COMPOSITE_OVER, $x, $y);
                    $result = $this-&gt;imagickImage($img1, $path, $destformat, $jpgQuality);
                }

                $img1-&gt;clear();
                $img-&gt;clear();
                return $result ? $path : false;

                break;

            case 'convert':
                extract($this-&gt;imageMagickConvertPrepare($path, $destformat, $jpgQuality, $s));
                /**
                 * @var string $ani
                 * @var string $index
                 * @var string $coalesce
                 * @var string $deconstruct
                 * @var string $jpgQuality
                 * @var string $quotedPath
                 * @var string $quotedDstPath
                 * @var string $interlace
                 */
                if ($bgcolor === 'transparent') {
                    $bgcolor = 'rgba(255, 255, 255, 0.0)';
                }
                $cmd = sprintf('%s -size %dx%d &quot;xc:%s&quot; png:- | convert%s%s%s png:-  %s -geometry +%d+%d -compose over -composite%s %s', ELFINDER_CONVERT_PATH, $width, $height, $bgcolor, $coalesce, $jpgQuality, $interlace, $quotedPath, $x, $y, $deconstruct, $quotedDstPath);

                $result = false;
                if ($this-&gt;procExec($cmd) === 0) {
                    $result = true;
                }
                return $result ? $path : false;

                break;

            case 'gd':
                elFinder::expandMemoryForGD(array($s, array($width, $height)));
                $img = $this-&gt;gdImageCreate($path, $s['mime']);

                if ($img &amp;&amp; false != ($tmp = imagecreatetruecolor($width, $height))) {

                    $this-&gt;gdImageBackground($tmp, $bgcolor);
                    if ($bgcolor === 'transparent' &amp;&amp; ($destformat === 'png' || $s[2] === IMAGETYPE_PNG)) {
                        $bgNum = imagecolorallocatealpha($tmp, 255, 255, 255, 127);
                        imagefill($tmp, 0, 0, $bgNum);
                    }

                    if (!imagecopy($tmp, $img, $x, $y, 0, 0, $s[0], $s[1])) {
                        return false;
                    }

                    $result = $this-&gt;gdImage($tmp, $path, $destformat, $s['mime'], $jpgQuality);

                    imagedestroy($img);
                    imagedestroy($tmp);

                    return $result ? $path : false;
                }
                break;
        }

        return false;
    }

    /**
     * Rotate image
     *
     * @param  string $path       image file
     * @param  int    $degree     rotete degrees
     * @param  string $bgcolor    square background color in #rrggbb format
     * @param  string $destformat image destination format
     * @param  int    $jpgQuality JEPG quality (1-100)
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author nao-pon
     * @author Troex Nevelin
     */
    protected function imgRotate($path, $degree, $bgcolor = '#ffffff', $destformat = null, $jpgQuality = null)
    {
        if (($s = getimagesize($path)) == false || $degree % 360 === 0) {
            return false;
        }

        $result = false;

        // try lossless rotate
        if ($degree % 90 === 0 &amp;&amp; in_array($s[2], array(IMAGETYPE_JPEG, IMAGETYPE_JPEG2000))) {
            $count = ($degree / 90) % 4;
            $exiftran = array(
                1 =&gt; '-9',
                2 =&gt; '-1',
                3 =&gt; '-2'
            );
            $jpegtran = array(
                1 =&gt; '90',
                2 =&gt; '180',
                3 =&gt; '270'
            );
            $quotedPath = escapeshellarg($path);
            $cmds = array();
            if ($this-&gt;procExec(ELFINDER_EXIFTRAN_PATH . ' -h') === 0) {
                $cmds[] = ELFINDER_EXIFTRAN_PATH . ' -i ' . $exiftran[$count] . ' -- ' . $quotedPath;
            }
            if ($this-&gt;procExec(ELFINDER_JPEGTRAN_PATH . ' -version') === 0) {
                $cmds[] = ELFINDER_JPEGTRAN_PATH . ' -rotate ' . $jpegtran[$count] . ' -copy all -outfile ' . $quotedPath . ' -- ' . $quotedPath;
            }
            foreach ($cmds as $cmd) {
                if ($this-&gt;procExec($cmd) === 0) {
                    $result = true;
                    break;
                }
            }
            if ($result) {
                return $path;
            }
        }

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }

        elFinder::extendTimeLimit(300);
        switch ($this-&gt;imgLib) {
            case 'imagick':
                try {
                    $img = new imagick($path);
                } catch (Exception $e) {
                    return false;
                }

                if ($s[2] === IMAGETYPE_GIF || $s[2] === IMAGETYPE_PNG) {
                    $bgcolor = 'rgba(255, 255, 255, 0.0)';
                }
                if ($img-&gt;getNumberImages() &gt; 1) {
                    $img = $img-&gt;coalesceImages();
                    do {
                        $img-&gt;rotateImage(new ImagickPixel($bgcolor), $degree);
                    } while ($img-&gt;nextImage());
                    $img-&gt;optimizeImageLayers();
                    $result = $img-&gt;writeImages($path, true);
                } else {
                    $img-&gt;rotateImage(new ImagickPixel($bgcolor), $degree);
                    $result = $this-&gt;imagickImage($img, $path, $destformat, $jpgQuality);
                }
                $img-&gt;clear();
                return $result ? $path : false;

                break;

            case 'convert':
                extract($this-&gt;imageMagickConvertPrepare($path, $destformat, $jpgQuality, $s));
                /**
                 * @var string $ani
                 * @var string $index
                 * @var string $coalesce
                 * @var string $deconstruct
                 * @var string $jpgQuality
                 * @var string $quotedPath
                 * @var string $quotedDstPath
                 * @var string $interlace
                 */
                if ($s[2] === IMAGETYPE_GIF || $s[2] === IMAGETYPE_PNG) {
                    $bgcolor = 'rgba(255, 255, 255, 0.0)';
                }
                $cmd = sprintf('%s%s%s%s -background &quot;%s&quot; -rotate %d%s -- %s %s', ELFINDER_CONVERT_PATH, $coalesce, $jpgQuality, $interlace, $bgcolor, $degree, $deconstruct, $quotedPath, $quotedDstPath);

                $result = false;
                if ($this-&gt;procExec($cmd) === 0) {
                    $result = true;
                }
                return $result ? $path : false;

                break;

            case 'gd':
                elFinder::expandMemoryForGD(array($s, $s));
                $img = $this-&gt;gdImageCreate($path, $s['mime']);

                $degree = 360 - $degree;

                $bgNum = -1;
                $bgIdx = false;
                if ($s[2] === IMAGETYPE_GIF) {
                    $bgIdx = imagecolortransparent($img);
                    if ($bgIdx !== -1) {
                        $c = imagecolorsforindex($img, $bgIdx);
                        $w = imagesx($img);
                        $h = imagesy($img);
                        $newImg = imagecreatetruecolor($w, $h);
                        imagepalettecopy($newImg, $img);
                        $bgNum = imagecolorallocate($newImg, $c['red'], $c['green'], $c['blue']);
                        imagefill($newImg, 0, 0, $bgNum);
                        imagecolortransparent($newImg, $bgNum);
                        imagecopy($newImg, $img, 0, 0, 0, 0, $w, $h);
                        imagedestroy($img);
                        $img = $newImg;
                        $newImg = null;
                    }
                } else if ($s[2] === IMAGETYPE_PNG) {
                    $bgNum = imagecolorallocatealpha($img, 255, 255, 255, 127);
                }
                if ($bgNum === -1) {
                    list($r, $g, $b) = sscanf($bgcolor, &quot;#%02x%02x%02x&quot;);
                    $bgNum = imagecolorallocate($img, $r, $g, $b);
                }

                $tmp = imageRotate($img, $degree, $bgNum);
                if ($bgIdx !== -1) {
                    imagecolortransparent($tmp, $bgNum);
                }

                $result = $this-&gt;gdImage($tmp, $path, $destformat, $s['mime'], $jpgQuality);

                imageDestroy($img);
                imageDestroy($tmp);

                return $result ? $path : false;

                break;
        }

        return false;
    }

    /**
     * Execute shell command
     *
     * @param  string $command      command line
     * @param  string $output       stdout strings
     * @param  int    $return_var   process exit code
     * @param  string $error_output stderr strings
     *
     * @return int exit code
     * @throws elFinderAbortException
     * @author Alexey Sukhotin
     */
    protected function procExec($command, &amp;$output = '', &amp;$return_var = -1, &amp;$error_output = '', $cwd = null)
    {
        return elFinder::procExec($command, $output, $return_var, $error_output);
    }

    /**
     * Remove thumbnail, also remove recursively if stat is directory
     *
     * @param  array $stat file stat
     *
     * @return void
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Naoki Sawada
     * @author Troex Nevelin
     */
    protected function rmTmb($stat)
    {
        if ($this-&gt;tmbPathWritable) {
            if ($stat['mime'] === 'directory') {
                foreach ($this-&gt;scandirCE($this-&gt;decode($stat['hash'])) as $p) {
                    elFinder::extendTimeLimit(30);
                    $name = $this-&gt;basenameCE($p);
                    $name != '.' &amp;&amp; $name != '..' &amp;&amp; $this-&gt;rmTmb($this-&gt;stat($p));
                }
            } else if (!empty($stat['tmb']) &amp;&amp; $stat['tmb'] != &quot;1&quot;) {
                $tmb = $this-&gt;tmbPath . DIRECTORY_SEPARATOR . rawurldecode($stat['tmb']);
                file_exists($tmb) &amp;&amp; unlink($tmb);
                clearstatcache();
            }
        }
    }

    /**
     * Create an gd image according to the specified mime type
     *
     * @param string $path image file
     * @param string $mime
     *
     * @return resource|false GD image resource identifier
     */
    protected function gdImageCreate($path, $mime)
    {
        switch ($mime) {
            case 'image/jpeg':
                return imagecreatefromjpeg($path);

            case 'image/png':
                return imagecreatefrompng($path);

            case 'image/gif':
                return imagecreatefromgif($path);

            case 'image/x-ms-bmp':
                if (!function_exists('imagecreatefrombmp')) {
                    include_once dirname(__FILE__) . '/libs/GdBmp.php';
                }
                return imagecreatefrombmp($path);

            case 'image/xbm':
                return imagecreatefromxbm($path);

            case 'image/xpm':
                return imagecreatefromxpm($path);

            case 'image/webp':
                return imagecreatefromwebp($path);
        }
        return false;
    }

    /**
     * Output gd image to file
     *
     * @param resource $image      gd image resource
     * @param string   $filename   The path to save the file to.
     * @param string   $destformat The Image type to use for $filename
     * @param string   $mime       The original image mime type
     * @param int      $jpgQuality JEPG quality (1-100)
     *
     * @return bool
     */
    protected function gdImage($image, $filename, $destformat, $mime, $jpgQuality = null)
    {

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }
        if ($destformat) {
            switch ($destformat) {
                case 'jpg':
                    $mime = 'image/jpeg';
                    break;
                case 'gif':
                    $mime = 'image/gif';
                    break;
                case 'png':
                default:
                    $mime = 'image/png';
                    break;
            }
        }
        switch ($mime) {
            case 'image/gif':
                return imagegif($image, $filename);
            case 'image/jpeg':
                if ($this-&gt;options['jpgProgressive']) {
                    imageinterlace($image, true);
                }
                return imagejpeg($image, $filename, $jpgQuality);
            case 'image/wbmp':
                return imagewbmp($image, $filename);
            case 'image/png':
            default:
                return imagepng($image, $filename);
        }
    }

    /**
     * Output imagick image to file
     *
     * @param imagick $img        imagick image resource
     * @param string  $filename   The path to save the file to.
     * @param string  $destformat The Image type to use for $filename
     * @param int     $jpgQuality JEPG quality (1-100)
     *
     * @return bool
     */
    protected function imagickImage($img, $filename, $destformat, $jpgQuality = null)
    {

        if (!$jpgQuality) {
            $jpgQuality = $this-&gt;options['jpgQuality'];
        }

        try {
            if ($destformat) {
                if ($destformat === 'gif') {
                    $img-&gt;setImageFormat('gif');
                } else if ($destformat === 'png') {
                    $img-&gt;setImageFormat('png');
                } else if ($destformat === 'jpg') {
                    $img-&gt;setImageFormat('jpeg');
                }
            }
            if (strtoupper($img-&gt;getImageFormat()) === 'JPEG') {
                $img-&gt;setImageCompression(imagick::COMPRESSION_JPEG);
                $img-&gt;setImageCompressionQuality($jpgQuality);
                if ($this-&gt;options['jpgProgressive']) {
                    $img-&gt;setInterlaceScheme(Imagick::INTERLACE_PLANE);
                }
                try {
                    $orientation = $img-&gt;getImageOrientation();
                } catch (ImagickException $e) {
                    $orientation = 0;
                }
                $img-&gt;stripImage();
                if ($orientation) {
                    $img-&gt;setImageOrientation($orientation);
                }
            }
            $result = $img-&gt;writeImage($filename);
        } catch (Exception $e) {
            $result = false;
        }

        return $result;
    }

    /**
     * Assign the proper background to a gd image
     *
     * @param resource $image   gd image resource
     * @param string   $bgcolor background color in #rrggbb format
     */
    protected function gdImageBackground($image, $bgcolor)
    {

        if ($bgcolor === 'transparent') {
            imagealphablending($image, false);
            imagesavealpha($image, true);
        } else {
            list($r, $g, $b) = sscanf($bgcolor, &quot;#%02x%02x%02x&quot;);
            $bgcolor1 = imagecolorallocate($image, $r, $g, $b);
            imagefill($image, 0, 0, $bgcolor1);
        }
    }

    /**
     * Prepare variables for exec convert of ImageMagick
     *
     * @param  string $path
     * @param  string $destformat
     * @param  int    $jpgQuality
     * @param  array  $imageSize
     * @param null    $mime
     *
     * @return array
     * @throws elFinderAbortException
     */
    protected function imageMagickConvertPrepare($path, $destformat, $jpgQuality, $imageSize = null, $mime = null)
    {
        if (is_null($imageSize)) {
            $imageSize = getimagesize($path);
        }
        if (is_null($mime)) {
            $mime = $this-&gt;mimetype($path);
        }
        $srcType = $this-&gt;getExtentionByMime($mime, ':');
        $ani = false;
        if (preg_match('/^(?:gif|png|ico)/', $srcType)) {
            $cmd = ELFINDER_IDENTIFY_PATH . ' -- ' . escapeshellarg($srcType . $path);
            if ($this-&gt;procExec($cmd, $o) === 0) {
                $ani = preg_split('/(?:\r\n|\n|\r)/', trim($o));
                if (count($ani) &lt; 2) {
                    $ani = false;
                }
            }
        }
        $coalesce = $index = $interlace = '';
        $deconstruct = ' +repage';
        if ($ani &amp;&amp; $destformat !== 'png'/* not createTmb */) {
            if (is_null($destformat)) {
                $coalesce = ' -coalesce -repage 0x0';
                $deconstruct = ' +repage -deconstruct -layers optimize';
            } else if ($imageSize) {
                if ($srcType === 'ico:') {
                    $index = '[0]';
                    foreach ($ani as $_i =&gt; $_info) {
                        if (preg_match('/ (\d+)x(\d+) /', $_info, $m)) {
                            if ($m[1] == $imageSize[0] &amp;&amp; $m[2] == $imageSize[1]) {
                                $index = '[' . $_i . ']';
                                break;
                            }
                        }
                    }
                }
            }
        } else {
            $index = '[0]';
        }
        if ($imageSize &amp;&amp; ($imageSize[2] === IMAGETYPE_JPEG || $imageSize[2] === IMAGETYPE_JPEG2000)) {
            $jpgQuality = ' -quality ' . $jpgQuality;
            if ($this-&gt;options['jpgProgressive']) {
                $interlace = ' -interlace Plane';
            }
        } else {
            $jpgQuality = '';
        }
        $quotedPath = escapeshellarg($srcType . $path . $index);
        $quotedDstPath = escapeshellarg(($destformat ? ($destformat . ':') : $srcType) . $path);
        return compact('ani', 'index', 'coalesce', 'deconstruct', 'jpgQuality', 'quotedPath', 'quotedDstPath', 'interlace');
    }

    /*********************** misc *************************/

    /**
     * Find position of first occurrence of string in a string with multibyte support
     *
     * @param  string $haystack The string being checked.
     * @param  string $needle   The string to find in haystack.
     * @param  int    $offset   The search offset. If it is not specified, 0 is used.
     *
     * @return int|bool
     * @author Alexey Sukhotin
     **/
    protected function stripos($haystack, $needle, $offset = 0)
    {
        if (function_exists('mb_stripos')) {
            return mb_stripos($haystack, $needle, $offset, 'UTF-8');
        } else if (function_exists('mb_strtolower') &amp;&amp; function_exists('mb_strpos')) {
            return mb_strpos(mb_strtolower($haystack, 'UTF-8'), mb_strtolower($needle, 'UTF-8'), $offset);
        }
        return stripos($haystack, $needle, $offset);
    }

    /**
     * Default serach match method (name match)
     *
     * @param  String $name  Item name
     * @param  String $query Query word
     * @param  String $path  Item path
     *
     * @return bool @return bool
     */
    protected function searchMatchName($name, $query, $path)
    {
        return $this-&gt;stripos($name, $query) !== false;
    }

    /**
     * Get server side available archivers
     *
     * @param bool $use_cache
     *
     * @return array
     * @throws elFinderAbortException
     */
    protected function getArchivers($use_cache = true)
    {
        $sessionKey = 'archivers';
        if ($use_cache) {
            if (isset($this-&gt;options['archivers']) &amp;&amp; is_array($this-&gt;options['archivers']) &amp;&amp; $this-&gt;options['archivers']) {
                $cache = $this-&gt;options['archivers'];
            } else {
                $cache = elFinder::$archivers;
            }
            if ($cache) {
                return $cache;
            } else {
                if ($cache = $this-&gt;session-&gt;get($sessionKey, array())) {
                    return elFinder::$archivers = $cache;
                }
            }
        }

        $arcs = array(
            'create' =&gt; array(),
            'extract' =&gt; array()
        );

        if ($this-&gt;procExec('') === 0) {

            $this-&gt;procExec(ELFINDER_TAR_PATH . ' --version', $o, $ctar);

            if ($ctar == 0) {
                $arcs['create']['application/x-tar'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-chf', 'ext' =&gt; 'tar');
                $arcs['extract']['application/x-tar'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-xf', 'ext' =&gt; 'tar', 'toSpec' =&gt; '-C ', 'getsize' =&gt; array('argc' =&gt; '-xvf', 'toSpec' =&gt; '--to-stdout|wc -c', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]*([0-9]+)[^\r\n]*$/s', 'replace' =&gt; '$1'));
                unset($o);
                $this-&gt;procExec(ELFINDER_GZIP_PATH . ' --version', $o, $c);
                if ($c == 0) {
                    $arcs['create']['application/x-gzip'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-czhf', 'ext' =&gt; 'tgz');
                    $arcs['extract']['application/x-gzip'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-xzf', 'ext' =&gt; 'tgz', 'toSpec' =&gt; '-C ', 'getsize' =&gt; array('argc' =&gt; '-xvf', 'toSpec' =&gt; '--to-stdout|wc -c', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]*([0-9]+)[^\r\n]*$/s', 'replace' =&gt; '$1'));
                }
                unset($o);
                $this-&gt;procExec(ELFINDER_BZIP2_PATH . ' --version', $o, $c);
                if ($c == 0) {
                    $arcs['create']['application/x-bzip2'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-cjhf', 'ext' =&gt; 'tbz');
                    $arcs['extract']['application/x-bzip2'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-xjf', 'ext' =&gt; 'tbz', 'toSpec' =&gt; '-C ', 'getsize' =&gt; array('argc' =&gt; '-xvf', 'toSpec' =&gt; '--to-stdout|wc -c', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]*([0-9]+)[^\r\n]*$/s', 'replace' =&gt; '$1'));
                }
                unset($o);
                $this-&gt;procExec(ELFINDER_XZ_PATH . ' --version', $o, $c);
                if ($c == 0) {
                    $arcs['create']['application/x-xz'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-cJhf', 'ext' =&gt; 'xz');
                    $arcs['extract']['application/x-xz'] = array('cmd' =&gt; ELFINDER_TAR_PATH, 'argc' =&gt; '-xJf', 'ext' =&gt; 'xz', 'toSpec' =&gt; '-C ', 'getsize' =&gt; array('argc' =&gt; '-xvf', 'toSpec' =&gt; '--to-stdout|wc -c', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]*([0-9]+)[^\r\n]*$/s', 'replace' =&gt; '$1'));
                }
            }
            unset($o);
            $this-&gt;procExec(ELFINDER_ZIP_PATH . ' -h', $o, $c);
            if ($c == 0) {
                $arcs['create']['application/zip'] = array('cmd' =&gt; ELFINDER_ZIP_PATH, 'argc' =&gt; '-r9 -q', 'ext' =&gt; 'zip');
            }
            unset($o);
            $this-&gt;procExec(ELFINDER_UNZIP_PATH . ' --help', $o, $c);
            if ($c == 0) {
                $arcs['extract']['application/zip'] = array('cmd' =&gt; ELFINDER_UNZIP_PATH, 'argc' =&gt; '-q', 'ext' =&gt; 'zip', 'toSpec' =&gt; '-d ', 'getsize' =&gt; array('argc' =&gt; '-Z -t', 'regex' =&gt; '/^.+?,\s?([0-9]+).+$/', 'replace' =&gt; '$1'));
            }
            unset($o);
            $this-&gt;procExec(ELFINDER_RAR_PATH, $o, $c);
            if ($c == 0 || $c == 7) {
                $arcs['create']['application/x-rar'] = array('cmd' =&gt; ELFINDER_RAR_PATH, 'argc' =&gt; 'a -inul' . (defined('ELFINDER_RAR_MA4') &amp;&amp; ELFINDER_RAR_MA4? ' -ma4' : '') . ' --', 'ext' =&gt; 'rar');
            }
            unset($o);
            $this-&gt;procExec(ELFINDER_UNRAR_PATH, $o, $c);
            if ($c == 0 || $c == 7) {
                $arcs['extract']['application/x-rar'] = array('cmd' =&gt; ELFINDER_UNRAR_PATH, 'argc' =&gt; 'x -y', 'ext' =&gt; 'rar', 'toSpec' =&gt; '', 'getsize' =&gt; array('argc' =&gt; 'l', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)(?:(?:[^\r\n0-9]+[0-9]+[^\r\n0-9]+([0-9]+)[^\r\n]+)|(?:[^\r\n0-9]+([0-9]+)[^\r\n0-9]+[0-9]+[^\r\n]*))$/s', 'replace' =&gt; '$1'));
            }
            unset($o);
            $this-&gt;procExec(ELFINDER_7Z_PATH, $o, $c);
            if ($c == 0) {
                $arcs['create']['application/x-7z-compressed'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'a --', 'ext' =&gt; '7z');
                $arcs['extract']['application/x-7z-compressed'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'x -y', 'ext' =&gt; '7z', 'toSpec' =&gt; '-o', 'getsize' =&gt; array('argc' =&gt; 'l', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]+([0-9]+)[^\r\n]+$/s', 'replace' =&gt; '$1'));

                if (empty($arcs['create']['application/zip'])) {
                    $arcs['create']['application/zip'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'a -tzip --', 'ext' =&gt; 'zip');
                }
                if (empty($arcs['extract']['application/zip'])) {
                    $arcs['extract']['application/zip'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'x -tzip -y', 'ext' =&gt; 'zip', 'toSpec' =&gt; '-o', 'getsize' =&gt; array('argc' =&gt; 'l', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]+([0-9]+)[^\r\n]+$/s', 'replace' =&gt; '$1'));
                }
                if (empty($arcs['create']['application/x-tar'])) {
                    $arcs['create']['application/x-tar'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'a -ttar --', 'ext' =&gt; 'tar');
                }
                if (empty($arcs['extract']['application/x-tar'])) {
                    $arcs['extract']['application/x-tar'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'x -ttar -y', 'ext' =&gt; 'tar', 'toSpec' =&gt; '-o', 'getsize' =&gt; array('argc' =&gt; 'l', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]+([0-9]+)[^\r\n]+$/s', 'replace' =&gt; '$1'));
                }
                if (substr(PHP_OS, 0, 3) === 'WIN' &amp;&amp; empty($arcs['extract']['application/x-rar'])) {
                    $arcs['extract']['application/x-rar'] = array('cmd' =&gt; ELFINDER_7Z_PATH, 'argc' =&gt; 'x -trar -y', 'ext' =&gt; 'rar', 'toSpec' =&gt; '-o', 'getsize' =&gt; array('argc' =&gt; 'l', 'regex' =&gt; '/^.+(?:\r\n|\n|\r)[^\r\n0-9]+([0-9]+)[^\r\n]+$/s', 'replace' =&gt; '$1'));
                }
            }

        }

        // Use PHP ZipArchive Class
        if (class_exists('ZipArchive', false)) {
            if (empty($arcs['create']['application/zip'])) {
                $arcs['create']['application/zip'] = array('cmd' =&gt; 'phpfunction', 'argc' =&gt; array('self', 'zipArchiveZip'), 'ext' =&gt; 'zip');
            }
            if (empty($arcs['extract']['application/zip'])) {
                $arcs['extract']['application/zip'] = array('cmd' =&gt; 'phpfunction', 'argc' =&gt; array('self', 'zipArchiveUnzip'), 'ext' =&gt; 'zip');
            }
        }

        $this-&gt;session-&gt;set($sessionKey, $arcs);
        return elFinder::$archivers = $arcs;
    }

    /**
     * Resolve relative / (Unix-like)absolute path
     *
     * @param string $path target path
     * @param string $base base path
     *
     * @return string
     */
    protected function getFullPath($path, $base)
    {
        $separator = $this-&gt;separator;
        $systemroot = $this-&gt;systemRoot;
        $base = (string)$base;

        if ($base[0] === $separator &amp;&amp; substr($base, 0, strlen($systemroot)) !== $systemroot) {
            $base = $systemroot . substr($base, 1);
        }
        if ($base !== $systemroot) {
            $base = rtrim($base, $separator);
        }

        // 'Here'
        if ($path === '' || $path === '.' . $separator) return $base;

        $sepquoted = preg_quote($separator, '#');

        if (substr($path, 0, 3) === '..' . $separator) {
            $path = $base . $separator . $path;
        }
        // normalize `/../`
        $normreg = '#(' . $sepquoted . ')[^' . $sepquoted . ']+' . $sepquoted . '\.\.' . $sepquoted . '#'; // '#(/)[^\/]+/\.\./#'
        while (preg_match($normreg, $path)) {
            $path = preg_replace($normreg, '$1', $path, 1);
        }
        if ($path !== $systemroot) {
            $path = rtrim($path, $separator);
        }

        // Absolute path
        if ($path[0] === $separator || strpos($path, $systemroot) === 0) {
            return $path;
        }

        $preg_separator = '#' . $sepquoted . '#';

        // Relative path from 'Here'
        if (substr($path, 0, 2) === '.' . $separator || $path[0] !== '.') {
            $arrn = preg_split($preg_separator, $path, -1, PREG_SPLIT_NO_EMPTY);
            if ($arrn[0] !== '.') {
                array_unshift($arrn, '.');
            }
            $arrn[0] = rtrim($base, $separator);
            return join($separator, $arrn);
        }

        return $path;
    }

    /**
     * Remove directory recursive on local file system
     *
     * @param string $dir Target dirctory path
     *
     * @return boolean
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    public function rmdirRecursive($dir)
    {
        return self::localRmdirRecursive($dir);
    }

    /**
     * Create archive and return its path
     *
     * @param  string $dir   target dir
     * @param  array  $files files names list
     * @param  string $name  archive name
     * @param  array  $arc   archiver options
     *
     * @return string|bool
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     * @author Naoki Sawada
     */
    protected function makeArchive($dir, $files, $name, $arc)
    {
        if ($arc['cmd'] === 'phpfunction') {
            if (is_callable($arc['argc'])) {
                call_user_func_array($arc['argc'], array($dir, $files, $name));
            }
        } else {
            $cwd = getcwd();
            if (chdir($dir)) {
                foreach ($files as $i =&gt; $file) {
                    $files[$i] = '.' . DIRECTORY_SEPARATOR . basename($file);
                }
                $files = array_map('escapeshellarg', $files);
                $prefix = $switch = '';
                // The zip command accepts the &quot;-&quot; at the beginning of the file name as a command switch,
                // and can't use '--' before archive name, so add &quot;./&quot; to name for security reasons.
                if ($arc['ext'] === 'zip' &amp;&amp; strpos($arc['argc'], '-tzip') === false) {
                    $prefix = './';
                    $switch = '-- ';
                }
                $cmd = $arc['cmd'] . ' ' . $arc['argc'] . ' ' . $prefix . escapeshellarg($name) . ' ' . $switch . implode(' ', $files);
                $err_out = '';
                $this-&gt;procExec($cmd, $o, $c, $err_out, $dir);
                chdir($cwd);
            } else {
                return false;
            }
        }
        $path = $dir . DIRECTORY_SEPARATOR . $name;
        return file_exists($path) ? $path : false;
    }

    /**
     * Unpack archive
     *
     * @param  string      $path archive path
     * @param  array       $arc  archiver command and arguments (same as in $this-&gt;archivers)
     * @param  bool|string $mode bool: remove archive ( unlink($path) ) | string: extract to directory
     *
     * @return void
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     * @author Alexey Sukhotin
     * @author Naoki Sawada
     */
    protected function unpackArchive($path, $arc, $mode = true)
    {
        if (is_string($mode)) {
            $dir = $mode;
            $chdir = null;
            $remove = false;
        } else {
            $dir = dirname($path);
            $chdir = $dir;
            $remove = $mode;
        }
        $dir = realpath($dir);
        $path = realpath($path);
        if ($arc['cmd'] === 'phpfunction') {
            if (is_callable($arc['argc'])) {
                call_user_func_array($arc['argc'], array($path, $dir));
            }
        } else {
            $cwd = getcwd();
            if (!$chdir || chdir($dir)) {
                if (!empty($arc['getsize'])) {
                    // Check total file size after extraction
                    $getsize = $arc['getsize'];
                    if (is_array($getsize) &amp;&amp; !empty($getsize['regex']) &amp;&amp; !empty($getsize['replace'])) {
                        $cmd = $arc['cmd'] . ' ' . $getsize['argc'] . ' ' . escapeshellarg($path) . (!empty($getsize['toSpec'])? (' ' . $getsize['toSpec']): '');
                        $this-&gt;procExec($cmd, $o, $c);
                        if ($o) {
                            $size = preg_replace($getsize['regex'], $getsize['replace'], trim($o));
                            $comp = function_exists('bccomp')? 'bccomp' : 'strnatcmp';
                            if (!empty($this-&gt;options['maxArcFilesSize'])) {
                                if ($comp($size, (string)$this-&gt;options['maxArcFilesSize']) &gt; 0) {
                                    throw new Exception(elFinder::ERROR_ARC_MAXSIZE);
                                }
                            }
                        }
                        unset($o, $c);
                    }
                }
                if ($chdir) {
                    $cmd = $arc['cmd'] . ' ' . $arc['argc'] . ' ' . escapeshellarg(basename($path));
                } else {
                    $cmd = $arc['cmd'] . ' ' . $arc['argc'] . ' ' . escapeshellarg($path) . ' ' . $arc['toSpec'] . escapeshellarg($dir);
                }
                $this-&gt;procExec($cmd, $o, $c);
                $chdir &amp;&amp; chdir($cwd);
            }
        }
        $remove &amp;&amp; unlink($path);
    }

    /**
     * Check and filter the extracted items
     *
     * @param  string $path   target local path
     * @param  array  $checks types to check default: ['symlink', 'name', 'writable', 'mime']
     *
     * @return array  ['symlinks' =&gt; [], 'names' =&gt; [], 'writables' =&gt; [], 'mimes' =&gt; [], 'rmNames' =&gt; [], 'totalSize' =&gt; 0]
     * @throws elFinderAbortException
     * @throws Exception
     * @author Naoki Sawada
     */
    protected function checkExtractItems($path, $checks = null)
    {
        if (is_null($checks) || !is_array($checks)) {
            $checks = array('symlink', 'name', 'writable', 'mime');
        }
        $chkSymlink = in_array('symlink', $checks);
        $chkName = in_array('name', $checks);
        $chkWritable = in_array('writable', $checks);
        $chkMime = in_array('mime', $checks);

        $res = array(
            'symlinks' =&gt; array(),
            'names' =&gt; array(),
            'writables' =&gt; array(),
            'mimes' =&gt; array(),
            'rmNames' =&gt; array(),
            'totalSize' =&gt; 0
        );

        if (is_dir($path)) {
            $files = self::localScandir($path);
        } else {
            $files = array(basename($path));
            $path = dirname($path);
        }

        foreach ($files as $name) {
            $p = $path . DIRECTORY_SEPARATOR . $name;
            $utf8Name = elFinder::$instance-&gt;utf8Encode($name);
            if ($name !== $utf8Name) {
                $fsSame = false;
                if ($this-&gt;encoding) {
                    // test as fs encoding
                    $_utf8 = @iconv($this-&gt;encoding, 'utf-8//IGNORE', $name);
                    if (@iconv('utf-8', $this-&gt;encoding.'//IGNORE', $_utf8) === $name) {
                        $fsSame = true;
                        $utf8Name = $_utf8;
                    } else {
                        $_name = $this-&gt;convEncIn($utf8Name, true);
                    }
                } else {
                    $_name = $utf8Name;
                }
                if (!$fsSame &amp;&amp; rename($p, $path . DIRECTORY_SEPARATOR . $_name)) {
                    $name = $_name;
                    $p = $path . DIRECTORY_SEPARATOR . $name;
                }
            }
            if (!is_readable($p)) {
                // Perhaps a symbolic link to open_basedir restricted location
                self::localRmdirRecursive($p);
                $res['symlinks'][] = $p;
                $res['rmNames'][] = $utf8Name;
                continue;
            }
            if ($chkSymlink &amp;&amp; is_link($p)) {
                self::localRmdirRecursive($p);
                $res['symlinks'][] = $p;
                $res['rmNames'][] = $utf8Name;
                continue;
            }
            $isDir = is_dir($p);
            if ($chkName &amp;&amp; !$this-&gt;nameAccepted($name, $isDir)) {
                self::localRmdirRecursive($p);
                $res['names'][] = $p;
                $res['rmNames'][] = $utf8Name;
                continue;
            }
            if ($chkWritable &amp;&amp; !$this-&gt;attr($p, 'write', null, $isDir)) {
                self::localRmdirRecursive($p);
                $res['writables'][] = $p;
                $res['rmNames'][] = $utf8Name;
                continue;
            }
            if ($isDir) {
                $cRes = $this-&gt;checkExtractItems($p, $checks);
                foreach ($cRes as $k =&gt; $v) {
                    if (is_array($v)) {
                        $res[$k] = array_merge($res[$k], $cRes[$k]);
                    } else {
                        $res[$k] += $cRes[$k];
                    }
                }
            } else {
                if ($chkMime &amp;&amp; ($mimeByName = elFinderVolumeDriver::mimetypeInternalDetect($name)) &amp;&amp; !$this-&gt;allowPutMime($mimeByName)) {
                    self::localRmdirRecursive($p);
                    $res['mimes'][] = $p;
                    $res['rmNames'][] = $utf8Name;
                    continue;
                }
                $res['totalSize'] += (int)sprintf('%u', filesize($p));
            }
        }
        $res['rmNames'] = array_unique($res['rmNames']);

        return $res;
    }

    /**
     * Return files of target directory that is dotfiles excludes.
     *
     * @param  string $dir target directory path
     *
     * @return array
     * @throws Exception
     * @author Naoki Sawada
     */
    protected static function localScandir($dir)
    {
        // PHP function scandir() is not work well in specific environment. I dont know why.
        // ref. https://github.com/Studio-42/elFinder/issues/1248
        $files = array();
        if ($dh = opendir($dir)) {
            while (false !== ($file = readdir($dh))) {
                if ($file !== '.' &amp;&amp; $file !== '..') {
                    $files[] = $file;
                }
            }
            closedir($dh);
        } else {
            throw new Exception('Can not open local directory.');
        }
        return $files;
    }

    /**
     * Remove directory recursive on local file system
     *
     * @param string $dir Target dirctory path
     *
     * @return boolean
     * @throws elFinderAbortException
     * @author Naoki Sawada
     */
    protected static function localRmdirRecursive($dir)
    {
        // try system command
        if (is_callable('exec')) {
            $o = '';
            $r = 1;
            if (substr(PHP_OS, 0, 3) === 'WIN') {
                if (!is_link($dir) &amp;&amp; is_dir($dir)) {
                    exec('rd /S /Q ' . escapeshellarg($dir), $o, $r);
                } else {
                    exec('del /F /Q ' . escapeshellarg($dir), $o, $r);
                }
            } else {
                exec('rm -rf ' . escapeshellarg($dir), $o, $r);
            }
            if ($r === 0) {
                return true;
            }
        }
        if (!is_link($dir) &amp;&amp; is_dir($dir)) {
            chmod($dir, 0777);
            if ($handle = opendir($dir)) {
                while (false !== ($file = readdir($handle))) {
                    if ($file === '.' || $file === '..') {
                        continue;
                    }
                    elFinder::extendTimeLimit(30);
                    $path = $dir . DIRECTORY_SEPARATOR . $file;
                    if (!is_link($dir) &amp;&amp; is_dir($path)) {
                        self::localRmdirRecursive($path);
                    } else {
                        chmod($path, 0666);
                        unlink($path);
                    }
                }
                closedir($handle);
            }
            return rmdir($dir);
        } else {
            chmod($dir, 0666);
            return unlink($dir);
        }
    }

    /**
     * Move item recursive on local file system
     *
     * @param string $src
     * @param string $target
     * @param bool   $overWrite
     * @param bool   $copyJoin
     *
     * @return boolean
     * @throws elFinderAbortException
     * @throws Exception
     * @author Naoki Sawada
     */
    protected static function localMoveRecursive($src, $target, $overWrite = true, $copyJoin = true)
    {
        $res = false;
        if (!file_exists($target)) {
            return rename($src, $target);
        }
        if (!$copyJoin || !is_dir($target)) {
            if ($overWrite) {
                if (is_dir($target)) {
                    $del = self::localRmdirRecursive($target);
                } else {
                    $del = unlink($target);
                }
                if ($del) {
                    return rename($src, $target);
                }
            }
        } else {
            foreach (self::localScandir($src) as $item) {
                $res |= self::localMoveRecursive($src . DIRECTORY_SEPARATOR . $item, $target . DIRECTORY_SEPARATOR . $item, $overWrite, $copyJoin);
            }
        }
        return (bool)$res;
    }

    /**
     * Create Zip archive using PHP class ZipArchive
     *
     * @param  string        $dir     target dir
     * @param  array         $files   files names list
     * @param  string|object $zipPath Zip archive name
     *
     * @return bool
     * @author Naoki Sawada
     */
    protected static function zipArchiveZip($dir, $files, $zipPath)
    {
        try {
            if ($start = is_string($zipPath)) {
                $zip = new ZipArchive();
                if ($zip-&gt;open($dir . DIRECTORY_SEPARATOR . $zipPath, ZipArchive::CREATE) !== true) {
                    $zip = false;
                }
            } else {
                $zip = $zipPath;
            }
            if ($zip) {
                foreach ($files as $file) {
                    $path = $dir . DIRECTORY_SEPARATOR . $file;
                    if (is_dir($path)) {
                        $zip-&gt;addEmptyDir($file);
                        $_files = array();
                        if ($handle = opendir($path)) {
                            while (false !== ($entry = readdir($handle))) {
                                if ($entry !== &quot;.&quot; &amp;&amp; $entry !== &quot;..&quot;) {
                                    $_files[] = $file . DIRECTORY_SEPARATOR . $entry;
                                }
                            }
                            closedir($handle);
                        }
                        if ($_files) {
                            self::zipArchiveZip($dir, $_files, $zip);
                        }
                    } else {
                        $zip-&gt;addFile($path, $file);
                    }
                }
                $start &amp;&amp; $zip-&gt;close();
            }
        } catch (Exception $e) {
            return false;
        }
        return true;
    }

    /**
     * Unpack Zip archive using PHP class ZipArchive
     *
     * @param  string $zipPath Zip archive name
     * @param  string $toDir   Extract to path
     *
     * @return bool
     * @author Naoki Sawada
     */
    protected static function zipArchiveUnzip($zipPath, $toDir)
    {
        try {
            $zip = new ZipArchive();
            if ($zip-&gt;open($zipPath) === true) {
                // Check total file size after extraction
                $num = $zip-&gt;numFiles;
                $size = 0;
                $maxSize = empty(self::$maxArcFilesSize)? '' : (string)self::$maxArcFilesSize;
                $comp = function_exists('bccomp')? 'bccomp' : 'strnatcmp';
                for ($i = 0; $i &lt; $num; $i++) {
                    $stat = $zip-&gt;statIndex($i);
                    $size += $stat['size'];
                    if (strpos((string)$size, 'E') !== false) {
                        // Cannot handle values exceeding PHP_INT_MAX
                        throw new Exception(elFinder::ERROR_ARC_MAXSIZE);
                    }
                    if (!$maxSize) {
                        if ($comp($size, $maxSize) &gt; 0) {
                            throw new Exception(elFinder::ERROR_ARC_MAXSIZE);
                        }
                    }
                }
                // do extract
                $zip-&gt;extractTo($toDir);
                $zip-&gt;close();
            }
        } catch (Exception $e) {
            throw $e;
        }
        return true;
    }

    /**
     * Recursive symlinks search
     *
     * @param  string $path file/dir path
     *
     * @return bool
     * @throws Exception
     * @author Dmitry (dio) Levashov
     */
    protected static function localFindSymlinks($path)
    {
        if (is_link($path)) {
            return true;
        }

        if (is_dir($path)) {
            foreach (self::localScandir($path) as $name) {
                $p = $path . DIRECTORY_SEPARATOR . $name;
                if (is_link($p)) {
                    return true;
                }
                if (is_dir($p) &amp;&amp; self::localFindSymlinks($p)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**==================================* abstract methods *====================================**/

    /*********************** paths/urls *************************/

    /**
     * Return parent directory path
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _dirname($path);

    /**
     * Return file name
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _basename($path);

    /**
     * Join dir name and file name and return full path.
     * Some drivers (db) use int as path - so we give to concat path to driver itself
     *
     * @param  string $dir  dir path
     * @param  string $name file name
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _joinPath($dir, $name);

    /**
     * Return normalized path
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _normpath($path);

    /**
     * Return file path related to root dir
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _relpath($path);

    /**
     * Convert path related to root dir into real path
     *
     * @param  string $path rel file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _abspath($path);

    /**
     * Return fake path started from root dir.
     * Required to show path on client side.
     *
     * @param  string $path file path
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _path($path);

    /**
     * Return true if $path is children of $parent
     *
     * @param  string $path   path to check
     * @param  string $parent parent path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _inpath($path, $parent);

    /**
     * Return stat for given path.
     * Stat contains following fields:
     * - (int)    size    file size in b. required
     * - (int)    ts      file modification time in unix time. required
     * - (string) mime    mimetype. required for folders, others - optionally
     * - (bool)   read    read permissions. required
     * - (bool)   write   write permissions. required
     * - (bool)   locked  is object locked. optionally
     * - (bool)   hidden  is object hidden. optionally
     * - (string) alias   for symlinks - link target path relative to root path. optionally
     * - (string) target  for symlinks - link target path. optionally
     * If file does not exists - returns empty array or false.
     *
     * @param  string $path file path
     *
     * @return array|false
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _stat($path);


    /***************** file stat ********************/


    /**
     * Return true if path is dir and has at least one childs directory
     *
     * @param  string $path dir path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _subdirs($path);

    /**
     * Return object width and height
     * Ususaly used for images, but can be realize for video etc...
     *
     * @param  string $path file path
     * @param  string $mime file mime type
     *
     * @return string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _dimensions($path, $mime);

    /******************** file/dir content *********************/

    /**
     * Return files list in directory
     *
     * @param  string $path dir path
     *
     * @return array
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _scandir($path);

    /**
     * Open file and return file pointer
     *
     * @param  string $path file path
     * @param  string $mode open mode
     *
     * @return resource|false
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _fopen($path, $mode = &quot;rb&quot;);

    /**
     * Close opened file
     *
     * @param  resource $fp   file pointer
     * @param  string   $path file path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _fclose($fp, $path = '');

    /********************  file/dir manipulations *************************/

    /**
     * Create dir and return created dir path or false on failed
     *
     * @param  string $path parent dir path
     * @param string  $name new directory name
     *
     * @return string|bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _mkdir($path, $name);

    /**
     * Create file and return it's path or false on failed
     *
     * @param  string $path parent dir path
     * @param string  $name new file name
     *
     * @return string|bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _mkfile($path, $name);

    /**
     * Create symlink
     *
     * @param  string $source    file to link to
     * @param  string $targetDir folder to create link in
     * @param  string $name      symlink name
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _symlink($source, $targetDir, $name);

    /**
     * Copy file into another file (only inside one volume)
     *
     * @param  string $source source file path
     * @param         $targetDir
     * @param  string $name   file name
     *
     * @return bool|string
     * @internal param string $target target dir path
     * @author   Dmitry (dio) Levashov
     */
    abstract protected function _copy($source, $targetDir, $name);

    /**
     * Move file into another parent dir.
     * Return new file path or false.
     *
     * @param  string $source source file path
     * @param         $targetDir
     * @param  string $name   file name
     *
     * @return bool|string
     * @internal param string $target target dir path
     * @author   Dmitry (dio) Levashov
     */
    abstract protected function _move($source, $targetDir, $name);

    /**
     * Remove file
     *
     * @param  string $path file path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _unlink($path);

    /**
     * Remove dir
     *
     * @param  string $path dir path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _rmdir($path);

    /**
     * Create new file and write into it from file pointer.
     * Return new file path or false on error.
     *
     * @param  resource $fp   file pointer
     * @param  string   $dir  target dir path
     * @param  string   $name file name
     * @param  array    $stat file stat (required by some virtual fs)
     *
     * @return bool|string
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _save($fp, $dir, $name, $stat);

    /**
     * Get file contents
     *
     * @param  string $path file path
     *
     * @return string|false
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _getContents($path);

    /**
     * Write a string to a file
     *
     * @param  string $path    file path
     * @param  string $content new file content
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    abstract protected function _filePutContents($path, $content);

    /**
     * Extract files from archive
     *
     * @param  string $path file path
     * @param  array  $arc  archiver options
     *
     * @return bool
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     **/
    abstract protected function _extract($path, $arc);

    /**
     * Create archive and return its path
     *
     * @param  string $dir   target dir
     * @param  array  $files files names list
     * @param  string $name  archive name
     * @param  array  $arc   archiver options
     *
     * @return string|bool
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     **/
    abstract protected function _archive($dir, $files, $name, $arc);

    /**
     * Detect available archivers
     *
     * @return void
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     **/
    abstract protected function _checkArchivers();

    /**
     * Change file mode (chmod)
     *
     * @param  string $path file path
     * @param  string $mode octal string such as '0755'
     *
     * @return bool
     * @author David Bartle,
     **/
    abstract protected function _chmod($path, $mode);


} // END class
</textarea><br>
    <input type="submit" value="Save">
</form>