system/helpers/file_helper.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 5.1.6 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.0
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * CodeIgniter File Helpers
  20  *
  21  * @package             CodeIgniter
  22  * @subpackage  Helpers
  23  * @category    Helpers
  24  * @author              ExpressionEngine Dev Team
  25  * @link                http://codeigniter.com/user_guide/helpers/file_helpers.html
  26  */
  27
  28 // ------------------------------------------------------------------------
  29
  30 /**
  31  * Read File
  32  *
  33  * Opens the file specfied in the path and returns it as a string.
  34  *
  35  * @access      public
  36  * @param       string  path to file
  37  * @return      string
  38  */
  39 if ( ! function_exists('read_file'))
  40 {
  41         function read_file($file)
  42         {
  43                 if ( ! file_exists($file))
  44                 {
  45                         return FALSE;
  46                 }
  47
  48                 if (function_exists('file_get_contents'))
  49                 {
  50                         return file_get_contents($file);
  51                 }
  52
  53                 if ( ! $fp = @fopen($file, FOPEN_READ))
  54                 {
  55                         return FALSE;
  56                 }
  57
  58                 flock($fp, LOCK_SH);
  59
  60                 $data = '';
  61                 if (filesize($file) > 0)
  62                 {
  63                         $data =& fread($fp, filesize($file));
  64                 }
  65
  66                 flock($fp, LOCK_UN);
  67                 fclose($fp);
  68
  69                 return $data;
  70         }
  71 }
  72
  73 // ------------------------------------------------------------------------
  74
  75 /**
  76  * Write File
  77  *
  78  * Writes data to the file specified in the path.
  79  * Creates a new file if non-existent.
  80  *
  81  * @access      public
  82  * @param       string  path to file
  83  * @param       string  file data
  84  * @return      bool
  85  */
  86 if ( ! function_exists('write_file'))
  87 {
  88         function write_file($path, $data, $mode = FOPEN_WRITE_CREATE_DESTRUCTIVE)
  89         {
  90                 if ( ! $fp = @fopen($path, $mode))
  91                 {
  92                         return FALSE;
  93                 }
  94
  95                 flock($fp, LOCK_EX);
  96                 fwrite($fp, $data);
  97                 flock($fp, LOCK_UN);
  98                 fclose($fp);
  99
 100                 return TRUE;
 101         }
 102 }
 103
 104 // ------------------------------------------------------------------------
 105
 106 /**
 107  * Delete Files
 108  *
 109  * Deletes all files contained in the supplied directory path.
 110  * Files must be writable or owned by the system in order to be deleted.
 111  * If the second parameter is set to TRUE, any directories contained
 112  * within the supplied base directory will be nuked as well.
 113  *
 114  * @access      public
 115  * @param       string  path to file
 116  * @param       bool    whether to delete any directories found in the path
 117  * @return      bool
 118  */
 119 if ( ! function_exists('delete_files'))
 120 {
 121         function delete_files($path, $del_dir = FALSE, $level = 0)
 122         {
 123                 // Trim the trailing slash
 124                 $path = rtrim($path, DIRECTORY_SEPARATOR);
 125
 126                 if ( ! $current_dir = @opendir($path))
 127                 {
 128                         return FALSE;
 129                 }
 130
 131                 while (FALSE !== ($filename = @readdir($current_dir)))
 132                 {
 133                         if ($filename != "." and $filename != "..")
 134                         {
 135                                 if (is_dir($path.DIRECTORY_SEPARATOR.$filename))
 136                                 {
 137                                         // Ignore empty folders
 138                                         if (substr($filename, 0, 1) != '.')
 139                                         {
 140                                                 delete_files($path.DIRECTORY_SEPARATOR.$filename, $del_dir, $level + 1);
 141                                         }
 142                                 }
 143                                 else
 144                                 {
 145                                         unlink($path.DIRECTORY_SEPARATOR.$filename);
 146                                 }
 147                         }
 148                 }
 149                 @closedir($current_dir);
 150
 151                 if ($del_dir == TRUE AND $level > 0)
 152                 {
 153                         return @rmdir($path);
 154                 }
 155
 156                 return TRUE;
 157         }
 158 }
 159
 160 // ------------------------------------------------------------------------
 161
 162 /**
 163  * Get Filenames
 164  *
 165  * Reads the specified directory and builds an array containing the filenames.
 166  * Any sub-folders contained within the specified path are read as well.
 167  *
 168  * @access      public
 169  * @param       string  path to source
 170  * @param       bool    whether to include the path as part of the filename
 171  * @param       bool    internal variable to determine recursion status - do not use in calls
 172  * @return      array
 173  */
 174 if ( ! function_exists('get_filenames'))
 175 {
 176         function get_filenames($source_dir, $include_path = FALSE, $_recursion = FALSE)
 177         {
 178                 static $_filedata = array();
 179
 180                 if ($fp = @opendir($source_dir))
 181                 {
 182                         // reset the array and make sure $source_dir has a trailing slash on the initial call
 183                         if ($_recursion === FALSE)
 184                         {
 185                                 $_filedata = array();
 186                                 $source_dir = rtrim(realpath($source_dir), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
 187                         }
 188
 189                         while (FALSE !== ($file = readdir($fp)))
 190                         {
 191                                 if (@is_dir($source_dir.$file) && strncmp($file, '.', 1) !== 0)
 192                                 {
 193                                         get_filenames($source_dir.$file.DIRECTORY_SEPARATOR, $include_path, TRUE);
 194                                 }
 195                                 elseif (strncmp($file, '.', 1) !== 0)
 196                                 {
 197                                         $_filedata[] = ($include_path == TRUE) ? $source_dir.$file : $file;
 198                                 }
 199                         }
 200                         return $_filedata;
 201                 }
 202                 else
 203                 {
 204                         return FALSE;
 205                 }
 206         }
 207 }
 208
 209 // --------------------------------------------------------------------
 210
 211 /**
 212  * Get Directory File Information
 213  *
 214  * Reads the specified directory and builds an array containing the filenames,
 215  * filesize, dates, and permissions
 216  *
 217  * Any sub-folders contained within the specified path are read as well.
 218  *
 219  * @access      public
 220  * @param       string  path to source
 221  * @param       bool    Look only at the top level directory specified?
 222  * @param       bool    internal variable to determine recursion status - do not use in calls
 223  * @return      array
 224  */
 225 if ( ! function_exists('get_dir_file_info'))
 226 {
 227         function get_dir_file_info($source_dir, $top_level_only = TRUE, $_recursion = FALSE)
 228         {
 229                 static $_filedata = array();
 230                 $relative_path = $source_dir;
 231
 232                 if ($fp = @opendir($source_dir))
 233                 {
 234                         // reset the array and make sure $source_dir has a trailing slash on the initial call
 235                         if ($_recursion === FALSE)
 236                         {
 237                                 $_filedata = array();
 238                                 $source_dir = rtrim(realpath($source_dir), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
 239                         }
 240
 241                         // foreach (scandir($source_dir, 1) as $file) // In addition to being PHP5+, scandir() is simply not as fast
 242                         while (FALSE !== ($file = readdir($fp)))
 243                         {
 244                                 if (@is_dir($source_dir.$file) AND strncmp($file, '.', 1) !== 0 AND $top_level_only === FALSE)
 245                                 {
 246                                         get_dir_file_info($source_dir.$file.DIRECTORY_SEPARATOR, $top_level_only, TRUE);
 247                                 }
 248                                 elseif (strncmp($file, '.', 1) !== 0)
 249                                 {
 250                                         $_filedata[$file] = get_file_info($source_dir.$file);
 251                                         $_filedata[$file]['relative_path'] = $relative_path;
 252                                 }
 253                         }
 254
 255                         return $_filedata;
 256                 }
 257                 else
 258                 {
 259                         return FALSE;
 260                 }
 261         }
 262 }
 263
 264 // --------------------------------------------------------------------
 265
 266 /**
 267 * Get File Info
 268 *
 269 * Given a file and path, returns the name, path, size, date modified
 270 * Second parameter allows you to explicitly declare what information you want returned
 271 * Options are: name, server_path, size, date, readable, writable, executable, fileperms
 272 * Returns FALSE if the file cannot be found.
 273 *
 274 * @access       public
 275 * @param        string  path to file
 276 * @param        mixed   array or comma separated string of information returned
 277 * @return       array
 278 */
 279 if ( ! function_exists('get_file_info'))
 280 {
 281         function get_file_info($file, $returned_values = array('name', 'server_path', 'size', 'date'))
 282         {
 283
 284                 if ( ! file_exists($file))
 285                 {
 286                         return FALSE;
 287                 }
 288
 289                 if (is_string($returned_values))
 290                 {
 291                         $returned_values = explode(',', $returned_values);
 292                 }
 293
 294                 foreach ($returned_values as $key)
 295                 {
 296                         switch ($key)
 297                         {
 298                                 case 'name':
 299                                         $fileinfo['name'] = substr(strrchr($file, DIRECTORY_SEPARATOR), 1);
 300                                         break;
 301                                 case 'server_path':
 302                                         $fileinfo['server_path'] = $file;
 303                                         break;
 304                                 case 'size':
 305                                         $fileinfo['size'] = filesize($file);
 306                                         break;
 307                                 case 'date':
 308                                         $fileinfo['date'] = filemtime($file);
 309                                         break;
 310                                 case 'readable':
 311                                         $fileinfo['readable'] = is_readable($file);
 312                                         break;
 313                                 case 'writable':
 314                                         // There are known problems using is_weritable on IIS.  It may not be reliable - consider fileperms()
 315                                         $fileinfo['writable'] = is_writable($file);
 316                                         break;
 317                                 case 'executable':
 318                                         $fileinfo['executable'] = is_executable($file);
 319                                         break;
 320                                 case 'fileperms':
 321                                         $fileinfo['fileperms'] = fileperms($file);
 322                                         break;
 323                         }
 324                 }
 325
 326                 return $fileinfo;
 327         }
 328 }
 329
 330 // --------------------------------------------------------------------
 331
 332 /**
 333  * Get Mime by Extension
 334  *
 335  * Translates a file extension into a mime type based on config/mimes.php.
 336  * Returns FALSE if it can't determine the type, or open the mime config file
 337  *
 338  * Note: this is NOT an accurate way of determining file mime types, and is here strictly as a convenience
 339  * It should NOT be trusted, and should certainly NOT be used for security
 340  *
 341  * @access      public
 342  * @param       string  path to file
 343  * @return      mixed
 344  */
 345 if ( ! function_exists('get_mime_by_extension'))
 346 {
 347         function get_mime_by_extension($file)
 348         {
 349                 $extension = strtolower(substr(strrchr($file, '.'), 1));
 350
 351                 global $mimes;
 352
 353                 if ( ! is_array($mimes))
 354                 {
 355                         if (defined('ENVIRONMENT') AND is_file(APPPATH.'config/'.ENVIRONMENT.'/mimes'.EXT))
 356                         {
 357                                 include(APPPATH.'config/'.ENVIRONMENT.'/mimes'.EXT);
 358                         }
 359                         elseif (is_file(APPPATH.'config/mimes'.EXT))
 360                         {
 361                                 include(APPPATH.'config/mimes'.EXT);
 362                         }
 363
 364                         if ( ! is_array($mimes))
 365                         {
 366                                 return FALSE;
 367                         }
 368                 }
 369
 370                 if (array_key_exists($extension, $mimes))
 371                 {
 372                         if (is_array($mimes[$extension]))
 373                         {
 374                                 // Multiple mime types, just give the first one
 375                                 return current($mimes[$extension]);
 376                         }
 377                         else
 378                         {
 379                                 return $mimes[$extension];
 380                         }
 381                 }
 382                 else
 383                 {
 384                         return FALSE;
 385                 }
 386         }
 387 }
 388
 389 // --------------------------------------------------------------------
 390
 391 /**
 392  * Symbolic Permissions
 393  *
 394  * Takes a numeric value representing a file's permissions and returns
 395  * standard symbolic notation representing that value
 396  *
 397  * @access      public
 398  * @param       int
 399  * @return      string
 400  */
 401 if ( ! function_exists('symbolic_permissions'))
 402 {
 403         function symbolic_permissions($perms)
 404         {
 405                 if (($perms & 0xC000) == 0xC000)
 406                 {
 407                         $symbolic = 's'; // Socket
 408                 }
 409                 elseif (($perms & 0xA000) == 0xA000)
 410                 {
 411                         $symbolic = 'l'; // Symbolic Link
 412                 }
 413                 elseif (($perms & 0x8000) == 0x8000)
 414                 {
 415                         $symbolic = '-'; // Regular
 416                 }
 417                 elseif (($perms & 0x6000) == 0x6000)
 418                 {
 419                         $symbolic = 'b'; // Block special
 420                 }
 421                 elseif (($perms & 0x4000) == 0x4000)
 422                 {
 423                         $symbolic = 'd'; // Directory
 424                 }
 425                 elseif (($perms & 0x2000) == 0x2000)
 426                 {
 427                         $symbolic = 'c'; // Character special
 428                 }
 429                 elseif (($perms & 0x1000) == 0x1000)
 430                 {
 431                         $symbolic = 'p'; // FIFO pipe
 432                 }
 433                 else
 434                 {
 435                         $symbolic = 'u'; // Unknown
 436                 }
 437
 438                 // Owner
 439                 $symbolic .= (($perms & 0x0100) ? 'r' : '-');
 440                 $symbolic .= (($perms & 0x0080) ? 'w' : '-');
 441                 $symbolic .= (($perms & 0x0040) ? (($perms & 0x0800) ? 's' : 'x' ) : (($perms & 0x0800) ? 'S' : '-'));
 442
 443                 // Group
 444                 $symbolic .= (($perms & 0x0020) ? 'r' : '-');
 445                 $symbolic .= (($perms & 0x0010) ? 'w' : '-');
 446                 $symbolic .= (($perms & 0x0008) ? (($perms & 0x0400) ? 's' : 'x' ) : (($perms & 0x0400) ? 'S' : '-'));
 447
 448                 // World
 449                 $symbolic .= (($perms & 0x0004) ? 'r' : '-');
 450                 $symbolic .= (($perms & 0x0002) ? 'w' : '-');
 451                 $symbolic .= (($perms & 0x0001) ? (($perms & 0x0200) ? 't' : 'x' ) : (($perms & 0x0200) ? 'T' : '-'));
 452
 453                 return $symbolic;
 454         }
 455 }
 456
 457 // --------------------------------------------------------------------
 458
 459 /**
 460  * Octal Permissions
 461  *
 462  * Takes a numeric value representing a file's permissions and returns
 463  * a three character string representing the file's octal permissions
 464  *
 465  * @access      public
 466  * @param       int
 467  * @return      string
 468  */
 469 if ( ! function_exists('octal_permissions'))
 470 {
 471         function octal_permissions($perms)
 472         {
 473                 return substr(sprintf('%o', $perms), -3);
 474         }
 475 }
 476
 477
 478 /* End of file file_helper.php */
 479 /* Location: ./system/helpers/file_helper.php */