Collaboration diagram for ILIAS\Filesystem\Util\Archive\Unzip:

Public Member Functions
	__construct (protected UnzipOptions $options, FileStream $stream)
	Only the path of the passed stream is used, the stream itself is not kept. More...

	close ()
	Releases the file handle of the ZIP-file. More...

	getPaths ()

	getStreams ()

	getFileStreams ()

	getAmountOfDirectories ()

	getDirectories ()
	Yields the directory-paths of the currently open zip-archive. More...

	getAmountOfFiles ()

	getFiles ()
	Yields the file-paths of the currently open zip-archive. More...

	hasMultipleRootEntriesInZip ()

	isWithinLimits ()
	Guards against decompression bombs by checking the archive metadata (entry count, total uncompressed size and the uncompressed/compressed ratio) before any data is handed out. More...

	extract ()
	Extracting is the last operation on the archive in almost all cases, therefore the file handle of the ZIP-file is released afterwards, so the ZIP-file and its directory can be deleted immediately (which otherwise fails on e.g. More...

	hasZipReadingError ()

Data Fields
const	DS_UNIX = "/"

const	DS_WIN = "\\"

const	BASE_DIR = '.'

Protected Member Functions
	pathToStreamGenerator ()

Protected Attributes
const	URI = 'uri'

const	DIRECTORY_SEPARATOR = DIRECTORY_SEPARATOR

ZipArchive	$zip

bool	$error_reading_zip = false

string	$path_to_zip

Private Member Functions
	open ()

	calculateIsWithinLimits ()

	extractAndKeepOpen ()

Private Attributes
bool	$is_open = false

int	$amount_of_entries = 0

bool	$within_limits = null

Detailed Description

Author: Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 30 of file Unzip.php.

Constructor & Destructor Documentation

◆ __construct()

ILIAS\Filesystem\Util\Archive\Unzip::__construct	(	protected UnzipOptions	$options,
		FileStream	$stream
	)

Only the path of the passed stream is used, the stream itself is not kept.

This way a stream which is created just for the Unzip (e.g. Streams::ofResource(fopen(...))) is closed right away and does not keep the ZIP-file open.

Definition at line 51 of file Unzip.php.

      {
        $this->path_to_zip = (string) $stream->getMetadata(self::URI);
        $this->zip = new \ZipArchive();
        if ($this->open()) {
            $this->amount_of_entries = $this->zip->count();
        }
    }

References ILIAS\Filesystem\Util\Archive\Unzip\open().

Here is the call graph for this function:

Member Function Documentation

◆ calculateIsWithinLimits()

ILIAS\Filesystem\Util\Archive\Unzip::calculateIsWithinLimits ( )

private

Definition at line 250 of file Unzip.php.

                                              : bool
    {
        $max_entries = $this->options->getMaxAmountOfEntries();
        if ($max_entries > UnzipOptions::UNLIMITED && $this->amount_of_entries > $max_entries) {
            return false;
        }
 
        if (!$this->open()) {
            return false;
        }
 
        $total_compressed = 0;
        $total_uncompressed = 0;
        for ($i = 0; $i < $this->amount_of_entries; $i++) {
            $stat = $this->zip->statIndex($i, \ZipArchive::FL_UNCHANGED);
            if ($stat === false) {
                continue;
            }
            $total_compressed += max(0, (int) ($stat['comp_size'] ?? 0));
            $total_uncompressed += max(0, (int) ($stat['size'] ?? 0));
        }
 
        $max_uncompressed = $this->options->getMaxUncompressedSize();
        if ($max_uncompressed > UnzipOptions::UNLIMITED && $total_uncompressed > $max_uncompressed) {
            return false;
        }
 
        $max_ratio = $this->options->getMaxCompressionRatio();
        if (
            $max_ratio > UnzipOptions::UNLIMITED
            && $total_compressed > 0
            && $total_uncompressed > $this->options->getRatioCheckMinUncompressedSize()
            && ($total_uncompressed / $total_compressed) > $max_ratio
        ) {
            return false;
        }
 
        return true;
    }

References ILIAS\Filesystem\Util\Archive\Unzip\$amount_of_entries, ILIAS\Filesystem\Util\Archive\Unzip\open(), and ILIAS\Filesystem\Util\Archive\UnzipOptions\UNLIMITED.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\isWithinLimits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close()

ILIAS\Filesystem\Util\Archive\Unzip::close ( )

Releases the file handle of the ZIP-file.

extract() does this on its own, consumers which only read paths or streams can call this as soon as they are done, e.g. before deleting the ZIP-file. The archive is opened again if it is accessed after it has been closed.

Definition at line 85 of file Unzip.php.

                           : void
    {
        if (!$this->is_open) {
            return;
        }
        $this->zip->close();
        $this->is_open = false;
    }

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\extract().

Here is the caller graph for this function:

◆ extract()

ILIAS\Filesystem\Util\Archive\Unzip::extract ( )

Extracting is the last operation on the archive in almost all cases, therefore the file handle of the ZIP-file is released afterwards, so the ZIP-file and its directory can be deleted immediately (which otherwise fails on e.g.

NFS as long as the file is open).

Definition at line 295 of file Unzip.php.

                             : bool
    {
        try {
            return $this->extractAndKeepOpen();
        } finally {
            $this->close();
        }
    }

References ILIAS\Filesystem\Util\Archive\Unzip\close(), and ILIAS\Filesystem\Util\Archive\Unzip\extractAndKeepOpen().

Here is the call graph for this function:

◆ extractAndKeepOpen()

ILIAS\Filesystem\Util\Archive\Unzip::extractAndKeepOpen ( )

private

Definition at line 304 of file Unzip.php.

                                         : bool
    {
        if (!$this->open()) {
            return false;
        }
 
        if (!$this->isWithinLimits()) {
            return false;
        }
 
        $destination_path = $this->options->getZipOutputPath();
        if ($destination_path === null) {
            return false;
        }
 
        switch ($this->options->getDirectoryHandling()) {
            case ZipDirectoryHandling::KEEP_STRUCTURE:
                break;
            case ZipDirectoryHandling::ENSURE_SINGLE_TOP_DIR:
                // top directory with same name as the ZIP without suffix
                $sufix = '.' . pathinfo($this->path_to_zip, PATHINFO_EXTENSION);
                $top_directory = basename($this->path_to_zip, $sufix);
 
                // first we check if the ZIP contains the top directory
                $has_top_directory = true;
                foreach ($this->getPaths() as $path) {
                    $has_top_directory = str_starts_with($path, $top_directory) && $has_top_directory;
                }
 
                // if not, we prepend the top directory to the destination path
                if (!$has_top_directory) {
                    $destination_path .= self::DIRECTORY_SEPARATOR . $top_directory;
                }
                break;
            case ZipDirectoryHandling::FLAT_STRUCTURE:
                if (!is_dir($destination_path) && (!mkdir($destination_path, 0777, true) && !is_dir($destination_path))) {
                    throw new \RuntimeException(sprintf('Directory "%s" was not created', $destination_path));
                }
 
                foreach ($this->getStreams() as $stream) {
                    $uri = $stream->getMetadata(self::URI);
                    if (substr((string) $uri, -1) === self::DIRECTORY_SEPARATOR) {
                        $stream->close();
                        continue; // Skip directories
                    }
                    $file_name = Util::sanitizeFileName($destination_path . self::DIRECTORY_SEPARATOR . basename((string) $uri));
                    file_put_contents(
                        $file_name,
                        $stream->getContents()
                    );
                    $stream->close();
                }
                return true; // Stop here
        }
 
        $this->zip->extractTo($destination_path, iterator_to_array($this->getPaths()));
 
        return true;
    }

References ILIAS\Filesystem\Util\Archive\FLAT_STRUCTURE, ILIAS\Filesystem\Util\Archive\Unzip\getPaths(), ILIAS\Filesystem\Util\Archive\Unzip\getStreams(), ILIAS\Filesystem\Util\Archive\Unzip\isWithinLimits(), ILIAS\Filesystem\Util\Archive\Unzip\open(), and ILIAS\Filesystem\Util\sanitizeFileName().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\extract().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAmountOfDirectories()

ILIAS\Filesystem\Util\Archive\Unzip::getAmountOfDirectories ( )

Definition at line 151 of file Unzip.php.

                                            : int
    {
        return iterator_count($this->getDirectories());
    }

References ILIAS\Filesystem\Util\Archive\Unzip\getDirectories().

Here is the call graph for this function:

◆ getAmountOfFiles()

ILIAS\Filesystem\Util\Archive\Unzip::getAmountOfFiles ( )

Definition at line 189 of file Unzip.php.

                                      : int
    {
        return iterator_count($this->getFiles());
    }

References ILIAS\Filesystem\Util\Archive\Unzip\getFiles().

Here is the call graph for this function:

◆ getDirectories()

ILIAS\Filesystem\Util\Archive\Unzip::getDirectories ( )

Yields the directory-paths of the currently open zip-archive.

This fixes the issue that win and mac zip archives have different directory structures.

Returns: \Generator|string[]

Definition at line 161 of file Unzip.php.

                                    : \Generator
    {
        $directories = [];
        foreach ($this->getPaths() as $path) {
            if (substr($path, -1) === self::DS_UNIX || substr($path, -1) === self::DS_WIN) {
                $directories[] = $path;
                continue;
            }
            if ((str_contains($path, self::DS_UNIX) || str_contains($path, self::DS_WIN))) {
                $directories[] = dirname($path) . self::DIRECTORY_SEPARATOR;
            }
        }
 
        $directories_with_parents = [];
 
        foreach ($directories as $directory) {
            $parent = dirname($directory) . self::DIRECTORY_SEPARATOR;
            if ($parent !== self::BASE_DIR . self::DIRECTORY_SEPARATOR && !in_array($parent, $directories, true)) {
                $directories_with_parents[] = $parent;
            }
            $directories_with_parents[] = $directory;
        }
 
        $directories_with_parents = array_unique($directories_with_parents);
        sort($directories_with_parents);
        yield from $directories_with_parents;
    }

References ILIAS\Filesystem\Util\Archive\Unzip\DIRECTORY_SEPARATOR, ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\Filesystem\Util\Archive\Unzip\getPaths(), and ILIAS\UI\examples\Symbol\Glyph\Sort\sort().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\getAmountOfDirectories(), and ILIAS\Filesystem\Util\Archive\Unzip\hasMultipleRootEntriesInZip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFiles()

ILIAS\Filesystem\Util\Archive\Unzip::getFiles ( )

Yields the file-paths of the currently open zip-archive.

Returns: \Generator|string[]

Definition at line 198 of file Unzip.php.

                              : \Generator
    {
        $files = [];
        foreach ($this->getPaths() as $path) {
            if (substr($path, -1) !== self::DS_UNIX && substr($path, -1) !== self::DS_WIN) {
                $files[] = $path;
            }
        }
        sort($files);
        yield from $files;
    }

References $files, ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\Filesystem\Util\Archive\Unzip\getPaths(), and ILIAS\UI\examples\Symbol\Glyph\Sort\sort().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\getAmountOfFiles(), ILIAS\Filesystem\Util\Archive\Unzip\getFileStreams(), ILIAS\Filesystem\Util\Archive\Unzip\getStreams(), and ILIAS\Filesystem\Util\Archive\Unzip\hasMultipleRootEntriesInZip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFileStreams()

ILIAS\Filesystem\Util\Archive\Unzip::getFileStreams ( )

Returns: \Generator|FileStream[]

Definition at line 144 of file Unzip.php.

                                    : \Generator
    {
        $paths_to_stream_generator = $this->pathToStreamGenerator();
 
        yield from $paths_to_stream_generator($this->getFiles());
    }

References ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\Filesystem\Util\Archive\Unzip\getFiles(), and ILIAS\Filesystem\Util\Archive\Unzip\pathToStreamGenerator().

Here is the call graph for this function:

◆ getPaths()

ILIAS\Filesystem\Util\Archive\Unzip::getPaths ( )

Returns: \Generator<bool|string>

Definition at line 114 of file Unzip.php.

                              : \Generator
    {
        if (!$this->error_reading_zip && $this->isWithinLimits() && $this->open()) {
            for ($i = 0, $i_max = $this->amount_of_entries; $i < $i_max; $i++) {
                $path = $this->zip->getNameIndex($i, \ZipArchive::FL_UNCHANGED);
                if ($this->isPathIgnored($path, $this->options)) {
                    continue;
                }
                yield $path;
            }
        }
    }

References ILIAS\Filesystem\Util\Archive\Unzip\isWithinLimits(), and ILIAS\Filesystem\Util\Archive\Unzip\open().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\extractAndKeepOpen(), ILIAS\Filesystem\Util\Archive\Unzip\getDirectories(), ILIAS\Filesystem\Util\Archive\Unzip\getFiles(), and ILIAS\Filesystem\Util\Archive\Unzip\getStreams().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getStreams()

ILIAS\Filesystem\Util\Archive\Unzip::getStreams ( )

Returns: \Generator|FileStream[]

Definition at line 130 of file Unzip.php.

                                : \Generator
    {
        $paths_to_stream_generator = $this->pathToStreamGenerator();
 
        if ($this->options->getDirectoryHandling() === ZipDirectoryHandling::FLAT_STRUCTURE) {
            yield from $paths_to_stream_generator($this->getFiles());
        } else {
            yield from $paths_to_stream_generator($this->getPaths());
        }
    }

References ILIAS\Filesystem\Util\Archive\FLAT_STRUCTURE, ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), ILIAS\Filesystem\Util\Archive\Unzip\getFiles(), ILIAS\Filesystem\Util\Archive\Unzip\getPaths(), and ILIAS\Filesystem\Util\Archive\Unzip\pathToStreamGenerator().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\extractAndKeepOpen().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasMultipleRootEntriesInZip()

