diff options
Diffstat (limited to 'vendor/maennchen/zipstream-php/src')
16 files changed, 2172 insertions, 0 deletions
diff --git a/vendor/maennchen/zipstream-php/src/Bigint.php b/vendor/maennchen/zipstream-php/src/Bigint.php new file mode 100644 index 0000000..f2565e9 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Bigint.php @@ -0,0 +1,174 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream; + +use OverflowException; + +class Bigint +{ + /** + * @var int[] + */ + private $bytes = [0, 0, 0, 0, 0, 0, 0, 0]; + + /** + * Initialize the bytes array + * + * @param int $value + */ + public function __construct(int $value = 0) + { + $this->fillBytes($value, 0, 8); + } + + /** + * Get an instance + * + * @param int $value + * @return Bigint + */ + public static function init(int $value = 0): self + { + return new self($value); + } + + /** + * Fill bytes from low to high + * + * @param int $low + * @param int $high + * @return Bigint + */ + public static function fromLowHigh(int $low, int $high): self + { + $bigint = new self(); + $bigint->fillBytes($low, 0, 4); + $bigint->fillBytes($high, 4, 4); + return $bigint; + } + + /** + * Get high 32 + * + * @return int + */ + public function getHigh32(): int + { + return $this->getValue(4, 4); + } + + /** + * Get value from bytes array + * + * @param int $end + * @param int $length + * @return int + */ + public function getValue(int $end = 0, int $length = 8): int + { + $result = 0; + for ($i = $end + $length - 1; $i >= $end; $i--) { + $result <<= 8; + $result |= $this->bytes[$i]; + } + return $result; + } + + /** + * Get low FF + * + * @param bool $force + * @return float + */ + public function getLowFF(bool $force = false): float + { + if ($force || $this->isOver32()) { + return (float)0xFFFFFFFF; + } + return (float)$this->getLow32(); + } + + /** + * Check if is over 32 + * + * @psalm-suppress ArgumentTypeCoercion + * @param bool $force + * @return bool + */ + public function isOver32(bool $force = false): bool + { + // value 0xFFFFFFFF already needs a Zip64 header + return $force || + max(array_slice($this->bytes, 4, 4)) > 0 || + min(array_slice($this->bytes, 0, 4)) === 0xFF; + } + + /** + * Get low 32 + * + * @return int + */ + public function getLow32(): int + { + return $this->getValue(0, 4); + } + + /** + * Get hexadecimal + * + * @return string + */ + public function getHex64(): string + { + $result = '0x'; + for ($i = 7; $i >= 0; $i--) { + $result .= sprintf('%02X', $this->bytes[$i]); + } + return $result; + } + + /** + * Add + * + * @param Bigint $other + * @return Bigint + */ + public function add(self $other): self + { + $result = clone $this; + $overflow = false; + for ($i = 0; $i < 8; $i++) { + $result->bytes[$i] += $other->bytes[$i]; + if ($overflow) { + $result->bytes[$i]++; + $overflow = false; + } + if ($result->bytes[$i] & 0x100) { + $overflow = true; + $result->bytes[$i] &= 0xFF; + } + } + if ($overflow) { + throw new OverflowException(); + } + return $result; + } + + /** + * Fill the bytes field with int + * + * @param int $value + * @param int $start + * @param int $count + * @return void + */ + protected function fillBytes(int $value, int $start, int $count): void + { + for ($i = 0; $i < $count; $i++) { + $this->bytes[$start + $i] = $i >= PHP_INT_SIZE ? 0 : $value & 0xFF; + $value >>= 8; + } + } +} diff --git a/vendor/maennchen/zipstream-php/src/DeflateStream.php b/vendor/maennchen/zipstream-php/src/DeflateStream.php new file mode 100644 index 0000000..8e1e579 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/DeflateStream.php @@ -0,0 +1,71 @@ +<?php
+
+declare(strict_types=1);
+
+namespace ZipStream;
+
+class DeflateStream extends Stream
+{
+ protected $filter;
+
+ /**
+ * @var Option\File
+ */
+ protected $options;
+
+ /**
+ * Rewind stream
+ *
+ * @return void
+ */
+ public function rewind(): void
+ {
+ // deflate filter needs to be removed before rewind
+ if ($this->filter) {
+ $this->removeDeflateFilter();
+ $this->seek(0);
+ $this->addDeflateFilter($this->options);
+ } else {
+ rewind($this->stream);
+ }
+ }
+
+ /**
+ * Remove the deflate filter
+ *
+ * @return void
+ */
+ public function removeDeflateFilter(): void
+ {
+ if (!$this->filter) {
+ return;
+ }
+ stream_filter_remove($this->filter);
+ $this->filter = null;
+ }
+
+ /**
+ * Add a deflate filter
+ *
+ * @param Option\File $options
+ * @return void
+ */
+ public function addDeflateFilter(Option\File $options): void
+ {
+ $this->options = $options;
+ // parameter 4 for stream_filter_append expects array
+ // so we convert the option object in an array
+ $optionsArr = [
+ 'comment' => $options->getComment(),
+ 'method' => $options->getMethod(),
+ 'deflateLevel' => $options->getDeflateLevel(),
+ 'time' => $options->getTime(),
+ ];
+ $this->filter = stream_filter_append(
+ $this->stream,
+ 'zlib.deflate',
+ STREAM_FILTER_READ,
+ $optionsArr
+ );
+ }
+}
diff --git a/vendor/maennchen/zipstream-php/src/Exception.php b/vendor/maennchen/zipstream-php/src/Exception.php new file mode 100644 index 0000000..03a8767 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception.php @@ -0,0 +1,12 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream; + +/** + * This class is only for inheriting + */ +abstract class Exception extends \Exception +{ +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/EncodingException.php b/vendor/maennchen/zipstream-php/src/Exception/EncodingException.php new file mode 100644 index 0000000..5b0267d --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/EncodingException.php @@ -0,0 +1,14 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if file or comment encoding is incorrect + */ +class EncodingException extends Exception +{ +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/FileNotFoundException.php b/vendor/maennchen/zipstream-php/src/Exception/FileNotFoundException.php new file mode 100644 index 0000000..eb82001 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/FileNotFoundException.php @@ -0,0 +1,23 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if a file wasn't found + */ +class FileNotFoundException extends Exception +{ + /** + * Constructor of the Exception + * + * @param String $path - The path which wasn't found + */ + public function __construct(string $path) + { + parent::__construct("The file with the path $path wasn't found."); + } +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/FileNotReadableException.php b/vendor/maennchen/zipstream-php/src/Exception/FileNotReadableException.php new file mode 100644 index 0000000..1fbfdc5 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/FileNotReadableException.php @@ -0,0 +1,23 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if a file wasn't found + */ +class FileNotReadableException extends Exception +{ + /** + * Constructor of the Exception + * + * @param String $path - The path which wasn't found + */ + public function __construct(string $path) + { + parent::__construct("The file with the path $path isn't readable."); + } +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/IncompatibleOptionsException.php b/vendor/maennchen/zipstream-php/src/Exception/IncompatibleOptionsException.php new file mode 100644 index 0000000..2f1a7ef --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/IncompatibleOptionsException.php @@ -0,0 +1,14 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if options are incompatible + */ +class IncompatibleOptionsException extends Exception +{ +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/OverflowException.php b/vendor/maennchen/zipstream-php/src/Exception/OverflowException.php new file mode 100644 index 0000000..a1bc4d0 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/OverflowException.php @@ -0,0 +1,18 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if a counter value exceeds storage size + */ +class OverflowException extends Exception +{ + public function __construct() + { + parent::__construct('File size exceeds limit of 32 bit integer. Please enable "zip64" option.'); + } +} diff --git a/vendor/maennchen/zipstream-php/src/Exception/StreamNotReadableException.php b/vendor/maennchen/zipstream-php/src/Exception/StreamNotReadableException.php new file mode 100644 index 0000000..e676e37 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Exception/StreamNotReadableException.php @@ -0,0 +1,23 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Exception; + +use ZipStream\Exception; + +/** + * This Exception gets invoked if `fread` fails on a stream. + */ +class StreamNotReadableException extends Exception +{ + /** + * Constructor of the Exception + * + * @param string $fileName - The name of the file which the stream belongs to. + */ + public function __construct(string $fileName) + { + parent::__construct("The stream for $fileName could not be read."); + } +} diff --git a/vendor/maennchen/zipstream-php/src/File.php b/vendor/maennchen/zipstream-php/src/File.php new file mode 100644 index 0000000..586d3d1 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/File.php @@ -0,0 +1,483 @@ +<?php
+
+declare(strict_types=1);
+
+namespace ZipStream;
+
+use HashContext;
+use Psr\Http\Message\StreamInterface;
+use ZipStream\Exception\FileNotFoundException;
+use ZipStream\Exception\FileNotReadableException;
+use ZipStream\Exception\OverflowException;
+use ZipStream\Option\File as FileOptions;
+use ZipStream\Option\Method;
+use ZipStream\Option\Version;
+
+class File
+{
+ public const HASH_ALGORITHM = 'crc32b';
+
+ public const BIT_ZERO_HEADER = 0x0008;
+
+ public const BIT_EFS_UTF8 = 0x0800;
+
+ public const COMPUTE = 1;
+
+ public const SEND = 2;
+
+ private const CHUNKED_READ_BLOCK_SIZE = 1048576;
+
+ /**
+ * @var string
+ */
+ public $name;
+
+ /**
+ * @var FileOptions
+ */
+ public $opt;
+
+ /**
+ * @var Bigint
+ */
+ public $len;
+
+ /**
+ * @var Bigint
+ */
+ public $zlen;
+
+ /** @var int */
+ public $crc;
+
+ /**
+ * @var Bigint
+ */
+ public $hlen;
+
+ /**
+ * @var Bigint
+ */
+ public $ofs;
+
+ /**
+ * @var int
+ */
+ public $bits;
+
+ /**
+ * @var Version
+ */
+ public $version;
+
+ /**
+ * @var ZipStream
+ */
+ public $zip;
+
+ /**
+ * @var resource
+ */
+ private $deflate;
+
+ /**
+ * @var HashContext
+ */
+ private $hash;
+
+ /**
+ * @var Method
+ */
+ private $method;
+
+ /**
+ * @var Bigint
+ */
+ private $totalLength;
+
+ public function __construct(ZipStream $zip, string $name, ?FileOptions $opt = null)
+ {
+ $this->zip = $zip;
+
+ $this->name = $name;
+ $this->opt = $opt ?: new FileOptions();
+ $this->method = $this->opt->getMethod();
+ $this->version = Version::STORE();
+ $this->ofs = new Bigint();
+ }
+
+ public function processPath(string $path): void
+ {
+ if (!is_readable($path)) {
+ if (!file_exists($path)) {
+ throw new FileNotFoundException($path);
+ }
+ throw new FileNotReadableException($path);
+ }
+ if ($this->zip->isLargeFile($path) === false) {
+ $data = file_get_contents($path);
+ $this->processData($data);
+ } else {
+ $this->method = $this->zip->opt->getLargeFileMethod();
+
+ $stream = new DeflateStream(fopen($path, 'rb'));
+ $this->processStream($stream);
+ $stream->close();
+ }
+ }
+
+ public function processData(string $data): void
+ {
+ $this->len = new Bigint(strlen($data));
+ $this->crc = crc32($data);
+
+ // compress data if needed
+ if ($this->method->equals(Method::DEFLATE())) {
+ $data = gzdeflate($data);
+ }
+
+ $this->zlen = new Bigint(strlen($data));
+ $this->addFileHeader();
+ $this->zip->send($data);
+ $this->addFileFooter();
+ }
+
+ /**
+ * Create and send zip header for this file.
+ *
+ * @return void
+ * @throws \ZipStream\Exception\EncodingException
+ */
+ public function addFileHeader(): void
+ {
+ $name = static::filterFilename($this->name);
+
+ // calculate name length
+ $nameLength = strlen($name);
+
+ // create dos timestamp
+ $time = static::dosTime($this->opt->getTime()->getTimestamp());
+
+ $comment = $this->opt->getComment();
+
+ if (!mb_check_encoding($name, 'ASCII') ||
+ !mb_check_encoding($comment, 'ASCII')) {
+ // Sets Bit 11: Language encoding flag (EFS). If this bit is set,
+ // the filename and comment fields for this file
+ // MUST be encoded using UTF-8. (see APPENDIX D)
+ if (mb_check_encoding($name, 'UTF-8') &&
+ mb_check_encoding($comment, 'UTF-8')) {
+ $this->bits |= self::BIT_EFS_UTF8;
+ }
+ }
+
+ if ($this->method->equals(Method::DEFLATE())) {
+ $this->version = Version::DEFLATE();
+ }
+
+ $force = (bool)($this->bits & self::BIT_ZERO_HEADER) &&
+ $this->zip->opt->isEnableZip64();
+
+ $footer = $this->buildZip64ExtraBlock($force);
+
+ // If this file will start over 4GB limit in ZIP file,
+ // CDR record will have to use Zip64 extension to describe offset
+ // to keep consistency we use the same value here
+ if ($this->zip->ofs->isOver32()) {
+ $this->version = Version::ZIP64();
+ }
+
+ $fields = [
+ ['V', ZipStream::FILE_HEADER_SIGNATURE],
+ ['v', $this->version->getValue()], // Version needed to Extract
+ ['v', $this->bits], // General purpose bit flags - data descriptor flag set
+ ['v', $this->method->getValue()], // Compression method
+ ['V', $time], // Timestamp (DOS Format)
+ ['V', $this->crc], // CRC32 of data (0 -> moved to data descriptor footer)
+ ['V', $this->zlen->getLowFF($force)], // Length of compressed data (forced to 0xFFFFFFFF for zero header)
+ ['V', $this->len->getLowFF($force)], // Length of original data (forced to 0xFFFFFFFF for zero header)
+ ['v', $nameLength], // Length of filename
+ ['v', strlen($footer)], // Extra data (see above)
+ ];
+
+ // pack fields and calculate "total" length
+ $header = ZipStream::packFields($fields);
+
+ // print header and filename
+ $data = $header . $name . $footer;
+ $this->zip->send($data);
+
+ // save header length
+ $this->hlen = Bigint::init(strlen($data));
+ }
+
+ /**
+ * Strip characters that are not legal in Windows filenames
+ * to prevent compatibility issues
+ *
+ * @param string $filename Unprocessed filename
+ * @return string
+ */
+ public static function filterFilename(string $filename): string
+ {
+ // strip leading slashes from file name
+ // (fixes bug in windows archive viewer)
+ $filename = preg_replace('/^\\/+/', '', $filename);
+
+ return str_replace(['\\', ':', '*', '?', '"', '<', '>', '|'], '_', $filename);
+ }
+
+ /**
+ * Create and send data descriptor footer for this file.
+ *
+ * @return void
+ */
+ public function addFileFooter(): void
+ {
+ if ($this->bits & self::BIT_ZERO_HEADER) {
+ // compressed and uncompressed size
+ $sizeFormat = 'V';
+ if ($this->zip->opt->isEnableZip64()) {
+ $sizeFormat = 'P';
+ }
+ $fields = [
+ ['V', ZipStream::DATA_DESCRIPTOR_SIGNATURE],
+ ['V', $this->crc], // CRC32
+ [$sizeFormat, $this->zlen], // Length of compressed data
+ [$sizeFormat, $this->len], // Length of original data
+ ];
+
+ $footer = ZipStream::packFields($fields);
+ $this->zip->send($footer);
+ } else {
+ $footer = '';
+ }
+ $this->totalLength = $this->hlen->add($this->zlen)->add(Bigint::init(strlen($footer)));
+ $this->zip->addToCdr($this);
+ }
+
+ public function processStream(StreamInterface $stream): void
+ {
+ $this->zlen = new Bigint();
+ $this->len = new Bigint();
+
+ if ($this->zip->opt->isZeroHeader()) {
+ $this->processStreamWithZeroHeader($stream);
+ } else {
+ $this->processStreamWithComputedHeader($stream);
+ }
+ }
+
+ /**
+ * Send CDR record for specified file.
+ *
+ * @return string
+ */
+ public function getCdrFile(): string
+ {
+ $name = static::filterFilename($this->name);
+
+ // get attributes
+ $comment = $this->opt->getComment();
+
+ // get dos timestamp
+ $time = static::dosTime($this->opt->getTime()->getTimestamp());
+
+ $footer = $this->buildZip64ExtraBlock();
+
+ $fields = [
+ ['V', ZipStream::CDR_FILE_SIGNATURE], // Central file header signature
+ ['v', ZipStream::ZIP_VERSION_MADE_BY], // Made by version
+ ['v', $this->version->getValue()], // Extract by version
+ ['v', $this->bits], // General purpose bit flags - data descriptor flag set
+ ['v', $this->method->getValue()], // Compression method
+ ['V', $time], // Timestamp (DOS Format)
+ ['V', $this->crc], // CRC32
+ ['V', $this->zlen->getLowFF()], // Compressed Data Length
+ ['V', $this->len->getLowFF()], // Original Data Length
+ ['v', strlen($name)], // Length of filename
+ ['v', strlen($footer)], // Extra data len (see above)
+ ['v', strlen($comment)], // Length of comment
+ ['v', 0], // Disk number
+ ['v', 0], // Internal File Attributes
+ ['V', 32], // External File Attributes
+ ['V', $this->ofs->getLowFF()], // Relative offset of local header
+ ];
+
+ // pack fields, then append name and comment
+ $header = ZipStream::packFields($fields);
+
+ return $header . $name . $footer . $comment;
+ }
+
+ /**
+ * @return Bigint
+ */
+ public function getTotalLength(): Bigint
+ {
+ return $this->totalLength;
+ }
+
+ /**
+ * Convert a UNIX timestamp to a DOS timestamp.
+ *
+ * @param int $when
+ * @return int DOS Timestamp
+ */
+ final protected static function dosTime(int $when): int
+ {
+ // get date array for timestamp
+ $d = getdate($when);
+
+ // set lower-bound on dates
+ if ($d['year'] < 1980) {
+ $d = [
+ 'year' => 1980,
+ 'mon' => 1,
+ 'mday' => 1,
+ 'hours' => 0,
+ 'minutes' => 0,
+ 'seconds' => 0,
+ ];
+ }
+
+ // remove extra years from 1980
+ $d['year'] -= 1980;
+
+ // return date string
+ return
+ ($d['year'] << 25) |
+ ($d['mon'] << 21) |
+ ($d['mday'] << 16) |
+ ($d['hours'] << 11) |
+ ($d['minutes'] << 5) |
+ ($d['seconds'] >> 1);
+ }
+
+ protected function buildZip64ExtraBlock(bool $force = false): string
+ {
+ $fields = [];
+ if ($this->len->isOver32($force)) {
+ $fields[] = ['P', $this->len]; // Length of original data
+ }
+
+ if ($this->len->isOver32($force)) {
+ $fields[] = ['P', $this->zlen]; // Length of compressed data
+ }
+
+ if ($this->ofs->isOver32()) {
+ $fields[] = ['P', $this->ofs]; // Offset of local header record
+ }
+
+ if (!empty($fields)) {
+ if (!$this->zip->opt->isEnableZip64()) {
+ throw new OverflowException();
+ }
+
+ array_unshift(
+ $fields,
+ ['v', 0x0001], // 64 bit extension
+ ['v', count($fields) * 8] // Length of data block
+ );
+ $this->version = Version::ZIP64();
+ }
+
+ if ($this->bits & self::BIT_EFS_UTF8) {
+ // Put the tricky entry to
+ // force Linux unzip to lookup EFS flag.
+ $fields[] = ['v', 0x5653]; // Choose 'ZS' for proprietary usage
+ $fields[] = ['v', 0x0000]; // zero length
+ }
+
+ return ZipStream::packFields($fields);
+ }
+
+ protected function processStreamWithZeroHeader(StreamInterface $stream): void
+ {
+ $this->bits |= self::BIT_ZERO_HEADER;
+ $this->addFileHeader();
+ $this->readStream($stream, self::COMPUTE | self::SEND);
+ $this->addFileFooter();
+ }
+
+ protected function readStream(StreamInterface $stream, ?int $options = null): void
+ {
+ $this->deflateInit();
+ $total = 0;
+ $size = $this->opt->getSize();
+ while (!$stream->eof() && ($size === 0 || $total < $size)) {
+ $data = $stream->read(self::CHUNKED_READ_BLOCK_SIZE);
+ $total += strlen($data);
+ if ($size > 0 && $total > $size) {
+ $data = substr($data, 0, strlen($data)-($total - $size));
+ }
+ $this->deflateData($stream, $data, $options);
+ if ($options & self::SEND) {
+ $this->zip->send($data);
+ }
+ }
+ $this->deflateFinish($options);
+ }
+
+ protected function deflateInit(): void
+ {
+ $hash = hash_init(self::HASH_ALGORITHM);
+ $this->hash = $hash;
+ if ($this->method->equals(Method::DEFLATE())) {
+ $this->deflate = deflate_init(
+ ZLIB_ENCODING_RAW,
+ ['level' => $this->opt->getDeflateLevel()]
+ );
+ }
+ }
+
+ protected function deflateData(StreamInterface $stream, string &$data, ?int $options = null): void
+ {
+ if ($options & self::COMPUTE) {
+ $this->len = $this->len->add(Bigint::init(strlen($data)));
+ hash_update($this->hash, $data);
+ }
+ if ($this->deflate) {
+ $data = deflate_add(
+ $this->deflate,
+ $data,
+ $stream->eof()
+ ? ZLIB_FINISH
+ : ZLIB_NO_FLUSH
+ );
+ }
+ if ($options & self::COMPUTE) {
+ $this->zlen = $this->zlen->add(Bigint::init(strlen($data)));
+ }
+ }
+
+ protected function deflateFinish(?int $options = null): void
+ {
+ if ($options & self::COMPUTE) {
+ $this->crc = hexdec(hash_final($this->hash));
+ }
+ }
+
+ protected function processStreamWithComputedHeader(StreamInterface $stream): void
+ {
+ $this->readStream($stream, self::COMPUTE);
+ $stream->rewind();
+
+ // incremental compression with deflate_add
+ // makes this second read unnecessary
+ // but it is only available from PHP 7.0
+ if (!$this->deflate && $stream instanceof DeflateStream && $this->method->equals(Method::DEFLATE())) {
+ $stream->addDeflateFilter($this->opt);
+ $this->zlen = new Bigint();
+ while (!$stream->eof()) {
+ $data = $stream->read(self::CHUNKED_READ_BLOCK_SIZE);
+ $this->zlen = $this->zlen->add(Bigint::init(strlen($data)));
+ }
+ $stream->rewind();
+ }
+
+ $this->addFileHeader();
+ $this->readStream($stream, self::SEND);
+ $this->addFileFooter();
+ }
+}
diff --git a/vendor/maennchen/zipstream-php/src/Option/Archive.php b/vendor/maennchen/zipstream-php/src/Option/Archive.php new file mode 100644 index 0000000..374dd1d --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Option/Archive.php @@ -0,0 +1,276 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Option; + +use Psr\Http\Message\StreamInterface; + +final class Archive +{ + public const DEFAULT_DEFLATE_LEVEL = 6; + + /** + * @var string + */ + private $comment = ''; + + /** + * Size, in bytes, of the largest file to try + * and load into memory (used by + * addFileFromPath()). Large files may also + * be compressed differently; see the + * 'largeFileMethod' option. Default is ~20 Mb. + * + * @var int + */ + private $largeFileSize = 20 * 1024 * 1024; + + /** + * How to handle large files. Legal values are + * Method::STORE() (the default), or + * Method::DEFLATE(). STORE sends the file + * raw and is significantly + * faster, while DEFLATE compresses the file + * and is much, much slower. Note that DEFLATE + * must compress the file twice and is extremely slow. + * + * @var Method + */ + private $largeFileMethod; + + /** + * Boolean indicating whether or not to send + * the HTTP headers for this file. + * + * @var bool + */ + private $sendHttpHeaders = false; + + /** + * The method called to send headers + * + * @var Callable + */ + private $httpHeaderCallback = 'header'; + + /** + * Enable Zip64 extension, supporting very large + * archives (any size > 4 GB or file count > 64k) + * + * @var bool + */ + private $enableZip64 = true; + + /** + * Enable streaming files with single read where + * general purpose bit 3 indicates local file header + * contain zero values in crc and size fields, + * these appear only after file contents + * in data descriptor block. + * + * @var bool + */ + private $zeroHeader = false; + + /** + * Enable reading file stat for determining file size. + * When a 32-bit system reads file size that is + * over 2 GB, invalid value appears in file size + * due to integer overflow. Should be disabled on + * 32-bit systems with method addFileFromPath + * if any file may exceed 2 GB. In this case file + * will be read in blocks and correct size will be + * determined from content. + * + * @var bool + */ + private $statFiles = true; + + /** + * Enable flush after every write to output stream. + * @var bool + */ + private $flushOutput = false; + + /** + * HTTP Content-Disposition. Defaults to + * 'attachment', where + * FILENAME is the specified filename. + * + * Note that this does nothing if you are + * not sending HTTP headers. + * + * @var string + */ + private $contentDisposition = 'attachment'; + + /** + * Note that this does nothing if you are + * not sending HTTP headers. + * + * @var string + */ + private $contentType = 'application/x-zip'; + + /** + * @var int + */ + private $deflateLevel = 6; + + /** + * @var StreamInterface|resource + */ + private $outputStream; + + /** + * Options constructor. + */ + public function __construct() + { + $this->largeFileMethod = Method::STORE(); + $this->outputStream = fopen('php://output', 'wb'); + } + + public function getComment(): string + { + return $this->comment; + } + + public function setComment(string $comment): void + { + $this->comment = $comment; + } + + public function getLargeFileSize(): int + { + return $this->largeFileSize; + } + + public function setLargeFileSize(int $largeFileSize): void + { + $this->largeFileSize = $largeFileSize; + } + + public function getLargeFileMethod(): Method + { + return $this->largeFileMethod; + } + + public function setLargeFileMethod(Method $largeFileMethod): void + { + $this->largeFileMethod = $largeFileMethod; + } + + public function isSendHttpHeaders(): bool + { + return $this->sendHttpHeaders; + } + + public function setSendHttpHeaders(bool $sendHttpHeaders): void + { + $this->sendHttpHeaders = $sendHttpHeaders; + } + + public function getHttpHeaderCallback(): callable + { + return $this->httpHeaderCallback; + } + + public function setHttpHeaderCallback(callable $httpHeaderCallback): void + { + $this->httpHeaderCallback = $httpHeaderCallback; + } + + public function isEnableZip64(): bool + { + return $this->enableZip64; + } + + public function setEnableZip64(bool $enableZip64): void + { + $this->enableZip64 = $enableZip64; + } + + public function isZeroHeader(): bool + { + return $this->zeroHeader; + } + + public function setZeroHeader(bool $zeroHeader): void + { + $this->zeroHeader = $zeroHeader; + } + + public function isFlushOutput(): bool + { + return $this->flushOutput; + } + + public function setFlushOutput(bool $flushOutput): void + { + $this->flushOutput = $flushOutput; + } + + public function isStatFiles(): bool + { + return $this->statFiles; + } + + public function setStatFiles(bool $statFiles): void + { + $this->statFiles = $statFiles; + } + + public function getContentDisposition(): string + { + return $this->contentDisposition; + } + + public function setContentDisposition(string $contentDisposition): void + { + $this->contentDisposition = $contentDisposition; + } + + public function getContentType(): string + { + return $this->contentType; + } + + public function setContentType(string $contentType): void + { + $this->contentType = $contentType; + } + + /** + * @return StreamInterface|resource + */ + public function getOutputStream() + { + return $this->outputStream; + } + + /** + * @param StreamInterface|resource $outputStream + */ + public function setOutputStream($outputStream): void + { + $this->outputStream = $outputStream; + } + + /** + * @return int + */ + public function getDeflateLevel(): int + { + return $this->deflateLevel; + } + + /** + * @param int $deflateLevel + */ + public function setDeflateLevel(int $deflateLevel): void + { + $this->deflateLevel = $deflateLevel; + } +} diff --git a/vendor/maennchen/zipstream-php/src/Option/File.php b/vendor/maennchen/zipstream-php/src/Option/File.php new file mode 100644 index 0000000..37e37ce --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Option/File.php @@ -0,0 +1,122 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream\Option; + +use DateTime; +use DateTimeInterface; + +final class File +{ + /** + * @var string + */ + private $comment = ''; + + /** + * @var Method + */ + private $method; + + /** + * @var int + */ + private $deflateLevel; + + /** + * @var DateTimeInterface + */ + private $time; + + /** + * @var int + */ + private $size = 0; + + public function defaultTo(Archive $archiveOptions): void + { + $this->deflateLevel = $this->deflateLevel ?: $archiveOptions->getDeflateLevel(); + $this->time = $this->time ?: new DateTime(); + } + + /** + * @return string + */ + public function getComment(): string + { + return $this->comment; + } + + /** + * @param string $comment + */ + public function setComment(string $comment): void + { + $this->comment = $comment; + } + + /** + * @return Method + */ + public function getMethod(): Method + { + return $this->method ?: Method::DEFLATE(); + } + + /** + * @param Method $method + */ + public function setMethod(Method $method): void + { + $this->method = $method; + } + + /** + * @return int + */ + public function getDeflateLevel(): int + { + return $this->deflateLevel ?: Archive::DEFAULT_DEFLATE_LEVEL; + } + + /** + * @param int $deflateLevel + */ + public function setDeflateLevel(int $deflateLevel): void + { + $this->deflateLevel = $deflateLevel; + } + + /** + * @return DateTimeInterface + */ + public function getTime(): DateTimeInterface + { + return $this->time; + } + + /** + * @param DateTimeInterface $time + */ + public function setTime(DateTimeInterface $time): void + { + $this->time = $time; + } + + /** + * @return int + */ + public function getSize(): int + { + return $this->size; + } + + /** + * @param int $size + */ + public function setSize(int $size): void + { + $this->size = $size; + } +} diff --git a/vendor/maennchen/zipstream-php/src/Option/Method.php b/vendor/maennchen/zipstream-php/src/Option/Method.php new file mode 100644 index 0000000..343b258 --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Option/Method.php @@ -0,0 +1,21 @@ +<?php
+
+declare(strict_types=1);
+
+namespace ZipStream\Option;
+
+use MyCLabs\Enum\Enum;
+
+/**
+ * Methods enum
+ *
+ * @method static STORE(): Method
+ * @method static DEFLATE(): Method
+ * @psalm-immutable
+ */
+class Method extends Enum
+{
+ public const STORE = 0x00;
+
+ public const DEFLATE = 0x08;
+}
diff --git a/vendor/maennchen/zipstream-php/src/Option/Version.php b/vendor/maennchen/zipstream-php/src/Option/Version.php new file mode 100644 index 0000000..cb664ca --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Option/Version.php @@ -0,0 +1,25 @@ +<?php
+
+declare(strict_types=1);
+
+namespace ZipStream\Option;
+
+use MyCLabs\Enum\Enum;
+
+/**
+ * Class Version
+ * @package ZipStream\Option
+ *
+ * @method static STORE(): Version
+ * @method static DEFLATE(): Version
+ * @method static ZIP64(): Version
+ * @psalm-immutable
+ */
+class Version extends Enum
+{
+ public const STORE = 0x000A; // 1.00
+
+ public const DEFLATE = 0x0014; // 2.00
+
+ public const ZIP64 = 0x002D; // 4.50
+}
diff --git a/vendor/maennchen/zipstream-php/src/Stream.php b/vendor/maennchen/zipstream-php/src/Stream.php new file mode 100644 index 0000000..d80e70f --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/Stream.php @@ -0,0 +1,265 @@ +<?php + +declare(strict_types=1); + +namespace ZipStream; + +use function mb_strlen; + +use Psr\Http\Message\StreamInterface; +use RuntimeException; + +/** + * Describes a data stream. + * + * Typically, an instance will wrap a PHP stream; this interface provides + * a wrapper around the most common operations, including serialization of + * the entire stream to a string. + */ +class Stream implements StreamInterface +{ + protected $stream; + + public function __construct($stream) + { + $this->stream = $stream; + } + + /** + * Reads all data from the stream into a string, from the beginning to end. + * + * This method MUST attempt to seek to the beginning of the stream before + * reading data and read the stream until the end is reached. + * + * Warning: This could attempt to load a large amount of data into memory. + * + * This method MUST NOT raise an exception in order to conform with PHP's + * string casting operations. + * + * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring + * @return string + */ + public function __toString(): string + { + try { + $this->seek(0); + } catch (RuntimeException $e) { + } + return (string) stream_get_contents($this->stream); + } + + /** + * Closes the stream and any underlying resources. + * + * @return void + */ + public function close(): void + { + if (is_resource($this->stream)) { + fclose($this->stream); + } + $this->detach(); + } + + /** + * Separates any underlying resources from the stream. + * + * After the stream has been detached, the stream is in an unusable state. + * + * @return resource|null Underlying PHP stream, if any + */ + public function detach() + { + $result = $this->stream; + $this->stream = null; + return $result; + } + + /** + * Seek to a position in the stream. + * + * @link http://www.php.net/manual/en/function.fseek.php + * @param int $offset Stream offset + * @param int $whence Specifies how the cursor position will be calculated + * based on the seek offset. Valid values are identical to the built-in + * PHP $whence values for `fseek()`. SEEK_SET: Set position equal to + * offset bytes SEEK_CUR: Set position to current location plus offset + * SEEK_END: Set position to end-of-stream plus offset. + * @throws RuntimeException on failure. + */ + public function seek($offset, $whence = SEEK_SET): void + { + if (!$this->isSeekable()) { + throw new RuntimeException(); + } + if (fseek($this->stream, $offset, $whence) !== 0) { + throw new RuntimeException(); + } + } + + /** + * Returns whether or not the stream is seekable. + * + * @return bool + */ + public function isSeekable(): bool + { + return (bool)$this->getMetadata('seekable'); + } + + /** + * Get stream metadata as an associative array or retrieve a specific key. + * + * The keys returned are identical to the keys returned from PHP's + * stream_get_meta_data() function. + * + * @link http://php.net/manual/en/function.stream-get-meta-data.php + * @param string $key Specific metadata to retrieve. + * @return array|mixed|null Returns an associative array if no key is + * provided. Returns a specific key value if a key is provided and the + * value is found, or null if the key is not found. + */ + public function getMetadata($key = null) + { + $metadata = stream_get_meta_data($this->stream); + return $key !== null ? @$metadata[$key] : $metadata; + } + + /** + * Get the size of the stream if known. + * + * @return int|null Returns the size in bytes if known, or null if unknown. + */ + public function getSize(): ?int + { + $stats = fstat($this->stream); + return $stats['size']; + } + + /** + * Returns the current position of the file read/write pointer + * + * @return int Position of the file pointer + * @throws RuntimeException on error. + */ + public function tell(): int + { + $position = ftell($this->stream); + if ($position === false) { + throw new RuntimeException(); + } + return $position; + } + + /** + * Returns true if the stream is at the end of the stream. + * + * @return bool + */ + public function eof(): bool + { + return feof($this->stream); + } + + /** + * Seek to the beginning of the stream. + * + * If the stream is not seekable, this method will raise an exception; + * otherwise, it will perform a seek(0). + * + * @see seek() + * @link http://www.php.net/manual/en/function.fseek.php + * @throws RuntimeException on failure. + */ + public function rewind(): void + { + $this->seek(0); + } + + /** + * Write data to the stream. + * + * @param string $string The string that is to be written. + * @return int Returns the number of bytes written to the stream. + * @throws RuntimeException on failure. + */ + public function write($string): int + { + if (!$this->isWritable()) { + throw new RuntimeException(); + } + if (fwrite($this->stream, $string) === false) { + throw new RuntimeException(); + } + return mb_strlen($string); + } + + /** + * Returns whether or not the stream is writable. + * + * @return bool + */ + public function isWritable(): bool + { + $mode = $this->getMetadata('mode'); + if (!is_string($mode)) { + throw new RuntimeException('Could not get stream mode from metadata!'); + } + return preg_match('/[waxc+]/', $mode) === 1; + } + + /** + * Read data from the stream. + * + * @param int $length Read up to $length bytes from the object and return + * them. Fewer than $length bytes may be returned if underlying stream + * call returns fewer bytes. + * @return string Returns the data read from the stream, or an empty string + * if no bytes are available. + * @throws RuntimeException if an error occurs. + */ + public function read($length): string + { + if (!$this->isReadable()) { + throw new RuntimeException(); + } + $result = fread($this->stream, $length); + if ($result === false) { + throw new RuntimeException(); + } + return $result; + } + + /** + * Returns whether or not the stream is readable. + * + * @return bool + */ + public function isReadable(): bool + { + $mode = $this->getMetadata('mode'); + if (!is_string($mode)) { + throw new RuntimeException('Could not get stream mode from metadata!'); + } + return preg_match('/[r+]/', $mode) === 1; + } + + /** + * Returns the remaining contents in a string + * + * @return string + * @throws RuntimeException if unable to read or an error occurs while + * reading. + */ + public function getContents(): string + { + if (!$this->isReadable()) { + throw new RuntimeException(); + } + $result = stream_get_contents($this->stream); + if ($result === false) { + throw new RuntimeException(); + } + return $result; + } +} diff --git a/vendor/maennchen/zipstream-php/src/ZipStream.php b/vendor/maennchen/zipstream-php/src/ZipStream.php new file mode 100644 index 0000000..eb5474a --- /dev/null +++ b/vendor/maennchen/zipstream-php/src/ZipStream.php @@ -0,0 +1,608 @@ +<?php
+
+declare(strict_types=1);
+
+namespace ZipStream;
+
+use Psr\Http\Message\StreamInterface;
+use ZipStream\Exception\OverflowException;
+use ZipStream\Option\Archive as ArchiveOptions;
+use ZipStream\Option\File as FileOptions;
+use ZipStream\Option\Version;
+
+/**
+ * ZipStream
+ *
+ * Streamed, dynamically generated zip archives.
+ *
+ * Usage:
+ *
+ * Streaming zip archives is a simple, three-step process:
+ *
+ * 1. Create the zip stream:
+ *
+ * $zip = new ZipStream('example.zip');
+ *
+ * 2. Add one or more files to the archive:
+ *
+ * * add first file
+ * $data = file_get_contents('some_file.gif');
+ * $zip->addFile('some_file.gif', $data);
+ *
+ * * add second file
+ * $data = file_get_contents('some_file.gif');
+ * $zip->addFile('another_file.png', $data);
+ *
+ * 3. Finish the zip stream:
+ *
+ * $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:
+ *
+ * // create a new zip stream object
+ * $zip = new ZipStream('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->addFile($path, file_get_contents($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
+ */
+ public const ZIP_VERSION_MADE_BY = 0x603;
+
+ /**
+ * The following signatures end with 0x4b50, which in ASCII is PK,
+ * the initials of the inventor Phil Katz.
+ * See https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
+ */
+ public const FILE_HEADER_SIGNATURE = 0x04034b50;
+
+ public const CDR_FILE_SIGNATURE = 0x02014b50;
+
+ public const CDR_EOF_SIGNATURE = 0x06054b50;
+
+ public const DATA_DESCRIPTOR_SIGNATURE = 0x08074b50;
+
+ public const ZIP64_CDR_EOF_SIGNATURE = 0x06064b50;
+
+ public const ZIP64_CDR_LOCATOR_SIGNATURE = 0x07064b50;
+
+ /**
+ * Global Options
+ *
+ * @var ArchiveOptions
+ */
+ public $opt;
+
+ /**
+ * @var array
+ */
+ public $files = [];
+
+ /**
+ * @var Bigint
+ */
+ public $cdr_ofs;
+
+ /**
+ * @var Bigint
+ */
+ public $ofs;
+
+ /**
+ * @var bool
+ */
+ protected $need_headers;
+
+ /**
+ * @var null|String
+ */
+ protected $output_name;
+
+ /**
+ * Create a new ZipStream object.
+ *
+ * Parameters:
+ *
+ * @param String $name - Name of output file (optional).
+ * @param ArchiveOptions $opt - Archive Options
+ *
+ * Large File Support:
+ *
+ * By default, the method addFileFromPath() will send send files
+ * larger than 20 megabytes along raw rather than attempting to
+ * compress them. You can change both the maximum size and the
+ * compression behavior using the largeFile* options above, with the
+ * following caveats:
+ *
+ * * For "small" files (e.g. files smaller than largeFileSize), the
+ * memory use can be up to twice that of the actual file. In other
+ * words, adding a 10 megabyte file to the archive could potentially
+ * occupy 20 megabytes of memory.
+ *
+ * * Enabling compression on large files (e.g. files larger than
+ * large_file_size) is extremely slow, because ZipStream has to pass
+ * over the large file once to calculate header information, and then
+ * again to compress and send the actual data.
+ *
+ * Examples:
+ *
+ * // create a new zip file named 'foo.zip'
+ * $zip = new ZipStream('foo.zip');
+ *
+ * // create a new zip file named 'bar.zip' with a comment
+ * $opt->setComment = 'this is a comment for the zip file.';
+ * $zip = new ZipStream('bar.zip', $opt);
+ *
+ * Notes:
+ *
+ * In order to let this library send HTTP headers, a filename must be given
+ * _and_ the option `sendHttpHeaders` must be `true`. This behavior is to
+ * allow software to send its own headers (including the filename), and
+ * still use this library.
+ */
+ public function __construct(?string $name = null, ?ArchiveOptions $opt = null)
+ {
+ $this->opt = $opt ?: new ArchiveOptions();
+
+ $this->output_name = $name;
+ $this->need_headers = $name && $this->opt->isSendHttpHeaders();
+
+ $this->cdr_ofs = new Bigint();
+ $this->ofs = new Bigint();
+ }
+
+ /**
+ * addFile
+ *
+ * Add a file to the archive.
+ *
+ * @param String $name - path of file in archive (including directory).
+ * @param String $data - contents of file
+ * @param FileOptions $options
+ *
+ * File Options:
+ * time - Last-modified timestamp (seconds since the epoch) of
+ * this file. Defaults to the current time.
+ * comment - Comment related to this file.
+ * method - Storage method for file ("store" or "deflate")
+ *
+ * Examples:
+ *
+ * // add a file named 'foo.txt'
+ * $data = file_get_contents('foo.txt');
+ * $zip->addFile('foo.txt', $data);
+ *
+ * // add a file named 'bar.jpg' with a comment and a last-modified
+ * // time of two hours ago
+ * $data = file_get_contents('bar.jpg');
+ * $opt->setTime = time() - 2 * 3600;
+ * $opt->setComment = 'this is a comment about bar.jpg';
+ * $zip->addFile('bar.jpg', $data, $opt);
+ */
+ public function addFile(string $name, string $data, ?FileOptions $options = null): void
+ {
+ $options = $options ?: new FileOptions();
+ $options->defaultTo($this->opt);
+
+ $file = new File($this, $name, $options);
+ $file->processData($data);
+ }
+
+ /**
+ * addFileFromPath
+ *
+ * Add a file at path to the archive.
+ *
+ * Note that large files may be compressed differently than smaller
+ * files; see the "Large File Support" section above for more
+ * information.
+ *
+ * @param String $name - name of file in archive (including directory path).
+ * @param String $path - path to file on disk (note: paths should be encoded using
+ * UNIX-style forward slashes -- e.g '/path/to/some/file').
+ * @param FileOptions $options
+ *
+ * File Options:
+ * time - Last-modified timestamp (seconds since the epoch) of
+ * this file. Defaults to the current time.
+ * comment - Comment related to this file.
+ * method - Storage method for file ("store" or "deflate")
+ *
+ * Examples:
+ *
+ * // add a file named 'foo.txt' from the local file '/tmp/foo.txt'
+ * $zip->addFileFromPath('foo.txt', '/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
+ * $path = '/usr/share/bigfile.rar';
+ * $opt->setTime = time() - 2 * 3600;
+ * $opt->setComment = 'this is a comment about bar.jpg';
+ * $zip->addFileFromPath('bigfile.rar', $path, $opt);
+ *
+ * @return void
+ * @throws \ZipStream\Exception\FileNotFoundException
+ * @throws \ZipStream\Exception\FileNotReadableException
+ */
+ public function addFileFromPath(string $name, string $path, ?FileOptions $options = null): void
+ {
+ $options = $options ?: new FileOptions();
+ $options->defaultTo($this->opt);
+
+ $file = new File($this, $name, $options);
+ $file->processPath($path);
+ }
+
+ /**
+ * addFileFromStream
+ *
+ * Add an open stream to the archive.
+ *
+ * @param String $name - path of file in archive (including directory).
+ * @param resource $stream - contents of file as a stream resource
+ * @param FileOptions $options
+ *
+ * File Options:
+ * time - Last-modified timestamp (seconds since the epoch) of
+ * this file. Defaults to the current time.
+ * comment - Comment related to this file.
+ *
+ * Examples:
+ *
+ * // create a temporary file stream and write text to it
+ * $fp = tmpfile();
+ * fwrite($fp, 'The quick brown fox jumped over the lazy dog.');
+ *
+ * // add a file named 'streamfile.txt' from the content of the stream
+ * $x->addFileFromStream('streamfile.txt', $fp);
+ *
+ * @return void
+ */
+ public function addFileFromStream(string $name, $stream, ?FileOptions $options = null): void
+ {
+ $options = $options ?: new FileOptions();
+ $options->defaultTo($this->opt);
+
+ $file = new File($this, $name, $options);
+ $file->processStream(new DeflateStream($stream));
+ }
+
+ /**
+ * addFileFromPsr7Stream
+ *
+ * Add an open stream to the archive.
+ *
+ * @param String $name - path of file in archive (including directory).
+ * @param StreamInterface $stream - contents of file as a stream resource
+ * @param FileOptions $options
+ *
+ * File Options:
+ * time - Last-modified timestamp (seconds since the epoch) of
+ * this file. Defaults to the current time.
+ * comment - Comment related to this file.
+ *
+ * Examples:
+ *
+ * $stream = $response->getBody();
+ * // add a file named 'streamfile.txt' from the content of the stream
+ * $x->addFileFromPsr7Stream('streamfile.txt', $stream);
+ *
+ * @return void
+ */
+ public function addFileFromPsr7Stream(
+ string $name,
+ StreamInterface $stream,
+ ?FileOptions $options = null
+ ): void {
+ $options = $options ?: new FileOptions();
+ $options->defaultTo($this->opt);
+
+ $file = new File($this, $name, $options);
+ $file->processStream($stream);
+ }
+
+ /**
+ * finish
+ *
+ * Write zip footer to stream.
+ *
+ * Example:
+ *
+ * // add a list of files to the archive
+ * $files = array('foo.txt', 'bar.jpg');
+ * foreach ($files as $path)
+ * $zip->addFile($path, file_get_contents($path));
+ *
+ * // write footer to stream
+ * $zip->finish();
+ * @return void
+ *
+ * @throws OverflowException
+ */
+ public function finish(): void
+ {
+ // add trailing cdr file records
+ foreach ($this->files as $cdrFile) {
+ $this->send($cdrFile);
+ $this->cdr_ofs = $this->cdr_ofs->add(Bigint::init(strlen($cdrFile)));
+ }
+
+ // Add 64bit headers (if applicable)
+ if (count($this->files) >= 0xFFFF ||
+ $this->cdr_ofs->isOver32() ||
+ $this->ofs->isOver32()) {
+ if (!$this->opt->isEnableZip64()) {
+ throw new OverflowException();
+ }
+
+ $this->addCdr64Eof();
+ $this->addCdr64Locator();
+ }
+
+ // add trailing cdr eof record
+ $this->addCdrEof();
+
+ // The End
+ $this->clear();
+ }
+
+ /**
+ * Create a format string and argument list for pack(), then call
+ * pack() and return the result.
+ *
+ * @param array $fields
+ * @return string
+ */
+ public static function packFields(array $fields): string
+ {
+ $fmt = '';
+ $args = [];
+
+ // populate format string and argument list
+ foreach ($fields as [$format, $value]) {
+ if ($format === 'P') {
+ $fmt .= 'VV';
+ if ($value instanceof Bigint) {
+ $args[] = $value->getLow32();
+ $args[] = $value->getHigh32();
+ } else {
+ $args[] = $value;
+ $args[] = 0;
+ }
+ } else {
+ if ($value instanceof Bigint) {
+ $value = $value->getLow32();
+ }
+ $fmt .= $format;
+ $args[] = $value;
+ }
+ }
+
+ // prepend format string to argument list
+ array_unshift($args, $fmt);
+
+ // build output string from header and compressed data
+ return pack(...$args);
+ }
+
+ /**
+ * Send string, sending HTTP headers if necessary.
+ * Flush output after write if configure option is set.
+ *
+ * @param String $str
+ * @return void
+ */
+ public function send(string $str): void
+ {
+ if ($this->need_headers) {
+ $this->sendHttpHeaders();
+ }
+ $this->need_headers = false;
+
+ $outputStream = $this->opt->getOutputStream();
+
+ if ($outputStream instanceof StreamInterface) {
+ $outputStream->write($str);
+ } else {
+ fwrite($outputStream, $str);
+ }
+
+ if ($this->opt->isFlushOutput()) {
+ // flush output buffer if it is on and flushable
+ $status = ob_get_status();
+ if (isset($status['flags']) && ($status['flags'] & PHP_OUTPUT_HANDLER_FLUSHABLE)) {
+ ob_flush();
+ }
+
+ // Flush system buffers after flushing userspace output buffer
+ flush();
+ }
+ }
+
+ /**
+ * Is this file larger than large_file_size?
+ *
+ * @param string $path
+ * @return bool
+ */
+ public function isLargeFile(string $path): bool
+ {
+ if (!$this->opt->isStatFiles()) {
+ return false;
+ }
+ $stat = stat($path);
+ return $stat['size'] > $this->opt->getLargeFileSize();
+ }
+
+ /**
+ * Save file attributes for trailing CDR record.
+ *
+ * @param File $file
+ * @return void
+ */
+ public function addToCdr(File $file): void
+ {
+ $file->ofs = $this->ofs;
+ $this->ofs = $this->ofs->add($file->getTotalLength());
+ $this->files[] = $file->getCdrFile();
+ }
+
+ /**
+ * Send ZIP64 CDR EOF (Central Directory Record End-of-File) record.
+ *
+ * @return void
+ */
+ protected function addCdr64Eof(): void
+ {
+ $num_files = count($this->files);
+ $cdr_length = $this->cdr_ofs;
+ $cdr_offset = $this->ofs;
+
+ $fields = [
+ ['V', static::ZIP64_CDR_EOF_SIGNATURE], // ZIP64 end of central file header signature
+ ['P', 44], // Length of data below this header (length of block - 12) = 44
+ ['v', static::ZIP_VERSION_MADE_BY], // Made by version
+ ['v', Version::ZIP64], // Extract by version
+ ['V', 0x00], // disk number
+ ['V', 0x00], // no of disks
+ ['P', $num_files], // no of entries on disk
+ ['P', $num_files], // no of entries in cdr
+ ['P', $cdr_length], // CDR size
+ ['P', $cdr_offset], // CDR offset
+ ];
+
+ $ret = static::packFields($fields);
+ $this->send($ret);
+ }
+
+ /**
+ * Send HTTP headers for this stream.
+ *
+ * @return void
+ */
+ protected function sendHttpHeaders(): void
+ {
+ // grab content disposition
+ $disposition = $this->opt->getContentDisposition();
+
+ if ($this->output_name) {
+ // Various different browsers dislike various characters here. Strip them all for safety.
+ $safe_output = trim(str_replace(['"', "'", '\\', ';', "\n", "\r"], '', $this->output_name));
+
+ // Check if we need to UTF-8 encode the filename
+ $urlencoded = rawurlencode($safe_output);
+ $disposition .= "; filename*=UTF-8''{$urlencoded}";
+ }
+
+ $headers = [
+ 'Content-Type' => $this->opt->getContentType(),
+ 'Content-Disposition' => $disposition,
+ 'Pragma' => 'public',
+ 'Cache-Control' => 'public, must-revalidate',
+ 'Content-Transfer-Encoding' => 'binary',
+ ];
+
+ $call = $this->opt->getHttpHeaderCallback();
+ foreach ($headers as $key => $val) {
+ $call("$key: $val");
+ }
+ }
+
+ /**
+ * Send ZIP64 CDR Locator (Central Directory Record Locator) record.
+ *
+ * @return void
+ */
+ protected function addCdr64Locator(): void
+ {
+ $cdr_offset = $this->ofs->add($this->cdr_ofs);
+
+ $fields = [
+ ['V', static::ZIP64_CDR_LOCATOR_SIGNATURE], // ZIP64 end of central file header signature
+ ['V', 0x00], // Disc number containing CDR64EOF
+ ['P', $cdr_offset], // CDR offset
+ ['V', 1], // Total number of disks
+ ];
+
+ $ret = static::packFields($fields);
+ $this->send($ret);
+ }
+
+ /**
+ * Send CDR EOF (Central Directory Record End-of-File) record.
+ *
+ * @return void
+ */
+ protected function addCdrEof(): void
+ {
+ $num_files = count($this->files);
+ $cdr_length = $this->cdr_ofs;
+ $cdr_offset = $this->ofs;
+
+ // grab comment (if specified)
+ $comment = $this->opt->getComment();
+
+ $fields = [
+ ['V', static::CDR_EOF_SIGNATURE], // end of central file header signature
+ ['v', 0x00], // disk number
+ ['v', 0x00], // no of disks
+ ['v', min($num_files, 0xFFFF)], // no of entries on disk
+ ['v', min($num_files, 0xFFFF)], // no of entries in cdr
+ ['V', $cdr_length->getLowFF()], // CDR size
+ ['V', $cdr_offset->getLowFF()], // CDR offset
+ ['v', strlen($comment)], // Zip Comment size
+ ];
+
+ $ret = static::packFields($fields) . $comment;
+ $this->send($ret);
+ }
+
+ /**
+ * Clear all internal variables. Note that the stream object is not
+ * usable after this.
+ *
+ * @return void
+ */
+ protected function clear(): void
+ {
+ $this->files = [];
+ $this->ofs = new Bigint();
+ $this->cdr_ofs = new Bigint();
+ $this->opt = new ArchiveOptions();
+ }
+}
|