[Summary view] [Print] [Text view]

   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   * uploadlib.php - This class handles all aspects of fileuploading
  20   *
  21   * @package    core
  22   * @subpackage file
  23   * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  24   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  25   */
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  /**
  30   * This class handles all aspects of fileuploading
  31   *
  32   * @deprecated since 2.7 - use new file pickers instead
  33   *
  34   * @package   moodlecore
  35   * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  36   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37   */
  38  class upload_manager {
  39  
  40     /**
  41      * Array to hold local copies of stuff in $_FILES
  42      * @var array $files
  43      */
  44      var $files;
  45     /**
  46      * Holds all configuration stuff
  47      * @var array $config
  48      */
  49      var $config;
  50     /**
  51      * Keep track of if we're ok
  52      * (errors for each file are kept in $files['whatever']['uploadlog']
  53      * @var boolean $status
  54      */
  55      var $status;
  56     /**
  57      * The course this file has been uploaded for. {@link $COURSE}
  58      * (for logging and virus notifications)
  59      * @var course $course
  60      */
  61      var $course;
  62     /**
  63      * If we're only getting one file.
  64      * (for logging and virus notifications)
  65      * @var string $inputname
  66      */
  67      var $inputname;
  68     /**
  69      * If we're given silent=true in the constructor, this gets built
  70      * up to hold info about the process.
  71      * @var string $notify
  72      */
  73      var $notify;
  74  
  75      /**
  76       * Constructor, sets up configuration stuff so we know how to act.
  77       *
  78       * Note: destination not taken as parameter as some modules want to use the insertid in the path and we need to check the other stuff first.
  79       *
  80       * @uses $CFG
  81       * @param string $inputname If this is given the upload manager will only process the file in $_FILES with this name.
  82       * @param boolean $deleteothers Whether to delete other files in the destination directory (optional, defaults to false)
  83       * @param boolean $handlecollisions Whether to use {@link handle_filename_collision()} or not. (optional, defaults to false)
  84       * @param course $course The course the files are being uploaded for (for logging and virus notifications) {@link $COURSE}
  85       * @param boolean $recoverifmultiple If we come across a virus, or if a file doesn't validate or whatever, do we continue? optional, defaults to true.
  86       * @param int $modbytes Max bytes for this module - this and $course->maxbytes are used to get the maxbytes from {@link get_max_upload_file_size()}.
  87       * @param boolean $silent Whether to notify errors or not.
  88       * @param boolean $allownull Whether we care if there's no file when we've set the input name.
  89       * @param boolean $allownullmultiple Whether we care if there's no files AT ALL  when we've got multiples. This won't complain if we have file 1 and file 3 but not file 2, only for NO FILES AT ALL.
  90       */
  91      function __construct($inputname='', $deleteothers=false, $handlecollisions=false, $course=null, $recoverifmultiple=false, $modbytes=0, $silent=false, $allownull=false, $allownullmultiple=true) {
  92          global $CFG, $SITE;
  93  
  94          debugging('upload_manager class is deprecated, use new file picker instead', DEBUG_DEVELOPER);
  95  
  96          if (empty($course->id)) {
  97              $course = $SITE;
  98          }
  99  
 100          $this->config = new stdClass();
 101          $this->config->deleteothers = $deleteothers;
 102          $this->config->handlecollisions = $handlecollisions;
 103          $this->config->recoverifmultiple = $recoverifmultiple;
 104          $this->config->maxbytes = get_max_upload_file_size($CFG->maxbytes, $course->maxbytes, $modbytes);
 105          $this->config->silent = $silent;
 106          $this->config->allownull = $allownull;
 107          $this->files = array();
 108          $this->status = false;
 109          $this->course = $course;
 110          $this->inputname = $inputname;
 111          if (empty($this->inputname)) {
 112              $this->config->allownull = $allownullmultiple;
 113          }
 114      }
 115  
 116      /**
 117       * Gets all entries out of $_FILES and stores them locally in $files and then
 118       * checks each one against {@link get_max_upload_file_size()} and calls {@link cleanfilename()}
 119       * and scans them for viruses etc.
 120       * @uses $CFG
 121       * @uses $_FILES
 122       * @return boolean
 123       */
 124      function preprocess_files() {
 125          global $CFG, $OUTPUT;
 126  
 127          foreach ($_FILES as $name => $file) {
 128              $this->status = true; // only set it to true here so that we can check if this function has been called.
 129              if (empty($this->inputname) || $name == $this->inputname) { // if we have input name, only process if it matches.
 130                  $file['originalname'] = $file['name']; // do this first for the log.
 131                  $this->files[$name] = $file; // put it in first so we can get uploadlog out in print_upload_log.
 132                  $this->files[$name]['uploadlog'] = ''; // initialize error log
 133                  $this->status = $this->validate_file($this->files[$name]); // default to only allowing empty on multiple uploads.
 134                  if (!$this->status && ($this->files[$name]['error'] == 0 || $this->files[$name]['error'] == 4) && ($this->config->allownull || empty($this->inputname))) {
 135                      // this shouldn't cause everything to stop.. modules should be responsible for knowing which if any are compulsory.
 136                      continue;
 137                  }
 138                  if ($this->status && !empty($CFG->runclamonupload)) {
 139                      $this->status = clam_scan_moodle_file($this->files[$name],$this->course);
 140                  }
 141                  if (!$this->status) {
 142                      if (!$this->config->recoverifmultiple && count($this->files) > 1) {
 143                          $a = new stdClass();
 144                          $a->name    = $this->files[$name]['originalname'];
 145                          $a->problem = $this->files[$name]['uploadlog'];
 146                          if (!$this->config->silent) {
 147                              echo $OUTPUT->notification(get_string('uploadfailednotrecovering','moodle',$a));
 148                          }
 149                          else {
 150                              $this->notify .= '<br />'. get_string('uploadfailednotrecovering','moodle',$a);
 151                          }
 152                          $this->status = false;
 153                          return false;
 154  
 155                      } else if (count($this->files) == 1) {
 156  
 157                          if (!$this->config->silent and !$this->config->allownull) {
 158                              echo $OUTPUT->notification($this->files[$name]['uploadlog']);
 159                          } else {
 160                              $this->notify .= '<br />'. $this->files[$name]['uploadlog'];
 161                          }
 162                          $this->status = false;
 163                          return false;
 164                      }
 165                  }
 166                  else {
 167                      $newname = clean_filename($this->files[$name]['name']);
 168                      if ($newname != $this->files[$name]['name']) {
 169                          $a = new stdClass();
 170                          $a->oldname = $this->files[$name]['name'];
 171                          $a->newname = $newname;
 172                          $this->files[$name]['uploadlog'] .= get_string('uploadrenamedchars','moodle', $a);
 173                      }
 174                      $this->files[$name]['name'] = $newname;
 175                      $this->files[$name]['clear'] = true; // ok to save.
 176                      $this->config->somethingtosave = true;
 177                  }
 178              }
 179          }
 180          if (!is_array($_FILES) || count($_FILES) == 0) {
 181              return $this->config->allownull;
 182          }
 183          $this->status = true;
 184          return true; // if we've got this far it means that we're recovering so we want status to be ok.
 185      }
 186  
 187      /**
 188       * Validates a single file entry from _FILES
 189       *
 190       * @param object $file The entry from _FILES to validate
 191       * @return boolean True if ok.
 192       */
 193      function validate_file(&$file) {
 194          if (empty($file)) {
 195              return false;
 196          }
 197          if (!is_uploaded_file($file['tmp_name']) || $file['size'] == 0) {
 198              $file['uploadlog'] .= "\n".$this->get_file_upload_error($file);
 199              return false;
 200          }
 201          if ($file['size'] > $this->config->maxbytes) {
 202              $file['uploadlog'] .= "\n". get_string('uploadedfiletoobig', 'moodle', $this->config->maxbytes);
 203              return false;
 204          }
 205          return true;
 206      }
 207  
 208      /**
 209       * Moves all the files to the destination directory.
 210       *
 211       * @uses $CFG
 212       * @uses $USER
 213       * @param string $destination The destination directory.
 214       * @return boolean status;
 215       */
 216      function save_files($destination) {
 217          global $CFG, $USER, $OUTPUT;
 218  
 219          if (!$this->status) { // preprocess_files hasn't been run
 220              $this->preprocess_files();
 221          }
 222  
 223          // if there are no files, bail before we create an empty directory.
 224          if (empty($this->config->somethingtosave)) {
 225              return true;
 226          }
 227  
 228          $savedsomething = false;
 229  
 230          if ($this->status) {
 231              if (!(strpos($destination, $CFG->dataroot) === false)) {
 232                  // take it out for giving to make_upload_directory
 233                  $destination = substr($destination, strlen($CFG->dataroot)+1);
 234              }
 235  
 236              if ($destination{strlen($destination)-1} == '/') { // strip off a trailing / if we have one
 237                  $destination = substr($destination, 0, -1);
 238              }
 239  
 240              if (!make_upload_directory($destination, true)) {
 241                  $this->status = false;
 242                  return false;
 243              }
 244  
 245              $destination = $CFG->dataroot .'/'. $destination; // now add it back in so we have a full path
 246  
 247              $exceptions = array(); //need this later if we're deleting other files.
 248  
 249              foreach (array_keys($this->files) as $i) {
 250  
 251                  if (!$this->files[$i]['clear']) {
 252                      // not ok to save
 253                      continue;
 254                  }
 255  
 256                  if ($this->config->handlecollisions) {
 257                      $this->handle_filename_collision($destination, $this->files[$i]);
 258                  }
 259                  if (move_uploaded_file($this->files[$i]['tmp_name'], $destination.'/'.$this->files[$i]['name'])) {
 260                      chmod($destination .'/'. $this->files[$i]['name'], $CFG->directorypermissions);
 261                      $this->files[$i]['fullpath'] = $destination.'/'.$this->files[$i]['name'];
 262                      $this->files[$i]['uploadlog'] .= "\n".get_string('uploadedfile');
 263                      $this->files[$i]['saved'] = true;
 264                      $exceptions[] = $this->files[$i]['name'];
 265                      $savedsomething=true;
 266                  }
 267              }
 268              if ($savedsomething && $this->config->deleteothers) {
 269                  $this->delete_other_files($destination, $exceptions);
 270              }
 271          }
 272          if (empty($savedsomething)) {
 273              $this->status = false;
 274              if ((empty($this->config->allownull) && !empty($this->inputname)) || (empty($this->inputname) && empty($this->config->allownullmultiple))) {
 275                  echo $OUTPUT->notification(get_string('uploadnofilefound'));
 276              }
 277              return false;
 278          }
 279          return $this->status;
 280      }
 281  
 282      /**
 283       * Wrapper function that calls {@link preprocess_files()} and {@link viruscheck_files()} and then {@link save_files()}
 284       * Modules that require the insert id in the filepath should not use this and call these functions seperately in the required order.
 285       * @parameter string $destination Where to save the uploaded files to.
 286       * @return boolean
 287       */
 288      function process_file_uploads($destination) {
 289          if ($this->preprocess_files()) {
 290              return $this->save_files($destination);
 291          }
 292          return false;
 293      }
 294  
 295      /**
 296       * Deletes all the files in a given directory except for the files in $exceptions (full paths)
 297       *
 298       * @param string $destination The directory to clean up.
 299       * @param array $exceptions Full paths of files to KEEP.
 300       */
 301      function delete_other_files($destination, $exceptions=null) {
 302          global $OUTPUT;
 303          $deletedsomething = false;
 304          if ($filestodel = get_directory_list($destination)) {
 305              foreach ($filestodel as $file) {
 306                  if (!is_array($exceptions) || !in_array($file, $exceptions)) {
 307                      unlink($destination .'/'. $file);
 308                      $deletedsomething = true;
 309                  }
 310              }
 311          }
 312          if ($deletedsomething) {
 313              if (!$this->config->silent) {
 314                  echo $OUTPUT->notification(get_string('uploadoldfilesdeleted'));
 315              }
 316              else {
 317                  $this->notify .= '<br />'. get_string('uploadoldfilesdeleted');
 318              }
 319          }
 320      }
 321  
 322      /**
 323       * Handles filename collisions - if the desired filename exists it will rename it according to the pattern in $format
 324       * @param string $destination Destination directory (to check existing files against)
 325       * @param object $file Passed in by reference. The current file from $files we're processing.
 326       * @return void - modifies &$file parameter.
 327       */
 328      function handle_filename_collision($destination, &$file) {
 329          if (!file_exists($destination .'/'. $file['name'])) {
 330              return;
 331          }
 332  
 333          $parts     = explode('.', $file['name']);
 334          if (count($parts) > 1) {
 335              $extension = '.'.array_pop($parts);
 336              $name      = implode('.', $parts);
 337          } else {
 338              $extension = '';
 339              $name      = $file['name'];
 340          }
 341  
 342          $current = 0;
 343          if (preg_match('/^(.*)_(\d*)$/s', $name, $matches)) {
 344              $name    = $matches[1];
 345              $current = (int)$matches[2];
 346          }
 347          $i = $current + 1;
 348  
 349          while (!$this->check_before_renaming($destination, $name.'_'.$i.$extension, $file)) {
 350              $i++;
 351          }
 352          $a = new stdClass();
 353          $a->oldname = $file['name'];
 354          $file['name'] = $name.'_'.$i.$extension;
 355          $a->newname = $file['name'];
 356          $file['uploadlog'] .= "\n". get_string('uploadrenamedcollision','moodle', $a);
 357      }
 358  
 359      /**
 360       * This function checks a potential filename against what's on the filesystem already and what's been saved already.
 361       * @param string $destination Destination directory (to check existing files against)
 362       * @param string $nametocheck The filename to be compared.
 363       * @param object $file The current file from $files we're processing.
 364       * return boolean
 365       */
 366      function check_before_renaming($destination, $nametocheck, $file) {
 367          if (!file_exists($destination .'/'. $nametocheck)) {
 368              return true;
 369          }
 370          if ($this->config->deleteothers) {
 371              foreach ($this->files as $tocheck) {
 372                  // if we're deleting files anyway, it's not THIS file and we care about it and it has the same name and has already been saved..
 373                  if ($file['tmp_name'] != $tocheck['tmp_name'] && $tocheck['clear'] && $nametocheck == $tocheck['name'] && $tocheck['saved']) {
 374                      $collision = true;
 375                  }
 376              }
 377              if (!$collision) {
 378                  return true;
 379              }
 380          }
 381          return false;
 382      }
 383  
 384      /**
 385       * ?
 386       *
 387       * @param object $file Passed in by reference. The current file from $files we're processing.
 388       * @return string
 389       */
 390      function get_file_upload_error(&$file) {
 391  
 392          switch ($file['error']) {
 393          case 0: // UPLOAD_ERR_OK
 394              if ($file['size'] > 0) {
 395                  $errmessage = get_string('uploadproblem', $file['name']);
 396              } else {
 397                  $errmessage = get_string('uploadnofilefound'); /// probably a dud file name
 398              }
 399              break;
 400  
 401          case 1: // UPLOAD_ERR_INI_SIZE
 402              $errmessage = get_string('uploadserverlimit');
 403              break;
 404  
 405          case 2: // UPLOAD_ERR_FORM_SIZE
 406              $errmessage = get_string('uploadformlimit');
 407              break;
 408  
 409          case 3: // UPLOAD_ERR_PARTIAL
 410              $errmessage = get_string('uploadpartialfile');
 411              break;
 412  
 413          case 4: // UPLOAD_ERR_NO_FILE
 414              $errmessage = get_string('uploadnofilefound');
 415              break;
 416  
 417          // Note: there is no error with a value of 5
 418  
 419          case 6: // UPLOAD_ERR_NO_TMP_DIR
 420              $errmessage = get_string('uploadnotempdir');
 421              break;
 422  
 423          case 7: // UPLOAD_ERR_CANT_WRITE
 424              $errmessage = get_string('uploadcantwrite');
 425              break;
 426  
 427          case 8: // UPLOAD_ERR_EXTENSION
 428              $errmessage = get_string('uploadextension');
 429              break;
 430  
 431          default:
 432              $errmessage = get_string('uploadproblem', $file['name']);
 433          }
 434          return $errmessage;
 435      }
 436  
 437      /**
 438       * prints a log of everything that happened (of interest) to each file in _FILES
 439       * @param $return - optional, defaults to false (log is echoed)
 440       */
 441      function print_upload_log($return=false,$skipemptyifmultiple=false) {
 442          $str = '';
 443          foreach (array_keys($this->files) as $i => $key) {
 444              if (count($this->files) > 1 && !empty($skipemptyifmultiple) && $this->files[$key]['error'] == 4) {
 445                  continue;
 446              }
 447              $str .= '<strong>'. get_string('uploadfilelog', 'moodle', $i+1) .' '
 448                  .((!empty($this->files[$key]['originalname'])) ? '('.$this->files[$key]['originalname'].')' : '')
 449                  .'</strong> :'. nl2br($this->files[$key]['uploadlog']) .'<br />';
 450          }
 451          if ($return) {
 452              return $str;
 453          }
 454          echo $str;
 455      }
 456  
 457      /**
 458       * If we're only handling one file (if inputname was given in the constructor) this will return the (possibly changed) filename of the file.
 459       @return boolean
 460       */
 461      function get_new_filename() {
 462          if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
 463              return $this->files[$this->inputname]['name'];
 464          }
 465          return false;
 466      }
 467  
 468      /**
 469       * If we're only handling one file (if input name was given in the constructor) this will return the full path to the saved file.
 470       * @return boolean
 471       */
 472      function get_new_filepath() {
 473          if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
 474              return $this->files[$this->inputname]['fullpath'];
 475          }
 476          return false;
 477      }
 478  
 479      /**
 480       * If we're only handling one file (if inputname was given in the constructor) this will return the ORIGINAL filename of the file.
 481       * @return boolean
 482       */
 483      function get_original_filename() {
 484          if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
 485              return $this->files[$this->inputname]['originalname'];
 486          }
 487          return false;
 488      }
 489  
 490      /**
 491       * This function returns any errors wrapped up in red.
 492       * @return string
 493       */
 494      function get_errors() {
 495          if (!empty($this->notify)) {
 496              return '<p class="notifyproblem">'. $this->notify .'</p>';
 497          } else {
 498              return null;
 499          }
 500      }
 501  }
 502  
 503  /**************************************************************************************
 504  THESE FUNCTIONS ARE OUTSIDE THE CLASS BECAUSE THEY NEED TO BE CALLED FROM OTHER PLACES.
 505  FOR EXAMPLE CLAM_HANDLE_INFECTED_FILE AND CLAM_REPLACE_INFECTED_FILE USED FROM CRON
 506  UPLOAD_PRINT_FORM_FRAGMENT DOESN'T REALLY BELONG IN THE CLASS BUT CERTAINLY IN THIS FILE
 507  ***************************************************************************************/
 508  
 509  /**
 510   * Deals with an infected file - either moves it to a quarantinedir
 511   * (specified in CFG->quarantinedir) or deletes it.
 512   *
 513   * If moving it fails, it deletes it.
 514   *
 515   * @deprecated since 2.7 - to be removed together with the upload_manager above
 516   *
 517   * @param string $file Full path to the file
 518   * @param int $userid If not used, defaults to $USER->id (there in case called from cron)
 519   * @param boolean $basiconly Admin level reporting or user level reporting.
 520   * @return string Details of what the function did.
 521   */
 522  function clam_handle_infected_file($file, $userid=0, $basiconly=false) {
 523      global $CFG, $USER;
 524  
 525      debugging('clam_handle_infected_file() is not supposed to be used, the files are now scanned in file picker', DEBUG_DEVELOPER);
 526  
 527      if ($USER && !$userid) {
 528          $userid = $USER->id;
 529      }
 530      $delete = true;
 531      $notice = '';
 532      if (file_exists($CFG->quarantinedir) && is_dir($CFG->quarantinedir) && is_writable($CFG->quarantinedir)) {
 533          $now = date('YmdHis');
 534          if (rename($file, $CFG->quarantinedir .'/'. $now .'-user-'. $userid .'-infected')) {
 535              $delete = false;
 536              if ($basiconly) {
 537                  $notice .= "\n". get_string('clammovedfilebasic');
 538              }
 539              else {
 540                  $notice .= "\n". get_string('clammovedfile', 'moodle', $CFG->quarantinedir.'/'. $now .'-user-'. $userid .'-infected');
 541              }
 542          }
 543          else {
 544              if ($basiconly) {
 545                  $notice .= "\n". get_string('clamdeletedfile');
 546              }
 547              else {
 548                  $notice .= "\n". get_string('clamquarantinedirfailed', 'moodle', $CFG->quarantinedir);
 549              }
 550          }
 551      }
 552      else {
 553          if ($basiconly) {
 554              $notice .= "\n". get_string('clamdeletedfile');
 555          }
 556          else {
 557              $notice .= "\n". get_string('clamquarantinedirfailed', 'moodle', $CFG->quarantinedir);
 558          }
 559      }
 560      if ($delete) {
 561          if (unlink($file)) {
 562              $notice .= "\n". get_string('clamdeletedfile');
 563          }
 564          else {
 565              if ($basiconly) {
 566                  // still tell the user the file has been deleted. this is only for admins.
 567                  $notice .= "\n". get_string('clamdeletedfile');
 568              }
 569              else {
 570                  $notice .= "\n". get_string('clamdeletedfilefailed');
 571              }
 572          }
 573      }
 574      return $notice;
 575  }
 576  
 577  /**
 578   * If $CFG->runclamonupload is set, we scan a given file. (called from {@link preprocess_files()})
 579   *
 580   * @deprecated since 2.7 - to be removed together with the upload_manager above
 581   *
 582   * @param mixed $file The file to scan from $files. or an absolute path to a file.
 583   * @param stdClass $course
 584   * @return int 1 if good, 0 if something goes wrong (opposite from actual error code from clam)
 585   */
 586  function clam_scan_moodle_file(&$file, $course) {
 587      global $CFG, $USER;
 588  
 589      debugging('clam_scan_moodle_file() is not supposed to be used, the files are now scanned in file picker', DEBUG_DEVELOPER);
 590  
 591      if (is_array($file) && is_uploaded_file($file['tmp_name'])) { // it's from $_FILES
 592          $appendlog = true;
 593          $fullpath = $file['tmp_name'];
 594      }
 595      else if (file_exists($file)) { // it's a path to somewhere on the filesystem!
 596          $fullpath = $file;
 597      }
 598      else {
 599          return false; // erm, what is this supposed to be then, huh?
 600      }
 601  
 602      $CFG->pathtoclam = trim($CFG->pathtoclam);
 603  
 604      if (!$CFG->pathtoclam || !file_exists($CFG->pathtoclam) || !is_executable($CFG->pathtoclam)) {
 605          $newreturn = 1;
 606          $notice = get_string('clamlost', 'moodle', $CFG->pathtoclam);
 607          if ($CFG->clamfailureonupload == 'actlikevirus') {
 608              $notice .= "\n". get_string('clamlostandactinglikevirus');
 609              $notice .= "\n". clam_handle_infected_file($fullpath);
 610              $newreturn = false;
 611          }
 612          clam_message_admins($notice);
 613          if ($appendlog) {
 614              $file['uploadlog'] .= "\n". get_string('clambroken');
 615              $file['clam'] = 1;
 616          }
 617          return $newreturn; // return 1 if we're allowing clam failures
 618      }
 619  
 620      $cmd = $CFG->pathtoclam .' '. $fullpath ." 2>&1";
 621  
 622      // before we do anything we need to change perms so that clamscan can read the file (clamdscan won't work otherwise)
 623      chmod($fullpath, $CFG->directorypermissions);
 624  
 625      exec($cmd, $output, $return);
 626  
 627  
 628      switch ($return) {
 629      case 0: // glee! we're ok.
 630          return 1; // translate clam return code into reasonable return code consistent with everything else.
 631      case 1:  // bad wicked evil, we have a virus.
 632          $info = new stdClass();
 633          if (!empty($course)) {
 634              $info->course = format_string($course->fullname, true, array('context' => context_course::instance($course->id)));
 635          }
 636          else {
 637              $info->course = 'No course';
 638          }
 639          $info->user = fullname($USER);
 640          $notice = get_string('virusfound', 'moodle', $info);
 641          $notice .= "\n\n". implode("\n", $output);
 642          $notice .= "\n\n". clam_handle_infected_file($fullpath);
 643          clam_message_admins($notice);
 644          if ($appendlog) {
 645              $info->filename = $file['originalname'];
 646              $file['uploadlog'] .= "\n". get_string('virusfounduser', 'moodle', $info);
 647              $file['virus'] = 1;
 648          }
 649          return false; // in this case, 0 means bad.
 650      default:
 651          // error - clam failed to run or something went wrong
 652          $notice = get_string('clamfailed', 'moodle', get_clam_error_code($return));
 653          $notice .= "\n\n". implode("\n", $output);
 654          $newreturn = true;
 655          if ($CFG->clamfailureonupload == 'actlikevirus') {
 656              $notice .= "\n". clam_handle_infected_file($fullpath);
 657              $newreturn = false;
 658          }
 659          clam_message_admins($notice);
 660          if ($appendlog) {
 661              $file['uploadlog'] .= "\n". get_string('clambroken');
 662              $file['clam'] = 1;
 663          }
 664          return $newreturn; // return 1 if we're allowing failures.
 665      }
 666  }
 667  
 668  /**
 669   * Emails admins about a clam outcome
 670   *
 671   * @param string $notice The body of the email to be sent.
 672   */
 673  function clam_message_admins($notice) {
 674  
 675      $site = get_site();
 676  
 677      $subject = get_string('clamemailsubject', 'moodle', format_string($site->fullname));
 678      $admins = get_admins();
 679      foreach ($admins as $admin) {
 680          $eventdata = new stdClass();
 681          $eventdata->component         = 'moodle';
 682          $eventdata->name              = 'errors';
 683          $eventdata->userfrom          = get_admin();
 684          $eventdata->userto            = $admin;
 685          $eventdata->subject           = $subject;
 686          $eventdata->fullmessage       = $notice;
 687          $eventdata->fullmessageformat = FORMAT_PLAIN;
 688          $eventdata->fullmessagehtml   = '';
 689          $eventdata->smallmessage      = '';
 690          message_send($eventdata);
 691      }
 692  }
 693  
 694  /**
 695   * Returns the string equivalent of a numeric clam error code
 696   *
 697   * @param int $returncode The numeric error code in question.
 698   * @return string The definition of the error code
 699   */
 700  function get_clam_error_code($returncode) {
 701      $returncodes = array();
 702      $returncodes[0] = 'No virus found.';
 703      $returncodes[1] = 'Virus(es) found.';
 704      $returncodes[2] = ' An error occured'; // specific to clamdscan
 705      // all after here are specific to clamscan
 706      $returncodes[40] = 'Unknown option passed.';
 707      $returncodes[50] = 'Database initialization error.';
 708      $returncodes[52] = 'Not supported file type.';
 709      $returncodes[53] = 'Can\'t open directory.';
 710      $returncodes[54] = 'Can\'t open file. (ofm)';
 711      $returncodes[55] = 'Error reading file. (ofm)';
 712      $returncodes[56] = 'Can\'t stat input file / directory.';
 713      $returncodes[57] = 'Can\'t get absolute path name of current working directory.';
 714      $returncodes[58] = 'I/O error, please check your filesystem.';
 715      $returncodes[59] = 'Can\'t get information about current user from /etc/passwd.';
 716      $returncodes[60] = 'Can\'t get information about user \'clamav\' (default name) from /etc/passwd.';
 717      $returncodes[61] = 'Can\'t fork.';
 718      $returncodes[63] = 'Can\'t create temporary files/directories (check permissions).';
 719      $returncodes[64] = 'Can\'t write to temporary directory (please specify another one).';
 720      $returncodes[70] = 'Can\'t allocate and clear memory (calloc).';
 721      $returncodes[71] = 'Can\'t allocate memory (malloc).';
 722      if ($returncodes[$returncode])
 723         return $returncodes[$returncode];
 724      return get_string('clamunknownerror');
 725  }