PHP ftp_pasv函数代码示例

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