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

/**
 * Simple elFinder driver for SFTP using phpseclib 1
 *
 * @author Dmitry (dio) Levashov
 * @author Cem (discofever), sitecode
 * @reference http://phpseclib.sourceforge.net/sftp/2.0/examples.html
 **/
class elFinderVolumeSFTPphpseclib extends elFinderVolumeFTP {

    /**
     * Constructor
     * Extend options with required fields
     *
     * @author Dmitry (dio) Levashov
     * @author Cem (DiscoFever)
     */
    public function __construct()
    {
        $opts = array(
            'host' =&gt; 'localhost',
            'user' =&gt; '',
            'pass' =&gt; '',
            'port' =&gt; 22,
            'path' =&gt; '/',
            'timeout' =&gt; 20,
            'owner' =&gt; true,
            'tmbPath' =&gt; '',
            'tmpPath' =&gt; '',
            'separator' =&gt; '/',
            'phpseclibDir' =&gt; '../phpseclib/',
            'connectCallback' =&gt; null, //provide your own already instantiated phpseclib $Sftp object returned by this callback
                                       //'connectCallback'=&gt; function($options) {
                                       //     //load and instantiate phpseclib $sftp
                                       //     return $sftp;
                                       // },
            'checkSubfolders' =&gt; -1,
            'dirMode' =&gt; 0755,
            'fileMode' =&gt; 0644,
            'rootCssClass' =&gt; 'elfinder-navbar-root-ftp',
        );
        $this-&gt;options = array_merge($this-&gt;options, $opts);
        $this-&gt;options['mimeDetect'] = 'internal';
    }

    /**
     * Prepare
     * Call from elFinder::netmout() before volume-&gt;mount()
     *
     * @param $options
     *
     * @return array volume root options
     * @author Naoki Sawada
     */
    public function netmountPrepare($options)
    {
        $options['statOwner'] = true;
        $options['allowChmodReadOnly'] = true;
        $options['acceptedName'] = '#^[^/\\?*:|&quot;&lt;&gt;]*[^./\\?*:|&quot;&lt;&gt;]$#';
        return $options;
    }

    /*********************************************************************/
    /*                        INIT AND CONFIGURE                         */
    /*********************************************************************/

    /**
     * Prepare SFTP connection
     * Connect to remote server and check if credentials are correct, if so, store the connection
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     * @author Cem (DiscoFever)
     **/
    protected function init()
    {
        if (!$this-&gt;options['connectCallback']) {
            if (!$this-&gt;options['host']
                || !$this-&gt;options['port']) {
                return $this-&gt;setError('Required options undefined.');
            }

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

            // make net mount key
            $this-&gt;netMountKey = md5(join('-', array('sftpphpseclib', $this-&gt;options['host'], $this-&gt;options['port'], $this-&gt;options['path'], $this-&gt;options['user'])));

            set_include_path(get_include_path() . PATH_SEPARATOR . getcwd().'/'.$this-&gt;options['phpseclibDir']);
            include_once('Net/SFTP.php');

            if (!class_exists('Net_SFTP')) {
                return $this-&gt;setError('SFTP extension not loaded. Install phpseclib version 1: http://phpseclib.sourceforge.net/ Set option &quot;phpseclibDir&quot; accordingly.');
            }

            // remove protocol from host
            $scheme = parse_url($this-&gt;options['host'], PHP_URL_SCHEME);

            if ($scheme) {
                $this-&gt;options['host'] = substr($this-&gt;options['host'], strlen($scheme) + 3);
            }
        } else {
            // make net mount key
            $this-&gt;netMountKey = md5(join('-', array('sftpphpseclib', $this-&gt;options['path'])));
        }

        // normalize root path
        $this-&gt;root = $this-&gt;options['path'] = $this-&gt;_normpath($this-&gt;options['path']);

        if (empty($this-&gt;options['alias'])) {
            $this-&gt;options['alias'] = $this-&gt;options['user'] . '@' . $this-&gt;options['host'];
            if (!empty($this-&gt;options['netkey'])) {
                elFinder::$instance-&gt;updateNetVolumeOption($this-&gt;options['netkey'], 'alias', $this-&gt;options['alias']);
            }
        }

        $this-&gt;rootName = $this-&gt;options['alias'];
        $this-&gt;options['separator'] = '/';

        if (is_null($this-&gt;options['syncChkAsTs'])) {
            $this-&gt;options['syncChkAsTs'] = true;
        }

        return $this-&gt;needOnline? $this-&gt;connect() : true;

    }


