885 lines
25 KiB
PHP
Executable File
885 lines
25 KiB
PHP
Executable File
<?php
|
|
/*
|
|
* This file is part of the `nicolab/php-ftp-client` package.
|
|
*
|
|
* (c) Nicolas Tallefourtane <dev@nicolab.net>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*
|
|
* @copyright Nicolas Tallefourtane http://nicolab.net
|
|
*/
|
|
namespace FtpClient;
|
|
|
|
use \Countable;
|
|
|
|
/**
|
|
* The FTP and SSL-FTP client for PHP.
|
|
*
|
|
* @method bool alloc() alloc(int $filesize, string &$result = null) Allocates space for a file to be uploaded
|
|
* @method bool cdup() cdup() Changes to the parent directory
|
|
* @method bool chdir() chdir(string $directory) Changes the current directory on a FTP server
|
|
* @method int chmod() chmod(int $mode, string $filename) Set permissions on a file via FTP
|
|
* @method bool delete() delete(string $path) Deletes a file on the FTP server
|
|
* @method bool exec() exec(string $command) Requests execution of a command on the FTP server
|
|
* @method bool fget() fget(resource $handle, string $remote_file, int $mode, int $resumepos = 0) Downloads a file from the FTP server and saves to an open file
|
|
* @method bool fput() fput(string $remote_file, resource $handle, int $mode, int $startpos = 0) Uploads from an open file to the FTP server
|
|
* @method mixed get_option() get_option(int $option) Retrieves various runtime behaviours of the current FTP stream
|
|
* @method bool get() get(string $local_file, string $remote_file, int $mode, int $resumepos = 0) Downloads a file from the FTP server
|
|
* @method int mdtm() mdtm(string $remote_file) Returns the last modified time of the given file
|
|
* @method int nb_continue() nb_continue() Continues retrieving/sending a file (non-blocking)
|
|
* @method int nb_fget() nb_fget(resource $handle, string $remote_file, int $mode, int $resumepos = 0) Retrieves a file from the FTP server and writes it to an open file (non-blocking)
|
|
* @method int nb_fput() nb_fput(string $remote_file, resource $handle, int $mode, int $startpos = 0) Stores a file from an open file to the FTP server (non-blocking)
|
|
* @method int nb_get() nb_get(string $local_file, string $remote_file, int $mode, int $resumepos = 0) Retrieves a file from the FTP server and writes it to a local file (non-blocking)
|
|
* @method int nb_put() nb_put(string $remote_file, string $local_file, int $mode, int $startpos = 0) Stores a file on the FTP server (non-blocking)
|
|
* @method bool pasv() pasv(bool $pasv) Turns passive mode on or off
|
|
* @method bool put() put(string $remote_file, string $local_file, int $mode, int $startpos = 0) Uploads a file to the FTP server
|
|
* @method string pwd() pwd() Returns the current directory name
|
|
* @method bool quit() quit() Closes an FTP connection
|
|
* @method array raw() raw(string $command) Sends an arbitrary command to an FTP server
|
|
* @method bool rename() rename(string $oldname, string $newname) Renames a file or a directory on the FTP server
|
|
* @method bool set_option() set_option(int $option, mixed $value) Set miscellaneous runtime FTP options
|
|
* @method bool site() site(string $command) Sends a SITE command to the server
|
|
* @method int size() size(string $remote_file) Returns the size of the given file
|
|
* @method string systype() systype() Returns the system type identifier of the remote FTP server
|
|
*
|
|
* @author Nicolas Tallefourtane <dev@nicolab.net>
|
|
*/
|
|
class FtpClient implements Countable
|
|
{
|
|
/**
|
|
* The connection with the server.
|
|
*
|
|
* @var resource
|
|
*/
|
|
protected $conn;
|
|
|
|
/**
|
|
* PHP FTP functions wrapper.
|
|
*
|
|
* @var FtpWrapper
|
|
*/
|
|
private $ftp;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param resource|null $connection
|
|
* @throws FtpException If FTP extension is not loaded.
|
|
*/
|
|
public function __construct($connection = null)
|
|
{
|
|
if (!extension_loaded('ftp')) {
|
|
throw new FtpException('FTP extension is not loaded!');
|
|
}
|
|
|
|
if ($connection) {
|
|
$this->conn = $connection;
|
|
}
|
|
|
|
$this->setWrapper(new FtpWrapper($this->conn));
|
|
}
|
|
|
|
/**
|
|
* Close the connection when the object is destroyed.
|
|
*/
|
|
public function __destruct()
|
|
{
|
|
if ($this->conn) {
|
|
$this->ftp->close();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call an internal method or a FTP method handled by the wrapper.
|
|
*
|
|
* Wrap the FTP PHP functions to call as method of FtpClient object.
|
|
* The connection is automaticaly passed to the FTP PHP functions.
|
|
*
|
|
* @param string $method
|
|
* @param array $arguments
|
|
* @return mixed
|
|
* @throws FtpException When the function is not valid
|
|
*/
|
|
public function __call($method, array $arguments)
|
|
{
|
|
return $this->ftp->__call($method, $arguments);
|
|
}
|
|
|
|
/**
|
|
* Overwrites the PHP limit
|
|
*
|
|
* @param string|null $memory The memory limit, if null is not modified
|
|
* @param int $time_limit The max execution time, unlimited by default
|
|
* @param bool $ignore_user_abort Ignore user abort, true by default
|
|
* @return FtpClient
|
|
*/
|
|
public function setPhpLimit($memory = null, $time_limit = 0, $ignore_user_abort = true)
|
|
{
|
|
if (null !== $memory) {
|
|
ini_set('memory_limit', $memory);
|
|
}
|
|
|
|
ignore_user_abort(true);
|
|
set_time_limit($time_limit);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get the help information of the remote FTP server.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function help()
|
|
{
|
|
return $this->ftp->raw('help');
|
|
}
|
|
|
|
/**
|
|
* Open a FTP connection.
|
|
*
|
|
* @param string $host
|
|
* @param bool $ssl
|
|
* @param int $port
|
|
* @param int $timeout
|
|
*
|
|
* @return FTPClient
|
|
* @throws FtpException If unable to connect
|
|
*/
|
|
public function connect($host, $ssl = false, $port = 21, $timeout = 90)
|
|
{
|
|
if ($ssl) {
|
|
$this->conn = @$this->ftp->ssl_connect($host, $port, $timeout);
|
|
} else {
|
|
$this->conn = @$this->ftp->connect($host, $port, $timeout);
|
|
}
|
|
|
|
if (!$this->conn) {
|
|
throw new FtpException('Unable to connect');
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Closes the current FTP connection.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function close()
|
|
{
|
|
if ($this->conn) {
|
|
$this->ftp->close();
|
|
$this->conn = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the connection with the server.
|
|
*
|
|
* @return resource
|
|
*/
|
|
public function getConnection()
|
|
{
|
|
return $this->conn;
|
|
}
|
|
|
|
/**
|
|
* Get the wrapper.
|
|
*
|
|
* @return FtpWrapper
|
|
*/
|
|
public function getWrapper()
|
|
{
|
|
return $this->ftp;
|
|
}
|
|
|
|
/**
|
|
* Logs in to an FTP connection.
|
|
*
|
|
* @param string $username
|
|
* @param string $password
|
|
*
|
|
* @return FtpClient
|
|
* @throws FtpException If the login is incorrect
|
|
*/
|
|
public function login($username = 'anonymous', $password = '')
|
|
{
|
|
$result = $this->ftp->login($username, $password);
|
|
|
|
if ($result === false) {
|
|
throw new FtpException('Login incorrect');
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the last modified time of the given file.
|
|
* Return -1 on error
|
|
*
|
|
* @param string $remoteFile
|
|
* @param string|null $format
|
|
*
|
|
* @return int
|
|
*/
|
|
public function modifiedTime($remoteFile, $format = null)
|
|
{
|
|
$time = $this->ftp->mdtm($remoteFile);
|
|
|
|
if ($time !== -1 && $format !== null) {
|
|
return date($format, $time);
|
|
}
|
|
|
|
return $time;
|
|
}
|
|
|
|
/**
|
|
* Changes to the parent directory.
|
|
*
|
|
* @throws FtpException
|
|
* @return FtpClient
|
|
*/
|
|
public function up()
|
|
{
|
|
$result = @$this->ftp->cdup();
|
|
|
|
if ($result === false) {
|
|
throw new FtpException('Unable to get parent folder');
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns a list of files in the given directory.
|
|
*
|
|
* @param string $directory The directory, by default is "." the current directory
|
|
* @param bool $recursive
|
|
* @param callable $filter A callable to filter the result, by default is asort() PHP function.
|
|
* The result is passed in array argument,
|
|
* must take the argument by reference !
|
|
* The callable should proceed with the reference array
|
|
* because is the behavior of several PHP sorting
|
|
* functions (by reference ensure directly the compatibility
|
|
* with all PHP sorting functions).
|
|
*
|
|
* @return array
|
|
* @throws FtpException If unable to list the directory
|
|
*/
|
|
public function nlist($directory = '.', $recursive = false, $filter = 'sort')
|
|
{
|
|
if (!$this->isDir($directory)) {
|
|
throw new FtpException('"'.$directory.'" is not a directory');
|
|
}
|
|
|
|
$files = $this->ftp->nlist($directory);
|
|
|
|
if ($files === false) {
|
|
throw new FtpException('Unable to list directory');
|
|
}
|
|
|
|
$result = array();
|
|
$dir_len = strlen($directory);
|
|
|
|
// if it's the current
|
|
if (false !== ($kdot = array_search('.', $files))) {
|
|
unset($files[$kdot]);
|
|
}
|
|
|
|
// if it's the parent
|
|
if(false !== ($kdot = array_search('..', $files))) {
|
|
unset($files[$kdot]);
|
|
}
|
|
|
|
if (!$recursive) {
|
|
foreach ($files as $file) {
|
|
$result[] = $directory.'/'.$file;
|
|
}
|
|
|
|
// working with the reference (behavior of several PHP sorting functions)
|
|
$filter($result);
|
|
|
|
return $result;
|
|
}
|
|
|
|
// utils for recursion
|
|
$flatten = function (array $arr) use (&$flatten) {
|
|
|
|
$flat = [];
|
|
|
|
foreach ($arr as $k => $v) {
|
|
if (is_array($v)) {
|
|
$flat = array_merge($flat, $flatten($v));
|
|
} else {
|
|
$flat[] = $v;
|
|
}
|
|
}
|
|
|
|
return $flat;
|
|
};
|
|
|
|
foreach ($files as $file) {
|
|
$file = $directory.'/'.$file;
|
|
|
|
// if contains the root path (behavior of the recursivity)
|
|
if (0 === strpos($file, $directory, $dir_len)) {
|
|
$file = substr($file, $dir_len);
|
|
}
|
|
|
|
if ($this->isDir($file)) {
|
|
$result[] = $file;
|
|
$items = $flatten($this->nlist($file, true, $filter));
|
|
|
|
foreach ($items as $item) {
|
|
$result[] = $item;
|
|
}
|
|
|
|
} else {
|
|
$result[] = $file;
|
|
}
|
|
}
|
|
|
|
$result = array_unique($result);
|
|
|
|
$filter($result);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Creates a directory.
|
|
*
|
|
* @see FtpClient::rmdir()
|
|
* @see FtpClient::remove()
|
|
* @see FtpClient::put()
|
|
* @see FtpClient::putAll()
|
|
*
|
|
* @param string $directory The directory
|
|
* @param bool $recursive
|
|
* @return array
|
|
*/
|
|
public function mkdir($directory, $recursive = false)
|
|
{
|
|
if (!$recursive or $this->isDir($directory)) {
|
|
return $this->ftp->mkdir($directory);
|
|
}
|
|
|
|
$result = false;
|
|
$pwd = $this->ftp->pwd();
|
|
$parts = explode('/', $directory);
|
|
|
|
foreach ($parts as $part) {
|
|
|
|
if (!@$this->ftp->chdir($part)) {
|
|
$result = $this->ftp->mkdir($part);
|
|
$this->ftp->chdir($part);
|
|
}
|
|
}
|
|
|
|
$this->ftp->chdir($pwd);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Remove a directory.
|
|
*
|
|
* @see FtpClient::mkdir()
|
|
* @see FtpClient::cleanDir()
|
|
* @see FtpClient::remove()
|
|
* @see FtpClient::delete()
|
|
* @param string $directory
|
|
* @param bool $recursive Forces deletion if the directory is not empty
|
|
* @return bool
|
|
* @throws FtpException If unable to list the directory to remove
|
|
*/
|
|
public function rmdir($directory, $recursive = true)
|
|
{
|
|
if ($recursive) {
|
|
$files = $this->nlist($directory, false, 'rsort');
|
|
|
|
// remove children
|
|
foreach ($files as $file) {
|
|
$this->remove($file, true);
|
|
}
|
|
}
|
|
|
|
// remove the directory
|
|
return $this->ftp->rmdir($directory);
|
|
}
|
|
|
|
/**
|
|
* Empty directory.
|
|
*
|
|
* @see FtpClient::remove()
|
|
* @see FtpClient::delete()
|
|
* @see FtpClient::rmdir()
|
|
*
|
|
* @param string $directory
|
|
* @return bool
|
|
*/
|
|
public function cleanDir($directory)
|
|
{
|
|
if(!$files = $this->nlist($directory)) {
|
|
return $this->isEmpty($directory);
|
|
}
|
|
|
|
// remove children
|
|
foreach ($files as $file) {
|
|
$this->remove($file, true);
|
|
}
|
|
|
|
return $this->isEmpty($directory);
|
|
}
|
|
|
|
/**
|
|
* Remove a file or a directory.
|
|
*
|
|
* @see FtpClient::rmdir()
|
|
* @see FtpClient::cleanDir()
|
|
* @see FtpClient::delete()
|
|
* @param string $path The path of the file or directory to remove
|
|
* @param bool $recursive Is effective only if $path is a directory, {@see FtpClient::rmdir()}
|
|
* @return bool
|
|
*/
|
|
public function remove($path, $recursive = false)
|
|
{
|
|
try {
|
|
if (@$this->ftp->delete($path)
|
|
or ($this->isDir($path) and @$this->rmdir($path, $recursive))) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
} catch (\Exception $e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a directory exist.
|
|
*
|
|
* @param string $directory
|
|
* @return bool
|
|
* @throws FtpException
|
|
*/
|
|
public function isDir($directory)
|
|
{
|
|
$pwd = $this->ftp->pwd();
|
|
|
|
if ($pwd === false) {
|
|
throw new FtpException('Unable to resolve the current directory');
|
|
}
|
|
|
|
if (@$this->ftp->chdir($directory)) {
|
|
$this->ftp->chdir($pwd);
|
|
return true;
|
|
}
|
|
|
|
$this->ftp->chdir($pwd);
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if a directory is empty.
|
|
*
|
|
* @param string $directory
|
|
* @return bool
|
|
*/
|
|
public function isEmpty($directory)
|
|
{
|
|
return $this->count($directory, null, false) === 0 ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Scan a directory and returns the details of each item.
|
|
*
|
|
* @see FtpClient::nlist()
|
|
* @see FtpClient::rawlist()
|
|
* @see FtpClient::parseRawList()
|
|
* @see FtpClient::dirSize()
|
|
* @param string $directory
|
|
* @param bool $recursive
|
|
* @return array
|
|
*/
|
|
public function scanDir($directory = '.', $recursive = false)
|
|
{
|
|
return $this->parseRawList($this->rawlist($directory, $recursive));
|
|
}
|
|
|
|
/**
|
|
* Returns the total size of the given directory in bytes.
|
|
*
|
|
* @param string $directory The directory, by default is the current directory.
|
|
* @param bool $recursive true by default
|
|
* @return int The size in bytes.
|
|
*/
|
|
public function dirSize($directory = '.', $recursive = true)
|
|
{
|
|
$items = $this->scanDir($directory, $recursive);
|
|
$size = 0;
|
|
|
|
foreach ($items as $item) {
|
|
$size += (int) $item['size'];
|
|
}
|
|
|
|
return $size;
|
|
}
|
|
|
|
/**
|
|
* Count the items (file, directory, link, unknown).
|
|
*
|
|
* @param string $directory The directory, by default is the current directory.
|
|
* @param string|null $type The type of item to count (file, directory, link, unknown)
|
|
* @param bool $recursive true by default
|
|
* @return int
|
|
*/
|
|
public function count($directory = '.', $type = null, $recursive = true)
|
|
{
|
|
$items = (null === $type ? $this->nlist($directory, $recursive)
|
|
: $this->scanDir($directory, $recursive));
|
|
|
|
$count = 0;
|
|
foreach ($items as $item) {
|
|
if (null === $type or $item['type'] == $type) {
|
|
$count++;
|
|
}
|
|
}
|
|
|
|
return $count;
|
|
}
|
|
|
|
/**
|
|
* Uploads a file to the server from a string.
|
|
*
|
|
* @param string $remote_file
|
|
* @param string $content
|
|
* @return FtpClient
|
|
* @throws FtpException When the transfer fails
|
|
*/
|
|
public function putFromString($remote_file, $content)
|
|
{
|
|
$handle = fopen('php://temp', 'w');
|
|
|
|
fwrite($handle, $content);
|
|
rewind($handle);
|
|
|
|
if ($this->ftp->fput($remote_file, $handle, FTP_BINARY)) {
|
|
return $this;
|
|
}
|
|
|
|
throw new FtpException('Unable to put the file "'.$remote_file.'"');
|
|
}
|
|
|
|
/**
|
|
* Uploads a file to the server.
|
|
*
|
|
* @param string $local_file
|
|
* @return FtpClient
|
|
* @throws FtpException When the transfer fails
|
|
*/
|
|
public function putFromPath($local_file)
|
|
{
|
|
$remote_file = basename($local_file);
|
|
$handle = fopen($local_file, 'r');
|
|
|
|
if ($this->ftp->fput($remote_file, $handle, FTP_BINARY)) {
|
|
rewind($handle);
|
|
return $this;
|
|
}
|
|
|
|
throw new FtpException(
|
|
'Unable to put the remote file from the local file "'.$local_file.'"'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Upload files.
|
|
*
|
|
* @param string $source_directory
|
|
* @param string $target_directory
|
|
* @param int $mode
|
|
* @return FtpClient
|
|
*/
|
|
public function putAll($source_directory, $target_directory, $mode = FTP_BINARY)
|
|
{
|
|
$d = dir($source_directory);
|
|
|
|
// do this for each file in the directory
|
|
while ($file = $d->read()) {
|
|
|
|
// to prevent an infinite loop
|
|
if ($file != "." && $file != "..") {
|
|
|
|
// do the following if it is a directory
|
|
if (is_dir($source_directory.'/'.$file)) {
|
|
|
|
if (!$this->isDir($target_directory.'/'.$file)) {
|
|
|
|
// create directories that do not yet exist
|
|
$this->ftp->mkdir($target_directory.'/'.$file);
|
|
}
|
|
|
|
// recursive part
|
|
$this->putAll(
|
|
$source_directory.'/'.$file, $target_directory.'/'.$file,
|
|
$mode
|
|
);
|
|
} else {
|
|
|
|
// put the files
|
|
$this->ftp->put(
|
|
$target_directory.'/'.$file, $source_directory.'/'.$file,
|
|
$mode
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns a detailed list of files in the given directory.
|
|
*
|
|
* @see FtpClient::nlist()
|
|
* @see FtpClient::scanDir()
|
|
* @see FtpClient::dirSize()
|
|
* @param string $directory The directory, by default is the current directory
|
|
* @param bool $recursive
|
|
* @return array
|
|
* @throws FtpException
|
|
*/
|
|
public function rawlist($directory = '.', $recursive = false)
|
|
{
|
|
if (!$this->isDir($directory)) {
|
|
throw new FtpException('"'.$directory.'" is not a directory.');
|
|
}
|
|
|
|
$list = $this->ftp->rawlist($directory);
|
|
$items = array();
|
|
|
|
if (!$list) {
|
|
return $items;
|
|
}
|
|
|
|
if (false == $recursive) {
|
|
|
|
foreach ($list as $path => $item) {
|
|
$chunks = preg_split("/\s+/", $item);
|
|
|
|
// if not "name"
|
|
if (empty($chunks[8]) || $chunks[8] == '.' || $chunks[8] == '..') {
|
|
continue;
|
|
}
|
|
|
|
$path = $directory.'/'.$chunks[8];
|
|
|
|
if (isset($chunks[9])) {
|
|
$nbChunks = count($chunks);
|
|
|
|
for ($i = 9; $i < $nbChunks; $i++) {
|
|
$path .= ' '.$chunks[$i];
|
|
}
|
|
}
|
|
|
|
|
|
if (substr($path, 0, 2) == './') {
|
|
$path = substr($path, 2);
|
|
}
|
|
|
|
$items[ $this->rawToType($item).'#'.$path ] = $item;
|
|
}
|
|
|
|
return $items;
|
|
}
|
|
|
|
$path = '';
|
|
|
|
foreach ($list as $item) {
|
|
$len = strlen($item);
|
|
|
|
if (!$len
|
|
|
|
// "."
|
|
|| ($item[$len-1] == '.' && $item[$len-2] == ' '
|
|
|
|
// ".."
|
|
or $item[$len-1] == '.' && $item[$len-2] == '.' && $item[$len-3] == ' ')
|
|
){
|
|
|
|
continue;
|
|
}
|
|
|
|
$chunks = preg_split("/\s+/", $item);
|
|
|
|
// if not "name"
|
|
if (empty($chunks[8]) || $chunks[8] == '.' || $chunks[8] == '..') {
|
|
continue;
|
|
}
|
|
|
|
$path = $directory.'/'.$chunks[8];
|
|
|
|
if (isset($chunks[9])) {
|
|
$nbChunks = count($chunks);
|
|
|
|
for ($i = 9; $i < $nbChunks; $i++) {
|
|
$path .= ' '.$chunks[$i];
|
|
}
|
|
}
|
|
|
|
if (substr($path, 0, 2) == './') {
|
|
$path = substr($path, 2);
|
|
}
|
|
|
|
$items[$this->rawToType($item).'#'.$path] = $item;
|
|
|
|
if ($item[0] == 'd') {
|
|
$sublist = $this->rawlist($path, true);
|
|
|
|
foreach ($sublist as $subpath => $subitem) {
|
|
$items[$subpath] = $subitem;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $items;
|
|
}
|
|
|
|
/**
|
|
* Parse raw list.
|
|
*
|
|
* @see FtpClient::rawlist()
|
|
* @see FtpClient::scanDir()
|
|
* @see FtpClient::dirSize()
|
|
* @param array $rawlist
|
|
* @return array
|
|
*/
|
|
public function parseRawList(array $rawlist)
|
|
{
|
|
$items = array();
|
|
$path = '';
|
|
|
|
foreach ($rawlist as $key => $child) {
|
|
$chunks = preg_split("/\s+/", $child);
|
|
|
|
if (isset($chunks[8]) && ($chunks[8] == '.' or $chunks[8] == '..')) {
|
|
continue;
|
|
}
|
|
|
|
if (count($chunks) === 1) {
|
|
$len = strlen($chunks[0]);
|
|
|
|
if ($len && $chunks[0][$len-1] == ':') {
|
|
$path = substr($chunks[0], 0, -1);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
$item = [
|
|
'permissions' => $chunks[0],
|
|
'number' => $chunks[1],
|
|
'owner' => $chunks[2],
|
|
'group' => $chunks[3],
|
|
'size' => $chunks[4],
|
|
'month' => $chunks[5],
|
|
'day' => $chunks[6],
|
|
'time' => $chunks[7],
|
|
'name' => $chunks[8],
|
|
'type' => $this->rawToType($chunks[0]),
|
|
];
|
|
|
|
unset($chunks[0]);
|
|
unset($chunks[1]);
|
|
unset($chunks[2]);
|
|
unset($chunks[3]);
|
|
unset($chunks[4]);
|
|
unset($chunks[5]);
|
|
unset($chunks[6]);
|
|
unset($chunks[7]);
|
|
$item['name'] = implode(' ', $chunks);
|
|
|
|
if ($item['type'] == 'link') {
|
|
$item['target'] = $chunks[10]; // 9 is "->"
|
|
}
|
|
|
|
// if the key is not the path, behavior of ftp_rawlist() PHP function
|
|
if (is_int($key) || false === strpos($key, $item['name'])) {
|
|
array_splice($chunks, 0, 8);
|
|
|
|
$key = $item['type'].'#'
|
|
.($path ? $path.'/' : '')
|
|
.implode(" ", $chunks);
|
|
|
|
if ($item['type'] == 'link') {
|
|
|
|
// get the first part of 'link#the-link.ext -> /path/of/the/source.ext'
|
|
$exp = explode(' ->', $key);
|
|
$key = rtrim($exp[0]);
|
|
}
|
|
|
|
$items[$key] = $item;
|
|
|
|
} else {
|
|
|
|
// the key is the path, behavior of FtpClient::rawlist() method()
|
|
$items[$key] = $item;
|
|
}
|
|
}
|
|
|
|
return $items;
|
|
}
|
|
|
|
/**
|
|
* Convert raw info (drwx---r-x ...) to type (file, directory, link, unknown).
|
|
* Only the first char is used for resolving.
|
|
*
|
|
* @param string $permission Example : drwx---r-x
|
|
*
|
|
* @return string The file type (file, directory, link, unknown)
|
|
* @throws FtpException
|
|
*/
|
|
public function rawToType($permission)
|
|
{
|
|
if (!is_string($permission)) {
|
|
throw new FtpException('The "$permission" argument must be a string, "'
|
|
.gettype($permission).'" given.');
|
|
}
|
|
|
|
if (empty($permission[0])) {
|
|
return 'unknown';
|
|
}
|
|
|
|
switch ($permission[0]) {
|
|
case '-':
|
|
return 'file';
|
|
|
|
case 'd':
|
|
return 'directory';
|
|
|
|
case 'l':
|
|
return 'link';
|
|
|
|
default:
|
|
return 'unknown';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the wrapper which forward the PHP FTP functions to use in FtpClient instance.
|
|
*
|
|
* @param FtpWrapper $wrapper
|
|
* @return FtpClient
|
|
*/
|
|
protected function setWrapper(FtpWrapper $wrapper)
|
|
{
|
|
$this->ftp = $wrapper;
|
|
|
|
return $this;
|
|
}
|
|
}
|