Release of v3.2.5
Add [AllowDynamicProperties] in the base view class for J5. Move the _prepareDocument above the display call in the base view class. Remove all backward compatibility issues, so JCB will not need the [Backward Compatibility] plugin to run. Added new import powers for custom import of spreadsheets. Move the setDocument and _prepareDocument above the display in the site view and custom admin view. Update the trashhelper layout to work in Joomla 5. Add AllowDynamicProperties (Joomla 4+5) to view class to allow Custom Dynamic Get methods to work without issues. Fix Save failed issue in dynamicGet. #1148. Move all [TEXT, EDITOR, TEXTAREA] fields from [NOT NULL] to [NULL]. Add the DateHelper class and improve the date methods. Add simple SessionHelper class. Add first classes for the new import engine. Improve the [VDM Registry] to be Joomla Registry Compatible. Move all registries to the [VDM Registry] class. Fix Checked Out to be null and not 0. (#1194). Fix created_by, modified_by, checked_out fields in the compiler of the SQL. (#1194). Update all core date fields in table class. (#1188). Update created_by, modified_by, checked_out fields in table class. Implementation of the decentralized Super-Power CORE repository network. (#1190). Fix the noticeboard to display Llewellyn's Joomla Social feed.
This commit is contained in:
864
libraries/phpspreadsheet/vendor/maennchen/zipstream-php/src/ZipStream.php
vendored
Normal file
864
libraries/phpspreadsheet/vendor/maennchen/zipstream-php/src/ZipStream.php
vendored
Normal file
@@ -0,0 +1,864 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace ZipStream;
|
||||
|
||||
use Closure;
|
||||
use DateTimeImmutable;
|
||||
use DateTimeInterface;
|
||||
use GuzzleHttp\Psr7\StreamWrapper;
|
||||
use Psr\Http\Message\StreamInterface;
|
||||
use RuntimeException;
|
||||
use ZipStream\Exception\FileNotFoundException;
|
||||
use ZipStream\Exception\FileNotReadableException;
|
||||
use ZipStream\Exception\OverflowException;
|
||||
use ZipStream\Exception\ResourceActionException;
|
||||
|
||||
/**
|
||||
* Streamed, dynamically generated zip archives.
|
||||
*
|
||||
* ## Usage
|
||||
*
|
||||
* Streaming zip archives is a simple, three-step process:
|
||||
*
|
||||
* 1. Create the zip stream:
|
||||
*
|
||||
* ```php
|
||||
* $zip = new ZipStream(outputName: 'example.zip');
|
||||
* ```
|
||||
*
|
||||
* 2. Add one or more files to the archive:
|
||||
*
|
||||
* ```php
|
||||
* // add first file
|
||||
* $zip->addFile(fileName: 'world.txt', data: 'Hello World');
|
||||
*
|
||||
* // add second file
|
||||
* $zip->addFile(fileName: 'moon.txt', data: 'Hello Moon');
|
||||
* ```
|
||||
*
|
||||
* 3. Finish the zip stream:
|
||||
*
|
||||
* ```php
|
||||
* $zip->finish();
|
||||
* ```
|
||||
*
|
||||
* You can also add an archive comment, add comments to individual files,
|
||||
* and adjust the timestamp of files. See the API documentation for each
|
||||
* method below for additional information.
|
||||
*
|
||||
* ## Example
|
||||
*
|
||||
* ```php
|
||||
* // create a new zip stream object
|
||||
* $zip = new ZipStream(outputName: 'some_files.zip');
|
||||
*
|
||||
* // list of local files
|
||||
* $files = array('foo.txt', 'bar.jpg');
|
||||
*
|
||||
* // read and add each file to the archive
|
||||
* foreach ($files as $path)
|
||||
* $zip->addFileFormPath(fileName: $path, $path);
|
||||
*
|
||||
* // write archive footer to stream
|
||||
* $zip->finish();
|
||||
* ```
|
||||
*/
|
||||
class ZipStream
|
||||
{
|
||||
/**
|
||||
* This number corresponds to the ZIP version/OS used (2 bytes)
|
||||
* From: https://www.iana.org/assignments/media-types/application/zip
|
||||
* The upper byte (leftmost one) indicates the host system (OS) for the
|
||||
* file. Software can use this information to determine
|
||||
* the line record format for text files etc. The current
|
||||
* mappings are:
|
||||
*
|
||||
* 0 - MS-DOS and OS/2 (F.A.T. file systems)
|
||||
* 1 - Amiga 2 - VAX/VMS
|
||||
* 3 - *nix 4 - VM/CMS
|
||||
* 5 - Atari ST 6 - OS/2 H.P.F.S.
|
||||
* 7 - Macintosh 8 - Z-System
|
||||
* 9 - CP/M 10 thru 255 - unused
|
||||
*
|
||||
* The lower byte (rightmost one) indicates the version number of the
|
||||
* software used to encode the file. The value/10
|
||||
* indicates the major version number, and the value
|
||||
* mod 10 is the minor version number.
|
||||
* Here we are using 6 for the OS, indicating OS/2 H.P.F.S.
|
||||
* to prevent file permissions issues upon extract (see #84)
|
||||
* 0x603 is 00000110 00000011 in binary, so 6 and 3
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
public const ZIP_VERSION_MADE_BY = 0x603;
|
||||
|
||||
private bool $ready = true;
|
||||
|
||||
private int $offset = 0;
|
||||
|
||||
/**
|
||||
* @var string[]
|
||||
*/
|
||||
private array $centralDirectoryRecords = [];
|
||||
|
||||
/**
|
||||
* @var resource
|
||||
*/
|
||||
private $outputStream;
|
||||
|
||||
private readonly Closure $httpHeaderCallback;
|
||||
|
||||
/**
|
||||
* @var File[]
|
||||
*/
|
||||
private array $recordedSimulation = [];
|
||||
|
||||
/**
|
||||
* Create a new ZipStream object.
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* // create a new zip file named 'foo.zip'
|
||||
* $zip = new ZipStream(outputName: 'foo.zip');
|
||||
*
|
||||
* // create a new zip file named 'bar.zip' with a comment
|
||||
* $zip = new ZipStream(
|
||||
* outputName: 'bar.zip',
|
||||
* comment: 'this is a comment for the zip file.',
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* @param OperationMode $operationMode
|
||||
* The mode can be used to switch between `NORMAL` and `SIMULATION_*` modes.
|
||||
* For details see the `OperationMode` documentation.
|
||||
*
|
||||
* Default to `NORMAL`.
|
||||
*
|
||||
* @param string $comment
|
||||
* Archive Level Comment
|
||||
*
|
||||
* @param StreamInterface|resource|null $outputStream
|
||||
* Override the output of the archive to a different target.
|
||||
*
|
||||
* By default the archive is sent to `STDOUT`.
|
||||
*
|
||||
* @param CompressionMethod $defaultCompressionMethod
|
||||
* How to handle file compression. Legal values are
|
||||
* `CompressionMethod::DEFLATE` (the default), or
|
||||
* `CompressionMethod::STORE`. `STORE` sends the file raw and is
|
||||
* significantly faster, while `DEFLATE` compresses the file and
|
||||
* is much, much slower.
|
||||
*
|
||||
* @param int $defaultDeflateLevel
|
||||
* Default deflation level. Only relevant if `compressionMethod`
|
||||
* is `DEFLATE`.
|
||||
*
|
||||
* See details of [`deflate_init`](https://www.php.net/manual/en/function.deflate-init.php#refsect1-function.deflate-init-parameters)
|
||||
*
|
||||
* @param bool $enableZip64
|
||||
* Enable Zip64 extension, supporting very large
|
||||
* archives (any size > 4 GB or file count > 64k)
|
||||
*
|
||||
* @param bool $defaultEnableZeroHeader
|
||||
* Enable streaming files with single read.
|
||||
*
|
||||
* When the zero header is set, the file is streamed into the output
|
||||
* and the size & checksum are added at the end of the file. This is the
|
||||
* fastest method and uses the least memory. Unfortunately not all
|
||||
* ZIP clients fully support this and can lead to clients reporting
|
||||
* the generated ZIP files as corrupted in combination with other
|
||||
* circumstances. (Zip64 enabled, using UTF8 in comments / names etc.)
|
||||
*
|
||||
* When the zero header is not set, the length & checksum need to be
|
||||
* defined before the file is actually added. To prevent loading all
|
||||
* the data into memory, the data has to be read twice. If the data
|
||||
* which is added is not seekable, this call will fail.
|
||||
*
|
||||
* @param bool $sendHttpHeaders
|
||||
* Boolean indicating whether or not to send
|
||||
* the HTTP headers for this file.
|
||||
*
|
||||
* @param ?Closure $httpHeaderCallback
|
||||
* The method called to send HTTP headers
|
||||
*
|
||||
* @param string|null $outputName
|
||||
* The name of the created archive.
|
||||
*
|
||||
* Only relevant if `$sendHttpHeaders = true`.
|
||||
*
|
||||
* @param string $contentDisposition
|
||||
* HTTP Content-Disposition
|
||||
*
|
||||
* Only relevant if `sendHttpHeaders = true`.
|
||||
*
|
||||
* @param string $contentType
|
||||
* HTTP Content Type
|
||||
*
|
||||
* Only relevant if `sendHttpHeaders = true`.
|
||||
*
|
||||
* @param bool $flushOutput
|
||||
* Enable flush after every write to output stream.
|
||||
*
|
||||
* @return self
|
||||
*/
|
||||
public function __construct(
|
||||
private OperationMode $operationMode = OperationMode::NORMAL,
|
||||
private readonly string $comment = '',
|
||||
$outputStream = null,
|
||||
private readonly CompressionMethod $defaultCompressionMethod = CompressionMethod::DEFLATE,
|
||||
private readonly int $defaultDeflateLevel = 6,
|
||||
private readonly bool $enableZip64 = true,
|
||||
private readonly bool $defaultEnableZeroHeader = true,
|
||||
private bool $sendHttpHeaders = true,
|
||||
?Closure $httpHeaderCallback = null,
|
||||
private readonly ?string $outputName = null,
|
||||
private readonly string $contentDisposition = 'attachment',
|
||||
private readonly string $contentType = 'application/x-zip',
|
||||
private bool $flushOutput = false,
|
||||
) {
|
||||
$this->outputStream = self::normalizeStream($outputStream);
|
||||
$this->httpHeaderCallback = $httpHeaderCallback ?? header(...);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a file to the archive.
|
||||
*
|
||||
* ##### File Options
|
||||
*
|
||||
* See {@see addFileFromPsr7Stream()}
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* // add a file named 'world.txt'
|
||||
* $zip->addFile(fileName: 'world.txt', data: 'Hello World!');
|
||||
*
|
||||
* // add a file named 'bar.jpg' with a comment and a last-modified
|
||||
* // time of two hours ago
|
||||
* $zip->addFile(
|
||||
* fileName: 'bar.jpg',
|
||||
* data: $data,
|
||||
* comment: 'this is a comment about bar.jpg',
|
||||
* lastModificationDateTime: new DateTime('2 hours ago'),
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* @param string $data
|
||||
*
|
||||
* contents of file
|
||||
*/
|
||||
public function addFile(
|
||||
string $fileName,
|
||||
string $data,
|
||||
string $comment = '',
|
||||
?CompressionMethod $compressionMethod = null,
|
||||
?int $deflateLevel = null,
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
?int $maxSize = null,
|
||||
?int $exactSize = null,
|
||||
?bool $enableZeroHeader = null,
|
||||
): void {
|
||||
$this->addFileFromCallback(
|
||||
fileName: $fileName,
|
||||
callback: fn () => $data,
|
||||
comment: $comment,
|
||||
compressionMethod: $compressionMethod,
|
||||
deflateLevel: $deflateLevel,
|
||||
lastModificationDateTime: $lastModificationDateTime,
|
||||
maxSize: $maxSize,
|
||||
exactSize: $exactSize,
|
||||
enableZeroHeader: $enableZeroHeader,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a file at path to the archive.
|
||||
*
|
||||
* ##### File Options
|
||||
*
|
||||
* See {@see addFileFromPsr7Stream()}
|
||||
*
|
||||
* ###### Examples
|
||||
*
|
||||
* ```php
|
||||
* // add a file named 'foo.txt' from the local file '/tmp/foo.txt'
|
||||
* $zip->addFileFromPath(
|
||||
* fileName: 'foo.txt',
|
||||
* path: '/tmp/foo.txt',
|
||||
* );
|
||||
*
|
||||
* // add a file named 'bigfile.rar' from the local file
|
||||
* // '/usr/share/bigfile.rar' with a comment and a last-modified
|
||||
* // time of two hours ago
|
||||
* $zip->addFile(
|
||||
* fileName: 'bigfile.rar',
|
||||
* path: '/usr/share/bigfile.rar',
|
||||
* comment: 'this is a comment about bigfile.rar',
|
||||
* lastModificationDateTime: new DateTime('2 hours ago'),
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* @throws \ZipStream\Exception\FileNotFoundException
|
||||
* @throws \ZipStream\Exception\FileNotReadableException
|
||||
*/
|
||||
public function addFileFromPath(
|
||||
/**
|
||||
* name of file in archive (including directory path).
|
||||
*/
|
||||
string $fileName,
|
||||
|
||||
/**
|
||||
* path to file on disk (note: paths should be encoded using
|
||||
* UNIX-style forward slashes -- e.g '/path/to/some/file').
|
||||
*/
|
||||
string $path,
|
||||
string $comment = '',
|
||||
?CompressionMethod $compressionMethod = null,
|
||||
?int $deflateLevel = null,
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
?int $maxSize = null,
|
||||
?int $exactSize = null,
|
||||
?bool $enableZeroHeader = null,
|
||||
): void {
|
||||
if (!is_readable($path)) {
|
||||
if (!file_exists($path)) {
|
||||
throw new FileNotFoundException($path);
|
||||
}
|
||||
throw new FileNotReadableException($path);
|
||||
}
|
||||
|
||||
if ($fileTime = filemtime($path)) {
|
||||
$lastModificationDateTime ??= (new DateTimeImmutable())->setTimestamp($fileTime);
|
||||
}
|
||||
|
||||
$this->addFileFromCallback(
|
||||
fileName: $fileName,
|
||||
callback: function () use ($path) {
|
||||
|
||||
$stream = fopen($path, 'rb');
|
||||
|
||||
if (!$stream) {
|
||||
// @codeCoverageIgnoreStart
|
||||
throw new ResourceActionException('fopen');
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
|
||||
return $stream;
|
||||
},
|
||||
comment: $comment,
|
||||
compressionMethod: $compressionMethod,
|
||||
deflateLevel: $deflateLevel,
|
||||
lastModificationDateTime: $lastModificationDateTime,
|
||||
maxSize: $maxSize,
|
||||
exactSize: $exactSize,
|
||||
enableZeroHeader: $enableZeroHeader,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an open stream (resource) to the archive.
|
||||
*
|
||||
* ##### File Options
|
||||
*
|
||||
* See {@see addFileFromPsr7Stream()}
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* // create a temporary file stream and write text to it
|
||||
* $filePointer = tmpfile();
|
||||
* fwrite($filePointer, 'The quick brown fox jumped over the lazy dog.');
|
||||
*
|
||||
* // add a file named 'streamfile.txt' from the content of the stream
|
||||
* $archive->addFileFromStream(
|
||||
* fileName: 'streamfile.txt',
|
||||
* stream: $filePointer,
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* @param resource $stream contents of file as a stream resource
|
||||
*/
|
||||
public function addFileFromStream(
|
||||
string $fileName,
|
||||
$stream,
|
||||
string $comment = '',
|
||||
?CompressionMethod $compressionMethod = null,
|
||||
?int $deflateLevel = null,
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
?int $maxSize = null,
|
||||
?int $exactSize = null,
|
||||
?bool $enableZeroHeader = null,
|
||||
): void {
|
||||
$this->addFileFromCallback(
|
||||
fileName: $fileName,
|
||||
callback: fn () => $stream,
|
||||
comment: $comment,
|
||||
compressionMethod: $compressionMethod,
|
||||
deflateLevel: $deflateLevel,
|
||||
lastModificationDateTime: $lastModificationDateTime,
|
||||
maxSize: $maxSize,
|
||||
exactSize: $exactSize,
|
||||
enableZeroHeader: $enableZeroHeader,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an open stream to the archive.
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* $stream = $response->getBody();
|
||||
* // add a file named 'streamfile.txt' from the content of the stream
|
||||
* $archive->addFileFromPsr7Stream(
|
||||
* fileName: 'streamfile.txt',
|
||||
* stream: $stream,
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* @param string $fileName
|
||||
* path of file in archive (including directory)
|
||||
*
|
||||
* @param StreamInterface $stream
|
||||
* contents of file as a stream resource
|
||||
*
|
||||
* @param string $comment
|
||||
* ZIP comment for this file
|
||||
*
|
||||
* @param ?CompressionMethod $compressionMethod
|
||||
* Override `defaultCompressionMethod`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*
|
||||
* @param ?int $deflateLevel
|
||||
* Override `defaultDeflateLevel`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*
|
||||
* @param ?DateTimeInterface $lastModificationDateTime
|
||||
* Set last modification time of file.
|
||||
*
|
||||
* Default: `now`
|
||||
*
|
||||
* @param ?int $maxSize
|
||||
* Only read `maxSize` bytes from file.
|
||||
*
|
||||
* The file is considered done when either reaching `EOF`
|
||||
* or the `maxSize`.
|
||||
*
|
||||
* @param ?int $exactSize
|
||||
* Read exactly `exactSize` bytes from file.
|
||||
* If `EOF` is reached before reading `exactSize` bytes, an error will be
|
||||
* thrown. The parameter allows for faster size calculations if the `stream`
|
||||
* does not support `fstat` size or is slow and otherwise known beforehand.
|
||||
*
|
||||
* @param ?bool $enableZeroHeader
|
||||
* Override `defaultEnableZeroHeader`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*/
|
||||
public function addFileFromPsr7Stream(
|
||||
string $fileName,
|
||||
StreamInterface $stream,
|
||||
string $comment = '',
|
||||
?CompressionMethod $compressionMethod = null,
|
||||
?int $deflateLevel = null,
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
?int $maxSize = null,
|
||||
?int $exactSize = null,
|
||||
?bool $enableZeroHeader = null,
|
||||
): void {
|
||||
$this->addFileFromCallback(
|
||||
fileName: $fileName,
|
||||
callback: fn () => $stream,
|
||||
comment: $comment,
|
||||
compressionMethod: $compressionMethod,
|
||||
deflateLevel: $deflateLevel,
|
||||
lastModificationDateTime: $lastModificationDateTime,
|
||||
maxSize: $maxSize,
|
||||
exactSize: $exactSize,
|
||||
enableZeroHeader: $enableZeroHeader,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a file based on a callback.
|
||||
*
|
||||
* This is useful when you want to simulate a lot of files without keeping
|
||||
* all of the file handles open at the same time.
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* foreach($files as $name => $size) {
|
||||
* $archive->addFileFromPsr7Stream(
|
||||
* fileName: 'streamfile.txt',
|
||||
* exactSize: $size,
|
||||
* callback: function() use($name): Psr\Http\Message\StreamInterface {
|
||||
* $response = download($name);
|
||||
* return $response->getBody();
|
||||
* }
|
||||
* );
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* @param string $fileName
|
||||
* path of file in archive (including directory)
|
||||
*
|
||||
* @param Closure $callback
|
||||
* @psalm-param Closure(): (resource|StreamInterface|string) $callback
|
||||
* A callback to get the file contents in the shape of a PHP stream,
|
||||
* a Psr StreamInterface implementation, or a string.
|
||||
*
|
||||
* @param string $comment
|
||||
* ZIP comment for this file
|
||||
*
|
||||
* @param ?CompressionMethod $compressionMethod
|
||||
* Override `defaultCompressionMethod`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*
|
||||
* @param ?int $deflateLevel
|
||||
* Override `defaultDeflateLevel`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*
|
||||
* @param ?DateTimeInterface $lastModificationDateTime
|
||||
* Set last modification time of file.
|
||||
*
|
||||
* Default: `now`
|
||||
*
|
||||
* @param ?int $maxSize
|
||||
* Only read `maxSize` bytes from file.
|
||||
*
|
||||
* The file is considered done when either reaching `EOF`
|
||||
* or the `maxSize`.
|
||||
*
|
||||
* @param ?int $exactSize
|
||||
* Read exactly `exactSize` bytes from file.
|
||||
* If `EOF` is reached before reading `exactSize` bytes, an error will be
|
||||
* thrown. The parameter allows for faster size calculations if the `stream`
|
||||
* does not support `fstat` size or is slow and otherwise known beforehand.
|
||||
*
|
||||
* @param ?bool $enableZeroHeader
|
||||
* Override `defaultEnableZeroHeader`
|
||||
*
|
||||
* See {@see __construct()}
|
||||
*/
|
||||
public function addFileFromCallback(
|
||||
string $fileName,
|
||||
Closure $callback,
|
||||
string $comment = '',
|
||||
?CompressionMethod $compressionMethod = null,
|
||||
?int $deflateLevel = null,
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
?int $maxSize = null,
|
||||
?int $exactSize = null,
|
||||
?bool $enableZeroHeader = null,
|
||||
): void {
|
||||
$file = new File(
|
||||
dataCallback: function () use ($callback, $maxSize) {
|
||||
$data = $callback();
|
||||
|
||||
if(is_resource($data)) {
|
||||
return $data;
|
||||
}
|
||||
|
||||
if($data instanceof StreamInterface) {
|
||||
return StreamWrapper::getResource($data);
|
||||
}
|
||||
|
||||
|
||||
$stream = fopen('php://memory', 'rw+');
|
||||
if ($stream === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
throw new ResourceActionException('fopen');
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
if ($maxSize !== null && fwrite($stream, $data, $maxSize) === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
throw new ResourceActionException('fwrite', $stream);
|
||||
// @codeCoverageIgnoreEnd
|
||||
} elseif (fwrite($stream, $data) === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
throw new ResourceActionException('fwrite', $stream);
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
if (rewind($stream) === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
throw new ResourceActionException('rewind', $stream);
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
|
||||
return $stream;
|
||||
|
||||
},
|
||||
send: $this->send(...),
|
||||
recordSentBytes: $this->recordSentBytes(...),
|
||||
operationMode: $this->operationMode,
|
||||
fileName: $fileName,
|
||||
startOffset: $this->offset,
|
||||
compressionMethod: $compressionMethod ?? $this->defaultCompressionMethod,
|
||||
comment: $comment,
|
||||
deflateLevel: $deflateLevel ?? $this->defaultDeflateLevel,
|
||||
lastModificationDateTime: $lastModificationDateTime ?? new DateTimeImmutable(),
|
||||
maxSize: $maxSize,
|
||||
exactSize: $exactSize,
|
||||
enableZip64: $this->enableZip64,
|
||||
enableZeroHeader: $enableZeroHeader ?? $this->defaultEnableZeroHeader,
|
||||
);
|
||||
|
||||
if($this->operationMode !== OperationMode::NORMAL) {
|
||||
$this->recordedSimulation[] = $file;
|
||||
}
|
||||
|
||||
$this->centralDirectoryRecords[] = $file->process();
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a directory to the archive.
|
||||
*
|
||||
* ##### File Options
|
||||
*
|
||||
* See {@see addFileFromPsr7Stream()}
|
||||
*
|
||||
* ##### Examples
|
||||
*
|
||||
* ```php
|
||||
* // add a directory named 'world/'
|
||||
* $zip->addFile(fileName: 'world/');
|
||||
* ```
|
||||
*/
|
||||
public function addDirectory(
|
||||
string $fileName,
|
||||
string $comment = '',
|
||||
?DateTimeInterface $lastModificationDateTime = null,
|
||||
): void {
|
||||
if (!str_ends_with($fileName, '/')) {
|
||||
$fileName .= '/';
|
||||
}
|
||||
|
||||
$this->addFile(
|
||||
fileName: $fileName,
|
||||
data: '',
|
||||
comment: $comment,
|
||||
compressionMethod: CompressionMethod::STORE,
|
||||
deflateLevel: null,
|
||||
lastModificationDateTime: $lastModificationDateTime,
|
||||
maxSize: 0,
|
||||
exactSize: 0,
|
||||
enableZeroHeader: false,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes a previously calculated simulation.
|
||||
*
|
||||
* ##### Example
|
||||
*
|
||||
* ```php
|
||||
* $zip = new ZipStream(
|
||||
* outputName: 'foo.zip',
|
||||
* operationMode: OperationMode::SIMULATE_STRICT,
|
||||
* );
|
||||
*
|
||||
* $zip->addFile('test.txt', 'Hello World');
|
||||
*
|
||||
* $size = $zip->finish();
|
||||
*
|
||||
* header('Content-Length: '. $size);
|
||||
*
|
||||
* $zip->executeSimulation();
|
||||
* ```
|
||||
*/
|
||||
public function executeSimulation(): void
|
||||
{
|
||||
if($this->operationMode !== OperationMode::NORMAL) {
|
||||
throw new RuntimeException('Zip simulation is not finished.');
|
||||
}
|
||||
|
||||
foreach($this->recordedSimulation as $file) {
|
||||
$this->centralDirectoryRecords[] = $file->cloneSimulationExecution()->process();
|
||||
}
|
||||
|
||||
$this->finish();
|
||||
}
|
||||
|
||||
/**
|
||||
* Write zip footer to stream.
|
||||
*
|
||||
* The clase is left in an unusable state after `finish`.
|
||||
*
|
||||
* ##### Example
|
||||
*
|
||||
* ```php
|
||||
* // write footer to stream
|
||||
* $zip->finish();
|
||||
* ```
|
||||
*/
|
||||
public function finish(): int
|
||||
{
|
||||
$centralDirectoryStartOffsetOnDisk = $this->offset;
|
||||
$sizeOfCentralDirectory = 0;
|
||||
|
||||
// add trailing cdr file records
|
||||
foreach ($this->centralDirectoryRecords as $centralDirectoryRecord) {
|
||||
$this->send($centralDirectoryRecord);
|
||||
$sizeOfCentralDirectory += strlen($centralDirectoryRecord);
|
||||
}
|
||||
|
||||
// Add 64bit headers (if applicable)
|
||||
if (count($this->centralDirectoryRecords) >= 0xFFFF ||
|
||||
$centralDirectoryStartOffsetOnDisk > 0xFFFFFFFF ||
|
||||
$sizeOfCentralDirectory > 0xFFFFFFFF) {
|
||||
if (!$this->enableZip64) {
|
||||
throw new OverflowException();
|
||||
}
|
||||
|
||||
$this->send(Zip64\EndOfCentralDirectory::generate(
|
||||
versionMadeBy: self::ZIP_VERSION_MADE_BY,
|
||||
versionNeededToExtract: Version::ZIP64->value,
|
||||
numberOfThisDisk: 0,
|
||||
numberOfTheDiskWithCentralDirectoryStart: 0,
|
||||
numberOfCentralDirectoryEntriesOnThisDisk: count($this->centralDirectoryRecords),
|
||||
numberOfCentralDirectoryEntries: count($this->centralDirectoryRecords),
|
||||
sizeOfCentralDirectory: $sizeOfCentralDirectory,
|
||||
centralDirectoryStartOffsetOnDisk: $centralDirectoryStartOffsetOnDisk,
|
||||
extensibleDataSector: '',
|
||||
));
|
||||
|
||||
$this->send(Zip64\EndOfCentralDirectoryLocator::generate(
|
||||
numberOfTheDiskWithZip64CentralDirectoryStart: 0x00,
|
||||
zip64centralDirectoryStartOffsetOnDisk: $centralDirectoryStartOffsetOnDisk + $sizeOfCentralDirectory,
|
||||
totalNumberOfDisks: 1,
|
||||
));
|
||||
}
|
||||
|
||||
// add trailing cdr eof record
|
||||
$numberOfCentralDirectoryEntries = min(count($this->centralDirectoryRecords), 0xFFFF);
|
||||
$this->send(EndOfCentralDirectory::generate(
|
||||
numberOfThisDisk: 0x00,
|
||||
numberOfTheDiskWithCentralDirectoryStart: 0x00,
|
||||
numberOfCentralDirectoryEntriesOnThisDisk: $numberOfCentralDirectoryEntries,
|
||||
numberOfCentralDirectoryEntries: $numberOfCentralDirectoryEntries,
|
||||
sizeOfCentralDirectory: min($sizeOfCentralDirectory, 0xFFFFFFFF),
|
||||
centralDirectoryStartOffsetOnDisk: min($centralDirectoryStartOffsetOnDisk, 0xFFFFFFFF),
|
||||
zipFileComment: $this->comment,
|
||||
));
|
||||
|
||||
$size = $this->offset;
|
||||
|
||||
// The End
|
||||
$this->clear();
|
||||
|
||||
return $size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param StreamInterface|resource|null $outputStream
|
||||
* @return resource
|
||||
*/
|
||||
private static function normalizeStream($outputStream)
|
||||
{
|
||||
if ($outputStream instanceof StreamInterface) {
|
||||
return StreamWrapper::getResource($outputStream);
|
||||
}
|
||||
if (is_resource($outputStream)) {
|
||||
return $outputStream;
|
||||
}
|
||||
return fopen('php://output', 'wb');
|
||||
}
|
||||
|
||||
/**
|
||||
* Record sent bytes
|
||||
*/
|
||||
private function recordSentBytes(int $sentBytes): void
|
||||
{
|
||||
$this->offset += $sentBytes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send string, sending HTTP headers if necessary.
|
||||
* Flush output after write if configure option is set.
|
||||
*/
|
||||
private function send(string $data): void
|
||||
{
|
||||
if (!$this->ready) {
|
||||
throw new RuntimeException('Archive is already finished');
|
||||
}
|
||||
|
||||
if ($this->operationMode === OperationMode::NORMAL && $this->sendHttpHeaders) {
|
||||
$this->sendHttpHeaders();
|
||||
$this->sendHttpHeaders = false;
|
||||
}
|
||||
|
||||
$this->recordSentBytes(strlen($data));
|
||||
|
||||
if ($this->operationMode === OperationMode::NORMAL) {
|
||||
if (fwrite($this->outputStream, $data) === false) {
|
||||
throw new ResourceActionException('fwrite', $this->outputStream);
|
||||
}
|
||||
|
||||
if ($this->flushOutput) {
|
||||
// flush output buffer if it is on and flushable
|
||||
$status = ob_get_status();
|
||||
if (isset($status['flags']) && is_int($status['flags']) && ($status['flags'] & PHP_OUTPUT_HANDLER_FLUSHABLE)) {
|
||||
ob_flush();
|
||||
}
|
||||
|
||||
// Flush system buffers after flushing userspace output buffer
|
||||
flush();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send HTTP headers for this stream.
|
||||
*/
|
||||
private function sendHttpHeaders(): void
|
||||
{
|
||||
// grab content disposition
|
||||
$disposition = $this->contentDisposition;
|
||||
|
||||
if ($this->outputName) {
|
||||
// Various different browsers dislike various characters here. Strip them all for safety.
|
||||
$safeOutput = trim(str_replace(['"', "'", '\\', ';', "\n", "\r"], '', $this->outputName));
|
||||
|
||||
// Check if we need to UTF-8 encode the filename
|
||||
$urlencoded = rawurlencode($safeOutput);
|
||||
$disposition .= "; filename*=UTF-8''{$urlencoded}";
|
||||
}
|
||||
|
||||
$headers = [
|
||||
'Content-Type' => $this->contentType,
|
||||
'Content-Disposition' => $disposition,
|
||||
'Pragma' => 'public',
|
||||
'Cache-Control' => 'public, must-revalidate',
|
||||
'Content-Transfer-Encoding' => 'binary',
|
||||
];
|
||||
|
||||
foreach ($headers as $key => $val) {
|
||||
($this->httpHeaderCallback)("$key: $val");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all internal variables. Note that the stream object is not
|
||||
* usable after this.
|
||||
*/
|
||||
private function clear(): void
|
||||
{
|
||||
$this->centralDirectoryRecords = [];
|
||||
$this->offset = 0;
|
||||
|
||||
if($this->operationMode === OperationMode::NORMAL) {
|
||||
$this->ready = false;
|
||||
$this->recordedSimulation = [];
|
||||
} else {
|
||||
$this->operationMode = OperationMode::NORMAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user