    /**
     * Configure after successfull mount.
     *
     * @return void
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function configure()
    {
        parent::configure();

        if (!$this-&gt;tmp) {
            $this-&gt;disabled[] = 'mkfile';
            $this-&gt;disabled[] = 'paste';
            $this-&gt;disabled[] = 'upload';
            $this-&gt;disabled[] = 'edit';
            //$this-&gt;disabled[] = 'archive';
            //$this-&gt;disabled[] = 'extract';
        }

        $this-&gt;disabled[] = 'archive';
        $this-&gt;disabled[] = 'extract';
    }

    /**
     * Connect to sftp server
     *
     * @return bool
     * @author sitecode
     **/
    protected function connect()
    {
        //use ca
        if ($this-&gt;options['connectCallback']) {
            $this-&gt;connect = $this-&gt;options['connectCallback']($this-&gt;options);
            if (!$this-&gt;connect || !$this-&gt;connect-&gt;isConnected()) {
                return $this-&gt;setError('Unable to connect successfully');
            }

            return true;
        }

        try{
            $host = $this-&gt;options['host'] . ($this-&gt;options['port'] != 22 ? ':' . $this-&gt;options['port'] : '');
            $this-&gt;connect = new Net_SFTP($host);
            //TODO check fingerprint before login, fail if no match to last time
            if (!$this-&gt;connect-&gt;login($this-&gt;options['user'], $this-&gt;options['pass'])) {
                return $this-&gt;setError('Unable to connect to SFTP server ' . $host);
            }
        } catch (Exception $e) {
            return $this-&gt;setError('Error while connecting to SFTP server '  . $host . ': ' . $e-&gt;getMessage());
        }

        if (!$this-&gt;connect-&gt;chdir($this-&gt;root)
            /*|| $this-&gt;root != $this-&gt;connect-&gt;pwd()*/) {
            //$this-&gt;umount();
            return $this-&gt;setError('Unable to open root folder.');
        }

        return true;
    }

    /**
     * Call rawlist
     *
     * @param string $path
     *
     * @return array
     */
    protected function ftpRawList($path)
    {
        return $this-&gt;connect-&gt;rawlist($path ?: '.') ?: [];
/*
        $raw = $this-&gt;connect-&gt;rawlist($path ?: '.') ?: [];
        $raw = array_map(function($key, $value) {
            $value['name'] = $key;
            return $value;
        }, array_keys($raw), $raw);
        return $raw;
*/
    }

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

    /**
     * Close opened connection
     *
     * @return void
     * @author Dmitry (dio) Levashov
     **/
    public function umount()
    {
        $this-&gt;connect &amp;&amp; $this-&gt;connect-&gt;disconnect();
    }


