tommaso/liceo-ariosto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
tommaso
2025-06-17 11:53:18 +02:00
commit 9f0f7ba12b
8804 changed files with 1369176 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

661
libraries/vendor/joomla/archive/src/Zip.php vendored Normal file
View File

@ -0,0 +1,661 @@
<?php
/**
* Part of the Joomla Framework Archive Package
*
* @copyright Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Archive;
use Joomla\Filesystem\File;
use Joomla\Filesystem\Folder;
use Joomla\Filesystem\Path;
/**
* ZIP format adapter for the Archive package
*
* The ZIP compression code is partially based on code from:
* Eric Mueller <eric@themepark.com>
* http://www.zend.com/codex.php?id=535&single=1
*
* Deins125 <webmaster@atlant.ru>
* http://www.zend.com/codex.php?id=470&single=1
*
* The ZIP compression date code is partially based on code from
* Peter Listiak <mlady@users.sourceforge.net>
*
* This class is inspired from and draws heavily in code and concept from the Compress package of
* The Horde Project <http://www.horde.org>
*
* @contributor Chuck Hagenbuch <chuck@horde.org>
* @contributor Michael Slusarz <slusarz@horde.org>
* @contributor Michael Cochrane <mike@graftonhall.co.nz>
*
* @since 1.0
*/
class Zip implements ExtractableInterface
{
/**
* ZIP compression methods.
*
* @var array
* @since 1.0
*/
private const METHODS = [
0x0 => 'None',
0x1 => 'Shrunk',
0x2 => 'Super Fast',
0x3 => 'Fast',
0x4 => 'Normal',
0x5 => 'Maximum',
0x6 => 'Imploded',
0x8 => 'Deflated',
];
/**
* Beginning of central directory record.
*
* @var string
* @since 1.0
*/
private const CTRL_DIR_HEADER = "\x50\x4b\x01\x02";
/**
* End of central directory record.
*
* @var string
* @since 1.0
*/
private const CTRL_DIR_END = "\x50\x4b\x05\x06\x00\x00\x00\x00";
/**
* Beginning of file contents.
*
* @var string
* @since 1.0
*/
private const FILE_HEADER = "\x50\x4b\x03\x04";
/**
* ZIP file data buffer
*
* @var string
* @since 1.0
*/
private $data;
/**
* ZIP file metadata array
*
* @var array
* @since 1.0
*/
private $metadata;
/**
* Holds the options array.
*
* @var array|\ArrayAccess
* @since 1.0
*/
protected $options = [];
/**
* Create a new Archive object.
*
* @param array|\ArrayAccess $options An array of options or an object that implements \ArrayAccess
*
* @since 1.0
* @throws \InvalidArgumentException
*/
public function __construct($options = [])
{
if (!\is_array($options) && !($options instanceof \ArrayAccess)) {
throw new \InvalidArgumentException(
'The options param must be an array or implement the ArrayAccess interface.'
);
}
$this->options = $options;
}
/**
* Create a ZIP compressed file from an array of file data.
*
* @param string $archive Path to save archive.
* @param array $files Array of files to add to archive.
*
* @return boolean True if successful.
*
* @since 1.0
* @todo Finish Implementation
*/
public function create($archive, $files)
{
$contents = [];
$ctrldir = [];
foreach ($files as $file) {
$this->addToZipFile($file, $contents, $ctrldir);
}
return $this->createZipFile($contents, $ctrldir, $archive);
}
/**
* Extract a ZIP compressed file to a given path
*
* @param string $archive Path to ZIP archive to extract
* @param string $destination Path to extract archive into
*
* @return boolean True if successful
*
* @since 1.0
* @throws \RuntimeException
*/
public function extract($archive, $destination)
{
if (!is_file($archive)) {
throw new \RuntimeException('Archive does not exist at ' . $archive);
}
if (static::hasNativeSupport()) {
return $this->extractNative($archive, $destination);
}
return $this->extractCustom($archive, $destination);
}
/**
* Tests whether this adapter can unpack files on this computer.
*
* @return boolean True if supported
*
* @since 1.0
*/
public static function isSupported()
{
return self::hasNativeSupport() || \extension_loaded('zlib');
}
/**
* Method to determine if the server has native zip support for faster handling
*
* @return boolean True if php has native ZIP support
*
* @since 1.0
*/
public static function hasNativeSupport()
{
return \extension_loaded('zip');
}
/**
* Checks to see if the data is a valid ZIP file.
*
* @param string $data ZIP archive data buffer.
*
* @return boolean True if valid, false if invalid.
*
* @since 1.0
*/
public function checkZipData($data)
{
return strpos($data, self::FILE_HEADER) !== false;
}
/**
* Extract a ZIP compressed file to a given path using a php based algorithm that only requires zlib support
*
* @param string $archive Path to ZIP archive to extract.
* @param string $destination Path to extract archive into.
*
* @return boolean True if successful
*
* @since 1.0
* @throws \RuntimeException
*/
protected function extractCustom($archive, $destination)
{
$this->metadata = [];
$this->data = file_get_contents($archive);
if (!$this->data) {
throw new \RuntimeException('Unable to read archive');
}
if (!$this->readZipInfo($this->data)) {
throw new \RuntimeException('Get ZIP Information failed');
}
foreach ($this->metadata as $i => $metadata) {
$lastPathCharacter = substr($metadata['name'], -1, 1);
if ($lastPathCharacter !== '/' && $lastPathCharacter !== '\\') {
$buffer = $this->getFileData($i);
$path = Path::clean($destination . '/' . $metadata['name']);
if (!$this->isBelow($destination, $destination . '/' . $metadata['name'])) {
throw new \OutOfBoundsException('Unable to write outside of destination path', 100);
}
// Make sure the destination folder exists
if (!Folder::create(\dirname($path))) {
throw new \RuntimeException('Unable to create destination folder');
}
if (!File::write($path, $buffer)) {
throw new \RuntimeException('Unable to write file');
}
}
}
return true;
}
/**
* Extract a ZIP compressed file to a given path using native php api calls for speed
*
* @param string $archive Path to ZIP archive to extract
* @param string $destination Path to extract archive into
*
* @return boolean True on success
*
* @throws \RuntimeException
* @since 1.0
*/
protected function extractNative($archive, $destination)
{
$zip = new \ZipArchive();
if ($zip->open($archive) !== true) {
throw new \RuntimeException('Unable to open archive');
}
// Make sure the destination folder exists
if (!Folder::create($destination)) {
throw new \RuntimeException('Unable to create destination folder ' . \dirname($destination));
}
// Read files in the archive
for ($index = 0; $index < $zip->numFiles; $index++) {
$file = $zip->getNameIndex($index);
if (substr($file, -1) === '/') {
continue;
}
$buffer = $zip->getFromIndex($index);
if ($buffer === false) {
throw new \RuntimeException('Unable to read ZIP entry');
}
if (!$this->isBelow($destination, $destination . '/' . $file)) {
throw new \RuntimeException('Unable to write outside of destination path', 100);
}
if (File::write($destination . '/' . $file, $buffer) === false) {
throw new \RuntimeException('Unable to write ZIP entry to file ' . $destination . '/' . $file);
}
}
$zip->close();
return true;
}
/**
* Get the list of files/data from a ZIP archive buffer.
*
* <pre>
* KEY: Position in zipfile
* VALUES: 'attr' -- File attributes
* 'crc' -- CRC checksum
* 'csize' -- Compressed file size
* 'date' -- File modification time
* 'name' -- Filename
* 'method'-- Compression method
* 'size' -- Original file size
* 'type' -- File type
* </pre>
*
* @param string $data The ZIP archive buffer.
*
* @return boolean True on success
*
* @since 1.0
* @throws \RuntimeException
*/
private function readZipInfo($data)
{
$entries = [];
// Find the last central directory header entry
$fhLast = strpos($data, self::CTRL_DIR_END);
do {
$last = $fhLast;
} while (($fhLast = strpos($data, self::CTRL_DIR_END, $fhLast + 1)) !== false);
// Find the central directory offset
$offset = 0;
if ($last) {
$endOfCentralDirectory = unpack(
'vNumberOfDisk/vNoOfDiskWithStartOfCentralDirectory/vNoOfCentralDirectoryEntriesOnDisk/' .
'vTotalCentralDirectoryEntries/VSizeOfCentralDirectory/VCentralDirectoryOffset/vCommentLength',
substr($data, $last + 4)
);
$offset = $endOfCentralDirectory['CentralDirectoryOffset'];
}
// Get details from central directory structure.
$fhStart = strpos($data, self::CTRL_DIR_HEADER, $offset);
$dataLength = \strlen($data);
do {
if ($dataLength < $fhStart + 31) {
throw new \RuntimeException('Invalid ZIP Data');
}
$info = unpack('vMethod/VTime/VCRC32/VCompressed/VUncompressed/vLength', substr($data, $fhStart + 10, 20));
$name = substr($data, $fhStart + 46, $info['Length']);
$entries[$name] = [
'attr' => null,
'crc' => sprintf('%08s', dechex($info['CRC32'])),
'csize' => $info['Compressed'],
'date' => null,
'_dataStart' => null,
'name' => $name,
'method' => self::METHODS[$info['Method']],
'_method' => $info['Method'],
'size' => $info['Uncompressed'],
'type' => null,
];
$entries[$name]['date'] = mktime(
($info['Time'] >> 11) & 0x1f,
($info['Time'] >> 5) & 0x3f,
($info['Time'] << 1) & 0x3e,
($info['Time'] >> 21) & 0x07,
($info['Time'] >> 16) & 0x1f,
(($info['Time'] >> 25) & 0x7f) + 1980
);
if ($dataLength < $fhStart + 43) {
throw new \RuntimeException('Invalid ZIP data');
}
$info = unpack('vInternal/VExternal/VOffset', substr($data, $fhStart + 36, 10));
$entries[$name]['type'] = ($info['Internal'] & 0x01) ? 'text' : 'binary';
$entries[$name]['attr'] = (($info['External'] & 0x10) ? 'D' : '-') . (($info['External'] & 0x20) ? 'A' : '-')
. (($info['External'] & 0x03) ? 'S' : '-') . (($info['External'] & 0x02) ? 'H' : '-') . (($info['External'] & 0x01) ? 'R' : '-');
$entries[$name]['offset'] = $info['Offset'];
// Get details from local file header since we have the offset
$lfhStart = strpos($data, self::FILE_HEADER, $entries[$name]['offset']);
if ($dataLength < $lfhStart + 34) {
throw new \RuntimeException('Invalid ZIP Data');
}
$info = unpack('vMethod/VTime/VCRC32/VCompressed/VUncompressed/vLength/vExtraLength', substr($data, $lfhStart + 8, 25));
$name = substr($data, $lfhStart + 30, $info['Length']);
$entries[$name]['_dataStart'] = $lfhStart + 30 + $info['Length'] + $info['ExtraLength'];
// Bump the max execution time because not using the built in php zip libs makes this process slow.
@set_time_limit(ini_get('max_execution_time'));
} while (($fhStart = strpos($data, self::CTRL_DIR_HEADER, $fhStart + 46)) !== false);
$this->metadata = array_values($entries);
return true;
}
/**
* Returns the file data for a file by offset in the ZIP archive
*
* @param integer $key The position of the file in the archive.
*
* @return string Uncompressed file data buffer.
*
* @since 1.0
*/
private function getFileData(int $key): string
{
if ($this->metadata[$key]['_method'] == 0x8) {
return gzinflate(substr($this->data, $this->metadata[$key]['_dataStart'], $this->metadata[$key]['csize']));
}
if ($this->metadata[$key]['_method'] == 0x0) {
// Files that aren't compressed.
return substr($this->data, $this->metadata[$key]['_dataStart'], $this->metadata[$key]['csize']);
}
if ($this->metadata[$key]['_method'] == 0x12) {
// If bz2 extension is loaded use it
if (\extension_loaded('bz2')) {
return bzdecompress(substr($this->data, $this->metadata[$key]['_dataStart'], $this->metadata[$key]['csize']));
}
}
return '';
}
/**
* Converts a UNIX timestamp to a 4-byte DOS date and time format (date in high 2-bytes, time in low 2-bytes allowing magnitude comparison).
*
* @param integer $unixtime The current UNIX timestamp.
*
* @return integer The current date in a 4-byte DOS format.
*
* @since 1.0
*/
protected function unix2DosTime($unixtime = null)
{
$timearray = $unixtime === null ? getdate() : getdate($unixtime);
if ($timearray['year'] < 1980) {
$timearray['year'] = 1980;
$timearray['mon'] = 1;
$timearray['mday'] = 1;
$timearray['hours'] = 0;
$timearray['minutes'] = 0;
$timearray['seconds'] = 0;
}
return (($timearray['year'] - 1980) << 25) | ($timearray['mon'] << 21) | ($timearray['mday'] << 16) | ($timearray['hours'] << 11) |
($timearray['minutes'] << 5) | ($timearray['seconds'] >> 1);
}
/**
* Adds a "file" to the ZIP archive.
*
* @param array $file File data array to add
* @param array $contents An array of existing zipped files.
* @param array $ctrldir An array of central directory information.
*
* @return void
*
* @since 1.0
* @todo Review and finish implementation
*/
private function addToZipFile(array &$file, array &$contents, array &$ctrldir): void
{
$data = &$file['data'];
$name = str_replace('\\', '/', $file['name']);
// See if time/date information has been provided.
$ftime = null;
if (isset($file['time'])) {
$ftime = $file['time'];
}
// Get the hex time.
$dtime = dechex($this->unix2DosTime($ftime));
$hexdtime = \chr(hexdec($dtime[6] . $dtime[7])) . \chr(hexdec($dtime[4] . $dtime[5])) . \chr(hexdec($dtime[2] . $dtime[3]))
. \chr(hexdec($dtime[0] . $dtime[1]));
// Begin creating the ZIP data.
$fr = self::FILE_HEADER;
// Version needed to extract.
$fr .= "\x14\x00";
// General purpose bit flag.
$fr .= "\x00\x00";
// Compression method.
$fr .= "\x08\x00";
// Last modification time/date.
$fr .= $hexdtime;
// "Local file header" segment.
$uncLen = \strlen($data);
$crc = crc32($data);
$zdata = gzcompress($data);
$zdata = substr(substr($zdata, 0, -4), 2);
$cLen = \strlen($zdata);
// CRC 32 information.
$fr .= pack('V', $crc);
// Compressed filesize.
$fr .= pack('V', $cLen);
// Uncompressed filesize.
$fr .= pack('V', $uncLen);
// Length of filename.
$fr .= pack('v', \strlen($name));
// Extra field length.
$fr .= pack('v', 0);
// File name.
$fr .= $name;
// "File data" segment.
$fr .= $zdata;
// Add this entry to array.
$oldOffset = \strlen(implode('', $contents));
$contents[] = &$fr;
// Add to central directory record.
$cdrec = self::CTRL_DIR_HEADER;
// Version made by.
$cdrec .= "\x00\x00";
// Version needed to extract
$cdrec .= "\x14\x00";
// General purpose bit flag
$cdrec .= "\x00\x00";
// Compression method
$cdrec .= "\x08\x00";
// Last mod time/date.
$cdrec .= $hexdtime;
// CRC 32 information.
$cdrec .= pack('V', $crc);
// Compressed filesize.
$cdrec .= pack('V', $cLen);
// Uncompressed filesize.
$cdrec .= pack('V', $uncLen);
// Length of filename.
$cdrec .= pack('v', \strlen($name));
// Extra field length.
$cdrec .= pack('v', 0);
// File comment length.
$cdrec .= pack('v', 0);
// Disk number start.
$cdrec .= pack('v', 0);
// Internal file attributes.
$cdrec .= pack('v', 0);
// External file attributes -'archive' bit set.
$cdrec .= pack('V', 32);
// Relative offset of local header.
$cdrec .= pack('V', $oldOffset);
// File name.
$cdrec .= $name;
// Save to central directory array.
$ctrldir[] = &$cdrec;
}
/**
* Creates the ZIP file.
*
* Official ZIP file format: http://www.pkware.com/appnote.txt
*
* @param array $contents An array of existing zipped files.
* @param array $ctrlDir An array of central directory information.
* @param string $path The path to store the archive.
*
* @return boolean True if successful
*
* @since 1.0
* @todo Review and finish implementation
*/
private function createZipFile(array $contents, array $ctrlDir, string $path): bool
{
$data = implode('', $contents);
$dir = implode('', $ctrlDir);
/*
* Buffer data:
* Total # of entries "on this disk".
* Total # of entries overall.
* Size of central directory.
* Offset to start of central dir.
* ZIP file comment length.
*/
$buffer = $data . $dir . self::CTRL_DIR_END .
pack('v', \count($ctrlDir)) .
pack('v', \count($ctrlDir)) .
pack('V', \strlen($dir)) .
pack('V', \strlen($data)) .
"\x00\x00";
return File::write($path, $buffer);
}
/**
* Check if a path is below a given destination path
*
* @param string $destination The destination path
* @param string $path The path to be checked
*
* @return boolean
*
* @since 1.1.10
*/
private function isBelow($destination, $path): bool
{
$absoluteRoot = Path::clean(Path::resolve($destination));
$absolutePath = Path::clean(Path::resolve($path));
return strpos($absolutePath, $absoluteRoot) === 0;
}
}