ILIAS\Filesystem\Util\Archive\Unzip::hasMultipleRootEntriesInZip ( )

Definition at line 210 of file Unzip.php.

                                                 : bool
    {
        $amount = 0;
        foreach ($this->getDirectories() as $zip_directory) {
            $dirname = dirname($zip_directory);
            if ($dirname === self::BASE_DIR) {
                $amount++;
            }
            if ($amount > 1) {
                return true;
            }
        }
        foreach ($this->getFiles() as $zip_file) {
            $dirname = dirname($zip_file);
            if ($dirname === self::BASE_DIR) {
                $amount++;
            }
            if ($amount > 1) {
                return true;
            }
        }
        return false;
    }

References ILIAS\Filesystem\Util\Archive\Unzip\getDirectories(), and ILIAS\Filesystem\Util\Archive\Unzip\getFiles().

Here is the call graph for this function:

◆ hasZipReadingError()

ILIAS\Filesystem\Util\Archive\Unzip::hasZipReadingError ( )

Definition at line 364 of file Unzip.php.

                                        : bool
    {
        return $this->error_reading_zip;
    }

References ILIAS\Filesystem\Util\Archive\Unzip\$error_reading_zip.

◆ isWithinLimits()

ILIAS\Filesystem\Util\Archive\Unzip::isWithinLimits ( )

