Merge branch 'MDL-50887-master' of https://github.com/lucisgit/moodle
[moodle.git] / repository / upload / lib.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/>.
18 /**
19  * This plugin is used to upload files
20  *
21  * @since Moodle 2.0
22  * @package    repository_upload
23  * @copyright  2010 Dongsheng Cai {@link http://dongsheng.org}
24  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
26 require_once($CFG->dirroot . '/repository/lib.php');
28 /**
29  * A repository plugin to allow user uploading files
30  *
31  * @since Moodle 2.0
32  * @package    repository_upload
33  * @copyright  2009 Dongsheng Cai {@link http://dongsheng.org}
34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
37 class repository_upload extends repository {
38     private $mimetypes = array();
40     /**
41      * Print a upload form
42      * @return array
43      */
44     public function print_login() {
45         return $this->get_listing();
46     }
48     /**
49      * Process uploaded file
50      * @return array|bool
51      */
52     public function upload($saveas_filename, $maxbytes) {
53         global $CFG;
55         $types = optional_param_array('accepted_types', '*', PARAM_RAW);
56         $savepath = optional_param('savepath', '/', PARAM_PATH);
57         $itemid   = optional_param('itemid', 0, PARAM_INT);
58         $license  = optional_param('license', $CFG->sitedefaultlicense, PARAM_TEXT);
59         $author   = optional_param('author', '', PARAM_TEXT);
60         $areamaxbytes = optional_param('areamaxbytes', FILE_AREA_MAX_BYTES_UNLIMITED, PARAM_INT);
61         $overwriteexisting = optional_param('overwrite', false, PARAM_BOOL);
63         return $this->process_upload($saveas_filename, $maxbytes, $types, $savepath, $itemid, $license, $author, $overwriteexisting, $areamaxbytes);
64     }
66     /**
67      * Do the actual processing of the uploaded file
68      * @param string $saveas_filename name to give to the file
69      * @param int $maxbytes maximum file size
70      * @param mixed $types optional array of file extensions that are allowed or '*' for all
71      * @param string $savepath optional path to save the file to
72      * @param int $itemid optional the ID for this item within the file area
73      * @param string $license optional the license to use for this file
74      * @param string $author optional the name of the author of this file
75      * @param bool $overwriteexisting optional user has asked to overwrite the existing file
76      * @param int $areamaxbytes maximum size of the file area.
77      * @return object containing details of the file uploaded
78      */
79     public function process_upload($saveas_filename, $maxbytes, $types = '*', $savepath = '/', $itemid = 0,
80             $license = null, $author = '', $overwriteexisting = false, $areamaxbytes = FILE_AREA_MAX_BYTES_UNLIMITED) {
81         global $USER, $CFG;
83         if ((is_array($types) and in_array('*', $types)) or $types == '*') {
84             $this->mimetypes = '*';
85         } else {
86             foreach ($types as $type) {
87                 $this->mimetypes[] = mimeinfo('type', $type);
88             }
89         }
91         if ($license == null) {
92             $license = $CFG->sitedefaultlicense;
93         }
95         $record = new stdClass();
96         $record->filearea = 'draft';
97         $record->component = 'user';
98         $record->filepath = $savepath;
99         $record->itemid   = $itemid;
100         $record->license  = $license;
101         $record->author   = $author;
103         $context = context_user::instance($USER->id);
104         $elname = 'repo_upload_file';
106         $fs = get_file_storage();
107         $sm = get_string_manager();
109         if ($record->filepath !== '/') {
110             $record->filepath = file_correct_filepath($record->filepath);
111         }
113         if (!isset($_FILES[$elname])) {
114             throw new moodle_exception('nofile');
115         }
116         if (!empty($_FILES[$elname]['error'])) {
117             switch ($_FILES[$elname]['error']) {
118             case UPLOAD_ERR_INI_SIZE:
119                 throw new moodle_exception('upload_error_ini_size', 'repository_upload');
120                 break;
121             case UPLOAD_ERR_FORM_SIZE:
122                 throw new moodle_exception('upload_error_form_size', 'repository_upload');
123                 break;
124             case UPLOAD_ERR_PARTIAL:
125                 throw new moodle_exception('upload_error_partial', 'repository_upload');
126                 break;
127             case UPLOAD_ERR_NO_FILE:
128                 throw new moodle_exception('upload_error_no_file', 'repository_upload');
129                 break;
130             case UPLOAD_ERR_NO_TMP_DIR:
131                 throw new moodle_exception('upload_error_no_tmp_dir', 'repository_upload');
132                 break;
133             case UPLOAD_ERR_CANT_WRITE:
134                 throw new moodle_exception('upload_error_cant_write', 'repository_upload');
135                 break;
136             case UPLOAD_ERR_EXTENSION:
137                 throw new moodle_exception('upload_error_extension', 'repository_upload');
138                 break;
139             default:
140                 throw new moodle_exception('nofile');
141             }
142         }
144         \core\antivirus\manager::scan_file($_FILES[$elname]['tmp_name'], $_FILES[$elname]['name'], true);
146         // {@link repository::build_source_field()}
147         $sourcefield = $this->get_file_source_info($_FILES[$elname]['name']);
148         $record->source = self::build_source_field($sourcefield);
150         if (empty($saveas_filename)) {
151             $record->filename = clean_param($_FILES[$elname]['name'], PARAM_FILE);
152         } else {
153             $ext = '';
154             $match = array();
155             $filename = clean_param($_FILES[$elname]['name'], PARAM_FILE);
156             if (strpos($filename, '.') === false) {
157                 // File has no extension at all - do not add a dot.
158                 $record->filename = $saveas_filename;
159             } else {
160                 if (preg_match('/\.([a-z0-9]+)$/i', $filename, $match)) {
161                     if (isset($match[1])) {
162                         $ext = $match[1];
163                     }
164                 }
165                 $ext = !empty($ext) ? $ext : '';
166                 if (preg_match('#\.(' . $ext . ')$#i', $saveas_filename)) {
167                     // saveas filename contains file extension already
168                     $record->filename = $saveas_filename;
169                 } else {
170                     $record->filename = $saveas_filename . '.' . $ext;
171                 }
172             }
173         }
175         // Check the file has some non-null contents - usually an indication that a user has
176         // tried to upload a folder by mistake
177         if (!$this->check_valid_contents($_FILES[$elname]['tmp_name'])) {
178             throw new moodle_exception('upload_error_invalid_file', 'repository_upload', '', $record->filename);
179         }
181         if ($this->mimetypes != '*') {
182             // check filetype
183             $filemimetype = file_storage::mimetype($_FILES[$elname]['tmp_name'], $record->filename);
184             if (!in_array($filemimetype, $this->mimetypes)) {
185                 throw new moodle_exception('invalidfiletype', 'repository', '', get_mimetype_description(array('filename' => $_FILES[$elname]['name'])));
186             }
187         }
189         if (empty($record->itemid)) {
190             $record->itemid = 0;
191         }
193         if (($maxbytes!==-1) && (filesize($_FILES[$elname]['tmp_name']) > $maxbytes)) {
194             throw new file_exception('maxbytesforfile', $_FILES[$elname]['name']);
195         }
197         if (file_is_draft_area_limit_reached($record->itemid, $areamaxbytes, filesize($_FILES[$elname]['tmp_name']))) {
198             throw new file_exception('maxareabytes');
199         }
201         $record->contextid = $context->id;
202         $record->userid    = $USER->id;
204         if (repository::draftfile_exists($record->itemid, $record->filepath, $record->filename)) {
205             $existingfilename = $record->filename;
206             $unused_filename = repository::get_unused_filename($record->itemid, $record->filepath, $record->filename);
207             $record->filename = $unused_filename;
208             $stored_file = $fs->create_file_from_pathname($record, $_FILES[$elname]['tmp_name']);
209             if ($overwriteexisting) {
210                 repository::overwrite_existing_draftfile($record->itemid, $record->filepath, $existingfilename, $record->filepath, $record->filename);
211                 $record->filename = $existingfilename;
212             } else {
213                 $event = array();
214                 $event['event'] = 'fileexists';
215                 $event['newfile'] = new stdClass;
216                 $event['newfile']->filepath = $record->filepath;
217                 $event['newfile']->filename = $unused_filename;
218                 $event['newfile']->url = moodle_url::make_draftfile_url($record->itemid, $record->filepath, $unused_filename)->out(false);
220                 $event['existingfile'] = new stdClass;
221                 $event['existingfile']->filepath = $record->filepath;
222                 $event['existingfile']->filename = $existingfilename;
223                 $event['existingfile']->url      = moodle_url::make_draftfile_url($record->itemid, $record->filepath, $existingfilename)->out(false);
224                 return $event;
225             }
226         } else {
227             $stored_file = $fs->create_file_from_pathname($record, $_FILES[$elname]['tmp_name']);
228         }
230         return array(
231             'url'=>moodle_url::make_draftfile_url($record->itemid, $record->filepath, $record->filename)->out(false),
232             'id'=>$record->itemid,
233             'file'=>$record->filename);
234     }
237     /**
238      * Checks the contents of the given file is not completely NULL - this can happen if a
239      * user drags & drops a folder onto a filemanager / filepicker element
240      * @param string $filepath full path (including filename) to file to check
241      * @return true if file has at least one non-null byte within it
242      */
243     protected function check_valid_contents($filepath) {
244         $buffersize = 4096;
246         $fp = fopen($filepath, 'r');
247         if (!$fp) {
248             return false; // Cannot read the file - something has gone wrong
249         }
250         while (!feof($fp)) {
251             // Read the file 4k at a time
252             $data = fread($fp, $buffersize);
253             if (preg_match('/[^\0]+/', $data)) {
254                 fclose($fp);
255                 return true; // Return as soon as a non-null byte is found
256             }
257         }
258         // Entire file is NULL
259         fclose($fp);
260         return false;
261     }
263     /**
264      * Return a upload form
265      * @return array
266      */
267     public function get_listing($path = '', $page = '') {
268         global $CFG;
269         $ret = array();
270         $ret['nologin']  = true;
271         $ret['nosearch'] = true;
272         $ret['norefresh'] = true;
273         $ret['list'] = array();
274         $ret['dynload'] = false;
275         $ret['upload'] = array('label'=>get_string('attachment', 'repository'), 'id'=>'repo-form');
276         $ret['allowcaching'] = true; // indicates that result of get_listing() can be cached in filepicker.js
277         return $ret;
278     }
280     /**
281      * supported return types
282      * @return int
283      */
284     public function supported_returntypes() {
285         return FILE_INTERNAL;
286     }
288     /**
289      * Is this repository accessing private data?
290      *
291      * @return bool
292      */
293     public function contains_private_data() {
294         return false;
295     }