8f1bf64db6c0cb4b8e1a0b18a6e6cbf4737b0c8e
[moodle.git] / lib / filestorage / file_storage.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
19 /**
20  * Core file storage class definition.
21  *
22  * @package    core
23  * @subpackage filestorage
24  * @copyright  2008 Petr Skoda {@link http://skodak.org}
25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
26  */
28 defined('MOODLE_INTERNAL') || die();
30 require_once("$CFG->libdir/filestorage/stored_file.php");
32 /**
33  * File storage class used for low level access to stored files.
34  *
35  * Only owner of file area may use this class to access own files,
36  * for example only code in mod/assignment/* may access assignment
37  * attachments. When some other part of moodle needs to access
38  * files of modules it has to use file_browser class instead or there
39  * has to be some callback API.
40  *
41  * @copyright 2008 Petr Skoda {@link http://skodak.org}
42  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
43  * @since     Moodle 2.0
44  */
45 class file_storage {
46     /** @var string Directory with file contents */
47     private $filedir;
48     /** @var string Contents of deleted files not needed any more */
49     private $trashdir;
50     /** @var string tempdir */
51     private $tempdir;
52     /** @var int Permissions for new directories */
53     private $dirpermissions;
54     /** @var int Permissions for new files */
55     private $filepermissions;
57     /**
58      * Constructor - do not use directly use @see get_file_storage() call instead.
59      *
60      * @param string $filedir full path to pool directory
61      * @param string $trashdir temporary storage of deleted area
62      * @param string $tempdir temporary storage of various files
63      * @param int $dirpermissions new directory permissions
64      * @param int $filepermissions new file permissions
65      */
66     public function __construct($filedir, $trashdir, $tempdir, $dirpermissions, $filepermissions) {
67         $this->filedir         = $filedir;
68         $this->trashdir        = $trashdir;
69         $this->tempdir         = $tempdir;
70         $this->dirpermissions  = $dirpermissions;
71         $this->filepermissions = $filepermissions;
73         // make sure the file pool directory exists
74         if (!is_dir($this->filedir)) {
75             if (!mkdir($this->filedir, $this->dirpermissions, true)) {
76                 throw new file_exception('storedfilecannotcreatefiledirs'); // permission trouble
77             }
78             // place warning file in file pool root
79             if (!file_exists($this->filedir.'/warning.txt')) {
80                 file_put_contents($this->filedir.'/warning.txt',
81                                   'This directory contains the content of uploaded files and is controlled by Moodle code. Do not manually move, change or rename any of the files and subdirectories here.');
82             }
83         }
84         // make sure the file pool directory exists
85         if (!is_dir($this->trashdir)) {
86             if (!mkdir($this->trashdir, $this->dirpermissions, true)) {
87                 throw new file_exception('storedfilecannotcreatefiledirs'); // permission trouble
88             }
89         }
90     }
92     /**
93      * Calculates sha1 hash of unique full path name information.
94      *
95      * This hash is a unique file identifier - it is used to improve
96      * performance and overcome db index size limits.
97      *
98      * @param int $contextid
99      * @param string $component
100      * @param string $filearea
101      * @param int $itemid
102      * @param string $filepath
103      * @param string $filename
104      * @return string sha1 hash
105      */
106     public static function get_pathname_hash($contextid, $component, $filearea, $itemid, $filepath, $filename) {
107         return sha1("/$contextid/$component/$filearea/$itemid".$filepath.$filename);
108     }
110     /**
111      * Does this file exist?
112      *
113      * @param int $contextid
114      * @param string $component
115      * @param string $filearea
116      * @param int $itemid
117      * @param string $filepath
118      * @param string $filename
119      * @return bool
120      */
121     public function file_exists($contextid, $component, $filearea, $itemid, $filepath, $filename) {
122         $filepath = clean_param($filepath, PARAM_PATH);
123         $filename = clean_param($filename, PARAM_FILE);
125         if ($filename === '') {
126             $filename = '.';
127         }
129         $pathnamehash = $this->get_pathname_hash($contextid, $component, $filearea, $itemid, $filepath, $filename);
130         return $this->file_exists_by_hash($pathnamehash);
131     }
133     /**
134      * Does this file exist?
135      *
136      * @param string $pathnamehash
137      * @return bool
138      */
139     public function file_exists_by_hash($pathnamehash) {
140         global $DB;
142         return $DB->record_exists('files', array('pathnamehash'=>$pathnamehash));
143     }
145     /**
146      * Create instance of file class from database record.
147      *
148      * @param stdClass $file_record record from the files table
149      * @return stored_file instance of file abstraction class
150      */
151     public function get_file_instance(stdClass $file_record) {
152         return new stored_file($this, $file_record, $this->filedir);
153     }
155     /**
156      * Fetch file using local file id.
157      *
158      * Please do not rely on file ids, it is usually easier to use
159      * pathname hashes instead.
160      *
161      * @param int $fileid
162      * @return stored_file instance if exists, false if not
163      */
164     public function get_file_by_id($fileid) {
165         global $DB;
167         if ($file_record = $DB->get_record('files', array('id'=>$fileid))) {
168             return $this->get_file_instance($file_record);
169         } else {
170             return false;
171         }
172     }
174     /**
175      * Fetch file using local file full pathname hash
176      *
177      * @param string $pathnamehash
178      * @return stored_file instance if exists, false if not
179      */
180     public function get_file_by_hash($pathnamehash) {
181         global $DB;
183         if ($file_record = $DB->get_record('files', array('pathnamehash'=>$pathnamehash))) {
184             return $this->get_file_instance($file_record);
185         } else {
186             return false;
187         }
188     }
190     /**
191      * Fetch locally stored file.
192      *
193      * @param int $contextid
194      * @param string $component
195      * @param string $filearea
196      * @param int $itemid
197      * @param string $filepath
198      * @param string $filename
199      * @return stored_file instance if exists, false if not
200      */
201     public function get_file($contextid, $component, $filearea, $itemid, $filepath, $filename) {
202         $filepath = clean_param($filepath, PARAM_PATH);
203         $filename = clean_param($filename, PARAM_FILE);
205         if ($filename === '') {
206             $filename = '.';
207         }
209         $pathnamehash = $this->get_pathname_hash($contextid, $component, $filearea, $itemid, $filepath, $filename);
210         return $this->get_file_by_hash($pathnamehash);
211     }
213     /**
214      * Are there any files (or directories)
215      * @param int $contextid
216      * @param string $component
217      * @param string $filearea
218      * @param bool|int $itemid tem id or false if all items
219      * @param bool $ignoredirs
220      * @return bool empty
221      */
222     public function is_area_empty($contextid, $component, $filearea, $itemid = false, $ignoredirs = true) {
223         global $DB;
225         $params = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea);
226         $where = "contextid = :contextid AND component = :component AND filearea = :filearea";
228         if ($itemid !== false) {
229             $params['itemid'] = $itemid;
230             $where .= " AND itemid = :itemid";
231         }
233         if ($ignoredirs) {
234             $sql = "SELECT 'x'
235                       FROM {files}
236                      WHERE $where AND filename <> '.'";
237         } else {
238             $sql = "SELECT 'x'
239                       FROM {files}
240                      WHERE $where AND (filename <> '.' OR filepath <> '/')";
241         }
243         return !$DB->record_exists_sql($sql, $params);
244     }
246     /**
247      * Returns all area files (optionally limited by itemid)
248      *
249      * @param int $contextid
250      * @param string $component
251      * @param string $filearea
252      * @param int $itemid (all files if not specified)
253      * @param string $sort
254      * @param bool $includedirs
255      * @return array of stored_files indexed by pathanmehash
256      */
257     public function get_area_files($contextid, $component, $filearea, $itemid = false, $sort="sortorder, itemid, filepath, filename", $includedirs = true) {
258         global $DB;
260         $conditions = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea);
261         if ($itemid !== false) {
262             $conditions['itemid'] = $itemid;
263         }
265         $result = array();
266         $file_records = $DB->get_records('files', $conditions, $sort);
267         foreach ($file_records as $file_record) {
268             if (!$includedirs and $file_record->filename === '.') {
269                 continue;
270             }
271             $result[$file_record->pathnamehash] = $this->get_file_instance($file_record);
272         }
273         return $result;
274     }
276     /**
277      * Returns array based tree structure of area files
278      *
279      * @param int $contextid
280      * @param string $component
281      * @param string $filearea
282      * @param int $itemid
283      * @return array each dir represented by dirname, subdirs, files and dirfile array elements
284      */
285     public function get_area_tree($contextid, $component, $filearea, $itemid) {
286         $result = array('dirname'=>'', 'dirfile'=>null, 'subdirs'=>array(), 'files'=>array());
287         $files = $this->get_area_files($contextid, $component, $filearea, $itemid, "sortorder, itemid, filepath, filename", true);
288         // first create directory structure
289         foreach ($files as $hash=>$dir) {
290             if (!$dir->is_directory()) {
291                 continue;
292             }
293             unset($files[$hash]);
294             if ($dir->get_filepath() === '/') {
295                 $result['dirfile'] = $dir;
296                 continue;
297             }
298             $parts = explode('/', trim($dir->get_filepath(),'/'));
299             $pointer =& $result;
300             foreach ($parts as $part) {
301                 if ($part === '') {
302                     continue;
303                 }
304                 if (!isset($pointer['subdirs'][$part])) {
305                     $pointer['subdirs'][$part] = array('dirname'=>$part, 'dirfile'=>null, 'subdirs'=>array(), 'files'=>array());
306                 }
307                 $pointer =& $pointer['subdirs'][$part];
308             }
309             $pointer['dirfile'] = $dir;
310             unset($pointer);
311         }
312         foreach ($files as $hash=>$file) {
313             $parts = explode('/', trim($file->get_filepath(),'/'));
314             $pointer =& $result;
315             foreach ($parts as $part) {
316                 if ($part === '') {
317                     continue;
318                 }
319                 $pointer =& $pointer['subdirs'][$part];
320             }
321             $pointer['files'][$file->get_filename()] = $file;
322             unset($pointer);
323         }
324         return $result;
325     }
327     /**
328      * Returns all files and optionally directories
329      *
330      * @param int $contextid
331      * @param string $component
332      * @param string $filearea
333      * @param int $itemid
334      * @param int $filepath directory path
335      * @param bool $recursive include all subdirectories
336      * @param bool $includedirs include files and directories
337      * @param string $sort
338      * @return array of stored_files indexed by pathanmehash
339      */
340     public function get_directory_files($contextid, $component, $filearea, $itemid, $filepath, $recursive = false, $includedirs = true, $sort = "filepath, filename") {
341         global $DB;
343         if (!$directory = $this->get_file($contextid, $component, $filearea, $itemid, $filepath, '.')) {
344             return array();
345         }
347         if ($recursive) {
349             $dirs = $includedirs ? "" : "AND filename <> '.'";
350             $length = textlib_get_instance()->strlen($filepath);
352             $sql = "SELECT *
353                       FROM {files}
354                      WHERE contextid = :contextid AND component = :component AND filearea = :filearea AND itemid = :itemid
355                            AND ".$DB->sql_substr("filepath", 1, $length)." = :filepath
356                            AND id <> :dirid
357                            $dirs
358                   ORDER BY $sort";
359             $params = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea, 'itemid'=>$itemid, 'filepath'=>$filepath, 'dirid'=>$directory->get_id());
361             $files = array();
362             $dirs  = array();
363             $file_records = $DB->get_records_sql($sql, $params);
364             foreach ($file_records as $file_record) {
365                 if ($file_record->filename == '.') {
366                     $dirs[$file_record->pathnamehash] = $this->get_file_instance($file_record);
367                 } else {
368                     $files[$file_record->pathnamehash] = $this->get_file_instance($file_record);
369                 }
370             }
371             $result = array_merge($dirs, $files);
373         } else {
374             $result = array();
375             $params = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea, 'itemid'=>$itemid, 'filepath'=>$filepath, 'dirid'=>$directory->get_id());
377             $length = textlib_get_instance()->strlen($filepath);
379             if ($includedirs) {
380                 $sql = "SELECT *
381                           FROM {files}
382                          WHERE contextid = :contextid AND component = :component AND filearea = :filearea
383                                AND itemid = :itemid AND filename = '.'
384                                AND ".$DB->sql_substr("filepath", 1, $length)." = :filepath
385                                AND id <> :dirid
386                       ORDER BY $sort";
387                 $reqlevel = substr_count($filepath, '/') + 1;
388                 $file_records = $DB->get_records_sql($sql, $params);
389                 foreach ($file_records as $file_record) {
390                     if (substr_count($file_record->filepath, '/') !== $reqlevel) {
391                         continue;
392                     }
393                     $result[$file_record->pathnamehash] = $this->get_file_instance($file_record);
394                 }
395             }
397             $sql = "SELECT *
398                       FROM {files}
399                      WHERE contextid = :contextid AND component = :component AND filearea = :filearea AND itemid = :itemid
400                            AND filepath = :filepath AND filename <> '.'
401                   ORDER BY $sort";
403             $file_records = $DB->get_records_sql($sql, $params);
404             foreach ($file_records as $file_record) {
405                 $result[$file_record->pathnamehash] = $this->get_file_instance($file_record);
406             }
407         }
409         return $result;
410     }
412     /**
413      * Delete all area files (optionally limited by itemid).
414      *
415      * @param int $contextid
416      * @param string $component
417      * @param string $filearea (all areas in context if not specified)
418      * @param int $itemid (all files if not specified)
419      * @return bool success
420      */
421     public function delete_area_files($contextid, $component = false, $filearea = false, $itemid = false) {
422         global $DB;
424         $conditions = array('contextid'=>$contextid);
425         if ($component !== false) {
426             $conditions['component'] = $component;
427         }
428         if ($filearea !== false) {
429             $conditions['filearea'] = $filearea;
430         }
431         if ($itemid !== false) {
432             $conditions['itemid'] = $itemid;
433         }
435         $file_records = $DB->get_records('files', $conditions);
436         foreach ($file_records as $file_record) {
437             $stored_file = $this->get_file_instance($file_record);
438             $stored_file->delete();
439         }
441         return true; // BC only
442     }
444     /**
445      * Move all the files in a file area from one context to another.
446      * @param integer $oldcontextid the context the files are being moved from.
447      * @param integer $newcontextid the context the files are being moved to.
448      * @param string $component the plugin that these files belong to.
449      * @param string $filearea the name of the file area.
450      * @return integer the number of files moved, for information.
451      */
452     public function move_area_files_to_new_context($oldcontextid, $newcontextid, $component, $filearea, $itemid = false) {
453         // Note, this code is based on some code that Petr wrote in
454         // forum_move_attachments in mod/forum/lib.php. I moved it here because
455         // I needed it in the question code too.
456         $count = 0;
458         $oldfiles = $this->get_area_files($oldcontextid, $component, $filearea, $itemid, 'id', false);
459         foreach ($oldfiles as $oldfile) {
460             $filerecord = new stdClass();
461             $filerecord->contextid = $newcontextid;
462             $this->create_file_from_storedfile($filerecord, $oldfile);
463             $count += 1;
464         }
466         if ($count) {
467             $this->delete_area_files($oldcontextid, $component, $filearea, $itemid);
468         }
470         return $count;
471     }
473     /**
474      * Recursively creates directory.
475      *
476      * @param int $contextid
477      * @param string $component
478      * @param string $filearea
479      * @param int $itemid
480      * @param string $filepath
481      * @param string $filename
482      * @return bool success
483      */
484     public function create_directory($contextid, $component, $filearea, $itemid, $filepath, $userid = null) {
485         global $DB;
487         // validate all parameters, we do not want any rubbish stored in database, right?
488         if (!is_number($contextid) or $contextid < 1) {
489             throw new file_exception('storedfileproblem', 'Invalid contextid');
490         }
492         if ($component === '' or $component !== clean_param($component, PARAM_ALPHAEXT)) {
493             throw new file_exception('storedfileproblem', 'Invalid component');
494         }
496         if ($filearea === '' or $filearea !== clean_param($filearea, PARAM_ALPHAEXT)) {
497             throw new file_exception('storedfileproblem', 'Invalid filearea');
498         }
500         if (!is_number($itemid) or $itemid < 0) {
501             throw new file_exception('storedfileproblem', 'Invalid itemid');
502         }
504         $filepath = clean_param($filepath, PARAM_PATH);
505         if (strpos($filepath, '/') !== 0 or strrpos($filepath, '/') !== strlen($filepath)-1) {
506             // path must start and end with '/'
507             throw new file_exception('storedfileproblem', 'Invalid file path');
508         }
510         $pathnamehash = $this->get_pathname_hash($contextid, $component, $filearea, $itemid, $filepath, '.');
512         if ($dir_info = $this->get_file_by_hash($pathnamehash)) {
513             return $dir_info;
514         }
516         static $contenthash = null;
517         if (!$contenthash) {
518             $this->add_string_to_pool('');
519             $contenthash = sha1('');
520         }
522         $now = time();
524         $dir_record = new stdClass();
525         $dir_record->contextid = $contextid;
526         $dir_record->component = $component;
527         $dir_record->filearea  = $filearea;
528         $dir_record->itemid    = $itemid;
529         $dir_record->filepath  = $filepath;
530         $dir_record->filename  = '.';
531         $dir_record->contenthash  = $contenthash;
532         $dir_record->filesize  = 0;
534         $dir_record->timecreated  = $now;
535         $dir_record->timemodified = $now;
536         $dir_record->mimetype     = null;
537         $dir_record->userid       = $userid;
539         $dir_record->pathnamehash = $pathnamehash;
541         $DB->insert_record('files', $dir_record);
542         $dir_info = $this->get_file_by_hash($pathnamehash);
544         if ($filepath !== '/') {
545             //recurse to parent dirs
546             $filepath = trim($filepath, '/');
547             $filepath = explode('/', $filepath);
548             array_pop($filepath);
549             $filepath = implode('/', $filepath);
550             $filepath = ($filepath === '') ? '/' : "/$filepath/";
551             $this->create_directory($contextid, $component, $filearea, $itemid, $filepath, $userid);
552         }
554         return $dir_info;
555     }
557     /**
558      * Add new local file based on existing local file.
559      *
560      * @param mixed $file_record object or array describing changes
561      * @param mixed $fileorid id or stored_file instance of the existing local file
562      * @return stored_file instance of newly created file
563      */
564     public function create_file_from_storedfile($file_record, $fileorid) {
565         global $DB;
567         if ($fileorid instanceof stored_file) {
568             $fid = $fileorid->get_id();
569         } else {
570             $fid = $fileorid;
571         }
573         $file_record = (array)$file_record; // we support arrays too, do not modify the submitted record!
575         unset($file_record['id']);
576         unset($file_record['filesize']);
577         unset($file_record['contenthash']);
578         unset($file_record['pathnamehash']);
580         if (!$newrecord = $DB->get_record('files', array('id'=>$fid))) {
581             throw new file_exception('storedfileproblem', 'File does not exist');
582         }
584         unset($newrecord->id);
586         foreach ($file_record as $key=>$value) {
587             // validate all parameters, we do not want any rubbish stored in database, right?
588             if ($key == 'contextid' and (!is_number($value) or $value < 1)) {
589                 throw new file_exception('storedfileproblem', 'Invalid contextid');
590             }
592             if ($key == 'component') {
593                 if ($value === '' or $value !== clean_param($value, PARAM_ALPHAEXT)) {
594                     throw new file_exception('storedfileproblem', 'Invalid component');
595                 }
596             }
598             if ($key == 'filearea') {
599                 if ($value === '' or $value !== clean_param($value, PARAM_ALPHAEXT)) {
600                     throw new file_exception('storedfileproblem', 'Invalid filearea');
601                 }
602             }
604             if ($key == 'itemid' and (!is_number($value) or $value < 0)) {
605                 throw new file_exception('storedfileproblem', 'Invalid itemid');
606             }
609             if ($key == 'filepath') {
610                 $value = clean_param($value, PARAM_PATH);
611                 if (strpos($value, '/') !== 0 or strrpos($value, '/') !== strlen($value)-1) {
612                     // path must start and end with '/'
613                     throw new file_exception('storedfileproblem', 'Invalid file path');
614                 }
615             }
617             if ($key == 'filename') {
618                 $value = clean_param($value, PARAM_FILE);
619                 if ($value === '') {
620                     // path must start and end with '/'
621                     throw new file_exception('storedfileproblem', 'Invalid file name');
622                 }
623             }
625             $newrecord->$key = $value;
626         }
628         $newrecord->pathnamehash = $this->get_pathname_hash($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->filename);
630         if ($newrecord->filename === '.') {
631             // special case - only this function supports directories ;-)
632             $directory = $this->create_directory($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->userid);
633             // update the existing directory with the new data
634             $newrecord->id = $directory->get_id();
635             $DB->update_record('files', $newrecord);
636             return $this->get_file_instance($newrecord);
637         }
639         try {
640             $newrecord->id = $DB->insert_record('files', $newrecord);
641         } catch (dml_exception $e) {
642             $newrecord->id = false;
643         }
645         if (!$newrecord->id) {
646             throw new stored_file_creation_exception($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid,
647                                                      $newrecord->filepath, $newrecord->filename);
648         }
650         $this->create_directory($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->userid);
652         return $this->get_file_instance($newrecord);
653     }
655     /**
656      * Add new local file.
657      *
658      * @param mixed $file_record object or array describing file
659      * @param string $path path to file or content of file
660      * @param array $options @see download_file_content() options
661      * @param bool $usetempfile use temporary file for download, may prevent out of memory problems
662      * @return stored_file instance
663      */
664     public function create_file_from_url($file_record, $url, array $options = NULL, $usetempfile = false) {
666         $file_record = (array)$file_record;  //do not modify the submitted record, this cast unlinks objects
667         $file_record = (object)$file_record; // we support arrays too
669         $headers        = isset($options['headers'])        ? $options['headers'] : null;
670         $postdata       = isset($options['postdata'])       ? $options['postdata'] : null;
671         $fullresponse   = isset($options['fullresponse'])   ? $options['fullresponse'] : false;
672         $timeout        = isset($options['timeout'])        ? $options['timeout'] : 300;
673         $connecttimeout = isset($options['connecttimeout']) ? $options['connecttimeout'] : 20;
674         $skipcertverify = isset($options['skipcertverify']) ? $options['skipcertverify'] : false;
676         if (!isset($file_record->filename)) {
677             $parts = explode('/', $url);
678             $filename = array_pop($parts);
679             $file_record->filename = clean_param($filename, PARAM_FILE);
680         }
681         $source = !empty($file_record->source) ? $file_record->source : $url;
682         $file_record->source = clean_param($source, PARAM_URL);
684         if ($usetempfile) {
685             check_dir_exists($this->tempdir);
686             $tmpfile = tempnam($this->tempdir, 'newfromurl');
687             $content = download_file_content($url, $headers, $postdata, $fullresponse, $timeout, $connecttimeout, $skipcertverify, $tmpfile);
688             if ($content === false) {
689                 throw new file_exception('storedfileproblem', 'Can not fetch file form URL');
690             }
691             try {
692                 $newfile = $this->create_file_from_pathname($file_record, $tmpfile);
693                 @unlink($tmpfile);
694                 return $newfile;
695             } catch (Exception $e) {
696                 @unlink($tmpfile);
697                 throw $e;
698             }
700         } else {
701             $content = download_file_content($url, $headers, $postdata, $fullresponse, $timeout, $connecttimeout, $skipcertverify);
702             if ($content === false) {
703                 throw new file_exception('storedfileproblem', 'Can not fetch file form URL');
704             }
705             return $this->create_file_from_string($file_record, $content);
706         }
707     }
709     /**
710      * Add new local file.
711      *
712      * @param mixed $file_record object or array describing file
713      * @param string $path path to file or content of file
714      * @return stored_file instance
715      */
716     public function create_file_from_pathname($file_record, $pathname) {
717         global $DB;
719         $file_record = (array)$file_record;  //do not modify the submitted record, this cast unlinks objects
720         $file_record = (object)$file_record; // we support arrays too
722         // validate all parameters, we do not want any rubbish stored in database, right?
723         if (!is_number($file_record->contextid) or $file_record->contextid < 1) {
724             throw new file_exception('storedfileproblem', 'Invalid contextid');
725         }
727         if ($file_record->component === '' or $file_record->component !== clean_param($file_record->component, PARAM_ALPHAEXT)) {
728             throw new file_exception('storedfileproblem', 'Invalid component');
729         }
731         if ($file_record->filearea === '' or $file_record->filearea !== clean_param($file_record->filearea, PARAM_ALPHAEXT)) {
732             throw new file_exception('storedfileproblem', 'Invalid filearea');
733         }
735         if (!is_number($file_record->itemid) or $file_record->itemid < 0) {
736             throw new file_exception('storedfileproblem', 'Invalid itemid');
737         }
739         if (!empty($file_record->sortorder)) {
740             if (!is_number($file_record->sortorder) or $file_record->sortorder < 0) {
741                 $file_record->sortorder = 0;
742             }
743         } else {
744             $file_record->sortorder = 0;
745         }
747         $file_record->filepath = clean_param($file_record->filepath, PARAM_PATH);
748         if (strpos($file_record->filepath, '/') !== 0 or strrpos($file_record->filepath, '/') !== strlen($file_record->filepath)-1) {
749             // path must start and end with '/'
750             throw new file_exception('storedfileproblem', 'Invalid file path');
751         }
753         $file_record->filename = clean_param($file_record->filename, PARAM_FILE);
754         if ($file_record->filename === '') {
755             // filename must not be empty
756             throw new file_exception('storedfileproblem', 'Invalid file name');
757         }
759         $now = time();
761         $newrecord = new stdClass();
763         $newrecord->contextid = $file_record->contextid;
764         $newrecord->component = $file_record->component;
765         $newrecord->filearea  = $file_record->filearea;
766         $newrecord->itemid    = $file_record->itemid;
767         $newrecord->filepath  = $file_record->filepath;
768         $newrecord->filename  = $file_record->filename;
770         $newrecord->timecreated  = empty($file_record->timecreated) ? $now : $file_record->timecreated;
771         $newrecord->timemodified = empty($file_record->timemodified) ? $now : $file_record->timemodified;
772         $newrecord->mimetype     = empty($file_record->mimetype) ? mimeinfo('type', $file_record->filename) : $file_record->mimetype;
773         $newrecord->userid       = empty($file_record->userid) ? null : $file_record->userid;
774         $newrecord->source       = empty($file_record->source) ? null : $file_record->source;
775         $newrecord->author       = empty($file_record->author) ? null : $file_record->author;
776         $newrecord->license      = empty($file_record->license) ? null : $file_record->license;
777         $newrecord->sortorder    = $file_record->sortorder;
779         list($newrecord->contenthash, $newrecord->filesize, $newfile) = $this->add_file_to_pool($pathname);
781         $newrecord->pathnamehash = $this->get_pathname_hash($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->filename);
783         try {
784             $newrecord->id = $DB->insert_record('files', $newrecord);
785         } catch (dml_exception $e) {
786             $newrecord->id = false;
787         }
789         if (!$newrecord->id) {
790             if ($newfile) {
791                 $this->deleted_file_cleanup($newrecord->contenthash);
792             }
793             throw new stored_file_creation_exception($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid,
794                                                     $newrecord->filepath, $newrecord->filename);
795         }
797         $this->create_directory($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->userid);
799         return $this->get_file_instance($newrecord);
800     }
802     /**
803      * Add new local file.
804      *
805      * @param mixed $file_record object or array describing file
806      * @param string $content content of file
807      * @return stored_file instance
808      */
809     public function create_file_from_string($file_record, $content) {
810         global $DB;
812         $file_record = (array)$file_record;  //do not modify the submitted record, this cast unlinks objects
813         $file_record = (object)$file_record; // we support arrays too
815         // validate all parameters, we do not want any rubbish stored in database, right?
816         if (!is_number($file_record->contextid) or $file_record->contextid < 1) {
817             throw new file_exception('storedfileproblem', 'Invalid contextid');
818         }
820         if ($file_record->component === '' or $file_record->component !== clean_param($file_record->component, PARAM_ALPHAEXT)) {
821             throw new file_exception('storedfileproblem', 'Invalid component');
822         }
824         if ($file_record->filearea === '' or $file_record->filearea !== clean_param($file_record->filearea, PARAM_ALPHAEXT)) {
825             throw new file_exception('storedfileproblem', 'Invalid filearea');
826         }
828         if (!is_number($file_record->itemid) or $file_record->itemid < 0) {
829             throw new file_exception('storedfileproblem', 'Invalid itemid');
830         }
832         if (!empty($file_record->sortorder)) {
833             if (!is_number($file_record->sortorder) or $file_record->sortorder < 0) {
834                 $file_record->sortorder = 0;
835             }
836         } else {
837             $file_record->sortorder = 0;
838         }
840         $file_record->filepath = clean_param($file_record->filepath, PARAM_PATH);
841         if (strpos($file_record->filepath, '/') !== 0 or strrpos($file_record->filepath, '/') !== strlen($file_record->filepath)-1) {
842             // path must start and end with '/'
843             throw new file_exception('storedfileproblem', 'Invalid file path');
844         }
846         $file_record->filename = clean_param($file_record->filename, PARAM_FILE);
847         if ($file_record->filename === '') {
848             // path must start and end with '/'
849             throw new file_exception('storedfileproblem', 'Invalid file name');
850         }
852         $now = time();
854         $newrecord = new stdClass();
856         $newrecord->contextid = $file_record->contextid;
857         $newrecord->component = $file_record->component;
858         $newrecord->filearea  = $file_record->filearea;
859         $newrecord->itemid    = $file_record->itemid;
860         $newrecord->filepath  = $file_record->filepath;
861         $newrecord->filename  = $file_record->filename;
863         $newrecord->timecreated  = empty($file_record->timecreated) ? $now : $file_record->timecreated;
864         $newrecord->timemodified = empty($file_record->timemodified) ? $now : $file_record->timemodified;
865         $newrecord->mimetype     = empty($file_record->mimetype) ? mimeinfo('type', $file_record->filename) : $file_record->mimetype;
866         $newrecord->userid       = empty($file_record->userid) ? null : $file_record->userid;
867         $newrecord->source       = empty($file_record->source) ? null : $file_record->source;
868         $newrecord->author       = empty($file_record->author) ? null : $file_record->author;
869         $newrecord->license      = empty($file_record->license) ? null : $file_record->license;
870         $newrecord->sortorder    = $file_record->sortorder;
872         list($newrecord->contenthash, $newrecord->filesize, $newfile) = $this->add_string_to_pool($content);
874         $newrecord->pathnamehash = $this->get_pathname_hash($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->filename);
876         try {
877             $newrecord->id = $DB->insert_record('files', $newrecord);
878         } catch (dml_exception $e) {
879             $newrecord->id = false;
880         }
882         if (!$newrecord->id) {
883             if ($newfile) {
884                 $this->deleted_file_cleanup($newrecord->contenthash);
885             }
886             throw new stored_file_creation_exception($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid,
887                                                     $newrecord->filepath, $newrecord->filename);
888         }
890         $this->create_directory($newrecord->contextid, $newrecord->component, $newrecord->filearea, $newrecord->itemid, $newrecord->filepath, $newrecord->userid);
892         return $this->get_file_instance($newrecord);
893     }
895     /**
896      * Creates new image file from existing.
897      *
898      * @param mixed $file_record object or array describing new file
899      * @param mixed file id or stored file object
900      * @param int $newwidth in pixels
901      * @param int $newheight in pixels
902      * @param bool $keepaspectratio
903      * @param int $quality depending on image type 0-100 for jpeg, 0-9 (0 means no compression) for png
904      * @return stored_file instance
905      */
906     public function convert_image($file_record, $fid, $newwidth = NULL, $newheight = NULL, $keepaspectratio = true, $quality = NULL) {
907         if ($fid instanceof stored_file) {
908             $fid = $fid->get_id();
909         }
911         $file_record = (array)$file_record; // we support arrays too, do not modify the submitted record!
913         if (!$file = $this->get_file_by_id($fid)) { // make sure file really exists and we we correct data
914             throw new file_exception('storedfileproblem', 'File does not exist');
915         }
917         if (!$imageinfo = $file->get_imageinfo()) {
918             throw new file_exception('storedfileproblem', 'File is not an image');
919         }
921         if (!isset($file_record['filename'])) {
922             $file_record['filename'] == $file->get_filename();
923         }
925         if (!isset($file_record['mimetype'])) {
926             $file_record['mimetype'] = mimeinfo('type', $file_record['filename']);
927         }
929         $width    = $imageinfo['width'];
930         $height   = $imageinfo['height'];
931         $mimetype = $imageinfo['mimetype'];
933         if ($keepaspectratio) {
934             if (0 >= $newwidth and 0 >= $newheight) {
935                 // no sizes specified
936                 $newwidth  = $width;
937                 $newheight = $height;
939             } else if (0 < $newwidth and 0 < $newheight) {
940                 $xheight = ($newwidth*($height/$width));
941                 if ($xheight < $newheight) {
942                     $newheight = (int)$xheight;
943                 } else {
944                     $newwidth = (int)($newheight*($width/$height));
945                 }
947             } else if (0 < $newwidth) {
948                 $newheight = (int)($newwidth*($height/$width));
950             } else { //0 < $newheight
951                 $newwidth = (int)($newheight*($width/$height));
952             }
954         } else {
955             if (0 >= $newwidth) {
956                 $newwidth = $width;
957             }
958             if (0 >= $newheight) {
959                 $newheight = $height;
960             }
961         }
963         $img = imagecreatefromstring($file->get_content());
964         if ($height != $newheight or $width != $newwidth) {
965             $newimg = imagecreatetruecolor($newwidth, $newheight);
966             if (!imagecopyresized($newimg, $img, 0, 0, 0, 0, $newwidth, $newheight, $width, $height)) {
967                 // weird
968                 throw new file_exception('storedfileproblem', 'Can not resize image');
969             }
970             imagedestroy($img);
971             $img = $newimg;
972         }
974         ob_start();
975         switch ($file_record['mimetype']) {
976             case 'image/gif':
977                 imagegif($img);
978                 break;
980             case 'image/jpeg':
981                 if (is_null($quality)) {
982                     imagejpeg($img);
983                 } else {
984                     imagejpeg($img, NULL, $quality);
985                 }
986                 break;
988             case 'image/png':
989                 $quality = (int)$quality;
990                 imagepng($img, NULL, $quality, NULL);
991                 break;
993             default:
994                 throw new file_exception('storedfileproblem', 'Unsupported mime type');
995         }
997         $content = ob_get_contents();
998         ob_end_clean();
999         imagedestroy($img);
1001         if (!$content) {
1002             throw new file_exception('storedfileproblem', 'Can not convert image');
1003         }
1005         return $this->create_file_from_string($file_record, $content);
1006     }
1008     /**
1009      * Add file content to sha1 pool.
1010      *
1011      * @param string $pathname path to file
1012      * @param string $contenthash sha1 hash of content if known (performance only)
1013      * @return array (contenthash, filesize, newfile)
1014      */
1015     public function add_file_to_pool($pathname, $contenthash = NULL) {
1016         if (!is_readable($pathname)) {
1017             throw new file_exception('storedfilecannotread');
1018         }
1020         if (is_null($contenthash)) {
1021             $contenthash = sha1_file($pathname);
1022         }
1024         $filesize = filesize($pathname);
1026         $hashpath = $this->path_from_hash($contenthash);
1027         $hashfile = "$hashpath/$contenthash";
1029         if (file_exists($hashfile)) {
1030             if (filesize($hashfile) !== $filesize) {
1031                 throw new file_pool_content_exception($contenthash);
1032             }
1033             $newfile = false;
1035         } else {
1036             if (!is_dir($hashpath)) {
1037                 if (!mkdir($hashpath, $this->dirpermissions, true)) {
1038                     throw new file_exception('storedfilecannotcreatefiledirs'); // permission trouble
1039                 }
1040             }
1041             $newfile = true;
1043             if (!copy($pathname, $hashfile)) {
1044                 throw new file_exception('storedfilecannotread');
1045             }
1047             if (filesize($hashfile) !== $filesize) {
1048                 @unlink($hashfile);
1049                 throw new file_pool_content_exception($contenthash);
1050             }
1051             chmod($hashfile, $this->filepermissions); // fix permissions if needed
1052         }
1055         return array($contenthash, $filesize, $newfile);
1056     }
1058     /**
1059      * Add string content to sha1 pool.
1060      *
1061      * @param string $content file content - binary string
1062      * @return array (contenthash, filesize, newfile)
1063      */
1064     public function add_string_to_pool($content) {
1065         $contenthash = sha1($content);
1066         $filesize = strlen($content); // binary length
1068         $hashpath = $this->path_from_hash($contenthash);
1069         $hashfile = "$hashpath/$contenthash";
1072         if (file_exists($hashfile)) {
1073             if (filesize($hashfile) !== $filesize) {
1074                 throw new file_pool_content_exception($contenthash);
1075             }
1076             $newfile = false;
1078         } else {
1079             if (!is_dir($hashpath)) {
1080                 if (!mkdir($hashpath, $this->dirpermissions, true)) {
1081                     throw new file_exception('storedfilecannotcreatefiledirs'); // permission trouble
1082                 }
1083             }
1084             $newfile = true;
1086             file_put_contents($hashfile, $content);
1088             if (filesize($hashfile) !== $filesize) {
1089                 @unlink($hashfile);
1090                 throw new file_pool_content_exception($contenthash);
1091             }
1092             chmod($hashfile, $this->filepermissions); // fix permissions if needed
1093         }
1095         return array($contenthash, $filesize, $newfile);
1096     }
1098     /**
1099      * Return path to file with given hash.
1100      *
1101      * NOTE: must not be public, files in pool must not be modified
1102      *
1103      * @param string $contenthash
1104      * @return string expected file location
1105      */
1106     protected function path_from_hash($contenthash) {
1107         $l1 = $contenthash[0].$contenthash[1];
1108         $l2 = $contenthash[2].$contenthash[3];
1109         return "$this->filedir/$l1/$l2";
1110     }
1112     /**
1113      * Return path to file with given hash.
1114      *
1115      * NOTE: must not be public, files in pool must not be modified
1116      *
1117      * @param string $contenthash
1118      * @return string expected file location
1119      */
1120     protected function trash_path_from_hash($contenthash) {
1121         $l1 = $contenthash[0].$contenthash[1];
1122         $l2 = $contenthash[2].$contenthash[3];
1123         return "$this->trashdir/$l1/$l2";
1124     }
1126     /**
1127      * Tries to recover missing content of file from trash.
1128      *
1129      * @param object $file_record
1130      * @return bool success
1131      */
1132     public function try_content_recovery($file) {
1133         $contenthash = $file->get_contenthash();
1134         $trashfile = $this->trash_path_from_hash($contenthash).'/'.$contenthash;
1135         if (!is_readable($trashfile)) {
1136             if (!is_readable($this->trashdir.'/'.$contenthash)) {
1137                 return false;
1138             }
1139             // nice, at least alternative trash file in trash root exists
1140             $trashfile = $this->trashdir.'/'.$contenthash;
1141         }
1142         if (filesize($trashfile) != $file->get_filesize() or sha1_file($trashfile) != $contenthash) {
1143             //weird, better fail early
1144             return false;
1145         }
1146         $contentdir  = $this->path_from_hash($contenthash);
1147         $contentfile = $contentdir.'/'.$contenthash;
1148         if (file_exists($contentfile)) {
1149             //strange, no need to recover anything
1150             return true;
1151         }
1152         if (!is_dir($contentdir)) {
1153             if (!mkdir($contentdir, $this->dirpermissions, true)) {
1154                 return false;
1155             }
1156         }
1157         return rename($trashfile, $contentfile);
1158     }
1160     /**
1161      * Marks pool file as candidate for deleting.
1162      *
1163      * DO NOT call directly - reserved for core!!
1164      *
1165      * @param string $contenthash
1166      * @return void
1167      */
1168     public function deleted_file_cleanup($contenthash) {
1169         global $DB;
1171         //Note: this section is critical - in theory file could be reused at the same
1172         //      time, if this happens we can still recover the file from trash
1173         if ($DB->record_exists('files', array('contenthash'=>$contenthash))) {
1174             // file content is still used
1175             return;
1176         }
1177         //move content file to trash
1178         $contentfile = $this->path_from_hash($contenthash).'/'.$contenthash;
1179         if (!file_exists($contentfile)) {
1180             //weird, but no problem
1181             return;
1182         }
1183         $trashpath = $this->trash_path_from_hash($contenthash);
1184         $trashfile = $trashpath.'/'.$contenthash;
1185         if (file_exists($trashfile)) {
1186             // we already have this content in trash, no need to move it there
1187             unlink($contentfile);
1188             return;
1189         }
1190         if (!is_dir($trashpath)) {
1191             mkdir($trashpath, $this->dirpermissions, true);
1192         }
1193         rename($contentfile, $trashfile);
1194         chmod($trashfile, $this->filepermissions); // fix permissions if needed
1195     }
1197     /**
1198      * Cron cleanup job.
1199      *
1200      * @return void
1201      */
1202     public function cron() {
1203         global $CFG, $DB;
1205         // find out all stale draft areas (older than 4 days) and purge them
1206         // those are identified by time stamp of the /. root dir
1207         mtrace('Deleting old draft files... ', '');
1208         $old = time() - 60*60*24*4;
1209         $sql = "SELECT *
1210                   FROM {files}
1211                  WHERE component = 'user' AND filearea = 'draft' AND filepath = '/' AND filename = '.'
1212                        AND timecreated < :old";
1213         $rs = $DB->get_recordset_sql($sql, array('old'=>$old));
1214         foreach ($rs as $dir) {
1215             $this->delete_area_files($dir->contextid, $dir->component, $dir->filearea, $dir->itemid);
1216         }
1218         // remove trash pool files once a day
1219         // if you want to disable purging of trash put $CFG->fileslastcleanup=time(); into config.php
1220         if (empty($CFG->fileslastcleanup) or $CFG->fileslastcleanup < time() - 60*60*24) {
1221             require_once($CFG->libdir.'/filelib.php');
1222             // Delete files that are associated with a context that no longer exists.
1223             mtrace('Cleaning up files from deleted contexts... ', '');
1224             $sql = "SELECT DISTINCT f.contextid
1225                     FROM {files} f
1226                     LEFT OUTER JOIN {context} c ON f.contextid = c.id
1227                     WHERE c.id IS NULL";
1228             if ($rs = $DB->get_recordset_sql($sql)) {
1229                 $fs = get_file_storage();
1230                 foreach ($rs as $ctx) {
1231                     $fs->delete_area_files($ctx->contextid);
1232                 }
1233             }
1234             mtrace('done.');
1236             mtrace('Deleting trash files... ', '');
1237             fulldelete($this->trashdir);
1238             set_config('fileslastcleanup', time());
1239             mtrace('done.');
1240         }
1241     }