Guards against decompression bombs by checking the archive metadata (entry count, total uncompressed size and the uncompressed/compressed ratio) before any data is handed out.

The sizes are read from the central directory via statIndex(); a crafted archive that lies about these sizes fails during the subsequent extraction anyway.

An archive that exceeds the limits behaves like an empty one: extract() returns false and all generators (getPaths(), getFiles(), getStreams(), getFileStreams(), ...) yield nothing. Callers that consume the streams themselves should ask this method first, so they can tell a rejected archive from an empty one and report it to the user.

Definition at line 245 of file Unzip.php.

                                    : bool
    {
        return $this->within_limits ??= $this->calculateIsWithinLimits();
    }

References ILIAS\Filesystem\Util\Archive\Unzip\calculateIsWithinLimits().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\extractAndKeepOpen(), and ILIAS\Filesystem\Util\Archive\Unzip\getPaths().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open()

ILIAS\Filesystem\Util\Archive\Unzip::open ( )

private

Definition at line 62 of file Unzip.php.

                           : bool
    {
        if ($this->is_open) {
            return true;
        }
        if ($this->error_reading_zip) {
            return false;
        }
        try {
            $this->is_open = $this->zip->open($this->path_to_zip, \ZipArchive::RDONLY) === true;
        } catch (\Throwable) {
            $this->is_open = false;
        }
        $this->error_reading_zip = !$this->is_open;
 
        return $this->is_open;
    }

