/**
  * Establece la conceccion al servidor de FTP
  *
  * @param $servidor_ftp=host  $user=usuario $pass=password $modo=de conexxion por defecto en true
  * @return $id_con identificador de la conexion FTP
  */
 function conexion($servidor_ftp, $user, $pass, $modo = true, $puerto = 21, $tiempoEspera = 360)
 {
     // configurar una conexion o abortar
     // el arroba es para evitar los warning que salgan por pantalla
     if (empty($tiempoEspera)) {
         $tiempoEspera = 90;
     }
     @($id_con = ftp_connect($servidor_ftp, $puerto, $tiempoEspera));
     if (!$id_con || !isset($id_con)) {
         return false;
         //return false conexion no establecida
     } else {
         // Abrir la session con usuario y contraseña
         // el arroba es para evitar los warning que salgan por pantalla
         @($login_result = ftp_login($id_con, $user, $pass));
         if (!$login_result || !isset($login_result)) {
             return false;
             //return false el logueo no fue establecida
         }
     }
     // Habilita o deshabilita el modo pasivo. En modo pasivo, las conexiones de datos son
     // iniciadas por el cliente, en lugar del servidor. Puede requerirse si el cliente se
     // encuentra detrás de un firewall. ftp_pasv() únicamente puede llamarse después de
     // un inicio de sesión exitoso, de otra forma fallará.
     ftp_pasv($id_con, $modo);
     // Verifico que type UNIX (tambien lo toman como valor la mayoria de los servidores windows)
     $res = ftp_systype($id_con);
     //if($res != "UNIX") return false;
     // Se conect OK
     return $id_con;
 }

 protected function connect()
 {
     // open connection
     if (!($this->cn = ftp_connect($this->host, $this->port))) {
         trigger_error(sprintf(self::TEXT_CONNECT, $this->host, $this->port));
     }
     // login
     if (!ftp_login($this->getConnection(), $this->user, $this->pass)) {
         $this->disconnect();
         trigger_error(sprintf(self::TEXT_LOGIN_FAILED, $this->user));
     }
     // passive mode
     if ($this->passive && !ftp_pasv($this->getConnection(), true)) {
         $this->disconnect();
         trigger_error(self::TEXT_PASSIVE_MODE);
     }
     // check path
     if ($this->path != '/') {
         if (!$this->isDir($this->path) && !$this->createDir($this->path)) {
             $this->disconnect();
             trigger_error(self::TEXT_MOUNT_DIR);
         }
         // switch directory
         if (!ftp_chdir($this->getConnection(), $this->path)) {
             $this->disconnect();
             trigger_error(sprintf(self::TEXT_CHANGE_DIR, $this->path));
         }
     }
 }

 function connect($hostName, $userName, $password, $port = 21, $passiveMode = true, $attempt = 0)
 {
     $this->currentHostName = $hostName;
     $this->currentUserName = $userName;
     $this->currentPassword = $password;
     $this->currentPort = $port;
     $this->currentPassiveMode = $passiveMode;
     // br()->log('Connecting to ' . $hostName . ' as ' . $userName);
     try {
         if ($this->connectionId = ftp_connect($hostName, $port)) {
             if (ftp_login($this->connectionId, $userName, $password)) {
                 if (ftp_pasv($this->connectionId, $passiveMode ? true : false)) {
                     $this->currentDirectory = $this->getServerDir();
                 } else {
                     throw new Exception('Can not switch passive mode to ' . $passiveMode);
                 }
             } else {
                 throw new Exception('Can not connect to ' . $hostName . ' as ' . $userName);
             }
         } else {
             throw new Exception('Can not connect to ' . $hostName);
         }
     } catch (Exception $e) {
         if (!preg_match('/Login incorrect/', $e->getMessage()) && $attempt < $this->reconnectsAmount) {
             usleep(250000);
             $this->connect($hostName, $userName, $password, $port, $passiveMode, $attempt + 1);
         } else {
             throw new Exception('Can not connect to ' . $hostName . ': ' . $e->getMessage());
         }
     }
 }

 /**
  * Establish an FTP connection
  * 
  * @throws \Exception If an FTP connection cannot be established
  */
 public function connect()
 {
     if ($this->blnIsConnected) {
         return;
     }
     // Check the FTP credentials
     if ($GLOBALS['TL_CONFIG']['ftpHost'] == '') {
         throw new \Exception('The FTP host must not be empty');
     } elseif ($GLOBALS['TL_CONFIG']['ftpUser'] == '') {
         throw new \Exception('The FTP username must not be empty');
     } elseif ($GLOBALS['TL_CONFIG']['ftpPass'] == '') {
         throw new \Exception('The FTP password must not be empty');
     }
     $ftp_connect = $GLOBALS['TL_CONFIG']['ftpSSL'] && function_exists('ftp_ssl_connect') ? 'ftp_ssl_connect' : 'ftp_connect';
     // Try to connect
     if (($resConnection = $ftp_connect($GLOBALS['TL_CONFIG']['ftpHost'], $GLOBALS['TL_CONFIG']['ftpPort'], 5)) == false) {
         throw new \Exception('Could not connect to the FTP server');
     } elseif (ftp_login($resConnection, $GLOBALS['TL_CONFIG']['ftpUser'], $GLOBALS['TL_CONFIG']['ftpPass']) == false) {
         throw new \Exception('Authentication failed');
     }
     // Switch to passive mode
     ftp_pasv($resConnection, true);
     $this->blnIsConnected = true;
     $this->resConnection = $resConnection;
 }

 /**
  * 连接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'));
 }

 public function connect()
 {
     $this->printLog("Connect");
     if ($this->conn_id = ftp_connect($this->host, $this->port, $this->timeout)) {
         if (ftp_login($this->conn_id, $this->user, $this->pass)) {
             $this->updateState(PR_FTP_STATE_LOGGED_IN);
             if ($status = ftp_chdir($this->conn_id, $this->cur_path)) {
                 $this->updateState(PR_FTP_STATE_TARGETED);
                 $this->updateStatus(PR_FTP_STATUS_READY);
                 $this->systype = ftp_systype($this->conn_id);
                 // TODO: make specific OS dependednt things
                 $this->printLog("OS: " . $this->systype . " " . ftp_pwd($this->conn_id));
                 // TODO: pass the mode into the module
                 ftp_pasv($this->conn_id, true);
                 unset($this->listing_cache);
                 $this->listing_cache = array();
             } else {
                 $this->updateState(PR_FTP_STATE_ERROR);
             }
         } else {
             $this->updateState(PR_FTP_STATE_DISCONNECTED);
             $this->updateStatus(PR_FTP_STATUS_NOT_READY);
         }
     } else {
         $this->updateState(PR_FTP_STATE_DISCONNECTED);
         $this->updateStatus(PR_FTP_STATUS_NOT_READY);
     }
 }

 /**
  * 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']);
 }

 private function ljg_ftp_login()
 {
     $conn = ftp_connect($this->ljg_ftp['ip']);
     ftp_login($conn, $this->ljg_ftp['login'], $this->ljg_ftp['pass']);
     ftp_pasv($conn, true);
     return $conn;
 }

 protected function _getConnexion($data)
 {
     if (!empty($this->conn)) {
         return $this->conn;
     }
     if (!array_key_exists('host', $data) || empty($data['host'])) {
         throw new InvalidArgumentException('Empty FTP server adress', 400);
     }
     if (!array_key_exists('port', $data) || empty($data['port'])) {
         throw new InvalidArgumentException('Empty FTP server port', 400);
     }
     if (!array_key_exists('user', $data)) {
         $data['user'] = '';
     }
     if (!array_key_exists('password', $data)) {
         $data['password'] = '';
     }
     $conn = ftp_connect($data['host'], $data['port']);
     if ($conn === false) {
         throw new \RuntimeException('Cannot connect to FTP server "' . $loginData['host'] . ':' . $loginData['port'] . '"', 502);
     }
     if (ftp_login($conn, $data['user'], $data['password'])) {
         // Turn passive mode on
         if (ftp_pasv($conn, true) === false) {
             throw new \RuntimeException('Cannot connect to FTP server "' . $loginData['host'] . ':' . $loginData['port'] . '" (cannot turn passive mode on)', 502);
         }
         $this->conn = $conn;
         return $conn;
     } else {
         throw new \RuntimeException('Cannot connect to FTP server "' . $loginData['host'] . ':' . $loginData['port'] . '" with username "' . $loginData['user'] . '" (authentification failed)', 401);
     }
 }

 function Connect($passive = TRUE)
 {
     $conn_id = ftp_connect($this->config->item('static_ftp_address'));
     ftp_login($conn_id, $this->config->item('static_ftp_username'), $this->config->item('static_ftp_password'));
     $mode = ftp_pasv($conn_id, $passive);
     return $conn_id;
 }

 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;
 }

function upload()
{
    $ftp_server = "ftp.webcindario.com";
    $ftp_user_name = "nngg";
    $ftp_user_pass = "caballo12";
    $destination_file = "./img/";
    $source_file = $_FILES['userfile']['tmp_name'];
    $source_name = $_FILES['userfile']['name'];
    $conn_id = ftp_connect($ftp_server);
    ftp_pasv($conn_id, true);
    $login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
    if (!$conn_id || !$login_result) {
        echo "";
        echo "";
        exit;
    } else {
        echo "";
    }
    $upload = ftp_put($conn_id, $destination_file . $_FILES['userfile']['name'], $source_file, FTP_BINARY);
    if (!$upload) {
        echo "";
    } else {
        echo "";
    }
}

 /**
  * 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;
 }

function DeleteUpfile($R, $d)
{
    global $g, $table;
    $UPFILES = getArrayString($R['upload']);
    foreach ($UPFILES['data'] as $_val) {
        $U = getUidData($table['s_upload'], $_val);
        if ($U['uid']) {
            if ($U['url'] == $d['comment']['ftp_urlpath']) {
                $FTP_CONNECT = ftp_connect($d['comment']['ftp_host'], $d['comment']['ftp_port']);
                $FTP_CRESULT = ftp_login($FTP_CONNECT, $d['comment']['ftp_user'], $d['comment']['ftp_pass']);
                if ($d['comment']['ftp_pasv']) {
                    ftp_pasv($FTP_CONNECT, true);
                }
                if (!$FTP_CONNECT) {
                    getLink('', '', 'FTP서버 연결에 문제가 발생했습니다.', '');
                }
                if (!$FTP_CRESULT) {
                    getLink('', '', 'FTP서버 아이디나 패스워드가 일치하지 않습니다.', '');
                }
                ftp_delete($FTP_CONNECT, $d['comment']['ftp_folder'] . $U['folder'] . '/' . $U['tmpname']);
                if ($U['type'] == 2) {
                    ftp_delete($FTP_CONNECT, $d['comment']['ftp_folder'] . $U['folder'] . '/' . $U['thumbname']);
                }
                ftp_close($FTP_CONNECT);
            } else {
                unlink($U['url'] . $U['folder'] . '/' . $U['tmpname']);
                if ($U['type'] == 2) {
                    unlink($U['url'] . $U['folder'] . '/' . $U['thumbname']);
                }
            }
            getDbDelete($table['s_upload'], 'uid=' . $U['uid']);
        }
    }
}

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

 /**
  * @return bool
  * @throws \Exception
  */
 public function setPassiveMode()
 {
     if (false === ftp_pasv($this->getFtp(), true)) {
         throw new \Exception("Can't switch to PASSIVE mode in " . $this->getFtpHost());
     }
     return true;
 }

 /**
  * Establish FTP connection
  * @param void
  * @return bool
  */
 public function connect()
 {
     $cf = $this->ssl === true ? 'ftp_ssl_connect' : 'ftp_connect';
     $this->connection = @$cf($this->host, $this->port, $this->timeout);
     if ($this->connection !== false) {
         $this->debugSet('400', 'Connection ok');
         $login = @ftp_login($this->connection, $this->user, $this->password);
         if ($login === true) {
             $this->debugSet('401', 'Login ok');
             if ($this->passive === true) {
                 $pasv = ftp_pasv($this->connection, true);
                 if ($login === true) {
                     $this->debugSet('402', 'Passive mode ok');
                 } else {
                     $this->debugSet('1402', 'Passive mode failed');
                 }
             }
             $this->status = true;
         } else {
             $this->debugSet('1401', 'FTP Login failed');
             ftp_close($this->connection);
             $this->connection = false;
         }
     } else {
         $this->debugSet('1400', 'FTP Connection failed');
     }
     return $this->status;
 }

 private function uploadPackageToFTP($account)
 {
     $connection = @ftp_connect($account['host']);
     if (!$connection) {
         cmsUser::addSessionMessage(LANG_CP_FTP_AUTH_FAILED, 'error');
         return false;
     }
     $session = @ftp_login($connection, $account['user'], $account['pass']);
     if (!$session) {
         cmsUser::addSessionMessage(LANG_CP_FTP_AUTH_FAILED, 'error');
         return false;
     }
     if ($account['is_pasv']) {
         ftp_pasv($connection, true);
     }
     if (!$this->checkDestination($connection, $account)) {
         return false;
     }
     $src_dir = $this->getPackageContentsDir();
     $dst_dir = '/' . trim($account['path'], '/');
     try {
         $this->uploadDirectoryToFTP($connection, $src_dir, $dst_dir);
     } catch (Exception $e) {
         ftp_close($connection);
         cmsUser::addSessionMessage($e->getMessage(), 'error');
         return false;
     }
     ftp_close($connection);
     $this->redirectToAction('install/finish');
     return true;
 }

 /**
  * Fetch data file from Itella FTP server
  * @param $type Data file type (PCF = localities, BAF = street addresses, POM = zip code changes)
  * @returns Temp file name
  */
 public function fetchFile($type)
 {
     //Connect to FTP server
     $ftp = ftp_connect($this->host);
     if ($ftp === false) {
         throw new Exception("Could not connect to '{$this->host}'");
     }
     if (!ftp_login($ftp, $this->user, $this->password)) {
         throw new Exception("Login to '{$this->host}' as '{$this->user}' failed");
     }
     //Find filename to download
     ftp_pasv($ftp, true);
     $list = ftp_nlist($ftp, '.');
     $file = null;
     foreach ($list as $item) {
         $parts = explode('_', $item);
         if (isset($parts[0]) && strtoupper($parts[0]) == strtoupper($type)) {
             $file = $item;
         }
     }
     if ($file == null) {
         throw new Exception("'{$type}' file not found");
     }
     //Download requested data file
     $tmpFile = tempnam(sys_get_temp_dir(), 'FinZip_' . $type . '_') . '.zip';
     $this->tmpFiles[] = $tmpFile;
     $tmp = fopen($tmpFile, 'w');
     ftp_pasv($ftp, true);
     ftp_fget($ftp, $tmp, $file, FTP_BINARY);
     ftp_close($ftp);
     fclose($tmp);
     //Return the filename of the temporary file
     return $tmpFile;
 }

