/**

protected $version = '2.0';

/**

protected $volumes = array();

/**

public static $netDrivers = array();

/**

public static $locale = '';

/**

public static $sessionCacheKey = '';

/**

private static $sessionClosed = false;

/**

protected static $base64encodeSessionData = false;

/**

protected static $commonTempPath = '';

/**

protected $netVolumesSessionKey = '';

/**

public static $volumesCnt = 1;

/**

protected $default = null;

/**

protected $commands = array(

'open' => array('target' => false, 'tree' => false, 'init' => false, 'mimes' => false, 'compare' => false),

'ls' => array('target' => true, 'mimes' => false),

'tree' => array('target' => true),

'parents' => array('target' => true),

'tmb' => array('targets' => true),

'file' => array('target' => true, 'download' => false),

'zipdl' => array('targets' => true, 'download' => false),

'size' => array('targets' => true),

'mkdir' => array('target' => true, 'name' => true),

'mkfile' => array('target' => true, 'name' => true, 'mimes' => false),

'rm' => array('targets' => true),

'rename' => array('target' => true, 'name' => true, 'mimes' => false),

'duplicate' => array('targets' => true, 'suffix' => false),

'paste' => array('dst' => true, 'targets' => true, 'cut' => false, 'mimes' => false, 'renames' => false, 'suffix' => false),

'upload' => array('target' => true, 'FILES' => true, 'mimes' => false, 'html' => false, 'upload' => false, 'name' => false, 'upload_path' => false, 'chunk' => false, 'cid' => false, 'node' => false, 'renames' => false, 'suffix' => false),

'get' => array('target' => true, 'conv' => false),

'put' => array('target' => true, 'content' => '', 'mimes' => false),

'archive' => array('targets' => true, 'type' => true, 'mimes' => false, 'name' => false),

'extract' => array('target' => true, 'mimes' => false, 'makedir' => false),

'search' => array('q' => true, 'mimes' => false, 'target' => false),

'info' => array('targets' => true, 'compare' => false),

'dim' => array('target' => true),

'resize' => array('target' => true, 'width' => true, 'height' => true, 'mode' => false, 'x' => false, 'y' => false, 'degree' => false, 'quality' => false),

'netmount' => array('protocol' => true, 'host' => true, 'path' => false, 'port' => false, 'user' => false, 'pass' => false, 'alias' => false, 'options' => false),

'url' => array('target' => true, 'options' => false),

'callback' => array('node' => true, 'json' => false, 'bind' => false, 'done' => false),

'chmod' => array('targets' => true, 'mode' => true)

);

/**

protected $plugins = array();

/**

protected $listeners = array();

/**

protected $time = 0;

/**

protected $loaded = false;

/**

protected $debug = false;

/**

protected $sessionCloseEarlier = true;

/**

protected $sessionUseCmds = array();

/**

protected $timeout = 0;

/**

protected $uploadTempPath = '';

/**

protected $maxArcFilesSize = 0;

/**

protected $uploadDebug = '';

/**

public $mountErrors = array();

/**

protected $callbackWindowURL = '';

// Errors messages

const ERROR_UNKNOWN = 'errUnknown';

const ERROR_UNKNOWN_CMD = 'errUnknownCmd';

const ERROR_CONF = 'errConf';

const ERROR_CONF_NO_JSON = 'errJSON';

const ERROR_CONF_NO_VOL = 'errNoVolumes';

const ERROR_INV_PARAMS = 'errCmdParams';

const ERROR_OPEN = 'errOpen';

const ERROR_DIR_NOT_FOUND = 'errFolderNotFound';

const ERROR_FILE_NOT_FOUND = 'errFileNotFound'; // 'File not found.'

const ERROR_TRGDIR_NOT_FOUND = 'errTrgFolderNotFound'; // 'Target folder "$1" not found.'

const ERROR_NOT_DIR = 'errNotFolder';

const ERROR_NOT_FILE = 'errNotFile';

const ERROR_PERM_DENIED = 'errPerm';

const ERROR_LOCKED = 'errLocked'; // '"$1" is locked and can not be renamed, moved or removed.'

const ERROR_EXISTS = 'errExists'; // 'File named "$1" already exists.'

const ERROR_INVALID_NAME = 'errInvName'; // 'Invalid file name.'

const ERROR_MKDIR = 'errMkdir';

const ERROR_MKFILE = 'errMkfile';

const ERROR_RENAME = 'errRename';

const ERROR_COPY = 'errCopy';

const ERROR_MOVE = 'errMove';

const ERROR_COPY_FROM = 'errCopyFrom';

const ERROR_COPY_TO = 'errCopyTo';

const ERROR_COPY_ITSELF = 'errCopyInItself';

const ERROR_REPLACE = 'errReplace'; // 'Unable to replace "$1".'

const ERROR_RM = 'errRm'; // 'Unable to remove "$1".'

const ERROR_RM_SRC = 'errRmSrc'; // 'Unable remove source file(s)'

const ERROR_MKOUTLINK = 'errMkOutLink'; // 'Unable to create a link to outside the volume root.'

const ERROR_UPLOAD = 'errUpload'; // 'Upload error.'

const ERROR_UPLOAD_FILE = 'errUploadFile'; // 'Unable to upload "$1".'

const ERROR_UPLOAD_NO_FILES = 'errUploadNoFiles'; // 'No files found for upload.'

const ERROR_UPLOAD_TOTAL_SIZE = 'errUploadTotalSize'; // 'Data exceeds the maximum allowed size.'

const ERROR_UPLOAD_FILE_SIZE = 'errUploadFileSize'; // 'File exceeds maximum allowed size.'

const ERROR_UPLOAD_FILE_MIME = 'errUploadMime'; // 'File type not allowed.'

const ERROR_UPLOAD_TRANSFER = 'errUploadTransfer'; // '"$1" transfer error.'

const ERROR_UPLOAD_TEMP = 'errUploadTemp'; // 'Unable to make temporary file for upload.'

// const ERROR_ACCESS_DENIED = 'errAccess';

const ERROR_NOT_REPLACE = 'errNotReplace'; // Object "$1" already exists at this location and can not be replaced with object of another type.

const ERROR_SAVE = 'errSave';

const ERROR_EXTRACT = 'errExtract';

const ERROR_ARCHIVE = 'errArchive';

const ERROR_NOT_ARCHIVE = 'errNoArchive';

const ERROR_ARCHIVE_TYPE = 'errArcType';

const ERROR_ARC_SYMLINKS = 'errArcSymlinks';

const ERROR_ARC_MAXSIZE = 'errArcMaxSize';

const ERROR_RESIZE = 'errResize';

const ERROR_UNSUPPORT_TYPE = 'errUsupportType';

const ERROR_CONV_UTF8 = 'errConvUTF8';

const ERROR_NOT_UTF8_CONTENT = 'errNotUTF8Content';

const ERROR_NETMOUNT = 'errNetMount';

const ERROR_NETUNMOUNT = 'errNetUnMount';

const ERROR_NETMOUNT_NO_DRIVER = 'errNetMountNoDriver';

const ERROR_NETMOUNT_FAILED = 'errNetMountFailed';

const ERROR_SESSION_EXPIRES = 'errSessionExpires';

const ERROR_CREATING_TEMP_DIR = 'errCreatingTempDir';

const ERROR_FTP_DOWNLOAD_FILE = 'errFtpDownloadFile';

const ERROR_FTP_UPLOAD_FILE = 'errFtpUploadFile';

const ERROR_FTP_MKDIR = 'errFtpMkdir';

const ERROR_ARCHIVE_EXEC = 'errArchiveExec';

const ERROR_EXTRACT_EXEC = 'errExtractExec';

const ERROR_SEARCH_TIMEOUT = 'errSearchTimeout'; // 'Timed out while searching "$1". Search result is partial.'

/**

public function __construct($opts) {

// try session start | restart

@session_start();

$sessionUseCmds = array();

if (isset($opts['sessionUseCmds']) && is_array($opts['sessionUseCmds'])) {

$sessionUseCmds = $opts['sessionUseCmds'];

}

// set self::$volumesCnt by HTTP header "X-elFinder-VolumesCntStart"

if (isset($_SERVER['HTTP_X_ELFINDER_VOLUMESCNTSTART']) && ($volumesCntStart = intval($_SERVER['HTTP_X_ELFINDER_VOLUMESCNTSTART']))) {

self::$volumesCnt = $volumesCntStart;

}

$this->time = $this->utime();

$this->debug = (isset($opts['debug']) && $opts['debug'] ? true : false);

$this->sessionCloseEarlier = isset($opts['sessionCloseEarlier'])? (bool)$opts['sessionCloseEarlier'] : true;

$this->sessionUseCmds = array_flip($sessionUseCmds);

$this->timeout = (isset($opts['timeout']) ? $opts['timeout'] : 0);

$this->uploadTempPath = (isset($opts['uploadTempPath']) ? $opts['uploadTempPath'] : '');

$this->netVolumesSessionKey = !empty($opts['netVolumesSessionKey'])? $opts['netVolumesSessionKey'] : 'elFinderNetVolumes';

$this->callbackWindowURL = (isset($opts['callbackWindowURL']) ? $opts['callbackWindowURL'] : '');

self::$sessionCacheKey = !empty($opts['sessionCacheKey']) ? $opts['sessionCacheKey'] : 'elFinderCaches';

elFinder::$commonTempPath = (isset($opts['commonTempPath']) ? $opts['commonTempPath'] : './.tmp');

if (!is_writable(elFinder::$commonTempPath)) {

elFinder::$commonTempPath = '';

}

$this->maxArcFilesSize = isset($opts['maxArcFilesSize'])? intval($opts['maxArcFilesSize']) : 0;

// check session cache

$_optsMD5 = md5(json_encode($opts['roots']));

if (! isset($_SESSION[self::$sessionCacheKey]) || $_SESSION[self::$sessionCacheKey]['_optsMD5'] !== $_optsMD5) {

$_SESSION[self::$sessionCacheKey] = array(

'_optsMD5' => $_optsMD5

);

}

self::$base64encodeSessionData = !empty($opts['base64encodeSessionData']);

// setlocale and global locale regists to elFinder::locale

self::$locale = !empty($opts['locale']) ? $opts['locale'] : 'en_US.UTF-8';

if (false === @setlocale(LC_ALL, self::$locale)) {

self::$locale = setlocale(LC_ALL, '');

}

// bind events listeners

if (!empty($opts['bind']) && is_array($opts['bind'])) {

$_req = $_SERVER["REQUEST_METHOD"] == 'POST' ? $_POST : $_GET;

$_reqCmd = isset($_req['cmd']) ? $_req['cmd'] : '';

foreach ($opts['bind'] as $cmd => $handlers) {

$doRegist = (strpos($cmd, '*') !== false);

if (! $doRegist) {

$_getcmd = create_function('$cmd', 'list($ret) = explode(\'.\', $cmd);return trim($ret);');

$doRegist = ($_reqCmd && in_array($_reqCmd, array_map($_getcmd, explode(' ', $cmd))));

}

if ($doRegist) {

if (! is_array($handlers) || is_object($handlers[0])) {

$handlers = array($handlers);

}

foreach($handlers as $handler) {

if ($handler) {

if (is_string($handler) && strpos($handler, '.')) {

list($_domain, $_name, $_method) = array_pad(explode('.', $handler), 3, '');

if (strcasecmp($_domain, 'plugin') === 0) {

if ($plugin = $this->getPluginInstance($_name, isset($opts['plugin'][$_name])? $opts['plugin'][$_name] : array())

and method_exists($plugin, $_method)) {

$this->bind($cmd, array($plugin, $_method));

}

}

} else {

$this->bind($cmd, $handler);

}

}

}

}

}

}

if (!isset($opts['roots']) || !is_array($opts['roots'])) {

$opts['roots'] = array();

}

// check for net volumes stored in session

foreach ($this->getNetVolumes() as $key => $root) {

$opts['roots'][$key] = $root;

}

// "mount" volumes

foreach ($opts['roots'] as $i => $o) {

$class = 'elFinderVolume'.(isset($o['driver']) ? $o['driver'] : '');

if (class_exists($class)) {

$volume = new $class();

try {

if ($this->maxArcFilesSize && (empty($o['maxArcFilesSize']) || $this->maxArcFilesSize < $o['maxArcFilesSize'])) {

$o['maxArcFilesSize'] = $this->maxArcFilesSize;

}

if ($volume->mount($o)) {

// unique volume id (ends on "_") - used as prefix to files hash

$id = $volume->id();

$this->volumes[$id] = $volume;

if ((!$this->default || $volume->root() !== $volume->defaultPath()) && $volume->isReadable()) {

$this->default = $this->volumes[$id];

}

} else {

$this->removeNetVolume($i);

$this->mountErrors[] = 'Driver "'.$class.'" : '.implode(' ', $volume->error());

}

} catch (Exception $e) {

$this->removeNetVolume($i);

$this->mountErrors[] = 'Driver "'.$class.'" : '.$e->getMessage();

}

} else {

$this->mountErrors[] = 'Driver "'.$class.'" does not exists';

}

}

// if at least one readable volume - ii desu >_<

$this->loaded = !empty($this->default);

}

/**

public function loaded() {

return $this->loaded;

}

/**

public function version() {

return $this->version;

}

/**

public function bind($cmd, $handler) {

$allCmds = array_keys($this->commands);

$cmds = array();

foreach(explode(' ', $cmd) as $_cmd) {

if ($_cmd !== '') {

if ($all = strpos($_cmd, '*') !== false) {

list(, $sub) = array_pad(explode('.', $_cmd), 2, '');

if ($sub) {

$sub = str_replace('\'', '\\\'', $sub);

$addSub = create_function('$cmd', 'return $cmd . \'.\' . trim(\'' . $sub . '\');');

$cmds = array_merge($cmds, array_map($addSub, $allCmds));

} else {

$cmds = array_merge($cmds, $allCmds);

}

} else {

$cmds[] = $_cmd;

}

}

}

$cmds = array_unique($cmds);

foreach ($cmds as $cmd) {

if (!isset($this->listeners[$cmd])) {

$this->listeners[$cmd] = array();

}

if (is_callable($handler)) {

$this->listeners[$cmd][] = $handler;

}

}

return $this;

}

/**

public function unbind($cmd, $handler) {

if (!empty($this->listeners[$cmd])) {

foreach ($this->listeners[$cmd] as $i => $h) {

if ($h === $handler) {

unset($this->listeners[$cmd][$i]);

return $this;

}

}

}

return $this;

}

/**

public function commandExists($cmd) {

return $this->loaded && isset($this->commands[$cmd]) && method_exists($this, $cmd);

}

/**

public function getVolume($hash) {

return $this->volume($hash);

}

/**

public function commandArgsList($cmd) {

return $this->commandExists($cmd) ? $this->commands[$cmd] : array();

}

private function session_expires() {

if (!isset($_SESSION[self::$sessionCacheKey . ':LAST_ACTIVITY'])) {

$_SESSION[self::$sessionCacheKey . ':LAST_ACTIVITY'] = time();

return false;

}

if ( ($this->timeout > 0) && (time() - $_SESSION[self::$sessionCacheKey . ':LAST_ACTIVITY'] > $this->timeout) ) {

return true;

}

$_SESSION[self::$sessionCacheKey . ':LAST_ACTIVITY'] = time();

return false;

}

/**

public function exec($cmd, $args) {

if (!$this->loaded) {

return array('error' => $this->error(self::ERROR_CONF, self::ERROR_CONF_NO_VOL));

}

if ($this->session_expires()) {

return array('error' => $this->error(self::ERROR_SESSION_EXPIRES));

}

if (!$this->commandExists($cmd)) {

return array('error' => $this->error(self::ERROR_UNKNOWN_CMD));

}

if (!empty($args['mimes']) && is_array($args['mimes'])) {

foreach ($this->volumes as $id => $v) {

$this->volumes[$id]->setMimesFilter($args['mimes']);

}

}

// call pre handlers for this command

$args['sessionCloseEarlier'] = isset($this->sessionUseCmds[$cmd])? false : $this->sessionCloseEarlier;

if (!empty($this->listeners[$cmd.'.pre'])) {

$volume = isset($args['target'])? $this->volume($args['target']) : false;

foreach ($this->listeners[$cmd.'.pre'] as $handler) {

call_user_func_array($handler, array($cmd, &$args, $this, $volume));

}

}

// unlock session data for multiple access

if ($this->sessionCloseEarlier && $args['sessionCloseEarlier'] && session_id()) {

session_write_close();

elFinder::$sessionClosed = true;

}

if (substr(PHP_OS,0,3) === 'WIN') {

// set time out

if (($_max_execution_time = ini_get('max_execution_time')) && $_max_execution_time < 300) {

@set_time_limit(300);

}

}

$result = $this->$cmd($args);

if (isset($result['removed'])) {

foreach ($this->volumes as $volume) {

$result['removed'] = array_merge($result['removed'], $volume->removed());

$volume->resetRemoved();

}

}

// call handlers for this command

if (!empty($this->listeners[$cmd])) {

foreach ($this->listeners[$cmd] as $handler) {

if (call_user_func_array($handler,array($cmd,&$result,$args,$this))) {

// handler return true to force sync client after command completed

$result['sync'] = true;

}

}

}

// replace removed files info with removed files hashes

if (!empty($result['removed'])) {

$removed = array();

foreach ($result['removed'] as $file) {

$removed[] = $file['hash'];

}

$result['removed'] = array_unique($removed);

}

// remove hidden files and filter files by mimetypes

if (!empty($result['added'])) {

$result['added'] = $this->filter($result['added']);

}

// remove hidden files and filter files by mimetypes

if (!empty($result['changed'])) {

$result['changed'] = $this->filter($result['changed']);

}

if ($this->debug || !empty($args['debug'])) {

$result['debug'] = array(

'connector' => 'php',

'phpver' => PHP_VERSION,

'time' => $this->utime() - $this->time,

'memory' => (function_exists('memory_get_peak_usage') ? ceil(memory_get_peak_usage()/1024).'Kb / ' : '').ceil(memory_get_usage()/1024).'Kb / '.ini_get('memory_limit'),

'upload' => $this->uploadDebug,

'volumes' => array(),

'mountErrors' => $this->mountErrors

);

foreach ($this->volumes as $id => $volume) {

$result['debug']['volumes'][] = $volume->debug();

}

}

foreach ($this->volumes as $volume) {

$volume->umount();

}

if (!empty($result['callback'])) {

$result['callback']['json'] = json_encode($result);

$this->callback($result['callback']);

} else {

return $result;

}

}

/**

public function realpath($hash) {

if (($volume = $this->volume($hash)) == false) {

return false;

}

return $volume->realpath($hash);

}

/**

protected function getNetVolumes() {

if (isset($_SESSION[$this->netVolumesSessionKey])) {

if ($data = elFinder::sessionDataDecode($_SESSION[$this->netVolumesSessionKey], 'array')) {

return $data;

}

}

return array();

}

/**

protected function saveNetVolumes($volumes) {

// try session restart

@session_start();

$_SESSION[$this->netVolumesSessionKey] = elFinder::sessionDataEncode($volumes);

elFinder::sessionWrite();

}

/**

protected function removeNetVolume($key) {

$netVolumes = $this->getNetVolumes();

if (is_string($key) && isset($netVolumes[$key])) {

unset($netVolumes[$key]);

$this->saveNetVolumes($netVolumes);

}

}

/**

protected function getPluginInstance($name, $opts = array()) {

$key = strtolower($name);

if (! isset($this->plugins[$key])) {

$p_file = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'plugins' . DIRECTORY_SEPARATOR . $name . DIRECTORY_SEPARATOR . 'plugin.php';

if (is_file($p_file)) {

require_once $p_file;

$class = 'elFinderPlugin' . $name;

$this->plugins[$key] = new $class($opts);

} else {

$this->plugins[$key] = false;

}

}

return $this->plugins[$key];

}

/***************************************************************************/

