Joomla Platform  13.1
Documentation des API du framework Joomla Platform
 Tout Classes Espaces de nommage Fichiers Fonctions Variables Pages
Fonctions membres publiques | Fonctions membres publiques statiques | Fonctions membres protégées | Attributs protégés statiques | Attributs privés
Référence de la classe JClientFtp
+ Graphe d'héritage de JClientFtp:

Liste de tous les membres

Fonctions membres publiques

 __construct (array $options=array())
 __destruct ()
 setOptions (array $options)
 connect ($host= '127.0.0.1', $port=21)
 isConnected ()
 login ($user= 'anonymous', $pass= 'jftp @joomla.org')
 quit ()
 pwd ()
 syst ()
 chdir ($path)
 reinit ()
 rename ($from, $to)
 chmod ($path, $mode)
 delete ($path)
 mkdir ($path)
 restart ($point)
 create ($path)
 read ($remote, &$buffer)
 get ($local, $remote)
 store ($local, $remote=null)
 write ($remote, $buffer)
 listNames ($path=null)
 listDetails ($path=null, $type= 'all')

Fonctions membres publiques statiques

static getInstance ($host= '127.0.0.1', $port= '21', array $options=array(), $user=null, $pass=null)

Fonctions membres protégées

 _putCmd ($cmd, $expectedResponse)
 _verifyResponse ($expected)
 _passive ()
 _findMode ($fileName)
 _mode ($mode)

Attributs protégés statiques

static $instances = array()

Attributs privés

 $_conn = null
 $_dataconn = null
 $_pasv = null
 $_response = null
 $_timeout = 15
 $_type = null
 $_autoAscii
 $_lineEndings = array('UNIX' => "\n", 'WIN' => "\r\n")

Description détaillée

Définition à la ligne 53 du fichier ftp.php.

Documentation des constructeurs et destructeur

JClientFtp::__construct ( array  $options = array())

JClientFtp object constructor

Paramètres:
array$optionsAssociative array of options to set
Depuis:
12.1

Réimplémentée dans JFTP.

Définition à la ligne 139 du fichier ftp.php.

Références jimport(), JLoader\load(), et setOptions().

