/**
  * Connect to FTP server and authenticate via password
  *
  * @since 3.0
  * @throws Exception
  * @return \WC_Customer_Order_CSV_Export_Method_FTP
  */
 public function __construct()
 {
     parent::__construct();
     // Handle errors from ftp_* functions that throw warnings for things like invalid username / password, failed directory changes, and failed data connections
     set_error_handler(array($this, 'handle_errors'));
     // setup connection
     $this->link = null;
     if ('ftps' == $this->security && function_exists('ftp_ssl_connect')) {
         $this->link = ftp_ssl_connect($this->server, $this->port, $this->timeout);
     } elseif ('ftps' !== $this->security) {
         $this->link = ftp_connect($this->server, $this->port, $this->timeout);
     }
     // check for successful connection
     if (!$this->link) {
         throw new Exception(__("Could not connect via FTP to {$this->server} on port {$this->port}, check server address and port.", WC_Customer_Order_CSV_Export::TEXT_DOMAIN));
     }
     // attempt to login, note that incorrect credentials throws an E_WARNING PHP error
     if (!ftp_login($this->link, $this->username, $this->password)) {
         throw new Exception(__("Could not authenticate via FTP with username {$this->username} and password <hidden>. Check username and password.", WC_Customer_Order_CSV_Export::TEXT_DOMAIN));
     }
     // set passive mode if enabled
     if ($this->passive_mode) {
         // check for success
         if (!ftp_pasv($this->link, true)) {
             throw new Exception(__('Could not set passive mode', WC_Customer_Order_CSV_Export::TEXT_DOMAIN));
         }
     }
     // change directories if initial path is populated, note that failing to change directory throws an E_WARNING PHP error
     if ($this->path) {
         // check for success
         if (!ftp_chdir($this->link, '/' . $this->path)) {
             throw new Exception(__("Could not change directory to {$this->path} - check path exists.", WC_Customer_Order_CSV_Export::TEXT_DOMAIN));
         }
     }
 }

 /**
  * Tries to logon to the FTP server with given id and password
  *
  * @access public
  *
  * @param  string $source Authentication source to be used 
  * @param  string $external_uid    The ID entered
  * @param  string $external_passwd The password of the user
  *
  * @return boolean  True if the authentication was a success, false 
  *                  otherwise
  */
 public function Authenticate($source, $external_uid, $external_passwd)
 {
     $enc = ExternalAuthenticator::getAuthEnc($source);
     $port = ExternalAuthenticator::getAuthPort($source);
     if (is_null($port)) {
         $port = self::$port;
     }
     ExternalAuthenticator::AuthLog($external_uid . '.ftp - Connecting to ' . ExternalAuthenticator::getAuthServer($source) . ' port ' . $port);
     if ($enc == 'ssl') {
         ExternalAuthenticator::AuthLog($external_uid . '.ftp - Connection type is SSL');
         $conn = @ftp_ssl_connect(ExternalAuthenticator::getAuthServer($source), $port);
     } else {
         $conn = @ftp_connect(ExternalAuthenticator::getAuthServer($source), $port);
     }
     if (!$conn) {
         ExternalAuthenticator::AuthLog($external_uid . '.ftp - Connection to server failed');
         ExternalAuthenticator::setAuthMessage(_t('FTP_Authenticator.NoConnect', 'Could not connect to FTP server'));
         return false;
     } else {
         ExternalAuthenticator::AuthLog($external_uid . '.ftp - Connection to server succeeded');
     }
     if (!@ftp_login($conn, $external_uid, $external_passwd)) {
         ExternalAuthenticator::AuthLog($external_uid . '.ftp - User credentials failed at ftp server');
         ftp_close($conn);
         ExternalAuthenticator::setAuthMessage(_t('ExternalAuthenticator.Failed'));
         return false;
     } else {
         ExternalAuthenticator::AuthLog($external_uid . '.ftp - ftp server validated credentials');
         ftp_close($conn);
         return true;
     }
 }

 function test_connection()
 {
     if ($this->input->is_ajax_request()) {
         header('Content-Type: application/json', true);
         $ftp_server = trim($this->input->post('address'));
         $ftp_user = trim($this->input->post('user'));
         $ftp_password = trim($this->input->post('password'));
         $port = trim($this->input->post('port'));
         // set up basic connection
         if ($this->input->post('SFTP') == true) {
             $conn_id = @ftp_ssl_connect($ftp_server, $port) or die(json_encode(array('status' => 'error', 'output' => '<span class="delete ftp-alert cmsicon" style="display: inline-block;float: none;"></span>&nbsp;Couldn\'t connect to ' . $ftp_server)));
         } else {
             $conn_id = @ftp_connect($ftp_server, $port) or die(json_encode(array('status' => 'error', 'output' => '<span class="delete ftp-alert cmsicon" style="display: inline-block;float: none;"></span>&nbsp;Couldn\'t connect to ' . $ftp_server)));
         }
         // login with username and password
         if (!@ftp_login($conn_id, $ftp_user, $ftp_password)) {
             $output = array('status' => 'error', 'output' => '<span class="cus-cross-octagon"></span>&nbsp;Username and Password is incorrect');
         } else {
             $output = array('status' => 'success', 'output' => '<span class="cus-accept"></span>&nbsp;Connection OK!');
         }
         ftp_close($conn_id);
         echo json_encode($output);
     } else {
         show_404();
     }
 }

 /**
  * Connect to FTP Server. Use ssl + passive mode by default.
  *
  * @throws 
  * @see __construct
  * @param string $host
  * @param string $user
  * @param string $pass
  */
 public function open($host, $user, $pass)
 {
     $this->setConf(['host' => $host, 'login' => $user, 'password' => $pass]);
     $required = ['host', 'login', 'password', 'port', 'timeout'];
     foreach ($required as $key) {
         if (empty($this->conf[$key])) {
             throw new Exception('empty conf parameter', $key);
         }
     }
     if ($this->conf['ssl']) {
         $this->ftp = @ftp_ssl_connect($this->conf['host'], $this->conf['port'], $this->conf['timeout']);
     } else {
         $this->ftp = @ftp_connect($this->conf['host'], $this->conf['port'], $this->conf['timeout']);
     }
     if ($this->ftp === false) {
         throw new Exception('FTP connect failed', 'host=' . $this->conf['host'] . ' port=' . $this->conf['port']);
     }
     if (!@ftp_login($this->ftp, $this->conf['login'], $this->conf['password'])) {
         $ssl_msg = $this->conf['ssl'] ? ' - try without ssl' : ' - try with ssl';
         throw new Exception('FTP login failed' . $ssl_msg, 'login=' . $this->conf['login'] . ' password=' . mb_substr($this->conf['password'], 0, 2) . '***');
     }
     if ($this->conf['passive'] && !@ftp_pasv($this->ftp, true)) {
         throw new Exception('Failed to switch to passive FTP mode');
     }
     $this->_log('FTP connected to ' . $this->conf['host']);
 }

 /**
  * connect to the server.
  */
 public function connect()
 {
     if ($this->connection !== null) {
         return;
     }
     if ($this->config->getSSL()) {
         $this->connection = ftp_ssl_connect($this->config->getHost(), $this->config->getPort(), $this->config->getTimeout());
     } else {
         $this->connection = ftp_connect($this->config->getHost(), $this->config->getPort(), $this->config->getTimeout());
     }
     if ($this->connection === false) {
         throw new FTPFilesystemConnectionException('Could not connect to ' . $this->config->getHost());
     }
     if ($this->config->getUsername()) {
         if (!ftp_login($this->connection, $this->config->getUsername(), $this->config->getPassword())) {
             throw new FTPFilesystemAuthenticationException('Could not login to ' . $this->config->getHost() . ' with username ' . $this->config->getUsername() . ':' . ($this->config->getPassword() ? '*****' : 'NOPASS'));
         }
     }
     ftp_pasv($this->connection, $this->config->getPassiveMode());
     if ($this->config->getBasePath()) {
         if (!ftp_chdir($this->connection, $this->config->getBasePath())) {
             throw new FTPFilesystemException('Could not change into directory ' . $this->config->getBasePath() . ' on ' . $this->config->getHost());
         }
     }
 }

 /**
  * FTP Connect
  *
  * @access	public
  * @param	array	 the connection values
  * @return	bool
  */
 function connect($config = array())
 {
     if ($this->_is_conn() == TRUE) {
         return TRUE;
     }
     if (count($config) > 0) {
         $this->initialize($config);
     }
     if ($this->ssl == TRUE) {
         if (function_exists('ftp_ssl_connect')) {
             $this->conn_id = @ftp_ssl_connect($this->hostname, $this->port, $this->timeout);
         } else {
             $this->_error('ftp_ssl_not_supported');
             return FALSE;
         }
     } else {
         $this->conn_id = @ftp_connect($this->hostname, $this->port, $this->timeout);
     }
     if ($this->conn_id === FALSE) {
         $this->_error('ftp_unable_to_connect');
         return FALSE;
     }
     if (!$this->_login()) {
         $this->_error('ftp_unable_to_login');
         return FALSE;
     }
     // Set passive mode if needed
     if ($this->passive == TRUE) {
         ftp_pasv($this->conn_id, TRUE);
     }
     return TRUE;
 }

 function connect()
 {
     if (!$this->options['hostname'] || !$this->options['username'] || !$this->options['password']) {
         if (!defined('SUPPORT_URL')) {
             define('SUPPORT_URL', getOption('supportURL'));
         }
         appUpdateMsg('<a href="' . SUPPORT_URL . 'solution/articles/195233-asking-for-ftp-sftp-details-during-update/" target="_blank">See how to add the FTP details</a>.');
         return false;
     }
     if (isset($this->options['ssl']) && $this->options['ssl'] && function_exists('ftp_ssl_connect')) {
         $this->link = @ftp_ssl_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
     } else {
         $this->link = @ftp_connect($this->options['hostname'], $this->options['port'], FS_CONNECT_TIMEOUT);
     }
     if (!$this->link) {
         //$this->errors->add('connect', sprintf(__('Failed to connect to FTP Server %1$s:%2$s'), $this->options['hostname'], $this->options['port']));
         appUpdateMsg(sprintf('Failed to connect to the FTP server "%1$s:%2$s"', $this->options['hostname'], $this->options['port']));
         return false;
     }
     if (!@ftp_login($this->link, $this->options['username'], $this->options['password'])) {
         //$this->errors->add('auth', sprintf(__('Username/Password incorrect for %s'), $this->options['username']));
         appUpdateMsg(sprintf('FTP username or password incorrect for "%s"', $this->options['username']));
         return false;
     }
     //Set the Connection to use Passive FTP
     if ($this->options['passive']) {
         @ftp_pasv($this->link, true);
     }
     if (@ftp_get_option($this->link, FTP_TIMEOUT_SEC) < FS_TIMEOUT) {
         @ftp_set_option($this->link, FTP_TIMEOUT_SEC, FS_TIMEOUT);
     }
     return true;
 }

 /**
  * FTP Connect
  *
  * @access	public
  * @param	array	 the connection values
  * @return	bool
  */
 public function connect()
 {
     if ($this->_ssl === true) {
         if (!function_exists('ftp_ssl_connect')) {
             throw new \RuntimeException('ftp_ssl_connect() function is missing.');
         }
         $this->_conn = @ftp_ssl_connect($this->_hostname, $this->_port, $this->_timeout);
     } else {
         $this->_conn = @ftp_connect($this->_hostname, $this->_port, $this->_timeout);
     }
     if ($this->_conn === false) {
         if ($this->_debug == true) {
             throw new \Exception('FTP - Unable to establish a connection');
         }
         return false;
     }
     if (!$this->_login()) {
         if ($this->_debug == true) {
             throw new \Exception('FTP - Unable to login');
         }
     }
     // Set passive mode if needed
     if ($this->_passive == true) {
         ftp_pasv($this->_conn, true);
     }
     return $this;
 }

 /**
  * 连接FTP服务器
  * @param string $host    　　 服务器地址
  * @param string $username　　　用户名
  * @param string $password　　　密码
  * @param integer $port　　　　   服务器端口，默认值为21
  * @param boolean $pasv        是否开启被动模式
  * @param boolean $ssl　　　　 　是否使用SSL连接
  * @param integer $timeout     超时时间　
  */
 public function connect($host, $username = '', $password = '', $port = '21', $pasv = false, $ssl = false, $timeout = 30)
 {
     $start = time();
     if ($ssl) {
         if (!($this->link = @ftp_ssl_connect($host, $port, $timeout))) {
             $this->err_code = 1;
             return false;
         }
     } else {
         if (!($this->link = ftp_connect($host, $port, $timeout))) {
             $this->err_code = 1;
             return false;
         }
     }
     if (ftp_login($this->link, $username, $password)) {
         if ($pasv) {
             ftp_pasv($this->link, true);
         }
         $this->link_time = time() - $start;
         return true;
     } else {
         $this->err_code = 1;
         return false;
     }
     register_shutdown_function(array(&$this, 'close'));
 }

 /**
  * Connect to an FTP server.
  *
  * @return Object FTP connection
  */
 private static function _connect()
 {
     // do we have an instance already?
     if (!isset(self::$instance)) {
         // give us an ftp connection
         // try ssl first
         @($connection = ftp_ssl_connect(FTP_HOST));
         if (!$connection) {
             // go old school
             @($connection = ftp_connect(FTP_HOST));
             // fail if we don't have a connection
             if (!$connection) {
                 return array('status' => 'fail', 'message' => 'Couldn\'t connect to the FTP server.');
             }
         }
         // login to the server
         @($login = ftp_login($connection, FTP_USER, FTP_PASS));
         // check that login went fine
         if (!$login) {
             return array('status' => 'fail', 'message' => 'Incorrect FTP account credentials.');
         }
         // change connection to a passive mode (connection initiated by client and not server)
         ftp_pasv($connection, TRUE);
         // set ftp connection
         self::$instance = $connection;
     }
     return self::$instance;
 }

 public function __construct($host, $port = 21, $timeout = 90, $ssl = false, $proxy = false, $proxyport = false)
 {
     $host = mb_substr($host, -1, 1) == '/' ? mb_substr($host, 0, mb_strlen($host) - 1) : $host;
     if (mb_strpos($host, 'ftp://') !== false) {
         $host = mb_substr($host, 6);
     }
     $host = $proxy ? $proxy : $host;
     $port = $proxyport ? $proxyport : $port;
     if ($this->debug && $proxy) {
         echo "Utilisation du proxy {$proxy}\n<br>";
     }
     if ($this->debug && $proxyport) {
         echo "Utilisation du port proxy {$proxyport}\n<br>";
     }
     $this->proxy = $proxy;
     $this->host = $host;
     if ($this->debug) {
         echo "Ouverture de connection vers {$host}:{$port} timeout {$timeout} et proxy {$proxy}:{$proxyport}\n<br>";
     }
     if (trim($host) == '') {
         throw new Exception('Nom d\'hote incorrect ' . $host);
     }
     if ($ssl === true) {
         if (($this->connexion = @ftp_ssl_connect($host, $port, $timeout)) === false) {
             throw new Exception('Impossible de se connecter au serveur FTP en SSL');
         }
     } else {
         if (($this->connexion = @ftp_connect($host, $port, $timeout)) === false) {
             throw new Exception('Impossible de se connecter au serveur FTP ' . $host . ":{$port} {$timeout}");
         }
     }
     return $this;
 }

 /**
  * @param  mixed  string or URL object
  * @param  int    Connection timeout in seconds
  * @throws IOException
  * @throws IllegalArgumentException
  */
 public function __construct($url, $timeout = 30)
 {
     $url = URL::valueOf($url);
     try {
         if ($url->isProtocol('ftp')) {
             $this->conn = ftp_connect($url->getHost('localhost'), $url->getPort(), $timeout);
         } elseif ($url->isProtocol('ftps')) {
             $this->conn = ftp_ssl_connect($url->getHost('localhost'), $url->getPort(), $timeout);
         } else {
             throw new IllegalTypeException('Unsupported protocol: ' . $url->getProtocol('???'));
         }
     } catch (PHPException $e) {
         $e->setMessage(str_replace(array('ftp_connect(): ', 'ftp_ssl_connect(): '), '', $e->getMessage()));
         throw new ConnectException($e);
     }
     if ($this->conn == false) {
         throw new ConnectException('Failed to connect (unknown reason)');
     }
     if ($url->getUser()) {
         $this->login($url->getUser(), $url->getPassword(''));
     }
     if ($url->getPath()) {
         $this->cd($url->getPath());
     }
 }

 /**
  * 
  * @param string $host
  * @param string $user
  * @param string $pass
  * @param string $port
  * @param boolean $passive
  * @param boolean $ssl
  * @return boolean
  * @throws Exception
  */
 public function connect($host, $user, $pass, $port = 21, $passive = true, $ssl = false)
 {
     $this->host = $host;
     $this->user = $user;
     $this->pass = $pass;
     $this->port = $port;
     $this->_idFtp = null;
     $this->passive = $passive;
     $this->ssl = $ssl;
     if ($this->ssl) {
         $this->_idFtp = @ftp_ssl_connect($this->host, $this->port);
     } else {
         $this->_idFtp = @ftp_connect($this->host, $this->port);
     }
     if (!$this->_idFtp) {
         throw new Exception('Nao foi possivel conectar ao servidor "' . $this->host . '" sobre a porta "' . $this->port . '".', -32001);
     }
     $result = @ftp_login($this->_idFtp, $this->user, $this->pass);
     if (!$result) {
         throw new Exception('Usuario ou senha invalido!', -32010);
     }
     if (!@ftp_pasv($this->_idFtp, $this->passive)) {
         throw new Exception('Nao foi possivel alterar o modo "passive mode"!', -32002);
     }
     $this->_isConnected = true;
     return true;
 }

 public function getListing()
 {
     $dir = $this->directory;
     // Parse directory to parts
     $parsed_dir = trim($dir, '/');
     $this->parts = empty($parsed_dir) ? array() : explode('/', $parsed_dir);
     // Find the path to the parent directory
     if (!empty($parts)) {
         $copy_of_parts = $parts;
         array_pop($copy_of_parts);
         if (!empty($copy_of_parts)) {
             $this->parent_directory = '/' . implode('/', $copy_of_parts);
         } else {
             $this->parent_directory = '/';
         }
     } else {
         $this->parent_directory = '';
     }
     // Connect to the server
     if ($this->ssl) {
         $con = @ftp_ssl_connect($this->host, $this->port);
     } else {
         $con = @ftp_connect($this->host, $this->port);
     }
     if ($con === false) {
         $this->setError(JText::_('FTPBROWSER_ERROR_HOSTNAME'));
         return false;
     }
     // Login
     $result = @ftp_login($con, $this->username, $this->password);
     if ($result === false) {
         $this->setError(JText::_('FTPBROWSER_ERROR_USERPASS'));
         return false;
     }
     // Set the passive mode -- don't care if it fails, though!
     @ftp_pasv($con, $this->passive);
     // Try to chdir to the specified directory
     if (!empty($dir)) {
         $result = @ftp_chdir($con, $dir);
         if ($result === false) {
             $this->setError(JText::_('FTPBROWSER_ERROR_NOACCESS'));
             return false;
         }
     } else {
         $this->directory = @ftp_pwd($con);
         $parsed_dir = trim($this->directory, '/');
         $this->parts = empty($parsed_dir) ? array() : explode('/', $parsed_dir);
         $this->parent_directory = $this->directory;
     }
     // Get a raw directory listing (hoping it's a UNIX server!)
     $list = @ftp_rawlist($con, '.');
     ftp_close($con);
     if ($list === false) {
         $this->setError(JText::_('FTPBROWSER_ERROR_UNSUPPORTED'));
         return false;
     }
     // Parse the raw listing into an array
     $folders = $this->parse_rawlist($list);
     return $folders;
 }

 /**
  * 建立ssl ftp连接
  * 
  */
 protected function connectSsl()
 {
     $ftpobj = @ftp_ssl_connect($this->host, $this->port, $this->timeout);
     if (null == $ftpobj) {
         throw new FtpException("FTP ERROR : Couldn't connect to {$this->host}");
     }
 }

 public function sslConnect()
 {
     try {
         $this->resource = ftp_ssl_connect($this->host, $this->port);
     } catch (Exception $e) {
         throw new Exception("Unable to establish a SSL-FTP connection to host: " . $this->host . ':' . $this->port);
     }
     $this->login();
 }

 /**
  * @desc Coneción al servidor
  * @return bool
  */
 public function connect($ssl = false, $timeout = 90)
 {
     $this->connection = $ssl ? ftp_ssl_connect($this->server, $this->port, $timeout) : ftp_connect($this->server, $this->port, $timeout);
     if (!ftp_login($this->connection, $this->uname, $this->pass)) {
         return false;
     } else {
         return true;
     }
 }

 /**
  * Establish a connection
  * @todo Options...
  */
 public function __construct($url, array $options = null)
 {
     $data = parse_url($url);
     //Establish connection to the server
     if (isset($data['scheme']) && strtolower($data['scheme']) == 'ftps') {
         if (isset($data['port']) && $data['port']) {
             $this->conn = ftp_ssl_connect($data['host'], $data['port']);
             if (!$this->conn) {
                 throw new \Exception("Could not connect to 'ftps://{$data['host']}:{$data['port']}'");
             }
         } else {
             $this->conn = ftp_ssl_connect($data['host']);
             if (!$this->conn) {
                 throw new \Exception("Could not connect to 'ftps://{$data['host']}'");
             }
         }
     } else {
         if (isset($data['port']) && $data['port']) {
             $this->conn = ftp_connect($data['host'], $data['port']);
             if (!$this->conn) {
                 throw new \Exception("Could not connect to 'ftp://{$data['host']}:{$data['port']}'");
             }
         } else {
             $this->conn = ftp_connect($data['host']);
             if (!$this->conn) {
                 throw new \Exception("Could not connect to 'ftp://{$data['host']}'");
             }
         }
     }
     //Provide username and password
     if (isset($data['user'])) {
         $user = $data['user'];
     } else {
         $user = 'anonymous';
     }
     if (isset($data['pass'])) {
         $pass = $data['pass'];
     } else {
         $pass = '';
     }
     if (!ftp_login($this->conn, $user, $pass)) {
         throw new \Exception("Could not login to '{$data['host']}' as '{$user}'");
     }
     //Use firewall friendly passive mode
     if (!ftp_pasv($this->conn, true)) {
         trigger_error("Passive mode failed", \E_USER_WARNING);
     }
     //Go to defined directory
     if (isset($data['path']) && $data['path']) {
         // Make sure the $path ends with a slash.
         $data['path'] = rtrim($data['path'], '/') . '/';
         if (!$this->cd(urldecode($data['path']))) {
             throw new \Exception("Could not change directory to '{$data['path']}'. Please make sure the directory exists.");
         }
     }
 }

 public function createSecondFTPConnect($ip, $port, $user, $pwd, $ssl = 'N')
 {
     $this->ftpSecondConnection = $ssl == 'N' ? @ftp_connect($ip, $port, 5) : @ftp_ssl_connect($ip, $port, 5);
     if ($this->ftpSecondConnection) {
         $ftpLogin = @ftp_login($this->ftpSecondConnection, $user, $pwd);
         if ($ftpLogin) {
             $this->secondLoggedIn = true;
             return true;
         }
     }
     return false;
 }

 function connect($base_dir = null)
 {
     static $ftp_conn, $_base_dir, $disconnected = false;
     if (!isset($ftp_conn) || $disconnected) {
         if (!defined('AK_FTP_PATH')) {
             trigger_error(Ak::t('You must set a valid FTP connection on AK_FTP_PATH in your config/config.php file'), E_USER_ERROR);
         } else {
             if (AK_AUTOMATIC_CONFIG_VARS_ENCRYPTION && substr(AK_FTP_PATH, 0, 10) == 'PROTECTED:') {
                 // You should change the key bellow and encode this file if you are going to distribute applications
                 // The ideal protection would be to encode user configuration file.
                 $AK_FTP_PATH = Ak::decrypt(base64_decode(substr(AK_FTP_PATH, 10)), 'HR23JHR93JZ0ALi1UvTZ0ALi1UvTk7MD70');
                 $_pass_encoded = true;
             } else {
                 $AK_FTP_PATH = AK_FTP_PATH;
             }
             $f = parse_url($AK_FTP_PATH);
             if (@$f['scheme'] != 'ftps') {
                 $ftp_conn = isset($f['port']) ? ftp_connect($f['host'], $f['port']) : ftp_connect($f['host']);
             } else {
                 $ftp_conn = isset($f['port']) ? ftp_ssl_connect($f['host'], $f['port']) : ftp_ssl_connect($f['host']);
             }
             $f['user'] = str_replace('+', '@', @$f['user']);
             $login_result = ftp_login($ftp_conn, $f['user'], @$f['pass']);
             if (!$ftp_conn || !$login_result) {
                 AK_FTP_SHOW_ERRORS ? trigger_error(Ak::t('Could not connect to the FTP server'), E_USER_NOTICE) : null;
                 return false;
             }
             $_base_dir = isset($f['path']) ? '/' . trim($f['path'], '/') : '/';
             if (defined('AK_FTP_AUTO_DISCONNECT') && AK_FTP_AUTO_DISCONNECT) {
                 register_shutdown_function(array('AkFtp', 'disconnect'));
             }
             if (AK_AUTOMATIC_CONFIG_VARS_ENCRYPTION && empty($_pass_encoded)) {
                 @register_shutdown_function(create_function('', "@Ak::file_put_contents(AK_CONFIG_DIR.DS.'config.php',\n                str_replace(AK_FTP_PATH,'PROTECTED:'.base64_encode(Ak::encrypt(AK_FTP_PATH,'HR23JHR93JZ0ALi1UvTZ0ALi1UvTk7MD70')),\n                Ak::file_get_contents(AK_CONFIG_DIR.DS.'config.php')));"));
             }
         }
     }
     if (isset($base_dir) && $base_dir === 'AK_DISCONNECT_FTP') {
         $disconnected = true;
         $base_dir = null;
     } else {
         $disconnected = false;
     }
     if (!isset($base_dir) && isset($_base_dir) && '/' . trim(ftp_pwd($ftp_conn), '/') != $_base_dir) {
         if (!@ftp_chdir($ftp_conn, $_base_dir) && AK_FTP_SHOW_ERRORS) {
             trigger_error(Ak::t('Could not change to the FTP base directory %directory', array('%directory' => $_base_dir)), E_USER_NOTICE);
         }
     } elseif (isset($base_dir)) {
         if (!ftp_chdir($ftp_conn, $base_dir) && AK_FTP_SHOW_ERRORS) {
             trigger_error(Ak::t('Could not change to the FTP directory %directory', array('%directory' => $base_dir)), E_USER_NOTICE);
         }
     }
     return $ftp_conn;
 }