- * An offset to check for. - *
+ * @param int $offset an offset to check for * - * @return bool true on success or false on failure. - * - *- * The return value will be casted to boolean if non-boolean was returned. - * - * @since 5.0.0 + * @return bool true on success or false on failure */ public function offsetExists($offset) { - return isset($this->collection[$offset]); + return isset($this->collection[(int) $offset]); } /** @@ -144,19 +151,13 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @see http://php.net/manual/en/arrayaccess.offsetget.php * - * @param mixed $offset
- * The offset to retrieve. - *
+ * @param int $offset the offset to retrieve * - * @throws ZipException - * - * @return mixed can return all value types - * - * @since 5.0.0 + * @return ZipExtraField|null */ public function offsetGet($offset) { - return $this->get($offset); + return isset($this->collection[$offset]) ? $this->collection[$offset] : null; } /** @@ -164,27 +165,15 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @see http://php.net/manual/en/arrayaccess.offsetset.php * - * @param mixed $offset- * The offset to assign the value to. - *
- * @param mixed $value- * The value to set. - *
- * - * @throws ZipException - * - * @since 5.0.0 + * @param mixed $offset the offset to assign the value to + * @param ZipExtraField $value the value to set */ public function offsetSet($offset, $value) { - if ($value instanceof ExtraField) { - if ($offset !== $value::getHeaderId()) { - throw new InvalidArgumentException('Value header id !== array access key'); - } - $this->add($value); - } else { - throw new InvalidArgumentException('value is not instanceof ' . ExtraField::class); + if (!$value instanceof ZipExtraField) { + throw new \InvalidArgumentException('value is not instanceof ' . ZipExtraField::class); } + $this->add($value); } /** @@ -192,13 +181,7 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @see http://php.net/manual/en/arrayaccess.offsetunset.php * - * @param mixed $offset- * The offset to unset. - *
- * - * @since 5.0.0 - * - * @throws ZipException + * @param mixed $offset the offset to unset */ public function offsetUnset($offset) { @@ -210,9 +193,7 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @see http://php.net/manual/en/iterator.current.php * - * @return mixed can return any type - * - * @since 5.0.0 + * @return ZipExtraField */ public function current() { @@ -223,7 +204,6 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * Move forward to next element. * * @see http://php.net/manual/en/iterator.next.php - * @since 5.0.0 */ public function next() { @@ -235,9 +215,7 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @see http://php.net/manual/en/iterator.key.php * - * @return mixed scalar on success, or null on failure - * - * @since 5.0.0 + * @return int scalar on success, or null on failure */ public function key() { @@ -251,25 +229,41 @@ class ExtraFieldsCollection implements \Countable, \ArrayAccess, \Iterator * * @return bool The return value will be casted to boolean and then evaluated. * Returns true on success or false on failure. - * - * @since 5.0.0 */ public function valid() { - return $this->offsetExists($this->key()); + return key($this->collection) !== null; } /** * Rewind the Iterator to the first element. * * @see http://php.net/manual/en/iterator.rewind.php - * @since 5.0.0 */ public function rewind() { reset($this->collection); } + public function clear() + { + $this->collection = []; + } + + /** + * @return string + */ + public function __toString() + { + $formats = []; + + foreach ($this->collection as $key => $value) { + $formats[] = (string) $value; + } + + return implode("\n", $formats); + } + /** * If clone extra fields. */ diff --git a/src/Model/Extra/Fields/AbstractUnicodeExtraField.php b/src/Model/Extra/Fields/AbstractUnicodeExtraField.php new file mode 100644 index 0000000..6587a82 --- /dev/null +++ b/src/Model/Extra/Fields/AbstractUnicodeExtraField.php @@ -0,0 +1,137 @@ +crc32 = (int) $crc32; + $this->unicodeValue = (string) $unicodeValue; + } + + /** + * @param string $unicodeValue + * + * @return static + */ + public static function create($unicodeValue) + { + return new static(crc32($unicodeValue), $unicodeValue); + } + + /** + * @return int the CRC32 checksum of the filename or comment as + * encoded in the central directory of the zip file + */ + public function getCrc32() + { + return $this->crc32; + } + + /** + * @return string + */ + public function getUnicodeValue() + { + return $this->unicodeValue; + } + + /** + * @param string $unicodeValue the UTF-8 encoded name to set + */ + public function setUnicodeValue($unicodeValue) + { + $this->unicodeValue = $unicodeValue; + $this->crc32 = crc32($unicodeValue); + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException on error + * + * @return static + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + if (\strlen($buffer) < 5) { + throw new ZipException('UniCode path extra data must have at least 5 bytes.'); + } + + $version = unpack('C', $buffer)[1]; + + if ($version !== self::DEFAULT_VERSION) { + throw new ZipException(sprintf('Unsupported version [%d] for UniCode path extra data.', $version)); + } + + $crc32 = unpack('V', substr($buffer, 1))[1]; + $unicodeValue = substr($buffer, 5); + + return new static($crc32, $unicodeValue); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException on error + * + * @return static + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + return pack( + 'CV', + self::DEFAULT_VERSION, + $this->crc32 + ) . + $this->unicodeValue; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return $this->packLocalFileData(); + } +} diff --git a/src/Model/Extra/Fields/ApkAlignmentExtraField.php b/src/Model/Extra/Fields/ApkAlignmentExtraField.php new file mode 100644 index 0000000..69c26b8 --- /dev/null +++ b/src/Model/Extra/Fields/ApkAlignmentExtraField.php @@ -0,0 +1,176 @@ +multiple = $multiple; + $this->padding = $padding; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * @return int + */ + public function getMultiple() + { + return $this->multiple; + } + + /** + * @return int + */ + public function getPadding() + { + return $this->padding; + } + + /** + * @param int $multiple + */ + public function setMultiple($multiple) + { + $this->multiple = (int) $multiple; + } + + /** + * @param int $padding + */ + public function setPadding($padding) + { + $this->padding = (int) $padding; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException + * + * @return ApkAlignmentExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $length = \strlen($buffer); + + if ($length < 2) { + // This is APK alignment field. + // FORMAT: + // * uint16 alignment multiple (in bytes) + // * remaining bytes -- padding to achieve alignment of data which starts after + // the extra field + throw new ZipException( + 'Minimum 6 bytes of the extensible data block/field used for alignment of uncompressed entries.' + ); + } + $multiple = unpack('v', $buffer)[1]; + $padding = $length - 2; + + return new self($multiple, $padding); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException on error + * + * @return ApkAlignmentExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + return pack('vx' . $this->padding, $this->multiple); + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return $this->packLocalFileData(); + } + + /** + * @return string + */ + public function __toString() + { + return sprintf( + '0x%04x APK Alignment: Multiple=%d Padding=%d', + self::HEADER_ID, + $this->multiple, + $this->padding + ); + } +} diff --git a/src/Model/Extra/Fields/AsiExtraField.php b/src/Model/Extra/Fields/AsiExtraField.php new file mode 100644 index 0000000..08cf014 --- /dev/null +++ b/src/Model/Extra/Fields/AsiExtraField.php @@ -0,0 +1,300 @@ +mode = (int) $mode; + $this->uid = (int) $uid; + $this->gid = (int) $gid; + $this->link = (string) $link; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws Crc32Exception + * + * @return static + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $givenChecksum = unpack('V', $buffer)[1]; + $buffer = substr($buffer, 4); + $realChecksum = crc32($buffer); + + if ($givenChecksum !== $realChecksum) { + throw new Crc32Exception('Asi Unix Extra Filed Data', $givenChecksum, $realChecksum); + } + + $data = unpack('vmode/VlinkSize/vuid/vgid', $buffer); + $link = ''; + + if ($data['linkSize'] > 0) { + $link = substr($buffer, 8); + } + + return new self($data['mode'], $data['uid'], $data['gid'], $link); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws Crc32Exception + * + * @return AsiExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + $data = pack( + 'vVvv', + $this->mode, + \strlen($this->link), + $this->uid, + $this->gid + ) . $this->link; + + return pack('V', crc32($data)) . $data; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return $this->packLocalFileData(); + } + + /** + * Name of linked file. + * + * @return string name of the file this entry links to if it is a + * symbolic link, the empty string otherwise + */ + public function getLink() + { + return $this->link; + } + + /** + * Indicate that this entry is a symbolic link to the given filename. + * + * @param string $link name of the file this entry links to, empty + * string if it is not a symbolic link + */ + public function setLink($link) + { + $this->link = $link; + $this->mode = $this->getPermissionsMode($this->mode); + } + + /** + * Is this entry a symbolic link? + * + * @return bool true if this is a symbolic link + */ + public function isLink() + { + return !empty($this->link); + } + + /** + * Get the file mode for given permissions with the correct file type. + * + * @param int $mode the mode + * + * @return int the type with the mode + */ + protected function getPermissionsMode($mode) + { + $type = UnixStat::UNX_IFMT; + + if ($this->isLink()) { + $type = UnixStat::UNX_IFLNK; + } elseif ($this->isDirectory()) { + $type = UnixStat::UNX_IFDIR; + } + + return $type | ($mode & self::PERM_MASK); + } + + /** + * Is this entry a directory? + * + * @return bool true if this entry is a directory + */ + public function isDirectory() + { + return ($this->mode & UnixStat::UNX_IFDIR) !== 0 && !$this->isLink(); + } + + /** + * @return int + */ + public function getMode() + { + return $this->mode; + } + + /** + * @param int $mode + */ + public function setMode($mode) + { + $this->mode = $this->getPermissionsMode($mode); + } + + /** + * @return int + */ + public function getUserId() + { + return $this->uid; + } + + /** + * @param int $uid + */ + public function setUserId($uid) + { + $this->uid = $uid; + } + + /** + * @return int + */ + public function getGroupId() + { + return $this->gid; + } + + /** + * @param int $gid + */ + public function setGroupId($gid) + { + $this->gid = $gid; + } + + /** + * @return string + */ + public function __toString() + { + return sprintf( + '0x%04x ASI: Mode=%o UID=%d GID=%d Link="%s', + self::HEADER_ID, + $this->mode, + $this->uid, + $this->gid, + $this->link + ); + } +} diff --git a/src/Model/Extra/Fields/ExtendedTimestampExtraField.php b/src/Model/Extra/Fields/ExtendedTimestampExtraField.php new file mode 100644 index 0000000..4019ca4 --- /dev/null +++ b/src/Model/Extra/Fields/ExtendedTimestampExtraField.php @@ -0,0 +1,425 @@ +flags = (int) $flags; + $this->modifyTime = $modifyTime; + $this->accessTime = $accessTime; + $this->createTime = $createTime; + } + + /** + * @param int|null $modifyTime + * @param int|null $accessTime + * @param int|null $createTime + * + * @return ExtendedTimestampExtraField + */ + public static function create($modifyTime, $accessTime, $createTime) + { + $flags = 0; + + if ($modifyTime !== null) { + $modifyTime = (int) $modifyTime; + $flags |= self::MODIFY_TIME_BIT; + } + + if ($accessTime !== null) { + $accessTime = (int) $accessTime; + $flags |= self::ACCESS_TIME_BIT; + } + + if ($createTime !== null) { + $createTime = (int) $createTime; + $flags |= self::CREATE_TIME_BIT; + } + + return new self($flags, $modifyTime, $accessTime, $createTime); + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return ExtendedTimestampExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $length = \strlen($buffer); + $flags = unpack('C', $buffer)[1]; + $offset = 1; + + $modifyTime = null; + $accessTime = null; + $createTime = null; + + if (($flags & self::MODIFY_TIME_BIT) === self::MODIFY_TIME_BIT) { + $modifyTime = unpack('V', substr($buffer, $offset, 4))[1]; + $offset += 4; + } + + // Notice the extra length check in case we are parsing the shorter + // central data field (for both access and create timestamps). + if ((($flags & self::ACCESS_TIME_BIT) === self::ACCESS_TIME_BIT) && $offset + 4 <= $length) { + $accessTime = unpack('V', substr($buffer, $offset, 4))[1]; + $offset += 4; + } + + if ((($flags & self::CREATE_TIME_BIT) === self::CREATE_TIME_BIT) && $offset + 4 <= $length) { + $createTime = unpack('V', substr($buffer, $offset, 4))[1]; + } + + return new self($flags, $modifyTime, $accessTime, $createTime); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return ExtendedTimestampExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + $data = ''; + + if (($this->flags & self::MODIFY_TIME_BIT) === self::MODIFY_TIME_BIT && $this->modifyTime !== null) { + $data .= pack('V', $this->modifyTime); + } + + if (($this->flags & self::ACCESS_TIME_BIT) === self::ACCESS_TIME_BIT && $this->accessTime !== null) { + $data .= pack('V', $this->accessTime); + } + + if (($this->flags & self::CREATE_TIME_BIT) === self::CREATE_TIME_BIT && $this->createTime !== null) { + $data .= pack('V', $this->createTime); + } + + return pack('C', $this->flags) . $data; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * Note: even if bit1 and bit2 are set, the Central data will still + * not contain access/create fields: only local data ever holds those! + * + * @return string the data + */ + public function packCentralDirData() + { + $cdLength = 1 + ($this->modifyTime !== null ? 4 : 0); + + return substr($this->packLocalFileData(), 0, $cdLength); + } + + /** + * Gets flags byte. + * + * The flags byte tells us which of the three datestamp fields are + * present in the data: + * bit0 - modify time + * bit1 - access time + * bit2 - create time + * + * Only first 3 bits of flags are used according to the + * latest version of the spec (December 2012). + * + * @return int flags byte indicating which of the + * three datestamp fields are present + */ + public function getFlags() + { + return $this->flags; + } + + /** + * Returns the modify time (seconds since epoch) of this zip entry, + * or null if no such timestamp exists in the zip entry. + * + * @return int|null modify time (seconds since epoch) or null + */ + public function getModifyTime() + { + return $this->modifyTime; + } + + /** + * Returns the access time (seconds since epoch) of this zip entry, + * or null if no such timestamp exists in the zip entry. + * + * @return int|null access time (seconds since epoch) or null + */ + public function getAccessTime() + { + return $this->accessTime; + } + + /** + * Returns the create time (seconds since epoch) of this zip entry, + * or null if no such timestamp exists in the zip entry. + * + * Note: modern linux file systems (e.g., ext2) + * do not appear to store a "create time" value, and so + * it's usually omitted altogether in the zip extra + * field. Perhaps other unix systems track this. + * + * @return int|null create time (seconds since epoch) or null + */ + public function getCreateTime() + { + return $this->createTime; + } + + /** + * Returns the modify time as a \DateTimeInterface + * of this zip entry, or null if no such timestamp exists in the zip entry. + * The milliseconds are always zeroed out, since the underlying data + * offers only per-second precision. + * + * @return \DateTimeInterface|null modify time as \DateTimeInterface or null + */ + public function getModifyDateTime() + { + return self::timestampToDateTime($this->modifyTime); + } + + /** + * Returns the access time as a \DateTimeInterface + * of this zip entry, or null if no such timestamp exists in the zip entry. + * The milliseconds are always zeroed out, since the underlying data + * offers only per-second precision. + * + * @return \DateTimeInterface|null access time as \DateTimeInterface or null + */ + public function getAccessDateTime() + { + return self::timestampToDateTime($this->accessTime); + } + + /** + * Returns the create time as a a \DateTimeInterface + * of this zip entry, or null if no such timestamp exists in the zip entry. + * The milliseconds are always zeroed out, since the underlying data + * offers only per-second precision. + * + * Note: modern linux file systems (e.g., ext2) + * do not appear to store a "create time" value, and so + * it's usually omitted altogether in the zip extra + * field. Perhaps other unix systems track $this->. + * + * @return \DateTimeInterface|null create time as \DateTimeInterface or null + */ + public function getCreateDateTime() + { + return self::timestampToDateTime($this->createTime); + } + + /** + * Sets the modify time (seconds since epoch) of this zip entry + * using a integer. + * + * @param int|null $unixTime unix time of the modify time (seconds per epoch) or null + */ + public function setModifyTime($unixTime) + { + $this->modifyTime = $unixTime; + } + + /** + * Sets the access time (seconds since epoch) of this zip entry + * using a integer. + * + * @param int|null $unixTime Unix time of the access time (seconds per epoch) or null + */ + public function setAccessTime($unixTime) + { + $this->accessTime = $unixTime; + } + + /** + * Sets the create time (seconds since epoch) of this zip entry + * using a integer. + * + * @param int|null $unixTime Unix time of the create time (seconds per epoch) or null + */ + public function setCreateTime($unixTime) + { + $this->createTime = $unixTime; + } + + /** + * @param int|null $timestamp + * + * @return \DateTimeInterface|null + */ + private static function timestampToDateTime($timestamp) + { + try { + return $timestamp !== null ? new \DateTimeImmutable('@' . $timestamp) : null; + } catch (\Exception $e) { + return null; + } + } + + /** + * @return string + */ + public function __toString() + { + $args = [self::HEADER_ID]; + $format = '0x%04x ExtendedTimestamp:'; + + if ($this->modifyTime !== null) { + $format .= ' Modify:[%s]'; + $args[] = date(\DATE_W3C, $this->modifyTime); + } + + if ($this->accessTime !== null) { + $format .= ' Access:[%s]'; + $args[] = date(\DATE_W3C, $this->accessTime); + } + + if ($this->createTime !== null) { + $format .= ' Create:[%s]'; + $args[] = date(\DATE_W3C, $this->createTime); + } + + return vsprintf($format, $args); + } +} diff --git a/src/Model/Extra/Fields/JarMarkerExtraField.php b/src/Model/Extra/Fields/JarMarkerExtraField.php new file mode 100644 index 0000000..e1683aa --- /dev/null +++ b/src/Model/Extra/Fields/JarMarkerExtraField.php @@ -0,0 +1,118 @@ +getEntries(); + + if (!empty($zipEntries)) { + foreach ($zipEntries as $zipEntry) { + $zipEntry->removeExtraField(self::HEADER_ID); + } + // set jar execute bit + reset($zipEntries); + $zipEntry = current($zipEntries); + $zipEntry->getCdExtraFields()[] = new self(); + } + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + return ''; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return ''; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException on error + * + * @return JarMarkerExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + if (!empty($buffer)) { + throw new ZipException("JarMarker doesn't expect any data"); + } + + return new self(); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException on error + * + * @return JarMarkerExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * @return string + */ + public function __toString() + { + return sprintf('0x%04x Jar Marker', self::HEADER_ID); + } +} diff --git a/src/Model/Extra/Fields/NewUnixExtraField.php b/src/Model/Extra/Fields/NewUnixExtraField.php new file mode 100644 index 0000000..2f657af --- /dev/null +++ b/src/Model/Extra/Fields/NewUnixExtraField.php @@ -0,0 +1,248 @@ +version = (int) $version; + $this->uid = (int) $uid; + $this->gid = (int) $gid; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException + * + * @return NewUnixExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $length = \strlen($buffer); + + if ($length < 3) { + throw new ZipException(sprintf('X7875_NewUnix length is too short, only %s bytes', $length)); + } + $offset = 0; + $data = unpack('Cversion/CuidSize', $buffer); + $offset += 2; + $uidSize = $data['uidSize']; + $gid = self::readSizeIntegerLE(substr($buffer, $offset, $uidSize), $uidSize); + $offset += $uidSize; + $gidSize = unpack('C', $buffer[$offset])[1]; + $offset++; + $uid = self::readSizeIntegerLE(substr($buffer, $offset, $gidSize), $gidSize); + + return new self($data['version'], $gid, $uid); + } + + /** + * Converts a signed byte into an unsigned integer representation + * (e.g., -1 becomes 255). + * + * @param int $b byte to convert to int + * + * @return int representation of the provided byte + * + * @since 1.5 + */ + public static function signedByteToUnsignedInt($b) + { + if ($b >= 0) { + return $b; + } + + return 256 + $b; + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @throws ZipException + * + * @return NewUnixExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + return pack( + 'CCVCV', + $this->version, + 4, // GIDSize + $this->gid, + 4, // UIDSize + $this->uid + ); + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return $this->packLocalFileData(); + } + + /** + * @param string $data + * @param int $size + * + * @throws ZipException + * + * @return int + */ + private static function readSizeIntegerLE($data, $size) + { + $format = [ + 1 => 'C', // unsigned byte + 2 => 'v', // unsigned short LE + 4 => 'V', // unsigned int LE + ]; + + if (!isset($format[$size])) { + throw new ZipException(sprintf('Invalid size bytes: %d', $size)); + } + + return unpack($format[$size], $data)[1]; + } + + /** + * @return int + */ + public function getUid() + { + return $this->uid; + } + + /** + * @param int $uid + */ + public function setUid($uid) + { + $this->uid = $uid & 0xffffffff; + } + + /** + * @return int + */ + public function getGid() + { + return $this->gid; + } + + /** + * @param int $gid + */ + public function setGid($gid) + { + $this->gid = $gid & 0xffffffff; + } + + /** + * @return string + */ + public function __toString() + { + return sprintf( + '0x%04x NewUnix: UID=%d GID=%d', + self::HEADER_ID, + $this->uid, + $this->gid + ); + } +} diff --git a/src/Model/Extra/Fields/NtfsExtraField.php b/src/Model/Extra/Fields/NtfsExtraField.php new file mode 100644 index 0000000..7d68d78 --- /dev/null +++ b/src/Model/Extra/Fields/NtfsExtraField.php @@ -0,0 +1,242 @@ +modifyTime = (int) $modifyTime; + $this->accessTime = (int) $accessTime; + $this->createTime = (int) $createTime; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return NtfsExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $buffer = substr($buffer, 4); + + $modifyTime = 0; + $accessTime = 0; + $createTime = 0; + + while ($buffer || $buffer !== '') { + $unpack = unpack('vtag/vsizeAttr', $buffer); + + if ($unpack['tag'] === self::TIME_ATTR_TAG && $unpack['sizeAttr'] === self::TIME_ATTR_SIZE) { + // refactoring will be needed when php 5.5 support ends + $modifyTime = PackUtil::unpackLongLE(substr($buffer, 4, 8)); + $accessTime = PackUtil::unpackLongLE(substr($buffer, 12, 8)); + $createTime = PackUtil::unpackLongLE(substr($buffer, 20, 8)); + + break; + } + $buffer = substr($buffer, 4 + $unpack['sizeAttr']); + } + + return new self($modifyTime, $accessTime, $createTime); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return NtfsExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + return self::unpackLocalFileData($buffer, $entry); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + $data = pack('Vvv', 0, self::TIME_ATTR_TAG, self::TIME_ATTR_SIZE); + // refactoring will be needed when php 5.5 support ends + $data .= PackUtil::packLongLE($this->modifyTime); + $data .= PackUtil::packLongLE($this->accessTime); + $data .= PackUtil::packLongLE($this->createTime); + + return $data; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + return $this->packLocalFileData(); + } + + /** + * @return \DateTimeInterface + */ + public function getModifyDateTime() + { + return $this->ntfsTimeToDateTime($this->modifyTime); + } + + /** + * @param \DateTimeInterface $modifyTime + */ + public function setModifyDateTime(\DateTimeInterface $modifyTime) + { + $this->modifyTime = $this->dateTimeToNtfsTime($modifyTime); + } + + /** + * @return \DateTimeInterface + */ + public function getAccessDateTime() + { + return $this->ntfsTimeToDateTime($this->accessTime); + } + + /** + * @param \DateTimeInterface $accessTime + */ + public function setAccessDateTime(\DateTimeInterface $accessTime) + { + $this->accessTime = $this->dateTimeToNtfsTime($accessTime); + } + + /** + * @return \DateTimeInterface + */ + public function getCreateDateTime() + { + return $this->ntfsTimeToDateTime($this->createTime); + } + + /** + * @param \DateTimeInterface $createTime + */ + public function setCreateDateTime(\DateTimeInterface $createTime) + { + $this->createTime = $this->dateTimeToNtfsTime($createTime); + } + + /** + * @param \DateTimeInterface $dateTime + * + * @return int + */ + protected function dateTimeToNtfsTime(\DateTimeInterface $dateTime) + { + return $dateTime->getTimestamp() * 10000000 + self::EPOCH_OFFSET; + } + + /** + * @param int $time + * + * @return \DateTimeInterface + */ + protected function ntfsTimeToDateTime($time) + { + $timestamp = (int) ($time / 10000000 + self::EPOCH_OFFSET); + + try { + return new \DateTimeImmutable('@' . $timestamp); + } catch (\Exception $e) { + throw new InvalidArgumentException('Cannot create date/time object for timestamp ' . $timestamp, 1, $e); + } + } + + /** + * @return string + */ + public function __toString() + { + $args = [self::HEADER_ID]; + $format = '0x%04x NtfsExtra:'; + + if ($this->modifyTime !== 0) { + $format .= ' Modify:[%s]'; + $args[] = $this->getModifyDateTime()->format(\DATE_ATOM); + } + + if ($this->accessTime !== 0) { + $format .= ' Access:[%s]'; + $args[] = $this->getAccessDateTime()->format(\DATE_ATOM); + } + + if ($this->createTime !== 0) { + $format .= ' Create:[%s]'; + $args[] = $this->getCreateDateTime()->format(\DATE_ATOM); + } + + return vsprintf($format, $args); + } +} diff --git a/src/Model/Extra/Fields/OldUnixExtraField.php b/src/Model/Extra/Fields/OldUnixExtraField.php new file mode 100644 index 0000000..1f69487 --- /dev/null +++ b/src/Model/Extra/Fields/OldUnixExtraField.php @@ -0,0 +1,327 @@ +accessTime = $accessTime; + $this->modifyTime = $modifyTime; + $this->uid = $uid; + $this->gid = $gid; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return self::HEADER_ID; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return OldUnixExtraField + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + $length = \strlen($buffer); + + $accessTime = $modifyTime = $uid = $gid = null; + + if ($length >= 4) { + $accessTime = unpack('V', $buffer)[1]; + } + + if ($length >= 8) { + $modifyTime = unpack('V', substr($buffer, 4, 4))[1]; + } + + if ($length >= 10) { + $uid = unpack('v', substr($buffer, 8, 2))[1]; + } + + if ($length >= 12) { + $gid = unpack('v', substr($buffer, 10, 2))[1]; + } + + return new self($accessTime, $modifyTime, $uid, $gid); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + * + * @return OldUnixExtraField + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + $length = \strlen($buffer); + + $accessTime = $modifyTime = null; + + if ($length >= 4) { + $accessTime = unpack('V', $buffer)[1]; + } + + if ($length >= 8) { + $modifyTime = unpack('V', substr($buffer, 4, 4))[1]; + } + + return new self($accessTime, $modifyTime, null, null); + } + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return string the data + */ + public function packLocalFileData() + { + $data = ''; + + if ($this->accessTime !== null) { + $data .= pack('V', $this->accessTime); + + if ($this->modifyTime !== null) { + $data .= pack('V', $this->modifyTime); + + if ($this->uid !== null) { + $data .= pack('v', $this->uid); + + if ($this->gid !== null) { + $data .= pack('v', $this->gid); + } + } + } + } + + return $data; + } + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return string the data + */ + public function packCentralDirData() + { + $data = ''; + + if ($this->accessTime !== null) { + $data .= pack('V', $this->accessTime); + + if ($this->modifyTime !== null) { + $data .= pack('V', $this->modifyTime); + } + } + + return $data; + } + + /** + * @return int|null + */ + public function getAccessTime() + { + return $this->accessTime; + } + + /** + * @param int|null $accessTime + */ + public function setAccessTime($accessTime) + { + $this->accessTime = $accessTime; + } + + /** + * @return \DateTimeInterface|null + */ + public function getAccessDateTime() + { + try { + return $this->accessTime === null ? null : + new \DateTimeImmutable('@' . $this->accessTime); + } catch (\Exception $e) { + return null; + } + } + + /** + * @return int|null + */ + public function getModifyTime() + { + return $this->modifyTime; + } + + /** + * @param int|null $modifyTime + */ + public function setModifyTime($modifyTime) + { + $this->modifyTime = $modifyTime; + } + + /** + * @return \DateTimeInterface|null + */ + public function getModifyDateTime() + { + try { + return $this->modifyTime === null ? null : + new \DateTimeImmutable('@' . $this->modifyTime); + } catch (\Exception $e) { + return null; + } + } + + /** + * @return int|null + */ + public function getUid() + { + return $this->uid; + } + + /** + * @param int|null $uid + */ + public function setUid($uid) + { + $this->uid = $uid; + } + + /** + * @return int|null + */ + public function getGid() + { + return $this->gid; + } + + /** + * @param int|null $gid + */ + public function setGid($gid) + { + $this->gid = $gid; + } + + /** + * @return string + */ + public function __toString() + { + $args = [self::HEADER_ID]; + $format = '0x%04x OldUnix:'; + + if (($modifyTime = $this->getModifyDateTime()) !== null) { + $format .= ' Modify:[%s]'; + $args[] = $modifyTime->format(\DATE_ATOM); + } + + if (($accessTime = $this->getAccessDateTime()) !== null) { + $format .= ' Access:[%s]'; + $args[] = $accessTime->format(\DATE_ATOM); + } + + if ($this->uid !== null) { + $format .= ' UID=%d'; + $args[] = $this->uid; + } + + if ($this->gid !== null) { + $format .= ' GID=%d'; + $args[] = $this->gid; + } + + return vsprintf($format, $args); + } +} diff --git a/src/Model/Extra/Fields/UnicodeCommentExtraField.php b/src/Model/Extra/Fields/UnicodeCommentExtraField.php new file mode 100644 index 0000000..d8280b6 --- /dev/null +++ b/src/Model/Extra/Fields/UnicodeCommentExtraField.php @@ -0,0 +1,76 @@ +getUnicodeValue() + ); + } +} diff --git a/src/Model/Extra/Fields/UnicodePathExtraField.php b/src/Model/Extra/Fields/UnicodePathExtraField.php new file mode 100644 index 0000000..047b2d0 --- /dev/null +++ b/src/Model/Extra/Fields/UnicodePathExtraField.php @@ -0,0 +1,77 @@ +getUnicodeValue() + ); + } +} diff --git a/src/Model/Extra/Fields/UnrecognizedExtraField.php b/src/Model/Extra/Fields/UnrecognizedExtraField.php new file mode 100644 index 0000000..d0f45f8 --- /dev/null +++ b/src/Model/Extra/Fields/UnrecognizedExtraField.php @@ -0,0 +1,115 @@ +headerId = (int) $headerId; + $this->data = (string) $data; + } + + /** + * @param int $headerId + */ + public function setHeaderId($headerId) + { + $this->headerId = $headerId; + } + + /** + * Returns the Header ID (type) of this Extra Field. + * The Header ID is an unsigned short integer (two bytes) + * which must be constant during the life cycle of this object. + * + * @return int + */ + public function getHeaderId() + { + return $this->headerId; + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + */ + public static function unpackLocalFileData($buffer, ZipEntry $entry = null) + { + throw new \RuntimeException('Unsupport parse'); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param string $buffer the buffer to read data from + * @param ZipEntry|null $entry + */ + public static function unpackCentralDirData($buffer, ZipEntry $entry = null) + { + throw new \RuntimeException('Unsupport parse'); + } + + /** + * {@inheritdoc} + */ + public function packLocalFileData() + { + return $this->data; + } + + /** + * {@inheritdoc} + */ + public function packCentralDirData() + { + return $this->data; + } + + /** + * @return string + */ + public function getData() + { + return $this->data; + } + + /** + * @param string $data + */ + public function setData($data) + { + $this->data = (string) $data; + } + + /** + * @return string + */ + public function __toString() + { + $args = [$this->headerId, $this->data]; + $format = '0x%04x Unrecognized Extra Field: "%s"'; + + return vsprintf($format, $args); + } +} diff --git a/src/Model/Extra/Fields/WinZipAesExtraField.php b/src/Model/Extra/Fields/WinZipAesExtraField.php new file mode 100644 index 0000000..5334f09 --- /dev/null +++ b/src/Model/Extra/Fields/WinZipAesExtraField.php @@ -0,0 +1,387 @@ + */ + private static $encryptionStrengths = [ + self::KEY_STRENGTH_128BIT => 128, + self::KEY_STRENGTH_192BIT => 192, + self::KEY_STRENGTH_256BIT => 256, + ]; + + /** @var array- * The return value is cast to an integer. - * - * @since 5.1.0 - */ - public function count() - { - return \count($this->outEntries); - } - - /** - * Undo all changes done in the archive. - */ - public function unchangeAll() - { - $this->outEntries = $this->inputEntries; - $this->unchangeArchiveComment(); - } - - /** - * Undo change archive comment. - */ - public function unchangeArchiveComment() - { - $this->archiveCommentChanges = null; - $this->archiveCommentChanged = false; - } - - /** - * Revert all changes done to an entry with the given name. - * - * @param string|ZipEntry $entry Entry name or ZipEntry - * - * @return bool - */ - public function unchangeEntry($entry) - { - $entry = $entry instanceof ZipEntry ? $entry->getName() : (string) $entry; - - if (isset($this->outEntries[$entry], $this->inputEntries[$entry])) { - $this->outEntries[$entry] = $this->inputEntries[$entry]; - - return true; - } - - return false; - } - - /** - * @param int $encryptionMethod - */ - public function setEncryptionMethod($encryptionMethod = ZipFile::ENCRYPTION_METHOD_WINZIP_AES_256) - { - $this->matcher()->all()->setEncryptionMethod($encryptionMethod); - } - - /** - * @return ZipEntryMatcher - */ - public function matcher() - { - return new ZipEntryMatcher($this); - } -} diff --git a/src/PhpZip/Stream/ZipInputStream.php b/src/PhpZip/Stream/ZipInputStream.php deleted file mode 100644 index 6d1779d..0000000 --- a/src/PhpZip/Stream/ZipInputStream.php +++ /dev/null @@ -1,718 +0,0 @@ -in = $in; - } - - /** - * @throws ZipException - * - * @return ZipModel - */ - public function readZip() - { - $this->checkZipFileSignature(); - $endOfCentralDirectory = $this->readEndOfCentralDirectory(); - $entries = $this->mountCentralDirectory($endOfCentralDirectory); - $this->zipModel = ZipModel::newSourceModel($entries, $endOfCentralDirectory); - - return $this->zipModel; - } - - /** - * Check zip file signature. - * - * @throws ZipException if this not .ZIP file. - */ - protected function checkZipFileSignature() - { - rewind($this->in); - // Constraint: A ZIP file must start with a Local File Header - // or a (ZIP64) End Of Central Directory Record if it's empty. - $signatureBytes = fread($this->in, 4); - - if (\strlen($signatureBytes) < 4) { - throw new ZipException('Invalid zip file.'); - } - $signature = unpack('V', $signatureBytes)[1]; - - if ( - $signature !== ZipEntry::LOCAL_FILE_HEADER_SIG - && $signature !== EndOfCentralDirectory::ZIP64_END_OF_CD_RECORD_SIG - && $signature !== EndOfCentralDirectory::END_OF_CD_SIG - ) { - throw new ZipException( - 'Expected Local File Header or (ZIP64) End Of Central Directory Record! Signature: ' . $signature - ); - } - } - - /** - * @throws ZipException - * - * @return EndOfCentralDirectory - */ - protected function readEndOfCentralDirectory() - { - if (!$this->findEndOfCentralDirectory()) { - throw new ZipException('Invalid zip file. The end of the central directory could not be found.'); - } - - $positionECD = ftell($this->in) - 4; - $buffer = fread($this->in, fstat($this->in)['size'] - $positionECD); - - $unpack = unpack( - 'vdiskNo/vcdDiskNo/vcdEntriesDisk/' . - 'vcdEntries/VcdSize/VcdPos/vcommentLength', - substr($buffer, 0, 18) - ); - - if ( - $unpack['diskNo'] !== 0 || - $unpack['cdDiskNo'] !== 0 || - $unpack['cdEntriesDisk'] !== $unpack['cdEntries'] - ) { - throw new ZipException( - 'ZIP file spanning/splitting is not supported!' - ); - } - // .ZIP file comment (variable sizeECD) - $comment = null; - - if ($unpack['commentLength'] > 0) { - $comment = substr($buffer, 18, $unpack['commentLength']); - } - - // Check for ZIP64 End Of Central Directory Locator exists. - $zip64ECDLocatorPosition = $positionECD - EndOfCentralDirectory::ZIP64_END_OF_CD_LOCATOR_LEN; - fseek($this->in, $zip64ECDLocatorPosition); - // zip64 end of central dir locator - // signature 4 bytes (0x07064b50) - if ($zip64ECDLocatorPosition > 0 && unpack( - 'V', - fread($this->in, 4) - )[1] === EndOfCentralDirectory::ZIP64_END_OF_CD_LOCATOR_SIG) { - $positionECD = $this->findZip64ECDPosition(); - $endCentralDirectory = $this->readZip64EndOfCentralDirectory($positionECD); - $endCentralDirectory->setComment($comment); - } else { - $endCentralDirectory = new EndOfCentralDirectory( - $unpack['cdEntries'], - $unpack['cdPos'], - $unpack['cdSize'], - false, - $comment - ); - } - - return $endCentralDirectory; - } - - /** - * @throws ZipException - * - * @return bool - */ - protected function findEndOfCentralDirectory() - { - $max = fstat($this->in)['size'] - EndOfCentralDirectory::END_OF_CENTRAL_DIRECTORY_RECORD_MIN_LEN; - - if ($max < 0) { - throw new ZipException('Too short to be a zip file'); - } - $min = $max >= 0xffff ? $max - 0xffff : 0; - // Search for End of central directory record. - for ($position = $max; $position >= $min; $position--) { - fseek($this->in, $position); - // end of central dir signature 4 bytes (0x06054b50) - if (unpack('V', fread($this->in, 4))[1] !== EndOfCentralDirectory::END_OF_CD_SIG) { - continue; - } - - return true; - } - - return false; - } - - /** - * Read Zip64 end of central directory locator and returns - * Zip64 end of central directory position. - * - * number of the disk with the - * start of the zip64 end of - * central directory 4 bytes - * relative offset of the zip64 - * end of central directory record 8 bytes - * total number of disks 4 bytes - * - * @throws ZipException - * - * @return int Zip64 End Of Central Directory position - */ - protected function findZip64ECDPosition() - { - $diskNo = unpack('V', fread($this->in, 4))[1]; - $zip64ECDPos = PackUtil::unpackLongLE(fread($this->in, 8)); - $totalDisks = unpack('V', fread($this->in, 4))[1]; - - if ($diskNo !== 0 || $totalDisks > 1) { - throw new ZipException('ZIP file spanning/splitting is not supported!'); - } - - return $zip64ECDPos; - } - - /** - * Read zip64 end of central directory locator and zip64 end - * of central directory record. - * - * zip64 end of central dir - * signature 4 bytes (0x06064b50) - * size of zip64 end of central - * directory record 8 bytes - * version made by 2 bytes - * version needed to extract 2 bytes - * number of this disk 4 bytes - * number of the disk with the - * start of the central directory 4 bytes - * total number of entries in the - * central directory on this disk 8 bytes - * total number of entries in the - * central directory 8 bytes - * size of the central directory 8 bytes - * offset of start of central - * directory with respect to - * the starting disk number 8 bytes - * zip64 extensible data sector (variable size) - * - * @param int $zip64ECDPosition - * - * @throws ZipException - * - * @return EndOfCentralDirectory - */ - protected function readZip64EndOfCentralDirectory($zip64ECDPosition) - { - fseek($this->in, $zip64ECDPosition); - - $buffer = fread($this->in, 56 /* zip64 end of cd rec length */); - - if (unpack('V', $buffer)[1] !== EndOfCentralDirectory::ZIP64_END_OF_CD_RECORD_SIG) { - throw new ZipException('Expected ZIP64 End Of Central Directory Record!'); - } - - $data = unpack( - 'VdiskNo/VcdDiskNo', - substr($buffer, 16) - ); - $cdEntriesDisk = PackUtil::unpackLongLE(substr($buffer, 24, 8)); - $entryCount = PackUtil::unpackLongLE(substr($buffer, 32, 8)); - $cdSize = PackUtil::unpackLongLE(substr($buffer, 40, 8)); - $cdPos = PackUtil::unpackLongLE(substr($buffer, 48, 8)); - - if ($data['diskNo'] !== 0 || $data['cdDiskNo'] !== 0 || $entryCount !== $cdEntriesDisk) { - throw new ZipException('ZIP file spanning/splitting is not supported!'); - } - - if ($entryCount < 0 || $entryCount > 0x7fffffff) { - throw new ZipException('Total Number Of Entries In The Central Directory out of range!'); - } - - // skip zip64 extensible data sector (variable sizeEndCD) - - return new EndOfCentralDirectory( - $entryCount, - $cdPos, - $cdSize, - true - ); - } - - /** - * Reads the central directory from the given seekable byte channel - * and populates the internal tables with ZipEntry instances. - * - * The ZipEntry's will know all data that can be obtained from the - * central directory alone, but not the data that requires the local - * file header or additional data to be read. - * - * @param EndOfCentralDirectory $endOfCentralDirectory - * - * @throws ZipException - * - * @return ZipEntry[] - */ - protected function mountCentralDirectory(EndOfCentralDirectory $endOfCentralDirectory) - { - $entries = []; - - fseek($this->in, $endOfCentralDirectory->getCdOffset()); - - if (!($cdStream = fopen('php://temp', 'w+b'))) { - throw new ZipException('Temp resource can not open from write'); - } - stream_copy_to_stream($this->in, $cdStream, $endOfCentralDirectory->getCdSize()); - rewind($cdStream); - for ($numEntries = $endOfCentralDirectory->getEntryCount(); $numEntries > 0; $numEntries--) { - $entry = $this->readCentralDirectoryEntry($cdStream); - $entries[$entry->getName()] = $entry; - } - fclose($cdStream); - - return $entries; - } - - /** - * Read central directory entry. - * - * central file header signature 4 bytes (0x02014b50) - * version made by 2 bytes - * version needed to extract 2 bytes - * general purpose bit flag 2 bytes - * compression method 2 bytes - * last mod file time 2 bytes - * last mod file date 2 bytes - * crc-32 4 bytes - * compressed size 4 bytes - * uncompressed size 4 bytes - * file name length 2 bytes - * extra field length 2 bytes - * file comment length 2 bytes - * disk number start 2 bytes - * internal file attributes 2 bytes - * external file attributes 4 bytes - * relative offset of local header 4 bytes - * - * file name (variable size) - * extra field (variable size) - * file comment (variable size) - * - * @param resource $stream - * - * @throws ZipException - * - * @return ZipEntry - */ - public function readCentralDirectoryEntry($stream) - { - if (unpack('V', fread($stream, 4))[1] !== ZipOutputStreamInterface::CENTRAL_FILE_HEADER_SIG) { - throw new ZipException('Corrupt zip file. Cannot read central dir entry.'); - } - - $data = unpack( - 'vversionMadeBy/vversionNeededToExtract/' . - 'vgeneralPurposeBitFlag/vcompressionMethod/' . - 'VlastModFile/Vcrc/VcompressedSize/' . - 'VuncompressedSize/vfileNameLength/vextraFieldLength/' . - 'vfileCommentLength/vdiskNumberStart/vinternalFileAttributes/' . - 'VexternalFileAttributes/VoffsetLocalHeader', - fread($stream, 42) - ); - - $createdOS = ($data['versionMadeBy'] & 0xFF00) >> 8; - $softwareVersion = $data['versionMadeBy'] & 0x00FF; - - $extractOS = ($data['versionNeededToExtract'] & 0xFF00) >> 8; - $extractVersion = $data['versionNeededToExtract'] & 0x00FF; - - $name = fread($stream, $data['fileNameLength']); - - $extra = ''; - - if ($data['extraFieldLength'] > 0) { - $extra = fread($stream, $data['extraFieldLength']); - } - - $comment = null; - - if ($data['fileCommentLength'] > 0) { - $comment = fread($stream, $data['fileCommentLength']); - } - - $entry = new ZipSourceEntry($this); - $entry->setName($name); - $entry->setCreatedOS($createdOS); - $entry->setSoftwareVersion($softwareVersion); - $entry->setVersionNeededToExtract($extractVersion); - $entry->setExtractedOS($extractOS); - $entry->setMethod($data['compressionMethod']); - $entry->setGeneralPurposeBitFlags($data['generalPurposeBitFlag']); - $entry->setDosTime($data['lastModFile']); - $entry->setCrc($data['crc']); - $entry->setCompressedSize($data['compressedSize']); - $entry->setSize($data['uncompressedSize']); - $entry->setInternalAttributes($data['internalFileAttributes']); - $entry->setExternalAttributes($data['externalFileAttributes']); - $entry->setOffset($data['offsetLocalHeader']); - $entry->setComment($comment); - $entry->setExtra($extra); - - return $entry; - } - - /** - * @param ZipEntry $entry - * - * @throws ZipException - * - * @return string - */ - public function readEntryContent(ZipEntry $entry) - { - if ($entry->isDirectory()) { - return null; - } - - if (!($entry instanceof ZipSourceEntry)) { - throw new InvalidArgumentException('entry must be ' . ZipSourceEntry::class); - } - $isEncrypted = $entry->isEncrypted(); - - if ($isEncrypted && $entry->getPassword() === null) { - throw new ZipException('Can not password from entry ' . $entry->getName()); - } - - $startPos = $pos = $entry->getOffset(); - - fseek($this->in, $startPos); - - // local file header signature 4 bytes (0x04034b50) - if (unpack('V', fread($this->in, 4))[1] !== ZipEntry::LOCAL_FILE_HEADER_SIG) { - throw new ZipException($entry->getName() . ' (expected Local File Header)'); - } - fseek($this->in, $pos + ZipEntry::LOCAL_FILE_HEADER_FILE_NAME_LENGTH_POS); - // file name length 2 bytes - // extra field length 2 bytes - $data = unpack('vfileLength/vextraLength', fread($this->in, 4)); - $pos += ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $data['fileLength'] + $data['extraLength']; - - if ($entry->getCrc() === ZipEntry::UNKNOWN) { - throw new ZipException(sprintf('Missing crc for entry %s', $entry->getName())); - } - - $method = $entry->getMethod(); - - fseek($this->in, $pos); - - // Get raw entry content - $compressedSize = $entry->getCompressedSize(); - $content = ''; - - if ($compressedSize > 0) { - $offset = 0; - - while ($offset < $compressedSize) { - $read = min(8192 /* chunk size */, $compressedSize - $offset); - $content .= fread($this->in, $read); - $offset += $read; - } - } - - $skipCheckCrc = false; - - if ($isEncrypted) { - if ($method === ZipEntry::METHOD_WINZIP_AES) { - // Strong Encryption Specification - WinZip AES - $winZipAesEngine = new WinZipAesEngine($entry); - $content = $winZipAesEngine->decrypt($content); - /** - * @var WinZipAesEntryExtraField $field - */ - $field = $entry->getExtraFieldsCollection()->get(WinZipAesEntryExtraField::getHeaderId()); - $method = $field->getMethod(); - $entry->setEncryptionMethod($field->getEncryptionMethod()); - $skipCheckCrc = true; - } else { - // Traditional PKWARE Decryption - $zipCryptoEngine = new TraditionalPkwareEncryptionEngine($entry); - $content = $zipCryptoEngine->decrypt($content); - $entry->setEncryptionMethod(ZipFile::ENCRYPTION_METHOD_TRADITIONAL); - } - - if (!$skipCheckCrc) { - // Check CRC32 in the Local File Header or Data Descriptor. - $localCrc = null; - - if ($entry->getGeneralPurposeBitFlag(ZipEntry::GPBF_DATA_DESCRIPTOR)) { - // The CRC32 is in the Data Descriptor after the compressed size. - // Note the Data Descriptor's Signature is optional: - // All newer apps should write it (and so does TrueVFS), - // but older apps might not. - fseek($this->in, $pos + $compressedSize); - $localCrc = unpack('V', fread($this->in, 4))[1]; - - if ($localCrc === ZipEntry::DATA_DESCRIPTOR_SIG) { - $localCrc = unpack('V', fread($this->in, 4))[1]; - } - } else { - fseek($this->in, $startPos + 14); - // The CRC32 in the Local File Header. - $localCrc = fread($this->in, 4)[1]; - } - - if (\PHP_INT_SIZE === 4) { - if (sprintf('%u', $entry->getCrc()) === sprintf('%u', $localCrc)) { - throw new Crc32Exception($entry->getName(), $entry->getCrc(), $localCrc); - } - } elseif ($localCrc !== $entry->getCrc()) { - throw new Crc32Exception($entry->getName(), $entry->getCrc(), $localCrc); - } - } - } - - switch ($method) { - case ZipFile::METHOD_STORED: - break; - - case ZipFile::METHOD_DEFLATED: - /** @noinspection PhpUsageOfSilenceOperatorInspection */ - $content = @gzinflate($content); - break; - - case ZipFile::METHOD_BZIP2: - if (!\extension_loaded('bz2')) { - throw new ZipException('Extension bzip2 not install'); - } - /** @noinspection PhpComposerExtensionStubsInspection */ - $content = bzdecompress($content); - - if (\is_int($content)) { // decompress error - $content = false; - } - break; - default: - throw new ZipUnsupportMethodException( - $entry->getName() . - ' (compression method ' . $method . ' is not supported)' - ); - } - - if ($content === false) { - if ($isEncrypted) { - throw new ZipAuthenticationException( - sprintf( - 'Invalid password for zip entry "%s"', - $entry->getName() - ) - ); - } - - throw new ZipException( - sprintf( - 'Failed to get the contents of the zip entry "%s"', - $entry->getName() - ) - ); - } - - if (!$skipCheckCrc) { - $localCrc = crc32($content); - - if (sprintf('%u', $entry->getCrc()) !== sprintf('%u', $localCrc)) { - if ($isEncrypted) { - throw new ZipAuthenticationException( - sprintf( - 'Invalid password for zip entry "%s"', - $entry->getName() - ) - ); - } - - throw new Crc32Exception($entry->getName(), $entry->getCrc(), $localCrc); - } - } - - return $content; - } - - /** - * @return resource - */ - public function getStream() - { - return $this->in; - } - - /** - * Copy the input stream of the LOC entry zip and the data into - * the output stream and zip the alignment if necessary. - * - * @param ZipEntry $entry - * @param ZipOutputStreamInterface $out - * - * @throws ZipException - */ - public function copyEntry(ZipEntry $entry, ZipOutputStreamInterface $out) - { - $pos = $entry->getOffset(); - - if ($pos === ZipEntry::UNKNOWN) { - throw new ZipException(sprintf('Missing local header offset for entry %s', $entry->getName())); - } - - $nameLength = \strlen($entry->getName()); - - fseek($this->in, $pos + ZipEntry::LOCAL_FILE_HEADER_MIN_LEN - 2, \SEEK_SET); - $sourceExtraLength = $destExtraLength = unpack('v', fread($this->in, 2))[1]; - - if ($sourceExtraLength > 0) { - // read Local File Header extra fields - fseek($this->in, $pos + ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $nameLength, \SEEK_SET); - $extra = ''; - $offset = 0; - - while ($offset < $sourceExtraLength) { - $read = min(8192 /* chunk size */, $sourceExtraLength - $offset); - $extra .= fread($this->in, $read); - $offset += $read; - } - $extraFieldsCollection = ExtraFieldsFactory::createExtraFieldCollections($extra, $entry); - - if (isset($extraFieldsCollection[ApkAlignmentExtraField::getHeaderId()]) && $this->zipModel->isZipAlign()) { - unset($extraFieldsCollection[ApkAlignmentExtraField::getHeaderId()]); - $destExtraLength = \strlen(ExtraFieldsFactory::createSerializedData($extraFieldsCollection)); - } - } else { - $extraFieldsCollection = new ExtraFieldsCollection(); - } - - $dataAlignmentMultiple = $this->zipModel->getZipAlign(); - $copyInToOutLength = $entry->getCompressedSize(); - - fseek($this->in, $pos, \SEEK_SET); - - if ( - $this->zipModel->isZipAlign() && - !$entry->isEncrypted() && - $entry->getMethod() === ZipFile::METHOD_STORED - ) { - if (StringUtil::endsWith($entry->getName(), '.so')) { - $dataAlignmentMultiple = ApkAlignmentExtraField::ANDROID_COMMON_PAGE_ALIGNMENT_BYTES; - } - - $dataMinStartOffset = - ftell($out->getStream()) + - ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + - $destExtraLength + - $nameLength + - ApkAlignmentExtraField::ALIGNMENT_ZIP_EXTRA_MIN_SIZE_BYTES; - $padding = - ($dataAlignmentMultiple - ($dataMinStartOffset % $dataAlignmentMultiple)) - % $dataAlignmentMultiple; - - $alignExtra = new ApkAlignmentExtraField(); - $alignExtra->setMultiple($dataAlignmentMultiple); - $alignExtra->setPadding($padding); - $extraFieldsCollection->add($alignExtra); - - $extra = ExtraFieldsFactory::createSerializedData($extraFieldsCollection); - - // copy Local File Header without extra field length - // from input stream to output stream - stream_copy_to_stream($this->in, $out->getStream(), ZipEntry::LOCAL_FILE_HEADER_MIN_LEN - 2); - // write new extra field length (2 bytes) to output stream - fwrite($out->getStream(), pack('v', \strlen($extra))); - // skip 2 bytes to input stream - fseek($this->in, 2, \SEEK_CUR); - // copy name from input stream to output stream - stream_copy_to_stream($this->in, $out->getStream(), $nameLength); - // write extra field to output stream - fwrite($out->getStream(), $extra); - // skip source extraLength from input stream - fseek($this->in, $sourceExtraLength, \SEEK_CUR); - } else { - $copyInToOutLength += ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $sourceExtraLength + $nameLength; - } - - if ($entry->getGeneralPurposeBitFlag(ZipEntry::GPBF_DATA_DESCRIPTOR)) { -// crc-32 4 bytes -// compressed size 4 bytes -// uncompressed size 4 bytes - $copyInToOutLength += 12; - - if ($entry->isZip64ExtensionsRequired()) { -// compressed size +4 bytes -// uncompressed size +4 bytes - $copyInToOutLength += 8; - } - } - // copy loc, data, data descriptor from input to output stream - stream_copy_to_stream($this->in, $out->getStream(), $copyInToOutLength); - } - - /** - * @param ZipEntry $entry - * @param ZipOutputStreamInterface $out - */ - public function copyEntryData(ZipEntry $entry, ZipOutputStreamInterface $out) - { - $offset = $entry->getOffset(); - $nameLength = \strlen($entry->getName()); - - fseek($this->in, $offset + ZipEntry::LOCAL_FILE_HEADER_MIN_LEN - 2, \SEEK_SET); - $extraLength = unpack('v', fread($this->in, 2))[1]; - - fseek($this->in, $offset + ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $nameLength + $extraLength, \SEEK_SET); - // copy raw data from input stream to output stream - stream_copy_to_stream($this->in, $out->getStream(), $entry->getCompressedSize()); - } - - public function __destruct() - { - $this->close(); - } - - public function close() - { - if ($this->in !== null) { - fclose($this->in); - $this->in = null; - } - } -} diff --git a/src/PhpZip/Stream/ZipInputStreamInterface.php b/src/PhpZip/Stream/ZipInputStreamInterface.php deleted file mode 100644 index e4f2c9c..0000000 --- a/src/PhpZip/Stream/ZipInputStreamInterface.php +++ /dev/null @@ -1,63 +0,0 @@ -out = $out; - $this->zipModel = $zipModel; - } - - /** - * @throws ZipException - */ - public function writeZip() - { - $entries = $this->zipModel->getEntries(); - $outPosEntries = []; - - foreach ($entries as $entry) { - $outPosEntries[] = new OutputOffsetEntry(ftell($this->out), $entry); - $this->writeEntry($entry); - } - $centralDirectoryOffset = ftell($this->out); - - foreach ($outPosEntries as $outputEntry) { - $this->writeCentralDirectoryHeader($outputEntry); - } - $this->writeEndOfCentralDirectoryRecord($centralDirectoryOffset); - } - - /** - * @param ZipEntry $entry - * - * @throws ZipException - */ - public function writeEntry(ZipEntry $entry) - { - if ($entry instanceof ZipSourceEntry) { - $entry->getInputStream()->copyEntry($entry, $this); - - return; - } - - $entryContent = $this->entryCommitChangesAndReturnContent($entry); - - $offset = ftell($this->out); - $compressedSize = $entry->getCompressedSize(); - - $extra = $entry->getExtra(); - - $nameLength = \strlen($entry->getName()); - $extraLength = \strlen($extra); - - // zip align - if ( - $this->zipModel->isZipAlign() && - !$entry->isEncrypted() && - $entry->getMethod() === ZipFile::METHOD_STORED - ) { - $dataAlignmentMultiple = $this->zipModel->getZipAlign(); - - if (StringUtil::endsWith($entry->getName(), '.so')) { - $dataAlignmentMultiple = ApkAlignmentExtraField::ANDROID_COMMON_PAGE_ALIGNMENT_BYTES; - } - $dataMinStartOffset = - $offset + - ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + - $extraLength + - $nameLength + - ApkAlignmentExtraField::ALIGNMENT_ZIP_EXTRA_MIN_SIZE_BYTES; - - $padding = - ($dataAlignmentMultiple - ($dataMinStartOffset % $dataAlignmentMultiple)) - % $dataAlignmentMultiple; - - $alignExtra = new ApkAlignmentExtraField(); - $alignExtra->setMultiple($dataAlignmentMultiple); - $alignExtra->setPadding($padding); - - $extraFieldsCollection = clone $entry->getExtraFieldsCollection(); - $extraFieldsCollection->add($alignExtra); - - $extra = ExtraFieldsFactory::createSerializedData($extraFieldsCollection); - $extraLength = \strlen($extra); - } - - $size = $nameLength + $extraLength; - - if ($size > 0xffff) { - throw new ZipException( - $entry->getName() . ' (the total size of ' . $size . - ' bytes for the name, extra fields and comment ' . - 'exceeds the maximum size of ' . 0xffff . ' bytes)' - ); - } - - $dd = $entry->isDataDescriptorRequired(); - fwrite( - $this->out, - pack( - 'VvvvVVVVvv', - // local file header signature 4 bytes (0x04034b50) - ZipEntry::LOCAL_FILE_HEADER_SIG, - // version needed to extract 2 bytes - ($entry->getExtractedOS() << 8) | $entry->getVersionNeededToExtract(), - // general purpose bit flag 2 bytes - $entry->getGeneralPurposeBitFlags(), - // compression method 2 bytes - $entry->getMethod(), - // last mod file time 2 bytes - // last mod file date 2 bytes - $entry->getDosTime(), - // crc-32 4 bytes - $dd ? 0 : $entry->getCrc(), - // compressed size 4 bytes - $dd ? 0 : $entry->getCompressedSize(), - // uncompressed size 4 bytes - $dd ? 0 : $entry->getSize(), - // file name length 2 bytes - $nameLength, - // extra field length 2 bytes - $extraLength - ) - ); - - if ($nameLength > 0) { - fwrite($this->out, $entry->getName()); - } - - if ($extraLength > 0) { - fwrite($this->out, $extra); - } - - if ($entry instanceof ZipChangesEntry && !$entry->isChangedContent()) { - $entry->getSourceEntry()->getInputStream()->copyEntryData($entry->getSourceEntry(), $this); - } elseif ($entryContent !== null) { - fwrite($this->out, $entryContent); - } - - if ($entry->getCrc() === ZipEntry::UNKNOWN) { - throw new ZipException(sprintf('No crc for entry %s', $entry->getName())); - } - - if ($entry->getSize() === ZipEntry::UNKNOWN) { - throw new ZipException(sprintf('No uncompressed size for entry %s', $entry->getName())); - } - - if ($entry->getCompressedSize() === ZipEntry::UNKNOWN) { - throw new ZipException(sprintf('No compressed size for entry %s', $entry->getName())); - } - - if ($entry->getGeneralPurposeBitFlag(ZipEntry::GPBF_DATA_DESCRIPTOR)) { - // data descriptor signature 4 bytes (0x08074b50) - // crc-32 4 bytes - fwrite($this->out, pack('VV', ZipEntry::DATA_DESCRIPTOR_SIG, $entry->getCrc())); - // compressed size 4 or 8 bytes - // uncompressed size 4 or 8 bytes - if ($entry->isZip64ExtensionsRequired()) { - fwrite($this->out, PackUtil::packLongLE($compressedSize)); - fwrite($this->out, PackUtil::packLongLE($entry->getSize())); - } else { - fwrite($this->out, pack('VV', $entry->getCompressedSize(), $entry->getSize())); - } - } elseif ($compressedSize !== $entry->getCompressedSize()) { - throw new ZipException( - $entry->getName() . ' (expected compressed entry size of ' - . $entry->getCompressedSize() . ' bytes, ' . - 'but is actually ' . $compressedSize . ' bytes)' - ); - } - } - - /** - * @param ZipEntry $entry - * - * @throws ZipException - * - * @return string|null - */ - protected function entryCommitChangesAndReturnContent(ZipEntry $entry) - { - if ($entry->getCreatedOS() === ZipEntry::UNKNOWN) { - $entry->setCreatedOS(ZipEntry::PLATFORM_UNIX); - } - - if ($entry->getSoftwareVersion() === ZipEntry::UNKNOWN) { - $entry->setSoftwareVersion(63); - } - - if ($entry->getExtractedOS() === ZipEntry::UNKNOWN) { - $entry->setExtractedOS(ZipEntry::PLATFORM_UNIX); - } - - if ($entry->getTime() === ZipEntry::UNKNOWN) { - $entry->setTime(time()); - } - $method = $entry->getMethod(); - - $encrypted = $entry->isEncrypted(); - // See appendix D of PKWARE's ZIP File Format Specification. - $utf8 = true; - - if ($encrypted && $entry->getPassword() === null) { - throw new ZipException(sprintf('Password not set for entry %s', $entry->getName())); - } - - // Compose General Purpose Bit Flag. - $general = ($encrypted ? ZipEntry::GPBF_ENCRYPTED : 0) - | ($entry->isDataDescriptorRequired() ? ZipEntry::GPBF_DATA_DESCRIPTOR : 0) - | ($utf8 ? ZipEntry::GPBF_UTF8 : 0); - - $entryContent = null; - $extraFieldsCollection = $entry->getExtraFieldsCollection(); - - if (!($entry instanceof ZipChangesEntry && !$entry->isChangedContent())) { - $entryContent = $entry->getEntryContent(); - - if ($entryContent !== null) { - $entry->setSize(\strlen($entryContent)); - $entry->setCrc(crc32($entryContent)); - - if ($encrypted && $method === ZipEntry::METHOD_WINZIP_AES) { - /** - * @var WinZipAesEntryExtraField $field - */ - $field = $extraFieldsCollection->get(WinZipAesEntryExtraField::getHeaderId()); - - if ($field !== null) { - $method = $field->getMethod(); - } - } - - switch ($method) { - case ZipFile::METHOD_STORED: - break; - - case ZipFile::METHOD_DEFLATED: - $entryContent = gzdeflate($entryContent, $entry->getCompressionLevel()); - break; - - case ZipFile::METHOD_BZIP2: - $compressionLevel = $entry->getCompressionLevel() === ZipFile::LEVEL_DEFAULT_COMPRESSION ? - ZipEntry::LEVEL_DEFAULT_BZIP2_COMPRESSION : - $entry->getCompressionLevel(); - /** @noinspection PhpComposerExtensionStubsInspection */ - $entryContent = bzcompress($entryContent, $compressionLevel); - - if (\is_int($entryContent)) { - throw new ZipException('Error bzip2 compress. Error code: ' . $entryContent); - } - break; - - case ZipEntry::UNKNOWN: - $entryContent = $this->determineBestCompressionMethod($entry, $entryContent); - $method = $entry->getMethod(); - break; - - default: - throw new ZipException($entry->getName() . ' (unsupported compression method ' . $method . ')'); - } - - if ($method === ZipFile::METHOD_DEFLATED) { - $bit1 = false; - $bit2 = false; - switch ($entry->getCompressionLevel()) { - case ZipFile::LEVEL_BEST_COMPRESSION: - $bit1 = true; - break; - - case ZipFile::LEVEL_FAST: - $bit2 = true; - break; - - case ZipFile::LEVEL_SUPER_FAST: - $bit1 = true; - $bit2 = true; - break; - } - - $general |= ($bit1 ? ZipEntry::GPBF_COMPRESSION_FLAG1 : 0); - $general |= ($bit2 ? ZipEntry::GPBF_COMPRESSION_FLAG2 : 0); - } - - if ($encrypted) { - if (\in_array( - $entry->getEncryptionMethod(), - [ - ZipFile::ENCRYPTION_METHOD_WINZIP_AES_128, - ZipFile::ENCRYPTION_METHOD_WINZIP_AES_192, - ZipFile::ENCRYPTION_METHOD_WINZIP_AES_256, - ], - true - )) { - $keyStrength = WinZipAesEntryExtraField::getKeyStrangeFromEncryptionMethod( - $entry->getEncryptionMethod() - ); // size bits - $field = ExtraFieldsFactory::createWinZipAesEntryExtra(); - $field->setKeyStrength($keyStrength); - $field->setMethod($method); - $size = $entry->getSize(); - - if ($size >= 20 && $method !== ZipFile::METHOD_BZIP2) { - $field->setVendorVersion(WinZipAesEntryExtraField::VV_AE_1); - } else { - $field->setVendorVersion(WinZipAesEntryExtraField::VV_AE_2); - $entry->setCrc(0); - } - $extraFieldsCollection->add($field); - $entry->setMethod(ZipEntry::METHOD_WINZIP_AES); - - $winZipAesEngine = new WinZipAesEngine($entry); - $entryContent = $winZipAesEngine->encrypt($entryContent); - } elseif ($entry->getEncryptionMethod() === ZipFile::ENCRYPTION_METHOD_TRADITIONAL) { - $zipCryptoEngine = new TraditionalPkwareEncryptionEngine($entry); - $entryContent = $zipCryptoEngine->encrypt($entryContent); - } - } - - $compressedSize = \strlen($entryContent); - $entry->setCompressedSize($compressedSize); - } - } - - // Commit changes. - $entry->setGeneralPurposeBitFlags($general); - - if ($entry->isZip64ExtensionsRequired()) { - $extraFieldsCollection->add(ExtraFieldsFactory::createZip64Extra($entry)); - } elseif ($extraFieldsCollection->has(Zip64ExtraField::getHeaderId())) { - $extraFieldsCollection->remove(Zip64ExtraField::getHeaderId()); - } - - return $entryContent; - } - - /** - * @param ZipEntry $entry - * @param string $content - * - * @throws ZipException - * - * @return string - */ - protected function determineBestCompressionMethod(ZipEntry $entry, $content) - { - if ($content !== null) { - $entryContent = gzdeflate($content, $entry->getCompressionLevel()); - - if (\strlen($entryContent) < \strlen($content)) { - $entry->setMethod(ZipFile::METHOD_DEFLATED); - - return $entryContent; - } - $entry->setMethod(ZipFile::METHOD_STORED); - } - - return $content; - } - - /** - * Writes a Central File Header record. - * - * @param OutputOffsetEntry $outEntry - */ - protected function writeCentralDirectoryHeader(OutputOffsetEntry $outEntry) - { - $entry = $outEntry->getEntry(); - $compressedSize = $entry->getCompressedSize(); - $size = $entry->getSize(); - // This test MUST NOT include the CRC-32 because VV_AE_2 sets it to - // UNKNOWN! - if (($compressedSize | $size) === ZipEntry::UNKNOWN) { - throw new RuntimeException('invalid entry'); - } - $extra = $entry->getExtra(); - $extraSize = \strlen($extra); - - $commentLength = \strlen($entry->getComment()); - fwrite( - $this->out, - pack( - 'VvvvvVVVVvvvvvVV', - // central file header signature 4 bytes (0x02014b50) - self::CENTRAL_FILE_HEADER_SIG, - // version made by 2 bytes - ($entry->getCreatedOS() << 8) | $entry->getSoftwareVersion(), - // version needed to extract 2 bytes - ($entry->getExtractedOS() << 8) | $entry->getVersionNeededToExtract(), - // general purpose bit flag 2 bytes - $entry->getGeneralPurposeBitFlags(), - // compression method 2 bytes - $entry->getMethod(), - // last mod file datetime 4 bytes - $entry->getDosTime(), - // crc-32 4 bytes - $entry->getCrc(), - // compressed size 4 bytes - $entry->getCompressedSize(), - // uncompressed size 4 bytes - $entry->getSize(), - // file name length 2 bytes - \strlen($entry->getName()), - // extra field length 2 bytes - $extraSize, - // 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 - $outEntry->getOffset() - ) - ); - // file name (variable size) - fwrite($this->out, $entry->getName()); - - if ($extraSize > 0) { - // extra field (variable size) - fwrite($this->out, $extra); - } - - if ($commentLength > 0) { - // file comment (variable size) - fwrite($this->out, $entry->getComment()); - } - } - - /** - * @param int $centralDirectoryOffset - */ - protected function writeEndOfCentralDirectoryRecord($centralDirectoryOffset) - { - $cdEntriesCount = \count($this->zipModel); - - $position = ftell($this->out); - $centralDirectorySize = $position - $centralDirectoryOffset; - - $cdEntriesZip64 = $cdEntriesCount > 0xFFFF; - $cdSizeZip64 = $centralDirectorySize > 0xFFFFFFFF; - $cdOffsetZip64 = $centralDirectoryOffset > 0xFFFFFFFF; - - $zip64Required = $cdEntriesZip64 || $cdSizeZip64 || $cdOffsetZip64; - - if ($zip64Required) { - $zip64EndOfCentralDirectoryOffset = ftell($this->out); - - // find max software version, version needed to extract and most common platform - list($softwareVersion, $versionNeededToExtract) = array_reduce( - $this->zipModel->getEntries(), - static function (array $carry, ZipEntry $entry) { - $carry[0] = max($carry[0], $entry->getSoftwareVersion() & 0xFF); - $carry[1] = max($carry[1], $entry->getVersionNeededToExtract() & 0xFF); - - return $carry; - }, - [10 /* simple file min ver */, 45 /* zip64 ext min ver */] - ); - - $createdOS = $extractedOS = ZipEntry::PLATFORM_FAT; - $versionMadeBy = ($createdOS << 8) | max($softwareVersion, 45 /* zip64 ext min ver */); - $versionExtractedBy = ($extractedOS << 8) | max($versionNeededToExtract, 45 /* zip64 ext min ver */); - - // signature 4 bytes (0x06064b50) - fwrite($this->out, pack('V', EndOfCentralDirectory::ZIP64_END_OF_CD_RECORD_SIG)); - // size of zip64 end of central - // directory record 8 bytes - fwrite($this->out, PackUtil::packLongLE(44)); - fwrite( - $this->out, - 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 - ) - ); - // total number of entries in the - // central directory on this disk 8 bytes - fwrite($this->out, PackUtil::packLongLE($cdEntriesCount)); - // total number of entries in the - // central directory 8 bytes - fwrite($this->out, PackUtil::packLongLE($cdEntriesCount)); - // size of the central directory 8 bytes - fwrite($this->out, PackUtil::packLongLE($centralDirectorySize)); - // offset of start of central - // directory with respect to - // the starting disk number 8 bytes - fwrite($this->out, PackUtil::packLongLE($centralDirectoryOffset)); - - // write zip64 end of central directory locator - fwrite( - $this->out, - pack( - 'VV', - // zip64 end of central dir locator - // signature 4 bytes (0x07064b50) - EndOfCentralDirectory::ZIP64_END_OF_CD_LOCATOR_SIG, - // 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 - fwrite($this->out, PackUtil::packLongLE($zip64EndOfCentralDirectoryOffset)); - // total number of disks 4 bytes - fwrite($this->out, pack('V', 1)); - } - - $comment = $this->zipModel->getArchiveComment(); - $commentLength = $comment !== null ? \strlen($comment) : 0; - - fwrite( - $this->out, - pack( - 'VvvvvVVv', - // end of central dir signature 4 bytes (0x06054b50) - EndOfCentralDirectory::END_OF_CD_SIG, - // 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 ? 0xFFFFFFFF : $centralDirectorySize, - // offset of start of central - // directory with respect to - // the starting disk number 4 bytes - $cdOffsetZip64 ? 0xFFFFFFFF : $centralDirectoryOffset, - // .ZIP file comment length 2 bytes - $commentLength - ) - ); - - if ($commentLength > 0) { - // .ZIP file comment (variable size) - fwrite($this->out, $comment); - } - } - - /** - * @return resource - */ - public function getStream() - { - return $this->out; - } -} diff --git a/src/PhpZip/Stream/ZipOutputStreamInterface.php b/src/PhpZip/Stream/ZipOutputStreamInterface.php deleted file mode 100644 index dc50801..0000000 --- a/src/PhpZip/Stream/ZipOutputStreamInterface.php +++ /dev/null @@ -1,29 +0,0 @@ - 3 && ctype_alpha($file[0]) + && $file[1] === ':' + && strspn($file, '/\\', 2, 1) + ) + || parse_url($file, \PHP_URL_SCHEME) !== null; + } + + /** + * @param string $linkPath + * @param string $target + * + * @return bool + */ + public static function symlink($target, $linkPath) + { + if (\DIRECTORY_SEPARATOR === '\\') { + $linkPath = str_replace('/', '\\', $linkPath); + $target = str_replace('/', '\\', $target); + $abs = null; + + if (!self::isAbsolutePath($target)) { + $abs = realpath(\dirname($linkPath) . \DIRECTORY_SEPARATOR . $target); + + if (\is_string($abs)) { + $target = $abs; + } + } + } + + if (!symlink($target, $linkPath)) { + if (\DIRECTORY_SEPARATOR === '\\' && is_file($target)) { + return copy($target, $linkPath); + } + + return false; + } + + return true; + } + + /** + * @param string $file + * + * @return bool + */ + public static function isBadCompressionFile($file) + { + $badCompressFileExt = [ + 'dic', + 'dng', + 'f4v', + 'flipchart', + 'h264', + 'lrf', + 'mobi', + 'mts', + 'nef', + 'pspimage', + ]; + + $ext = strtolower(pathinfo($file, \PATHINFO_EXTENSION)); + + if (\in_array($ext, $badCompressFileExt, true)) { + return true; + } + + $mimeType = self::getMimeTypeFromFile($file); + + return self::isBadCompressionMimeType($mimeType); + } + + /** + * @param string $mimeType + * + * @return bool + */ + public static function isBadCompressionMimeType($mimeType) + { + static $badDeflateCompMimeTypes = [ + 'application/epub+zip', + 'application/gzip', + 'application/vnd.debian.binary-package', + 'application/vnd.oasis.opendocument.graphics', + 'application/vnd.oasis.opendocument.presentation', + 'application/vnd.oasis.opendocument.text', + 'application/vnd.oasis.opendocument.text-master', + 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', + 'application/vnd.rn-realmedia', + 'application/x-7z-compressed', + 'application/x-arj', + 'application/x-bzip2', + 'application/x-hwp', + 'application/x-lzip', + 'application/x-lzma', + 'application/x-ms-reader', + 'application/x-rar', + 'application/x-rpm', + 'application/x-stuffit', + 'application/x-tar', + 'application/x-xz', + 'application/zip', + 'application/zlib', + 'audio/flac', + 'audio/mpeg', + 'audio/ogg', + 'audio/vnd.dolby.dd-raw', + 'audio/webm', + 'audio/x-ape', + 'audio/x-hx-aac-adts', + 'audio/x-m4a', + 'audio/x-m4a', + 'audio/x-wav', + 'image/gif', + 'image/heic', + 'image/jp2', + 'image/jpeg', + 'image/png', + 'image/vnd.djvu', + 'image/webp', + 'image/x-canon-cr2', + 'video/ogg', + 'video/webm', + 'video/x-matroska', + 'video/x-ms-asf', + 'x-epoc/x-sisx-app', + ]; + + if (\in_array($mimeType, $badDeflateCompMimeTypes, true)) { + return true; + } + + return false; + } + + /** + * @param string $file + * + * @return string + * + * @noinspection PhpComposerExtensionStubsInspection + */ + public static function getMimeTypeFromFile($file) + { + if (\function_exists('mime_content_type')) { + return mime_content_type($file); + } + + return 'application/octet-stream'; + } + + /** + * @param string $contents + * + * @return string + * @noinspection PhpComposerExtensionStubsInspection + */ + public static function getMimeTypeFromString($contents) + { + $contents = (string) $contents; + $finfo = new \finfo(\FILEINFO_MIME); + $mimeType = $finfo->buffer($contents); + + if ($mimeType === false) { + $mimeType = 'application/octet-stream'; + } + + return explode(';', $mimeType)[0]; + } } diff --git a/src/PhpZip/Util/Iterator/IgnoreFilesFilterIterator.php b/src/Util/Iterator/IgnoreFilesFilterIterator.php similarity index 100% rename from src/PhpZip/Util/Iterator/IgnoreFilesFilterIterator.php rename to src/Util/Iterator/IgnoreFilesFilterIterator.php diff --git a/src/PhpZip/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php b/src/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php similarity index 96% rename from src/PhpZip/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php rename to src/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php index 580805b..8935127 100644 --- a/src/PhpZip/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php +++ b/src/Util/Iterator/IgnoreFilesRecursiveFilterIterator.php @@ -66,7 +66,6 @@ class IgnoreFilesRecursiveFilterIterator extends \RecursiveFilterIterator /** * @return IgnoreFilesRecursiveFilterIterator - * @noinspection PhpMissingParentCallCommonInspection */ public function getChildren() { diff --git a/src/PhpZip/Util/PackUtil.php b/src/Util/PackUtil.php similarity index 84% rename from src/PhpZip/Util/PackUtil.php rename to src/Util/PackUtil.php index bd50ee2..653fab7 100644 --- a/src/PhpZip/Util/PackUtil.php +++ b/src/Util/PackUtil.php @@ -13,13 +13,13 @@ namespace PhpZip\Util; final class PackUtil { /** - * @param int|string $longValue + * @param int $longValue * * @return string */ public static function packLongLE($longValue) { - if (\PHP_INT_SIZE === 8 && \PHP_VERSION_ID >= 506030) { + if (\PHP_VERSION_ID >= 506030) { return pack('P', $longValue); } @@ -33,13 +33,13 @@ final class PackUtil } /** - * @param string|int $value + * @param string $value * * @return int */ public static function unpackLongLE($value) { - if (\PHP_INT_SIZE === 8 && \PHP_VERSION_ID >= 506030) { + if (\PHP_VERSION_ID >= 506030) { return unpack('P', $value)[1]; } $unpack = unpack('Va/Vb', $value); diff --git a/src/PhpZip/Util/StringUtil.php b/src/Util/StringUtil.php similarity index 65% rename from src/PhpZip/Util/StringUtil.php rename to src/Util/StringUtil.php index 8b067db..c40a8ad 100644 --- a/src/PhpZip/Util/StringUtil.php +++ b/src/Util/StringUtil.php @@ -31,4 +31,24 @@ final class StringUtil return $needle === '' || (($temp = \strlen($haystack) - \strlen($needle)) >= 0 && strpos($haystack, $needle, $temp) !== false); } + + /** + * @param string $string + * + * @return bool + */ + public static function isBinary($string) + { + return strpos($string, "\0") !== false; + } + + /** + * @param string $name + * + * @return bool + */ + public static function isASCII($name) + { + return preg_match('~[^\x20-\x7e]~', (string) $name) === 0; + } } diff --git a/src/PhpZip/ZipFile.php b/src/ZipFile.php similarity index 56% rename from src/PhpZip/ZipFile.php rename to src/ZipFile.php index 8b0a803..5b4f656 100644 --- a/src/PhpZip/ZipFile.php +++ b/src/ZipFile.php @@ -1,33 +1,39 @@ 'application/zip', 'apk' => 'application/vnd.android.package-archive', 'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', - 'jar' => 'application/java-archive', 'epub' => 'application/epub+zip', + 'jar' => 'application/java-archive', + 'odt' => 'application/vnd.oasis.opendocument.text', + 'pptx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template', + 'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', + 'xpi' => 'application/x-xpinstall', ]; - /** @var ZipInputStreamInterface input seekable input stream */ - protected $inputStream; + /** @var ZipContainer */ + protected $zipContainer; - /** @var ZipModel */ - protected $zipModel; + /** @var ZipReader|null */ + private $reader; /** * ZipFile constructor. */ public function __construct() { - $this->zipModel = new ZipModel(); + $this->zipContainer = new ZipContainer(); + } + + /** + * @param resource $inputStream + * @param array $options + * + * @return ZipReader + */ + protected function createZipReader($inputStream, array $options = []) + { + return new ZipReader($inputStream, $options); + } + + /** + * @return ZipWriter + */ + protected function createZipWriter() + { + return new ZipWriter($this->zipContainer); } /** * Open zip archive from file. * * @param string $filename + * @param array $options * * @throws ZipException if can't open file * * @return ZipFile */ - public function openFile($filename) + public function openFile($filename, array $options = []) { if (!file_exists($filename)) { throw new ZipException("File {$filename} does not exist."); @@ -94,21 +108,21 @@ class ZipFile implements ZipFileInterface if (!($handle = @fopen($filename, 'rb'))) { throw new ZipException("File {$filename} can't open."); } - $this->openFromStream($handle); - return $this; + return $this->openFromStream($handle, $options); } /** * Open zip archive from raw string data. * * @param string $data + * @param array $options * * @throws ZipException if can't open temp stream * * @return ZipFile */ - public function openFromString($data) + public function openFromString($data, array $options = []) { if ($data === null || $data === '') { throw new InvalidArgumentException('Empty string passed'); @@ -119,41 +133,24 @@ class ZipFile implements ZipFileInterface } fwrite($handle, $data); rewind($handle); - $this->openFromStream($handle); - return $this; + return $this->openFromStream($handle, $options); } /** * Open zip archive from stream resource. * * @param resource $handle + * @param array $options * * @throws ZipException * * @return ZipFile */ - public function openFromStream($handle) + public function openFromStream($handle, array $options = []) { - if (!\is_resource($handle)) { - throw new InvalidArgumentException('Invalid stream resource.'); - } - $type = get_resource_type($handle); - - if ($type !== 'stream') { - throw new InvalidArgumentException("Invalid resource type - {$type}."); - } - $meta = stream_get_meta_data($handle); - - if ($meta['stream_type'] === 'dir') { - throw new InvalidArgumentException("Invalid stream type - {$meta['stream_type']}."); - } - - if (!$meta['seekable']) { - throw new InvalidArgumentException('Resource cannot seekable stream.'); - } - $this->inputStream = new ZipInputStream($handle); - $this->zipModel = $this->inputStream->readZip(); + $this->reader = $this->createZipReader($handle, $options); + $this->zipContainer = new ZipContainer($this->reader->read()); return $this; } @@ -163,7 +160,8 @@ class ZipFile implements ZipFileInterface */ public function getListFiles() { - return array_map('strval', array_keys($this->zipModel->getEntries())); + // strval is needed to cast entry names to string type + return array_map('strval', array_keys($this->zipContainer->getEntries())); } /** @@ -171,7 +169,7 @@ class ZipFile implements ZipFileInterface */ public function count() { - return $this->zipModel->count(); + return $this->zipContainer->count(); } /** @@ -181,7 +179,7 @@ class ZipFile implements ZipFileInterface */ public function getArchiveComment() { - return $this->zipModel->getArchiveComment(); + return $this->zipContainer->getArchiveComment(); } /** @@ -193,11 +191,37 @@ class ZipFile implements ZipFileInterface */ public function setArchiveComment($comment = null) { - $this->zipModel->setArchiveComment($comment); + $this->zipContainer->setArchiveComment($comment); return $this; } + /** + * Checks if there is an entry in the archive. + * + * @param string $entryName + * + * @return bool + */ + public function hasEntry($entryName) + { + return $this->zipContainer->hasEntry($entryName); + } + + /** + * Returns ZipEntry object. + * + * @param string $entryName + * + * @throws ZipEntryNotFoundException + * + * @return ZipEntry + */ + public function getEntry($entryName) + { + return $this->zipContainer->getEntry($entryName); + } + /** * Checks that the entry in the archive is a directory. * Returns true if and only if this ZIP entry represents a directory entry @@ -211,7 +235,7 @@ class ZipFile implements ZipFileInterface */ public function isDirectory($entryName) { - return $this->zipModel->getEntry($entryName)->isDirectory(); + return $this->getEntry($entryName)->isDirectory(); } /** @@ -220,12 +244,13 @@ class ZipFile implements ZipFileInterface * @param string $entryName * * @throws ZipEntryNotFoundException + * @throws ZipException * * @return string */ public function getEntryComment($entryName) { - return $this->zipModel->getEntry($entryName)->getComment(); + return $this->getEntry($entryName)->getComment(); } /** @@ -241,7 +266,7 @@ class ZipFile implements ZipFileInterface */ public function setEntryComment($entryName, $comment = null) { - $this->zipModel->getEntryForChanges($entryName)->setComment($comment); + $this->getEntry($entryName)->setComment($comment); return $this; } @@ -252,24 +277,35 @@ class ZipFile implements ZipFileInterface * @param string $entryName * * @throws ZipException + * @throws ZipEntryNotFoundException * * @return string */ public function getEntryContents($entryName) { - return $this->zipModel->getEntry($entryName)->getEntryContent(); + $zipData = $this->zipContainer->getEntry($entryName)->getData(); + + if ($zipData === null) { + throw new ZipException(sprintf('No data for zip entry %s', $entryName)); + } + + return $zipData->getDataAsString(); } /** - * Checks if there is an entry in the archive. - * * @param string $entryName * - * @return bool + * @throws ZipException + * @throws ZipEntryNotFoundException + * + * @return resource */ - public function hasEntry($entryName) + public function getEntryStream($entryName) { - return $this->zipModel->hasEntry($entryName); + $resource = ZipEntryStreamWrapper::wrap($this->zipContainer->getEntry($entryName)); + rewind($resource); + + return $resource; } /** @@ -284,7 +320,7 @@ class ZipFile implements ZipFileInterface */ public function getEntryInfo($entryName) { - return new ZipInfo($this->zipModel->getEntry($entryName)); + return new ZipInfo($this->zipContainer->getEntry($entryName)); } /** @@ -294,7 +330,13 @@ class ZipFile implements ZipFileInterface */ public function getAllInfo() { - return array_map([$this, 'getEntryInfo'], $this->zipModel->getEntries()); + $infoMap = []; + + foreach ($this->zipContainer->getEntries() as $name => $entry) { + $infoMap[$name] = new ZipInfo($entry); + } + + return $infoMap; } /** @@ -302,37 +344,49 @@ class ZipFile implements ZipFileInterface */ public function matcher() { - return $this->zipModel->matcher(); + return $this->zipContainer->matcher(); } /** - * Extract the archive contents. + * Returns an array of zip records (ex. for modify time). + * + * @return ZipEntry[] array of raw zip entries + */ + public function getEntries() + { + return $this->zipContainer->getEntries(); + } + + /** + * Extract the archive contents (unzip). * * Extract the complete archive or the given files to the specified destination. * - * @param string $destination location where to extract the files - * @param array|string|null $entries The entries to extract. It accepts either - * a single entry name or an array of names. + * @param string $destDir location where to extract the files + * @param array|string|null $entries The entries to extract. It accepts either + * a single entry name or an array of names. * * @throws ZipException * * @return ZipFile */ - public function extractTo($destination, $entries = null) + public function extractTo($destDir, $entries = null) { - if (!file_exists($destination)) { - throw new ZipException(sprintf('Destination %s not found', $destination)); + if (!file_exists($destDir)) { + throw new ZipException(sprintf('Destination %s not found', $destDir)); } - if (!is_dir($destination)) { + if (!is_dir($destDir)) { throw new ZipException('Destination is not directory'); } - if (!is_writable($destination)) { + if (!is_writable($destDir)) { throw new ZipException('Destination is not writable directory'); } - $zipEntries = $this->zipModel->getEntries(); + $extractedEntries = []; + + $zipEntries = $this->zipContainer->getEntries(); if (!empty($entries)) { if (\is_string($entries)) { @@ -344,165 +398,375 @@ class ZipFile implements ZipFileInterface $flipEntries = array_flip($entries); $zipEntries = array_filter( $zipEntries, - static function (ZipEntry $zipEntry) use ($flipEntries) { - return isset($flipEntries[$zipEntry->getName()]); - } + /** + * @param string $entryName + * + * @return bool + */ + static function ($entryName) use ($flipEntries) { + return isset($flipEntries[$entryName]); + }, + \ARRAY_FILTER_USE_KEY ); } } - foreach ($zipEntries as $entry) { - $entryName = FilesUtil::normalizeZipPath($entry->getName()); - $file = $destination . \DIRECTORY_SEPARATOR . $entryName; + if (empty($zipEntries)) { + return $this; + } + + /** @var int[] $lastModDirs */ + $lastModDirs = []; + + krsort($zipEntries, \SORT_NATURAL); + + $symlinks = []; + $destDir = rtrim($destDir, '/\\'); + + foreach ($zipEntries as $entryName => $entry) { + $unixMode = $entry->getUnixMode(); + $entryName = FilesUtil::normalizeZipPath($entryName); + $file = $destDir . \DIRECTORY_SEPARATOR . $entryName; + + if (\DIRECTORY_SEPARATOR === '\\') { + $file = str_replace('/', '\\', $file); + } + $extractedEntries[$file] = $entry; + $modifyTimestamp = $entry->getMTime()->getTimestamp(); + $atime = $entry->getATime(); + $accessTimestamp = $atime === null ? null : $atime->getTimestamp(); + + $dir = $entry->isDirectory() ? $file : \dirname($file); + + if (!is_dir($dir)) { + $dirMode = $entry->isDirectory() ? $unixMode : 0755; + + if ($dirMode === 0) { + $dirMode = 0755; + } + + if (!mkdir($dir, $dirMode, true) && !is_dir($dir)) { + throw new \RuntimeException(sprintf('Directory "%s" was not created', $dir)); + } + chmod($dir, $dirMode); + } + + $parts = explode('/', rtrim($entryName, '/')); + $path = $destDir . \DIRECTORY_SEPARATOR; + + foreach ($parts as $part) { + if (!isset($lastModDirs[$path]) || $lastModDirs[$path] > $modifyTimestamp) { + $lastModDirs[$path] = $modifyTimestamp; + } + + $path .= $part . \DIRECTORY_SEPARATOR; + } if ($entry->isDirectory()) { - if (!is_dir($file)) { - if (!mkdir($file, 0755, true) && !is_dir($file)) { - throw new ZipException('Can not create dir ' . $file); - } - chmod($file, 0755); - touch($file, $entry->getTime()); - } + $lastModDirs[$dir] = $modifyTimestamp; continue; } - $dir = \dirname($file); - if (!is_dir($dir)) { - if (!mkdir($dir, 0755, true) && !is_dir($dir)) { - throw new ZipException('Can not create dir ' . $dir); - } - chmod($dir, 0755); - touch($dir, $entry->getTime()); + $zipData = $entry->getData(); + + if ($zipData === null) { + continue; } - if (file_put_contents($file, $entry->getEntryContent()) === false) { - throw new ZipException('Can not extract file ' . $entry->getName()); + if ($entry->isUnixSymlink()) { + $symlinks[$file] = $zipData->getDataAsString(); + + continue; + } + + /** @noinspection PhpUsageOfSilenceOperatorInspection */ + if (!($handle = @fopen($file, 'w+b'))) { + throw new ZipException( + sprintf( + 'Cannot extract zip entry %s. File %s cannot open for write.', + $entry->getName(), + $file + ) + ); + } + + try { + $zipData->copyDataToStream($handle); + } catch (ZipException $e) { + unlink($file); + + throw $e; + } finally { + fclose($handle); + } + + if ($unixMode === 0) { + $unixMode = 0644; + } + chmod($file, $unixMode); + + if ($accessTimestamp !== null) { + /** @noinspection PotentialMalwareInspection */ + touch($file, $modifyTimestamp, $accessTimestamp); + } else { + touch($file, $modifyTimestamp); } - touch($file, $entry->getTime()); } + foreach ($symlinks as $linkPath => $target) { + if (!FilesUtil::symlink($target, $linkPath)) { + unset($extractedEntries[$linkPath]); + } + } + + krsort($lastModDirs, \SORT_NATURAL); + + foreach ($lastModDirs as $dir => $lastMod) { + touch($dir, $lastMod); + } + +// ksort($extractedEntries); + return $this; } /** * Add entry from the string. * - * @param string $localName zip entry name + * @param string $entryName zip entry name * @param string $contents string contents * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. + * If null, then auto choosing method. * * @throws ZipException * * @return ZipFile - * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 */ - public function addFromString($localName, $contents, $compressionMethod = null) + public function addFromString($entryName, $contents, $compressionMethod = null) { + if ($entryName === null) { + throw new InvalidArgumentException('Entry name is null'); + } + if ($contents === null) { throw new InvalidArgumentException('Contents is null'); } - if ($localName === null) { - throw new InvalidArgumentException('Entry name is null'); - } - $localName = ltrim((string) $localName, '\\/'); + $entryName = ltrim((string) $entryName, '\\/'); - if ($localName === '') { + if ($entryName === '') { throw new InvalidArgumentException('Empty entry name'); } $contents = (string) $contents; $length = \strlen($contents); - if ($compressionMethod === null) { - if ($length >= 512) { - $compressionMethod = ZipEntry::UNKNOWN; + if ($compressionMethod === null || $compressionMethod === ZipEntry::UNKNOWN) { + if ($length < 512) { + $compressionMethod = ZipCompressionMethod::STORED; } else { - $compressionMethod = self::METHOD_STORED; + $mimeType = FilesUtil::getMimeTypeFromString($contents); + $compressionMethod = FilesUtil::isBadCompressionMimeType($mimeType) ? + ZipCompressionMethod::STORED : + ZipCompressionMethod::DEFLATED; } - } elseif (!\in_array($compressionMethod, self::$allowCompressionMethods, true)) { - throw new ZipUnsupportMethodException('Unsupported compression method ' . $compressionMethod); } - $externalAttributes = 0100644 << 16; - $entry = new ZipNewEntry($contents); - $entry->setName($localName); - $entry->setMethod($compressionMethod); - $entry->setTime(time()); - $entry->setExternalAttributes($externalAttributes); + $zipEntry = new ZipEntry($entryName); + $zipEntry->setData(new ZipNewData($zipEntry, $contents)); + $zipEntry->setUncompressedSize($length); + $zipEntry->setCompressionMethod($compressionMethod); + $zipEntry->setCreatedOS(ZipPlatform::OS_UNIX); + $zipEntry->setExtractedOS(ZipPlatform::OS_UNIX); + $zipEntry->setUnixMode(010644); + $zipEntry->setTime(time()); - $this->zipModel->addEntry($entry); + $this->addZipEntry($zipEntry); return $this; } + /** + * @param Finder $finder + * @param array $options + * + * @throws ZipException + * + * @return ZipEntry[] + */ + public function addFromFinder(Finder $finder, array $options = []) + { + $defaultOptions = [ + ZipOptions::STORE_ONLY_FILES => false, + ZipOptions::COMPRESSION_METHOD => null, + ZipOptions::MODIFIED_TIME => null, + ]; + $options += $defaultOptions; + + if ($options[ZipOptions::STORE_ONLY_FILES]) { + $finder->files(); + } + + $entries = []; + + foreach ($finder as $fileInfo) { + if ($fileInfo->isReadable()) { + $entry = $this->addSplFile($fileInfo, null, $options); + $entries[$entry->getName()] = $entry; + } + } + + return $entries; + } + + /** + * @param \SplFileInfo $file + * @param string|null $entryName + * @param array $options + * + * @throws ZipException + * + * @return ZipEntry + */ + public function addSplFile(\SplFileInfo $file, $entryName = null, array $options = []) + { + if ($file instanceof \DirectoryIterator) { + throw new InvalidArgumentException('File should not be \DirectoryIterator.'); + } + $defaultOptions = [ + ZipOptions::COMPRESSION_METHOD => null, + ZipOptions::MODIFIED_TIME => null, + ]; + $options += $defaultOptions; + + if (!$file->isReadable()) { + throw new InvalidArgumentException(sprintf('File %s is not readable', $file->getPathname())); + } + + if ($entryName === null) { + if ($file instanceof SymfonySplFileInfo) { + $entryName = $file->getRelativePathname(); + } else { + $entryName = $file->getBasename(); + } + } + + $entryName = ltrim((string) $entryName, '\\/'); + + if ($entryName === '') { + throw new InvalidArgumentException('Empty entry name'); + } + + $entryName = $file->isDir() ? rtrim($entryName, '/\\') . '/' : $entryName; + + $zipEntry = new ZipEntry($entryName); + $zipData = null; + + if ($file->isFile()) { + if (isset($options[ZipOptions::COMPRESSION_METHOD])) { + $compressionMethod = $options[ZipOptions::COMPRESSION_METHOD]; + } elseif ($file->getSize() < 512) { + $compressionMethod = ZipCompressionMethod::STORED; + } else { + $compressionMethod = FilesUtil::isBadCompressionFile($file->getPathname()) ? + ZipCompressionMethod::STORED : + ZipCompressionMethod::DEFLATED; + } + + $zipEntry->setUncompressedSize($file->getSize()); + $zipEntry->setCompressionMethod($compressionMethod); + + $zipData = new ZipFileData($file); + } elseif ($file->isDir()) { + $zipEntry->setCompressionMethod(ZipCompressionMethod::STORED); + $zipEntry->setUncompressedSize(0); + $zipEntry->setCompressedSize(0); + $zipEntry->setCrc(0); + } elseif ($file->isLink()) { + $linkTarget = $file->getLinkTarget(); + $lengthLinkTarget = \strlen($linkTarget); + + $zipEntry->setCompressionMethod(ZipCompressionMethod::STORED); + $zipEntry->setUncompressedSize($lengthLinkTarget); + $zipEntry->setCompressedSize($lengthLinkTarget); + $zipEntry->setCrc(crc32($linkTarget)); + + $zipData = new ZipNewData($zipEntry, $linkTarget); + } + + $zipEntry->setCreatedOS(ZipPlatform::OS_UNIX); + $zipEntry->setExtractedOS(ZipPlatform::OS_UNIX); + $zipEntry->setUnixMode($file->getPerms()); + + $timestamp = null; + + if (isset($options[ZipOptions::MODIFIED_TIME])) { + $mtime = $options[ZipOptions::MODIFIED_TIME]; + + if ($mtime instanceof \DateTimeInterface) { + $timestamp = $mtime->getTimestamp(); + } elseif (is_numeric($mtime)) { + $timestamp = (int) $mtime; + } elseif (\is_string($mtime)) { + $timestamp = strtotime($mtime); + + if ($timestamp === false) { + $timestamp = null; + } + } + } + + if ($timestamp === null) { + $timestamp = $file->getMTime(); + } + + $zipEntry->setTime($timestamp); + $zipEntry->setData($zipData); + + $this->addZipEntry($zipEntry); + + return $zipEntry; + } + + /** + * @param ZipEntry $zipEntry + */ + protected function addZipEntry(ZipEntry $zipEntry) + { + $this->zipContainer->addEntry($zipEntry); + } + /** * Add entry from the file. * * @param string $filename destination file - * @param string|null $localName zip Entry name + * @param string|null $entryName zip Entry name * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. + * If null, then auto choosing method. * * @throws ZipException * * @return ZipFile - * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 */ - public function addFile($filename, $localName = null, $compressionMethod = null) + public function addFile($filename, $entryName = null, $compressionMethod = null) { - $entry = new ZipNewFileEntry($filename); - - if ($compressionMethod === null) { - if (\function_exists('mime_content_type')) { - /** @noinspection PhpComposerExtensionStubsInspection */ - $mimeType = @mime_content_type($filename); - $type = strtok($mimeType, '/'); - - if ($type === 'image') { - $compressionMethod = self::METHOD_STORED; - } elseif ($type === 'text' && filesize($filename) < 150) { - $compressionMethod = self::METHOD_STORED; - } else { - $compressionMethod = ZipEntry::UNKNOWN; - } - } elseif (filesize($filename) >= 512) { - $compressionMethod = ZipEntry::UNKNOWN; - } else { - $compressionMethod = self::METHOD_STORED; - } - } elseif (!\in_array($compressionMethod, self::$allowCompressionMethods, true)) { - throw new ZipUnsupportMethodException('Unsupported compression method ' . $compressionMethod); + if ($filename === null) { + throw new InvalidArgumentException('Filename is null'); } - if ($localName === null) { - $localName = basename($filename); - } - $localName = ltrim((string) $localName, '\\/'); - - if ($localName === '') { - throw new InvalidArgumentException('Empty entry name'); - } - - $stat = stat($filename); - $mode = sprintf('%o', $stat['mode']); - $externalAttributes = (octdec($mode) & 0xffff) << 16; - - $entry->setName($localName); - $entry->setMethod($compressionMethod); - $entry->setTime($stat['mtime']); - $entry->setExternalAttributes($externalAttributes); - - $this->zipModel->addEntry($entry); + $this->addSplFile( + new \SplFileInfo($filename), + $entryName, + [ + ZipOptions::COMPRESSION_METHOD => $compressionMethod, + ] + ); return $this; } @@ -511,63 +775,69 @@ class ZipFile implements ZipFileInterface * Add entry from the stream. * * @param resource $stream stream resource - * @param string $localName zip Entry name + * @param string $entryName zip Entry name * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. + * If null, then auto choosing method. * * @throws ZipException * * @return ZipFile - * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 */ - public function addFromStream($stream, $localName, $compressionMethod = null) + public function addFromStream($stream, $entryName, $compressionMethod = null) { if (!\is_resource($stream)) { throw new InvalidArgumentException('Stream is not resource'); } - if ($localName === null) { + if ($entryName === null) { throw new InvalidArgumentException('Entry name is null'); } - $localName = ltrim((string) $localName, '\\/'); + $entryName = ltrim((string) $entryName, '\\/'); - if ($localName === '') { + if ($entryName === '') { throw new InvalidArgumentException('Empty entry name'); } $fstat = fstat($stream); + $zipEntry = new ZipEntry($entryName); + if ($fstat !== false) { - $mode = sprintf('%o', $fstat['mode']); + $unixMode = (int) sprintf('%o', $fstat['mode']); $length = $fstat['size']; - if ($compressionMethod === null) { - if ($length >= 512) { - $compressionMethod = ZipEntry::UNKNOWN; + if ($compressionMethod === null || $compressionMethod === ZipEntry::UNKNOWN) { + if ($length < 512) { + $compressionMethod = ZipCompressionMethod::STORED; } else { - $compressionMethod = self::METHOD_STORED; + rewind($stream); + $bufferContents = stream_get_contents($stream, min(1024, $length)); + rewind($stream); + $mimeType = FilesUtil::getMimeTypeFromString($bufferContents); + $compressionMethod = FilesUtil::isBadCompressionMimeType($mimeType) ? + ZipCompressionMethod::STORED : + ZipCompressionMethod::DEFLATED; } + $zipEntry->setUncompressedSize($length); } } else { - $mode = 010644; + $unixMode = 010644; + + if ($compressionMethod === null || $compressionMethod === ZipEntry::UNKNOWN) { + $compressionMethod = ZipCompressionMethod::DEFLATED; + } } - if ($compressionMethod !== null && !\in_array($compressionMethod, self::$allowCompressionMethods, true)) { - throw new ZipUnsupportMethodException('Unsupported method ' . $compressionMethod); - } + $zipEntry->setCreatedOS(ZipPlatform::OS_UNIX); + $zipEntry->setExtractedOS(ZipPlatform::OS_UNIX); + $zipEntry->setUnixMode($unixMode); + $zipEntry->setCompressionMethod($compressionMethod); + $zipEntry->setTime(time()); + $zipEntry->setData(new ZipNewData($zipEntry, $stream)); - $externalAttributes = (octdec($mode) & 0xffff) << 16; - - $entry = new ZipNewEntry($stream); - $entry->setName($localName); - $entry->setMethod($compressionMethod); - $entry->setTime(time()); - $entry->setExternalAttributes($externalAttributes); - - $this->zipModel->addEntry($entry); + $this->addZipEntry($zipEntry); return $this; } @@ -592,18 +862,18 @@ class ZipFile implements ZipFileInterface throw new InvalidArgumentException('Empty dir name'); } $dirName = rtrim($dirName, '\\/') . '/'; - $externalAttributes = 040755 << 16; - $entry = new ZipNewEntry(); - $entry->setName($dirName); - $entry->setTime(time()); - $entry->setMethod(self::METHOD_STORED); - $entry->setSize(0); - $entry->setCompressedSize(0); - $entry->setCrc(0); - $entry->setExternalAttributes($externalAttributes); + $zipEntry = new ZipEntry($dirName); + $zipEntry->setCompressionMethod(ZipCompressionMethod::STORED); + $zipEntry->setUncompressedSize(0); + $zipEntry->setCompressedSize(0); + $zipEntry->setCrc(0); + $zipEntry->setCreatedOS(ZipPlatform::OS_UNIX); + $zipEntry->setExtractedOS(ZipPlatform::OS_UNIX); + $zipEntry->setUnixMode(040755); + $zipEntry->setTime(time()); - $this->zipModel->addEntry($entry); + $this->addZipEntry($zipEntry); return $this; } @@ -614,8 +884,10 @@ class ZipFile implements ZipFileInterface * @param string $inputDir Input directory * @param string $localPath add files to this directory, or the root * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * + * Use {@see ZipCompressionMethod::STORED}, {@see + * ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -648,16 +920,17 @@ class ZipFile implements ZipFileInterface * @param string $inputDir Input directory * @param string $localPath add files to this directory, or the root * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, {@see + * ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * * @return ZipFile * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 + * @see ZipCompressionMethod::STORED + * @see ZipCompressionMethod::DEFLATED + * @see ZipCompressionMethod::BZIP2 */ public function addDirRecursive($inputDir, $localPath = '/', $compressionMethod = null) { @@ -686,16 +959,17 @@ class ZipFile implements ZipFileInterface * @param \Iterator $iterator directory iterator * @param string $localPath add files to this directory, or the root * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, {@see + * ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * * @return ZipFile * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 + * @see ZipCompressionMethod::STORED + * @see ZipCompressionMethod::DEFLATED + * @see ZipCompressionMethod::BZIP2 */ public function addFilesFromIterator( \Iterator $iterator, @@ -748,12 +1022,13 @@ class ZipFile implements ZipFileInterface /** * Add files from glob pattern. * - * @param string $inputDir Input directory - * @param string $globPattern glob pattern - * @param string|null $localPath add files to this directory, or the root - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir Input directory + * @param string $globPattern glob pattern + * @param string $localPath add files to this directory, or the root + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -768,13 +1043,14 @@ class ZipFile implements ZipFileInterface /** * Add files from glob pattern. * - * @param string $inputDir Input directory - * @param string $globPattern glob pattern - * @param string|null $localPath add files to this directory, or the root - * @param bool $recursive recursive search - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir Input directory + * @param string $globPattern glob pattern + * @param string $localPath add files to this directory, or the root + * @param bool $recursive recursive search + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -823,12 +1099,13 @@ class ZipFile implements ZipFileInterface /** * Add files recursively from glob pattern. * - * @param string $inputDir Input directory - * @param string $globPattern glob pattern - * @param string|null $localPath add files to this directory, or the root - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir Input directory + * @param string $globPattern glob pattern + * @param string $localPath add files to this directory, or the root + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -843,12 +1120,13 @@ class ZipFile implements ZipFileInterface /** * Add files from regex pattern. * - * @param string $inputDir search files in this directory - * @param string $regexPattern regex pattern - * @param string|null $localPath add files to this directory, or the root - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir search files in this directory + * @param string $regexPattern regex pattern + * @param string $localPath add files to this directory, or the root + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -864,13 +1142,15 @@ class ZipFile implements ZipFileInterface /** * Add files from regex pattern. * - * @param string $inputDir search files in this directory - * @param string $regexPattern regex pattern - * @param string|null $localPath add files to this directory, or the root - * @param bool $recursive recursive search - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir search files in this directory + * @param string $regexPattern regex pattern + * @param string $localPath add files to this directory, or the root + * @param bool $recursive recursive search + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. + * If null, then auto choosing method. * * @throws ZipException * @@ -946,12 +1226,13 @@ class ZipFile implements ZipFileInterface /** * Add files recursively from regex pattern. * - * @param string $inputDir search files in this directory - * @param string $regexPattern regex pattern - * @param string|null $localPath add files to this directory, or the root - * @param int|null $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * @param string $inputDir search files in this directory + * @param string $regexPattern regex pattern + * @param string $localPath add files to this directory, or the root + * @param int|null $compressionMethod Compression method. + * Use {@see ZipCompressionMethod::STORED}, + * {@see ZipCompressionMethod::DEFLATED} or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * @@ -997,7 +1278,7 @@ class ZipFile implements ZipFileInterface $newName = ltrim((string) $newName, '\\/'); if ($oldName !== $newName) { - $this->zipModel->renameEntry($oldName, $newName); + $this->zipContainer->renameEntry($oldName, $newName); } return $this; @@ -1016,7 +1297,7 @@ class ZipFile implements ZipFileInterface { $entryName = ltrim((string) $entryName, '\\/'); - if (!$this->zipModel->deleteEntry($entryName)) { + if (!$this->zipContainer->deleteEntry($entryName)) { throw new ZipEntryNotFoundException($entryName); } @@ -1066,7 +1347,7 @@ class ZipFile implements ZipFileInterface */ public function deleteAll() { - $this->zipModel->deleteAll(); + $this->zipContainer->deleteAll(); return $this; } @@ -1078,22 +1359,15 @@ class ZipFile implements ZipFileInterface * * @return ZipFile * - * @see ZipFile::LEVEL_DEFAULT_COMPRESSION - * @see ZipFile::LEVEL_SUPER_FAST - * @see ZipFile::LEVEL_FAST - * @see ZipFile::LEVEL_BEST_COMPRESSION + * @see ZipCompressionLevel::NORMAL + * @see ZipCompressionLevel::SUPER_FAST + * @see ZipCompressionLevel::FAST + * @see ZipCompressionLevel::MAXIMUM */ public function setCompressionLevel($compressionLevel = self::LEVEL_DEFAULT_COMPRESSION) { - if ($compressionLevel < self::LEVEL_DEFAULT_COMPRESSION || - $compressionLevel > self::LEVEL_BEST_COMPRESSION - ) { - throw new InvalidArgumentException( - 'Invalid compression level. Minimum level ' . - self::LEVEL_DEFAULT_COMPRESSION . '. Maximum level ' . self::LEVEL_BEST_COMPRESSION - ); - } $this->matcher()->all()->invoke( + /** @param string $entry */ function ($entry) use ($compressionLevel) { $this->setCompressionLevelEntry($entry, $compressionLevel); } @@ -1110,29 +1384,15 @@ class ZipFile implements ZipFileInterface * * @return ZipFile * - * @see ZipFile::LEVEL_DEFAULT_COMPRESSION - * @see ZipFile::LEVEL_SUPER_FAST - * @see ZipFile::LEVEL_FAST - * @see ZipFile::LEVEL_BEST_COMPRESSION + * @see ZipCompressionLevel::NORMAL + * @see ZipCompressionLevel::SUPER_FAST + * @see ZipCompressionLevel::FAST + * @see ZipCompressionLevel::MAXIMUM */ public function setCompressionLevelEntry($entryName, $compressionLevel) { - if ($compressionLevel !== null) { - if ($compressionLevel < self::LEVEL_DEFAULT_COMPRESSION || - $compressionLevel > self::LEVEL_BEST_COMPRESSION - ) { - throw new InvalidArgumentException( - 'Invalid compression level. Minimum level ' . - self::LEVEL_DEFAULT_COMPRESSION . '. Maximum level ' . self::LEVEL_BEST_COMPRESSION - ); - } - $entry = $this->zipModel->getEntry($entryName); - - if ($compressionLevel !== $entry->getCompressionLevel()) { - $entry = $this->zipModel->getEntryForChanges($entry); - $entry->setCompressionLevel($compressionLevel); - } - } + $compressionLevel = (int) $compressionLevel; + $this->getEntry($entryName)->setCompressionLevel($compressionLevel); return $this; } @@ -1140,30 +1400,24 @@ class ZipFile implements ZipFileInterface /** * @param string $entryName * @param int $compressionMethod Compression method. - * Use {@see ZipFile::METHOD_STORED}, {@see ZipFile::METHOD_DEFLATED} or - * {@see ZipFile::METHOD_BZIP2}. If null, then auto choosing method. + * Use {@see ZipCompressionMethod::STORED}, {@see ZipCompressionMethod::DEFLATED} + * or + * {@see ZipCompressionMethod::BZIP2}. If null, then auto choosing method. * * @throws ZipException * * @return ZipFile * - * @see ZipFile::METHOD_STORED - * @see ZipFile::METHOD_DEFLATED - * @see ZipFile::METHOD_BZIP2 + * @see ZipCompressionMethod::STORED + * @see ZipCompressionMethod::DEFLATED + * @see ZipCompressionMethod::BZIP2 */ public function setCompressionMethodEntry($entryName, $compressionMethod) { - if (!\in_array($compressionMethod, self::$allowCompressionMethods, true)) { - throw new ZipUnsupportMethodException('Unsupported method ' . $compressionMethod); - } - $entry = $this->zipModel->getEntry($entryName); - - if ($compressionMethod !== $entry->getMethod()) { - $this->zipModel - ->getEntryForChanges($entry) - ->setMethod($compressionMethod) - ; - } + $this->zipContainer + ->getEntry($entryName) + ->setCompressionMethod($compressionMethod) + ; return $this; } @@ -1179,7 +1433,7 @@ class ZipFile implements ZipFileInterface */ public function setZipAlign($align = null) { - $this->zipModel->setZipAlign($align); + $this->zipContainer->setZipAlign($align); return $this; } @@ -1189,29 +1443,11 @@ class ZipFile implements ZipFileInterface * * @param string $password Password * - * @throws ZipException - * - * @return ZipFile - * - * @deprecated using ZipFile::setReadPassword() - */ - public function withReadPassword($password) - { - return $this->setReadPassword($password); - } - - /** - * Set password to all input encrypted entries. - * - * @param string $password Password - * - * @throws ZipException - * * @return ZipFile */ public function setReadPassword($password) { - $this->zipModel->setReadPassword($password); + $this->zipContainer->setReadPassword($password); return $this; } @@ -1228,47 +1464,25 @@ class ZipFile implements ZipFileInterface */ public function setReadPasswordEntry($entryName, $password) { - $this->zipModel->setReadPasswordEntry($entryName, $password); + $this->zipContainer->setReadPasswordEntry($entryName, $password); return $this; } - /** - * Set password for all entries for update. - * - * @param string $password If password null then encryption clear - * @param int|null $encryptionMethod Encryption method - * - * @throws ZipException - * - * @return ZipFile - * - * @deprecated using ZipFile::setPassword() - */ - public function withNewPassword($password, $encryptionMethod = self::ENCRYPTION_METHOD_WINZIP_AES_256) - { - return $this->setPassword($password, $encryptionMethod); - } - /** * Sets a new password for all files in the archive. * - * @param string $password + * @param string $password Password * @param int|null $encryptionMethod Encryption method * - * @throws ZipException - * * @return ZipFile */ - public function setPassword($password, $encryptionMethod = self::ENCRYPTION_METHOD_WINZIP_AES_256) + public function setPassword($password, $encryptionMethod = ZipEncryptionMethod::WINZIP_AES_256) { - $this->zipModel->setWritePassword($password); + $this->zipContainer->setWritePassword($password); if ($encryptionMethod !== null) { - if (!\in_array($encryptionMethod, self::$allowEncryptionMethods, true)) { - throw new ZipException('Invalid encryption method "' . $encryptionMethod . '"'); - } - $this->zipModel->setEncryptionMethod($encryptionMethod); + $this->zipContainer->setEncryptionMethod($encryptionMethod); } return $this; @@ -1287,26 +1501,11 @@ class ZipFile implements ZipFileInterface */ public function setPasswordEntry($entryName, $password, $encryptionMethod = null) { - if ($encryptionMethod !== null && !\in_array($encryptionMethod, self::$allowEncryptionMethods, true)) { - throw new ZipException('Invalid encryption method "' . $encryptionMethod . '"'); - } - $this->matcher()->add($entryName)->setPassword($password, $encryptionMethod); + $this->getEntry($entryName)->setPassword($password, $encryptionMethod); return $this; } - /** - * Remove password for all entries for update. - * - * @return ZipFile - * - * @deprecated using ZipFile::disableEncryption() - */ - public function withoutPassword() - { - return $this->disableEncryption(); - } - /** * Disable encryption for all entries that are already in the archive. * @@ -1314,7 +1513,7 @@ class ZipFile implements ZipFileInterface */ public function disableEncryption() { - $this->zipModel->removePassword(); + $this->zipContainer->removePassword(); return $this; } @@ -1328,7 +1527,7 @@ class ZipFile implements ZipFileInterface */ public function disableEncryptionEntry($entryName) { - $this->zipModel->removePasswordEntry($entryName); + $this->zipContainer->removePasswordEntry($entryName); return $this; } @@ -1340,7 +1539,7 @@ class ZipFile implements ZipFileInterface */ public function unchangeAll() { - $this->zipModel->unchangeAll(); + $this->zipContainer->unchangeAll(); return $this; } @@ -1352,7 +1551,7 @@ class ZipFile implements ZipFileInterface */ public function unchangeArchiveComment() { - $this->zipModel->unchangeArchiveComment(); + $this->zipContainer->unchangeArchiveComment(); return $this; } @@ -1366,7 +1565,7 @@ class ZipFile implements ZipFileInterface */ public function unchangeEntry($entry) { - $this->zipModel->unchangeEntry($entry); + $this->zipContainer->unchangeEntry($entry); return $this; } @@ -1519,11 +1718,16 @@ class ZipFile implements ZipFileInterface } $stream = new ResponseStream($handle); + $size = $stream->getSize(); + + if ($size !== null) { + /** @noinspection CallableParameterUseCaseInTypeContextInspection */ + $response = $response->withHeader('Content-Length', (string) $size); + } return $response ->withHeader('Content-Type', $mimeType) ->withHeader('Content-Disposition', $contentDispositionValue) - ->withHeader('Content-Length', $stream->getSize()) ->withBody($stream) ; } @@ -1537,8 +1741,7 @@ class ZipFile implements ZipFileInterface { $this->onBeforeSave(); - $output = new ZipOutputStream($handle, $this->zipModel); - $output->writeZip(); + $this->createZipWriter()->write($handle); } /** @@ -1575,10 +1778,10 @@ class ZipFile implements ZipFileInterface */ public function close() { - if ($this->inputStream !== null) { - $this->inputStream->close(); - $this->inputStream = null; - $this->zipModel = new ZipModel(); + if ($this->reader !== null) { + $this->reader->close(); + $this->reader = null; + $this->zipContainer = new ZipContainer(); } } @@ -1591,31 +1794,30 @@ class ZipFile implements ZipFileInterface */ public function rewrite() { - if ($this->inputStream === null) { + if ($this->reader === null) { throw new ZipException('input stream is null'); } - $meta = stream_get_meta_data($this->inputStream->getStream()); - $content = $this->outputAsString(); - $this->close(); - if ($meta['wrapper_type'] === 'plainfile') { - /** - * @var resource $uri - */ - $uri = $meta['uri']; + $meta = $this->reader->getStreamMetaData(); - if (file_put_contents($uri, $content) === false) { - throw new ZipException("Can not overwrite the zip file in the {$uri} file."); + if ($meta['wrapper_type'] === 'plainfile' && isset($meta['uri'])) { + $this->saveAsFile($meta['uri']); + $this->close(); + + if (!($handle = @fopen($meta['uri'], 'rb'))) { + throw new ZipException("File {$meta['uri']} can't open."); } + } else { + $handle = @fopen('php://temp', 'r+b'); - if (!($handle = @fopen($uri, 'rb'))) { - throw new ZipException("File {$uri} can't open."); + if (!$handle) { + throw new ZipException('php://temp cannot open for write.'); } - - return $this->openFromStream($handle); + $this->writeZipToStream($handle); + $this->close(); } - return $this->openFromString($content); + return $this->openFromStream($handle); } /** @@ -1631,8 +1833,8 @@ class ZipFile implements ZipFileInterface * * @see http://php.net/manual/en/arrayaccess.offsetset.php * - * @param string $entryName the offset to assign the value to - * @param mixed $contents the value to set + * @param string $entryName the offset to assign the value to + * @param string|\DirectoryIterator|\SplFileInfo|resource $contents the value to set * * @throws ZipException * @@ -1644,26 +1846,19 @@ class ZipFile implements ZipFileInterface public function offsetSet($entryName, $contents) { if ($entryName === null) { - throw new InvalidArgumentException('entryName is null'); + throw new InvalidArgumentException('Key must not be null, but must contain the name of the zip entry.'); } $entryName = ltrim((string) $entryName, '\\/'); if ($entryName === '') { - throw new InvalidArgumentException('entryName is empty'); + throw new InvalidArgumentException('Key is empty, but must contain the name of the zip entry.'); } - if ($contents instanceof \SplFileInfo) { - if ($contents instanceof \DirectoryIterator) { - $this->addFilesFromIterator($contents, $entryName); - - return; - } - $this->addFile($contents->getPathname(), $entryName); - - return; - } - - if (StringUtil::endsWith($entryName, '/')) { + if ($contents instanceof \DirectoryIterator) { + $this->addFilesFromIterator($contents, $entryName); + } elseif ($contents instanceof \SplFileInfo) { + $this->addSplFile($contents, $entryName); + } elseif (StringUtil::endsWith($entryName, '/')) { $this->addEmptyDir($entryName); } elseif (\is_resource($contents)) { $this->addFromStream($contents, $entryName); @@ -1729,7 +1924,7 @@ class ZipFile implements ZipFileInterface */ public function key() { - return key($this->zipModel->getEntries()); + return key($this->zipContainer->getEntries()); } /** @@ -1740,7 +1935,7 @@ class ZipFile implements ZipFileInterface */ public function next() { - next($this->zipModel->getEntries()); + next($this->zipContainer->getEntries()); } /** @@ -1781,6 +1976,6 @@ class ZipFile implements ZipFileInterface */ public function rewind() { - reset($this->zipModel->getEntries()); + reset($this->zipContainer->getEntries()); } } diff --git a/src/ZipFileInterface.php b/src/ZipFileInterface.php new file mode 100644 index 0000000..9ff0f60 --- /dev/null +++ b/src/ZipFileInterface.php @@ -0,0 +1,897 @@ +fp = @fopen($uri, $mode); + + return $this->fp !== false; + } + + /** + * Read from stream. + * + * This method is called in response to {@see fread()} and {@see fgets()}. + * + * Note: Remember to update the read/write position of the stream + * (by the number of bytes that were successfully read). + * + * @param int $count how many bytes of data from the current + * position should be returned + * + * @return false|string If there are less than count bytes available, + * return as many as are available. If no more data + * is available, return either FALSE or + * an empty string. + * + * @see https://www.php.net/streamwrapper.stream-read + */ + public function stream_read($count) + { + return fread($this->fp, $count); + } + + /** + * Seeks to specific location in a stream. + * + * This method is called in response to {@see fseek()}. + * The read/write position of the stream should be updated according + * to the offset and whence. + * + * @param int $offset the stream offset to seek to + * @param int $whence Possible values: + * {@see \SEEK_SET} - Set position equal to offset bytes. + * {@see \SEEK_CUR} - Set position to current location plus offset. + * {@see \SEEK_END} - Set position to end-of-file plus offset. + * + * @return bool return TRUE if the position was updated, FALSE otherwise + * + * @see https://www.php.net/streamwrapper.stream-seek + */ + public function stream_seek($offset, $whence = \SEEK_SET) + { + return fseek($this->fp, $offset, $whence) === 0; + } + + /** + * Retrieve the current position of a stream. + * + * This method is called in response to {@see fseek()} to determine + * the current position. + * + * @return int should return the current position of the stream + * + * @see https://www.php.net/streamwrapper.stream-tell + */ + public function stream_tell() + { + $pos = ftell($this->fp); + + if ($pos === false) { + throw new \RuntimeException('Cannot get stream position.'); + } + + return $pos; + } + + /** + * Tests for end-of-file on a file pointer. + * + * This method is called in response to {@see feof()}. + * + * @return bool should return TRUE if the read/write position is at + * the end of the stream and if no more data is available + * to be read, or FALSE otherwise + * + * @see https://www.php.net/streamwrapper.stream-eof + */ + public function stream_eof() + { + return feof($this->fp); + } + + /** + * Retrieve information about a file resource. + * + * This method is called in response to {@see fstat()}. + * + * @return array + * + * @see https://www.php.net/streamwrapper.stream-stat + * @see https://www.php.net/stat + * @see https://www.php.net/fstat + */ + public function stream_stat() + { + return fstat($this->fp); + } + + /** + * Flushes the output. + * + * This method is called in response to {@see fflush()} and when the + * stream is being closed while any unflushed data has been written to + * it before. + * If you have cached data in your stream but not yet stored it into + * the underlying storage, you should do so now. + * + * @return bool should return TRUE if the cached data was successfully + * stored (or if there was no data to store), or FALSE + * if the data could not be stored + * + * @see https://www.php.net/streamwrapper.stream-flush + */ + public function stream_flush() + { + return fflush($this->fp); + } + + /** + * Truncate stream. + * + * Will respond to truncation, e.g., through {@see ftruncate()}. + * + * @param int $new_size the new size + * + * @return bool returns TRUE on success or FALSE on failure + * + * @see https://www.php.net/streamwrapper.stream-truncate + */ + public function stream_truncate($new_size) + { + return ftruncate($this->fp, (int) $new_size); + } + + /** + * Write to stream. + * + * This method is called in response to {@see fwrite().} + * + * Note: Remember to update the current position of the stream by + * number of bytes that were successfully written. + * + * @param string $data should be stored into the underlying stream + * + * @return int should return the number of bytes that were successfully stored, or 0 if none could be stored + * + * @see https://www.php.net/streamwrapper.stream-write + */ + public function stream_write($data) + { + $bytes = fwrite($this->fp, $data); + + return $bytes === false ? 0 : $bytes; + } + + /** + * Close a resource. + * + * This method is called in response to {@see fclose()}. + * All resources that were locked, or allocated, by the wrapper should be released. + * + * @see https://www.php.net/streamwrapper.stream-close + */ + public function stream_close() + { + fclose($this->fp); + } +} diff --git a/tests/PhpZip/Internal/ZipFileExtended.php b/tests/Internal/ZipFileExtended.php similarity index 80% rename from tests/PhpZip/Internal/ZipFileExtended.php rename to tests/Internal/ZipFileExtended.php index 5e00777..4e4ff14 100644 --- a/tests/PhpZip/Internal/ZipFileExtended.php +++ b/tests/Internal/ZipFileExtended.php @@ -1,6 +1,6 @@ setZipAlign(4); $this->deleteFromRegex('~^META\-INF/~i'); } } diff --git a/tests/PhpZip/Issue24Test.php b/tests/Issue24Test.php similarity index 76% rename from tests/PhpZip/Issue24Test.php rename to tests/Issue24Test.php index 4250470..6aa59a6 100644 --- a/tests/PhpZip/Issue24Test.php +++ b/tests/Issue24Test.php @@ -1,8 +1,10 @@ outputFilename); - $stream = fopen('dummyfs://localhost/' . $this->outputFilename, 'rb'); + $uri = self::PROTO_DUMMYFS . '://localhost/' . $this->outputFilename; + $stream = fopen($uri, 'rb'); static::assertNotFalse($stream); $zip->openFromStream($stream); static::assertSame($zip->getListFiles(), ['file.txt']); diff --git a/tests/PhpZip/Internal/DummyFileSystemStream.php b/tests/PhpZip/Internal/DummyFileSystemStream.php deleted file mode 100644 index a278dcd..0000000 --- a/tests/PhpZip/Internal/DummyFileSystemStream.php +++ /dev/null @@ -1,72 +0,0 @@ -fp = fopen($path, $mode); - - return true; - } - - /** - * @param $count - * - * @return false|string - */ - public function stream_read($count) - { - return fread($this->fp, $count); - } - - /** - * @return false|int - */ - public function stream_tell() - { - return ftell($this->fp); - } - - /** - * @return bool - */ - public function stream_eof() - { - return feof($this->fp); - } - - /** - * @param $offset - * @param $whence - */ - public function stream_seek($offset, $whence) - { - fseek($this->fp, $offset, $whence); - } - - /** - * @return array - */ - public function stream_stat() - { - return fstat($this->fp); - } -} diff --git a/tests/PhpZip/PhpZipExtResourceTest.php b/tests/PhpZipExtResourceTest.php similarity index 88% rename from tests/PhpZip/PhpZipExtResourceTest.php rename to tests/PhpZipExtResourceTest.php index 859ebe5..cd6eaef 100644 --- a/tests/PhpZip/PhpZipExtResourceTest.php +++ b/tests/PhpZipExtResourceTest.php @@ -1,11 +1,12 @@ openFile($filename); @@ -48,7 +49,7 @@ class PhpZipExtResourceTest extends ZipTestCase */ public function testBug8009() { - $filename = __DIR__ . '/php-zip-ext-test-resources/bug8009.zip'; + $filename = __DIR__ . '/resources/pecl/bug8009.zip'; $zipFile = new ZipFile(); $zipFile->openFile($filename); @@ -95,7 +96,7 @@ class PhpZipExtResourceTest extends ZipTestCase public function provideBug40228() { return [ - [__DIR__ . '/php-zip-ext-test-resources/bug40228.zip'], + [__DIR__ . '/resources/pecl/bug40228.zip'], ]; } @@ -110,7 +111,7 @@ class PhpZipExtResourceTest extends ZipTestCase { $this->setExpectedException(Crc32Exception::class, 'file1'); - $filename = __DIR__ . '/php-zip-ext-test-resources/bug49072.zip'; + $filename = __DIR__ . '/resources/pecl/bug49072.zip'; $zipFile = new ZipFile(); $zipFile->openFile($filename); @@ -134,11 +135,11 @@ class PhpZipExtResourceTest extends ZipTestCase } else { // php 64 bit $this->setExpectedException( ZipAuthenticationException::class, - 'nvalid password for zip entry "bug70752.txt"' + 'Invalid password' ); } - $filename = __DIR__ . '/php-zip-ext-test-resources/bug70752.zip'; + $filename = __DIR__ . '/resources/pecl/bug70752.zip'; static::assertTrue(mkdir($this->outputDirname, 0755, true)); @@ -151,9 +152,10 @@ class PhpZipExtResourceTest extends ZipTestCase static::markTestIncomplete('failed test'); } catch (ZipException $exception) { static::assertFileNotExists($this->outputDirname . '/bug70752.txt'); - $zipFile->close(); throw $exception; + } finally { + $zipFile->close(); } } @@ -166,9 +168,9 @@ class PhpZipExtResourceTest extends ZipTestCase */ public function testPecl12414() { - $this->setExpectedException(ZipException::class, 'Corrupt zip file. Cannot read central dir entry.'); + $this->setExpectedException(ZipException::class, 'Corrupt zip file. Cannot read zip entry.'); - $filename = __DIR__ . '/php-zip-ext-test-resources/pecl12414.zip'; + $filename = __DIR__ . '/resources/pecl/pecl12414.zip'; $zipFile = new ZipFile(); $zipFile->openFile($filename); diff --git a/tests/SlowTests/Zip64Test.php b/tests/SlowTests/Zip64Test.php new file mode 100644 index 0000000..e262413 --- /dev/null +++ b/tests/SlowTests/Zip64Test.php @@ -0,0 +1,100 @@ +outputFilename); + $tmpLargeFile = $basedir . '/large_bin_file.bin'; + + $sizeLargeBinFile = (int) (4.2 * 1024 * 1024 * 1024); + $needFreeSpace = $sizeLargeBinFile * 4; + $diskFreeSpace = disk_free_space($basedir); + + if ($needFreeSpace > $diskFreeSpace) { + static::markTestIncomplete( + sprintf( + 'Not enough disk space for the test. Need to free %s', + FilesUtil::humanSize($needFreeSpace - $diskFreeSpace) + ) + ); + + return; + } + + try { + $commandCreateLargeBinFile = 'fallocate -l ' . escapeshellarg($sizeLargeBinFile) . ' ' . escapeshellarg($tmpLargeFile); + + exec($commandCreateLargeBinFile, $output, $returnCode); + + if ($returnCode !== 0) { + static::markTestIncomplete('Cannot create large file. Error code: ' . $returnCode); + + return; + } + + $zipFile = new ZipFile(); + $zipFile + ->addFile($tmpLargeFile, 'large_file1.bin', ZipCompressionMethod::STORED) + ->addFile($tmpLargeFile, 'large_file2.bin', ZipCompressionMethod::DEFLATED) + ->saveAsFile($this->outputFilename) + ->close() + ; + + if (is_file($tmpLargeFile)) { + unlink($tmpLargeFile); + } + + self::assertCorrectZipArchive($this->outputFilename); + + if (!is_dir($this->outputDirname)) { + mkdir($this->outputDirname, 0755, true); + } + + $zipFile->openFile($this->outputFilename); + $zipFile->extractTo($this->outputDirname); + + static::assertTrue(is_file($this->outputDirname . '/large_file1.bin')); + static::assertTrue(is_file($this->outputDirname . '/large_file2.bin')); + + $zipFile->deleteFromName('large_file1.bin'); + $zipFile->saveAsFile($this->outputFilename); + + self::assertCorrectZipArchive($this->outputFilename); + } finally { + if (is_file($tmpLargeFile)) { + unlink($tmpLargeFile); + } + } + } +} diff --git a/tests/PhpZip/Zip64Test.php b/tests/Zip64Test.php similarity index 88% rename from tests/PhpZip/Zip64Test.php rename to tests/Zip64Test.php index e9ebe85..bcb12cb 100644 --- a/tests/PhpZip/Zip64Test.php +++ b/tests/Zip64Test.php @@ -1,13 +1,16 @@ addFromString( 'entry' . $i . '.txt', random_bytes(mt_rand(100, 4096)), - ZipFile::METHOD_STORED + ZipCompressionMethod::STORED ); } $zipFile->saveAsFile($this->outputFilename); @@ -96,7 +98,7 @@ class ZipAlignTest extends ZipTestCase $zipFile->addFromString( 'entry' . $i . '.txt', random_bytes(mt_rand(100, 4096)), - ZipFile::METHOD_STORED + ZipCompressionMethod::STORED ); } $zipFile->setZipAlign(4); @@ -125,7 +127,7 @@ class ZipAlignTest extends ZipTestCase $zipFile->addFromString( 'entry' . $i . '.txt', random_bytes(mt_rand(100, 4096)), - ZipFile::METHOD_STORED + ZipCompressionMethod::STORED ); } $zipFile->saveAsFile($this->outputFilename); @@ -151,8 +153,8 @@ class ZipAlignTest extends ZipTestCase 'entry_new_' . ($isStored ? 'stored' : 'deflated') . '_' . $i . '.txt', random_bytes(mt_rand(100, 4096)), $isStored ? - ZipFile::METHOD_STORED : - ZipFile::METHOD_DEFLATED + ZipCompressionMethod::STORED : + ZipCompressionMethod::DEFLATED ); } $zipFile->setZipAlign(4); diff --git a/tests/PhpZip/ZipEventTest.php b/tests/ZipEventTest.php similarity index 82% rename from tests/PhpZip/ZipEventTest.php rename to tests/ZipEventTest.php index 950a645..63cd426 100644 --- a/tests/PhpZip/ZipEventTest.php +++ b/tests/ZipEventTest.php @@ -1,8 +1,9 @@ openFile(__DIR__ . '/resources/apk.zip'); static::assertTrue(isset($zipFile['META-INF/MANIFEST.MF'])); static::assertTrue(isset($zipFile['META-INF/CERT.SF'])); static::assertTrue(isset($zipFile['META-INF/CERT.RSA'])); + // the "META-INF/" folder will be deleted when saved + // in the ZipFileExtended::onBeforeSave() method $zipFile->saveAsFile($this->outputFilename); static::assertFalse(isset($zipFile['META-INF/MANIFEST.MF'])); static::assertFalse(isset($zipFile['META-INF/CERT.SF'])); @@ -28,11 +31,6 @@ class ZipEventTest extends ZipTestCase $zipFile->close(); static::assertCorrectZipArchive($this->outputFilename); - $result = static::assertVerifyZipAlign($this->outputFilename); - - if ($result !== null) { - static::assertTrue($result); - } $zipFile->openFile($this->outputFilename); static::assertFalse(isset($zipFile['META-INF/MANIFEST.MF'])); diff --git a/tests/PhpZip/ZipFileAddDirTest.php b/tests/ZipFileAddDirTest.php similarity index 81% rename from tests/PhpZip/ZipFileAddDirTest.php rename to tests/ZipFileAddDirTest.php index 9a08fb4..4c8285f 100644 --- a/tests/PhpZip/ZipFileAddDirTest.php +++ b/tests/ZipFileAddDirTest.php @@ -1,10 +1,11 @@ 'Hidden file', - 'text file.txt' => 'Text file', - 'Текстовый документ.txt' => 'Текстовый документ', - 'empty dir/' => null, - 'empty dir2/ещё пустой каталог/' => null, - 'catalog/New File' => 'New Catalog File', - 'catalog/New File 2' => 'New Catalog File 2', - 'catalog/Empty Dir/' => null, - 'category/list.txt' => 'Category list', - 'category/Pictures/128x160/Car/01.jpg' => 'File 01.jpg', - 'category/Pictures/128x160/Car/02.jpg' => 'File 02.jpg', - 'category/Pictures/240x320/Car/01.jpg' => 'File 01.jpg', - 'category/Pictures/240x320/Car/02.jpg' => 'File 02.jpg', - ]; - - /** - * Before test. - */ - protected function setUp() - { - parent::setUp(); - $this->fillDirectory(); - } - - protected function fillDirectory() - { - foreach (self::$files as $name => $content) { - $fullName = $this->outputDirname . '/' . $name; - - if ($content === null) { - if (!is_dir($fullName)) { - mkdir($fullName, 0755, true); - } - } else { - $dirname = \dirname($fullName); - - if (!is_dir($dirname)) { - mkdir($dirname, 0755, true); - } - file_put_contents($fullName, $content); - } - } - } - - /** - * @param ZipFile $zipFile - * @param array $actualResultFiles - * @param string $localPath - */ - protected static function assertFilesResult( - ZipFile $zipFile, - array $actualResultFiles = [], - $localPath = '/' - ) { - $localPath = rtrim($localPath, '/'); - $localPath = empty($localPath) ? '' : $localPath . '/'; - static::assertCount(\count($zipFile), $actualResultFiles); - $actualResultFiles = array_flip($actualResultFiles); - - foreach (self::$files as $file => $content) { - $zipEntryName = $localPath . $file; - - if (isset($actualResultFiles[$file])) { - static::assertTrue(isset($zipFile[$zipEntryName])); - static::assertSame($zipFile[$zipEntryName], $content); - unset($actualResultFiles[$file]); - } else { - static::assertFalse(isset($zipFile[$zipEntryName])); - } - } - static::assertEmpty($actualResultFiles); - } - /** * @throws ZipException */ @@ -111,6 +38,7 @@ class ZipFileAddDirTest extends ZipTestCase 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ], $localPath ); @@ -137,6 +65,7 @@ class ZipFileAddDirTest extends ZipTestCase 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ] ); $zipFile->close(); @@ -166,6 +95,7 @@ class ZipFileAddDirTest extends ZipTestCase 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ], $localPath ); @@ -196,6 +126,7 @@ class ZipFileAddDirTest extends ZipTestCase 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ] ); $zipFile->close(); @@ -267,6 +198,7 @@ class ZipFileAddDirTest extends ZipTestCase $ignoreFiles = [ 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ]; $directoryIterator = new \DirectoryIterator($this->outputDirname); @@ -302,6 +234,7 @@ class ZipFileAddDirTest extends ZipTestCase 'empty dir2/ещё пустой каталог/', 'list.txt', 'category/Pictures/240x320', + 'LoremIpsum.txt', ]; $directoryIterator = new \RecursiveDirectoryIterator($this->outputDirname); @@ -354,6 +287,7 @@ class ZipFileAddDirTest extends ZipTestCase [ 'text file.txt', 'Текстовый документ.txt', + 'LoremIpsum.txt', ], $localPath ); @@ -387,6 +321,7 @@ class ZipFileAddDirTest extends ZipTestCase 'category/Pictures/128x160/Car/02.jpg', 'category/Pictures/240x320/Car/01.jpg', 'category/Pictures/240x320/Car/02.jpg', + 'LoremIpsum.txt', ], $localPath ); @@ -415,6 +350,7 @@ class ZipFileAddDirTest extends ZipTestCase [ 'text file.txt', 'Текстовый документ.txt', + 'LoremIpsum.txt', ], $localPath ); @@ -444,6 +380,7 @@ class ZipFileAddDirTest extends ZipTestCase 'text file.txt', 'Текстовый документ.txt', 'category/list.txt', + 'LoremIpsum.txt', 'category/Pictures/128x160/Car/01.jpg', 'category/Pictures/128x160/Car/02.jpg', 'category/Pictures/240x320/Car/01.jpg', diff --git a/tests/ZipFileSetTestCase.php b/tests/ZipFileSetTestCase.php new file mode 100644 index 0000000..6872840 --- /dev/null +++ b/tests/ZipFileSetTestCase.php @@ -0,0 +1,91 @@ + 'Hidden file', + 'text file.txt' => 'Text file', + 'Текстовый документ.txt' => 'Текстовый документ', + 'LoremIpsum.txt' => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.', + 'empty dir/' => '', + 'empty dir2/ещё пустой каталог/' => '', + 'catalog/New File' => 'New Catalog File', + 'catalog/New File 2' => 'New Catalog File 2', + 'catalog/Empty Dir/' => '', + 'category/list.txt' => 'Category list', + 'category/Pictures/128x160/Car/01.jpg' => 'File 01.jpg', + 'category/Pictures/128x160/Car/02.jpg' => 'File 02.jpg', + 'category/Pictures/240x320/Car/01.jpg' => 'File 01.jpg', + 'category/Pictures/240x320/Car/02.jpg' => 'File 02.jpg', + ]; + + /** + * Before test. + */ + protected function setUp() + { + parent::setUp(); + $this->fillDirectory(); + } + + protected function fillDirectory() + { + foreach (self::$files as $name => $content) { + $fullName = $this->outputDirname . '/' . $name; + + if (StringUtil::endsWith($name, '/')) { + if (!is_dir($fullName) && !mkdir($fullName, 0755, true) && !is_dir($fullName)) { + throw new \RuntimeException(sprintf('Directory "%s" was not created', $fullName)); + } + } else { + $dirname = \dirname($fullName); + + if (!is_dir($dirname) && !mkdir($dirname, 0755, true) && !is_dir($dirname)) { + throw new \RuntimeException(sprintf('Directory "%s" was not created', $dirname)); + } + file_put_contents($fullName, $content); + } + } + } + + /** + * @param ZipFile $zipFile + * @param array $actualResultFiles + * @param string $localPath + */ + protected static function assertFilesResult( + ZipFile $zipFile, + array $actualResultFiles = [], + $localPath = '/' + ) { + $localPath = rtrim($localPath, '/'); + $localPath = empty($localPath) ? '' : $localPath . '/'; + static::assertCount(\count($zipFile), $actualResultFiles); + $actualResultFiles = array_flip($actualResultFiles); + + foreach (self::$files as $file => $content) { + $zipEntryName = $localPath . $file; + + if (isset($actualResultFiles[$file])) { + static::assertTrue(isset($zipFile[$zipEntryName])); + static::assertSame( + $zipFile[$zipEntryName], + $content, + sprintf('The content of the entry "%s" is not as expected.', $zipEntryName) + ); + unset($actualResultFiles[$file]); + } else { + static::assertFalse(isset($zipFile[$zipEntryName])); + } + } + static::assertEmpty($actualResultFiles); + } +} diff --git a/tests/PhpZip/ZipFileTest.php b/tests/ZipFileTest.php similarity index 87% rename from tests/PhpZip/ZipFileTest.php rename to tests/ZipFileTest.php index 6f90730..a701c48 100644 --- a/tests/PhpZip/ZipFileTest.php +++ b/tests/ZipFileTest.php @@ -1,7 +1,10 @@ setExpectedException(ZipException::class, 'can\'t open'); - /** @noinspection PhpComposerExtensionStubsInspection */ - if (posix_getuid() === 0) { - static::markTestSkipped('Skip the test for a user with root privileges'); - + if (static::skipTestForRootUser()) { return; } @@ -58,7 +59,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFileEmptyFile() { - $this->setExpectedException(ZipException::class, 'Invalid zip file'); + $this->setExpectedException(ZipException::class, 'Corrupt zip file'); static::assertNotFalse(touch($this->outputFilename)); $zipFile = new ZipFile(); @@ -73,7 +74,7 @@ class ZipFileTest extends ZipTestCase { $this->setExpectedException( ZipException::class, - 'Expected Local File Header or (ZIP64) End Of Central Directory Record' + 'Invalid zip file. The end of the central directory could not be found.' ); static::assertNotFalse(file_put_contents($this->outputFilename, random_bytes(255))); @@ -111,7 +112,7 @@ class ZipFileTest extends ZipTestCase { $this->setExpectedException( ZipException::class, - 'Expected Local File Header or (ZIP64) End Of Central Directory Record' + 'Invalid zip file. The end of the central directory could not be found.' ); $zipFile = new ZipFile(); @@ -143,7 +144,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamNullStream() { - $this->setExpectedException(InvalidArgumentException::class, 'Invalid stream resource'); + $this->setExpectedException(InvalidArgumentException::class, 'Stream must be a resource'); $zipFile = new ZipFile(); $zipFile->openFromStream(null); @@ -154,7 +155,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamInvalidResourceType() { - $this->setExpectedException(InvalidArgumentException::class, 'Invalid stream resource'); + $this->setExpectedException(InvalidArgumentException::class, 'Stream must be a resource'); $zipFile = new ZipFile(); /** @noinspection PhpParamsInspection */ @@ -166,7 +167,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamInvalidResourceType2() { - $this->setExpectedException(InvalidArgumentException::class, 'Invalid resource type - gd.'); + $this->setExpectedException(InvalidArgumentException::class, 'Invalid resource type'); $zipFile = new ZipFile(); @@ -184,7 +185,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamInvalidResourceType3() { - $this->setExpectedException(InvalidArgumentException::class, 'Invalid stream type - dir.'); + $this->setExpectedException(InvalidArgumentException::class, 'Directory stream not supported'); $zipFile = new ZipFile(); $zipFile->openFromStream(opendir(__DIR__)); @@ -197,7 +198,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamNoSeekable() { - $this->setExpectedException(InvalidArgumentException::class, 'Resource cannot seekable stream.'); + $this->setExpectedException(InvalidArgumentException::class, 'The stream wrapper type "http" is not supported'); if (!$fp = @fopen('http://localhost', 'rb')) { if (!$fp = @fopen('http://example.org', 'rb')) { @@ -216,7 +217,7 @@ class ZipFileTest extends ZipTestCase */ public function testOpenFromStreamEmptyContents() { - $this->setExpectedException(ZipException::class, 'Invalid zip file'); + $this->setExpectedException(ZipException::class, 'Corrupt zip file'); $fp = fopen($this->outputFilename, 'w+b'); $zipFile = new ZipFile(); @@ -231,7 +232,7 @@ class ZipFileTest extends ZipTestCase { $this->setExpectedException( ZipException::class, - 'Expected Local File Header or (ZIP64) End Of Central Directory Record' + 'Invalid zip file. The end of the central directory could not be found.' ); $fp = fopen($this->outputFilename, 'w+b'); @@ -301,7 +302,7 @@ class ZipFileTest extends ZipTestCase $fileExpected = $this->outputDirname . \DIRECTORY_SEPARATOR . 'file_expected.zip'; $zipFile = new ZipFile(); - $zipFile->addDirRecursive(__DIR__ . '/../../src'); + $zipFile->addDirRecursive(__DIR__ . '/../src'); $sourceCount = $zipFile->count(); static::assertTrue($sourceCount > 0); $zipFile @@ -344,9 +345,9 @@ class ZipFileTest extends ZipTestCase public function testCreateArchiveAndAddFiles() { $outputFromString = file_get_contents(__FILE__); - $outputFromString2 = file_get_contents(\dirname(\dirname(__DIR__)) . \DIRECTORY_SEPARATOR . 'README.md'); - $outputFromFile = file_get_contents(\dirname(\dirname(__DIR__)) . \DIRECTORY_SEPARATOR . 'phpunit.xml'); - $outputFromStream = file_get_contents(\dirname(\dirname(__DIR__)) . \DIRECTORY_SEPARATOR . 'composer.json'); + $outputFromString2 = file_get_contents(\dirname(__DIR__) . \DIRECTORY_SEPARATOR . 'README.md'); + $outputFromFile = file_get_contents(\dirname(__DIR__) . \DIRECTORY_SEPARATOR . 'phpunit.xml'); + $outputFromStream = file_get_contents(\dirname(__DIR__) . \DIRECTORY_SEPARATOR . 'composer.json'); $filenameFromString = basename(__FILE__); $filenameFromString2 = 'test_file.txt'; @@ -451,7 +452,7 @@ class ZipFileTest extends ZipTestCase $zipFile->openFile($this->outputFilename); $info = $zipFile->getEntryInfo($basename); - static::assertSame($info->getMethodName(), 'No compression'); + static::assertSame($info->getMethodName(), 'Stored'); $zipFile->close(); } @@ -562,7 +563,7 @@ class ZipFileTest extends ZipTestCase */ public function testDeleteFromName() { - $inputDir = \dirname(\dirname(__DIR__)) . \DIRECTORY_SEPARATOR; + $inputDir = \dirname(__DIR__) . \DIRECTORY_SEPARATOR; $deleteEntryName = 'composer.json'; $zipFile = new ZipFile(); @@ -585,7 +586,7 @@ class ZipFileTest extends ZipTestCase } /** - * @throws Exception\ZipEntryNotFoundException + * @throws ZipEntryNotFoundException * @throws ZipException */ public function testDeleteNewEntry() @@ -615,6 +616,18 @@ class ZipFileTest extends ZipTestCase $zipFile->deleteFromName('entry'); } + public function testCatchNotFoundEntry() + { + $entryName = 'entry'; + $zipFile = new ZipFile(); + + try { + $zipFile->getEntry($entryName); + } catch (ZipEntryNotFoundException $e) { + static::assertSame($e->getEntryName(), $entryName); + } + } + /** * Delete zip entries from glob pattern. * @@ -622,7 +635,7 @@ class ZipFileTest extends ZipTestCase */ public function testDeleteFromGlob() { - $inputDir = \dirname(\dirname(__DIR__)); + $inputDir = \dirname(__DIR__); $zipFile = new ZipFile(); $zipFile->addFilesFromGlobRecursive($inputDir, '**.{xml,json,md}', '/'); @@ -677,7 +690,7 @@ class ZipFileTest extends ZipTestCase */ public function testDeleteFromRegex() { - $inputDir = \dirname(\dirname(__DIR__)); + $inputDir = \dirname(__DIR__); $zipFile = new ZipFile(); $zipFile->addFilesFromRegexRecursive($inputDir, '~\.(xml|json)$~i', 'Path'); @@ -726,7 +739,7 @@ class ZipFileTest extends ZipTestCase public function testDeleteAll() { $zipFile = new ZipFile(); - $zipFile->addDirRecursive(\dirname(\dirname(__DIR__)) . \DIRECTORY_SEPARATOR . 'src'); + $zipFile->addDirRecursive(\dirname(__DIR__) . \DIRECTORY_SEPARATOR . 'src'); static::assertTrue($zipFile->count() > 0); $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); @@ -880,7 +893,7 @@ class ZipFileTest extends ZipTestCase */ public function testVeryLongEntryComment() { - $this->setExpectedException(ZipException::class, 'Comment too long'); + $this->setExpectedException(InvalidArgumentException::class, 'Comment too long'); $comment = 'Very long comment' . \PHP_EOL . 'Очень длинный комментарий' . \PHP_EOL; @@ -913,21 +926,21 @@ class ZipFileTest extends ZipTestCase $entries = [ '1' => [ 'data' => random_bytes(255), - 'method' => ZipFile::METHOD_STORED, - 'expected' => 'No compression', + 'method' => ZipCompressionMethod::STORED, + 'expected' => 'Stored', ], '2' => [ 'data' => random_bytes(255), - 'method' => ZipFile::METHOD_DEFLATED, - 'expected' => 'Deflate', + 'method' => ZipCompressionMethod::DEFLATED, + 'expected' => 'Deflated', ], ]; if (\extension_loaded('bz2')) { $entries['3'] = [ 'data' => random_bytes(255), - 'method' => ZipFile::METHOD_BZIP2, - 'expected' => 'Bzip2', + 'method' => ZipCompressionMethod::BZIP2, + 'expected' => 'BZIP2', ]; } @@ -942,7 +955,7 @@ class ZipFileTest extends ZipTestCase static::assertCorrectZipArchive($this->outputFilename); $zipFile->openFile($this->outputFilename); - $zipFile->setCompressionLevel(ZipFile::LEVEL_BEST_COMPRESSION); + $zipFile->setCompressionLevel(ZipCompressionLevel::MAXIMUM); $zipAllInfo = $zipFile->getAllInfo(); foreach ($zipAllInfo as $entryName => $info) { @@ -954,26 +967,34 @@ class ZipFileTest extends ZipTestCase $zipFile->close(); } - public function testSetInvalidCompressionLevel() + /** + * @dataProvider provideInvalidCompressionLevels + * + * @param int $compressionLevel + */ + public function testSetInvalidCompressionLevel($compressionLevel) { $this->setExpectedException( InvalidArgumentException::class, - 'Invalid compression level. Minimum level -1. Maximum level 9' + 'Invalid compression level. Minimum level 1. Maximum level 9' ); $zipFile = new ZipFile(); - $zipFile->setCompressionLevel(-2); + $zipFile['file 1'] = 'contents'; + $zipFile->setCompressionLevel($compressionLevel); } - public function testSetInvalidCompressionLevel2() + /** + * @return array + */ + public function provideInvalidCompressionLevels() { - $this->setExpectedException( - InvalidArgumentException::class, - 'Invalid compression level. Minimum level -1. Maximum level 9' - ); - - $zipFile = new ZipFile(); - $zipFile->setCompressionLevel(10); + return [ + [-10], + [-2], + [10], + [0xffff], + ]; } /** @@ -1125,10 +1146,7 @@ class ZipFileTest extends ZipTestCase { $this->setExpectedException(ZipException::class, 'Destination is not writable directory'); - /** @noinspection PhpComposerExtensionStubsInspection */ - if (posix_getuid() === 0) { - static::markTestSkipped('Skip the test for a user with root privileges'); - + if (static::skipTestForRootUser()) { return; } @@ -1149,7 +1167,10 @@ class ZipFileTest extends ZipTestCase */ public function testAddFromArrayAccessNullName() { - $this->setExpectedException(InvalidArgumentException::class, 'entryName is null'); + $this->setExpectedException( + InvalidArgumentException::class, + 'Key must not be null, but must contain the name of the zip entry.' + ); $zipFile = new ZipFile(); $zipFile[null] = 'content'; @@ -1160,7 +1181,10 @@ class ZipFileTest extends ZipTestCase */ public function testAddFromArrayAccessEmptyName() { - $this->setExpectedException(InvalidArgumentException::class, 'entryName is empty'); + $this->setExpectedException( + InvalidArgumentException::class, + 'Key is empty, but must contain the name of the zip entry.' + ); $zipFile = new ZipFile(); $zipFile[''] = 'content'; @@ -1193,10 +1217,14 @@ class ZipFileTest extends ZipTestCase */ public function testAddFromStringUnsupportedMethod() { - $this->setExpectedException(ZipUnsupportMethodException::class, 'Unsupported compression method'); + $this->setExpectedException( + ZipUnsupportMethodException::class, + 'Compression method 99 (AES Encryption) is not supported.' + ); $zipFile = new ZipFile(); - $zipFile->addFromString('file', 'contents', ZipEntry::METHOD_WINZIP_AES); + $zipFile->addFromString('file', 'contents', ZipCompressionMethod::WINZIP_AES); + $zipFile->outputAsString(); } /** @@ -1235,8 +1263,8 @@ class ZipFileTest extends ZipTestCase $zipFile->openFile($this->outputFilename); $infoStored = $zipFile->getEntryInfo(basename($fileStored)); $infoDeflated = $zipFile->getEntryInfo(basename($fileDeflated)); - static::assertSame($infoStored->getMethodName(), 'No compression'); - static::assertSame($infoDeflated->getMethodName(), 'Deflate'); + static::assertSame($infoStored->getMethodName(), 'Stored'); + static::assertSame($infoDeflated->getMethodName(), 'Deflated'); $zipFile->close(); } @@ -1270,12 +1298,16 @@ class ZipFileTest extends ZipTestCase */ public function testAddFromStreamUnsupportedMethod() { - $this->setExpectedException(ZipUnsupportMethodException::class, 'Unsupported method'); + $this->setExpectedException( + ZipUnsupportMethodException::class, + 'Compression method 99 (AES Encryption) is not supported.' + ); $handle = fopen(__FILE__, 'rb'); $zipFile = new ZipFile(); - $zipFile->addFromStream($handle, basename(__FILE__), ZipEntry::METHOD_WINZIP_AES); + $zipFile->addFromStream($handle, basename(__FILE__), ZipCompressionMethod::WINZIP_AES); + $zipFile->outputAsString(); } /** @@ -1306,8 +1338,8 @@ class ZipFileTest extends ZipTestCase $zipFile->openFile($this->outputFilename); $infoStored = $zipFile->getEntryInfo(basename($fileStored)); $infoDeflated = $zipFile->getEntryInfo(basename($fileDeflated)); - static::assertSame($infoStored->getMethodName(), 'No compression'); - static::assertSame($infoDeflated->getMethodName(), 'Deflate'); + static::assertSame($infoStored->getMethodName(), 'Stored'); + static::assertSame($infoDeflated->getMethodName(), 'Deflated'); $zipFile->close(); } @@ -1316,7 +1348,7 @@ class ZipFileTest extends ZipTestCase */ public function testAddFileNullFileName() { - $this->setExpectedException(InvalidArgumentException::class, 'file is null'); + $this->setExpectedException(InvalidArgumentException::class, 'Filename is null'); $zipFile = new ZipFile(); $zipFile->addFile(null); @@ -1327,7 +1359,7 @@ class ZipFileTest extends ZipTestCase */ public function testAddFileCantExists() { - $this->setExpectedException(ZipException::class, 'does not exist'); + $this->setExpectedException(InvalidArgumentException::class, 'File path/to/file is not readable'); $zipFile = new ZipFile(); $zipFile->addFile('path/to/file'); @@ -1338,10 +1370,14 @@ class ZipFileTest extends ZipTestCase */ public function testAddFileUnsupportedMethod() { - $this->setExpectedException(ZipUnsupportMethodException::class, 'Unsupported compression method 99'); + $this->setExpectedException( + ZipUnsupportMethodException::class, + 'Compression method 99 (AES Encryption) is not supported.' + ); $zipFile = new ZipFile(); - $zipFile->addFile(__FILE__, null, ZipEntry::METHOD_WINZIP_AES); + $zipFile->addFile(__FILE__, null, ZipCompressionMethod::WINZIP_AES); + $zipFile->outputAsString(); } /** @@ -1349,12 +1385,9 @@ class ZipFileTest extends ZipTestCase */ public function testAddFileCantOpen() { - $this->setExpectedException(ZipException::class, 'file could not be read'); - - /** @noinspection PhpComposerExtensionStubsInspection */ - if (posix_getuid() === 0) { - static::markTestSkipped('Skip the test for a user with root privileges'); + $this->setExpectedException(InvalidArgumentException::class, 'is not readable'); + if (static::skipTestForRootUser()) { return; } @@ -1670,10 +1703,7 @@ class ZipFileTest extends ZipTestCase { $this->setExpectedException(InvalidArgumentException::class, 'can not open from write'); - /** @noinspection PhpComposerExtensionStubsInspection */ - if (posix_getuid() === 0) { - static::markTestSkipped('Skip the test for a user with root privileges'); - + if (static::skipTestForRootUser()) { return; } @@ -1700,17 +1730,21 @@ class ZipFileTest extends ZipTestCase $files['file' . $i . '.txt'] = random_bytes(255); } - $methods = [ZipFile::METHOD_STORED, ZipFile::METHOD_DEFLATED]; + $compressionMethods = [ZipCompressionMethod::STORED, ZipCompressionMethod::DEFLATED]; if (\extension_loaded('bz2')) { - $methods[] = ZipFile::METHOD_BZIP2; + $compressionMethods[] = ZipCompressionMethod::BZIP2; } $zipFile = new ZipFile(); - $zipFile->setCompressionLevel(ZipFile::LEVEL_BEST_SPEED); + $zipFile->setCompressionLevel(ZipCompressionLevel::SUPER_FAST); + + $i = 0; + $countMethods = \count($compressionMethods); foreach ($files as $entryName => $content) { - $zipFile->addFromString($entryName, $content, $methods[array_rand($methods)]); + $compressionMethod = $compressionMethods[$i++ % $countMethods]; + $zipFile->addFromString($entryName, $content, $compressionMethod); } $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); @@ -1804,7 +1838,7 @@ class ZipFileTest extends ZipTestCase } /** - * @throws Exception\ZipEntryNotFoundException + * @throws ZipEntryNotFoundException * @throws ZipException * @throws \Exception */ @@ -1815,16 +1849,15 @@ class ZipFileTest extends ZipTestCase $zipFile->addFromString('file', 'content', ZipEntry::UNKNOWN); $zipFile->addFromString('file2', base64_encode(random_bytes(512)), ZipEntry::UNKNOWN); - static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Unknown'); - static::assertSame($zipFile->getEntryInfo('file2')->getMethodName(), 'Unknown'); + static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Stored'); + static::assertSame($zipFile->getEntryInfo('file2')->getMethodName(), 'Deflated'); $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); $zipFile->openFile($this->outputFilename); - - static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'No compression'); - static::assertSame($zipFile->getEntryInfo('file2')->getMethodName(), 'Deflate'); + static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Stored'); + static::assertSame($zipFile->getEntryInfo('file2')->getMethodName(), 'Deflated'); $zipFile->close(); } @@ -1986,21 +2019,23 @@ class ZipFileTest extends ZipTestCase } /** + * @dataProvider provideCompressionLevels + * + * @param int $compressionLevel + * * @throws ZipEntryNotFoundException * @throws ZipException + * @throws \Exception */ - public function testCompressionLevel() + public function testCompressionLevel($compressionLevel) { + $fileContent = random_bytes(512); + $entryName = 'file.txt'; + $zipFile = new ZipFile(); $zipFile - ->addFromString('file', 'content', ZipFile::METHOD_DEFLATED) - ->setCompressionLevelEntry('file', ZipFile::LEVEL_BEST_COMPRESSION) - ->addFromString('file2', 'content', ZipFile::METHOD_DEFLATED) - ->setCompressionLevelEntry('file2', ZipFile::LEVEL_FAST) - ->addFromString('file3', 'content', ZipFile::METHOD_DEFLATED) - ->setCompressionLevelEntry('file3', ZipFile::LEVEL_SUPER_FAST) - ->addFromString('file4', 'content', ZipFile::METHOD_DEFLATED) - ->setCompressionLevelEntry('file4', ZipFile::LEVEL_DEFAULT_COMPRESSION) + ->addFromString($entryName, $fileContent, ZipCompressionMethod::DEFLATED) + ->setCompressionLevelEntry($entryName, $compressionLevel) ->saveAsFile($this->outputFilename) ->close() ; @@ -2008,29 +2043,25 @@ class ZipFileTest extends ZipTestCase static::assertCorrectZipArchive($this->outputFilename); $zipFile->openFile($this->outputFilename); - static::assertSame( - $zipFile->getEntryInfo('file') - ->getCompressionLevel(), - ZipFile::LEVEL_BEST_COMPRESSION - ); - static::assertSame( - $zipFile->getEntryInfo('file2') - ->getCompressionLevel(), - ZipFile::LEVEL_FAST - ); - static::assertSame( - $zipFile->getEntryInfo('file3') - ->getCompressionLevel(), - ZipFile::LEVEL_SUPER_FAST - ); - static::assertSame( - $zipFile->getEntryInfo('file4') - ->getCompressionLevel(), - ZipFile::LEVEL_DEFAULT_COMPRESSION - ); + static::assertSame($zipFile->getEntryContents($entryName), $fileContent); + static::assertSame($zipFile->getEntry($entryName)->getCompressionLevel(), $compressionLevel); + static::assertSame($zipFile->getEntryInfo($entryName)->getCompressionLevel(), $compressionLevel); $zipFile->close(); } + /** + * @return array + */ + public function provideCompressionLevels() + { + return [ + [ZipCompressionLevel::MAXIMUM], + [ZipCompressionLevel::NORMAL], + [ZipCompressionLevel::FAST], + [ZipCompressionLevel::SUPER_FAST], + ]; + } + /** * @throws ZipException */ @@ -2062,10 +2093,10 @@ class ZipFileTest extends ZipTestCase { $zipFile = new ZipFile(); for ($i = 0; $i < 10; $i++) { - $zipFile->addFromString('file' . $i, 'content', ZipFile::METHOD_DEFLATED); + $zipFile->addFromString('file' . $i, 'content', ZipCompressionMethod::DEFLATED); } $zipFile - ->setCompressionLevel(ZipFile::LEVEL_BEST_SPEED) + ->setCompressionLevel(ZipCompressionLevel::SUPER_FAST) ->saveAsFile($this->outputFilename) ->close() ; @@ -2077,7 +2108,7 @@ class ZipFileTest extends ZipTestCase array_walk( $infoList, function (ZipInfo $zipInfo) { - $this->assertSame($zipInfo->getCompressionLevel(), ZipFile::LEVEL_BEST_SPEED); + $this->assertSame($zipInfo->getCompressionLevel(), ZipCompressionLevel::SUPER_FAST); } ); $zipFile->close(); @@ -2090,17 +2121,17 @@ class ZipFileTest extends ZipTestCase public function testCompressionMethodEntry() { $zipFile = new ZipFile(); - $zipFile->addFromString('file', 'content', ZipFile::METHOD_STORED); + $zipFile->addFromString('file', 'content', ZipCompressionMethod::STORED); $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); $zipFile->openFile($this->outputFilename); - static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'No compression'); - $zipFile->setCompressionMethodEntry('file', ZipFile::METHOD_DEFLATED); - static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Deflate'); + static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Stored'); + $zipFile->setCompressionMethodEntry('file', ZipCompressionMethod::DEFLATED); + static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Deflated'); $zipFile->rewrite(); - static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Deflate'); + static::assertSame($zipFile->getEntryInfo('file')->getMethodName(), 'Deflated'); } /** @@ -2108,11 +2139,15 @@ class ZipFileTest extends ZipTestCase */ public function testInvalidCompressionMethodEntry() { - $this->setExpectedException(ZipUnsupportMethodException::class, 'Unsupported method'); + $this->setExpectedException( + ZipUnsupportMethodException::class, + 'Compression method 99 (AES Encryption) is not supported.' + ); $zipFile = new ZipFile(); - $zipFile->addFromString('file', 'content', ZipFile::METHOD_STORED); + $zipFile->addFromString('file', 'content', ZipCompressionMethod::STORED); $zipFile->setCompressionMethodEntry('file', 99); + $zipFile->outputAsString(); } /** @@ -2268,4 +2303,90 @@ class ZipFileTest extends ZipTestCase ['file.apk', null, 'application/vnd.android.package-archive', true, 'attachment'], ]; } + + /** + * @dataProvider provideGetEntryStream + * + * @param ZipFile $zipFile + * @param string $entryName + * @param string $contents + * + * @throws ZipEntryNotFoundException + * @throws ZipException + */ + public function testReopenEntryStream(ZipFile $zipFile, $entryName, $contents) + { + for ($i = 0; $i < 2; $i++) { + $fp = $zipFile->getEntryStream($entryName); + static::assertInternalType('resource', $fp); + static::assertSame(stream_get_contents($fp), $contents); + fclose($fp); + } + + $zipFile->close(); + } + + /** + * @throws \Exception + * + * @return array + */ + public function provideGetEntryStream() + { + $entryName = 'entry'; + $contents = random_bytes(1024); + + $zipFileSpl = new ZipFile(); + $zipFileSpl->addSplFile(new \SplFileInfo(__FILE__), $entryName); + + return [ + [(new ZipFile())->addFromString($entryName, $contents), $entryName, $contents], + [(new ZipFile())->addFile(__FILE__, $entryName), $entryName, file_get_contents(__FILE__)], + [ + (new ZipFile())->addFromStream(fopen(__FILE__, 'rb'), $entryName), + $entryName, + file_get_contents(__FILE__), + ], + [$zipFileSpl, $entryName, file_get_contents(__FILE__)], + ]; + } + + /** + * @throws ZipException + */ + public function testGetEntries() + { + $zipFile = new ZipFile(); + for ($i = 0; $i < 100; $i++) { + $zipFile->addFromString($i . '.txt', 'contents ' . $i); + } + $zipFile->saveAsFile($this->outputFilename); + $zipFile->close(); + + $zipFile->openFile($this->outputFilename); + $zipEntries = $zipFile->getEntries(); + static::assertCount(100, $zipEntries); + + foreach ($zipEntries as $zipEntry) { + static::assertInstanceOf(ZipEntry::class, $zipEntry); + static::assertNotSame($zipEntry->getDosTime(), 0); + $zipEntry->setDosTime(0); + $zipEntry->setCreatedOS(ZipPlatform::OS_DOS); + $zipEntry->setExtractedOS(ZipPlatform::OS_DOS); + $zipEntry->setInternalAttributes(1); + $zipEntry->setExternalAttributes(0); + } + $zipFile->rewrite(); + + self::assertCorrectZipArchive($this->outputFilename); + + foreach ($zipFile->getEntries() as $zipEntry) { + static::assertSame($zipEntry->getDosTime(), 0); + static::assertSame($zipEntry->getExtractedOS(), ZipPlatform::OS_DOS); + static::assertSame($zipEntry->getCreatedOS(), ZipPlatform::OS_DOS); + static::assertSame($zipEntry->getInternalAttributes(), 1); + static::assertSame($zipEntry->getExternalAttributes(), 0); + } + $zipFile->close(); + } } diff --git a/tests/ZipFinderTest.php b/tests/ZipFinderTest.php new file mode 100644 index 0000000..67cdbcd --- /dev/null +++ b/tests/ZipFinderTest.php @@ -0,0 +1,42 @@ +files() + ->name('*.php') + ->in(__DIR__) + ; + $zipFile = new ZipFile(); + $zipFile->addFromFinder( + $finder, + [ + ZipOptions::COMPRESSION_METHOD => ZipCompressionMethod::DEFLATED, + ] + ); + $zipFile->saveAsFile($this->outputFilename); + + static::assertCorrectZipArchive($this->outputFilename); + + static::assertSame($finder->count(), $zipFile->count()); + $zipFile->close(); + } +} diff --git a/tests/PhpZip/ZipMatcherTest.php b/tests/ZipMatcherTest.php similarity index 98% rename from tests/PhpZip/ZipMatcherTest.php rename to tests/ZipMatcherTest.php index 345fa3d..415af67 100644 --- a/tests/PhpZip/ZipMatcherTest.php +++ b/tests/ZipMatcherTest.php @@ -1,10 +1,11 @@ addDir(__DIR__); - $zipFile->setPassword($password, ZipFile::ENCRYPTION_METHOD_TRADITIONAL); + $zipFile->setPassword($password, ZipEncryptionMethod::PKWARE); $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); static::assertCorrectZipArchive($this->outputFilename, $password); - // check bad password for ZipCrypto $zipFile->openFile($this->outputFilename); + // check bad password for Traditional PKWARE encryption $zipFile->setReadPassword($badPassword); foreach ($zipFile->getListFiles() as $entryName) { @@ -54,23 +58,23 @@ class ZipPasswordTest extends ZipFileAddDirTest $zipFile[$entryName]; static::fail('Expected Exception has not been raised.'); } catch (ZipAuthenticationException $ae) { - static::assertContains('Invalid password for zip entry', $ae->getMessage()); + static::assertContains('Invalid password', $ae->getMessage()); } } - // check correct password for ZipCrypto + // check correct password for Traditional PKWARE encryption $zipFile->setReadPassword($password); foreach ($zipFile->getAllInfo() as $info) { static::assertTrue($info->isEncrypted()); - static::assertContains('ZipCrypto', $info->getMethodName()); + static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName()); $decryptContent = $zipFile[$info->getName()]; static::assertNotEmpty($decryptContent); static::assertContains('setPassword($password, ZipFile::ENCRYPTION_METHOD_WINZIP_AES); + $zipFile->setPassword($password, ZipEncryptionMethod::WINZIP_AES_256); $zipFile->saveAsFile($this->outputFilename); $zipFile->close(); @@ -78,6 +82,7 @@ class ZipPasswordTest extends ZipFileAddDirTest // check from WinZip AES encryption $zipFile->openFile($this->outputFilename); + // set bad password WinZip AES $zipFile->setReadPassword($badPassword); @@ -95,7 +100,8 @@ class ZipPasswordTest extends ZipFileAddDirTest foreach ($zipFile->getAllInfo() as $info) { static::assertTrue($info->isEncrypted()); - static::assertContains('WinZip', $info->getMethodName()); + static::assertContains('Deflated', $info->getMethodName()); + static::assertContains('WinZip AES-256', $info->getEncryptionMethodName()); $decryptContent = $zipFile[$info->getName()]; static::assertNotEmpty($decryptContent); static::assertContains('addDirRecursive($this->outputDirname); - $zip->setPassword($password, ZipFile::ENCRYPTION_METHOD_TRADITIONAL); + $zip->setPassword($password, ZipEncryptionMethod::PKWARE); $zip->saveAsFile($this->outputFilename); $zip->close(); @@ -149,7 +155,7 @@ class ZipPasswordTest extends ZipFileAddDirTest foreach ($zip->getAllInfo() as $info) { if (!$info->isFolder()) { static::assertTrue($info->isEncrypted()); - static::assertContains('ZipCrypto', $info->getMethodName()); + static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName()); } } $zip->close(); @@ -184,7 +190,7 @@ class ZipPasswordTest extends ZipFileAddDirTest if (!$info->isFolder()) { static::assertTrue($info->isEncrypted()); static::assertSame($info->getEncryptionMethod(), $encryptionMethod); - static::assertContains('WinZip AES-' . $bitSize, $info->getMethodName()); + static::assertContains('WinZip AES-' . $bitSize, $info->getEncryptionMethodName()); } } $zip->close(); @@ -196,15 +202,14 @@ class ZipPasswordTest extends ZipFileAddDirTest public function winZipKeyStrengthProvider() { return [ - [ZipFile::ENCRYPTION_METHOD_WINZIP_AES_128, 128], - [ZipFile::ENCRYPTION_METHOD_WINZIP_AES_192, 192], - [ZipFile::ENCRYPTION_METHOD_WINZIP_AES, 256], - [ZipFile::ENCRYPTION_METHOD_WINZIP_AES_256, 256], + [ZipEncryptionMethod::WINZIP_AES_128, 128], + [ZipEncryptionMethod::WINZIP_AES_192, 192], + [ZipEncryptionMethod::WINZIP_AES_256, 256], ]; } /** - * @throws Exception\ZipEntryNotFoundException + * @throws ZipEntryNotFoundException * @throws ZipException */ public function testEncryptionEntries() @@ -221,8 +226,8 @@ class ZipPasswordTest extends ZipFileAddDirTest $zip = new ZipFile(); $zip->addDir($this->outputDirname); - $zip->setPasswordEntry('.hidden', $password1, ZipFile::ENCRYPTION_METHOD_TRADITIONAL); - $zip->setPasswordEntry('text file.txt', $password2, ZipFile::ENCRYPTION_METHOD_WINZIP_AES); + $zip->setPasswordEntry('.hidden', $password1, ZipEncryptionMethod::PKWARE); + $zip->setPasswordEntry('text file.txt', $password2, ZipEncryptionMethod::WINZIP_AES_256); $zip->saveAsFile($this->outputFilename); $zip->close(); @@ -236,16 +241,17 @@ class ZipPasswordTest extends ZipFileAddDirTest 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ] ); $info = $zip->getEntryInfo('.hidden'); static::assertTrue($info->isEncrypted()); - static::assertContains('ZipCrypto', $info->getMethodName()); + static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName()); $info = $zip->getEntryInfo('text file.txt'); static::assertTrue($info->isEncrypted()); - static::assertContains('WinZip AES', $info->getMethodName()); + static::assertContains('WinZip AES', $info->getEncryptionMethodName()); static::assertFalse($zip->getEntryInfo('Текстовый документ.txt')->isEncrypted()); static::assertFalse($zip->getEntryInfo('empty dir/')->isEncrypted()); @@ -254,7 +260,7 @@ class ZipPasswordTest extends ZipFileAddDirTest } /** - * @throws Exception\ZipEntryNotFoundException + * @throws ZipEntryNotFoundException * @throws ZipException */ public function testEncryptionEntriesWithDefaultPassword() @@ -273,8 +279,8 @@ class ZipPasswordTest extends ZipFileAddDirTest $zip = new ZipFile(); $zip->addDir($this->outputDirname); $zip->setPassword($defaultPassword); - $zip->setPasswordEntry('.hidden', $password1, ZipFile::ENCRYPTION_METHOD_TRADITIONAL); - $zip->setPasswordEntry('text file.txt', $password2, ZipFile::ENCRYPTION_METHOD_WINZIP_AES); + $zip->setPasswordEntry('.hidden', $password1, ZipEncryptionMethod::PKWARE); + $zip->setPasswordEntry('text file.txt', $password2, ZipEncryptionMethod::WINZIP_AES_256); $zip->saveAsFile($this->outputFilename); $zip->close(); @@ -289,20 +295,21 @@ class ZipPasswordTest extends ZipFileAddDirTest 'text file.txt', 'Текстовый документ.txt', 'empty dir/', + 'LoremIpsum.txt', ] ); $info = $zip->getEntryInfo('.hidden'); static::assertTrue($info->isEncrypted()); - static::assertContains('ZipCrypto', $info->getMethodName()); + static::assertContains('Traditional PKWARE encryption', $info->getEncryptionMethodName()); $info = $zip->getEntryInfo('text file.txt'); static::assertTrue($info->isEncrypted()); - static::assertContains('WinZip AES', $info->getMethodName()); + static::assertContains('WinZip AES', $info->getEncryptionMethodName()); $info = $zip->getEntryInfo('Текстовый документ.txt'); static::assertTrue($info->isEncrypted()); - static::assertContains('WinZip AES', $info->getMethodName()); + static::assertContains('WinZip AES', $info->getEncryptionMethodName()); static::assertFalse($zip->getEntryInfo('empty dir/')->isEncrypted()); @@ -314,17 +321,17 @@ class ZipPasswordTest extends ZipFileAddDirTest */ public function testSetEncryptionMethodInvalid() { - $this->setExpectedException(ZipException::class, 'Invalid encryption method'); + $this->setExpectedException(InvalidArgumentException::class, 'Encryption method 9999 is not supported.'); $zipFile = new ZipFile(); $encryptionMethod = 9999; - $zipFile->setPassword('pass', $encryptionMethod); $zipFile['entry'] = 'content'; + $zipFile->setPassword('pass', $encryptionMethod); $zipFile->outputAsString(); } /** - * @throws Exception\ZipEntryNotFoundException + * @throws ZipEntryNotFoundException * @throws ZipException */ public function testEntryPassword() @@ -362,11 +369,11 @@ class ZipPasswordTest extends ZipFileAddDirTest */ public function testInvalidEncryptionMethodEntry() { - $this->setExpectedException(ZipException::class, 'Invalid encryption method'); + $this->setExpectedException(InvalidArgumentException::class, 'Encryption method 99 is not supported.'); $zipFile = new ZipFile(); - $zipFile->addFromString('file', 'content', ZipFile::METHOD_STORED); - $zipFile->setPasswordEntry('file', 'pass', 99); + $zipFile->addFromString('file', 'content', ZipCompressionMethod::STORED); + $zipFile->setPasswordEntry('file', 'pass', ZipCompressionMethod::WINZIP_AES); } /** @@ -424,11 +431,10 @@ class ZipPasswordTest extends ZipFileAddDirTest $contents = str_pad('', 1000, 'test;test2;test3' . \PHP_EOL, \STR_PAD_RIGHT); $password = base64_encode(random_bytes(20)); - $encryptMethod = ZipFile::ENCRYPTION_METHOD_WINZIP_AES_256; $zipFile = new ZipFile(); $zipFile - ->addFromString('codes.csv', $contents) - ->setPassword($password, $encryptMethod) + ->addFromString('codes.csv', $contents, ZipCompressionMethod::DEFLATED) + ->setPassword($password, ZipEncryptionMethod::WINZIP_AES_256) ->saveAsFile($this->outputFilename) ->close() ; @@ -453,6 +459,7 @@ class ZipPasswordTest extends ZipFileAddDirTest $zipFile = new ZipFile(); $zipFile->openFile($file); $zipFile->setReadPassword($password); + $zipFile->setPassword($password); $zipFile->setEntryComment('contents.txt', 'comment'); // change entry, but not changed contents $zipFile->saveAsFile($this->outputFilename); diff --git a/tests/PhpZip/ZipRemoteFileTest.php b/tests/ZipRemoteFileTest.php similarity index 97% rename from tests/PhpZip/ZipRemoteFileTest.php rename to tests/ZipRemoteFileTest.php index 5047d04..bfe425e 100644 --- a/tests/PhpZip/ZipRemoteFileTest.php +++ b/tests/ZipRemoteFileTest.php @@ -1,8 +1,9 @@ addFromStream($fp, $fileName); - $zipFile->saveAsFile($outputZip); $zipFile->close(); diff --git a/tests/PhpZip/ZipSlipVulnerabilityTest.php b/tests/ZipSlipVulnerabilityTest.php similarity index 88% rename from tests/PhpZip/ZipSlipVulnerabilityTest.php rename to tests/ZipSlipVulnerabilityTest.php index 45d92e7..a283cbd 100644 --- a/tests/PhpZip/ZipSlipVulnerabilityTest.php +++ b/tests/ZipSlipVulnerabilityTest.php @@ -1,6 +1,9 @@ setExpectedException( + $exceptionClass, + $exceptionMessage + ); + } + + static::assertInternalType('resource', $resource); + + $zipFile = new ZipFile(); + $zipFile->openFromStream($resource); + + static::assertTrue(fclose($resource)); + } + + /** + * @return array|\Generator + */ + public function provideStreams() + { + return [ + 'file' => yield [fopen(__DIR__ . '/resources/apk.zip', 'rb'), null, null], + 'directory' => yield [ + fopen(__DIR__, 'rb'), + InvalidArgumentException::class, + 'Directory stream not supported', + ], + 'temp' => yield [$this->getTempResource('php://temp'), null, null], + 'memory' => yield [$this->getTempResource('php://memory'), null, null], + 'bz' => yield [ + $this->getBzResource(), + InvalidArgumentException::class, + 'The stream wrapper type "Unknown" is not supported.', + ], + 'url' => yield [ + fopen('https://github.com/Ne-Lexa/php-zip/archive/master.zip', 'rb'), + InvalidArgumentException::class, + 'The stream wrapper type "http" is not supported.', + ], + 'ftp' => yield [ + fopen('ftp://ftp.ripe.net/pub/stats/ripencc/delegated-ripencc-latest.md5', 'rb'), + InvalidArgumentException::class, + 'The stream wrapper type "ftp" is not supported.', + ], + ]; + } + + /** + * @param string $filename + * + * @return resource + */ + private function getTempResource($filename) + { + $fp = fopen(__DIR__ . '/resources/apk.zip', 'rb'); + $stream = fopen($filename, 'r+b'); + stream_copy_to_stream($fp, $stream); + fclose($fp); + rewind($stream); + + return $stream; + } + + /** + * @return resource|null + */ + private function getBzResource() + { + if (!\extension_loaded('bz2')) { + return null; + } + $stream = bzopen('php://temp', 'w'); + bzwrite($stream, 'some input here'); + + return $stream; + } +} diff --git a/tests/PhpZip/ZipTestCase.php b/tests/ZipTestCase.php similarity index 89% rename from tests/PhpZip/ZipTestCase.php rename to tests/ZipTestCase.php index ab61665..d900208 100644 --- a/tests/PhpZip/ZipTestCase.php +++ b/tests/ZipTestCase.php @@ -1,9 +1,9 @@