Merge branch 'MDL-65081-master' of git://github.com/junpataleta/moodle
[moodle.git] / lib / filelib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Functions for file handling.
19  *
20  * @package   core_files
21  * @copyright 1999 onwards Martin Dougiamas (http://dougiamas.com)
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
27 /**
28  * BYTESERVING_BOUNDARY - string unique string constant.
29  */
30 define('BYTESERVING_BOUNDARY', 's1k2o3d4a5k6s7');
33 /**
34  * Do not process file merging when working with draft area files.
35  */
36 define('IGNORE_FILE_MERGE', -1);
38 /**
39  * Unlimited area size constant
40  */
41 define('FILE_AREA_MAX_BYTES_UNLIMITED', -1);
43 require_once("$CFG->libdir/filestorage/file_exceptions.php");
44 require_once("$CFG->libdir/filestorage/file_storage.php");
45 require_once("$CFG->libdir/filestorage/zip_packer.php");
46 require_once("$CFG->libdir/filebrowser/file_browser.php");
48 /**
49  * Encodes file serving url
50  *
51  * @deprecated use moodle_url factory methods instead
52  *
53  * @todo MDL-31071 deprecate this function
54  * @global stdClass $CFG
55  * @param string $urlbase
56  * @param string $path /filearea/itemid/dir/dir/file.exe
57  * @param bool $forcedownload
58  * @param bool $https https url required
59  * @return string encoded file url
60  */
61 function file_encode_url($urlbase, $path, $forcedownload=false, $https=false) {
62     global $CFG;
64 //TODO: deprecate this
66     if ($CFG->slasharguments) {
67         $parts = explode('/', $path);
68         $parts = array_map('rawurlencode', $parts);
69         $path  = implode('/', $parts);
70         $return = $urlbase.$path;
71         if ($forcedownload) {
72             $return .= '?forcedownload=1';
73         }
74     } else {
75         $path = rawurlencode($path);
76         $return = $urlbase.'?file='.$path;
77         if ($forcedownload) {
78             $return .= '&amp;forcedownload=1';
79         }
80     }
82     if ($https) {
83         $return = str_replace('http://', 'https://', $return);
84     }
86     return $return;
87 }
89 /**
90  * Detects if area contains subdirs,
91  * this is intended for file areas that are attached to content
92  * migrated from 1.x where subdirs were allowed everywhere.
93  *
94  * @param context $context
95  * @param string $component
96  * @param string $filearea
97  * @param string $itemid
98  * @return bool
99  */
100 function file_area_contains_subdirs(context $context, $component, $filearea, $itemid) {
101     global $DB;
103     if (!isset($itemid)) {
104         // Not initialised yet.
105         return false;
106     }
108     // Detect if any directories are already present, this is necessary for content upgraded from 1.x.
109     $select = "contextid = :contextid AND component = :component AND filearea = :filearea AND itemid = :itemid AND filepath <> '/' AND filename = '.'";
110     $params = array('contextid'=>$context->id, 'component'=>$component, 'filearea'=>$filearea, 'itemid'=>$itemid);
111     return $DB->record_exists_select('files', $select, $params);
114 /**
115  * Prepares 'editor' formslib element from data in database
116  *
117  * The passed $data record must contain field foobar, foobarformat and optionally foobartrust. This
118  * function then copies the embedded files into draft area (assigning itemids automatically),
119  * creates the form element foobar_editor and rewrites the URLs so the embedded images can be
120  * displayed.
121  * In your mform definition, you must have an 'editor' element called foobar_editor. Then you call
122  * your mform's set_data() supplying the object returned by this function.
123  *
124  * @category files
125  * @param stdClass $data database field that holds the html text with embedded media
126  * @param string $field the name of the database field that holds the html text with embedded media
127  * @param array $options editor options (like maxifiles, maxbytes etc.)
128  * @param stdClass $context context of the editor
129  * @param string $component
130  * @param string $filearea file area name
131  * @param int $itemid item id, required if item exists
132  * @return stdClass modified data object
133  */
134 function file_prepare_standard_editor($data, $field, array $options, $context=null, $component=null, $filearea=null, $itemid=null) {
135     $options = (array)$options;
136     if (!isset($options['trusttext'])) {
137         $options['trusttext'] = false;
138     }
139     if (!isset($options['forcehttps'])) {
140         $options['forcehttps'] = false;
141     }
142     if (!isset($options['subdirs'])) {
143         $options['subdirs'] = false;
144     }
145     if (!isset($options['maxfiles'])) {
146         $options['maxfiles'] = 0; // no files by default
147     }
148     if (!isset($options['noclean'])) {
149         $options['noclean'] = false;
150     }
152     //sanity check for passed context. This function doesn't expect $option['context'] to be set
153     //But this function is called before creating editor hence, this is one of the best places to check
154     //if context is used properly. This check notify developer that they missed passing context to editor.
155     if (isset($context) && !isset($options['context'])) {
156         //if $context is not null then make sure $option['context'] is also set.
157         debugging('Context for editor is not set in editoroptions. Hence editor will not respect editor filters', DEBUG_DEVELOPER);
158     } else if (isset($options['context']) && isset($context)) {
159         //If both are passed then they should be equal.
160         if ($options['context']->id != $context->id) {
161             $exceptionmsg = 'Editor context ['.$options['context']->id.'] is not equal to passed context ['.$context->id.']';
162             throw new coding_exception($exceptionmsg);
163         }
164     }
166     if (is_null($itemid) or is_null($context)) {
167         $contextid = null;
168         $itemid = null;
169         if (!isset($data)) {
170             $data = new stdClass();
171         }
172         if (!isset($data->{$field})) {
173             $data->{$field} = '';
174         }
175         if (!isset($data->{$field.'format'})) {
176             $data->{$field.'format'} = editors_get_preferred_format();
177         }
178         if (!$options['noclean']) {
179             $data->{$field} = clean_text($data->{$field}, $data->{$field.'format'});
180         }
182     } else {
183         if ($options['trusttext']) {
184             // noclean ignored if trusttext enabled
185             if (!isset($data->{$field.'trust'})) {
186                 $data->{$field.'trust'} = 0;
187             }
188             $data = trusttext_pre_edit($data, $field, $context);
189         } else {
190             if (!$options['noclean']) {
191                 $data->{$field} = clean_text($data->{$field}, $data->{$field.'format'});
192             }
193         }
194         $contextid = $context->id;
195     }
197     if ($options['maxfiles'] != 0) {
198         $draftid_editor = file_get_submitted_draft_itemid($field);
199         $currenttext = file_prepare_draft_area($draftid_editor, $contextid, $component, $filearea, $itemid, $options, $data->{$field});
200         $data->{$field.'_editor'} = array('text'=>$currenttext, 'format'=>$data->{$field.'format'}, 'itemid'=>$draftid_editor);
201     } else {
202         $data->{$field.'_editor'} = array('text'=>$data->{$field}, 'format'=>$data->{$field.'format'}, 'itemid'=>0);
203     }
205     return $data;
208 /**
209  * Prepares the content of the 'editor' form element with embedded media files to be saved in database
210  *
211  * This function moves files from draft area to the destination area and
212  * encodes URLs to the draft files so they can be safely saved into DB. The
213  * form has to contain the 'editor' element named foobar_editor, where 'foobar'
214  * is the name of the database field to hold the wysiwyg editor content. The
215  * editor data comes as an array with text, format and itemid properties. This
216  * function automatically adds $data properties foobar, foobarformat and
217  * foobartrust, where foobar has URL to embedded files encoded.
218  *
219  * @category files
220  * @param stdClass $data raw data submitted by the form
221  * @param string $field name of the database field containing the html with embedded media files
222  * @param array $options editor options (trusttext, subdirs, maxfiles, maxbytes etc.)
223  * @param stdClass $context context, required for existing data
224  * @param string $component file component
225  * @param string $filearea file area name
226  * @param int $itemid item id, required if item exists
227  * @return stdClass modified data object
228  */
229 function file_postupdate_standard_editor($data, $field, array $options, $context, $component=null, $filearea=null, $itemid=null) {
230     $options = (array)$options;
231     if (!isset($options['trusttext'])) {
232         $options['trusttext'] = false;
233     }
234     if (!isset($options['forcehttps'])) {
235         $options['forcehttps'] = false;
236     }
237     if (!isset($options['subdirs'])) {
238         $options['subdirs'] = false;
239     }
240     if (!isset($options['maxfiles'])) {
241         $options['maxfiles'] = 0; // no files by default
242     }
243     if (!isset($options['maxbytes'])) {
244         $options['maxbytes'] = 0; // unlimited
245     }
246     if (!isset($options['removeorphaneddrafts'])) {
247         $options['removeorphaneddrafts'] = false; // Don't remove orphaned draft files by default.
248     }
250     if ($options['trusttext']) {
251         $data->{$field.'trust'} = trusttext_trusted($context);
252     } else {
253         $data->{$field.'trust'} = 0;
254     }
256     $editor = $data->{$field.'_editor'};
258     if ($options['maxfiles'] == 0 or is_null($filearea) or is_null($itemid) or empty($editor['itemid'])) {
259         $data->{$field} = $editor['text'];
260     } else {
261         // Clean the user drafts area of any files not referenced in the editor text.
262         if ($options['removeorphaneddrafts']) {
263             file_remove_editor_orphaned_files($editor);
264         }
265         $data->{$field} = file_save_draft_area_files($editor['itemid'], $context->id, $component, $filearea, $itemid, $options, $editor['text'], $options['forcehttps']);
266     }
267     $data->{$field.'format'} = $editor['format'];
269     return $data;
272 /**
273  * Saves text and files modified by Editor formslib element
274  *
275  * @category files
276  * @param stdClass $data $database entry field
277  * @param string $field name of data field
278  * @param array $options various options
279  * @param stdClass $context context - must already exist
280  * @param string $component
281  * @param string $filearea file area name
282  * @param int $itemid must already exist, usually means data is in db
283  * @return stdClass modified data obejct
284  */
285 function file_prepare_standard_filemanager($data, $field, array $options, $context=null, $component=null, $filearea=null, $itemid=null) {
286     $options = (array)$options;
287     if (!isset($options['subdirs'])) {
288         $options['subdirs'] = false;
289     }
290     if (is_null($itemid) or is_null($context)) {
291         $itemid = null;
292         $contextid = null;
293     } else {
294         $contextid = $context->id;
295     }
297     $draftid_editor = file_get_submitted_draft_itemid($field.'_filemanager');
298     file_prepare_draft_area($draftid_editor, $contextid, $component, $filearea, $itemid, $options);
299     $data->{$field.'_filemanager'} = $draftid_editor;
301     return $data;
304 /**
305  * Saves files modified by File manager formslib element
306  *
307  * @todo MDL-31073 review this function
308  * @category files
309  * @param stdClass $data $database entry field
310  * @param string $field name of data field
311  * @param array $options various options
312  * @param stdClass $context context - must already exist
313  * @param string $component
314  * @param string $filearea file area name
315  * @param int $itemid must already exist, usually means data is in db
316  * @return stdClass modified data obejct
317  */
318 function file_postupdate_standard_filemanager($data, $field, array $options, $context, $component, $filearea, $itemid) {
319     $options = (array)$options;
320     if (!isset($options['subdirs'])) {
321         $options['subdirs'] = false;
322     }
323     if (!isset($options['maxfiles'])) {
324         $options['maxfiles'] = -1; // unlimited
325     }
326     if (!isset($options['maxbytes'])) {
327         $options['maxbytes'] = 0; // unlimited
328     }
330     if (empty($data->{$field.'_filemanager'})) {
331         $data->$field = '';
333     } else {
334         file_save_draft_area_files($data->{$field.'_filemanager'}, $context->id, $component, $filearea, $itemid, $options);
335         $fs = get_file_storage();
337         if ($fs->get_area_files($context->id, $component, $filearea, $itemid)) {
338             $data->$field = '1'; // TODO: this is an ugly hack (skodak)
339         } else {
340             $data->$field = '';
341         }
342     }
344     return $data;
347 /**
348  * Generate a draft itemid
349  *
350  * @category files
351  * @global moodle_database $DB
352  * @global stdClass $USER
353  * @return int a random but available draft itemid that can be used to create a new draft
354  * file area.
355  */
356 function file_get_unused_draft_itemid() {
357     global $DB, $USER;
359     if (isguestuser() or !isloggedin()) {
360         // guests and not-logged-in users can not be allowed to upload anything!!!!!!
361         print_error('noguest');
362     }
364     $contextid = context_user::instance($USER->id)->id;
366     $fs = get_file_storage();
367     $draftitemid = rand(1, 999999999);
368     while ($files = $fs->get_area_files($contextid, 'user', 'draft', $draftitemid)) {
369         $draftitemid = rand(1, 999999999);
370     }
372     return $draftitemid;
375 /**
376  * Initialise a draft file area from a real one by copying the files. A draft
377  * area will be created if one does not already exist. Normally you should
378  * get $draftitemid by calling file_get_submitted_draft_itemid('elementname');
379  *
380  * @category files
381  * @global stdClass $CFG
382  * @global stdClass $USER
383  * @param int $draftitemid the id of the draft area to use, or 0 to create a new one, in which case this parameter is updated.
384  * @param int $contextid This parameter and the next two identify the file area to copy files from.
385  * @param string $component
386  * @param string $filearea helps indentify the file area.
387  * @param int $itemid helps identify the file area. Can be null if there are no files yet.
388  * @param array $options text and file options ('subdirs'=>false, 'forcehttps'=>false)
389  * @param string $text some html content that needs to have embedded links rewritten to point to the draft area.
390  * @return string|null returns string if $text was passed in, the rewritten $text is returned. Otherwise NULL.
391  */
392 function file_prepare_draft_area(&$draftitemid, $contextid, $component, $filearea, $itemid, array $options=null, $text=null) {
393     global $CFG, $USER, $CFG;
395     $options = (array)$options;
396     if (!isset($options['subdirs'])) {
397         $options['subdirs'] = false;
398     }
399     if (!isset($options['forcehttps'])) {
400         $options['forcehttps'] = false;
401     }
403     $usercontext = context_user::instance($USER->id);
404     $fs = get_file_storage();
406     if (empty($draftitemid)) {
407         // create a new area and copy existing files into
408         $draftitemid = file_get_unused_draft_itemid();
409         $file_record = array('contextid'=>$usercontext->id, 'component'=>'user', 'filearea'=>'draft', 'itemid'=>$draftitemid);
410         if (!is_null($itemid) and $files = $fs->get_area_files($contextid, $component, $filearea, $itemid)) {
411             foreach ($files as $file) {
412                 if ($file->is_directory() and $file->get_filepath() === '/') {
413                     // we need a way to mark the age of each draft area,
414                     // by not copying the root dir we force it to be created automatically with current timestamp
415                     continue;
416                 }
417                 if (!$options['subdirs'] and ($file->is_directory() or $file->get_filepath() !== '/')) {
418                     continue;
419                 }
420                 $draftfile = $fs->create_file_from_storedfile($file_record, $file);
421                 // XXX: This is a hack for file manager (MDL-28666)
422                 // File manager needs to know the original file information before copying
423                 // to draft area, so we append these information in mdl_files.source field
424                 // {@link file_storage::search_references()}
425                 // {@link file_storage::search_references_count()}
426                 $sourcefield = $file->get_source();
427                 $newsourcefield = new stdClass;
428                 $newsourcefield->source = $sourcefield;
429                 $original = new stdClass;
430                 $original->contextid = $contextid;
431                 $original->component = $component;
432                 $original->filearea  = $filearea;
433                 $original->itemid    = $itemid;
434                 $original->filename  = $file->get_filename();
435                 $original->filepath  = $file->get_filepath();
436                 $newsourcefield->original = file_storage::pack_reference($original);
437                 $draftfile->set_source(serialize($newsourcefield));
438                 // End of file manager hack
439             }
440         }
441         if (!is_null($text)) {
442             // at this point there should not be any draftfile links yet,
443             // because this is a new text from database that should still contain the @@pluginfile@@ links
444             // this happens when developers forget to post process the text
445             $text = str_replace("\"$CFG->wwwroot/draftfile.php", "\"$CFG->wwwroot/brokenfile.php#", $text);
446         }
447     } else {
448         // nothing to do
449     }
451     if (is_null($text)) {
452         return null;
453     }
455     // relink embedded files - editor can not handle @@PLUGINFILE@@ !
456     return file_rewrite_pluginfile_urls($text, 'draftfile.php', $usercontext->id, 'user', 'draft', $draftitemid, $options);
459 /**
460  * Convert encoded URLs in $text from the @@PLUGINFILE@@/... form to an actual URL.
461  * Passing a new option reverse = true in the $options var will make the function to convert actual URLs in $text to encoded URLs
462  * in the @@PLUGINFILE@@ form.
463  *
464  * @param   string  $text The content that may contain ULRs in need of rewriting.
465  * @param   string  $file The script that should be used to serve these files. pluginfile.php, draftfile.php, etc.
466  * @param   int     $contextid This parameter and the next two identify the file area to use.
467  * @param   string  $component
468  * @param   string  $filearea helps identify the file area.
469  * @param   int     $itemid helps identify the file area.
470  * @param   array   $options
471  *          bool    $options.forcehttps Force the user of https
472  *          bool    $options.reverse Reverse the behaviour of the function
473  *          bool    $options.includetoken Use a token for authentication
474  *          string  The processed text.
475  */
476 function file_rewrite_pluginfile_urls($text, $file, $contextid, $component, $filearea, $itemid, array $options=null) {
477     global $CFG, $USER;
479     $options = (array)$options;
480     if (!isset($options['forcehttps'])) {
481         $options['forcehttps'] = false;
482     }
484     $baseurl = "{$CFG->wwwroot}/{$file}";
485     if (!empty($options['includetoken'])) {
486         $token = get_user_key('core_files', $USER->id);
487         $finalfile = basename($file);
488         $tokenfile = "token{$finalfile}";
489         $file = substr($file, 0, strlen($file) - strlen($finalfile)) . $tokenfile;
490         $baseurl = "{$CFG->wwwroot}/{$file}";
492         if (!$CFG->slasharguments) {
493             $baseurl .= "?token={$token}&file=";
494         } else {
495             $baseurl .= "/{$token}";
496         }
497     }
499     $baseurl .= "/{$contextid}/{$component}/{$filearea}/";
501     if ($itemid !== null) {
502         $baseurl .= "$itemid/";
503     }
505     if ($options['forcehttps']) {
506         $baseurl = str_replace('http://', 'https://', $baseurl);
507     }
509     if (!empty($options['reverse'])) {
510         return str_replace($baseurl, '@@PLUGINFILE@@/', $text);
511     } else {
512         return str_replace('@@PLUGINFILE@@/', $baseurl, $text);
513     }
516 /**
517  * Returns information about files in a draft area.
518  *
519  * @global stdClass $CFG
520  * @global stdClass $USER
521  * @param int $draftitemid the draft area item id.
522  * @param string $filepath path to the directory from which the information have to be retrieved.
523  * @return array with the following entries:
524  *      'filecount' => number of files in the draft area.
525  *      'filesize' => total size of the files in the draft area.
526  *      'foldercount' => number of folders in the draft area.
527  *      'filesize_without_references' => total size of the area excluding file references.
528  * (more information will be added as needed).
529  */
530 function file_get_draft_area_info($draftitemid, $filepath = '/') {
531     global $USER;
533     $usercontext = context_user::instance($USER->id);
534     return file_get_file_area_info($usercontext->id, 'user', 'draft', $draftitemid, $filepath);
537 /**
538  * Returns information about files in an area.
539  *
540  * @param int $contextid context id
541  * @param string $component component
542  * @param string $filearea file area name
543  * @param int $itemid item id or all files if not specified
544  * @param string $filepath path to the directory from which the information have to be retrieved.
545  * @return array with the following entries:
546  *      'filecount' => number of files in the area.
547  *      'filesize' => total size of the files in the area.
548  *      'foldercount' => number of folders in the area.
549  *      'filesize_without_references' => total size of the area excluding file references.
550  * @since Moodle 3.4
551  */
552 function file_get_file_area_info($contextid, $component, $filearea, $itemid = 0, $filepath = '/') {
554     $fs = get_file_storage();
556     $results = array(
557         'filecount' => 0,
558         'foldercount' => 0,
559         'filesize' => 0,
560         'filesize_without_references' => 0
561     );
563     $draftfiles = $fs->get_directory_files($contextid, $component, $filearea, $itemid, $filepath, true, true);
565     foreach ($draftfiles as $file) {
566         if ($file->is_directory()) {
567             $results['foldercount'] += 1;
568         } else {
569             $results['filecount'] += 1;
570         }
572         $filesize = $file->get_filesize();
573         $results['filesize'] += $filesize;
574         if (!$file->is_external_file()) {
575             $results['filesize_without_references'] += $filesize;
576         }
577     }
579     return $results;
582 /**
583  * Returns whether a draft area has exceeded/will exceed its size limit.
584  *
585  * Please note that the unlimited value for $areamaxbytes is -1 {@link FILE_AREA_MAX_BYTES_UNLIMITED}, not 0.
586  *
587  * @param int $draftitemid the draft area item id.
588  * @param int $areamaxbytes the maximum size allowed in this draft area.
589  * @param int $newfilesize the size that would be added to the current area.
590  * @param bool $includereferences true to include the size of the references in the area size.
591  * @return bool true if the area will/has exceeded its limit.
592  * @since Moodle 2.4
593  */
594 function file_is_draft_area_limit_reached($draftitemid, $areamaxbytes, $newfilesize = 0, $includereferences = false) {
595     if ($areamaxbytes != FILE_AREA_MAX_BYTES_UNLIMITED) {
596         $draftinfo = file_get_draft_area_info($draftitemid);
597         $areasize = $draftinfo['filesize_without_references'];
598         if ($includereferences) {
599             $areasize = $draftinfo['filesize'];
600         }
601         if ($areasize + $newfilesize > $areamaxbytes) {
602             return true;
603         }
604     }
605     return false;
608 /**
609  * Get used space of files
610  * @global moodle_database $DB
611  * @global stdClass $USER
612  * @return int total bytes
613  */
614 function file_get_user_used_space() {
615     global $DB, $USER;
617     $usercontext = context_user::instance($USER->id);
618     $sql = "SELECT SUM(files1.filesize) AS totalbytes FROM {files} files1
619             JOIN (SELECT contenthash, filename, MAX(id) AS id
620             FROM {files}
621             WHERE contextid = ? AND component = ? AND filearea != ?
622             GROUP BY contenthash, filename) files2 ON files1.id = files2.id";
623     $params = array('contextid'=>$usercontext->id, 'component'=>'user', 'filearea'=>'draft');
624     $record = $DB->get_record_sql($sql, $params);
625     return (int)$record->totalbytes;
628 /**
629  * Convert any string to a valid filepath
630  * @todo review this function
631  * @param string $str
632  * @return string path
633  */
634 function file_correct_filepath($str) { //TODO: what is this? (skodak) - No idea (Fred)
635     if ($str == '/' or empty($str)) {
636         return '/';
637     } else {
638         return '/'.trim($str, '/').'/';
639     }
642 /**
643  * Generate a folder tree of draft area of current USER recursively
644  *
645  * @todo MDL-31073 use normal return value instead, this does not fit the rest of api here (skodak)
646  * @param int $draftitemid
647  * @param string $filepath
648  * @param mixed $data
649  */
650 function file_get_drafarea_folders($draftitemid, $filepath, &$data) {
651     global $USER, $OUTPUT, $CFG;
652     $data->children = array();
653     $context = context_user::instance($USER->id);
654     $fs = get_file_storage();
655     if ($files = $fs->get_directory_files($context->id, 'user', 'draft', $draftitemid, $filepath, false)) {
656         foreach ($files as $file) {
657             if ($file->is_directory()) {
658                 $item = new stdClass();
659                 $item->sortorder = $file->get_sortorder();
660                 $item->filepath = $file->get_filepath();
662                 $foldername = explode('/', trim($item->filepath, '/'));
663                 $item->fullname = trim(array_pop($foldername), '/');
665                 $item->id = uniqid();
666                 file_get_drafarea_folders($draftitemid, $item->filepath, $item);
667                 $data->children[] = $item;
668             } else {
669                 continue;
670             }
671         }
672     }
675 /**
676  * Listing all files (including folders) in current path (draft area)
677  * used by file manager
678  * @param int $draftitemid
679  * @param string $filepath
680  * @return stdClass
681  */
682 function file_get_drafarea_files($draftitemid, $filepath = '/') {
683     global $USER, $OUTPUT, $CFG;
685     $context = context_user::instance($USER->id);
686     $fs = get_file_storage();
688     $data = new stdClass();
689     $data->path = array();
690     $data->path[] = array('name'=>get_string('files'), 'path'=>'/');
692     // will be used to build breadcrumb
693     $trail = '/';
694     if ($filepath !== '/') {
695         $filepath = file_correct_filepath($filepath);
696         $parts = explode('/', $filepath);
697         foreach ($parts as $part) {
698             if ($part != '' && $part != null) {
699                 $trail .= ($part.'/');
700                 $data->path[] = array('name'=>$part, 'path'=>$trail);
701             }
702         }
703     }
705     $list = array();
706     $maxlength = 12;
707     if ($files = $fs->get_directory_files($context->id, 'user', 'draft', $draftitemid, $filepath, false)) {
708         foreach ($files as $file) {
709             $item = new stdClass();
710             $item->filename = $file->get_filename();
711             $item->filepath = $file->get_filepath();
712             $item->fullname = trim($item->filename, '/');
713             $filesize = $file->get_filesize();
714             $item->size = $filesize ? $filesize : null;
715             $item->filesize = $filesize ? display_size($filesize) : '';
717             $item->sortorder = $file->get_sortorder();
718             $item->author = $file->get_author();
719             $item->license = $file->get_license();
720             $item->datemodified = $file->get_timemodified();
721             $item->datecreated = $file->get_timecreated();
722             $item->isref = $file->is_external_file();
723             if ($item->isref && $file->get_status() == 666) {
724                 $item->originalmissing = true;
725             }
726             // find the file this draft file was created from and count all references in local
727             // system pointing to that file
728             $source = @unserialize($file->get_source());
729             if (isset($source->original)) {
730                 $item->refcount = $fs->search_references_count($source->original);
731             }
733             if ($file->is_directory()) {
734                 $item->filesize = 0;
735                 $item->icon = $OUTPUT->image_url(file_folder_icon(24))->out(false);
736                 $item->type = 'folder';
737                 $foldername = explode('/', trim($item->filepath, '/'));
738                 $item->fullname = trim(array_pop($foldername), '/');
739                 $item->thumbnail = $OUTPUT->image_url(file_folder_icon(90))->out(false);
740             } else {
741                 // do NOT use file browser here!
742                 $item->mimetype = get_mimetype_description($file);
743                 if (file_extension_in_typegroup($file->get_filename(), 'archive')) {
744                     $item->type = 'zip';
745                 } else {
746                     $item->type = 'file';
747                 }
748                 $itemurl = moodle_url::make_draftfile_url($draftitemid, $item->filepath, $item->filename);
749                 $item->url = $itemurl->out();
750                 $item->icon = $OUTPUT->image_url(file_file_icon($file, 24))->out(false);
751                 $item->thumbnail = $OUTPUT->image_url(file_file_icon($file, 90))->out(false);
753                 // The call to $file->get_imageinfo() fails with an exception if the file can't be read on the file system.
754                 // We still want to add such files to the list, so the owner can view and delete them if needed. So, we only call
755                 // get_imageinfo() on files that can be read, and we also spoof the file status based on whether it was found.
756                 // We'll use the same status types used by stored_file->get_status(), where 0 = OK. 1 = problem, as these will be
757                 // used by the widget to display a warning about the problem files.
758                 // The value of stored_file->get_status(), and the file record are unaffected by this. It's only superficially set.
759                 $item->status = $fs->get_file_system()->is_file_readable_remotely_by_storedfile($file) ? 0 : 1;
760                 if ($item->status == 0) {
761                     if ($imageinfo = $file->get_imageinfo()) {
762                         $item->realthumbnail = $itemurl->out(false, array('preview' => 'thumb',
763                             'oid' => $file->get_timemodified()));
764                         $item->realicon = $itemurl->out(false, array('preview' => 'tinyicon', 'oid' => $file->get_timemodified()));
765                         $item->image_width = $imageinfo['width'];
766                         $item->image_height = $imageinfo['height'];
767                     }
768                 }
769             }
770             $list[] = $item;
771         }
772     }
773     $data->itemid = $draftitemid;
774     $data->list = $list;
775     return $data;
778 /**
779  * Returns all of the files in the draftarea.
780  *
781  * @param  int $draftitemid The draft item ID
782  * @param  string $filepath path for the uploaded files.
783  * @return array An array of files associated with this draft item id.
784  */
785 function file_get_all_files_in_draftarea(int $draftitemid, string $filepath = '/') : array {
786     $files = [];
787     $draftfiles = file_get_drafarea_files($draftitemid, $filepath);
788     file_get_drafarea_folders($draftitemid, $filepath, $draftfiles);
790     if (!empty($draftfiles)) {
791         foreach ($draftfiles->list as $draftfile) {
792             if ($draftfile->type == 'file') {
793                 $files[] = $draftfile;
794             }
795         }
797         if (isset($draftfiles->children)) {
798             foreach ($draftfiles->children as $draftfile) {
799                 $files = array_merge($files, file_get_all_files_in_draftarea($draftitemid, $draftfile->filepath));
800             }
801         }
802     }
803     return $files;
806 /**
807  * Returns draft area itemid for a given element.
808  *
809  * @category files
810  * @param string $elname name of formlib editor element, or a hidden form field that stores the draft area item id, etc.
811  * @return int the itemid, or 0 if there is not one yet.
812  */
813 function file_get_submitted_draft_itemid($elname) {
814     // this is a nasty hack, ideally all new elements should use arrays here or there should be a new parameter
815     if (!isset($_REQUEST[$elname])) {
816         return 0;
817     }
818     if (is_array($_REQUEST[$elname])) {
819         $param = optional_param_array($elname, 0, PARAM_INT);
820         if (!empty($param['itemid'])) {
821             $param = $param['itemid'];
822         } else {
823             debugging('Missing itemid, maybe caused by unset maxfiles option', DEBUG_DEVELOPER);
824             return false;
825         }
827     } else {
828         $param = optional_param($elname, 0, PARAM_INT);
829     }
831     if ($param) {
832         require_sesskey();
833     }
835     return $param;
838 /**
839  * Restore the original source field from draft files
840  *
841  * Do not use this function because it makes field files.source inconsistent
842  * for draft area files. This function will be deprecated in 2.6
843  *
844  * @param stored_file $storedfile This only works with draft files
845  * @return stored_file
846  */
847 function file_restore_source_field_from_draft_file($storedfile) {
848     $source = @unserialize($storedfile->get_source());
849     if (!empty($source)) {
850         if (is_object($source)) {
851             $restoredsource = $source->source;
852             $storedfile->set_source($restoredsource);
853         } else {
854             throw new moodle_exception('invalidsourcefield', 'error');
855         }
856     }
857     return $storedfile;
860 /**
861  * Removes those files from the user drafts filearea which are not referenced in the editor text.
862  *
863  * @param stdClass $editor The online text editor element from the submitted form data.
864  */
865 function file_remove_editor_orphaned_files($editor) {
866     global $CFG, $USER;
868     // Find those draft files included in the text, and generate their hashes.
869     $context = context_user::instance($USER->id);
870     $baseurl = $CFG->wwwroot . '/draftfile.php/' . $context->id . '/user/draft/' . $editor['itemid'] . '/';
871     $pattern = "/" . preg_quote($baseurl, '/') . "(.+?)[\?\"']/";
872     preg_match_all($pattern, $editor['text'], $matches);
873     $usedfilehashes = [];
874     foreach ($matches[1] as $matchedfilename) {
875         $matchedfilename = urldecode($matchedfilename);
876         $usedfilehashes[] = \file_storage::get_pathname_hash($context->id, 'user', 'draft', $editor['itemid'], '/',
877                                                              $matchedfilename);
878     }
880     // Now, compare the hashes of all draft files, and remove those which don't match used files.
881     $fs = get_file_storage();
882     $files = $fs->get_area_files($context->id, 'user', 'draft', $editor['itemid'], 'id', false);
883     foreach ($files as $file) {
884         $tmphash = $file->get_pathnamehash();
885         if (!in_array($tmphash, $usedfilehashes)) {
886             $file->delete();
887         }
888     }
891 /**
892  * Finds all draft areas used in a textarea and copies the files into the primary textarea. If a user copies and pastes
893  * content from another draft area it's possible for a single textarea to reference multiple draft areas.
894  *
895  * @category files
896  * @param int $draftitemid the id of the primary draft area.
897  *            When set to -1 (probably, by a WebService) it won't process file merging, keeping the original state of the file area.
898  * @param int $usercontextid the user's context id.
899  * @param string $text some html content that needs to have files copied to the correct draft area.
900  * @param bool $forcehttps force https urls.
901  *
902  * @return string $text html content modified with new draft links
903  */
904 function file_merge_draft_areas($draftitemid, $usercontextid, $text, $forcehttps = false) {
905     if (is_null($text)) {
906         return null;
907     }
909     // Do not merge files, leave it as it was.
910     if ($draftitemid === IGNORE_FILE_MERGE) {
911         return null;
912     }
914     $urls = extract_draft_file_urls_from_text($text, $forcehttps, $usercontextid, 'user', 'draft');
916     // No draft areas to rewrite.
917     if (empty($urls)) {
918         return $text;
919     }
921     foreach ($urls as $url) {
922         // Do not process the "home" draft area.
923         if ($url['itemid'] == $draftitemid) {
924             continue;
925         }
927         // Decode the filename.
928         $filename = urldecode($url['filename']);
930         // Copy the file.
931         file_copy_file_to_file_area($url, $filename, $draftitemid);
933         // Rewrite draft area.
934         $text = file_replace_file_area_in_text($url, $draftitemid, $text, $forcehttps);
935     }
936     return $text;
939 /**
940  * Rewrites a file area in arbitrary text.
941  *
942  * @param array $file General information about the file.
943  * @param int $newid The new file area itemid.
944  * @param string $text The text to rewrite.
945  * @param bool $forcehttps force https urls.
946  * @return string The rewritten text.
947  */
948 function file_replace_file_area_in_text($file, $newid, $text, $forcehttps = false) {
949     global $CFG;
951     $wwwroot = $CFG->wwwroot;
952     if ($forcehttps) {
953         $wwwroot = str_replace('http://', 'https://', $wwwroot);
954     }
956     $search = [
957         $wwwroot,
958         $file['urlbase'],
959         $file['contextid'],
960         $file['component'],
961         $file['filearea'],
962         $file['itemid'],
963         $file['filename']
964     ];
965     $replace = [
966         $wwwroot,
967         $file['urlbase'],
968         $file['contextid'],
969         $file['component'],
970         $file['filearea'],
971         $newid,
972         $file['filename']
973     ];
975     $text = str_ireplace( implode('/', $search), implode('/', $replace), $text);
976     return $text;
979 /**
980  * Copies a file from one file area to another.
981  *
982  * @param array $file Information about the file to be copied.
983  * @param string $filename The filename.
984  * @param int $itemid The new file area.
985  */
986 function file_copy_file_to_file_area($file, $filename, $itemid) {
987     $fs = get_file_storage();
989     // Load the current file in the old draft area.
990     $fileinfo = array(
991         'component' => $file['component'],
992         'filearea' => $file['filearea'],
993         'itemid' => $file['itemid'],
994         'contextid' => $file['contextid'],
995         'filepath' => '/',
996         'filename' => $filename
997     );
998     $oldfile = $fs->get_file($fileinfo['contextid'], $fileinfo['component'], $fileinfo['filearea'],
999         $fileinfo['itemid'], $fileinfo['filepath'], $fileinfo['filename']);
1000     $newfileinfo = array(
1001         'component' => $file['component'],
1002         'filearea' => $file['filearea'],
1003         'itemid' => $itemid,
1004         'contextid' => $file['contextid'],
1005         'filepath' => '/',
1006         'filename' => $filename
1007     );
1009     $newcontextid = $newfileinfo['contextid'];
1010     $newcomponent = $newfileinfo['component'];
1011     $newfilearea = $newfileinfo['filearea'];
1012     $newitemid = $newfileinfo['itemid'];
1013     $newfilepath = $newfileinfo['filepath'];
1014     $newfilename = $newfileinfo['filename'];
1016     // Check if the file exists.
1017     if (!$fs->file_exists($newcontextid, $newcomponent, $newfilearea, $newitemid, $newfilepath, $newfilename)) {
1018         $fs->create_file_from_storedfile($newfileinfo, $oldfile);
1019     }
1022 /**
1023  * Saves files from a draft file area to a real one (merging the list of files).
1024  * Can rewrite URLs in some content at the same time if desired.
1025  *
1026  * @category files
1027  * @global stdClass $USER
1028  * @param int $draftitemid the id of the draft area to use. Normally obtained
1029  *      from file_get_submitted_draft_itemid('elementname') or similar.
1030  *      When set to -1 (probably, by a WebService) it won't process file merging, keeping the original state of the file area.
1031  * @param int $contextid This parameter and the next two identify the file area to save to.
1032  * @param string $component
1033  * @param string $filearea indentifies the file area.
1034  * @param int $itemid helps identifies the file area.
1035  * @param array $options area options (subdirs=>false, maxfiles=-1, maxbytes=0)
1036  * @param string $text some html content that needs to have embedded links rewritten
1037  *      to the @@PLUGINFILE@@ form for saving in the database.
1038  * @param bool $forcehttps force https urls.
1039  * @return string|null if $text was passed in, the rewritten $text is returned. Otherwise NULL.
1040  */
1041 function file_save_draft_area_files($draftitemid, $contextid, $component, $filearea, $itemid, array $options=null, $text=null, $forcehttps=false) {
1042     global $USER;
1044     // Do not merge files, leave it as it was.
1045     if ($draftitemid === IGNORE_FILE_MERGE) {
1046         return null;
1047     }
1049     $usercontext = context_user::instance($USER->id);
1050     $fs = get_file_storage();
1052     $options = (array)$options;
1053     if (!isset($options['subdirs'])) {
1054         $options['subdirs'] = false;
1055     }
1056     if (!isset($options['maxfiles'])) {
1057         $options['maxfiles'] = -1; // unlimited
1058     }
1059     if (!isset($options['maxbytes']) || $options['maxbytes'] == USER_CAN_IGNORE_FILE_SIZE_LIMITS) {
1060         $options['maxbytes'] = 0; // unlimited
1061     }
1062     if (!isset($options['areamaxbytes'])) {
1063         $options['areamaxbytes'] = FILE_AREA_MAX_BYTES_UNLIMITED; // Unlimited.
1064     }
1065     $allowreferences = true;
1066     if (isset($options['return_types']) && !($options['return_types'] & (FILE_REFERENCE | FILE_CONTROLLED_LINK))) {
1067         // we assume that if $options['return_types'] is NOT specified, we DO allow references.
1068         // this is not exactly right. BUT there are many places in code where filemanager options
1069         // are not passed to file_save_draft_area_files()
1070         $allowreferences = false;
1071     }
1073     // Check if the user has copy-pasted from other draft areas. Those files will be located in different draft
1074     // areas and need to be copied into the current draft area.
1075     $text = file_merge_draft_areas($draftitemid, $usercontext->id, $text, $forcehttps);
1077     // Check if the draft area has exceeded the authorised limit. This should never happen as validation
1078     // should have taken place before, unless the user is doing something nauthly. If so, let's just not save
1079     // anything at all in the next area.
1080     if (file_is_draft_area_limit_reached($draftitemid, $options['areamaxbytes'])) {
1081         return null;
1082     }
1084     $draftfiles = $fs->get_area_files($usercontext->id, 'user', 'draft', $draftitemid, 'id');
1085     $oldfiles   = $fs->get_area_files($contextid, $component, $filearea, $itemid, 'id');
1087     // One file in filearea means it is empty (it has only top-level directory '.').
1088     if (count($draftfiles) > 1 || count($oldfiles) > 1) {
1089         // we have to merge old and new files - we want to keep file ids for files that were not changed
1090         // we change time modified for all new and changed files, we keep time created as is
1092         $newhashes = array();
1093         $filecount = 0;
1094         $context = context::instance_by_id($contextid, MUST_EXIST);
1095         foreach ($draftfiles as $file) {
1096             if (!$options['subdirs'] && $file->get_filepath() !== '/') {
1097                 continue;
1098             }
1099             if (!$allowreferences && $file->is_external_file()) {
1100                 continue;
1101             }
1102             if (!$file->is_directory()) {
1103                 // Check to see if this file was uploaded by someone who can ignore the file size limits.
1104                 $fileusermaxbytes = get_user_max_upload_file_size($context, $options['maxbytes'], 0, 0, $file->get_userid());
1105                 if ($fileusermaxbytes != USER_CAN_IGNORE_FILE_SIZE_LIMITS
1106                         && ($options['maxbytes'] and $options['maxbytes'] < $file->get_filesize())) {
1107                     // Oversized file.
1108                     continue;
1109                 }
1110                 if ($options['maxfiles'] != -1 and $options['maxfiles'] <= $filecount) {
1111                     // more files - should not get here at all
1112                     continue;
1113                 }
1114                 $filecount++;
1115             }
1116             $newhash = $fs->get_pathname_hash($contextid, $component, $filearea, $itemid, $file->get_filepath(), $file->get_filename());
1117             $newhashes[$newhash] = $file;
1118         }
1120         // Loop through oldfiles and decide which we need to delete and which to update.
1121         // After this cycle the array $newhashes will only contain the files that need to be added.
1122         foreach ($oldfiles as $oldfile) {
1123             $oldhash = $oldfile->get_pathnamehash();
1124             if (!isset($newhashes[$oldhash])) {
1125                 // delete files not needed any more - deleted by user
1126                 $oldfile->delete();
1127                 continue;
1128             }
1130             $newfile = $newhashes[$oldhash];
1131             // Now we know that we have $oldfile and $newfile for the same path.
1132             // Let's check if we can update this file or we need to delete and create.
1133             if ($newfile->is_directory()) {
1134                 // Directories are always ok to just update.
1135             } else if (($source = @unserialize($newfile->get_source())) && isset($source->original)) {
1136                 // File has the 'original' - we need to update the file (it may even have not been changed at all).
1137                 $original = file_storage::unpack_reference($source->original);
1138                 if ($original['filename'] !== $oldfile->get_filename() || $original['filepath'] !== $oldfile->get_filepath()) {
1139                     // Very odd, original points to another file. Delete and create file.
1140                     $oldfile->delete();
1141                     continue;
1142                 }
1143             } else {
1144                 // The same file name but absence of 'original' means that file was deteled and uploaded again.
1145                 // By deleting and creating new file we properly manage all existing references.
1146                 $oldfile->delete();
1147                 continue;
1148             }
1150             // status changed, we delete old file, and create a new one
1151             if ($oldfile->get_status() != $newfile->get_status()) {
1152                 // file was changed, use updated with new timemodified data
1153                 $oldfile->delete();
1154                 // This file will be added later
1155                 continue;
1156             }
1158             // Updated author
1159             if ($oldfile->get_author() != $newfile->get_author()) {
1160                 $oldfile->set_author($newfile->get_author());
1161             }
1162             // Updated license
1163             if ($oldfile->get_license() != $newfile->get_license()) {
1164                 $oldfile->set_license($newfile->get_license());
1165             }
1167             // Updated file source
1168             // Field files.source for draftarea files contains serialised object with source and original information.
1169             // We only store the source part of it for non-draft file area.
1170             $newsource = $newfile->get_source();
1171             if ($source = @unserialize($newfile->get_source())) {
1172                 $newsource = $source->source;
1173             }
1174             if ($oldfile->get_source() !== $newsource) {
1175                 $oldfile->set_source($newsource);
1176             }
1178             // Updated sort order
1179             if ($oldfile->get_sortorder() != $newfile->get_sortorder()) {
1180                 $oldfile->set_sortorder($newfile->get_sortorder());
1181             }
1183             // Update file timemodified
1184             if ($oldfile->get_timemodified() != $newfile->get_timemodified()) {
1185                 $oldfile->set_timemodified($newfile->get_timemodified());
1186             }
1188             // Replaced file content
1189             if (!$oldfile->is_directory() &&
1190                     ($oldfile->get_contenthash() != $newfile->get_contenthash() ||
1191                     $oldfile->get_filesize() != $newfile->get_filesize() ||
1192                     $oldfile->get_referencefileid() != $newfile->get_referencefileid() ||
1193                     $oldfile->get_userid() != $newfile->get_userid())) {
1194                 $oldfile->replace_file_with($newfile);
1195             }
1197             // unchanged file or directory - we keep it as is
1198             unset($newhashes[$oldhash]);
1199         }
1201         // Add fresh file or the file which has changed status
1202         // the size and subdirectory tests are extra safety only, the UI should prevent it
1203         foreach ($newhashes as $file) {
1204             $file_record = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea, 'itemid'=>$itemid, 'timemodified'=>time());
1205             if ($source = @unserialize($file->get_source())) {
1206                 // Field files.source for draftarea files contains serialised object with source and original information.
1207                 // We only store the source part of it for non-draft file area.
1208                 $file_record['source'] = $source->source;
1209             }
1211             if ($file->is_external_file()) {
1212                 $repoid = $file->get_repository_id();
1213                 if (!empty($repoid)) {
1214                     $context = context::instance_by_id($contextid, MUST_EXIST);
1215                     $repo = repository::get_repository_by_id($repoid, $context);
1216                     if (!empty($options)) {
1217                         $repo->options = $options;
1218                     }
1219                     $file_record['repositoryid'] = $repoid;
1220                     // This hook gives the repo a place to do some house cleaning, and update the $reference before it's saved
1221                     // to the file store. E.g. transfer ownership of the file to a system account etc.
1222                     $reference = $repo->reference_file_selected($file->get_reference(), $context, $component, $filearea, $itemid);
1224                     $file_record['reference'] = $reference;
1225                 }
1226             }
1228             $fs->create_file_from_storedfile($file_record, $file);
1229         }
1230     }
1232     // note: do not purge the draft area - we clean up areas later in cron,
1233     //       the reason is that user might press submit twice and they would loose the files,
1234     //       also sometimes we might want to use hacks that save files into two different areas
1236     if (is_null($text)) {
1237         return null;
1238     } else {
1239         return file_rewrite_urls_to_pluginfile($text, $draftitemid, $forcehttps);
1240     }
1243 /**
1244  * Convert the draft file area URLs in some content to @@PLUGINFILE@@ tokens
1245  * ready to be saved in the database. Normally, this is done automatically by
1246  * {@link file_save_draft_area_files()}.
1247  *
1248  * @category files
1249  * @param string $text the content to process.
1250  * @param int $draftitemid the draft file area the content was using.
1251  * @param bool $forcehttps whether the content contains https URLs. Default false.
1252  * @return string the processed content.
1253  */
1254 function file_rewrite_urls_to_pluginfile($text, $draftitemid, $forcehttps = false) {
1255     global $CFG, $USER;
1257     $usercontext = context_user::instance($USER->id);
1259     $wwwroot = $CFG->wwwroot;
1260     if ($forcehttps) {
1261         $wwwroot = str_replace('http://', 'https://', $wwwroot);
1262     }
1264     // relink embedded files if text submitted - no absolute links allowed in database!
1265     $text = str_ireplace("$wwwroot/draftfile.php/$usercontext->id/user/draft/$draftitemid/", '@@PLUGINFILE@@/', $text);
1267     if (strpos($text, 'draftfile.php?file=') !== false) {
1268         $matches = array();
1269         preg_match_all("!$wwwroot/draftfile.php\?file=%2F{$usercontext->id}%2Fuser%2Fdraft%2F{$draftitemid}%2F[^'\",&<>|`\s:\\\\]+!iu", $text, $matches);
1270         if ($matches) {
1271             foreach ($matches[0] as $match) {
1272                 $replace = str_ireplace('%2F', '/', $match);
1273                 $text = str_replace($match, $replace, $text);
1274             }
1275         }
1276         $text = str_ireplace("$wwwroot/draftfile.php?file=/$usercontext->id/user/draft/$draftitemid/", '@@PLUGINFILE@@/', $text);
1277     }
1279     return $text;
1282 /**
1283  * Set file sort order
1284  *
1285  * @global moodle_database $DB
1286  * @param int $contextid the context id
1287  * @param string $component file component
1288  * @param string $filearea file area.
1289  * @param int $itemid itemid.
1290  * @param string $filepath file path.
1291  * @param string $filename file name.
1292  * @param int $sortorder the sort order of file.
1293  * @return bool
1294  */
1295 function file_set_sortorder($contextid, $component, $filearea, $itemid, $filepath, $filename, $sortorder) {
1296     global $DB;
1297     $conditions = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea, 'itemid'=>$itemid, 'filepath'=>$filepath, 'filename'=>$filename);
1298     if ($file_record = $DB->get_record('files', $conditions)) {
1299         $sortorder = (int)$sortorder;
1300         $file_record->sortorder = $sortorder;
1301         $DB->update_record('files', $file_record);
1302         return true;
1303     }
1304     return false;
1307 /**
1308  * reset file sort order number to 0
1309  * @global moodle_database $DB
1310  * @param int $contextid the context id
1311  * @param string $component
1312  * @param string $filearea file area.
1313  * @param int|bool $itemid itemid.
1314  * @return bool
1315  */
1316 function file_reset_sortorder($contextid, $component, $filearea, $itemid=false) {
1317     global $DB;
1319     $conditions = array('contextid'=>$contextid, 'component'=>$component, 'filearea'=>$filearea);
1320     if ($itemid !== false) {
1321         $conditions['itemid'] = $itemid;
1322     }
1324     $file_records = $DB->get_records('files', $conditions);
1325     foreach ($file_records as $file_record) {
1326         $file_record->sortorder = 0;
1327         $DB->update_record('files', $file_record);
1328     }
1329     return true;
1332 /**
1333  * Returns description of upload error
1334  *
1335  * @param int $errorcode found in $_FILES['filename.ext']['error']
1336  * @return string error description string, '' if ok
1337  */
1338 function file_get_upload_error($errorcode) {
1340     switch ($errorcode) {
1341     case 0: // UPLOAD_ERR_OK - no error
1342         $errmessage = '';
1343         break;
1345     case 1: // UPLOAD_ERR_INI_SIZE
1346         $errmessage = get_string('uploadserverlimit');
1347         break;
1349     case 2: // UPLOAD_ERR_FORM_SIZE
1350         $errmessage = get_string('uploadformlimit');
1351         break;
1353     case 3: // UPLOAD_ERR_PARTIAL
1354         $errmessage = get_string('uploadpartialfile');
1355         break;
1357     case 4: // UPLOAD_ERR_NO_FILE
1358         $errmessage = get_string('uploadnofilefound');
1359         break;
1361     // Note: there is no error with a value of 5
1363     case 6: // UPLOAD_ERR_NO_TMP_DIR
1364         $errmessage = get_string('uploadnotempdir');
1365         break;
1367     case 7: // UPLOAD_ERR_CANT_WRITE
1368         $errmessage = get_string('uploadcantwrite');
1369         break;
1371     case 8: // UPLOAD_ERR_EXTENSION
1372         $errmessage = get_string('uploadextension');
1373         break;
1375     default:
1376         $errmessage = get_string('uploadproblem');
1377     }
1379     return $errmessage;
1382 /**
1383  * Recursive function formating an array in POST parameter
1384  * @param array $arraydata - the array that we are going to format and add into &$data array
1385  * @param string $currentdata - a row of the final postdata array at instant T
1386  *                when finish, it's assign to $data under this format: name[keyname][][]...[]='value'
1387  * @param array $data - the final data array containing all POST parameters : 1 row = 1 parameter
1388  */
1389 function format_array_postdata_for_curlcall($arraydata, $currentdata, &$data) {
1390         foreach ($arraydata as $k=>$v) {
1391             $newcurrentdata = $currentdata;
1392             if (is_array($v)) { //the value is an array, call the function recursively
1393                 $newcurrentdata = $newcurrentdata.'['.urlencode($k).']';
1394                 format_array_postdata_for_curlcall($v, $newcurrentdata, $data);
1395             }  else { //add the POST parameter to the $data array
1396                 $data[] = $newcurrentdata.'['.urlencode($k).']='.urlencode($v);
1397             }
1398         }
1401 /**
1402  * Transform a PHP array into POST parameter
1403  * (see the recursive function format_array_postdata_for_curlcall)
1404  * @param array $postdata
1405  * @return array containing all POST parameters  (1 row = 1 POST parameter)
1406  */
1407 function format_postdata_for_curlcall($postdata) {
1408         $data = array();
1409         foreach ($postdata as $k=>$v) {
1410             if (is_array($v)) {
1411                 $currentdata = urlencode($k);
1412                 format_array_postdata_for_curlcall($v, $currentdata, $data);
1413             }  else {
1414                 $data[] = urlencode($k).'='.urlencode($v);
1415             }
1416         }
1417         $convertedpostdata = implode('&', $data);
1418         return $convertedpostdata;
1421 /**
1422  * Fetches content of file from Internet (using proxy if defined). Uses cURL extension if present.
1423  * Due to security concerns only downloads from http(s) sources are supported.
1424  *
1425  * @category files
1426  * @param string $url file url starting with http(s)://
1427  * @param array $headers http headers, null if none. If set, should be an
1428  *   associative array of header name => value pairs.
1429  * @param array $postdata array means use POST request with given parameters
1430  * @param bool $fullresponse return headers, responses, etc in a similar way snoopy does
1431  *   (if false, just returns content)
1432  * @param int $timeout timeout for complete download process including all file transfer
1433  *   (default 5 minutes)
1434  * @param int $connecttimeout timeout for connection to server; this is the timeout that
1435  *   usually happens if the remote server is completely down (default 20 seconds);
1436  *   may not work when using proxy
1437  * @param bool $skipcertverify If true, the peer's SSL certificate will not be checked.
1438  *   Only use this when already in a trusted location.
1439  * @param string $tofile store the downloaded content to file instead of returning it.
1440  * @param bool $calctimeout false by default, true enables an extra head request to try and determine
1441  *   filesize and appropriately larger timeout based on $CFG->curltimeoutkbitrate
1442  * @return stdClass|string|bool stdClass object if $fullresponse is true, false if request failed, true
1443  *   if file downloaded into $tofile successfully or the file content as a string.
1444  */
1445 function download_file_content($url, $headers=null, $postdata=null, $fullresponse=false, $timeout=300, $connecttimeout=20, $skipcertverify=false, $tofile=NULL, $calctimeout=false) {
1446     global $CFG;
1448     // Only http and https links supported.
1449     if (!preg_match('|^https?://|i', $url)) {
1450         if ($fullresponse) {
1451             $response = new stdClass();
1452             $response->status        = 0;
1453             $response->headers       = array();
1454             $response->response_code = 'Invalid protocol specified in url';
1455             $response->results       = '';
1456             $response->error         = 'Invalid protocol specified in url';
1457             return $response;
1458         } else {
1459             return false;
1460         }
1461     }
1463     $options = array();
1465     $headers2 = array();
1466     if (is_array($headers)) {
1467         foreach ($headers as $key => $value) {
1468             if (is_numeric($key)) {
1469                 $headers2[] = $value;
1470             } else {
1471                 $headers2[] = "$key: $value";
1472             }
1473         }
1474     }
1476     if ($skipcertverify) {
1477         $options['CURLOPT_SSL_VERIFYPEER'] = false;
1478     } else {
1479         $options['CURLOPT_SSL_VERIFYPEER'] = true;
1480     }
1482     $options['CURLOPT_CONNECTTIMEOUT'] = $connecttimeout;
1484     $options['CURLOPT_FOLLOWLOCATION'] = 1;
1485     $options['CURLOPT_MAXREDIRS'] = 5;
1487     // Use POST if requested.
1488     if (is_array($postdata)) {
1489         $postdata = format_postdata_for_curlcall($postdata);
1490     } else if (empty($postdata)) {
1491         $postdata = null;
1492     }
1494     // Optionally attempt to get more correct timeout by fetching the file size.
1495     if (!isset($CFG->curltimeoutkbitrate)) {
1496         // Use very slow rate of 56kbps as a timeout speed when not set.
1497         $bitrate = 56;
1498     } else {
1499         $bitrate = $CFG->curltimeoutkbitrate;
1500     }
1501     if ($calctimeout and !isset($postdata)) {
1502         $curl = new curl();
1503         $curl->setHeader($headers2);
1505         $curl->head($url, $postdata, $options);
1507         $info = $curl->get_info();
1508         $error_no = $curl->get_errno();
1509         if (!$error_no && $info['download_content_length'] > 0) {
1510             // No curl errors - adjust for large files only - take max timeout.
1511             $timeout = max($timeout, ceil($info['download_content_length'] * 8 / ($bitrate * 1024)));
1512         }
1513     }
1515     $curl = new curl();
1516     $curl->setHeader($headers2);
1518     $options['CURLOPT_RETURNTRANSFER'] = true;
1519     $options['CURLOPT_NOBODY'] = false;
1520     $options['CURLOPT_TIMEOUT'] = $timeout;
1522     if ($tofile) {
1523         $fh = fopen($tofile, 'w');
1524         if (!$fh) {
1525             if ($fullresponse) {
1526                 $response = new stdClass();
1527                 $response->status        = 0;
1528                 $response->headers       = array();
1529                 $response->response_code = 'Can not write to file';
1530                 $response->results       = false;
1531                 $response->error         = 'Can not write to file';
1532                 return $response;
1533             } else {
1534                 return false;
1535             }
1536         }
1537         $options['CURLOPT_FILE'] = $fh;
1538     }
1540     if (isset($postdata)) {
1541         $content = $curl->post($url, $postdata, $options);
1542     } else {
1543         $content = $curl->get($url, null, $options);
1544     }
1546     if ($tofile) {
1547         fclose($fh);
1548         @chmod($tofile, $CFG->filepermissions);
1549     }
1551 /*
1552     // Try to detect encoding problems.
1553     if ((curl_errno($ch) == 23 or curl_errno($ch) == 61) and defined('CURLOPT_ENCODING')) {
1554         curl_setopt($ch, CURLOPT_ENCODING, 'none');
1555         $result = curl_exec($ch);
1556     }
1557 */
1559     $info       = $curl->get_info();
1560     $error_no   = $curl->get_errno();
1561     $rawheaders = $curl->get_raw_response();
1563     if ($error_no) {
1564         $error = $content;
1565         if (!$fullresponse) {
1566             debugging("cURL request for \"$url\" failed with: $error ($error_no)", DEBUG_ALL);
1567             return false;
1568         }
1570         $response = new stdClass();
1571         if ($error_no == 28) {
1572             $response->status    = '-100'; // Mimic snoopy.
1573         } else {
1574             $response->status    = '0';
1575         }
1576         $response->headers       = array();
1577         $response->response_code = $error;
1578         $response->results       = false;
1579         $response->error         = $error;
1580         return $response;
1581     }
1583     if ($tofile) {
1584         $content = true;
1585     }
1587     if (empty($info['http_code'])) {
1588         // For security reasons we support only true http connections (Location: file:// exploit prevention).
1589         $response = new stdClass();
1590         $response->status        = '0';
1591         $response->headers       = array();
1592         $response->response_code = 'Unknown cURL error';
1593         $response->results       = false; // do NOT change this, we really want to ignore the result!
1594         $response->error         = 'Unknown cURL error';
1596     } else {
1597         $response = new stdClass();
1598         $response->status        = (string)$info['http_code'];
1599         $response->headers       = $rawheaders;
1600         $response->results       = $content;
1601         $response->error         = '';
1603         // There might be multiple headers on redirect, find the status of the last one.
1604         $firstline = true;
1605         foreach ($rawheaders as $line) {
1606             if ($firstline) {
1607                 $response->response_code = $line;
1608                 $firstline = false;
1609             }
1610             if (trim($line, "\r\n") === '') {
1611                 $firstline = true;
1612             }
1613         }
1614     }
1616     if ($fullresponse) {
1617         return $response;
1618     }
1620     if ($info['http_code'] != 200) {
1621         debugging("cURL request for \"$url\" failed, HTTP response code: ".$response->response_code, DEBUG_ALL);
1622         return false;
1623     }
1624     return $response->results;
1627 /**
1628  * Returns a list of information about file types based on extensions.
1629  *
1630  * The following elements expected in value array for each extension:
1631  * 'type' - mimetype
1632  * 'icon' - location of the icon file. If value is FILENAME, then either pix/f/FILENAME.gif
1633  *     or pix/f/FILENAME.png must be present in moodle and contain 16x16 filetype icon;
1634  *     also files with bigger sizes under names
1635  *     FILENAME-24, FILENAME-32, FILENAME-64, FILENAME-128, FILENAME-256 are recommended.
1636  * 'groups' (optional) - array of filetype groups this filetype extension is part of;
1637  *     commonly used in moodle the following groups:
1638  *       - web_image - image that can be included as <img> in HTML
1639  *       - image - image that we can parse using GD to find it's dimensions, also used for portfolio format
1640  *       - video - file that can be imported as video in text editor
1641  *       - audio - file that can be imported as audio in text editor
1642  *       - archive - we can extract files from this archive
1643  *       - spreadsheet - used for portfolio format
1644  *       - document - used for portfolio format
1645  *       - presentation - used for portfolio format
1646  * 'string' (optional) - the name of the string from lang/en/mimetypes.php that displays
1647  *     human-readable description for this filetype;
1648  *     Function {@link get_mimetype_description()} first looks at the presence of string for
1649  *     particular mimetype (value of 'type'), if not found looks for string specified in 'string'
1650  *     attribute, if not found returns the value of 'type';
1651  * 'defaulticon' (boolean, optional) - used by function {@link file_mimetype_icon()} to find
1652  *     an icon for mimetype. If an entry with 'defaulticon' is not found for a particular mimetype,
1653  *     this function will return first found icon; Especially usefull for types such as 'text/plain'
1654  *
1655  * @category files
1656  * @return array List of information about file types based on extensions.
1657  *   Associative array of extension (lower-case) to associative array
1658  *   from 'element name' to data. Current element names are 'type' and 'icon'.
1659  *   Unknown types should use the 'xxx' entry which includes defaults.
1660  */
1661 function &get_mimetypes_array() {
1662     // Get types from the core_filetypes function, which includes caching.
1663     return core_filetypes::get_types();
1666 /**
1667  * Determine a file's MIME type based on the given filename using the function mimeinfo.
1668  *
1669  * This function retrieves a file's MIME type for a file that will be sent to the user.
1670  * This should only be used for file-sending purposes just like in send_stored_file, send_file, and send_temp_file.
1671  * Should the file's MIME type cannot be determined by mimeinfo, it will return 'application/octet-stream' as a default
1672  * MIME type which should tell the browser "I don't know what type of file this is, so just download it.".
1673  *
1674  * @param string $filename The file's filename.
1675  * @return string The file's MIME type or 'application/octet-stream' if it cannot be determined.
1676  */
1677 function get_mimetype_for_sending($filename = '') {
1678     // Guess the file's MIME type using mimeinfo.
1679     $mimetype = mimeinfo('type', $filename);
1681     // Use octet-stream as fallback if MIME type cannot be determined by mimeinfo.
1682     if (!$mimetype || $mimetype === 'document/unknown') {
1683         $mimetype = 'application/octet-stream';
1684     }
1686     return $mimetype;
1689 /**
1690  * Obtains information about a filetype based on its extension. Will
1691  * use a default if no information is present about that particular
1692  * extension.
1693  *
1694  * @category files
1695  * @param string $element Desired information (usually 'icon'
1696  *   for icon filename or 'type' for MIME type. Can also be
1697  *   'icon24', ...32, 48, 64, 72, 80, 96, 128, 256)
1698  * @param string $filename Filename we're looking up
1699  * @return string Requested piece of information from array
1700  */
1701 function mimeinfo($element, $filename) {
1702     global $CFG;
1703     $mimeinfo = & get_mimetypes_array();
1704     static $iconpostfixes = array(256=>'-256', 128=>'-128', 96=>'-96', 80=>'-80', 72=>'-72', 64=>'-64', 48=>'-48', 32=>'-32', 24=>'-24', 16=>'');
1706     $filetype = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
1707     if (empty($filetype)) {
1708         $filetype = 'xxx'; // file without extension
1709     }
1710     if (preg_match('/^icon(\d*)$/', $element, $iconsizematch)) {
1711         $iconsize = max(array(16, (int)$iconsizematch[1]));
1712         $filenames = array($mimeinfo['xxx']['icon']);
1713         if ($filetype != 'xxx' && isset($mimeinfo[$filetype]['icon'])) {
1714             array_unshift($filenames, $mimeinfo[$filetype]['icon']);
1715         }
1716         // find the file with the closest size, first search for specific icon then for default icon
1717         foreach ($filenames as $filename) {
1718             foreach ($iconpostfixes as $size => $postfix) {
1719                 $fullname = $CFG->dirroot.'/pix/f/'.$filename.$postfix;
1720                 if ($iconsize >= $size &&
1721                         (file_exists($fullname.'.svg') || file_exists($fullname.'.png') || file_exists($fullname.'.gif'))) {
1722                     return $filename.$postfix;
1723                 }
1724             }
1725         }
1726     } else if (isset($mimeinfo[$filetype][$element])) {
1727         return $mimeinfo[$filetype][$element];
1728     } else if (isset($mimeinfo['xxx'][$element])) {
1729         return $mimeinfo['xxx'][$element];   // By default
1730     } else {
1731         return null;
1732     }
1735 /**
1736  * Obtains information about a filetype based on the MIME type rather than
1737  * the other way around.
1738  *
1739  * @category files
1740  * @param string $element Desired information ('extension', 'icon', 'icon-24', etc.)
1741  * @param string $mimetype MIME type we're looking up
1742  * @return string Requested piece of information from array
1743  */
1744 function mimeinfo_from_type($element, $mimetype) {
1745     /* array of cached mimetype->extension associations */
1746     static $cached = array();
1747     $mimeinfo = & get_mimetypes_array();
1749     if (!array_key_exists($mimetype, $cached)) {
1750         $cached[$mimetype] = null;
1751         foreach($mimeinfo as $filetype => $values) {
1752             if ($values['type'] == $mimetype) {
1753                 if ($cached[$mimetype] === null) {
1754                     $cached[$mimetype] = '.'.$filetype;
1755                 }
1756                 if (!empty($values['defaulticon'])) {
1757                     $cached[$mimetype] = '.'.$filetype;
1758                     break;
1759                 }
1760             }
1761         }
1762         if (empty($cached[$mimetype])) {
1763             $cached[$mimetype] = '.xxx';
1764         }
1765     }
1766     if ($element === 'extension') {
1767         return $cached[$mimetype];
1768     } else {
1769         return mimeinfo($element, $cached[$mimetype]);
1770     }
1773 /**
1774  * Return the relative icon path for a given file
1775  *
1776  * Usage:
1777  * <code>
1778  * // $file - instance of stored_file or file_info
1779  * $icon = $OUTPUT->image_url(file_file_icon($file))->out();
1780  * echo html_writer::empty_tag('img', array('src' => $icon, 'alt' => get_mimetype_description($file)));
1781  * </code>
1782  * or
1783  * <code>
1784  * echo $OUTPUT->pix_icon(file_file_icon($file), get_mimetype_description($file));
1785  * </code>
1786  *
1787  * @param stored_file|file_info|stdClass|array $file (in case of object attributes $file->filename
1788  *     and $file->mimetype are expected)
1789  * @param int $size The size of the icon. Defaults to 16 can also be 24, 32, 64, 128, 256
1790  * @return string
1791  */
1792 function file_file_icon($file, $size = null) {
1793     if (!is_object($file)) {
1794         $file = (object)$file;
1795     }
1796     if (isset($file->filename)) {
1797         $filename = $file->filename;
1798     } else if (method_exists($file, 'get_filename')) {
1799         $filename = $file->get_filename();
1800     } else if (method_exists($file, 'get_visible_name')) {
1801         $filename = $file->get_visible_name();
1802     } else {
1803         $filename = '';
1804     }
1805     if (isset($file->mimetype)) {
1806         $mimetype = $file->mimetype;
1807     } else if (method_exists($file, 'get_mimetype')) {
1808         $mimetype = $file->get_mimetype();
1809     } else {
1810         $mimetype = '';
1811     }
1812     $mimetypes = &get_mimetypes_array();
1813     if ($filename) {
1814         $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
1815         if ($extension && !empty($mimetypes[$extension])) {
1816             // if file name has known extension, return icon for this extension
1817             return file_extension_icon($filename, $size);
1818         }
1819     }
1820     return file_mimetype_icon($mimetype, $size);
1823 /**
1824  * Return the relative icon path for a folder image
1825  *
1826  * Usage:
1827  * <code>
1828  * $icon = $OUTPUT->image_url(file_folder_icon())->out();
1829  * echo html_writer::empty_tag('img', array('src' => $icon));
1830  * </code>
1831  * or
1832  * <code>
1833  * echo $OUTPUT->pix_icon(file_folder_icon(32), '');
1834  * </code>
1835  *
1836  * @param int $iconsize The size of the icon. Defaults to 16 can also be 24, 32, 48, 64, 72, 80, 96, 128, 256
1837  * @return string
1838  */
1839 function file_folder_icon($iconsize = null) {
1840     global $CFG;
1841     static $iconpostfixes = array(256=>'-256', 128=>'-128', 96=>'-96', 80=>'-80', 72=>'-72', 64=>'-64', 48=>'-48', 32=>'-32', 24=>'-24', 16=>'');
1842     static $cached = array();
1843     $iconsize = max(array(16, (int)$iconsize));
1844     if (!array_key_exists($iconsize, $cached)) {
1845         foreach ($iconpostfixes as $size => $postfix) {
1846             $fullname = $CFG->dirroot.'/pix/f/folder'.$postfix;
1847             if ($iconsize >= $size &&
1848                     (file_exists($fullname.'.svg') || file_exists($fullname.'.png') || file_exists($fullname.'.gif'))) {
1849                 $cached[$iconsize] = 'f/folder'.$postfix;
1850                 break;
1851             }
1852         }
1853     }
1854     return $cached[$iconsize];
1857 /**
1858  * Returns the relative icon path for a given mime type
1859  *
1860  * This function should be used in conjunction with $OUTPUT->image_url to produce
1861  * a return the full path to an icon.
1862  *
1863  * <code>
1864  * $mimetype = 'image/jpg';
1865  * $icon = $OUTPUT->image_url(file_mimetype_icon($mimetype))->out();
1866  * echo html_writer::empty_tag('img', array('src' => $icon, 'alt' => get_mimetype_description($mimetype)));
1867  * </code>
1868  *
1869  * @category files
1870  * @todo MDL-31074 When an $OUTPUT->icon method is available this function should be altered
1871  * to conform with that.
1872  * @param string $mimetype The mimetype to fetch an icon for
1873  * @param int $size The size of the icon. Defaults to 16 can also be 24, 32, 64, 128, 256
1874  * @return string The relative path to the icon
1875  */
1876 function file_mimetype_icon($mimetype, $size = NULL) {
1877     return 'f/'.mimeinfo_from_type('icon'.$size, $mimetype);
1880 /**
1881  * Returns the relative icon path for a given file name
1882  *
1883  * This function should be used in conjunction with $OUTPUT->image_url to produce
1884  * a return the full path to an icon.
1885  *
1886  * <code>
1887  * $filename = '.jpg';
1888  * $icon = $OUTPUT->image_url(file_extension_icon($filename))->out();
1889  * echo html_writer::empty_tag('img', array('src' => $icon, 'alt' => '...'));
1890  * </code>
1891  *
1892  * @todo MDL-31074 When an $OUTPUT->icon method is available this function should be altered
1893  * to conform with that.
1894  * @todo MDL-31074 Implement $size
1895  * @category files
1896  * @param string $filename The filename to get the icon for
1897  * @param int $size The size of the icon. Defaults to 16 can also be 24, 32, 64, 128, 256
1898  * @return string
1899  */
1900 function file_extension_icon($filename, $size = NULL) {
1901     return 'f/'.mimeinfo('icon'.$size, $filename);
1904 /**
1905  * Obtains descriptions for file types (e.g. 'Microsoft Word document') from the
1906  * mimetypes.php language file.
1907  *
1908  * @param mixed $obj - instance of stored_file or file_info or array/stdClass with field
1909  *   'filename' and 'mimetype', or just a string with mimetype (though it is recommended to
1910  *   have filename); In case of array/stdClass the field 'mimetype' is optional.
1911  * @param bool $capitalise If true, capitalises first character of result
1912  * @return string Text description
1913  */
1914 function get_mimetype_description($obj, $capitalise=false) {
1915     $filename = $mimetype = '';
1916     if (is_object($obj) && method_exists($obj, 'get_filename') && method_exists($obj, 'get_mimetype')) {
1917         // this is an instance of stored_file
1918         $mimetype = $obj->get_mimetype();
1919         $filename = $obj->get_filename();
1920     } else if (is_object($obj) && method_exists($obj, 'get_visible_name') && method_exists($obj, 'get_mimetype')) {
1921         // this is an instance of file_info
1922         $mimetype = $obj->get_mimetype();
1923         $filename = $obj->get_visible_name();
1924     } else if (is_array($obj) || is_object ($obj)) {
1925         $obj = (array)$obj;
1926         if (!empty($obj['filename'])) {
1927             $filename = $obj['filename'];
1928         }
1929         if (!empty($obj['mimetype'])) {
1930             $mimetype = $obj['mimetype'];
1931         }
1932     } else {
1933         $mimetype = $obj;
1934     }
1935     $mimetypefromext = mimeinfo('type', $filename);
1936     if (empty($mimetype) || $mimetypefromext !== 'document/unknown') {
1937         // if file has a known extension, overwrite the specified mimetype
1938         $mimetype = $mimetypefromext;
1939     }
1940     $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
1941     if (empty($extension)) {
1942         $mimetypestr = mimeinfo_from_type('string', $mimetype);
1943         $extension = str_replace('.', '', mimeinfo_from_type('extension', $mimetype));
1944     } else {
1945         $mimetypestr = mimeinfo('string', $filename);
1946     }
1947     $chunks = explode('/', $mimetype, 2);
1948     $chunks[] = '';
1949     $attr = array(
1950         'mimetype' => $mimetype,
1951         'ext' => $extension,
1952         'mimetype1' => $chunks[0],
1953         'mimetype2' => $chunks[1],
1954     );
1955     $a = array();
1956     foreach ($attr as $key => $value) {
1957         $a[$key] = $value;
1958         $a[strtoupper($key)] = strtoupper($value);
1959         $a[ucfirst($key)] = ucfirst($value);
1960     }
1962     // MIME types may include + symbol but this is not permitted in string ids.
1963     $safemimetype = str_replace('+', '_', $mimetype);
1964     $safemimetypestr = str_replace('+', '_', $mimetypestr);
1965     $customdescription = mimeinfo('customdescription', $filename);
1966     if ($customdescription) {
1967         // Call format_string on the custom description so that multilang
1968         // filter can be used (if enabled on system context). We use system
1969         // context because it is possible that the page context might not have
1970         // been defined yet.
1971         $result = format_string($customdescription, true,
1972                 array('context' => context_system::instance()));
1973     } else if (get_string_manager()->string_exists($safemimetype, 'mimetypes')) {
1974         $result = get_string($safemimetype, 'mimetypes', (object)$a);
1975     } else if (get_string_manager()->string_exists($safemimetypestr, 'mimetypes')) {
1976         $result = get_string($safemimetypestr, 'mimetypes', (object)$a);
1977     } else if (get_string_manager()->string_exists('default', 'mimetypes')) {
1978         $result = get_string('default', 'mimetypes', (object)$a);
1979     } else {
1980         $result = $mimetype;
1981     }
1982     if ($capitalise) {
1983         $result=ucfirst($result);
1984     }
1985     return $result;
1988 /**
1989  * Returns array of elements of type $element in type group(s)
1990  *
1991  * @param string $element name of the element we are interested in, usually 'type' or 'extension'
1992  * @param string|array $groups one group or array of groups/extensions/mimetypes
1993  * @return array
1994  */
1995 function file_get_typegroup($element, $groups) {
1996     static $cached = array();
1997     if (!is_array($groups)) {
1998         $groups = array($groups);
1999     }
2000     if (!array_key_exists($element, $cached)) {
2001         $cached[$element] = array();
2002     }
2003     $result = array();
2004     foreach ($groups as $group) {
2005         if (!array_key_exists($group, $cached[$element])) {
2006             // retrieive and cache all elements of type $element for group $group
2007             $mimeinfo = & get_mimetypes_array();
2008             $cached[$element][$group] = array();
2009             foreach ($mimeinfo as $extension => $value) {
2010                 $value['extension'] = '.'.$extension;
2011                 if (empty($value[$element])) {
2012                     continue;
2013                 }
2014                 if (($group === '.'.$extension || $group === $value['type'] ||
2015                         (!empty($value['groups']) && in_array($group, $value['groups']))) &&
2016                         !in_array($value[$element], $cached[$element][$group])) {
2017                     $cached[$element][$group][] = $value[$element];
2018                 }
2019             }
2020         }
2021         $result = array_merge($result, $cached[$element][$group]);
2022     }
2023     return array_values(array_unique($result));
2026 /**
2027  * Checks if file with name $filename has one of the extensions in groups $groups
2028  *
2029  * @see get_mimetypes_array()
2030  * @param string $filename name of the file to check
2031  * @param string|array $groups one group or array of groups to check
2032  * @param bool $checktype if true and extension check fails, find the mimetype and check if
2033  * file mimetype is in mimetypes in groups $groups
2034  * @return bool
2035  */
2036 function file_extension_in_typegroup($filename, $groups, $checktype = false) {
2037     $extension = pathinfo($filename, PATHINFO_EXTENSION);
2038     if (!empty($extension) && in_array('.'.strtolower($extension), file_get_typegroup('extension', $groups))) {
2039         return true;
2040     }
2041     return $checktype && file_mimetype_in_typegroup(mimeinfo('type', $filename), $groups);
2044 /**
2045  * Checks if mimetype $mimetype belongs to one of the groups $groups
2046  *
2047  * @see get_mimetypes_array()
2048  * @param string $mimetype
2049  * @param string|array $groups one group or array of groups to check
2050  * @return bool
2051  */
2052 function file_mimetype_in_typegroup($mimetype, $groups) {
2053     return !empty($mimetype) && in_array($mimetype, file_get_typegroup('type', $groups));
2056 /**
2057  * Requested file is not found or not accessible, does not return, terminates script
2058  *
2059  * @global stdClass $CFG
2060  * @global stdClass $COURSE
2061  */
2062 function send_file_not_found() {
2063     global $CFG, $COURSE;
2065     // Allow cross-origin requests only for Web Services.
2066     // This allow to receive requests done by Web Workers or webapps in different domains.
2067     if (WS_SERVER) {
2068         header('Access-Control-Allow-Origin: *');
2069     }
2071     send_header_404();
2072     print_error('filenotfound', 'error', $CFG->wwwroot.'/course/view.php?id='.$COURSE->id); //this is not displayed on IIS??
2074 /**
2075  * Helper function to send correct 404 for server.
2076  */
2077 function send_header_404() {
2078     if (substr(php_sapi_name(), 0, 3) == 'cgi') {
2079         header("Status: 404 Not Found");
2080     } else {
2081         header('HTTP/1.0 404 not found');
2082     }
2085 /**
2086  * The readfile function can fail when files are larger than 2GB (even on 64-bit
2087  * platforms). This wrapper uses readfile for small files and custom code for
2088  * large ones.
2089  *
2090  * @param string $path Path to file
2091  * @param int $filesize Size of file (if left out, will get it automatically)
2092  * @return int|bool Size read (will always be $filesize) or false if failed
2093  */
2094 function readfile_allow_large($path, $filesize = -1) {
2095     // Automatically get size if not specified.
2096     if ($filesize === -1) {
2097         $filesize = filesize($path);
2098     }
2099     if ($filesize <= 2147483647) {
2100         // If the file is up to 2^31 - 1, send it normally using readfile.
2101         return readfile($path);
2102     } else {
2103         // For large files, read and output in 64KB chunks.
2104         $handle = fopen($path, 'r');
2105         if ($handle === false) {
2106             return false;
2107         }
2108         $left = $filesize;
2109         while ($left > 0) {
2110             $size = min($left, 65536);
2111             $buffer = fread($handle, $size);
2112             if ($buffer === false) {
2113                 return false;
2114             }
2115             echo $buffer;
2116             $left -= $size;
2117         }
2118         return $filesize;
2119     }
2122 /**
2123  * Enhanced readfile() with optional acceleration.
2124  * @param string|stored_file $file
2125  * @param string $mimetype
2126  * @param bool $accelerate
2127  * @return void
2128  */
2129 function readfile_accel($file, $mimetype, $accelerate) {
2130     global $CFG;
2132     if ($mimetype === 'text/plain') {
2133         // there is no encoding specified in text files, we need something consistent
2134         header('Content-Type: text/plain; charset=utf-8');
2135     } else {
2136         header('Content-Type: '.$mimetype);
2137     }
2139     $lastmodified = is_object($file) ? $file->get_timemodified() : filemtime($file);
2140     header('Last-Modified: '. gmdate('D, d M Y H:i:s', $lastmodified) .' GMT');
2142     if (is_object($file)) {
2143         header('Etag: "' . $file->get_contenthash() . '"');
2144         if (isset($_SERVER['HTTP_IF_NONE_MATCH']) and trim($_SERVER['HTTP_IF_NONE_MATCH'], '"') === $file->get_contenthash()) {
2145             header('HTTP/1.1 304 Not Modified');
2146             return;
2147         }
2148     }
2150     // if etag present for stored file rely on it exclusively
2151     if (!empty($_SERVER['HTTP_IF_MODIFIED_SINCE']) and (empty($_SERVER['HTTP_IF_NONE_MATCH']) or !is_object($file))) {
2152         // get unixtime of request header; clip extra junk off first
2153         $since = strtotime(preg_replace('/;.*$/', '', $_SERVER["HTTP_IF_MODIFIED_SINCE"]));
2154         if ($since && $since >= $lastmodified) {
2155             header('HTTP/1.1 304 Not Modified');
2156             return;
2157         }
2158     }
2160     if ($accelerate and !empty($CFG->xsendfile)) {
2161         if (empty($CFG->disablebyteserving) and $mimetype !== 'text/plain') {
2162             header('Accept-Ranges: bytes');
2163         } else {
2164             header('Accept-Ranges: none');
2165         }
2167         if (is_object($file)) {
2168             $fs = get_file_storage();
2169             if ($fs->xsendfile($file->get_contenthash())) {
2170                 return;
2171             }
2173         } else {
2174             require_once("$CFG->libdir/xsendfilelib.php");
2175             if (xsendfile($file)) {
2176                 return;
2177             }
2178         }
2179     }
2181     $filesize = is_object($file) ? $file->get_filesize() : filesize($file);
2183     header('Last-Modified: '. gmdate('D, d M Y H:i:s', $lastmodified) .' GMT');
2185     if ($accelerate and empty($CFG->disablebyteserving) and $mimetype !== 'text/plain') {
2186         header('Accept-Ranges: bytes');
2188         if (!empty($_SERVER['HTTP_RANGE']) and strpos($_SERVER['HTTP_RANGE'],'bytes=') !== FALSE) {
2189             // byteserving stuff - for acrobat reader and download accelerators
2190             // see: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
2191             // inspired by: http://www.coneural.org/florian/papers/04_byteserving.php
2192             $ranges = false;
2193             if (preg_match_all('/(\d*)-(\d*)/', $_SERVER['HTTP_RANGE'], $ranges, PREG_SET_ORDER)) {
2194                 foreach ($ranges as $key=>$value) {
2195                     if ($ranges[$key][1] == '') {
2196                         //suffix case
2197                         $ranges[$key][1] = $filesize - $ranges[$key][2];
2198                         $ranges[$key][2] = $filesize - 1;
2199                     } else if ($ranges[$key][2] == '' || $ranges[$key][2] > $filesize - 1) {
2200                         //fix range length
2201                         $ranges[$key][2] = $filesize - 1;
2202                     }
2203                     if ($ranges[$key][2] != '' && $ranges[$key][2] < $ranges[$key][1]) {
2204                         //invalid byte-range ==> ignore header
2205                         $ranges = false;
2206                         break;
2207                     }
2208                     //prepare multipart header
2209                     $ranges[$key][0] =  "\r\n--".BYTESERVING_BOUNDARY."\r\nContent-Type: $mimetype\r\n";
2210                     $ranges[$key][0] .= "Content-Range: bytes {$ranges[$key][1]}-{$ranges[$key][2]}/$filesize\r\n\r\n";
2211                 }
2212             } else {
2213                 $ranges = false;
2214             }
2215             if ($ranges) {
2216                 if (is_object($file)) {
2217                     $handle = $file->get_content_file_handle();
2218                 } else {
2219                     $handle = fopen($file, 'rb');
2220                 }
2221                 byteserving_send_file($handle, $mimetype, $ranges, $filesize);
2222             }
2223         }
2224     } else {
2225         // Do not byteserve
2226         header('Accept-Ranges: none');
2227     }
2229     header('Content-Length: '.$filesize);
2231     if ($filesize > 10000000) {
2232         // for large files try to flush and close all buffers to conserve memory
2233         while(@ob_get_level()) {
2234             if (!@ob_end_flush()) {
2235                 break;
2236             }
2237         }
2238     }
2240     // send the whole file content
2241     if (is_object($file)) {
2242         $file->readfile();
2243     } else {
2244         readfile_allow_large($file, $filesize);
2245     }
2248 /**
2249  * Similar to readfile_accel() but designed for strings.
2250  * @param string $string
2251  * @param string $mimetype
2252  * @param bool $accelerate
2253  * @return void
2254  */
2255 function readstring_accel($string, $mimetype, $accelerate) {
2256     global $CFG;
2258     if ($mimetype === 'text/plain') {
2259         // there is no encoding specified in text files, we need something consistent
2260         header('Content-Type: text/plain; charset=utf-8');
2261     } else {
2262         header('Content-Type: '.$mimetype);
2263     }
2264     header('Last-Modified: '. gmdate('D, d M Y H:i:s', time()) .' GMT');
2265     header('Accept-Ranges: none');
2267     if ($accelerate and !empty($CFG->xsendfile)) {
2268         $fs = get_file_storage();
2269         if ($fs->xsendfile(sha1($string))) {
2270             return;
2271         }
2272     }
2274     header('Content-Length: '.strlen($string));
2275     echo $string;
2278 /**
2279  * Handles the sending of temporary file to user, download is forced.
2280  * File is deleted after abort or successful sending, does not return, script terminated
2281  *
2282  * @param string $path path to file, preferably from moodledata/temp/something; or content of file itself
2283  * @param string $filename proposed file name when saving file
2284  * @param bool $pathisstring If the path is string
2285  */
2286 function send_temp_file($path, $filename, $pathisstring=false) {
2287     global $CFG;
2289     // Guess the file's MIME type.
2290     $mimetype = get_mimetype_for_sending($filename);
2292     // close session - not needed anymore
2293     \core\session\manager::write_close();
2295     if (!$pathisstring) {
2296         if (!file_exists($path)) {
2297             send_header_404();
2298             print_error('filenotfound', 'error', $CFG->wwwroot.'/');
2299         }
2300         // executed after normal finish or abort
2301         core_shutdown_manager::register_function('send_temp_file_finished', array($path));
2302     }
2304     // if user is using IE, urlencode the filename so that multibyte file name will show up correctly on popup
2305     if (core_useragent::is_ie() || core_useragent::is_edge()) {
2306         $filename = urlencode($filename);
2307     }
2309     header('Content-Disposition: attachment; filename="'.$filename.'"');
2310     if (is_https()) { // HTTPS sites - watch out for IE! KB812935 and KB316431.
2311         header('Cache-Control: private, max-age=10, no-transform');
2312         header('Expires: '. gmdate('D, d M Y H:i:s', 0) .' GMT');
2313         header('Pragma: ');
2314     } else { //normal http - prevent caching at all cost
2315         header('Cache-Control: private, must-revalidate, pre-check=0, post-check=0, max-age=0, no-transform');
2316         header('Expires: '. gmdate('D, d M Y H:i:s', 0) .' GMT');
2317         header('Pragma: no-cache');
2318     }
2320     // send the contents - we can not accelerate this because the file will be deleted asap
2321     if ($pathisstring) {
2322         readstring_accel($path, $mimetype, false);
2323     } else {
2324         readfile_accel($path, $mimetype, false);
2325         @unlink($path);
2326     }
2328     die; //no more chars to output
2331 /**
2332  * Internal callback function used by send_temp_file()
2333  *
2334  * @param string $path
2335  */
2336 function send_temp_file_finished($path) {
2337     if (file_exists($path)) {
2338         @unlink($path);
2339     }
2342 /**
2343  * Serve content which is not meant to be cached.
2344  *
2345  * This is only intended to be used for volatile public files, for instance
2346  * when development is enabled, or when caching is not required on a public resource.
2347  *
2348  * @param string $content Raw content.
2349  * @param string $filename The file name.
2350  * @return void
2351  */
2352 function send_content_uncached($content, $filename) {
2353     $mimetype = mimeinfo('type', $filename);
2354     $charset = strpos($mimetype, 'text/') === 0 ? '; charset=utf-8' : '';
2356     header('Content-Disposition: inline; filename="' . $filename . '"');
2357     header('Last-Modified: ' . gmdate('D, d M Y H:i:s', time()) . ' GMT');
2358     header('Expires: ' . gmdate('D, d M Y H:i:s', time() + 2) . ' GMT');
2359     header('Pragma: ');
2360     header('Accept-Ranges: none');
2361     header('Content-Type: ' . $mimetype . $charset);
2362     header('Content-Length: ' . strlen($content));
2364     echo $content;
2365     die();
2368 /**
2369  * Safely save content to a certain path.
2370  *
2371  * This function tries hard to be atomic by first copying the content
2372  * to a separate file, and then moving the file across. It also prevents
2373  * the user to abort a request to prevent half-safed files.
2374  *
2375  * This function is intended to be used when saving some content to cache like
2376  * $CFG->localcachedir. If you're not caching a file you should use the File API.
2377  *
2378  * @param string $content The file content.
2379  * @param string $destination The absolute path of the final file.
2380  * @return void
2381  */
2382 function file_safe_save_content($content, $destination) {
2383     global $CFG;
2385     clearstatcache();
2386     if (!file_exists(dirname($destination))) {
2387         @mkdir(dirname($destination), $CFG->directorypermissions, true);
2388     }
2390     // Prevent serving of incomplete file from concurrent request,
2391     // the rename() should be more atomic than fwrite().
2392     ignore_user_abort(true);
2393     if ($fp = fopen($destination . '.tmp', 'xb')) {
2394         fwrite($fp, $content);
2395         fclose($fp);
2396         rename($destination . '.tmp', $destination);
2397         @chmod($destination, $CFG->filepermissions);
2398         @unlink($destination . '.tmp'); // Just in case anything fails.
2399     }
2400     ignore_user_abort(false);
2401     if (connection_aborted()) {
2402         die();
2403     }
2406 /**
2407  * Handles the sending of file data to the user's browser, including support for
2408  * byteranges etc.
2409  *
2410  * @category files
2411  * @param string|stored_file $path Path of file on disk (including real filename),
2412  *                                 or actual content of file as string,
2413  *                                 or stored_file object
2414  * @param string $filename Filename to send
2415  * @param int $lifetime Number of seconds before the file should expire from caches (null means $CFG->filelifetime)
2416  * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
2417  * @param bool $pathisstring If true (default false), $path is the content to send and not the pathname.
2418  *                           Forced to false when $path is a stored_file object.
2419  * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
2420  * @param string $mimetype Include to specify the MIME type; leave blank to have it guess the type from $filename
2421  * @param bool $dontdie - return control to caller afterwards. this is not recommended and only used for cleanup tasks.
2422  *                        if this is passed as true, ignore_user_abort is called.  if you don't want your processing to continue on cancel,
2423  *                        you must detect this case when control is returned using connection_aborted. Please not that session is closed
2424  *                        and should not be reopened.
2425  * @param array $options An array of options, currently accepts:
2426  *                       - (string) cacheability: public, or private.
2427  *                       - (string|null) immutable
2428  * @return null script execution stopped unless $dontdie is true
2429  */
2430 function send_file($path, $filename, $lifetime = null , $filter=0, $pathisstring=false, $forcedownload=false, $mimetype='',
2431                    $dontdie=false, array $options = array()) {
2432     global $CFG, $COURSE;
2434     if ($dontdie) {
2435         ignore_user_abort(true);
2436     }
2438     if ($lifetime === 'default' or is_null($lifetime)) {
2439         $lifetime = $CFG->filelifetime;
2440     }
2442     if (is_object($path)) {
2443         $pathisstring = false;
2444     }
2446     \core\session\manager::write_close(); // Unlock session during file serving.
2448     // Use given MIME type if specified, otherwise guess it.
2449     if (!$mimetype || $mimetype === 'document/unknown') {
2450         $mimetype = get_mimetype_for_sending($filename);
2451     }
2453     // if user is using IE, urlencode the filename so that multibyte file name will show up correctly on popup
2454     if (core_useragent::is_ie() || core_useragent::is_edge()) {
2455         $filename = rawurlencode($filename);
2456     }
2458     if ($forcedownload) {
2459         header('Content-Disposition: attachment; filename="'.$filename.'"');
2460     } else if ($mimetype !== 'application/x-shockwave-flash') {
2461         // If this is an swf don't pass content-disposition with filename as this makes the flash player treat the file
2462         // as an upload and enforces security that may prevent the file from being loaded.
2464         header('Content-Disposition: inline; filename="'.$filename.'"');
2465     }
2467     if ($lifetime > 0) {
2468         $immutable = '';
2469         if (!empty($options['immutable'])) {
2470             $immutable = ', immutable';
2471             // Overwrite lifetime accordingly:
2472             // 90 days only - based on Moodle point release cadence being every 3 months.
2473             $lifetimemin = 60 * 60 * 24 * 90;
2474             $lifetime = max($lifetime, $lifetimemin);
2475         }
2476         $cacheability = ' public,';
2477         if (!empty($options['cacheability']) && ($options['cacheability'] === 'public')) {
2478             // This file must be cache-able by both browsers and proxies.
2479             $cacheability = ' public,';
2480         } else if (!empty($options['cacheability']) && ($options['cacheability'] === 'private')) {
2481             // This file must be cache-able only by browsers.
2482             $cacheability = ' private,';
2483         } else if (isloggedin() and !isguestuser()) {
2484             // By default, under the conditions above, this file must be cache-able only by browsers.
2485             $cacheability = ' private,';
2486         }
2487         $nobyteserving = false;
2488         header('Cache-Control:'.$cacheability.' max-age='.$lifetime.', no-transform'.$immutable);
2489         header('Expires: '. gmdate('D, d M Y H:i:s', time() + $lifetime) .' GMT');
2490         header('Pragma: ');
2492     } else { // Do not cache files in proxies and browsers
2493         $nobyteserving = true;
2494         if (is_https()) { // HTTPS sites - watch out for IE! KB812935 and KB316431.
2495             header('Cache-Control: private, max-age=10, no-transform');
2496             header('Expires: '. gmdate('D, d M Y H:i:s', 0) .' GMT');
2497             header('Pragma: ');
2498         } else { //normal http - prevent caching at all cost
2499             header('Cache-Control: private, must-revalidate, pre-check=0, post-check=0, max-age=0, no-transform');
2500             header('Expires: '. gmdate('D, d M Y H:i:s', 0) .' GMT');
2501             header('Pragma: no-cache');
2502         }
2503     }
2505     if (empty($filter)) {
2506         // send the contents
2507         if ($pathisstring) {
2508             readstring_accel($path, $mimetype, !$dontdie);
2509         } else {
2510             readfile_accel($path, $mimetype, !$dontdie);
2511         }
2513     } else {
2514         // Try to put the file through filters
2515         if ($mimetype == 'text/html' || $mimetype == 'application/xhtml+xml') {
2516             $options = new stdClass();
2517             $options->noclean = true;
2518             $options->nocache = true; // temporary workaround for MDL-5136
2519             if (is_object($path)) {
2520                 $text = $path->get_content();
2521             } else if ($pathisstring) {
2522                 $text = $path;
2523             } else {
2524                 $text = implode('', file($path));
2525             }
2526             $output = format_text($text, FORMAT_HTML, $options, $COURSE->id);
2528             readstring_accel($output, $mimetype, false);
2530         } else if (($mimetype == 'text/plain') and ($filter == 1)) {
2531             // only filter text if filter all files is selected
2532             $options = new stdClass();
2533             $options->newlines = false;
2534             $options->noclean = true;
2535             if (is_object($path)) {
2536                 $text = htmlentities($path->get_content(), ENT_QUOTES, 'UTF-8');
2537             } else if ($pathisstring) {
2538                 $text = htmlentities($path, ENT_QUOTES, 'UTF-8');
2539             } else {
2540                 $text = htmlentities(implode('', file($path)), ENT_QUOTES, 'UTF-8');
2541             }
2542             $output = '<pre>'. format_text($text, FORMAT_MOODLE, $options, $COURSE->id) .'</pre>';
2544             readstring_accel($output, $mimetype, false);
2546         } else {
2547             // send the contents
2548             if ($pathisstring) {
2549                 readstring_accel($path, $mimetype, !$dontdie);
2550             } else {
2551                 readfile_accel($path, $mimetype, !$dontdie);
2552             }
2553         }
2554     }
2555     if ($dontdie) {
2556         return;
2557     }
2558     die; //no more chars to output!!!
2561 /**
2562  * Handles the sending of file data to the user's browser, including support for
2563  * byteranges etc.
2564  *
2565  * The $options parameter supports the following keys:
2566  *  (string|null) preview - send the preview of the file (e.g. "thumb" for a thumbnail)
2567  *  (string|null) filename - overrides the implicit filename
2568  *  (bool) dontdie - return control to caller afterwards. this is not recommended and only used for cleanup tasks.
2569  *      if this is passed as true, ignore_user_abort is called.  if you don't want your processing to continue on cancel,
2570  *      you must detect this case when control is returned using connection_aborted. Please not that session is closed
2571  *      and should not be reopened
2572  *  (string|null) cacheability - force the cacheability setting of the HTTP response, "private" or "public",
2573  *      when $lifetime is greater than 0. Cacheability defaults to "private" when logged in as other than guest; otherwise,
2574  *      defaults to "public".
2575  *  (string|null) immutable - set the immutable cache setting in the HTTP response, when served under HTTPS.
2576  *      Note: it's up to the consumer to set it properly i.e. when serving a "versioned" URL.
2577  *
2578  * @category files
2579  * @param stored_file $stored_file local file object
2580  * @param int $lifetime Number of seconds before the file should expire from caches (null means $CFG->filelifetime)
2581  * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
2582  * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
2583  * @param array $options additional options affecting the file serving
2584  * @return null script execution stopped unless $options['dontdie'] is true
2585  */
2586 function send_stored_file($stored_file, $lifetime=null, $filter=0, $forcedownload=false, array $options=array()) {
2587     global $CFG, $COURSE;
2589     if (empty($options['filename'])) {
2590         $filename = null;
2591     } else {
2592         $filename = $options['filename'];
2593     }
2595     if (empty($options['dontdie'])) {
2596         $dontdie = false;
2597     } else {
2598         $dontdie = true;
2599     }
2601     if ($lifetime === 'default' or is_null($lifetime)) {
2602         $lifetime = $CFG->filelifetime;
2603     }
2605     if (!empty($options['preview'])) {
2606         // replace the file with its preview
2607         $fs = get_file_storage();
2608         $preview_file = $fs->get_file_preview($stored_file, $options['preview']);
2609         if (!$preview_file) {
2610             // unable to create a preview of the file, send its default mime icon instead
2611             if ($options['preview'] === 'tinyicon') {
2612                 $size = 24;
2613             } else if ($options['preview'] === 'thumb') {
2614                 $size = 90;
2615             } else {
2616                 $size = 256;
2617             }
2618             $fileicon = file_file_icon($stored_file, $size);
2619             send_file($CFG->dirroot.'/pix/'.$fileicon.'.png', basename($fileicon).'.png');
2620         } else {
2621             // preview images have fixed cache lifetime and they ignore forced download
2622             // (they are generated by GD and therefore they are considered reasonably safe).
2623             $stored_file = $preview_file;
2624             $lifetime = DAYSECS;
2625             $filter = 0;
2626             $forcedownload = false;
2627         }
2628     }
2630     // handle external resource
2631     if ($stored_file && $stored_file->is_external_file() && !isset($options['sendcachedexternalfile'])) {
2632         $stored_file->send_file($lifetime, $filter, $forcedownload, $options);
2633         die;
2634     }
2636     if (!$stored_file or $stored_file->is_directory()) {
2637         // nothing to serve
2638         if ($dontdie) {
2639             return;
2640         }
2641         die;
2642     }
2644     $filename = is_null($filename) ? $stored_file->get_filename() : $filename;
2646     // Use given MIME type if specified.
2647     $mimetype = $stored_file->get_mimetype();
2649     // Allow cross-origin requests only for Web Services.
2650     // This allow to receive requests done by Web Workers or webapps in different domains.
2651     if (WS_SERVER) {
2652         header('Access-Control-Allow-Origin: *');
2653     }
2655     send_file($stored_file, $filename, $lifetime, $filter, false, $forcedownload, $mimetype, $dontdie, $options);
2658 /**
2659  * Recursively delete the file or folder with path $location. That is,
2660  * if it is a file delete it. If it is a folder, delete all its content
2661  * then delete it. If $location does not exist to start, that is not
2662  * considered an error.
2663  *
2664  * @param string $location the path to remove.
2665  * @return bool
2666  */
2667 function fulldelete($location) {
2668     if (empty($location)) {
2669         // extra safety against wrong param
2670         return false;
2671     }
2672     if (is_dir($location)) {
2673         if (!$currdir = opendir($location)) {
2674             return false;
2675         }
2676         while (false !== ($file = readdir($currdir))) {
2677             if ($file <> ".." && $file <> ".") {
2678                 $fullfile = $location."/".$file;
2679                 if (is_dir($fullfile)) {
2680                     if (!fulldelete($fullfile)) {
2681                         return false;
2682                     }
2683                 } else {
2684                     if (!unlink($fullfile)) {
2685                         return false;
2686                     }
2687                 }
2688             }
2689         }
2690         closedir($currdir);
2691         if (! rmdir($location)) {
2692             return false;
2693         }
2695     } else if (file_exists($location)) {
2696         if (!unlink($location)) {
2697             return false;
2698         }
2699     }
2700     return true;
2703 /**
2704  * Send requested byterange of file.
2705  *
2706  * @param resource $handle A file handle
2707  * @param string $mimetype The mimetype for the output
2708  * @param array $ranges An array of ranges to send
2709  * @param string $filesize The size of the content if only one range is used
2710  */
2711 function byteserving_send_file($handle, $mimetype, $ranges, $filesize) {
2712     // better turn off any kind of compression and buffering
2713     ini_set('zlib.output_compression', 'Off');
2715     $chunksize = 1*(1024*1024); // 1MB chunks - must be less than 2MB!
2716     if ($handle === false) {
2717         die;
2718     }
2719     if (count($ranges) == 1) { //only one range requested
2720         $length = $ranges[0][2] - $ranges[0][1] + 1;
2721         header('HTTP/1.1 206 Partial content');
2722         header('Content-Length: '.$length);
2723         header('Content-Range: bytes '.$ranges[0][1].'-'.$ranges[0][2].'/'.$filesize);
2724         header('Content-Type: '.$mimetype);
2726         while(@ob_get_level()) {
2727             if (!@ob_end_flush()) {
2728                 break;
2729             }
2730         }
2732         fseek($handle, $ranges[0][1]);
2733         while (!feof($handle) && $length > 0) {
2734             core_php_time_limit::raise(60*60); //reset time limit to 60 min - should be enough for 1 MB chunk
2735             $buffer = fread($handle, ($chunksize < $length ? $chunksize : $length));
2736             echo $buffer;
2737             flush();
2738             $length -= strlen($buffer);
2739         }
2740         fclose($handle);
2741         die;
2742     } else { // multiple ranges requested - not tested much
2743         $totallength = 0;
2744         foreach($ranges as $range) {
2745             $totallength += strlen($range[0]) + $range[2] - $range[1] + 1;
2746         }
2747         $totallength += strlen("\r\n--".BYTESERVING_BOUNDARY."--\r\n");
2748         header('HTTP/1.1 206 Partial content');
2749         header('Content-Length: '.$totallength);
2750         header('Content-Type: multipart/byteranges; boundary='.BYTESERVING_BOUNDARY);
2752         while(@ob_get_level()) {
2753             if (!@ob_end_flush()) {
2754                 break;
2755             }
2756         }
2758         foreach($ranges as $range) {
2759             $length = $range[2] - $range[1] + 1;
2760             echo $range[0];
2761             fseek($handle, $range[1]);
2762             while (!feof($handle) && $length > 0) {
2763                 core_php_time_limit::raise(60*60); //reset time limit to 60 min - should be enough for 1 MB chunk
2764                 $buffer = fread($handle, ($chunksize < $length ? $chunksize : $length));
2765                 echo $buffer;
2766                 flush();
2767                 $length -= strlen($buffer);
2768             }
2769         }
2770         echo "\r\n--".BYTESERVING_BOUNDARY."--\r\n";
2771         fclose($handle);
2772         die;
2773     }
2776 /**
2777  * Tells whether the filename is executable.
2778  *
2779  * @link http://php.net/manual/en/function.is-executable.php
2780  * @link https://bugs.php.net/bug.php?id=41062
2781  * @param string $filename Path to the file.
2782  * @return bool True if the filename exists and is executable; otherwise, false.
2783  */
2784 function file_is_executable($filename) {
2785     if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
2786         if (is_executable($filename)) {
2787             return true;
2788         } else {
2789             $fileext = strrchr($filename, '.');
2790             // If we have an extension we can check if it is listed as executable.
2791             if ($fileext && file_exists($filename) && !is_dir($filename)) {
2792                 $winpathext = strtolower(getenv('PATHEXT'));
2793                 $winpathexts = explode(';', $winpathext);
2795                 return in_array(strtolower($fileext), $winpathexts);
2796             }
2798             return false;
2799         }
2800     } else {
2801         return is_executable($filename);
2802     }
2805 /**
2806  * Overwrite an existing file in a draft area.
2807  *
2808  * @param  stored_file $newfile      the new file with the new content and meta-data
2809  * @param  stored_file $existingfile the file that will be overwritten
2810  * @throws moodle_exception
2811  * @since Moodle 3.2
2812  */
2813 function file_overwrite_existing_draftfile(stored_file $newfile, stored_file $existingfile) {
2814     if ($existingfile->get_component() != 'user' or $existingfile->get_filearea() != 'draft') {
2815         throw new coding_exception('The file to overwrite is not in a draft area.');
2816     }
2818     $fs = get_file_storage();
2819     // Remember original file source field.
2820     $source = @unserialize($existingfile->get_source());
2821     // Remember the original sortorder.
2822     $sortorder = $existingfile->get_sortorder();
2823     if ($newfile->is_external_file()) {
2824         // New file is a reference. Check that existing file does not have any other files referencing to it
2825         if (isset($source->original) && $fs->search_references_count($source->original)) {
2826             throw new moodle_exception('errordoublereference', 'repository');
2827         }
2828     }
2830     // Delete existing file to release filename.
2831     $newfilerecord = array(
2832         'contextid' => $existingfile->get_contextid(),
2833         'component' => 'user',
2834         'filearea' => 'draft',
2835         'itemid' => $existingfile->get_itemid(),
2836         'timemodified' => time()
2837     );
2838     $existingfile->delete();
2840     // Create new file.
2841     $newfile = $fs->create_file_from_storedfile($newfilerecord, $newfile);
2842     // Preserve original file location (stored in source field) for handling references.
2843     if (isset($source->original)) {
2844         if (!($newfilesource = @unserialize($newfile->get_source()))) {
2845             $newfilesource = new stdClass();
2846         }
2847         $newfilesource->original = $source->original;
2848         $newfile->set_source(serialize($newfilesource));
2849     }
2850     $newfile->set_sortorder($sortorder);
2853 /**
2854  * Add files from a draft area into a final area.
2855  *
2856  * Most of the time you do not want to use this. It is intended to be used
2857  * by asynchronous services which cannot direcly manipulate a final
2858  * area through a draft area. Instead they add files to a new draft
2859  * area and merge that new draft into the final area when ready.
2860  *
2861  * @param int $draftitemid the id of the draft area to use.
2862  * @param int $contextid this parameter and the next two identify the file area to save to.
2863  * @param string $component component name
2864  * @param string $filearea indentifies the file area
2865  * @param int $itemid identifies the item id or false for all items in the file area
2866  * @param array $options area options (subdirs=false, maxfiles=-1, maxbytes=0, areamaxbytes=FILE_AREA_MAX_BYTES_UNLIMITED)
2867  * @see file_save_draft_area_files
2868  * @since Moodle 3.2
2869  */
2870 function file_merge_files_from_draft_area_into_filearea($draftitemid, $contextid, $component, $filearea, $itemid,
2871                                                         array $options = null) {
2872     // We use 0 here so file_prepare_draft_area creates a new one, finaldraftid will be updated with the new draft id.
2873     $finaldraftid = 0;
2874     file_prepare_draft_area($finaldraftid, $contextid, $component, $filearea, $itemid, $options);
2875     file_merge_draft_area_into_draft_area($draftitemid, $finaldraftid);
2876     file_save_draft_area_files($finaldraftid, $contextid, $component, $filearea, $itemid, $options);
2879 /**
2880  * Merge files from two draftarea areas.
2881  *
2882  * This does not handle conflict resolution, files in the destination area which appear
2883  * to be more recent will be kept disregarding the intended ones.
2884  *
2885  * @param int $getfromdraftid the id of the draft area where are the files to merge.
2886  * @param int $mergeintodraftid the id of the draft area where new files will be merged.
2887  * @throws coding_exception
2888  * @since Moodle 3.2
2889  */
2890 function file_merge_draft_area_into_draft_area($getfromdraftid, $mergeintodraftid) {
2891     global $USER;
2893     $fs = get_file_storage();
2894     $contextid = context_user::instance($USER->id)->id;
2896     if (!$filestomerge = $fs->get_area_files($contextid, 'user', 'draft', $getfromdraftid)) {
2897         throw new coding_exception('Nothing to merge or area does not belong to current user');
2898     }
2900     $currentfiles = $fs->get_area_files($contextid, 'user', 'draft', $mergeintodraftid);
2902     // Get hashes of the files to merge.
2903     $newhashes = array();
2904     foreach ($filestomerge as $filetomerge) {
2905         $filepath = $filetomerge->get_filepath();
2906         $filename = $filetomerge->get_filename();
2908         $newhash = $fs->get_pathname_hash($contextid, 'user', 'draft', $mergeintodraftid, $filepath, $filename);
2909         $newhashes[$newhash] = $filetomerge;
2910     }
2912     // Calculate wich files must be added.
2913     foreach ($currentfiles as $file) {
2914         $filehash = $file->get_pathnamehash();
2915         // One file to be merged already exists.
2916         if (isset($newhashes[$filehash])) {
2917             $updatedfile = $newhashes[$filehash];
2919             // Avoid race conditions.
2920             if ($file->get_timemodified() > $updatedfile->get_timemodified()) {
2921                 // The existing file is more recent, do not copy the suposedly "new" one.
2922                 unset($newhashes[$filehash]);
2923                 continue;
2924             }
2925             // Update existing file (not only content, meta-data too).
2926             file_overwrite_existing_draftfile($updatedfile, $file);
2927             unset($newhashes[$filehash]);
2928         }
2929     }
2931     foreach ($newhashes as $newfile) {
2932         $newfilerecord = array(
2933             'contextid' => $contextid,
2934             'component' => 'user',
2935             'filearea' => 'draft',
2936             'itemid' => $mergeintodraftid,
2937             'timemodified' => time()
2938         );
2940         $fs->create_file_from_storedfile($newfilerecord, $newfile);
2941     }
2944 /**
2945  * RESTful cURL class
2946  *
2947  * This is a wrapper class for curl, it is quite easy to use:
2948  * <code>
2949  * $c = new curl;
2950  * // enable cache
2951  * $c = new curl(array('cache'=>true));
2952  * // enable cookie
2953  * $c = new curl(array('cookie'=>true));
2954  * // enable proxy
2955  * $c = new curl(array('proxy'=>true));
2956  *
2957  * // HTTP GET Method
2958  * $html = $c->get('http://example.com');
2959  * // HTTP POST Method
2960  * $html = $c->post('http://example.com/', array('q'=>'words', 'name'=>'moodle'));
2961  * // HTTP PUT Method
2962  * $html = $c->put('http://example.com/', array('file'=>'/var/www/test.txt');
2963  * </code>
2964  *
2965  * @package   core_files
2966  * @category files
2967  * @copyright Dongsheng Cai <dongsheng@moodle.com>
2968  * @license   http://www.gnu.org/copyleft/gpl.html GNU Public License
2969  */
2970 class curl {
2971     /** @var bool Caches http request contents */
2972     public  $cache    = false;
2973     /** @var bool Uses proxy, null means automatic based on URL */
2974     public  $proxy    = null;
2975     /** @var string library version */
2976     public  $version  = '0.4 dev';
2977     /** @var array http's response */
2978     public  $response = array();
2979     /** @var array Raw response headers, needed for BC in download_file_content(). */
2980     public $rawresponse = array();
2981     /** @var array http header */
2982     public  $header   = array();
2983     /** @var string cURL information */
2984     public  $info;
2985     /** @var string error */
2986     public  $error;
2987     /** @var int error code */
2988     public  $errno;
2989     /** @var bool use workaround for open_basedir restrictions, to be changed from unit tests only! */
2990     public $emulateredirects = null;
2992     /** @var array cURL options */
2993     private $options;
2995     /** @var string Proxy host */
2996     private $proxy_host = '';
2997     /** @var string Proxy auth */
2998     private $proxy_auth = '';
2999     /** @var string Proxy type */
3000     private $proxy_type = '';
3001     /** @var bool Debug mode on */
3002     private $debug    = false;
3003     /** @var bool|string Path to cookie file */
3004     private $cookie   = false;
3005     /** @var bool tracks multiple headers in response - redirect detection */
3006     private $responsefinished = false;
3007     /** @var security helper class, responsible for checking host/ports against blacklist/whitelist entries.*/
3008     private $securityhelper;
3009     /** @var bool ignoresecurity a flag which can be supplied to the constructor, allowing security to be bypassed. */
3010     private $ignoresecurity;
3011     /** @var array $mockresponses For unit testing only - return the head of this list instead of making the next request. */
3012     private static $mockresponses = [];
3014     /**
3015      * Curl constructor.
3016      *
3017      * Allowed settings are:
3018      *  proxy: (bool) use proxy server, null means autodetect non-local from url
3019      *  debug: (bool) use debug output
3020      *  cookie: (string) path to cookie file, false if none
3021      *  cache: (bool) use cache
3022      *  module_cache: (string) type of cache
3023      *  securityhelper: (\core\files\curl_security_helper_base) helper object providing URL checking for requests.
3024      *  ignoresecurity: (bool) set true to override and ignore the security helper when making requests.
3025      *
3026      * @param array $settings
3027      */
3028     public function __construct($settings = array()) {
3029         global $CFG;
3030         if (!function_exists('curl_init')) {
3031             $this->error = 'cURL module must be enabled!';
3032             trigger_error($this->error, E_USER_ERROR);
3033             return false;
3034         }
3036         // All settings of this class should be init here.
3037         $this->resetopt();
3038         if (!empty($settings['debug'])) {
3039             $this->debug = true;
3040         }
3041         if (!empty($settings['cookie'])) {
3042             if($settings['cookie'] === true) {
3043                 $this->cookie = $CFG->dataroot.'/curl_cookie.txt';
3044             } else {
3045                 $this->cookie = $settings['cookie'];
3046             }
3047         }
3048         if (!empty($settings['cache'])) {
3049             if (class_exists('curl_cache')) {
3050                 if (!empty($settings['module_cache'])) {
3051                     $this->cache = new curl_cache($settings['module_cache']);
3052                 } else {
3053                     $this->cache = new curl_cache('misc');
3054                 }
3055             }
3056         }
3057         if (!empty($CFG->proxyhost)) {
3058             if (empty($CFG->proxyport)) {
3059                 $this->proxy_host = $CFG->proxyhost;
3060             } else {
3061                 $this->proxy_host = $CFG->proxyhost.':'.$CFG->proxyport;
3062             }
3063             if (!empty($CFG->proxyuser) and !empty($CFG->proxypassword)) {
3064                 $this->proxy_auth = $CFG->proxyuser.':'.$CFG->proxypassword;
3065                 $this->setopt(array(
3066                             'proxyauth'=> CURLAUTH_BASIC | CURLAUTH_NTLM,
3067                             'proxyuserpwd'=>$this->proxy_auth));
3068             }
3069             if (!empty($CFG->proxytype)) {
3070                 if ($CFG->proxytype == 'SOCKS5') {
3071                     $this->proxy_type = CURLPROXY_SOCKS5;
3072                 } else {
3073                     $this->proxy_type = CURLPROXY_HTTP;
3074                     $this->setopt(array('httpproxytunnel'=>false));
3075                 }
3076                 $this->setopt(array('proxytype'=>$this->proxy_type));
3077             }
3079             if (isset($settings['proxy'])) {
3080                 $this->proxy = $settings['proxy'];
3081             }
3082         } else {
3083             $this->proxy = false;
3084         }
3086         if (!isset($this->emulateredirects)) {
3087             $this->emulateredirects = ini_get('open_basedir');
3088         }
3090         // Curl security setup. Allow injection of a security helper, but if not found, default to the core helper.
3091         if (isset($settings['securityhelper']) && $settings['securityhelper'] instanceof \core\files\curl_security_helper_base) {
3092             $this->set_security($settings['securityhelper']);
3093         } else {
3094             $this->set_security(new \core\files\curl_security_helper());
3095         }
3096         $this->ignoresecurity = isset($settings['ignoresecurity']) ? $settings['ignoresecurity'] : false;
3097     }
3099     /**
3100      * Resets the CURL options that have already been set
3101      */
3102     public function resetopt() {
3103         $this->options = array();
3104         $this->options['CURLOPT_USERAGENT']         = 'MoodleBot/1.0';
3105         // True to include the header in the output
3106         $this->options['CURLOPT_HEADER']            = 0;
3107         // True to Exclude the body from the output
3108         $this->options['CURLOPT_NOBODY']            = 0;
3109         // Redirect ny default.
3110         $this->options['CURLOPT_FOLLOWLOCATION']    = 1;
3111         $this->options['CURLOPT_MAXREDIRS']         = 10;
3112         $this->options['CURLOPT_ENCODING']          = '';
3113         // TRUE to return the transfer as a string of the return
3114         // value of curl_exec() instead of outputting it out directly.
3115         $this->options['CURLOPT_RETURNTRANSFER']    = 1;
3116         $this->options['CURLOPT_SSL_VERIFYPEER']    = 0;
3117         $this->options['CURLOPT_SSL_VERIFYHOST']    = 2;
3118         $this->options['CURLOPT_CONNECTTIMEOUT']    = 30;
3120         if ($cacert = self::get_cacert()) {
3121             $this->options['CURLOPT_CAINFO'] = $cacert;
3122         }
3123     }
3125     /**
3126      * Get the location of ca certificates.
3127      * @return string absolute file path or empty if default used
3128      */
3129     public static function get_cacert() {
3130         global $CFG;
3132         // Bundle in dataroot always wins.
3133         if (is_readable("$CFG->dataroot/moodleorgca.crt")) {
3134             return realpath("$CFG->dataroot/moodleorgca.crt");
3135         }
3137         // Next comes the default from php.ini
3138         $cacert = ini_get('curl.cainfo');
3139         if (!empty($cacert) and is_readable($cacert)) {
3140             return realpath($cacert);
3141         }
3143         // Windows PHP does not have any certs, we need to use something.
3144         if ($CFG->ostype === 'WINDOWS') {
3145             if (is_readable("$CFG->libdir/cacert.pem")) {
3146                 return realpath("$CFG->libdir/cacert.pem");
3147             }
3148         }
3150         // Use default, this should work fine on all properly configured *nix systems.
3151         return null;
3152     }
3154     /**
3155      * Reset Cookie
3156      */
3157     public function resetcookie() {
3158         if (!empty($this->cookie)) {
3159             if (is_file($this->cookie)) {
3160                 $fp = fopen($this->cookie, 'w');
3161                 if (!empty($fp)) {
3162                     fwrite($fp, '');
3163                     fclose($fp);
3164                 }
3165             }
3166         }
3167     }
3169     /**
3170      * Set curl options.
3171      *
3172      * Do not use the curl constants to define the options, pass a string
3173      * corresponding to that constant. Ie. to set CURLOPT_MAXREDIRS, pass
3174      * array('CURLOPT_MAXREDIRS' => 10) or array('maxredirs' => 10) to this method.
3175      *
3176      * @param array $options If array is null, this function will reset the options to default value.
3177      * @return void
3178      * @throws coding_exception If an option uses constant value instead of option name.
3179      */
3180     public function setopt($options = array()) {
3181         if (is_array($options)) {
3182             foreach ($options as $name => $val) {
3183                 if (!is_string($name)) {
3184                     throw new coding_exception('Curl options should be defined using strings, not constant values.');
3185                 }
3186                 if (stripos($name, 'CURLOPT_') === false) {
3187                     $name = strtoupper('CURLOPT_'.$name);
3188                 } else {
3189                     $name = strtoupper($name);
3190                 }
3191                 $this->options[$name] = $val;
3192             }
3193         }
3194     }
3196     /**
3197      * Reset http method
3198      */
3199     public function cleanopt() {
3200         unset($this->options['CURLOPT_HTTPGET']);
3201         unset($this->options['CURLOPT_POST']);
3202         unset($this->options['CURLOPT_POSTFIELDS']);
3203         unset($this->options['CURLOPT_PUT']);
3204         unset($this->options['CURLOPT_INFILE']);
3205         unset($this->options['CURLOPT_INFILESIZE']);
3206         unset($this->options['CURLOPT_CUSTOMREQUEST']);
3207         unset($this->options['CURLOPT_FILE']);
3208     }
3210     /**
3211      * Resets the HTTP Request headers (to prepare for the new request)
3212      */
3213     public function resetHeader() {
3214         $this->header = array();
3215     }
3217     /**
3218      * Set HTTP Request Header
3219      *
3220      * @param array $header
3221      */
3222     public function setHeader($header) {
3223         if (is_array($header)) {
3224             foreach ($header as $v) {
3225                 $this->setHeader($v);
3226             }
3227         } else {
3228             // Remove newlines, they are not allowed in headers.
3229             $newvalue = preg_replace('/[\r\n]/', '', $header);
3230             if (!in_array($newvalue, $this->header)) {
3231                 $this->header[] = $newvalue;
3232             }
3233         }
3234     }
3236     /**
3237      * Get HTTP Response Headers
3238      * @return array of arrays
3239      */
3240     public function getResponse() {
3241         return $this->response;
3242     }
3244     /**
3245      * Get raw HTTP Response Headers
3246      * @return array of strings
3247      */
3248     public function get_raw_response() {
3249         return $this->rawresponse;
3250     }
3252     /**
3253      * private callback function
3254      * Formatting HTTP Response Header
3255      *
3256      * We only keep the last headers returned. For example during a redirect the
3257      * redirect headers will not appear in {@link self::getResponse()}, if you need
3258      * to use those headers, refer to {@link self::get_raw_response()}.
3259      *
3260      * @param resource $ch Apparently not used
3261      * @param string $header
3262      * @return int The strlen of the header
3263      */
3264     private function formatHeader($ch, $header) {
3265         $this->rawresponse[] = $header;
3267         if (trim($header, "\r\n") === '') {
3268             // This must be the last header.
3269             $this->responsefinished = true;
3270         }
3272         if (strlen($header) > 2) {
3273             if ($this->responsefinished) {
3274                 // We still have headers after the supposedly last header, we must be
3275                 // in a redirect so let's empty the response to keep the last headers.
3276                 $this->responsefinished = false;
3277                 $this->response = array();
3278             }
3279             $parts = explode(" ", rtrim($header, "\r\n"), 2);
3280             $key = rtrim($parts[0], ':');
3281             $value = isset($parts[1]) ? $parts[1] : null;
3282             if (!empty($this->response[$key])) {
3283                 if (is_array($this->response[$key])) {
3284                     $this->response[$key][] = $value;
3285                 } else {
3286                     $tmp = $this->response[$key];
3287                     $this->response[$key] = array();
3288                     $this->response[$key][] = $tmp;
3289                     $this->response[$key][] = $value;
3291                 }
3292             } else {
3293                 $this->response[$key] = $value;
3294             }
3295         }
3296         return strlen($header);
3297     }
3299     /**
3300      * Set options for individual curl instance
3301      *
3302      * @param resource $curl A curl handle
3303      * @param array $options
3304      * @return resource The curl handle
3305      */
3306     private function apply_opt($curl, $options) {
3307         // Clean up
3308         $this->cleanopt();
3309         // set cookie
3310         if (!empty($this->cookie) || !empty($options['cookie'])) {
3311             $this->setopt(array('cookiejar'=>$this->cookie,
3312                             'cookiefile'=>$this->cookie
3313                              ));
3314         }
3316         // Bypass proxy if required.
3317         if ($this->proxy === null) {
3318             if (!empty($this->options['CURLOPT_URL']) and is_proxybypass($this->options['CURLOPT_URL'])) {
3319                 $proxy = false;
3320             } else {
3321                 $proxy = true;
3322             }
3323         } else {
3324             $proxy = (bool)$this->proxy;
3325         }
3327         // Set proxy.
3328         if ($proxy) {
3329             $options['CURLOPT_PROXY'] = $this->proxy_host;
3330         } else {
3331             unset($this->options['CURLOPT_PROXY']);
3332         }
3334         $this->setopt($options);
3336         // Reset before set options.
3337         curl_setopt($curl, CURLOPT_HEADERFUNCTION, array(&$this,'formatHeader'));
3339         // Setting the User-Agent based on options provided.
3340         $useragent = '';
3342         if (!empty($options['CURLOPT_USERAGENT'])) {
3343             $useragent = $options['CURLOPT_USERAGENT'];
3344         } else if (!empty($this->options['CURLOPT_USERAGENT'])) {
3345             $useragent = $this->options['CURLOPT_USERAGENT'];
3346         } else {
3347             $useragent = 'MoodleBot/1.0';
3348         }
3350         // Set headers.
3351         if (empty($this->header)) {
3352             $this->setHeader(array(
3353                 'User-Agent: ' . $useragent,
3354                 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7',
3355                 'Connection: keep-alive'
3356                 ));
3357         } else if (!in_array('User-Agent: ' . $useragent, $this->header)) {
3358             // Remove old User-Agent if one existed.
3359             // We have to partial search since we don't know what the original User-Agent is.
3360             if ($match = preg_grep('/User-Agent.*/', $this->header)) {
3361                 $key = array_keys($match)[0];
3362                 unset($this->header[$key]);
3363             }
3364             $this->setHeader(array('User-Agent: ' . $useragent));
3365         }
3366         curl_setopt($curl, CURLOPT_HTTPHEADER, $this->header);
3368         if ($this->debug) {
3369             echo '<h1>Options</h1>';
3370             var_dump($this->options);
3371             echo '<h1>Header</h1>';
3372             var_dump($this->header);
3373         }
3375         // Do not allow infinite redirects.
3376         if (!isset($this->options['CURLOPT_MAXREDIRS'])) {
3377             $this->options['CURLOPT_MAXREDIRS'] = 0;
3378         } else if ($this->options['CURLOPT_MAXREDIRS'] > 100) {
3379             $this->options['CURLOPT_MAXREDIRS'] = 100;
3380         } else {
3381             $this->options['CURLOPT_MAXREDIRS'] = (int)$this->options['CURLOPT_MAXREDIRS'];
3382         }
3384         // Make sure we always know if redirects expected.
3385         if (!isset($this->options['CURLOPT_FOLLOWLOCATION'])) {
3386             $this->options['CURLOPT_FOLLOWLOCATION'] = 0;
3387         }
3389         // Limit the protocols to HTTP and HTTPS.
3390         if (defined('CURLOPT_PROTOCOLS')) {
3391             $this->options['CURLOPT_PROTOCOLS'] = (CURLPROTO_HTTP | CURLPROTO_HTTPS);
3392             $this->options['CURLOPT_REDIR_PROTOCOLS'] = (CURLPROTO_HTTP | CURLPROTO_HTTPS);
3393         }
3395         // Set options.
3396         foreach($this->options as $name => $val) {
3397             if ($name === 'CURLOPT_FOLLOWLOCATION' and $this->emulateredirects) {
3398                 // The redirects are emulated elsewhere.
3399                 curl_setopt($curl, CURLOPT_FOLLOWLOCATION, 0);
3400                 continue;
3401             }
3402             $name = constant($name);
3403             curl_setopt($curl, $name, $val);
3404         }
3406         return $curl;
3407     }
3409     /**
3410      * Download multiple files in parallel
3411      *
3412      * Calls {@link multi()} with specific download headers
3413      *
3414      * <code>
3415      * $c = new curl();
3416      * $file1 = fopen('a', 'wb');
3417      * $file2 = fopen('b', 'wb');
3418      * $c->download(array(
3419      *     array('url'=>'http://localhost/', 'file'=>$file1),
3420      *     array('url'=>'http://localhost/20/', 'file'=>$file2)
3421      * ));
3422      * fclose($file1);
3423      * fclose($file2);
3424      * </code>
3425      *
3426      * or
3427      *
3428      * <code>
3429      * $c = new curl();
3430      * $c->download(array(
3431      *              array('url'=>'http://localhost/', 'filepath'=>'/tmp/file1.tmp'),
3432      *              array('url'=>'http://localhost/20/', 'filepath'=>'/tmp/file2.tmp')
3433      *              ));
3434      * </code>
3435      *
3436      * @param array $requests An array of files to request {
3437      *                  url => url to download the file [required]
3438      *                  file => file handler, or
3439      *                  filepath => file path
3440      * }
3441      * If 'file' and 'filepath' parameters are both specified in one request, the
3442      * open file handle in the 'file' parameter will take precedence and 'filepath'
3443      * will be ignored.
3444      *
3445      * @param array $options An array of options to set
3446      * @return array An array of results
3447      */
3448     public function download($requests, $options = array()) {
3449         $options['RETURNTRANSFER'] = false;
3450         return $this->multi($requests, $options);
3451     }
3453     /**
3454      * Returns the current curl security helper.
3455      *
3456      * @return \core\files\curl_security_helper instance.
3457      */
3458     public function get_security() {
3459         return $this->securityhelper;
3460     }
3462     /**
3463      * Sets the curl security helper.
3464      *
3465      * @param \core\files\curl_security_helper $securityobject instance/subclass of the base curl_security_helper class.
3466      * @return bool true if the security helper could be set, false otherwise.
3467      */
3468     public function set_security($securityobject) {
3469         if ($securityobject instanceof \core\files\curl_security_helper) {
3470             $this->securityhelper = $securityobject;
3471             return true;
3472         }
3473         return false;
3474     }
3476     /**
3477      * Multi HTTP Requests
3478      * This function could run multi-requests in parallel.
3479      *
3480      * @param array $requests An array of files to request
3481      * @param array $options An array of options to set
3482      * @return array An array of results
3483      */
3484     protected function multi($requests, $options = array()) {
3485         $count   = count($requests);
3486         $handles = array();
3487         $results = array();
3488         $main    = curl_multi_init();
3489         for ($i = 0; $i < $count; $i++) {
3490             if (!empty($requests[$i]['filepath']) and empty($requests[$i]['file'])) {
3491                 // open file
3492                 $requests[$i]['file'] = fopen($requests[$i]['filepath'], 'w');
3493                 $requests[$i]['auto-handle'] = true;
3494             }
3495             foreach($requests[$i] as $n=>$v) {
3496                 $options[$n] = $v;
3497             }
3498             $handles[$i] = curl_init($requests[$i]['url']);
3499             $this->apply_opt($handles[$i], $options);
3500             curl_multi_add_handle($main, $handles[$i]);
3501         }
3502         $running = 0;
3503         do {
3504             curl_multi_exec($main, $running);
3505         } while($running > 0);
3506         for ($i = 0; $i < $count; $i++) {
3507             if (!empty($options['CURLOPT_RETURNTRANSFER'])) {
3508                 $results[] = true;
3509             } else {
3510                 $results[] = curl_multi_getcontent($handles[$i]);
3511             }
3512             curl_multi_remove_handle($main, $handles[$i]);
3513         }
3514         curl_multi_close($main);
3516         for ($i = 0; $i < $count; $i++) {
3517             if (!empty($requests[$i]['filepath']) and !empty($requests[$i]['auto-handle'])) {
3518                 // close file handler if file is opened in this function
3519                 fclose($requests[$i]['file']);
3520             }
3521         }
3522         return $results;
3523     }
3525     /**
3526      * Helper function to reset the request state vars.
3527      *
3528      * @return void.
3529      */
3530     protected function reset_request_state_vars() {
3531         $this->info             = array();
3532         $this->error            = '';
3533         $this->errno            = 0;
3534         $this->response         = array();
3535         $this->rawresponse      = array();
3536         $this->responsefinished = false;
3537     }
3539     /**
3540      * For use only in unit tests - we can pre-set the next curl response.
3541      * This is useful for unit testing APIs that call external systems.
3542      * @param string $response
3543      */
3544     public static function mock_response($response) {
3545         if ((defined('PHPUNIT_TEST') && PHPUNIT_TEST)) {
3546             array_push(self::$mockresponses, $response);
3547         } else {
3548             throw new coding_excpetion('mock_response function is only available for unit tests.');
3549         }
3550     }
3552     /**
3553      * Single HTTP Request
3554      *
3555      * @param string $url The URL to request
3556      * @param array $options
3557      * @return bool
3558      */
3559     protected function request($url, $options = array()) {
3560         // Reset here so that the data is valid when result returned from cache, or if we return due to a blacklist hit.
3561         $this->reset_request_state_vars();
3563         if ((defined('PHPUNIT_TEST') && PHPUNIT_TEST)) {
3564             if ($mockresponse = array_pop(self::$mockresponses)) {
3565                 $this->info = [ 'http_code' => 200 ];
3566                 return $mockresponse;
3567             }
3568         }
3570         // If curl security is enabled, check the URL against the blacklist before calling curl_exec.
3571         // Note: This will only check the base url. In the case of redirects, the blacklist is also after the curl_exec.
3572         if (!$this->ignoresecurity && $this->securityhelper->url_is_blocked($url)) {
3573             $this->error = $this->securityhelper->get_blocked_url_string();
3574             return $this->error;
3575         }
3577         // Set the URL as a curl option.
3578         $this->setopt(array('CURLOPT_URL' => $url));
3580         // Create curl instance.
3581         $curl = curl_init();
3583         $this->apply_opt($curl, $options);
3584         if ($this->cache && $ret = $this->cache->get($this->options)) {
3585             return $ret;
3586         }