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
     * @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) {
        $extractor = new tgz_extractor($archivefile);
        return $extractor->extract(
                new tgz_packer_extract_to_pathname($pathname, $onlyfiles), $progress);
    }

    /**
     * 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;
    }
}