{
// If default transfer type is not set, set it to autoascii detect
if (!isset($options['type']))
{
$options['type'] = FTP_BINARY;
}
$this->setOptions($options);
if (FTP_NATIVE)
{
// Import the generic buffer stream handler
jimport('joomla.utilities.buffer');
// Autoloading fails for JBuffer as the class is used as a stream handler
JLoader::load('JBuffer');
}
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::__destruct ( )

JClientFtp object destructor

Closes an existing connection, if we have one

Depuis:
12.1

Définition à la ligne 165 du fichier ftp.php.

Références quit().

{
if (is_resource($this->_conn))
{
$this->quit();
}
}

+ Voici le graphe d'appel pour cette fonction :

Documentation des fonctions membres

JClientFtp::_findMode (   $fileName)
protected

Method to find out the correct transfer mode for a specific file

Paramètres:
string$fileNameName of the file
Renvoie:
integer Transfer-mode for this filetype [FTP_ASCII|FTP_BINARY]
Depuis:
12.1

Définition à la ligne 1705 du fichier ftp.php.

Référencé par get(), read(), store(), et write().

{
if ($this->_type == FTP_AUTOASCII)
{
$dot = strrpos($fileName, '.') + 1;
$ext = substr($fileName, $dot);
if (in_array($ext, $this->_autoAscii))
{
$mode = FTP_ASCII;
}
else
{
$mode = FTP_BINARY;
}
}
elseif ($this->_type == FTP_ASCII)
{
$mode = FTP_ASCII;
}
else
{
$mode = FTP_BINARY;
}
return $mode;
}

+ Voici le graphe des appelants de cette fonction :

JClientFtp::_mode (   $mode)
protected

Set transfer mode

Paramètres:
integer$modeInteger representation of data transfer mode [1:Binary|0:Ascii] Defined constants can also be used [FTP_BINARY|FTP_ASCII]
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 1742 du fichier ftp.php.

Références _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

Référencé par get(), read(), store(), et write().

{
if ($mode == FTP_BINARY)
{
if (!$this->_putCmd("TYPE I", 200))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_MODE_BINARY', $this->_response), JLog::WARNING, 'jerror');
return false;
}
}
else
{
if (!$this->_putCmd("TYPE A", 200))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_MODE_ASCII', $this->_response), JLog::WARNING, 'jerror');
return false;
}
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::_passive ( )
protected

Set server to passive mode and open a data port connection

Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 1617 du fichier ftp.php.

Références $_timeout, JText\_(), JLog\add(), JText\sprintf(), et JLog\WARNING.

Référencé par create(), get(), listDetails(), listNames(), read(), store(), et write().

{
$match = array();
$parts = array();
$errno = null;
$err = null;
// Make sure we have a connection to the server
if (!is_resource($this->_conn))
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_PASSIVE_CONNECT_PORT'), JLog::WARNING, 'jerror');
return false;
}
// Request a passive connection - this means, we'll talk to you, you don't talk to us.
@ fwrite($this->_conn, "PASV\r\n");
// Wait for a response from the server, but timeout after the set time limit
$endTime = time() + $this->_timeout;
$this->_response = '';
do
{
$this->_response .= fgets($this->_conn, 4096);
}
while (!preg_match("/^([0-9]{3})(-(.*" . CRLF . ")+\\1)? [^" . CRLF . "]+" . CRLF . "$/", $this->_response, $parts) && time() < $endTime);
// Catch a timeout or bad response
if (!isset($parts[1]))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PASSIVE_RESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
// Separate the code from the message
$this->_responseCode = $parts[1];
$this->_responseMsg = $parts[0];
// If it's not 227, we weren't given an IP and port, which means it failed.
if ($this->_responseCode != '227')
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PASSIVE_IP_OBTAIN', $this->_responseMsg), JLog::WARNING, 'jerror');
return false;
}
// Snatch the IP and port information, or die horribly trying...
if (preg_match('~\((\d+),\s*(\d+),\s*(\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+))\)~', $this->_responseMsg, $match) == 0)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PASSIVE_IP_VALID', $this->_responseMsg), JLog::WARNING, 'jerror');
return false;
}
// This is pretty simple - store it for later use ;).
$this->_pasv = array('ip' => $match[1] . '.' . $match[2] . '.' . $match[3] . '.' . $match[4], 'port' => $match[5] * 256 + $match[6]);
// Connect, assuming we've got a connection.
$this->_dataconn = @fsockopen($this->_pasv['ip'], $this->_pasv['port'], $errno, $err, $this->_timeout);
if (!$this->_dataconn)
{
JLog::add(
JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PASSIVE_CONNECT', $this->_pasv['ip'], $this->_pasv['port'], $errno, $err),
JLog::WARNING,
'jerror'
);
return false;
}
// Set the timeout for this connection
socket_set_timeout($this->_conn, $this->_timeout, 0);
return true;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::_putCmd (   $cmd,
  $expectedResponse 
)
protected

Send command to the FTP server and validate an expected response code

Paramètres:
string$cmdCommand to send to the FTP server
mixed$expectedResponseInteger response code or array of integer response codes
Renvoie:
boolean True if command executed successfully
Depuis:
12.1

Définition à la ligne 1530 du fichier ftp.php.

