maxbytes are used to get the maxbytes from {@link get_max_upload_file_size()}.
* @param boolean $silent Whether to notify errors or not.
* @param boolean $allownull Whether we care if there's no file when we've set the input name.
* @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.
*/
function upload_manager($inputname='', $deleteothers=false, $handlecollisions=false, $course=null, $recoverifmultiple=false, $modbytes=0, $silent=false, $allownull=false, $allownullmultiple=true) {
global $CFG, $SITE;
if (empty($course->id)) {
$course = $SITE;
}
$this->config->deleteothers = $deleteothers;
$this->config->handlecollisions = $handlecollisions;
$this->config->recoverifmultiple = $recoverifmultiple;
$this->config->maxbytes = get_max_upload_file_size($CFG->maxbytes, $course->maxbytes, $modbytes);
$this->config->silent = $silent;
$this->config->allownull = $allownull;
$this->files = array();
$this->status = false;
$this->course = $course;
$this->inputname = $inputname;
if (empty($this->inputname)) {
$this->config->allownull = $allownullmultiple;
}
}
/**
* Gets all entries out of $_FILES and stores them locally in $files and then
* checks each one against {@link get_max_upload_file_size()} and calls {@link cleanfilename()}
* and scans them for viruses etc.
* @uses $CFG
* @uses $_FILES
* @return boolean
*/
function preprocess_files() {
global $CFG;
foreach ($_FILES as $name => $file) {
$this->status = true; // only set it to true here so that we can check if this function has been called.
if (empty($this->inputname) || $name == $this->inputname) { // if we have input name, only process if it matches.
$file['originalname'] = $file['name']; // do this first for the log.
$this->files[$name] = $file; // put it in first so we can get uploadlog out in print_upload_log.
$this->files[$name]['uploadlog'] = ''; // initialize error log
$this->status = $this->validate_file($this->files[$name]); // default to only allowing empty on multiple uploads.
if (!$this->status && ($this->files[$name]['error'] == 0 || $this->files[$name]['error'] == 4) && ($this->config->allownull || empty($this->inputname))) {
// this shouldn't cause everything to stop.. modules should be responsible for knowing which if any are compulsory.
continue;
}
if ($this->status && !empty($CFG->runclamonupload)) {
$this->status = clam_scan_moodle_file($this->files[$name],$this->course);
}
if (!$this->status) {
if (!$this->config->recoverifmultiple && count($this->files) > 1) {
$a->name = $this->files[$name]['originalname'];
$a->problem = $this->files[$name]['uploadlog'];
if (!$this->config->silent) {
notify(get_string('uploadfailednotrecovering','moodle',$a));
}
else {
$this->notify .= '
'. get_string('uploadfailednotrecovering','moodle',$a);
}
$this->status = false;
return false;
} else if (count($this->files) == 1) {
if (!$this->config->silent and !$this->config->allownull) {
notify($this->files[$name]['uploadlog']);
} else {
$this->notify .= '
'. $this->files[$name]['uploadlog'];
}
$this->status = false;
return false;
}
}
else {
$newname = clean_filename($this->files[$name]['name']);
if ($newname != $this->files[$name]['name']) {
$a->oldname = $this->files[$name]['name'];
$a->newname = $newname;
$this->files[$name]['uploadlog'] .= get_string('uploadrenamedchars','moodle', $a);
}
$this->files[$name]['name'] = $newname;
$this->files[$name]['clear'] = true; // ok to save.
$this->config->somethingtosave = true;
}
}
}
if (!is_array($_FILES) || count($_FILES) == 0) {
return $this->config->allownull;
}
$this->status = true;
return true; // if we've got this far it means that we're recovering so we want status to be ok.
}
/**
* Validates a single file entry from _FILES
*
* @param object $file The entry from _FILES to validate
* @return boolean True if ok.
*/
function validate_file(&$file) {
if (empty($file)) {
return false;
}
if (!is_uploaded_file($file['tmp_name']) || $file['size'] == 0) {
$file['uploadlog'] .= "\n".$this->get_file_upload_error($file);
return false;
}
if ($file['size'] > $this->config->maxbytes) {
$file['uploadlog'] .= "\n". get_string('uploadedfiletoobig', 'moodle', $this->config->maxbytes);
return false;
}
return true;
}
/**
* Moves all the files to the destination directory.
*
* @uses $CFG
* @uses $USER
* @param string $destination The destination directory.
* @return boolean status;
*/
function save_files($destination) {
global $CFG, $USER;
if (!$this->status) { // preprocess_files hasn't been run
$this->preprocess_files();
}
// if there are no files, bail before we create an empty directory.
if (empty($this->config->somethingtosave)) {
return true;
}
$savedsomething = false;
if ($this->status) {
if (!(strpos($destination, $CFG->dataroot) === false)) {
// take it out for giving to make_upload_directory
$destination = substr($destination, strlen($CFG->dataroot)+1);
}
if ($destination{strlen($destination)-1} == '/') { // strip off a trailing / if we have one
$destination = substr($destination, 0, -1);
}
if (!make_upload_directory($destination, true)) { //TODO maybe put this function here instead of moodlelib.php now.
$this->status = false;
return false;
}
$destination = $CFG->dataroot .'/'. $destination; // now add it back in so we have a full path
$exceptions = array(); //need this later if we're deleting other files.
foreach (array_keys($this->files) as $i) {
if (!$this->files[$i]['clear']) {
// not ok to save
continue;
}
if ($this->config->handlecollisions) {
$this->handle_filename_collision($destination, $this->files[$i]);
}
if (move_uploaded_file($this->files[$i]['tmp_name'], $destination.'/'.$this->files[$i]['name'])) {
chmod($destination .'/'. $this->files[$i]['name'], $CFG->directorypermissions);
$this->files[$i]['fullpath'] = $destination.'/'.$this->files[$i]['name'];
$this->files[$i]['uploadlog'] .= "\n".get_string('uploadedfile');
$this->files[$i]['saved'] = true;
$exceptions[] = $this->files[$i]['name'];
// now add it to the log (this is important so we know who to notify if a virus is found later on)
clam_log_upload($this->files[$i]['fullpath'], $this->course);
$savedsomething=true;
}
}
if ($savedsomething && $this->config->deleteothers) {
$this->delete_other_files($destination, $exceptions);
}
}
if (empty($savedsomething)) {
$this->status = false;
if ((empty($this->config->allownull) && !empty($this->inputname)) || (empty($this->inputname) && empty($this->config->allownullmultiple))) {
notify(get_string('uploadnofilefound'));
}
return false;
}
return $this->status;
}
/**
* Wrapper function that calls {@link preprocess_files()} and {@link viruscheck_files()} and then {@link save_files()}
* Modules that require the insert id in the filepath should not use this and call these functions seperately in the required order.
* @parameter string $destination Where to save the uploaded files to.
* @return boolean
*/
function process_file_uploads($destination) {
if ($this->preprocess_files()) {
return $this->save_files($destination);
}
return false;
}
/**
* Deletes all the files in a given directory except for the files in $exceptions (full paths)
*
* @param string $destination The directory to clean up.
* @param array $exceptions Full paths of files to KEEP.
*/
function delete_other_files($destination, $exceptions=null) {
$deletedsomething = false;
if ($filestodel = get_directory_list($destination)) {
foreach ($filestodel as $file) {
if (!is_array($exceptions) || !in_array($file, $exceptions)) {
unlink($destination .'/'. $file);
$deletedsomething = true;
}
}
}
if ($deletedsomething) {
if (!$this->config->silent) {
notify(get_string('uploadoldfilesdeleted'));
}
else {
$this->notify .= '
'. get_string('uploadoldfilesdeleted');
}
}
}
/**
* Handles filename collisions - if the desired filename exists it will rename it according to the pattern in $format
* @param string $destination Destination directory (to check existing files against)
* @param object $file Passed in by reference. The current file from $files we're processing.
* @return void - modifies &$file parameter.
*/
function handle_filename_collision($destination, &$file) {
if (!file_exists($destination .'/'. $file['name'])) {
return;
}
$parts = explode('.', $file['name']);
if (count($parts) > 1) {
$extension = '.'.array_pop($parts);
$name = implode('.', $parts);
} else {
$extension = '';
$name = $file['name'];
}
$current = 0;
if (preg_match('/^(.*)_(\d*)$/s', $name, $matches)) {
$name = $matches[1];
$current = (int)$matches[2];
}
$i = $current + 1;
while (!$this->check_before_renaming($destination, $name.'_'.$i.$extension, $file)) {
$i++;
}
$a = new object();
$a->oldname = $file['name'];
$file['name'] = $name.'_'.$i.$extension;
$a->newname = $file['name'];
$file['uploadlog'] .= "\n". get_string('uploadrenamedcollision','moodle', $a);
}
/**
* This function checks a potential filename against what's on the filesystem already and what's been saved already.
* @param string $destination Destination directory (to check existing files against)
* @param string $nametocheck The filename to be compared.
* @param object $file The current file from $files we're processing.
* return boolean
*/
function check_before_renaming($destination, $nametocheck, $file) {
if (!file_exists($destination .'/'. $nametocheck)) {
return true;
}
if ($this->config->deleteothers) {
foreach ($this->files as $tocheck) {
// 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..
if ($file['tmp_name'] != $tocheck['tmp_name'] && $tocheck['clear'] && $nametocheck == $tocheck['name'] && $tocheck['saved']) {
$collision = true;
}
}
if (!$collision) {
return true;
}
}
return false;
}
/**
* ?
*
* @param object $file Passed in by reference. The current file from $files we're processing.
* @return string
* @todo Finish documenting this function
*/
function get_file_upload_error(&$file) {
switch ($file['error']) {
case 0: // UPLOAD_ERR_OK
if ($file['size'] > 0) {
$errmessage = get_string('uploadproblem', $file['name']);
} else {
$errmessage = get_string('uploadnofilefound'); /// probably a dud file name
}
break;
case 1: // UPLOAD_ERR_INI_SIZE
$errmessage = get_string('uploadserverlimit');
break;
case 2: // UPLOAD_ERR_FORM_SIZE
$errmessage = get_string('uploadformlimit');
break;
case 3: // UPLOAD_ERR_PARTIAL
$errmessage = get_string('uploadpartialfile');
break;
case 4: // UPLOAD_ERR_NO_FILE
$errmessage = get_string('uploadnofilefound');
break;
// Note: there is no error with a value of 5
case 6: // UPLOAD_ERR_NO_TMP_DIR
$errmessage = get_string('uploadnotempdir');
break;
case 7: // UPLOAD_ERR_CANT_WRITE
$errmessage = get_string('uploadcantwrite');
break;
case 8: // UPLOAD_ERR_EXTENSION
$errmessage = get_string('uploadextension');
break;
default:
$errmessage = get_string('uploadproblem', $file['name']);
}
return $errmessage;
}
/**
* prints a log of everything that happened (of interest) to each file in _FILES
* @param $return - optional, defaults to false (log is echoed)
*/
function print_upload_log($return=false,$skipemptyifmultiple=false) {
$str = '';
foreach (array_keys($this->files) as $i => $key) {
if (count($this->files) > 1 && !empty($skipemptyifmultiple) && $this->files[$key]['error'] == 4) {
continue;
}
$str .= ''. get_string('uploadfilelog', 'moodle', $i+1) .' '
.((!empty($this->files[$key]['originalname'])) ? '('.$this->files[$key]['originalname'].')' : '')
.' :'. nl2br($this->files[$key]['uploadlog']) .'
';
}
if ($return) {
return $str;
}
echo $str;
}
/**
* If we're only handling one file (if inputname was given in the constructor) this will return the (possibly changed) filename of the file.
@return boolean
*/
function get_new_filename() {
if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
return $this->files[$this->inputname]['name'];
}
return false;
}
/**
* 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.
* @return boolean
*/
function get_new_filepath() {
if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
return $this->files[$this->inputname]['fullpath'];
}
return false;
}
/**
* If we're only handling one file (if inputname was given in the constructor) this will return the ORIGINAL filename of the file.
* @return boolean
*/
function get_original_filename() {
if (!empty($this->inputname) and count($this->files) == 1 and $this->files[$this->inputname]['error'] != 4) {
return $this->files[$this->inputname]['originalname'];
}
return false;
}
/**
* This function returns any errors wrapped up in red.
* @return string
*/
function get_errors() {
if (!empty($this->notify)) {
return '
'. $this->notify .'
'; } else { return null; } } } /************************************************************************************** THESE FUNCTIONS ARE OUTSIDE THE CLASS BECAUSE THEY NEED TO BE CALLED FROM OTHER PLACES. FOR EXAMPLE CLAM_HANDLE_INFECTED_FILE AND CLAM_REPLACE_INFECTED_FILE USED FROM CRON UPLOAD_PRINT_FORM_FRAGMENT DOESN'T REALLY BELONG IN THE CLASS BUT CERTAINLY IN THIS FILE ***************************************************************************************/ /** * This function prints out a number of upload form elements. * * @param int $numfiles The number of elements required (optional, defaults to 1) * @param array $names Array of element names to use (optional, defaults to FILE_n) * @param array $descriptions Array of strings to be printed out before each file bit. * @param boolean $uselabels -Whether to output text fields for file descriptions or not (optional, defaults to false) * @param array $labelnames Array of element names to use for labels (optional, defaults to LABEL_n) * @param int $coursebytes $coursebytes and $maxbytes are used to calculate upload max size ( using {@link get_max_upload_file_size}) * @param int $modbytes $coursebytes and $maxbytes are used to calculate upload max size ( using {@link get_max_upload_file_size}) * @param boolean $return -Whether to return the string (defaults to false - string is echoed) * @return string Form returned as string if $return is true */ function upload_print_form_fragment($numfiles=1, $names=null, $descriptions=null, $uselabels=false, $labelnames=null, $coursebytes=0, $modbytes=0, $return=false) { global $CFG; $maxbytes = get_max_upload_file_size($CFG->maxbytes, $coursebytes, $modbytes); $str = ''."\n"; for ($i = 0; $i < $numfiles; $i++) { if (is_array($descriptions) && !empty($descriptions[$i])) { $str .= ''. $descriptions[$i] .'