/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: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

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'