wp-admin/includes/class-wp-filesystem-direct.php

   1 <?php
   2 /**
   3  * WordPress Direct Filesystem.
   4  *
   5  * @package WordPress
   6  * @subpackage Filesystem
   7  */
   8
   9 /**
  10  * WordPress Filesystem Class for direct PHP file and folder manipulation.
  11  *
  12  * @since 2.5.0
  13  * @package WordPress
  14  * @subpackage Filesystem
  15  * @uses WP_Filesystem_Base Extends class
  16  */
  17 class WP_Filesystem_Direct extends WP_Filesystem_Base {
  18
  19         /**
  20          * constructor
  21          *
  22          * @access public
  23          *
  24          * @param mixed $arg ignored argument
  25          */
  26         public function __construct($arg) {
  27                 $this->method = 'direct';
  28                 $this->errors = new WP_Error();
  29         }
  30
  31         /**
  32          * Reads entire file into a string
  33          *
  34          * @access public
  35          *
  36          * @param string $file Name of the file to read.
  37          * @return string|bool The function returns the read data or false on failure.
  38          */
  39         public function get_contents($file) {
  40                 return @file_get_contents($file);
  41         }
  42
  43         /**
  44          * Reads entire file into an array
  45          *
  46          * @access public
  47          *
  48          * @param string $file Path to the file.
  49          * @return array|bool the file contents in an array or false on failure.
  50          */
  51         public function get_contents_array($file) {
  52                 return @file($file);
  53         }
  54
  55         /**
  56          * Write a string to a file
  57          *
  58          * @access public
  59          *
  60          * @param string $file     Remote path to the file where to write the data.
  61          * @param string $contents The data to write.
  62          * @param int    $mode     Optional. The file permissions as octal number, usually 0644.
  63          *                         Default false.
  64          * @return bool False upon failure, true otherwise.
  65          */
  66         public function put_contents( $file, $contents, $mode = false ) {
  67                 $fp = @fopen( $file, 'wb' );
  68                 if ( ! $fp )
  69                         return false;
  70
  71                 mbstring_binary_safe_encoding();
  72
  73                 $data_length = strlen( $contents );
  74
  75                 $bytes_written = fwrite( $fp, $contents );
  76
  77                 reset_mbstring_encoding();
  78
  79                 fclose( $fp );
  80
  81                 if ( $data_length !== $bytes_written )
  82                         return false;
  83
  84                 $this->chmod( $file, $mode );
  85
  86                 return true;
  87         }
  88
  89         /**
  90          * Gets the current working directory
  91          *
  92          * @access public
  93          *
  94          * @return string|bool the current working directory on success, or false on failure.
  95          */
  96         public function cwd() {
  97                 return @getcwd();
  98         }
  99
 100         /**
 101          * Change directory
 102          *
 103          * @access public
 104          *
 105          * @param string $dir The new current directory.
 106          * @return bool Returns true on success or false on failure.
 107          */
 108         public function chdir($dir) {
 109                 return @chdir($dir);
 110         }
 111
 112         /**
 113          * Changes file group
 114          *
 115          * @access public
 116          *
 117          * @param string $file      Path to the file.
 118          * @param mixed  $group     A group name or number.
 119          * @param bool   $recursive Optional. If set True changes file group recursively. Default false.
 120          * @return bool Returns true on success or false on failure.
 121          */
 122         public function chgrp($file, $group, $recursive = false) {
 123                 if ( ! $this->exists($file) )
 124                         return false;
 125                 if ( ! $recursive )
 126                         return @chgrp($file, $group);
 127                 if ( ! $this->is_dir($file) )
 128                         return @chgrp($file, $group);
 129                 // Is a directory, and we want recursive
 130                 $file = trailingslashit($file);
 131                 $filelist = $this->dirlist($file);
 132                 foreach ($filelist as $filename)
 133                         $this->chgrp($file . $filename, $group, $recursive);
 134
 135                 return true;
 136         }
 137
 138         /**
 139          * Changes filesystem permissions
 140          *
 141          * @access public
 142          *
 143          * @param string $file      Path to the file.
 144          * @param int    $mode      Optional. The permissions as octal number, usually 0644 for files,
 145          *                          0755 for dirs. Default false.
 146          * @param bool   $recursive Optional. If set True changes file group recursively. Default false.
 147          * @return bool Returns true on success or false on failure.
 148          */
 149         public function chmod($file, $mode = false, $recursive = false) {
 150                 if ( ! $mode ) {
 151                         if ( $this->is_file($file) )
 152                                 $mode = FS_CHMOD_FILE;
 153                         elseif ( $this->is_dir($file) )
 154                                 $mode = FS_CHMOD_DIR;
 155                         else
 156                                 return false;
 157                 }
 158
 159                 if ( ! $recursive || ! $this->is_dir($file) )
 160                         return @chmod($file, $mode);
 161                 // Is a directory, and we want recursive
 162                 $file = trailingslashit($file);
 163                 $filelist = $this->dirlist($file);
 164                 foreach ( (array)$filelist as $filename => $filemeta)
 165                         $this->chmod($file . $filename, $mode, $recursive);
 166
 167                 return true;
 168         }
 169
 170         /**
 171          * Changes file owner
 172          *
 173          * @access public
 174          *
 175          * @param string $file      Path to the file.
 176          * @param mixed  $owner     A user name or number.
 177          * @param bool   $recursive Optional. If set True changes file owner recursively.
 178          *                          Default false.
 179          * @return bool Returns true on success or false on failure.
 180          */
 181         public function chown($file, $owner, $recursive = false) {
 182                 if ( ! $this->exists($file) )
 183                         return false;
 184                 if ( ! $recursive )
 185                         return @chown($file, $owner);
 186                 if ( ! $this->is_dir($file) )
 187                         return @chown($file, $owner);
 188                 // Is a directory, and we want recursive
 189                 $filelist = $this->dirlist($file);
 190                 foreach ($filelist as $filename) {
 191                         $this->chown($file . '/' . $filename, $owner, $recursive);
 192                 }
 193                 return true;
 194         }
 195
 196         /**
 197          * Gets file owner
 198          *
 199          * @access public
 200          *
 201          * @param string $file Path to the file.
 202          * @return string|bool Username of the user or false on error.
 203          */
 204         public function owner($file) {
 205                 $owneruid = @fileowner($file);
 206                 if ( ! $owneruid )
 207                         return false;
 208                 if ( ! function_exists('posix_getpwuid') )
 209                         return $owneruid;
 210                 $ownerarray = posix_getpwuid($owneruid);
 211                 return $ownerarray['name'];
 212         }
 213
 214         /**
 215          * Gets file permissions
 216          *
 217          * FIXME does not handle errors in fileperms()
 218          *
 219          * @access public
 220          *
 221          * @param string $file Path to the file.
 222          * @return string Mode of the file (last 3 digits).
 223          */
 224         public function getchmod($file) {
 225                 return substr( decoct( @fileperms( $file ) ), -3 );
 226         }
 227
 228         /**
 229          * @access public
 230          *
 231          * @param string $file
 232          * @return string|false
 233          */
 234         public function group($file) {
 235                 $gid = @filegroup($file);
 236                 if ( ! $gid )
 237                         return false;
 238                 if ( ! function_exists('posix_getgrgid') )
 239                         return $gid;
 240                 $grouparray = posix_getgrgid($gid);
 241                 return $grouparray['name'];
 242         }
 243
 244         /**
 245          * @access public
 246          *
 247          * @param string $source
 248          * @param string $destination
 249          * @param bool   $overwrite
 250          * @param int    $mode
 251          * @return bool
 252          */
 253         public function copy($source, $destination, $overwrite = false, $mode = false) {
 254                 if ( ! $overwrite && $this->exists($destination) )
 255                         return false;
 256
 257                 $rtval = copy($source, $destination);
 258                 if ( $mode )
 259                         $this->chmod($destination, $mode);
 260                 return $rtval;
 261         }
 262
 263         /**
 264          * @access public
 265          *
 266          * @param string $source
 267          * @param string $destination
 268          * @param bool $overwrite
 269          * @return bool
 270          */
 271         public function move($source, $destination, $overwrite = false) {
 272                 if ( ! $overwrite && $this->exists($destination) )
 273                         return false;
 274
 275                 // Try using rename first. if that fails (for example, source is read only) try copy.
 276                 if ( @rename($source, $destination) )
 277                         return true;
 278
 279                 if ( $this->copy($source, $destination, $overwrite) && $this->exists($destination) ) {
 280                         $this->delete($source);
 281                         return true;
 282                 } else {
 283                         return false;
 284                 }
 285         }
 286
 287         /**
 288          * @access public
 289          *
 290          * @param string $file
 291          * @param bool $recursive
 292          * @param string $type
 293          * @return bool
 294          */
 295         public function delete($file, $recursive = false, $type = false) {
 296                 if ( empty( $file ) ) // Some filesystems report this as /, which can cause non-expected recursive deletion of all files in the filesystem.
 297                         return false;
 298                 $file = str_replace( '\\', '/', $file ); // for win32, occasional problems deleting files otherwise
 299
 300                 if ( 'f' == $type || $this->is_file($file) )
 301                         return @unlink($file);
 302                 if ( ! $recursive && $this->is_dir($file) )
 303                         return @rmdir($file);
 304
 305                 // At this point it's a folder, and we're in recursive mode
 306                 $file = trailingslashit($file);
 307                 $filelist = $this->dirlist($file, true);
 308
 309                 $retval = true;
 310                 if ( is_array( $filelist ) ) {
 311                         foreach ( $filelist as $filename => $fileinfo ) {
 312                                 if ( ! $this->delete($file . $filename, $recursive, $fileinfo['type']) )
 313                                         $retval = false;
 314                         }
 315                 }
 316
 317                 if ( file_exists($file) && ! @rmdir($file) )
 318                         $retval = false;
 319
 320                 return $retval;
 321         }
 322         /**
 323          * @access public
 324          *
 325          * @param string $file
 326          * @return bool
 327          */
 328         public function exists($file) {
 329                 return @file_exists($file);
 330         }
 331         /**
 332          * @access public
 333          *
 334          * @param string $file
 335          * @return bool
 336          */
 337         public function is_file($file) {
 338                 return @is_file($file);
 339         }
 340         /**
 341          * @access public
 342          *
 343          * @param string $path
 344          * @return bool
 345          */
 346         public function is_dir($path) {
 347                 return @is_dir($path);
 348         }
 349
 350         /**
 351          * @access public
 352          *
 353          * @param string $file
 354          * @return bool
 355          */
 356         public function is_readable($file) {
 357                 return @is_readable($file);
 358         }
 359
 360         /**
 361          * @access public
 362          *
 363          * @param string $file
 364          * @return bool
 365          */
 366         public function is_writable($file) {
 367                 return @is_writable($file);
 368         }
 369
 370         /**
 371          * @access public
 372          *
 373          * @param string $file
 374          * @return int
 375          */
 376         public function atime($file) {
 377                 return @fileatime($file);
 378         }
 379
 380         /**
 381          * @access public
 382          *
 383          * @param string $file
 384          * @return int
 385          */
 386         public function mtime($file) {
 387                 return @filemtime($file);
 388         }
 389
 390         /**
 391          * @access public
 392          *
 393          * @param string $file
 394          * @return int
 395          */
 396         public function size($file) {
 397                 return @filesize($file);
 398         }
 399
 400         /**
 401          * @access public
 402          *
 403          * @param string $file
 404          * @param int $time
 405          * @param int $atime
 406          * @return bool
 407          */
 408         public function touch($file, $time = 0, $atime = 0) {
 409                 if ($time == 0)
 410                         $time = time();
 411                 if ($atime == 0)
 412                         $atime = time();
 413                 return @touch($file, $time, $atime);
 414         }
 415
 416         /**
 417          * @access public
 418          *
 419          * @param string $path
 420          * @param mixed  $chmod
 421          * @param mixed  $chown
 422          * @param mixed  $chgrp
 423          * @return bool
 424          */
 425         public function mkdir($path, $chmod = false, $chown = false, $chgrp = false) {
 426                 // Safe mode fails with a trailing slash under certain PHP versions.
 427                 $path = untrailingslashit($path);
 428                 if ( empty($path) )
 429                         return false;
 430
 431                 if ( ! $chmod )
 432                         $chmod = FS_CHMOD_DIR;
 433
 434                 if ( ! @mkdir($path) )
 435                         return false;
 436                 $this->chmod($path, $chmod);
 437                 if ( $chown )
 438                         $this->chown($path, $chown);
 439                 if ( $chgrp )
 440                         $this->chgrp($path, $chgrp);
 441                 return true;
 442         }
 443
 444         /**
 445          * @access public
 446          *
 447          * @param string $path
 448          * @param bool $recursive
 449          * @return bool
 450          */
 451         public function rmdir($path, $recursive = false) {
 452                 return $this->delete($path, $recursive);
 453         }
 454
 455         /**
 456          * @access public
 457          *
 458          * @param string $path
 459          * @param bool $include_hidden
 460          * @param bool $recursive
 461          * @return bool|array
 462          */
 463         public function dirlist($path, $include_hidden = true, $recursive = false) {
 464                 if ( $this->is_file($path) ) {
 465                         $limit_file = basename($path);
 466                         $path = dirname($path);
 467                 } else {
 468                         $limit_file = false;
 469                 }
 470
 471                 if ( ! $this->is_dir($path) )
 472                         return false;
 473
 474                 $dir = @dir($path);
 475                 if ( ! $dir )
 476                         return false;
 477
 478                 $ret = array();
 479
 480                 while (false !== ($entry = $dir->read()) ) {
 481                         $struc = array();
 482                         $struc['name'] = $entry;
 483
 484                         if ( '.' == $struc['name'] || '..' == $struc['name'] )
 485                                 continue;
 486
 487                         if ( ! $include_hidden && '.' == $struc['name'][0] )
 488                                 continue;
 489
 490                         if ( $limit_file && $struc['name'] != $limit_file)
 491                                 continue;
 492
 493                         $struc['perms']         = $this->gethchmod($path.'/'.$entry);
 494                         $struc['permsn']        = $this->getnumchmodfromh($struc['perms']);
 495                         $struc['number']        = false;
 496                         $struc['owner']         = $this->owner($path.'/'.$entry);
 497                         $struc['group']         = $this->group($path.'/'.$entry);
 498                         $struc['size']          = $this->size($path.'/'.$entry);
 499                         $struc['lastmodunix']= $this->mtime($path.'/'.$entry);
 500                         $struc['lastmod']   = date('M j',$struc['lastmodunix']);
 501                         $struc['time']          = date('h:i:s',$struc['lastmodunix']);
 502                         $struc['type']          = $this->is_dir($path.'/'.$entry) ? 'd' : 'f';
 503
 504                         if ( 'd' == $struc['type'] ) {
 505                                 if ( $recursive )
 506                                         $struc['files'] = $this->dirlist($path . '/' . $struc['name'], $include_hidden, $recursive);
 507                                 else
 508                                         $struc['files'] = array();
 509                         }
 510
 511                         $ret[ $struc['name'] ] = $struc;
 512                 }
 513                 $dir->close();
 514                 unset($dir);
 515                 return $ret;
 516         }
 517 }