Proyectos de Subversion Moodle

<?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|null $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 , $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;

    }

}