user gets notified interatively or by email in case of a CIS error
[living-lab-site.git] / 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 */