Références JText\_(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

Référencé par _mode(), chdir(), chmod(), create(), delete(), get(), listDetails(), listNames(), login(), mkdir(), pwd(), read(), reinit(), rename(), restart(), store(), syst(), et write().

{
// Make sure we have a connection to the server
if (!is_resource($this->_conn))
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_PUTCMD_UNCONNECTED'), JLog::WARNING, 'jerror');
return false;
}
// Send the command to the server
if (!fwrite($this->_conn, $cmd . "\r\n"))
{
JLog::add(JText::sprintf('DDD', JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PUTCMD_SEND', $cmd)), JLog::WARNING, 'jerror');
}
return $this->_verifyResponse($expectedResponse);
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::_verifyResponse (   $expected)
protected

Verify the response code from the server and log response if flag is set

Paramètres:
mixed$expectedInteger response code or array of integer response codes
Renvoie:
boolean True if response code from the server is expected
Depuis:
12.1

Définition à la ligne 1558 du fichier ftp.php.

Références $_timeout, JLog\add(), JText\sprintf(), et JLog\WARNING.

Référencé par _putCmd(), connect(), create(), get(), listDetails(), listNames(), read(), store(), et write().

{
$parts = null;
// Wait for a response from the server, but timeout after the set time limit
$endTime = time() + $this->_timeout;
$this->_response = '';
do
{
$this->_response .= fgets($this->_conn, 4096);
}
while (!preg_match("/^([0-9]{3})(-(.*" . CRLF . ")+\\1)? [^" . CRLF . "]+" . CRLF . "$/", $this->_response, $parts) && time() < $endTime);
// Catch a timeout or bad response
if (!isset($parts[1]))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_VERIFYRESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
// Separate the code from the message
$this->_responseCode = $parts[1];
$this->_responseMsg = $parts[0];
// Did the server respond with the code we wanted?
if (is_array($expected))
{
if (in_array($this->_responseCode, $expected))
{
$retval = true;
}
else
{
$retval = false;
}
}
else
{
if ($this->_responseCode == $expected)
{
$retval = true;
}
else
{
$retval = false;
}
}
return $retval;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::chdir (   $path)

Method to change the current working directory on the FTP server

Paramètres:
string$pathPath to change into on the server
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 485 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled lets use it...
if (FTP_NATIVE)
{
if (@ftp_chdir($this->_conn, $path) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_CHDIR_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send change directory command and verify success
if (!$this->_putCmd('CWD ' . $path, 250))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_CHDIR_BAD_RESPONSE', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::chmod (   $path,
  $mode 
)

Method to change mode for a path on the FTP server

Paramètres:
string$pathPath to change mode on
mixed$modeOctal value to change mode to, e.g. '0777', 0777 or 511 (string or integer)
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 597 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If no filename is given, we assume the current directory is the target
if ($path == '')
{
$path = '.';
}
// Convert the mode to a string
if (is_int($mode))
{
$mode = decoct($mode);
}
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_site($this->_conn, 'CHMOD ' . $mode . ' ' . $path) === false)
{
if (!IS_WIN)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_CHMOD_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
}
return false;
}
return true;
}
// Send change mode command and verify success [must convert mode from octal]
if (!$this->_putCmd('SITE CHMOD ' . $mode . ' ' . $path, array(200, 250)))
{
if (!IS_WIN)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_CHMOD_BAD_RESPONSE', $this->_response, $path, $mode), JLog::WARNING, 'jerror');
}
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::connect (   $host = '127.0.0.1',
  $port = 21 
)

Method to connect to a FTP server

Paramètres:
string$hostHost to connect to [Default: 127.0.0.1]
string$portPort to connect on [Default: port 21]
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 252 du fichier ftp.php.

Références _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
$errno = null;
$err = null;
// If already connected, return
if (is_resource($this->_conn))
{
return true;
}
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
$this->_conn = @ftp_connect($host, $port, $this->_timeout);
if ($this->_conn === false)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_NO_CONNECT', $host, $port), JLog::WARNING, 'jerror');
return false;
}
// Set the timeout for this connection
ftp_set_option($this->_conn, FTP_TIMEOUT_SEC, $this->_timeout);
return true;
}
// Connect to the FTP server.
$this->_conn = @ fsockopen($host, $port, $errno, $err, $this->_timeout);
if (!$this->_conn)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_NO_CONNECT_SOCKET', $host, $port, $errno, $err), JLog::WARNING, 'jerror');
return false;
}
// Set the timeout for this connection
socket_set_timeout($this->_conn, $this->_timeout, 0);
// Check for welcome response code
if (!$this->_verifyResponse(220))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_BAD_RESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::create (   $path)

Method to create an empty file on the FTP server

Paramètres:
string$pathPath local file to store on the FTP server
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 752 du fichier ftp.php.

Références JText\_(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_CREATE_BAD_RESPONSE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
$buffer = fopen('buffer://tmp', 'r');
if (@ftp_fput($this->_conn, $path, $buffer, FTP_ASCII) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_CREATE_BAD_RESPONSE_BUFFER'), JLog::WARNING, 'jerror');
fclose($buffer);
return false;
}
fclose($buffer);
return true;
}
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_CREATE_BAD_RESPONSE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (!$this->_putCmd('STOR ' . $path, array(150, 125)))
{
@ fclose($this->_dataconn);
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_CREATE_BAD_RESPONSE', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
// To create a zero byte upload close the data port connection
fclose($this->_dataconn);
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_CREATE_BAD_RESPONSE_TRANSFER', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::delete (   $path)

Method to delete a path [file/folder] on the FTP server

Paramètres:
string$pathPath to delete
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 646 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_delete($this->_conn, $path) === false)
{
if (@ftp_rmdir($this->_conn, $path) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_DELETE_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
}
return true;
}
// Send delete file command and if that doesn't work, try to remove a directory
if (!$this->_putCmd('DELE ' . $path, 250))
{
if (!$this->_putCmd('RMD ' . $path, 250))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_DELETE_BAD_RESPONSE', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::get (   $local,
  $remote 
)

Method to get a file from the FTP server and save it to a local file

Paramètres:
string$localLocal path to save remote file to
string$remotePath to remote file to get on the FTP server
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 918 du fichier ftp.php.

