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 4.3.2 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008, 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_helper.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 = preg_replace("|^(.+?)/*$|", "\\1", $path);
 125
 126                 if ( ! $current_dir = @opendir($path))
 127                         return;
 128
 129                 while(FALSE !== ($filename = @readdir($current_dir)))
 130                 {
 131                         if ($filename != "." and $filename != "..")
 132                         {
 133                                 if (is_dir($path.'/'.$filename))
 134                                 {
 135                                         // Ignore empty folders
 136                                         if (substr($filename, 0, 1) != '.')
 137                                         {
 138                                                 delete_files($path.'/'.$filename, $del_dir, $level + 1);
 139                                         }
 140                                 }
 141                                 else
 142                                 {
 143                                         unlink($path.'/'.$filename);
 144                                 }
 145                         }
 146                 }
 147                 @closedir($current_dir);
 148
 149                 if ($del_dir == TRUE AND $level > 0)
 150                 {
 151                         @rmdir($path);
 152                 }
 153         }
 154 }
 155
 156 // ------------------------------------------------------------------------
 157
 158 /**
 159  * Get Filenames
 160  *
 161  * Reads the specified directory and builds an array containing the filenames.
 162  * Any sub-folders contained within the specified path are read as well.
 163  *
 164  * @access      public
 165  * @param       string  path to source
 166  * @param       bool    whether to include the path as part of the filename
 167  * @param       bool    internal variable to determine recursion status - do not use in calls
 168  * @return      array
 169  */
 170 if ( ! function_exists('get_filenames'))
 171 {
 172         function get_filenames($source_dir, $include_path = FALSE, $_recursion = FALSE)
 173         {
 174                 static $_filedata = array();
 175
 176                 if ($fp = @opendir($source_dir))
 177                 {
 178                         // reset the array and make sure $source_dir has a trailing slash on the initial call
 179                         if ($_recursion === FALSE)
 180                         {
 181                                 $_filedata = array();
 182                                 $source_dir = rtrim(realpath($source_dir), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
 183                         }
 184
 185                         while (FALSE !== ($file = readdir($fp)))
 186                         {
 187                                 if (@is_dir($source_dir.$file) && strncmp($file, '.', 1) !== 0)
 188                                 {
 189                                          get_filenames($source_dir.$file.DIRECTORY_SEPARATOR, $include_path, TRUE);
 190                                 }
 191                                 elseif (strncmp($file, '.', 1) !== 0)
 192                                 {
 193
 194                                         $_filedata[] = ($include_path == TRUE) ? $source_dir.$file : $file;
 195                                 }
 196                         }
 197                         return $_filedata;
 198                 }
 199                 else
 200                 {
 201                         return FALSE;
 202                 }
 203         }
 204 }
 205
 206 // --------------------------------------------------------------------
 207
 208 /**
 209  * Get Directory File Information
 210  *
 211  * Reads the specified directory and builds an array containing the filenames,
 212  * filesize, dates, and permissions
 213  *
 214  * Any sub-folders contained within the specified path are read as well.
 215  *
 216  * @access      public
 217  * @param       string  path to source
 218  * @param       bool    whether to include the path as part of the filename
 219  * @param       bool    internal variable to determine recursion status - do not use in calls
 220  * @return      array
 221  */
 222 if ( ! function_exists('get_dir_file_info'))
 223 {
 224         function get_dir_file_info($source_dir, $include_path = FALSE, $_recursion = FALSE)
 225         {
 226                 $_filedata = array();
 227                 $relative_path = $source_dir;
 228
 229                 if ($fp = @opendir($source_dir))
 230                 {
 231                         // reset the array and make sure $source_dir has a trailing slash on the initial call
 232                         if ($_recursion === FALSE)
 233                         {
 234                                 $_filedata = array();
 235                                 $source_dir = rtrim(realpath($source_dir), DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
 236                         }
 237
 238                         while (FALSE !== ($file = readdir($fp)))
 239                         {
 240                                 if (@is_dir($source_dir.$file) && strncmp($file, '.', 1) !== 0)
 241                                 {
 242                                          get_dir_file_info($source_dir.$file.DIRECTORY_SEPARATOR, $include_path, TRUE);
 243                                 }
 244                                 elseif (strncmp($file, '.', 1) !== 0)
 245                                 {
 246                                         $_filedata[$file] = get_file_info($source_dir.$file);
 247                                         $_filedata[$file]['relative_path'] = $relative_path;
 248                                 }
 249                         }
 250                         return $_filedata;
 251                 }
 252                 else
 253                 {
 254                         return FALSE;
 255                 }
 256         }
 257 }
 258
 259 // --------------------------------------------------------------------
 260
 261 /**
 262 * Get File Info
 263 *
 264 * Given a file and path, returns the name, path, size, date modified
 265 * Second parameter allows you to explicitly declare what information you want returned
 266 * Options are: name, server_path, size, date, readable, writable, executable, fileperms
 267 * Returns FALSE if the file cannot be found.
 268 *
 269 * @access       public
 270 * @param        string          path to file
 271 * @param        mixed           array or comma separated string of information returned
 272 * @return       array
 273 */
 274 if ( ! function_exists('get_file_info'))
 275 {
 276         function get_file_info($file, $returned_values = array('name', 'server_path', 'size', 'date'))
 277         {
 278
 279                 if ( ! file_exists($file))
 280                 {
 281                         return FALSE;
 282                 }
 283
 284                 if (is_string($returned_values))
 285                 {
 286                         $returned_values = explode(',', $returned_values);
 287                 }
 288
 289                 foreach ($returned_values as $key)
 290                 {
 291                         switch ($key)
 292                         {
 293                                 case 'name':
 294                                         $fileinfo['name'] = substr(strrchr($file, '/'), 1);
 295                                         break;
 296                                 case 'server_path':
 297                                         $fileinfo['server_path'] = $file;
 298                                         break;
 299                                 case 'size':
 300                                         $fileinfo['size'] = filesize($file);
 301                                         break;
 302                                 case 'date':
 303                                         $fileinfo['date'] = filectime($file);
 304                                         break;
 305                                 case 'readable':
 306                                         $fileinfo['readable'] = is_readable($file);
 307                                         break;
 308                                 case 'writable':
 309                                         // There are known problems using is_weritable on IIS.  It may not be reliable - consider fileperms()
 310                                         $fileinfo['writable'] = is_writable($file);
 311                                         break;
 312                                 case 'executable':
 313                                         $fileinfo['executable'] = is_executable($file);
 314                                         break;
 315                                 case 'fileperms':
 316                                         $fileinfo['fileperms'] = fileperms($file);
 317                                         break;
 318                         }
 319                 }
 320
 321                 return $fileinfo;
 322         }
 323 }
 324
 325 // --------------------------------------------------------------------
 326
 327 /**
 328  * Get Mime by Extension
 329  *
 330  * Translates a file extension into a mime type based on config/mimes.php.
 331  * Returns FALSE if it can't determine the type, or open the mime config file
 332  *
 333  * Note: this is NOT an accurate way of determining file mime types, and is here strictly as a convenience
 334  * It should NOT be trusted, and should certainly NOT be used for security
 335  *
 336  * @access      public
 337  * @param       string  path to file
 338  * @return      mixed
 339  */
 340 if ( ! function_exists('get_mime_by_extension'))
 341 {
 342         function get_mime_by_extension($file)
 343         {
 344                 $extension = substr(strrchr($file, '.'), 1);
 345
 346                 global $mimes;
 347
 348                 if ( ! is_array($mimes))
 349                 {
 350                         if ( ! require_once(APPPATH.'config/mimes.php'))
 351                         {
 352                                 return FALSE;
 353                         }
 354                 }
 355
 356                 if (array_key_exists($extension, $mimes))
 357                 {
 358                         if (is_array($mimes[$extension]))
 359                         {
 360                                 // Multiple mime types, just give the first one
 361                                 return current($mimes[$extension]);
 362                         }
 363                         else
 364                         {
 365                                 return $mimes[$extension];
 366                         }
 367                 }
 368                 else
 369                 {
 370                         return FALSE;
 371                 }
 372         }
 373 }
 374
 375 // --------------------------------------------------------------------
 376
 377 /**
 378  * Symbolic Permissions
 379  *
 380  * Takes a numeric value representing a file's permissions and returns
 381  * standard symbolic notation representing that value
 382  *
 383  * @access      public
 384  * @param       int
 385  * @return      string
 386  */
 387 if ( ! function_exists('symbolic_permissions'))
 388 {
 389         function symbolic_permissions($perms)
 390         {
 391                 if (($perms & 0xC000) == 0xC000)
 392                 {
 393                         $symbolic = 's'; // Socket
 394                 }
 395                 elseif (($perms & 0xA000) == 0xA000)
 396                 {
 397                         $symbolic = 'l'; // Symbolic Link
 398                 }
 399                 elseif (($perms & 0x8000) == 0x8000)
 400                 {
 401                         $symbolic = '-'; // Regular
 402                 }
 403                 elseif (($perms & 0x6000) == 0x6000)
 404                 {
 405                         $symbolic = 'b'; // Block special
 406                 }
 407                 elseif (($perms & 0x4000) == 0x4000)
 408                 {
 409                         $symbolic = 'd'; // Directory
 410                 }
 411                 elseif (($perms & 0x2000) == 0x2000)
 412                 {
 413                         $symbolic = 'c'; // Character special
 414                 }
 415                 elseif (($perms & 0x1000) == 0x1000)
 416                 {
 417                         $symbolic = 'p'; // FIFO pipe
 418                 }
 419                 else
 420                 {
 421                         $symbolic = 'u'; // Unknown
 422                 }
 423
 424                 // Owner
 425                 $symbolic .= (($perms & 0x0100) ? 'r' : '-');
 426                 $symbolic .= (($perms & 0x0080) ? 'w' : '-');
 427                 $symbolic .= (($perms & 0x0040) ? (($perms & 0x0800) ? 's' : 'x' ) : (($perms & 0x0800) ? 'S' : '-'));
 428
 429                 // Group
 430                 $symbolic .= (($perms & 0x0020) ? 'r' : '-');
 431                 $symbolic .= (($perms & 0x0010) ? 'w' : '-');
 432                 $symbolic .= (($perms & 0x0008) ? (($perms & 0x0400) ? 's' : 'x' ) : (($perms & 0x0400) ? 'S' : '-'));
 433
 434                 // World
 435                 $symbolic .= (($perms & 0x0004) ? 'r' : '-');
 436                 $symbolic .= (($perms & 0x0002) ? 'w' : '-');
 437                 $symbolic .= (($perms & 0x0001) ? (($perms & 0x0200) ? 't' : 'x' ) : (($perms & 0x0200) ? 'T' : '-'));
 438
 439                 return $symbolic;
 440         }
 441 }
 442
 443 // --------------------------------------------------------------------
 444
 445 /**
 446  * Octal Permissions
 447  *
 448  * Takes a numeric value representing a file's permissions and returns
 449  * a three character string representing the file's octal permissions
 450  *
 451  * @access      public
 452  * @param       int
 453  * @return      string
 454  */
 455 if ( ! function_exists('octal_permissions'))
 456 {
 457         function octal_permissions($perms)
 458         {
 459                 return substr(sprintf('%o', $perms), -3);
 460         }
 461 }
 462
 463
 464 /* End of file file_helper.php */
 465 /* Location: ./system/helpers/file_helper.php */