function copyViaFtpRecursively($uploadLocation, $previewPath, $remoteDirectory, $ftpType)
{
    $errorMessage = '';
    $connectionId = getFtpConnection($uploadLocation['host'], $uploadLocation['username'], $uploadLocation['password'], $uploadLocation['port']);
    switch ($ftpType) {
        case 'active':
            ftp_pasv($connectionId, False);
            break;
        case 'passive':
            ftp_pasv($connectionId, True);
            break;
    }
    $baseDirectory = $uploadLocation['baseDirectory'];
    if (substr($baseDirectory, strlen($baseDirectory) - 1, 1) != '/') {
        $baseDirectory .= '/';
    }
    ftp_mkdir($connectionId, $baseDirectory);
    // No point showing an error message if the directory exists (most likely cause of error) because it will exist (at least) after the first time.
    $remoteBaseDirectory = $baseDirectory . $remoteDirectory;
    if (substr($remoteBaseDirectory, strlen($remoteBaseDirectory) - 1, 1) == '/') {
        $remoteBaseDirectory = substr($remoteBaseDirectory, 0, strlen($remoteBaseDirectory) - 1);
    }
    $remoteBaseDirectory .= '/';
    $errorMessage .= copyFileViaFtp($previewPath, $remoteBaseDirectory, $connectionId);
    ftp_close($connectionId);
    $errorHtml = '';
    if ($errorMessage) {
        $errorHtml = nl2br($errorMessage);
    }
    return $errorHtml;
}