/* commands */

/***************************************************************************/

/**

public function error() {

$errors = array();

foreach (func_get_args() as $msg) {

if (is_array($msg)) {

$errors = array_merge($errors, $msg);

} else {

$errors[] = $msg;

}

}

return count($errors) ? $errors : array(self::ERROR_UNKNOWN);

}

protected function netmount($args) {

// try session restart

@session_start();

$options = array();

$protocol = $args['protocol'];

if ($protocol === 'netunmount') {

$key = $args['host'];

$netVolumes = $this->getNetVolumes();

if ($netVolumes[$key]) {

$res = true;

$volume = $this->volume($args['user']);

if (method_exists($volume, 'netunmount')) {

$res = $volume->netunmount($netVolumes, $key);

}

if ($res) {

unset($netVolumes[$key]);

$this->saveNetVolumes($netVolumes);

return array('sync' => true);

}

}

return array('error' => $this->error(self::ERROR_NETUNMOUNT));

}

$driver = isset(self::$netDrivers[$protocol]) ? self::$netDrivers[$protocol] : '';

$class = 'elfindervolume'.$driver;

if (!class_exists($class)) {

return array('error' => $this->error(self::ERROR_NETMOUNT, $args['host'], self::ERROR_NETMOUNT_NO_DRIVER));

}

if (!$args['path']) {

$args['path'] = '/';

}

foreach ($args as $k => $v) {

if ($k != 'options' && $k != 'protocol' && $v) {

$options[$k] = $v;

}

}

if (is_array($args['options'])) {

foreach ($args['options'] as $key => $value) {

$options[$key] = $value;

}

}

$volume = new $class();

if (method_exists($volume, 'netmountPrepare')) {

$options = $volume->netmountPrepare($options);

if (isset($options['exit'])) {

if ($options['exit'] === 'callback') {

$this->callback($options['out']);

}

return $options;

}

}

$netVolumes = $this->getNetVolumes();

if ($volume->mount($options)) {

if (! $key = @ $volume->netMountKey) {

$key = md5($protocol . '-' . join('-', $options));

}

$options['driver'] = $driver;

$options['netkey'] = $key;

$netVolumes[$key] = $options;

$this->saveNetVolumes($netVolumes);

$rootstat = $volume->file($volume->root());

$rootstat['netkey'] = $key;

return array('added' => array($rootstat));

} else {

$this->removeNetVolume($volume);

return array('error' => $this->error(self::ERROR_NETMOUNT, $args['host'], implode(' ', $volume->error())));

}

}

/**

protected function open($args) {

$target = $args['target'];

$init = !empty($args['init']);

$tree = !empty($args['tree']);

$volume = $this->volume($target);

$cwd = $volume ? $volume->dir($target) : false;

$hash = $init ? 'default folder' : '#'.$target;

$sleep = 0;

$compare = '';

// on init request we can get invalid dir hash -

// dir which can not be opened now, but remembered by client,

// so open default dir

if ((!$cwd || !$cwd['read']) && $init) {

$volume = $this->default;

$cwd = $volume->dir($volume->defaultPath());

}

if (!$cwd) {

return array('error' => $this->error(self::ERROR_OPEN, $hash, self::ERROR_DIR_NOT_FOUND));

}

if (!$cwd['read']) {

return array('error' => $this->error(self::ERROR_OPEN, $hash, self::ERROR_PERM_DENIED));

}

$files = array();

// get other volume root

if ($tree) {

foreach ($this->volumes as $id => $v) {

$files[] = $v->file($v->root());

}

}

// get current working directory files list and add to $files if not exists in it

if (($ls = $volume->scandir($cwd['hash'])) === false) {

return array('error' => $this->error(self::ERROR_OPEN, $cwd['name'], $volume->error()));

}

// long polling mode

if ($args['compare']) {

$sleep = max(1, (int)$volume->getOption('lsPlSleep'));

$limit = max(1, (int)$volume->getOption('plStandby') / $sleep) + 1;

$timelimit = ini_get('max_execution_time');

$compare = $args['compare'];

do {

$timelimit && @ set_time_limit($timelimit + $sleep);

$_mtime = 0;

foreach($ls as $_f) {

$_mtime = max($_mtime, $_f['ts']);

}

$compare = strval(count($ls)).':'.strval($_mtime);

if ($compare !== $args['compare']) {

break;

}

if (--$limit) {

sleep($sleep);

$volume->clearstatcache();

if (($ls = $volume->scandir($cwd['hash'])) === false) {

break;

}

}

} while($limit);

if ($ls === false) {

return array('error' => $this->error(self::ERROR_OPEN, $cwd['name'], $volume->error()));

}

}

if ($ls) {

if ($files) {

$files = array_merge($files, $ls);

$files = array_unique($files, SORT_REGULAR);

} else {

$files = $ls;

}

}

$result = array(

'cwd' => $cwd,

'options' => $volume->options($cwd['hash']),

'files' => $files

);

if ($compare) {

$result['cwd']['compare'] = $compare;

}

if (!empty($args['init'])) {

$result['api'] = $this->version;

$result['uplMaxSize'] = ini_get('upload_max_filesize');

$result['uplMaxFile'] = ini_get('max_file_uploads');

$result['netDrivers'] = array_keys(self::$netDrivers);

if ($volume) {

$result['cwd']['root'] = $volume->root();

}

}

return $result;

}

/**

protected function ls($args) {

$target = $args['target'];

if (($volume = $this->volume($target)) == false

|| ($list = $volume->ls($target)) === false) {

return array('error' => $this->error(self::ERROR_OPEN, '#'.$target));

}

return array('list' => $list);

}

/**

protected function tree($args) {

$target = $args['target'];

if (($volume = $this->volume($target)) == false

|| ($tree = $volume->tree($target)) == false) {

return array('error' => $this->error(self::ERROR_OPEN, '#'.$target));

}

return array('tree' => $tree);

}

/**

protected function parents($args) {

$target = $args['target'];

if (($volume = $this->volume($target)) == false

|| ($tree = $volume->parents($target)) == false) {

return array('error' => $this->error(self::ERROR_OPEN, '#'.$target));

}

return array('tree' => $tree);