lib/filestorage/file_storage.php

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