Current Path : C:/Users/Mahmood/Desktop/moodle/lib/filestorage/ |
Current File : C:/Users/Mahmood/Desktop/moodle/lib/filestorage/tgz_packer.php |
<?php // This file is part of Moodle - http://moodle.org/ // // Moodle is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // Moodle is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Moodle. If not, see <http://www.gnu.org/licenses/>. /** * Implementation of .tar.gz packer. * * A limited subset of the .tar format is supported. This packer can open files * that it wrote, but may not be able to open files from other sources, * especially if they use extensions. There are restrictions on file * length and character set of filenames. * * We generate POSIX-compliant ustar files. As a result, the following * restrictions apply to archive paths: * * - Filename may not be more than 100 characters. * - Total of path + filename may not be more than 256 characters. * - For path more than 155 characters it may or may not work. * - May not contain non-ASCII characters. * * @package core_files * @copyright 2013 The Open University * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ defined('MOODLE_INTERNAL') || die(); require_once("$CFG->libdir/filestorage/file_packer.php"); require_once("$CFG->libdir/filestorage/tgz_extractor.php"); /** * Utility class - handles all packing/unpacking of .tar.gz files. * * @package core_files * @category files * @copyright 2013 The Open University * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ class tgz_packer extends file_packer { /** * @var int Default timestamp used where unknown (Jan 1st 2013 00:00) */ const DEFAULT_TIMESTAMP = 1356998400; /** * @var string Name of special archive index file added by Moodle. */ const ARCHIVE_INDEX_FILE = '.ARCHIVE_INDEX'; /** * @var string Required text at start of archive index file before file count. */ const ARCHIVE_INDEX_COUNT_PREFIX = 'Moodle archive file index. Count: '; /** * @var bool If true, includes .ARCHIVE_INDEX file in root of tar file. */ protected $includeindex = true; /** * @var int Max value for total progress. */ const PROGRESS_MAX = 1000000; /** * @var int Tar files have a fixed block size of 512 bytes. */ const TAR_BLOCK_SIZE = 512; /** * Archive files and store the result in file storage. * * Any existing file at that location will be overwritten. * * @param array $files array from archive path => pathname or stored_file * @param int $contextid context ID * @param string $component component * @param string $filearea file area * @param int $itemid item ID * @param string $filepath file path * @param string $filename file name * @param int $userid user ID * @param bool $ignoreinvalidfiles true means ignore missing or invalid files, false means abort on any error * @param file_progress $progress Progress indicator callback or null if not required * @return stored_file|bool false if error stored_file instance if ok * @throws file_exception If file operations fail * @throws coding_exception If any archive paths do not meet the restrictions */ public function archive_to_storage(array $files, $contextid, $component, $filearea, $itemid, $filepath, $filename, $userid = null, $ignoreinvalidfiles = true, file_progress $progress = null) { global $CFG; // Set up a temporary location for the file. $tempfolder = $CFG->tempdir . '/core_files'; check_dir_exists($tempfolder); $tempfile = tempnam($tempfolder, '.tgz'); // Archive to the given path. if ($result = $this->archive_to_pathname($files, $tempfile, $ignoreinvalidfiles, $progress)) { // If there is an existing file, delete it. $fs = get_file_storage(); if ($existing = $fs->get_file($contextid, $component, $filearea, $itemid, $filepath, $filename)) { $existing->delete(); } $filerecord = array('contextid' => $contextid, 'component' => $component, 'filearea' => $filearea, 'itemid' => $itemid, 'filepath' => $filepath, 'filename' => $filename, 'userid' => $userid, 'mimetype' => 'application/x-tgz'); self::delete_existing_file_record($fs, $filerecord); $result = $fs->create_file_from_pathname($filerecord, $tempfile); } // Delete the temporary file (if created) and return. @unlink($tempfile); return $result; } /** * Wrapper function useful for deleting an existing file (if present) just * before creating a new one. * * @param file_storage $fs File storage * @param array $filerecord File record in same format used to create file */ public static function delete_existing_file_record(file_storage $fs, array $filerecord) { if ($existing = $fs->get_file($filerecord['contextid'], $filerecord['component'], $filerecord['filearea'], $filerecord['itemid'], $filerecord['filepath'], $filerecord['filename'])) { $existing->delete(); } } /** * By default, the .tar file includes a .ARCHIVE_INDEX file as its first * entry. This makes list_files much faster and allows for better progress * reporting. * * If you need to disable the inclusion of this file, use this function * before calling one of the archive_xx functions. * * @param bool $includeindex If true, includes index */ public function set_include_index($includeindex) { $this->includeindex = $includeindex; } /** * Archive files and store the result in an OS file. * * @param array $files array from archive path => pathname or stored_file * @param string $archivefile path to target zip file * @param bool $ignoreinvalidfiles true means ignore missing or invalid files, false means abort on any error * @param file_progress $progress Progress indicator callback or null if not required * @return bool true if file created, false if not * @throws coding_exception If any archive paths do not meet the restrictions */ public function archive_to_pathname(array $files, $archivefile, $ignoreinvalidfiles=true, file_progress $progress = null) { // Open .gz file. if (!($gz = gzopen($archivefile, 'wb'))) { return false; } try { // Because we update how we calculate progress after we already // analyse the directory list, we can't just use a number of files // as progress. Instead, progress always goes to PROGRESS_MAX // and we do estimates as a proportion of that. To begin with, // assume that counting files will be 10% of the work, so allocate // one-tenth of PROGRESS_MAX to the total of all files. if ($files) { $progressperfile = (int)(self::PROGRESS_MAX / (count($files) * 10)); } else { // If there are no files, avoid divide by zero. $progressperfile = 1; } $done = 0; // Expand the provided files into a complete list of single files. $expandedfiles = array(); foreach ($files as $archivepath => $file) { // Update progress if required. if ($progress) { $progress->progress($done, self::PROGRESS_MAX); } $done += $progressperfile; if (is_null($file)) { // Empty directory record. Ensure it ends in a /. if (!preg_match('~/$~', $archivepath)) { $archivepath .= '/'; } $expandedfiles[$archivepath] = null; } else if (is_string($file)) { // File specified as path on disk. if (!$this->list_files_path($expandedfiles, $archivepath, $file, $progress, $done)) { gzclose($gz); unlink($archivefile); return false; } } else if (is_array($file)) { // File specified as raw content in array. $expandedfiles[$archivepath] = $file; } else { // File specified as stored_file object. $this->list_files_stored($expandedfiles, $archivepath, $file); } } // Store the list of files as a special file that is first in the // archive. This contains enough information to implement list_files // if required later. $list = self::ARCHIVE_INDEX_COUNT_PREFIX . count($expandedfiles) . "\n"; $sizes = array(); $mtimes = array(); foreach ($expandedfiles as $archivepath => $file) { // Check archivepath doesn't contain any non-ASCII characters. if (!preg_match('~^[\x00-\xff]*$~', $archivepath)) { throw new coding_exception( 'Non-ASCII paths not supported: ' . $archivepath); } // Build up the details. $type = 'f'; $mtime = '?'; if (is_null($file)) { $type = 'd'; $size = 0; } else if (is_string($file)) { $stat = stat($file); $mtime = (int)$stat['mtime']; $size = (int)$stat['size']; } else if (is_array($file)) { $size = (int)strlen(reset($file)); } else { $mtime = (int)$file->get_timemodified(); $size = (int)$file->get_filesize(); } $sizes[$archivepath] = $size; $mtimes[$archivepath] = $mtime; // Write a line in the index. $list .= "$archivepath\t$type\t$size\t$mtime\n"; } // The index file is optional; only write into archive if needed. if ($this->includeindex) { // Put the index file into the archive. $this->write_tar_entry($gz, self::ARCHIVE_INDEX_FILE, null, strlen($list), '?', $list); } // Update progress ready for main stage. $done = (int)(self::PROGRESS_MAX / 10); if ($progress) { $progress->progress($done, self::PROGRESS_MAX); } if ($expandedfiles) { // The remaining 9/10ths of progress represents these files. $progressperfile = (int)((9 * self::PROGRESS_MAX) / (10 * count($expandedfiles))); } else { $progressperfile = 1; } // Actually write entries for each file/directory. foreach ($expandedfiles as $archivepath => $file) { if (is_null($file)) { // Null entry indicates a directory. $this->write_tar_entry($gz, $archivepath, null, $sizes[$archivepath], $mtimes[$archivepath]); } else if (is_string($file)) { // String indicates an OS file. $this->write_tar_entry($gz, $archivepath, $file, $sizes[$archivepath], $mtimes[$archivepath], null, $progress, $done); } else if (is_array($file)) { // Array indicates in-memory data. $data = reset($file); $this->write_tar_entry($gz, $archivepath, null, $sizes[$archivepath], $mtimes[$archivepath], $data, $progress, $done); } else { // Stored_file object. $this->write_tar_entry($gz, $archivepath, $file->get_content_file_handle(), $sizes[$archivepath], $mtimes[$archivepath], null, $progress, $done); } $done += $progressperfile; if ($progress) { $progress->progress($done, self::PROGRESS_MAX); } } // Finish tar file with two empty 512-byte records. gzwrite($gz, str_pad('', 2 * self::TAR_BLOCK_SIZE, "\x00")); gzclose($gz); return true; } catch (Exception $e) { // If there is an exception, delete the in-progress file. gzclose($gz); unlink($archivefile); throw $e; } } /** * Writes a single tar file to the archive, including its header record and * then the file contents. * * @param resource $gz Gzip file * @param string $archivepath Full path of file within archive * @param string|resource $file Full path of file on disk or file handle or null if none * @param int $size Size or 0 for directories * @param int|string $mtime Time or ? if unknown * @param string $content Actual content of file to write (null if using $filepath) * @param file_progress $progress Progress indicator or null if none * @param int $done Value for progress indicator * @return bool True if OK * @throws coding_exception If names aren't valid */ protected function write_tar_entry($gz, $archivepath, $file, $size, $mtime, $content = null, file_progress $progress = null, $done = 0) { // Header based on documentation of POSIX ustar format from: // http://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5&manpath=FreeBSD+8-current . // For directories, ensure name ends in a slash. $directory = false; if ($size === 0 && is_null($file)) { $directory = true; if (!preg_match('~/$~', $archivepath)) { $archivepath .= '/'; } $mode = '755'; } else { $mode = '644'; } // Split archivepath into name and prefix. $name = $archivepath; $prefix = ''; while (strlen($name) > 100) { $slash = strpos($name, '/'); if ($slash === false) { throw new coding_exception( 'Name cannot fit length restrictions (> 100 characters): ' . $archivepath); } if ($prefix !== '') { $prefix .= '/'; } $prefix .= substr($name, 0, $slash); $name = substr($name, $slash + 1); if (strlen($prefix) > 155) { throw new coding_exception( 'Name cannot fit length restrictions (path too long): ' . $archivepath); } } // Checksum performance is a bit slow because of having to call 'ord' // lots of times (it takes about 1/3 the time of the actual gzwrite // call). To improve performance of checksum calculation, we will // store all the non-zero, non-fixed bytes that need adding to the // checksum, and checksum only those bytes. $forchecksum = $name; // struct header_posix_ustar { // char name[100]; $header = str_pad($name, 100, "\x00"); // char mode[8]; // char uid[8]; // char gid[8]; $header .= '0000' . $mode . "\x000000000\x000000000\x00"; $forchecksum .= $mode; // char size[12]; $octalsize = decoct($size); if (strlen($octalsize) > 11) { throw new coding_exception( 'File too large for .tar file: ' . $archivepath . ' (' . $size . ' bytes)'); } $paddedsize = str_pad($octalsize, 11, '0', STR_PAD_LEFT); $forchecksum .= $paddedsize; $header .= $paddedsize . "\x00"; // char mtime[12]; if ($mtime === '?') { // Use a default timestamp rather than zero; GNU tar outputs // warnings about zeroes here. $mtime = self::DEFAULT_TIMESTAMP; } $octaltime = decoct($mtime); $paddedtime = str_pad($octaltime, 11, '0', STR_PAD_LEFT); $forchecksum .= $paddedtime; $header .= $paddedtime . "\x00"; // char checksum[8]; // Checksum needs to be completed later. $header .= ' '; // char typeflag[1]; $typeflag = $directory ? '5' : '0'; $forchecksum .= $typeflag; $header .= $typeflag; // char linkname[100]; $header .= str_pad('', 100, "\x00"); // char magic[6]; // char version[2]; $header .= "ustar\x0000"; // char uname[32]; // char gname[32]; // char devmajor[8]; // char devminor[8]; $header .= str_pad('', 80, "\x00"); // char prefix[155]; // char pad[12]; $header .= str_pad($prefix, 167, "\x00"); $forchecksum .= $prefix; // }; // We have now calculated the header, but without the checksum. To work // out the checksum, sum all the bytes that aren't fixed or zero, and add // to a standard value that contains all the fixed bytes. // The fixed non-zero bytes are: // // '000000000000000000 ustar00' // mode (except 3 digits), uid, gid, checksum space, magic number, version // // To calculate the number, call the calculate_checksum function on the // above string. The result is 1775. $checksum = 1775 + self::calculate_checksum($forchecksum); $octalchecksum = str_pad(decoct($checksum), 6, '0', STR_PAD_LEFT) . "\x00 "; // Slot it into place in the header. $header = substr($header, 0, 148) . $octalchecksum . substr($header, 156); if (strlen($header) != self::TAR_BLOCK_SIZE) { throw new coding_exception('Header block wrong size!!!!!'); } // Awesome, now write out the header. gzwrite($gz, $header); // Special pre-handler for OS filename. if (is_string($file)) { $file = fopen($file, 'rb'); if (!$file) { return false; } } if ($content !== null) { // Write in-memory content if any. if (strlen($content) !== $size) { throw new coding_exception('Mismatch between provided sizes: ' . $archivepath); } gzwrite($gz, $content); } else if ($file !== null) { // Write file content if any, using a 64KB buffer. $written = 0; $chunks = 0; while (true) { $data = fread($file, 65536); if ($data === false || strlen($data) == 0) { break; } $written += gzwrite($gz, $data); // After every megabyte of large files, update the progress // tracker (so there are no long gaps without progress). $chunks++; if ($chunks == 16) { $chunks = 0; if ($progress) { // This call always has the same values, but that gives // the tracker a chance to indicate indeterminate // progress and output something to avoid timeouts. $progress->progress($done, self::PROGRESS_MAX); } } } fclose($file); if ($written !== $size) { throw new coding_exception('Mismatch between provided sizes: ' . $archivepath . ' (was ' . $written . ', expected ' . $size . ')'); } } else if ($size != 0) { throw new coding_exception('Missing data file handle for non-empty file'); } // Pad out final 512-byte block in file, if applicable. $leftover = self::TAR_BLOCK_SIZE - ($size % self::TAR_BLOCK_SIZE); if ($leftover == 512) { $leftover = 0; } else { gzwrite($gz, str_pad('', $leftover, "\x00")); } return true; } /** * Calculates a checksum by summing all characters of the binary string * (treating them as unsigned numbers). * * @param string $str Input string * @return int Checksum */ protected static function calculate_checksum($str) { $checksum = 0; $checklength = strlen($str); for ($i = 0; $i < $checklength; $i++) { $checksum += ord($str[$i]); } return $checksum; } /** * Based on an OS path, adds either that path (if it's a file) or * all its children (if it's a directory) into the list of files to * archive. * * If a progress indicator is supplied and if this corresponds to a * directory, then it will be repeatedly called with the same values. This * allows the progress handler to respond in some way to avoid timeouts * if required. * * @param array $expandedfiles List of all files to archive (output) * @param string $archivepath Current path within archive * @param string $path OS path on disk * @param file_progress $progress Progress indicator or null if none * @param int $done Value for progress indicator * @return bool True if successful */ protected function list_files_path(array &$expandedfiles, $archivepath, $path, file_progress $progress = null, $done) { if (is_dir($path)) { // Unless we're using this directory as archive root, add a // directory entry. if ($archivepath != '') { // Add directory-creation record. $expandedfiles[$archivepath . '/'] = null; } // Loop through directory contents and recurse. if (!$handle = opendir($path)) { return false; } while (false !== ($entry = readdir($handle))) { if ($entry === '.' || $entry === '..') { continue; } $result = $this->list_files_path($expandedfiles, $archivepath . '/' . $entry, $path . '/' . $entry, $progress, $done); if (!$result) { return false; } if ($progress) { $progress->progress($done, self::PROGRESS_MAX); } } closedir($handle); } else { // Just add it to list. $expandedfiles[$archivepath] = $path; } return true; } /** * Based on a stored_file objects, adds either that file (if it's a file) or * all its children (if it's a directory) into the list of files to * archive. * * If a progress indicator is supplied and if this corresponds to a * directory, then it will be repeatedly called with the same values. This * allows the progress handler to respond in some way to avoid timeouts * if required. * * @param array $expandedfiles List of all files to archive (output) * @param string $archivepath Current path within archive * @param stored_file $file File object */ protected function list_files_stored(array &$expandedfiles, $archivepath, stored_file $file) { if ($file->is_directory()) { // Add a directory-creation record. $expandedfiles[$archivepath . '/'] = null; // Loop through directory contents (this is a recursive collection // of all children not just one directory). $fs = get_file_storage(); $baselength = strlen($file->get_filepath()); $files = $fs->get_directory_files( $file->get_contextid(), $file->get_component(), $file->get_filearea(), $file->get_itemid(), $file->get_filepath(), true, true); foreach ($files as $childfile) { // Get full pathname after original part. $path = $childfile->get_filepath(); $path = substr($path, $baselength); $path = $archivepath . '/' . $path; if ($childfile->is_directory()) { $childfile = null; } else { $path .= $childfile->get_filename(); } $expandedfiles[$path] = $childfile; } } else { // Just add it to list. $expandedfiles[$archivepath] = $file; } } /** * Extract file to given file path (real OS filesystem), existing files are overwritten. * * @param stored_file|string $archivefile full pathname of zip file or stored_file instance * @param string $pathname target directory * @param array $onlyfiles only extract files present in the array * @param file_progress $progress Progress indicator callback or null if not required * @param bool $returnbool Whether to return a basic true/false indicating error state, or full per-file error * details. * @return array list of processed files (name=>true) * @throws moodle_exception If error */ public function extract_to_pathname($archivefile, $pathname, array $onlyfiles = null, file_progress $progress = null, $returnbool = false) { $extractor = new tgz_extractor($archivefile); try { $result = $extractor->extract( new tgz_packer_extract_to_pathname($pathname, $onlyfiles), $progress); if ($returnbool) { if (!is_array($result)) { return false; } foreach ($result as $status) { if ($status !== true) { return false; } } return true; } else { return $result; } } catch (moodle_exception $e) { if ($returnbool) { return false; } else { throw $e; } } } /** * Extract file to given file path (real OS filesystem), existing files are overwritten. * * @param string|stored_file $archivefile full pathname of zip file or stored_file instance * @param int $contextid context ID * @param string $component component * @param string $filearea file area * @param int $itemid item ID * @param string $pathbase file path * @param int $userid user ID * @param file_progress $progress Progress indicator callback or null if not required * @return array list of processed files (name=>true) * @throws moodle_exception If error */ public function extract_to_storage($archivefile, $contextid, $component, $filearea, $itemid, $pathbase, $userid = null, file_progress $progress = null) { $extractor = new tgz_extractor($archivefile); return $extractor->extract( new tgz_packer_extract_to_storage($contextid, $component, $filearea, $itemid, $pathbase, $userid), $progress); } /** * Returns array of info about all files in archive. * * @param string|stored_file $archivefile * @return array of file infos */ public function list_files($archivefile) { $extractor = new tgz_extractor($archivefile); return $extractor->list_files(); } /** * Checks whether a file appears to be a .tar.gz file. * * @param string|stored_file $archivefile * @return bool True if file contains the gzip magic number */ public static function is_tgz_file($archivefile) { if (is_a($archivefile, 'stored_file')) { $fp = $archivefile->get_content_file_handle(); } else { $fp = fopen($archivefile, 'rb'); } $firstbytes = fread($fp, 2); fclose($fp); return ($firstbytes[0] == "\x1f" && $firstbytes[1] == "\x8b"); } /** * The zlib extension is required for this packer to work. This is a single * location for the code to check whether the extension is available. * * @deprecated since 2.7 Always true because zlib extension is now required. * * @return bool True if the zlib extension is available OK */ public static function has_required_extension() { return extension_loaded('zlib'); } } /** * Handles extraction to pathname. */ class tgz_packer_extract_to_pathname implements tgz_extractor_handler { /** * @var string Target directory for extract. */ protected $pathname; /** * @var array Array of files to extract (other files are skipped). */ protected $onlyfiles; /** * Constructor. * * @param string $pathname target directory * @param array $onlyfiles only extract files present in the array */ public function __construct($pathname, array $onlyfiles = null) { $this->pathname = $pathname; $this->onlyfiles = $onlyfiles; } /** * @see tgz_extractor_handler::tgz_start_file() */ public function tgz_start_file($archivepath) { // Check file restriction. if ($this->onlyfiles !== null && !in_array($archivepath, $this->onlyfiles)) { return null; } // Ensure directory exists and prepare filename. $fullpath = $this->pathname . '/' . $archivepath; check_dir_exists(dirname($fullpath)); return $fullpath; } /** * @see tgz_extractor_handler::tgz_end_file() */ public function tgz_end_file($archivepath, $realpath) { // Do nothing. } /** * @see tgz_extractor_handler::tgz_directory() */ public function tgz_directory($archivepath, $mtime) { // Check file restriction. if ($this->onlyfiles !== null && !in_array($archivepath, $this->onlyfiles)) { return false; } // Ensure directory exists. $fullpath = $this->pathname . '/' . $archivepath; check_dir_exists($fullpath); return true; } } /** * Handles extraction to file storage. */ class tgz_packer_extract_to_storage implements tgz_extractor_handler { /** * @var string Path to temp file. */ protected $tempfile; /** * @var int Context id for files. */ protected $contextid; /** * @var string Component name for files. */ protected $component; /** * @var string File area for files. */ protected $filearea; /** * @var int Item ID for files. */ protected $itemid; /** * @var string Base path for files (subfolders will go inside this). */ protected $pathbase; /** * @var int User id for files or null if none. */ protected $userid; /** * Constructor. * * @param int $contextid Context id for files. * @param string $component Component name for files. * @param string $filearea File area for files. * @param int $itemid Item ID for files. * @param string $pathbase Base path for files (subfolders will go inside this). * @param int $userid User id for files or null if none. */ public function __construct($contextid, $component, $filearea, $itemid, $pathbase, $userid) { global $CFG; // Store all data. $this->contextid = $contextid; $this->component = $component; $this->filearea = $filearea; $this->itemid = $itemid; $this->pathbase = $pathbase; $this->userid = $userid; // Obtain temp filename. $tempfolder = $CFG->tempdir . '/core_files'; check_dir_exists($tempfolder); $this->tempfile = tempnam($tempfolder, '.dat'); } /** * @see tgz_extractor_handler::tgz_start_file() */ public function tgz_start_file($archivepath) { // All files are stored in the same filename. return $this->tempfile; } /** * @see tgz_extractor_handler::tgz_end_file() */ public function tgz_end_file($archivepath, $realpath) { // Place temp file into storage. $fs = get_file_storage(); $filerecord = array('contextid' => $this->contextid, 'component' => $this->component, 'filearea' => $this->filearea, 'itemid' => $this->itemid); $filerecord['filepath'] = $this->pathbase . dirname($archivepath) . '/'; $filerecord['filename'] = basename($archivepath); if ($this->userid) { $filerecord['userid'] = $this->userid; } // Delete existing file (if any) and create new one. tgz_packer::delete_existing_file_record($fs, $filerecord); $fs->create_file_from_pathname($filerecord, $this->tempfile); unlink($this->tempfile); } /** * @see tgz_extractor_handler::tgz_directory() */ public function tgz_directory($archivepath, $mtime) { // Standardise path. if (!preg_match('~/$~', $archivepath)) { $archivepath .= '/'; } // Create directory if it doesn't already exist. $fs = get_file_storage(); if (!$fs->file_exists($this->contextid, $this->component, $this->filearea, $this->itemid, $this->pathbase . $archivepath, '.')) { $fs->create_directory($this->contextid, $this->component, $this->filearea, $this->itemid, $this->pathbase . $archivepath); } return true; } }