References ILIAS\Filesystem\Util\Archive\Unzip\$is_open.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\__construct(), ILIAS\Filesystem\Util\Archive\Unzip\calculateIsWithinLimits(), ILIAS\Filesystem\Util\Archive\Unzip\extractAndKeepOpen(), ILIAS\Filesystem\Util\Archive\Unzip\getPaths(), and ILIAS\Filesystem\Util\Archive\Unzip\pathToStreamGenerator().

Here is the caller graph for this function:

◆ pathToStreamGenerator()

ILIAS\Filesystem\Util\Archive\Unzip::pathToStreamGenerator ( )

protected

Returns: \Closure

Definition at line 97 of file Unzip.php.

                                              : \Closure
    {
        return function (\Generator $paths): \Generator {
            foreach ($paths as $path) {
                if (!$this->open()) {
                    return;
                }
                $resource = $this->zip->getStream($path);
 
                yield Streams::ofResource($resource);
            }
        };
    }

References ILIAS\Filesystem\Stream\Streams\ofResource(), and ILIAS\Filesystem\Util\Archive\Unzip\open().

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\getFileStreams(), and ILIAS\Filesystem\Util\Archive\Unzip\getStreams().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ $amount_of_entries

int ILIAS\Filesystem\Util\Archive\Unzip::$amount_of_entries = 0