Références JText\_(), _findMode(), _mode(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// Determine file type
$mode = $this->_findMode($remote);
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_GET_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (@ftp_get($this->_conn, $local, $remote, $mode) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_GET_BAD_RESPONSE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
$this->_mode($mode);
// Check to see if the local file can be opened for writing
$fp = fopen($local, "wb");
if (!$fp)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_GET_WRITING_LOCAL', $local), JLog::WARNING, 'jerror');
return false;
}
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_GET_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (!$this->_putCmd('RETR ' . $remote, array(150, 125)))
{
@ fclose($this->_dataconn);
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_GET_BAD_RESPONSE_RETR', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
// Read data from data port connection and add to the buffer
while (!feof($this->_dataconn))
{
$buffer = fread($this->_dataconn, 4096);
fwrite($fp, $buffer, 4096);
}
// Close the data port connection and file pointer
fclose($this->_dataconn);
fclose($fp);
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_GET_BAD_RESPONSE_TRANSFER', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

static JClientFtp::getInstance (   $host = '127.0.0.1',
  $port = '21',
array  $options = array(),
  $user = null,
  $pass = null 
)
static

Returns the global FTP connector object, only creating it if it doesn't already exist.

You may optionally specify a username and password in the parameters. If you do so, you may not login() again with different credentials using the same object. If you do not use this option, you must quit() the current connection when you are done, to free it for use by others.

Paramètres:
string$hostHost to connect to
string$portPort to connect to
array$optionsArray with any of these options: type=>[FTP_AUTOASCII|FTP_ASCII|FTP_BINARY], timeout=>(int)
string$userUsername to use for a connection
string$passPassword to use for a connection
Renvoie:
JClientFtp The FTP Client object.
Depuis:
12.1

Définition à la ligne 192 du fichier ftp.php.

Références isConnected().

Référencé par JFolder\copy(), JFile\copy(), JFolder\create(), JFile\delete(), JFolder\delete(), JFile\move(), JFolder\move(), JClientHelper\setCredentials(), JFile\upload(), et JFile\write().

{
$signature = $user . ':' . $pass . '@' . $host . ":" . $port;
// Create a new instance, or set the options of an existing one
if (!isset(self::$instances[$signature]) || !is_object(self::$instances[$signature]))
{
self::$instances[$signature] = new static($options);
}
else
{
self::$instances[$signature]->setOptions($options);
}
// Connect to the server, and login, if requested
if (!self::$instances[$signature]->isConnected())
{
$return = self::$instances[$signature]->connect($host, $port);
if ($return && $user !== null && $pass !== null)
{
self::$instances[$signature]->login($user, $pass);
}
}
return self::$instances[$signature];
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::isConnected ( )

Method to determine if the object is connected to an FTP server

Renvoie:
boolean True if connected
Depuis:
12.1

Définition à la ligne 311 du fichier ftp.php.

Référencé par getInstance().

{
return is_resource($this->_conn);
}

+ Voici le graphe des appelants de cette fonction :

JClientFtp::listDetails (   $path = null,
  $type = 'all' 
)

Method to list the contents of a directory on the FTP server

Paramètres:
string$pathPath to the local file to be stored on the FTP server
string$typeReturn type [raw|all|folders|files]
Renvoie:
mixed If $type is raw: string Directory listing, otherwise array of string with file-names
Depuis:
12.1

Définition à la ligne 1312 du fichier ftp.php.

Références JText\_(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

Référencé par listNames().

{
$dir_list = array();
$data = null;
$regs = null;
// TODO: Deal with recurse -- nightmare
// For now we will just set it to false
$recurse = false;
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (($contents = @ftp_rawlist($this->_conn, $path)) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_BAD_RESPONSE'), JLog::WARNING, 'jerror');
return false;
}
}
else
{
// Non Native mode
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
// If a path exists, prepend a space
if ($path != null)
{
$path = ' ' . $path;
}
// Request the file listing
if (!$this->_putCmd(($recurse == true) ? 'LIST -R' : 'LIST' . $path, array(150, 125)))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_BAD_RESPONSE_LIST', $this->_response, $path), JLog::WARNING, 'jerror');
@ fclose($this->_dataconn);
return false;
}
// Read in the file listing.
while (!feof($this->_dataconn))
{
$data .= fread($this->_dataconn, 4096);
}
fclose($this->_dataconn);
// Everything go okay?
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_BAD_RESPONSE_TRANSFER', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
$contents = explode(CRLF, $data);
}
// If only raw output is requested we are done
if ($type == 'raw')
{
return $data;
}
// If we received the listing of an empty directory, we are done as well
if (empty($contents[0]))
{
return $dir_list;
}
// If the server returned the number of results in the first response, let's dump it
if (strtolower(substr($contents[0], 0, 6)) == 'total ')
{
array_shift($contents);
if (!isset($contents[0]) || empty($contents[0]))
{
return $dir_list;
}
}
// Regular expressions for the directory listing parsing.
$regexps = array(
'UNIX' => '#([-dl][rwxstST-]+).* ([0-9]*) ([a-zA-Z0-9]+).* ([a-zA-Z0-9]+).* ([0-9]*)'
. ' ([a-zA-Z]+[0-9: ]*[0-9])[ ]+(([0-9]{1,2}:[0-9]{2})|[0-9]{4}) (.+)#',
'MAC' => '#([-dl][rwxstST-]+).* ?([0-9 ]*)?([a-zA-Z0-9]+).* ([a-zA-Z0-9]+).* ([0-9]*)'
. ' ([a-zA-Z]+[0-9: ]*[0-9])[ ]+(([0-9]{2}:[0-9]{2})|[0-9]{4}) (.+)#',
'WIN' => '#([0-9]{2})-([0-9]{2})-([0-9]{2}) +([0-9]{2}):([0-9]{2})(AM|PM) +([0-9]+|<DIR>) +(.+)#'
);
// Find out the format of the directory listing by matching one of the regexps
$osType = null;
foreach ($regexps as $k => $v)
{
if (@preg_match($v, $contents[0]))
{
$osType = $k;
$regexp = $v;
break;
}
}
if (!$osType)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTDETAILS_UNRECOGNISED'), JLog::WARNING, 'jerror');
return false;
}
/*
* Here is where it is going to get dirty....
*/
if ($osType == 'UNIX' || $osType == 'MAC')
{
foreach ($contents as $file)
{
$tmp_array = null;
if (@preg_match($regexp, $file, $regs))
{
$fType = (int) strpos("-dl", $regs[1]{0});
// $tmp_array['line'] = $regs[0];
$tmp_array['type'] = $fType;
$tmp_array['rights'] = $regs[1];
// $tmp_array['number'] = $regs[2];
$tmp_array['user'] = $regs[3];
$tmp_array['group'] = $regs[4];
$tmp_array['size'] = $regs[5];
$tmp_array['date'] = @date("m-d", strtotime($regs[6]));
$tmp_array['time'] = $regs[7];
$tmp_array['name'] = $regs[9];
}
// If we just want files, do not add a folder
if ($type == 'files' && $tmp_array['type'] == 1)
{
continue;
}
// If we just want folders, do not add a file
if ($type == 'folders' && $tmp_array['type'] == 0)
{
continue;
}
if (is_array($tmp_array) && $tmp_array['name'] != '.' && $tmp_array['name'] != '..')
{
$dir_list[] = $tmp_array;
}
}
}
else
{
foreach ($contents as $file)
{
$tmp_array = null;
if (@preg_match($regexp, $file, $regs))
{
$fType = (int) ($regs[7] == '<DIR>');
$timestamp = strtotime("$regs[3]-$regs[1]-$regs[2] $regs[4]:$regs[5]$regs[6]");
// $tmp_array['line'] = $regs[0];
$tmp_array['type'] = $fType;
$tmp_array['rights'] = '';
// $tmp_array['number'] = 0;
$tmp_array['user'] = '';
$tmp_array['group'] = '';
$tmp_array['size'] = (int) $regs[7];
$tmp_array['date'] = date('m-d', $timestamp);
$tmp_array['time'] = date('H:i', $timestamp);
$tmp_array['name'] = $regs[8];
}
// If we just want files, do not add a folder
if ($type == 'files' && $tmp_array['type'] == 1)
{
continue;
}
// If we just want folders, do not add a file
if ($type == 'folders' && $tmp_array['type'] == 0)
{
continue;
}
if (is_array($tmp_array) && $tmp_array['name'] != '.' && $tmp_array['name'] != '..')
{
$dir_list[] = $tmp_array;
}
}
}
return $dir_list;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

JClientFtp::listNames (   $path = null)

Method to list the filenames of the contents of a directory on the FTP server

Note: Some servers also return folder names. However, to be sure to list folders on all servers, you should use listDetails() instead if you also need to deal with folders

Paramètres:
string$pathPath local file to store on the FTP server
Renvoie:
string Directory listing
Depuis:
12.1

Définition à la ligne 1206 du fichier ftp.php.

Références JText\_(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), listDetails(), JText\sprintf(), et JLog\WARNING.

{
$data = null;
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTNAMES_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (($list = @ftp_nlist($this->_conn, $path)) === false)
{
// Workaround for empty directories on some servers
if ($this->listDetails($path, 'files') === array())
{
return array();
}
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTNAMES_BAD_RESPONSE'), JLog::WARNING, 'jerror');
return false;
}
$list = preg_replace('#^' . preg_quote($path, '#') . '[/\\\\]?#', '', $list);
if ($keys = array_merge(array_keys($list, '.'), array_keys($list, '..')))
{
foreach ($keys as $key)
{
unset($list[$key]);
}
}
return $list;
}
/*
* If a path exists, prepend a space
*/
if ($path != null)
{
$path = ' ' . $path;
}
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_LISTNAMES_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (!$this->_putCmd('NLST' . $path, array(150, 125)))
{
@ fclose($this->_dataconn);
// Workaround for empty directories on some servers
if ($this->listDetails($path, 'files') === array())
{
return array();
}
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_LISTNAMES_BAD_RESPONSE_NLST', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
// Read in the file listing.
while (!feof($this->_dataconn))
{
$data .= fread($this->_dataconn, 4096);
}
fclose($this->_dataconn);
// Everything go okay?
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_LISTNAMES_BAD_RESPONSE_TRANSFER', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
$data = preg_split("/[" . CRLF . "]+/", $data, -1, PREG_SPLIT_NO_EMPTY);
$data = preg_replace('#^' . preg_quote(substr($path, 1), '#') . '[/\\\\]?#', '', $data);
if ($keys = array_merge(array_keys($data, '.'), array_keys($data, '..')))
{
foreach ($keys as $key)
{
unset($data[$key]);
}
}
return $data;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::login (   $user = 'anonymous',
  $pass = 'jftp@joomla.org' 
)

Method to login to a server once connected

Paramètres:
string$userUsername to login to the server
string$passPassword to login to the server
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 326 du fichier ftp.php.

Références _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_login($this->_conn, $user, $pass) === false)
{
JLog::add('JFTP::login: Unable to login', JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send the username
if (!$this->_putCmd('USER ' . $user, array(331, 503)))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_BAD_USERNAME', $this->_response, $user), JLog::WARNING, 'jerror');
return false;
}
// If we are already logged in, continue :)
if ($this->_responseCode == 503)
{
return true;
}
// Send the password
if (!$this->_putCmd('PASS ' . $pass, 230))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_BAD_PASSWORD', $this->_response, str_repeat('*', strlen($pass))), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::mkdir (   $path)

Method to create a directory on the FTP server

Paramètres:
string$pathDirectory to create
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 685 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_mkdir($this->_conn, $path) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_MKDIR_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send change directory command and verify success
if (!$this->_putCmd('MKD ' . $path, 257))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_MKDIR_BAD_RESPONSE', $this->_response, $path), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::pwd ( )

Method to retrieve the current working directory on the FTP server

Renvoie:
string Current working directory
Depuis:
12.1

Définition à la ligne 396 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (($ret = @ftp_pwd($this->_conn)) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_PWD_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return $ret;
}
$match = array(null);
// Send print working directory command and verify success
if (!$this->_putCmd('PWD', 257))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_PWD_BAD_RESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
// Match just the path
preg_match('/"[^"\r\n]*"/', $this->_response, $match);
// Return the cleaned path
return preg_replace("/\"/", "", $match[0]);
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::quit ( )

Method to quit and close the connection

Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 372 du fichier ftp.php.

Référencé par __destruct().

{
// If native FTP support is enabled lets use it...
if (FTP_NATIVE)
{
@ftp_close($this->_conn);
return true;
}
// Logout and close connection
@fwrite($this->_conn, "QUIT\r\n");
@fclose($this->_conn);
return true;
}

+ Voici le graphe des appelants de cette fonction :

JClientFtp::read (   $remote,
&  $buffer 
)

Method to read a file from the FTP server's contents into a buffer

Paramètres:
string$remotePath to remote file to read on the FTP server
string&$bufferBuffer variable to read file contents into
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 818 du fichier ftp.php.

Références $os, JText\_(), _findMode(), _mode(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// Determine file type
$mode = $this->_findMode($remote);
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_READ_BAD_RESPONSE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
$tmp = fopen('buffer://tmp', 'br+');
if (@ftp_fget($this->_conn, $tmp, $remote, $mode) === false)
{
fclose($tmp);
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_READ_BAD_RESPONSE_BUFFER'), JLog::WARNING, 'jerror');
return false;
}
// Read tmp buffer contents
rewind($tmp);
$buffer = '';
while (!feof($tmp))
{
$buffer .= fread($tmp, 8192);
}
fclose($tmp);
return true;
}
$this->_mode($mode);
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_READ_BAD_RESPONSE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (!$this->_putCmd('RETR ' . $remote, array(150, 125)))
{
@ fclose($this->_dataconn);
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_READ_BAD_RESPONSE', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
// Read data from data port connection and add to the buffer
$buffer = '';
while (!feof($this->_dataconn))
{
$buffer .= fread($this->_dataconn, 4096);
}
// Close the data port connection
fclose($this->_dataconn);
// Let's try to cleanup some line endings if it is ascii
if ($mode == FTP_ASCII)
{
$os = 'UNIX';
if (IS_WIN)
{
$os = 'WIN';
}
$buffer = preg_replace("/" . CRLF . "/", $this->_lineEndings[$os], $buffer);
}
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_READ_BAD_RESPONSE_TRANSFER', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::reinit ( )

Method to reinitialise the server, ie. need to login again

NOTE: This command not available on all servers

Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 519 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_site($this->_conn, 'REIN') === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_REINIT_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send reinitialise command to the server
if (!$this->_putCmd('REIN', 220))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_REINIT_BAD_RESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::rename (   $from,
  $to 
)

Method to rename a file/folder on the FTP server

Paramètres:
string$fromPath to change file/folder from
string$toPath to change file/folder to
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 554 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_rename($this->_conn, $from, $to) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_RENAME_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send rename from command to the server
if (!$this->_putCmd('RNFR ' . $from, 350))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_RENAME_BAD_RESPONSE_FROM', $this->_response, $from), JLog::WARNING, 'jerror');
return false;
}
// Send rename to command to the server
if (!$this->_putCmd('RNTO ' . $to, 250))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_RENAME_BAD_RESPONSE_TO', $this->_response, $to), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::restart (   $point)

Method to restart data transfer at a given byte

Paramètres:
integer$pointByte to restart transfer at
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 718 du fichier ftp.php.

Références JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
if (@ftp_site($this->_conn, 'REST ' . $point) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_RESTART_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
// Send restart command and verify success
if (!$this->_putCmd('REST ' . $point, 350))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_RESTART_BAD_RESPONSE', $this->_response, $point), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::setOptions ( array  $options)

Set client options

Paramètres:
array$optionsAssociative array of options to set
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 229 du fichier ftp.php.

Référencé par __construct().

{
if (isset($options['type']))
{
$this->_type = $options['type'];
}
if (isset($options['timeout']))
{
$this->_timeout = $options['timeout'];
}
return true;
}

+ Voici le graphe des appelants de cette fonction :

JClientFtp::store (   $local,
  $remote = null 
)

Method to store a file to the FTP server

Paramètres:
string$localPath to local file to store on the FTP server
string$remoteFTP path to file to create
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 1002 du fichier ftp.php.

Références JText\_(), _findMode(), _mode(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If remote file is not given, use the filename of the local file in the current
// working directory.
if ($remote == null)
{
$remote = basename($local);
}
// Determine file type
$mode = $this->_findMode($remote);
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_STORE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
if (@ftp_put($this->_conn, $remote, $local, $mode) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_STORE_BAD_RESPONSE'), JLog::WARNING, 'jerror');
return false;
}
return true;
}
$this->_mode($mode);
// Check to see if the local file exists and if so open it for reading
if (@ file_exists($local))
{
$fp = fopen($local, "rb");
if (!$fp)
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_STORE_READING_LOCAL', $local), JLog::WARNING, 'jerror');
return false;
}
}
else
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_STORE_FIND_LOCAL', $local), JLog::WARNING, 'jerror');
return false;
}
// Start passive mode
if (!$this->_passive())
{
@ fclose($fp);
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_STORE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
// Send store command to the FTP server
if (!$this->_putCmd('STOR ' . $remote, array(150, 125)))
{
@ fclose($fp);
@ fclose($this->_dataconn);
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_STORE_BAD_RESPONSE_STOR', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
// Do actual file transfer, read local file and write to data port connection
while (!feof($fp))
{
$line = fread($fp, 4096);
do
{
if (($result = @ fwrite($this->_dataconn, $line)) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_STORE_DATA_PORT'), JLog::WARNING, 'jerror');
return false;
}
$line = substr($line, $result);
}
while ($line != "");
}
fclose($fp);
fclose($this->_dataconn);
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_STORE_BAD_RESPONSE_TRANSFER', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::syst ( )

Method to system string from the FTP server

Renvoie:
string System identifier string
Depuis:
12.1

Définition à la ligne 434 du fichier ftp.php.

Références $_response, JText\_(), _putCmd(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// If native FTP support is enabled lets use it...
if (FTP_NATIVE)
{
if (($ret = @ftp_systype($this->_conn)) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_SYS_BAD_RESPONSE_NATIVE'), JLog::WARNING, 'jerror');
return false;
}
}
else
{
// Send print working directory command and verify success
if (!$this->_putCmd('SYST', 215))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_SYST_BAD_RESPONSE', $this->_response), JLog::WARNING, 'jerror');
return false;
}
$ret = $this->_response;
}
// Match the system string to an OS
if (strpos(strtoupper($ret), 'MAC') !== false)
{
$ret = 'MAC';
}
elseif (strpos(strtoupper($ret), 'WIN') !== false)
{
$ret = 'WIN';
}
else
{
$ret = 'UNIX';
}
// Return the os type
return $ret;
}

+ Voici le graphe d'appel pour cette fonction :

JClientFtp::write (   $remote,
  $buffer 
)

Method to write a string to the FTP server

Paramètres:
string$remoteFTP path to file to write to
string$bufferContents to write to the FTP server
Renvoie:
boolean True if successful
Depuis:
12.1

Définition à la ligne 1115 du fichier ftp.php.

Références JText\_(), _findMode(), _mode(), _passive(), _putCmd(), _verifyResponse(), JLog\add(), JText\sprintf(), et JLog\WARNING.

{
// Determine file type
$mode = $this->_findMode($remote);
// If native FTP support is enabled let's use it...
if (FTP_NATIVE)
{
// Turn passive mode on
if (@ftp_pasv($this->_conn, true) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_WRITE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
$tmp = fopen('buffer://tmp', 'br+');
fwrite($tmp, $buffer);
rewind($tmp);
if (@ftp_fput($this->_conn, $remote, $tmp, $mode) === false)
{
fclose($tmp);
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_WRITE_BAD_RESPONSE'), JLog::WARNING, 'jerror');
return false;
}
fclose($tmp);
return true;
}
// First we need to set the transfer mode
$this->_mode($mode);
// Start passive mode
if (!$this->_passive())
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_WRITE_PASSIVE'), JLog::WARNING, 'jerror');
return false;
}
// Send store command to the FTP server
if (!$this->_putCmd('STOR ' . $remote, array(150, 125)))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_WRITE_BAD_RESPONSE_STOR', $this->_response, $remote), JLog::WARNING, 'jerror');
@ fclose($this->_dataconn);
return false;
}
// Write buffer to the data connection port
do
{
if (($result = @ fwrite($this->_dataconn, $buffer)) === false)
{
JLog::add(JText::_('JLIB_CLIENT_ERROR_JFTP_WRITE_DATA_PORT'), JLog::WARNING, 'jerror');
return false;
}
$buffer = substr($buffer, $result);
}
while ($buffer != "");
// Close the data connection port [Data transfer complete]
fclose($this->_dataconn);
// Verify that the server recieved the transfer
if (!$this->_verifyResponse(226))
{
JLog::add(JText::sprintf('JLIB_CLIENT_ERROR_JFTP_WRITE_BAD_RESPONSE_TRANSFER', $this->_response, $remote), JLog::WARNING, 'jerror');
return false;
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

Documentation des données membres

JClientFtp::$_autoAscii
private
Valeur initiale :
array(
"asp",
"bat",
"c",
"cpp",
"csv",
"h",
"htm",
"html",
"shtml",
"ini",
"inc",
"log",
"php",
"php3",
"pl",
"perl",
"sh",
"sql",
"txt",
"xhtml",
"xml")

Définition à la ligne 95 du fichier ftp.php.

JClientFtp::$_conn = null
private

Définition à la ligne 59 du fichier ftp.php.

JClientFtp::$_dataconn = null
private

Définition à la ligne 65 du fichier ftp.php.

JClientFtp::$_lineEndings = array('UNIX' => "\n", 'WIN' => "\r\n")
private

Définition à la ligne 124 du fichier ftp.php.

JClientFtp::$_pasv = null
private

Définition à la ligne 71 du fichier ftp.php.

JClientFtp::$_response = null
private

Définition à la ligne 77 du fichier ftp.php.

Référencé par syst().

JClientFtp::$_timeout = 15
private

Définition à la ligne 83 du fichier ftp.php.

Référencé par _passive(), et _verifyResponse().

JClientFtp::$_type = null
private

Définition à la ligne 89 du fichier ftp.php.

JClientFtp::$instances = array()
staticprotected

Définition à la ligne 130 du fichier ftp.php.

La documentation de cette classe a été générée à partir du fichier suivant :