[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * WordPress FTP Sockets Filesystem.
   4   *
   5   * @package WordPress
   6   * @subpackage Filesystem
   7   */
   8  
   9  /**
  10   * WordPress Filesystem Class for implementing FTP Sockets.
  11   *
  12   * @since 2.5
  13   * @package WordPress
  14   * @subpackage Filesystem
  15   * @uses WP_Filesystem_Base Extends class
  16   */
  17  class WP_Filesystem_ftpsockets extends WP_Filesystem_Base {
  18      var $ftp = false;
  19      var $errors = null;
  20      var $options = array();
  21  
  22  	function WP_Filesystem_ftpsockets($opt = '') {
  23          $this->method = 'ftpsockets';
  24          $this->errors = new WP_Error();
  25  
  26          //Check if possible to use ftp functions.
  27          if ( ! @include_once ABSPATH . 'wp-admin/includes/class-ftp.php' )
  28                  return false;
  29          $this->ftp = new ftp();
  30  
  31          //Set defaults:
  32          if ( empty($opt['port']) )
  33              $this->options['port'] = 21;
  34          else
  35              $this->options['port'] = $opt['port'];
  36  
  37          if ( empty($opt['hostname']) )
  38              $this->errors->add('empty_hostname', __('FTP hostname is required'));
  39          else
  40              $this->options['hostname'] = $opt['hostname'];
  41  
  42          if ( isset($opt['base']) && ! empty($opt['base']) )
  43              $this->wp_base = $opt['base'];
  44  
  45          // Check if the options provided are OK.
  46          if ( empty ($opt['username']) )
  47              $this->errors->add('empty_username', __('FTP username is required'));
  48          else
  49              $this->options['username'] = $opt['username'];
  50  
  51          if ( empty ($opt['password']) )
  52              $this->errors->add('empty_password', __('FTP password is required'));
  53          else
  54              $this->options['password'] = $opt['password'];
  55      }
  56  
  57  	function connect() {
  58          if ( ! $this->ftp )
  59              return false;
  60  
  61          $this->ftp->setTimeout(FS_CONNECT_TIMEOUT);
  62  
  63          if ( ! $this->ftp->SetServer($this->options['hostname'], $this->options['port']) ) {
  64              $this->errors->add('connect', sprintf(__('Failed to connect to FTP Server %1$s:%2$s'), $this->options['hostname'], $this->options['port']));
  65              return false;
  66          }
  67  
  68          if ( ! $this->ftp->connect() ) {
  69              $this->errors->add('connect', sprintf(__('Failed to connect to FTP Server %1$s:%2$s'), $this->options['hostname'], $this->options['port']));
  70              return false;
  71          }
  72  
  73          if ( ! $this->ftp->login($this->options['username'], $this->options['password']) ) {
  74              $this->errors->add('auth', sprintf(__('Username/Password incorrect for %s'), $this->options['username']));
  75              return false;
  76          }
  77  
  78          $this->ftp->SetType(FTP_AUTOASCII);
  79          $this->ftp->Passive(true);
  80          $this->ftp->setTimeout(FS_TIMEOUT);
  81          return true;
  82      }
  83  
  84  	function get_contents($file, $type = '', $resumepos = 0) {
  85          if ( ! $this->exists($file) )
  86              return false;
  87  
  88          if ( empty($type) )
  89              $type = FTP_AUTOASCII;
  90          $this->ftp->SetType($type);
  91  
  92          $temp = wp_tempnam( $file );
  93  
  94          if ( ! $temphandle = fopen($temp, 'w+') )
  95              return false;
  96  
  97          if ( ! $this->ftp->fget($temphandle, $file) ) {
  98              fclose($temphandle);
  99              unlink($temp);
 100              return ''; //Blank document, File does exist, Its just blank.
 101          }
 102  
 103          fseek($temphandle, 0); //Skip back to the start of the file being written to
 104          $contents = '';
 105  
 106          while ( ! feof($temphandle) )
 107              $contents .= fread($temphandle, 8192);
 108  
 109          fclose($temphandle);
 110          unlink($temp);
 111          return $contents;
 112      }
 113  
 114  	function get_contents_array($file) {
 115          return explode("\n", $this->get_contents($file) );
 116      }
 117  
 118  	function put_contents($file, $contents, $type = '' ) {
 119          if ( empty($type) )
 120              $type = $this->is_binary($contents) ? FTP_BINARY : FTP_ASCII;
 121  
 122          $this->ftp->SetType($type);
 123  
 124          $temp = wp_tempnam( $file );
 125          if ( ! $temphandle = fopen($temp, 'w+') ) {
 126              unlink($temp);
 127              return false;
 128          }
 129  
 130          fwrite($temphandle, $contents);
 131          fseek($temphandle, 0); //Skip back to the start of the file being written to
 132  
 133          $ret = $this->ftp->fput($file, $temphandle);
 134  
 135          fclose($temphandle);
 136          unlink($temp);
 137          return $ret;
 138      }
 139  
 140  	function cwd() {
 141          $cwd = $this->ftp->pwd();
 142          if ( $cwd )
 143              $cwd = trailingslashit($cwd);
 144          return $cwd;
 145      }
 146  
 147  	function chdir($file) {
 148          return $this->ftp->chdir($file);
 149      }
 150  
 151  	function chgrp($file, $group, $recursive = false ) {
 152          return false;
 153      }
 154  
 155  	function chmod($file, $mode = false, $recursive = false ) {
 156  
 157          if ( ! $mode ) {
 158              if ( $this->is_file($file) )
 159                  $mode = FS_CHMOD_FILE;
 160              elseif ( $this->is_dir($file) )
 161                  $mode = FS_CHMOD_DIR;
 162              else
 163                  return false;
 164          }
 165  
 166          if ( ! $recursive || ! $this->is_dir($file) ) {
 167              return $this->ftp->chmod($file, $mode);
 168          }
 169  
 170          //Is a directory, and we want recursive
 171          $filelist = $this->dirlist($file);
 172          foreach ( $filelist as $filename )
 173              $this->chmod($file . '/' . $filename, $mode, $recursive);
 174  
 175          return true;
 176      }
 177  
 178  	function chown($file, $owner, $recursive = false ) {
 179          return false;
 180      }
 181  
 182  	function owner($file) {
 183          $dir = $this->dirlist($file);
 184          return $dir[$file]['owner'];
 185      }
 186  
 187  	function getchmod($file) {
 188          $dir = $this->dirlist($file);
 189          return $dir[$file]['permsn'];
 190      }
 191  
 192  	function group($file) {
 193          $dir = $this->dirlist($file);
 194          return $dir[$file]['group'];
 195      }
 196  
 197  	function copy($source, $destination, $overwrite = false ) {
 198          if ( ! $overwrite && $this->exists($destination) )
 199              return false;
 200  
 201          $content = $this->get_contents($source);
 202          if ( false === $content )
 203              return false;
 204  
 205          return $this->put_contents($destination, $content);
 206      }
 207  
 208  	function move($source, $destination, $overwrite = false ) {
 209          return $this->ftp->rename($source, $destination);
 210      }
 211  
 212  	function delete($file, $recursive = false ) {
 213          if ( empty($file) )
 214              return false;
 215          if ( $this->is_file($file) )
 216              return $this->ftp->delete($file);
 217          if ( !$recursive )
 218              return $this->ftp->rmdir($file);
 219  
 220          return $this->ftp->mdel($file);
 221      }
 222  
 223  	function exists($file) {
 224          return $this->ftp->is_exists($file);
 225      }
 226  
 227  	function is_file($file) {
 228          return $this->is_dir($file) ? false : true;
 229      }
 230  
 231  	function is_dir($path) {
 232          $cwd = $this->cwd();
 233          if ( $this->chdir($path) ) {
 234              $this->chdir($cwd);
 235              return true;
 236          }
 237          return false;
 238      }
 239  
 240  	function is_readable($file) {
 241          //Get dir list, Check if the file is writable by the current user??
 242          return true;
 243      }
 244  
 245  	function is_writable($file) {
 246          //Get dir list, Check if the file is writable by the current user??
 247          return true;
 248      }
 249  
 250  	function atime($file) {
 251          return false;
 252      }
 253  
 254  	function mtime($file) {
 255          return $this->ftp->mdtm($file);
 256      }
 257  
 258  	function size($file) {
 259          return $this->ftp->filesize($file);
 260      }
 261  
 262  	function touch($file, $time = 0, $atime = 0 ) {
 263          return false;
 264      }
 265  
 266  	function mkdir($path, $chmod = false, $chown = false, $chgrp = false ) {
 267          if ( ! $this->ftp->mkdir($path) )
 268              return false;
 269          if ( ! $chmod )
 270              $chmod = FS_CHMOD_DIR;
 271          $this->chmod($path, $chmod);
 272          if ( $chown )
 273              $this->chown($path, $chown);
 274          if ( $chgrp )
 275              $this->chgrp($path, $chgrp);
 276          return true;
 277      }
 278  
 279  	function rmdir($path, $recursive = false ) {
 280          if ( ! $recursive )
 281              return $this->ftp->rmdir($path);
 282  
 283          return $this->ftp->mdel($path);
 284      }
 285  
 286  	function dirlist($path = '.', $include_hidden = true, $recursive = false ) {
 287          if ( $this->is_file($path) ) {
 288              $limit_file = basename($path);
 289              $path = dirname($path) . '/';
 290          } else {
 291              $limit_file = false;
 292          }
 293  
 294          $list = $this->ftp->dirlist($path);
 295          if ( ! $list )
 296              return false;
 297  
 298          $ret = array();
 299          foreach ( $list as $struc ) {
 300  
 301              if ( '.' == $struc['name'] || '..' == $struc['name'] )
 302                  continue;
 303  
 304              if ( ! $include_hidden && '.' == $struc['name'][0] )
 305                  continue;
 306  
 307              if ( $limit_file && $struc['name'] != $limit_file )
 308                  continue;
 309  
 310              if ( 'd' == $struc['type'] ) {
 311                  if ( $recursive )
 312                      $struc['files'] = $this->dirlist($path . '/' . $struc['name'], $include_hidden, $recursive);
 313                  else
 314                      $struc['files'] = array();
 315              }
 316  
 317              $ret[ $struc['name'] ] = $struc;
 318          }
 319          return $ret;
 320      }
 321  
 322  	function __destruct() {
 323          $this->ftp->quit();
 324      }
 325  }
 326  
 327  ?>