private

Definition at line 43 of file Unzip.php.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\calculateIsWithinLimits().

◆ $error_reading_zip

bool ILIAS\Filesystem\Util\Archive\Unzip::$error_reading_zip = false

protected

Definition at line 40 of file Unzip.php.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\hasZipReadingError().

◆ $is_open

bool ILIAS\Filesystem\Util\Archive\Unzip::$is_open = false

private

Definition at line 42 of file Unzip.php.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\open().

◆ $path_to_zip

string ILIAS\Filesystem\Util\Archive\Unzip::$path_to_zip

protected

Definition at line 41 of file Unzip.php.

◆ $within_limits

bool ILIAS\Filesystem\Util\Archive\Unzip::$within_limits = null

private

Definition at line 44 of file Unzip.php.

◆ $zip

ZipArchive ILIAS\Filesystem\Util\Archive\Unzip::$zip

protected

Definition at line 39 of file Unzip.php.

◆ BASE_DIR

const ILIAS\Filesystem\Util\Archive\Unzip::BASE_DIR = '.'

Definition at line 38 of file Unzip.php.

◆ DIRECTORY_SEPARATOR

const ILIAS\Filesystem\Util\Archive\Unzip::DIRECTORY_SEPARATOR = DIRECTORY_SEPARATOR

protected

Definition at line 35 of file Unzip.php.

Referenced by ILIAS\Filesystem\Util\Archive\Unzip\getDirectories().

◆ DS_UNIX

const ILIAS\Filesystem\Util\Archive\Unzip::DS_UNIX = "/"

Definition at line 36 of file Unzip.php.

◆ DS_WIN

const ILIAS\Filesystem\Util\Archive\Unzip::DS_WIN = "\\"

Definition at line 37 of file Unzip.php.

◆ URI

const ILIAS\Filesystem\Util\Archive\Unzip::URI = 'uri'

protected

Definition at line 34 of file Unzip.php.

The documentation for this class was generated from the following file:

components/ILIAS/Filesystem/src/Util/Archive/Unzip.php

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ calculateIsWithinLimits()

◆ close()

◆ extract()

◆ extractAndKeepOpen()

◆ getAmountOfDirectories()

◆ getAmountOfFiles()

◆ getDirectories()

◆ getFiles()

◆ getFileStreams()

◆ getPaths()

◆ getStreams()

◆ hasMultipleRootEntriesInZip()

◆ hasZipReadingError()

◆ isWithinLimits()

◆ open()

◆ pathToStreamGenerator()

Field Documentation

◆ $amount_of_entries

◆ $error_reading_zip

◆ $is_open

◆ $path_to_zip

◆ $within_limits

◆ $zip

◆ BASE_DIR

◆ DIRECTORY_SEPARATOR

◆ DS_UNIX

◆ DS_WIN

◆ URI