    /**
     * Parse line from rawlist() output and return file stat (array)
     *
     * @param  string $raw line from rawlist() output
     * @param         $base
     * @param bool    $nameOnly
     *
     * @return array
     * @author Dmitry Levashov
     */
    protected function parseRaw($raw, $base, $nameOnly = false)
    {
        $info = $raw;
        $stat = array();

        if ($info['filename'] == '.' || $info['filename'] == '..') {
            return false;
        }

        $name = $info['filename'];

        if (preg_match('|(.+)\-\&gt;(.+)|', $name, $m)) {
            $name = trim($m[1]);
            // check recursive processing
            if ($this-&gt;cacheDirTarget &amp;&amp; $this-&gt;_joinPath($base, $name) !== $this-&gt;cacheDirTarget) {
                return array();
            }
            if (!$nameOnly) {
                $target = trim($m[2]);
                if (substr($target, 0, 1) !== $this-&gt;separator) {
                    $target = $this-&gt;getFullPath($target, $base);
                }
                $target = $this-&gt;_normpath($target);
                $stat['name'] = $name;
                $stat['target'] = $target;
                return $stat;
            }
        }

        if ($nameOnly) {
            return array('name' =&gt; $name);
        }

        $stat['ts'] = $info['mtime'];

        if ($this-&gt;options['statOwner']) {
            $stat['owner'] = $info['uid'];
            $stat['group'] = $info['gid'];
            $stat['perm'] = $info['permissions'];
            $stat['isowner'] = isset($stat['owner']) ? ($this-&gt;options['owner'] ? true : ($stat['owner'] == $this-&gt;options['user'])) : true;
        }

        $owner_computed = isset($stat['isowner']) ? $stat['isowner'] : $this-&gt;options['owner'];
        $perm = $this-&gt;parsePermissions($info['permissions'], $owner_computed);
        $stat['name'] = $name;
        $stat['mime'] = $info['type'] == NET_SFTP_TYPE_DIRECTORY ? 'directory' : $this-&gt;mimetype($stat['name'], true);
        $stat['size'] = $stat['mime'] == 'directory' ? 0 : $info['size'];
        $stat['read'] = $perm['read'];
        $stat['write'] = $perm['write'];

        return $stat;
    }

    /**
     * Parse permissions string. Return array(read =&gt; true/false, write =&gt; true/false)
     *
     * @param  int $perm
     *                                             The isowner parameter is computed by the caller.
     *                                             If the owner parameter in the options is true, the user is the actual owner of all objects even if the user used in the ftp Login
     *                                             is different from the file owner id.
     *                                             If the owner parameter is false to understand if the user is the file owner we compare the ftp user with the file owner id.
     * @param Boolean $isowner                     . Tell if the current user is the owner of the object.
     *
     * @return array
     * @author Dmitry (dio) Levashov
     * @author sitecode
     */
    protected function parsePermissions($permissions, $isowner = true)
    {
        $permissions = decoct($permissions);
        $perm = $isowner ? decbin($permissions[-3]) : decbin($permissions[-1]);

        return array(
            'read' =&gt; $perm[-3],
            'write' =&gt; $perm[-2]
        );
    }

