/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/system/helpers/file_helper.php

  • Committer: galaxyAbstractor
  • Date: 2013-04-10 15:49:32 UTC
  • mto: (19.1.5 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410154932-4vizlzk0ar5gykvi
* Added an simple admin panel to the codeviewer-cmssy stuff
* Redesigned a bit like the mockups - still stuff to come
* Implemented the codeviewer + admin panel again using the Framework CodeIgniter instead 

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/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.php'))
 
356
                        {
 
357
                                include(APPPATH.'config/'.ENVIRONMENT.'/mimes.php');
 
358
                        }
 
359
                        elseif (is_file(APPPATH.'config/mimes.php'))
 
360
                        {
 
361
                                include(APPPATH.'config/mimes.php');
 
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 */
 
 
b'\\ No newline at end of file'