ZipWriter::writeAndCountChecksum() - Code Metrics - Inspection of "Merge branch 'release/3.2.0'" - Ne-Lexa/php-zip - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 3b7697...25d5dd )

by Alexey
created 2020-01-09 14:46 UTC
ZipWriter::writeAndCountChecksum() A

↳ Parent: ZipWriter
Complexity

Conditions	2
Paths	2
Size

Total Lines	14
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	2
eloc	9
c	1
b	0
f	1
nc	2
nop	3
dl	0
loc	14
rs	9.9666
<?php

namespace PhpZip\IO;

use PhpZip\Constants\DosCodePage;
use PhpZip\Constants\ZipCompressionMethod;
use PhpZip\Constants\ZipConstants;
use PhpZip\Constants\ZipEncryptionMethod;
use PhpZip\Constants\ZipPlatform;
use PhpZip\Constants\ZipVersion;
use PhpZip\Exception\ZipException;
use PhpZip\Exception\ZipUnsupportMethodException;
use PhpZip\IO\Filter\Cipher\Pkware\PKEncryptionStreamFilter;
use PhpZip\IO\Filter\Cipher\WinZipAes\WinZipAesEncryptionStreamFilter;
use PhpZip\Model\Data\ZipSourceFileData;
use PhpZip\Model\Extra\Fields\ApkAlignmentExtraField;
use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
use PhpZip\Model\Extra\Fields\Zip64ExtraField;
use PhpZip\Model\ZipContainer;
use PhpZip\Model\ZipEntry;
use PhpZip\Util\PackUtil;
use PhpZip\Util\StringUtil;

/**
 * Class ZipWriter.
 */
class ZipWriter
{
    /** @var int Chunk read size */
    const CHUNK_SIZE = 8192;

    /** @var ZipContainer */
    protected $zipContainer;

    /**
     * ZipWriter constructor.
     *
     * @param ZipContainer $container
     */
    public function __construct(ZipContainer $container)
    {
        $this->zipContainer = $container;
    }

    /**
     * @param resource $outStream
     *
     * @throws ZipException
     */
    public function write($outStream)
    {
        if (!\is_resource($outStream)) {
            throw new \InvalidArgumentException('$outStream must be resource');
        }
        $this->beforeWrite();
        $this->writeLocalBlock($outStream);
        $cdOffset = ftell($outStream);
        $this->writeCentralDirectoryBlock($outStream);
        $cdSize = ftell($outStream) - $cdOffset;
        $this->writeEndOfCentralDirectoryBlock($outStream, $cdOffset, $cdSize);
    }

    protected function beforeWrite()
    {
    }