    /**
     * Cache dir contents
     *
     * @param  string $path dir path
     *
     * @return void
     * @author Dmitry Levashov, sitecode
     **/
    protected function cacheDir($path)
    {
        $this-&gt;dirsCache[$path] = array();
        $hasDir = false;

        $list = array();
        $encPath = $this-&gt;convEncIn($path);
        foreach ($this-&gt;ftpRawList($encPath) as $raw) {
            if (($stat = $this-&gt;parseRaw($raw, $encPath))) {
                $list[] = $stat;
            }
        }
        $list = $this-&gt;convEncOut($list);
        $prefix = ($path === $this-&gt;separator) ? $this-&gt;separator : $path . $this-&gt;separator;
        $targets = array();
        foreach ($list as $stat) {
            $p = $prefix . $stat['name'];
            if (isset($stat['target'])) {
                // stat later
                $targets[$stat['name']] = $stat['target'];
            } else {
                $stat = $this-&gt;updateCache($p, $stat);
                if (empty($stat['hidden'])) {
                    if (!$hasDir &amp;&amp; $stat['mime'] === 'directory') {
                        $hasDir = true;
                    }
                    $this-&gt;dirsCache[$path][] = $p;
                }
            }
        }
        // stat link targets
        foreach ($targets as $name =&gt; $target) {
            $stat = array();
            $stat['name'] = $name;
            $p = $prefix . $name;
            $cacheDirTarget = $this-&gt;cacheDirTarget;
            $this-&gt;cacheDirTarget = $this-&gt;convEncIn($target, true);
            if ($tstat = $this-&gt;stat($target)) {
                $stat['size'] = $tstat['size'];
                $stat['alias'] = $target;
                $stat['thash'] = $tstat['hash'];
                $stat['mime'] = $tstat['mime'];
                $stat['read'] = $tstat['read'];
                $stat['write'] = $tstat['write'];

                if (isset($tstat['ts'])) {
                    $stat['ts'] = $tstat['ts'];
                }
                if (isset($tstat['owner'])) {
                    $stat['owner'] = $tstat['owner'];
                }
                if (isset($tstat['group'])) {
                    $stat['group'] = $tstat['group'];
                }
                if (isset($tstat['perm'])) {
                    $stat['perm'] = $tstat['perm'];
                }
                if (isset($tstat['isowner'])) {
                    $stat['isowner'] = $tstat['isowner'];
                }
            } else {

                $stat['mime'] = 'symlink-broken';
                $stat['read'] = false;
                $stat['write'] = false;
                $stat['size'] = 0;

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

        if (isset($this-&gt;sessionCache['subdirs'])) {
            $this-&gt;sessionCache['subdirs'][$path] = $hasDir;
        }
    }


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

    /**
     * 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
     **/
    protected function _stat($path)
    {
        $outPath = $this-&gt;convEncOut($path);
        if (isset($this-&gt;cache[$outPath])) {
            return $this-&gt;convEncIn($this-&gt;cache[$outPath]);
        } else {
            $this-&gt;convEncIn();
        }
        if ($path === $this-&gt;root) {
            $res = array(
                'name' =&gt; $this-&gt;root,
                'mime' =&gt; 'directory',
                'dirs' =&gt; -1
            );
            if ($this-&gt;needOnline &amp;&amp; (($this-&gt;ARGS['cmd'] === 'open' &amp;&amp; $this-&gt;ARGS['target'] === $this-&gt;encode($this-&gt;root)) || $this-&gt;isMyReload())) {
                $check = array(
                    'ts' =&gt; true,
                    'dirs' =&gt; true,
                );
                $ts = 0;
                foreach ($this-&gt;ftpRawList($path) as $str) {
                    $info = preg_split('/\s+/', $str, 9);
                    if ($info[8] === '.') {
                        $info[8] = 'root';
                        if ($stat = $this-&gt;parseRaw(join(' ', $info), $path)) {
                            unset($stat['name']);
                            $res = array_merge($res, $stat);
                            if ($res['ts']) {
                                $ts = 0;
                                unset($check['ts']);
                            }
                        }
                    }
                    if ($check &amp;&amp; ($stat = $this-&gt;parseRaw($str, $path))) {
                        if (isset($stat['ts']) &amp;&amp; !empty($stat['ts'])) {
                            $ts = max($ts, $stat['ts']);
                        }
                        if (isset($stat['dirs']) &amp;&amp; $stat['mime'] === 'directory') {
                            $res['dirs'] = 1;
                            unset($stat['dirs']);
                        }
                        if (!$check) {
                            break;
                        }
                    }
                }
                if ($ts) {
                    $res['ts'] = $ts;
                }
                $this-&gt;cache[$outPath] = $res;
            }
            return $res;
        }

        $pPath = $this-&gt;_dirname($path);
        if ($this-&gt;_inPath($pPath, $this-&gt;root)) {
            $outPPpath = $this-&gt;convEncOut($pPath);
            if (!isset($this-&gt;dirsCache[$outPPpath])) {
                $parentSubdirs = null;
                if (isset($this-&gt;sessionCache['subdirs']) &amp;&amp; isset($this-&gt;sessionCache['subdirs'][$outPPpath])) {
                    $parentSubdirs = $this-&gt;sessionCache['subdirs'][$outPPpath];
                }
                $this-&gt;cacheDir($outPPpath);
                if ($parentSubdirs) {
                    $this-&gt;sessionCache['subdirs'][$outPPpath] = $parentSubdirs;
                }
            }
        }

        $stat = $this-&gt;convEncIn(isset($this-&gt;cache[$outPath]) ? $this-&gt;cache[$outPath] : array());
        if (!$this-&gt;mounted) {
            // dispose incomplete cache made by calling `stat` by 'startPath' option
            $this-&gt;cache = array();
        }

        return $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, sitecode
     **/
    protected function _subdirs($path)
    {
        foreach ($this-&gt;ftpRawList($path) as $info) {
            $name = $info['filename'];
            if ($name &amp;&amp; $name !== '.' &amp;&amp; $name !== '..' &amp;&amp; $info['type'] == NET_SFTP_TYPE_DIRECTORY) {
                return true;
            }
        }

        return false;
    }


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

    /**
     * Open file and return file pointer
     *
     * @param  string $path file path
     * @param string  $mode
     *
     * @return false|resource
     * @throws elFinderAbortException
     * @internal param bool $write open file for writing
     * @author   Dmitry (dio) Levashov
     */
    protected function _fopen($path, $mode = 'rb')
    {
        if ($this-&gt;tmp) {
            $local = $this-&gt;getTempFile($path);
            $this-&gt;connect-&gt;get($path, $local);
            return @fopen($local, $mode);
        }

        return false;
    }

    /**
     * Close opened file
     *
     * @param  resource $fp file pointer
     * @param string    $path
     *
     * @return void
     * @author Dmitry (dio) Levashov
     */
    protected function _fclose($fp, $path = '')
    {
        is_resource($fp) &amp;&amp; fclose($fp);
        if ($path) {
            unlink($this-&gt;getTempFile($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
     **/
    protected function _mkdir($path, $name)
    {
        $path = $this-&gt;_joinPath($path, $this-&gt;_basename($name));
        if ($this-&gt;connect-&gt;mkdir($path) === false) {
            return false;
        }

        $this-&gt;options['dirMode'] &amp;&amp; $this-&gt;connect-&gt;chmod($this-&gt;options['dirMode'], $path);
        return $path;
    }

    /**
     * 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 sitecode
     **/
    protected function _mkfile($path, $name)
    {
        $path = $this-&gt;_joinPath($path, $this-&gt;_basename($name));
        return $this-&gt;connect-&gt;put($path, '') ? $path : false;
/*
        if ($this-&gt;tmp) {
            $path = $this-&gt;_joinPath($path, $name);
            $local = $this-&gt;getTempFile();
            $res = touch($local) &amp;&amp; $this-&gt;connect-&gt;put($path, $local, NET_SFTP_LOCAL_FILE);
            unlink($local);
            return $res ? $path : false;
        }

        return false;
 */
    }

    /**
     * Copy file into another file
     *
     * @param  string $source    source file path
     * @param  string $targetDir target directory path
     * @param  string $name      new file name
     *
     * @return bool
     * @author Dmitry (dio) Levashov, sitecode
     **/
    protected function _copy($source, $targetDir, $name)
    {
        $res = false;

        $target = $this-&gt;_joinPath($targetDir, $this-&gt;_basename($name));
        if ($this-&gt;tmp) {
            $local = $this-&gt;getTempFile();

            if ($this-&gt;connect-&gt;get($source, $local)
                &amp;&amp; $this-&gt;connect-&gt;put($target, $local, NET_SFTP_LOCAL_FILE)) {
                $res = true;
            }
            unlink($local);
        } else {
            //not memory efficient
            $res = $this-&gt;_filePutContents($target, $this-&gt;_getContents($source));
        }

        return $res;
    }

    /**
     * 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
     */
    protected function _move($source, $targetDir, $name)
    {
        $target = $this-&gt;_joinPath($targetDir, $this-&gt;_basename($name));
        return $this-&gt;connect-&gt;rename($source, $target) ? $target : false;
    }

    /**
     * Remove file
     *
     * @param  string $path file path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function _unlink($path)
    {
        return $this-&gt;connect-&gt;delete($path, false);
    }

    /**
     * Remove dir
     *
     * @param  string $path dir path
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function _rmdir($path)
    {
        return $this-&gt;connect-&gt;delete($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
     **/
    protected function _save($fp, $dir, $name, $stat)
    {
        //TODO optionally encrypt $fp before uploading if mime is not already encrypted type
        $path = $this-&gt;_joinPath($dir, $this-&gt;_basename($name));
        return $this-&gt;connect-&gt;put($path, $fp)
            ? $path
            : false;
    }

    /**
     * Get file contents
     *
     * @param  string $path file path
     *
     * @return string|false
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov
     */
    protected function _getContents($path)
    {
        return $this-&gt;connect-&gt;get($path);
    }

    /**
     * Write a string to a file
     *
     * @param  string $path    file path
     * @param  string $content new file content
     *
     * @return bool
     * @author Dmitry (dio) Levashov
     **/
    protected function _filePutContents($path, $content)
    {
        return $this-&gt;connect-&gt;put($path, $content);
    }

    /**
     * chmod availability
     *
     * @param string $path
     * @param string $mode
     *
     * @return bool
     */
    protected function _chmod($path, $mode)
    {
        $modeOct = is_string($mode) ? octdec($mode) : octdec(sprintf(&quot;%04o&quot;, $mode));
        return $this-&gt;connect-&gt;chmod($modeOct, $path);
    }

    /**
     * Extract files from archive
     *
     * @param  string $path archive path
     * @param  array  $arc  archiver command and arguments (same as in $this-&gt;archivers)
     *
     * @return true
     * @throws elFinderAbortException
     * @author Dmitry (dio) Levashov,
     * @author Alexey Sukhotin
     */
    protected function _extract($path, $arc)
    {
        return false; //TODO
    }

    /**
     * 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
     */
    protected function _archive($dir, $files, $name, $arc)
    {
        return false; //TODO
    }

    /**
     * Gets an array of absolute remote SFTP paths of files and
     * folders in $remote_directory omitting symbolic links.
     *
     * @param $remote_directory string remote SFTP path to scan for file and folders recursively
     * @param $targets          array  Array of target item. `null` is to get all of items
     *
     * @return array of elements each of which is an array of two elements:
     * &lt;ul&gt;
     * &lt;li&gt;$item['path'] - absolute remote SFTP path&lt;/li&gt;
     * &lt;li&gt;$item['type'] - either 'f' for file or 'd' for directory&lt;/li&gt;
     * &lt;/ul&gt;
     */
    protected function ftp_scan_dir($remote_directory, $targets = null)
    {
        $buff = $this-&gt;ftpRawList($remote_directory);
        $items = array();
        if ($targets &amp;&amp; is_array($targets)) {
            $targets = array_flip($targets);
        } else {
            $targets = false;
        }
        foreach ($buff as $info) {
            $name = $info['filename'];
            if ($name !== '.' &amp;&amp; $name !== '..' &amp;&amp; (!$targets || isset($targets[$name]))) {
                switch ($info['type']) {
                    case NET_SFTP_TYPE_SYMLINK : //omit symbolic links
                    case NET_SFTP_TYPE_DIRECTORY :
                        $remote_file_path = $this-&gt;_joinPath($remote_directory, $name);
                        $item = array();
                        $item['path'] = $remote_file_path;
                        $item['type'] = 'd'; // normal file
                        $items[] = $item;
                        $items = array_merge($items, $this-&gt;ftp_scan_dir($remote_file_path));
                        break;
                    default:
                        $remote_file_path = $this-&gt;_joinPath($remote_directory, $name);
                        $item = array();
                        $item['path'] = $remote_file_path;
                        $item['type'] = 'f'; // normal file
                        $items[] = $item;
                }
            }
        }
        return $items;
    }

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