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