    /**
     * @param resource $outStream
     *
     * @throws ZipException
     */
    protected function writeLocalBlock($outStream)
    {
        $zipEntries = $this->zipContainer->getEntries();

        foreach ($zipEntries as $zipEntry) {
            $this->writeLocalHeader($outStream, $zipEntry);
            $this->writeData($outStream, $zipEntry);

            if ($zipEntry->isDataDescriptorEnabled()) {
                $this->writeDataDescriptor($outStream, $zipEntry);
            }
        }
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     *
     * @throws ZipException
     */
    protected function writeLocalHeader($outStream, ZipEntry $entry)
    {
        // todo in 4.0 version move zipalign functional to ApkWriter class
        if ($this->zipContainer->isZipAlign()) {
            $this->zipAlign($outStream, $entry);
        }

        $relativeOffset = ftell($outStream);
        $entry->setLocalHeaderOffset($relativeOffset);

        if ($entry->isEncrypted() && $entry->getEncryptionMethod() === ZipEncryptionMethod::PKWARE) {
            $entry->enableDataDescriptor(true);
        }

        $dd = $entry->isDataDescriptorRequired() ||
            $entry->isDataDescriptorEnabled();

        $compressedSize = $entry->getCompressedSize();
        $uncompressedSize = $entry->getUncompressedSize();

        $entry->getLocalExtraFields()->remove(Zip64ExtraField::HEADER_ID);

        if ($compressedSize > ZipConstants::ZIP64_MAGIC || $uncompressedSize > ZipConstants::ZIP64_MAGIC) {
            $entry->getLocalExtraFields()->add(
                new Zip64ExtraField($uncompressedSize, $compressedSize)
            );

            $compressedSize = ZipConstants::ZIP64_MAGIC;
            $uncompressedSize = ZipConstants::ZIP64_MAGIC;
        }

        $compressionMethod = $entry->getCompressionMethod();
        $crc = $entry->getCrc();

        if ($entry->isEncrypted() && ZipEncryptionMethod::isWinZipAesMethod($entry->getEncryptionMethod())) {
            /** @var WinZipAesExtraField|null $winZipAesExtra */
            $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);

            if ($winZipAesExtra === null) {
                $winZipAesExtra = WinZipAesExtraField::create($entry);
            }

            if ($winZipAesExtra->isV2()) {
                $crc = 0;
            }
            $compressionMethod = ZipCompressionMethod::WINZIP_AES;
        }

        $extra = $this->getExtraFieldsContents($entry, true);
        $name = $entry->getName();
        $dosCharset = $entry->getCharset();

        if ($dosCharset !== null && !$entry->isUtf8Flag()) {
            $name = DosCodePage::fromUTF8($name, $dosCharset);
        }

        $nameLength = \strlen($name);
        $extraLength = \strlen($extra);

        $size = $nameLength + $extraLength;

        if ($size > 0xffff) {
            throw new ZipException(
                sprintf(
                    '%s (the total size of %s bytes for the name, extra fields and comment exceeds the maximum size of %d bytes)',
                    $entry->getName(),
                    $size,
                    0xffff
                )
            );
        }

        $extractedBy = ($entry->getExtractedOS() << 8) | $entry->getExtractVersion();

        fwrite(
            $outStream,
            pack(
                'VvvvVVVVvv',
                // local file header signature     4 bytes  (0x04034b50)
                ZipConstants::LOCAL_FILE_HEADER,
                // version needed to extract       2 bytes
                $extractedBy,
                // general purpose bit flag        2 bytes
                $entry->getGeneralPurposeBitFlags(),
                // compression method              2 bytes
                $compressionMethod,
                // last mod file time              2 bytes
                // last mod file date              2 bytes
                $entry->getDosTime(),
                // crc-32                          4 bytes
                $dd ? 0 : $crc,
                // compressed size                 4 bytes
                $dd ? 0 : $compressedSize,
                // uncompressed size               4 bytes
                $dd ? 0 : $uncompressedSize,
                // file name length                2 bytes
                $nameLength,
                // extra field length              2 bytes
                $extraLength
            )
        );

        if ($nameLength > 0) {
            fwrite($outStream, $name);
        }

        if ($extraLength > 0) {
            fwrite($outStream, $extra);
        }
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     *
     * @throws ZipException
     */
    private function zipAlign($outStream, ZipEntry $entry)
    {
        if (!$entry->isDirectory() && $entry->getCompressionMethod() === ZipCompressionMethod::STORED) {
            $entry->removeExtraField(ApkAlignmentExtraField::HEADER_ID);

            $extra = $this->getExtraFieldsContents($entry, true);
            $extraLength = \strlen($extra);
            $name = $entry->getName();

            $dosCharset = $entry->getCharset();

            if ($dosCharset !== null && !$entry->isUtf8Flag()) {
                $name = DosCodePage::fromUTF8($name, $dosCharset);
            }
            $nameLength = \strlen($name);

            $multiple = ApkAlignmentExtraField::ALIGNMENT_BYTES;

            if (StringUtil::endsWith($name, '.so')) {
                $multiple = ApkAlignmentExtraField::COMMON_PAGE_ALIGNMENT_BYTES;
            }

            $offset = ftell($outStream);

            $dataMinStartOffset =
                $offset +
                ZipConstants::LFH_FILENAME_POS +
                $extraLength +
                $nameLength;

            $padding =
                ($multiple - ($dataMinStartOffset % $multiple))
                % $multiple;

            if ($padding > 0) {
                $dataMinStartOffset += ApkAlignmentExtraField::MIN_SIZE;
                $padding =
                    ($multiple - ($dataMinStartOffset % $multiple))
                    % $multiple;

                $entry->getLocalExtraFields()->add(
                    new ApkAlignmentExtraField($multiple, $padding)
                );
            }
        }
    }

    /**
     * Merges the local file data fields of the given ZipExtraFields.
     *
     * @param ZipEntry $entry
     * @param bool     $local
     *
     * @throws ZipException
     *
     * @return string
     */
    protected function getExtraFieldsContents(ZipEntry $entry, $local)
    {
        $local = (bool) $local;
        $collection = $local ?
            $entry->getLocalExtraFields() :
            $entry->getCdExtraFields();
        $extraData = '';

        foreach ($collection as $extraField) {
            if ($local) {
                $data = $extraField->packLocalFileData();
            } else {
                $data = $extraField->packCentralDirData();
            }
            $extraData .= pack(
                'vv',
                $extraField->getHeaderId(),
                \strlen($data)
            );
            $extraData .= $data;
        }

        $size = \strlen($extraData);

        if ($size > 0xffff) {
            throw new ZipException(
                sprintf(
                    'Size extra out of range: %d. Extra data: %s',
                    $size,
                    $extraData
                )
            );
        }

        return $extraData;
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     *
     * @throws ZipException
     */
    protected function writeData($outStream, ZipEntry $entry)
    {
        $zipData = $entry->getData();

        if ($zipData === null) {
            if ($entry->isDirectory()) {
                return;
            }

            throw new ZipException(sprintf('No zip data for entry "%s"', $entry->getName()));
        }

        // data write variants:
        // --------------------
        // * data of source zip file -> copy compressed data
        // * store - simple write
        // * store and encryption - apply encryption filter and simple write
        // * deflate or bzip2 - apply compression filter and simple write
        // * (deflate or bzip2) and encryption - create temp stream and apply
        //     compression filter to it, then apply encryption filter to root
        //     stream and write temp stream data.
        //     (PHP cannot apply the filter for encryption after the compression
        //     filter, so a temporary stream is created for the compressed data)

        if ($zipData instanceof ZipSourceFileData && !$zipData->hasRecompressData($entry)) {
            // data of source zip file -> copy compressed data
            $zipData->copyCompressedDataToStream($outStream);

            return;
        }

        $entryStream = $zipData->getDataAsStream();

        if (stream_get_meta_data($entryStream)['seekable']) {
            rewind($entryStream);
        }

        $uncompressedSize = $entry->getUncompressedSize();

        $posBeforeWrite = ftell($outStream);
        $compressionMethod = $entry->getCompressionMethod();

        if ($entry->isEncrypted()) {
            if ($compressionMethod === ZipCompressionMethod::STORED) {
                $contextFilter = $this->appendEncryptionFilter($outStream, $entry, $uncompressedSize);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                $checksum = $this->writeAndCountChecksum($entryStream, $outStream, $uncompressedSize);
            } else {
                $compressStream = fopen('php://temp', 'w+b');
                $contextFilter = $this->appendCompressionFilter($compressStream, $entry);
                $contextFilter = $this->appendCompressionFilter(/** @scrutinizer ignore-type */ $compressStream, $entry);
                $checksum = $this->writeAndCountChecksum($entryStream, $compressStream, $uncompressedSize);
                $checksum = $this->writeAndCountChecksum($entryStream, /** @scrutinizer ignore-type */ $compressStream, $uncompressedSize);

                if ($contextFilter !== null) {
                    stream_filter_remove($contextFilter);
                    $contextFilter = null;

                }

                rewind($compressStream);
                rewind(/** @scrutinizer ignore-type */ $compressStream);

                $compressedSize = fstat($compressStream)['size'];
                $compressedSize = fstat(/** @scrutinizer ignore-type */ $compressStream)['size'];
                $contextFilter = $this->appendEncryptionFilter($outStream, $entry, $compressedSize);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

                stream_copy_to_stream($compressStream, $outStream);
                stream_copy_to_stream(/** @scrutinizer ignore-type */ $compressStream, $outStream);
            }
        } else {
            $contextFilter = $this->appendCompressionFilter($outStream, $entry);
            $checksum = $this->writeAndCountChecksum($entryStream, $outStream, $uncompressedSize);
        }

        if ($contextFilter !== null) {
            stream_filter_remove($contextFilter);
            $contextFilter = null;
        }

        // my hack {@see https://bugs.php.net/bug.php?id=49874}
        fseek($outStream, 0, \SEEK_END);
        $compressedSize = ftell($outStream) - $posBeforeWrite;

        $entry->setCompressedSize($compressedSize);
        $entry->setCrc($checksum);

        if (!$entry->isDataDescriptorEnabled()) {
            if ($uncompressedSize > ZipConstants::ZIP64_MAGIC || $compressedSize > ZipConstants::ZIP64_MAGIC) {
                /** @var Zip64ExtraField|null $zip64ExtraLocal */
                $zip64ExtraLocal = $entry->getLocalExtraField(Zip64ExtraField::HEADER_ID);

                // if there is a zip64 extra record, then update it;
                // if not, write data to data descriptor
                if ($zip64ExtraLocal !== null) {
                    $zip64ExtraLocal->setCompressedSize($compressedSize);
                    $zip64ExtraLocal->setUncompressedSize($uncompressedSize);

                    $posExtra = $entry->getLocalHeaderOffset() + ZipConstants::LFH_FILENAME_POS + \strlen($entry->getName());
                    fseek($outStream, $posExtra);
                    fwrite($outStream, $this->getExtraFieldsContents($entry, true));
                } else {
                    $posGPBF = $entry->getLocalHeaderOffset() + 6;
                    $entry->enableDataDescriptor(true);
                    fseek($outStream, $posGPBF);
                    fwrite(
                        $outStream,
                        pack(
                            'v',
                            // general purpose bit flag        2 bytes
                            $entry->getGeneralPurposeBitFlags()
                        )
                    );
                }

                $compressedSize = ZipConstants::ZIP64_MAGIC;
                $uncompressedSize = ZipConstants::ZIP64_MAGIC;
            }

            $posChecksum = $entry->getLocalHeaderOffset() + 14;

            /** @var WinZipAesExtraField|null $winZipAesExtra */
            $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);

            if ($winZipAesExtra !== null && $winZipAesExtra->isV2()) {
                $checksum = 0;
            }

            fseek($outStream, $posChecksum);
            fwrite(
                $outStream,
                pack(
                    'VVV',
                    // crc-32                          4 bytes
                    $checksum,
                    // compressed size                 4 bytes
                    $compressedSize,
                    // uncompressed size               4 bytes
                    $uncompressedSize
                )
            );
            fseek($outStream, 0, \SEEK_END);
        }
    }

    /**
     * @param resource $inStream
     * @param resource $outStream
     * @param int      $size
     *
     * @return int
     */
    private function writeAndCountChecksum($inStream, $outStream, $size)
    {
        $contextHash = hash_init('crc32b');
        $offset = 0;

        while ($offset < $size) {
            $read = min(self::CHUNK_SIZE, $size - $offset);
            $buffer = fread($inStream, $read);
            fwrite($outStream, $buffer);
            hash_update($contextHash, $buffer);
            $offset += $read;
        }

        return (int) hexdec(hash_final($contextHash));
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     *
     * @throws ZipUnsupportMethodException
     *
     * @return resource|null
     */
    protected function appendCompressionFilter($outStream, ZipEntry $entry)
    {
        $contextCompress = null;
        switch ($entry->getCompressionMethod()) {
            case ZipCompressionMethod::DEFLATED:
                if (!($contextCompress = stream_filter_append(
                    $outStream,
                    'zlib.deflate',
                    \STREAM_FILTER_WRITE,
                    ['level' => $entry->getCompressionLevel()]
                ))) {
                    throw new \RuntimeException('Could not append filter "zlib.deflate" to out stream');
                }
                break;

            case ZipCompressionMethod::BZIP2:
                if (!($contextCompress = stream_filter_append(
                    $outStream,
                    'bzip2.compress',
                    \STREAM_FILTER_WRITE,
                    ['blocks' => $entry->getCompressionLevel(), 'work' => 0]
                ))) {
                    throw new \RuntimeException('Could not append filter "bzip2.compress" to out stream');
                }
                break;

            case ZipCompressionMethod::STORED:
                // file without compression, do nothing
                break;

            default:
                throw new ZipUnsupportMethodException(
                    sprintf(
                        '%s (compression method %d (%s) is not supported)',
                        $entry->getName(),
                        $entry->getCompressionMethod(),
                        ZipCompressionMethod::getCompressionMethodName($entry->getCompressionMethod())
                    )
                );
        }

        return $contextCompress;
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     * @param int      $size
     *
     * @return resource|null
     */
    protected function appendEncryptionFilter($outStream, ZipEntry $entry, $size)
    {
        $encContextFilter = null;

        if ($entry->isEncrypted()) {
            if ($entry->getEncryptionMethod() === ZipEncryptionMethod::PKWARE) {
                PKEncryptionStreamFilter::register();
                $cipherFilterName = PKEncryptionStreamFilter::FILTER_NAME;
            } else {
                WinZipAesEncryptionStreamFilter::register();
                $cipherFilterName = WinZipAesEncryptionStreamFilter::FILTER_NAME;
            }
            $encContextFilter = stream_filter_append(
                $outStream,
                $cipherFilterName,
                \STREAM_FILTER_WRITE,
                [
                    'entry' => $entry,
                    'size' => $size,
                ]
            );

            if (!$encContextFilter) {

                throw new \RuntimeException('Not apply filter ' . $cipherFilterName);
            }
        }

        return $encContextFilter;
    }

    /**
     * @param resource $outStream
     * @param ZipEntry $entry
     */
    protected function writeDataDescriptor($outStream, ZipEntry $entry)
    {
        $crc = $entry->getCrc();

        /** @var WinZipAesExtraField|null $winZipAesExtra */
        $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);

        if ($winZipAesExtra !== null && $winZipAesExtra->isV2()) {
            $crc = 0;
        }

        fwrite(
            $outStream,
            pack(
                'VV',
                // data descriptor signature       4 bytes  (0x08074b50)
                ZipConstants::DATA_DESCRIPTOR,
                // crc-32                          4 bytes
                $crc
            )
        );

        if (
            $entry->isZip64ExtensionsRequired() ||
            $entry->getLocalExtraFields()->has(Zip64ExtraField::HEADER_ID)
        ) {
            $dd =
                // compressed size                 8 bytes
                PackUtil::packLongLE($entry->getCompressedSize()) .
                // uncompressed size               8 bytes
                PackUtil::packLongLE($entry->getUncompressedSize());
        } else {
            $dd = pack(
                'VV',
                // compressed size                 4 bytes
                $entry->getCompressedSize(),
                // uncompressed size               4 bytes
                $entry->getUncompressedSize()
            );
        }

        fwrite($outStream, $dd);
    }

    /**
     * @param resource $outStream
     *
     * @throws ZipException
     */
    protected function writeCentralDirectoryBlock($outStream)
    {
        foreach ($this->zipContainer->getEntries() as $outputEntry) {
            $this->writeCentralDirectoryHeader($outStream, $outputEntry);
        }
    }

    /**
     * Writes a Central File Header record.
     *
     * @param resource $outStream
     * @param ZipEntry $entry
     *
     * @throws ZipException
     */
    protected function writeCentralDirectoryHeader($outStream, ZipEntry $entry)
    {
        $compressedSize = $entry->getCompressedSize();
        $uncompressedSize = $entry->getUncompressedSize();
        $localHeaderOffset = $entry->getLocalHeaderOffset();

        $entry->getCdExtraFields()->remove(Zip64ExtraField::HEADER_ID);

        if (
            $localHeaderOffset > ZipConstants::ZIP64_MAGIC ||
            $compressedSize > ZipConstants::ZIP64_MAGIC ||
            $uncompressedSize > ZipConstants::ZIP64_MAGIC
        ) {
            $zip64ExtraField = new Zip64ExtraField();

            if ($uncompressedSize >= ZipConstants::ZIP64_MAGIC) {
                $zip64ExtraField->setUncompressedSize($uncompressedSize);
                $uncompressedSize = ZipConstants::ZIP64_MAGIC;
            }

            if ($compressedSize >= ZipConstants::ZIP64_MAGIC) {
                $zip64ExtraField->setCompressedSize($compressedSize);
                $compressedSize = ZipConstants::ZIP64_MAGIC;
            }

            if ($localHeaderOffset >= ZipConstants::ZIP64_MAGIC) {
                $zip64ExtraField->setLocalHeaderOffset($localHeaderOffset);
                $localHeaderOffset = ZipConstants::ZIP64_MAGIC;
            }

            $entry->getCdExtraFields()->add($zip64ExtraField);
        }

        $extra = $this->getExtraFieldsContents($entry, false);
        $extraLength = \strlen($extra);

        $name = $entry->getName();
        $comment = $entry->getComment();

        $dosCharset = $entry->getCharset();

        if ($dosCharset !== null && !$entry->isUtf8Flag()) {
            $name = DosCodePage::fromUTF8($name, $dosCharset);

            if ($comment) {
                $comment = DosCodePage::fromUTF8($comment, $dosCharset);
            }
        }

        $commentLength = \strlen($comment);

        $compressionMethod = $entry->getCompressionMethod();
        $crc = $entry->getCrc();

        /** @var WinZipAesExtraField|null $winZipAesExtra */
        $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);

        if ($winZipAesExtra !== null) {
            if ($winZipAesExtra->isV2()) {
                $crc = 0;
            }
            $compressionMethod = ZipCompressionMethod::WINZIP_AES;
        }

        fwrite(
            $outStream,
            pack(
                'VvvvvVVVVvvvvvVV',
                // central file header signature   4 bytes  (0x02014b50)
                ZipConstants::CENTRAL_FILE_HEADER,
                // version made by                 2 bytes
                ($entry->getCreatedOS() << 8) | $entry->getSoftwareVersion(),
                // version needed to extract       2 bytes
                ($entry->getExtractedOS() << 8) | $entry->getExtractVersion(),
                // general purpose bit flag        2 bytes
                $entry->getGeneralPurposeBitFlags(),
                // compression method              2 bytes
                $compressionMethod,
                // last mod file datetime          4 bytes
                $entry->getDosTime(),
                // crc-32                          4 bytes
                $crc,
                // compressed size                 4 bytes
                $compressedSize,
                // uncompressed size               4 bytes
                $uncompressedSize,
                // file name length                2 bytes
                \strlen($name),
                // extra field length              2 bytes
                $extraLength,
                // file comment length             2 bytes
                $commentLength,
                // disk number start               2 bytes
                0,
                // internal file attributes        2 bytes
                $entry->getInternalAttributes(),
                // external file attributes        4 bytes
                $entry->getExternalAttributes(),
                // relative offset of local header 4 bytes
                $localHeaderOffset
            )
        );

        // file name (variable size)
        fwrite($outStream, $name);

        if ($extraLength > 0) {
            // extra field (variable size)
            fwrite($outStream, $extra);
        }

        if ($commentLength > 0) {
            // file comment (variable size)
            fwrite($outStream, $comment);
        }
    }

    /**
     * @param resource $outStream
     * @param int      $centralDirectoryOffset
     * @param int      $centralDirectorySize
     */
    protected function writeEndOfCentralDirectoryBlock(
        $outStream,
        $centralDirectoryOffset,
        $centralDirectorySize
    ) {
        $cdEntriesCount = \count($this->zipContainer);

        $cdEntriesZip64 = $cdEntriesCount > 0xffff;
        $cdSizeZip64 = $centralDirectorySize > ZipConstants::ZIP64_MAGIC;
        $cdOffsetZip64 = $centralDirectoryOffset > ZipConstants::ZIP64_MAGIC;

        $zip64Required = $cdEntriesZip64
            || $cdSizeZip64
            || $cdOffsetZip64;

        if ($zip64Required) {
            $zip64EndOfCentralDirectoryOffset = ftell($outStream);

            // find max software version, version needed to extract and most common platform
            list($softwareVersion, $versionNeededToExtract) = array_reduce(
                $this->zipContainer->getEntries(),
                static function (array $carry, ZipEntry $entry) {
                    $carry[0] = max($carry[0], $entry->getSoftwareVersion() & 0xFF);
                    $carry[1] = max($carry[1], $entry->getExtractVersion() & 0xFF);

                    return $carry;
                },
                [ZipVersion::v10_DEFAULT_MIN, ZipVersion::v45_ZIP64_EXT]
            );

            $createdOS = $extractedOS = ZipPlatform::OS_DOS;
            $versionMadeBy = ($createdOS << 8) | max($softwareVersion, ZipVersion::v45_ZIP64_EXT);
            $versionExtractedBy = ($extractedOS << 8) | max($versionNeededToExtract, ZipVersion::v45_ZIP64_EXT);

            // write zip64 end of central directory signature
            fwrite(
                $outStream,
                pack(
                    'V',
                    // signature                       4 bytes  (0x06064b50)
                    ZipConstants::ZIP64_END_CD
                )
            );
            // size of zip64 end of central
            // directory record                8 bytes
            fwrite($outStream, PackUtil::packLongLE(ZipConstants::ZIP64_END_OF_CD_LEN - 12));
            fwrite(
                $outStream,
                pack(
                    'vvVV',
                    // version made by                 2 bytes
                    $versionMadeBy & 0xFFFF,
                    // version needed to extract       2 bytes
                    $versionExtractedBy & 0xFFFF,
                    // number of this disk             4 bytes
                    0,
                    // number of the disk with the
                    // start of the central directory  4 bytes
                    0
                )
            );

            fwrite(
                $outStream,
                // total number of entries in the
                // central directory on this disk  8 bytes
                PackUtil::packLongLE($cdEntriesCount) .
                // total number of entries in the
                // central directory               8 bytes
                PackUtil::packLongLE($cdEntriesCount) .
                // size of the central directory   8 bytes
                PackUtil::packLongLE($centralDirectorySize) .
                // offset of start of central
                // directory with respect to
                // the starting disk number        8 bytes
                PackUtil::packLongLE($centralDirectoryOffset)
            );

            // write zip64 end of central directory locator
            fwrite(
                $outStream,
                pack(
                    'VV',
                    // zip64 end of central dir locator
                    // signature                       4 bytes  (0x07064b50)
                    ZipConstants::ZIP64_END_CD_LOC,
                    // number of the disk with the
                    // start of the zip64 end of
                    // central directory               4 bytes
                    0
                ) .
                // relative offset of the zip64
                // end of central directory record 8 bytes
                PackUtil::packLongLE($zip64EndOfCentralDirectoryOffset) .
                // total number of disks           4 bytes
                pack('V', 1)
            );
        }

        $comment = $this->zipContainer->getArchiveComment();
        $commentLength = $comment !== null ? \strlen($comment) : 0;

        fwrite(
            $outStream,
            pack(
                'VvvvvVVv',
                // end of central dir signature    4 bytes  (0x06054b50)
                ZipConstants::END_CD,
                // number of this disk             2 bytes
                0,
                // number of the disk with the
                // start of the central directory  2 bytes
                0,
                // total number of entries in the
                // central directory on this disk  2 bytes
                $cdEntriesZip64 ? 0xffff : $cdEntriesCount,
                // total number of entries in
                // the central directory           2 bytes
                $cdEntriesZip64 ? 0xffff : $cdEntriesCount,
                // size of the central directory   4 bytes
                $cdSizeZip64 ? ZipConstants::ZIP64_MAGIC : $centralDirectorySize,
                // offset of start of central
                // directory with respect to
                // the starting disk number        4 bytes
                $cdOffsetZip64 ? ZipConstants::ZIP64_MAGIC : $centralDirectoryOffset,
                // .ZIP file comment length        2 bytes
                $commentLength
            )
        );

        if ($comment !== null && $commentLength > 0) {
            // .ZIP file comment       (variable size)
            fwrite($outStream, $comment);
        }
    }
}

Ne-Lexa / php-zip

Push — master ( 3b7697...25d5dd )

ZipWriter::writeAndCountChecksum() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
