?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/Zip.pm.tar

???????
usr/share/perl5/IO/Compress/Zip.pm��0000644��00000175352�15126263602�0012730 0��ustar�00��package IO::Compress::Zip ; use strict ; use warnings; use bytes; use IO::Compress::Base::Common 2.101 qw(:Status ); use IO::Compress::RawDeflate 2.101 (); use IO::Compress::Adapter::Deflate 2.101 ; use IO::Compress::Adapter::Identity 2.101 ; use IO::Compress::Zlib::Extra 2.101 ; use IO::Compress::Zip::Constants 2.101 ; use File::Spec(); use Config; use Compress::Raw::Zlib 2.101 (); BEGIN { eval { require IO::Compress::Adapter::Bzip2 ; IO::Compress::Adapter::Bzip2->import( 2.101 ); require IO::Compress::Bzip2 ; IO::Compress::Bzip2->import( 2.101 ); } ; eval { require IO::Compress::Adapter::Lzma ; IO::Compress::Adapter::Lzma->import( 2.101 ); require IO::Compress::Lzma ; IO::Compress::Lzma->import( 2.101 ); } ; eval { require IO::Compress::Adapter::Xz ; IO::Compress::Adapter::Xz->import( 2.101 ); require IO::Compress::Xz ; IO::Compress::Xz->import( 2.101 ); } ; eval { require IO::Compress::Adapter::Zstd ; IO::Compress::Adapter::Zstd->import( 2.101 ); require IO::Compress::Zstd ; IO::Compress::Zstd->import( 2.101 ); } ; } require Exporter ; our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, %DEFLATE_CONSTANTS, $ZipError); $VERSION = '2.102'; $ZipError = ''; @ISA = qw(IO::Compress::RawDeflate Exporter); @EXPORT_OK = qw( $ZipError zip ) ; %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ; push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ; $EXPORT_TAGS{zip_method} = [qw( ZIP_CM_STORE ZIP_CM_DEFLATE ZIP_CM_BZIP2 ZIP_CM_LZMA ZIP_CM_XZ ZIP_CM_ZSTD)]; push @{ $EXPORT_TAGS{all} }, @{ $EXPORT_TAGS{zip_method} }; Exporter::export_ok_tags('all'); sub new { my $class = shift ; my $obj = IO::Compress::Base::Common::createSelfTiedObject($class, \$ZipError); $obj->_create(undef, @_); } sub zip { my $obj = IO::Compress::Base::Common::createSelfTiedObject(undef, \$ZipError); return $obj->_def(@_); } sub isMethodAvailable { my $method = shift; # Store & Deflate are always available return 1 if $method == ZIP_CM_STORE \|\| $method == ZIP_CM_DEFLATE ; return 1 if $method == ZIP_CM_BZIP2 and defined $IO::Compress::Adapter::Bzip2::VERSION; return 1 if $method == ZIP_CM_LZMA and defined $IO::Compress::Adapter::Lzma::VERSION; return 1 if $method == ZIP_CM_XZ and defined $IO::Compress::Adapter::Xz::VERSION; return 1 if $method == ZIP_CM_ZSTD and defined $IO::Compress::Adapter::ZSTD::VERSION; return 0; } sub beforePayload { my $self = shift ; if ($self->{ZipData}{Sparse} ) { my $inc = 1024 100 ; my $NULLS = ("\x00" x $inc) ; my $sparse = $self->{ZipData}{Sparse} ; $self->{CompSize}->add( $sparse ); $self->{UnCompSize}->add( $sparse ); $self->{FH}->seek($sparse, IO::Handle::SEEK_CUR); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32($NULLS, $self->{ZipData}{CRC32}) for 1 .. int $sparse / $inc; $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(substr($NULLS, 0, $sparse % $inc), $self->{ZipData}{CRC32}) if $sparse % $inc; } } sub mkComp { my $self = shift ; my $got = shift ; my ($obj, $errstr, $errno) ; if ($self->{ZipData}{Method} == ZIP_CM_STORE) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Identity::mkCompObject( $got->getValue('level'), $got->getValue('strategy') ); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef); } elsif ($self->{ZipData}{Method} == ZIP_CM_DEFLATE) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject( $got->getValue('crc32'), $got->getValue('adler32'), $got->getValue('level'), $got->getValue('strategy') ); } elsif ($self->{ZipData}{Method} == ZIP_CM_BZIP2) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Bzip2::mkCompObject( $got->getValue('blocksize100k'), $got->getValue('workfactor'), $got->getValue('verbosity') ); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef); } elsif ($self->{ZipData}{Method} == ZIP_CM_LZMA) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Lzma::mkRawZipCompObject($got->getValue('preset'), $got->getValue('extreme'), ); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef); } elsif ($self->{ZipData}{Method} == ZIP_CM_XZ) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Xz::mkCompObject($got->getValue('preset'), $got->getValue('extreme'), 0 ); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef); } elsif ($self->{ZipData}{Method} == ZIP_CM_ZSTD) { ($obj, $errstr, $errno) = IO::Compress::Adapter::Zstd::mkCompObject(defined $got->getValue('level') ? $got->getValue('level') : 3, ); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef); } return $self->saveErrorString(undef, $errstr, $errno) if ! defined $obj; if (! defined $self->{ZipData}{SizesOffset}) { $self->{ZipData}{SizesOffset} = 0; $self->{ZipData}{Offset} = U64->new(); } $self->{ZipData}{AnyZip64} = 0 if ! defined $self->{ZipData}{AnyZip64} ; return $obj; } sub reset { my $self = shift ; $self->{Compress}->reset(); $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(''); return STATUS_OK; } sub filterUncompressed { my $self = shift ; if ($self->{ZipData}{Method} == ZIP_CM_DEFLATE) { $self->{ZipData}{CRC32} = $self->{Compress}->crc32(); } else { $self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(${$_[0]}, $self->{ZipData}{CRC32}); } } sub canonicalName { # This sub is derived from Archive::Zip::_asZipDirName # Return the normalized name as used in a zip file (path # separators become slashes, etc.). # Will translate internal slashes in path components (i.e. on Macs) to # underscores. Discards volume names. # When $forceDir is set, returns paths with trailing slashes # # input output # . '.' # ./a a # ./a/b a/b # ./a/b/ a/b # a/b/ a/b # /a/b/ a/b # c:\a\b\c.doc a/b/c.doc # on Windows # "i/o maps:whatever" i_o maps/whatever # on Macs my $name = shift; my $forceDir = shift ; my ( $volume, $directories, $file ) = File::Spec->splitpath( File::Spec->canonpath($name), $forceDir ); my @dirs = map { $_ =~ s{/}{_}g; $_ } File::Spec->splitdir($directories); if ( @dirs > 0 ) { pop (@dirs) if $dirs[-1] eq '' } # remove empty component push @dirs, defined($file) ? $file : '' ; my $normalised_path = join '/', @dirs; # Leading directory separators should not be stored in zip archives. # Example: # C:\a\b\c\ a/b/c # C:\a\b\c.txt a/b/c.txt # /a/b/c/ a/b/c # /a/b/c.txt a/b/c.txt $normalised_path =~ s{^/}{}; # remove leading separator return $normalised_path; } sub mkHeader { my $self = shift; my $param = shift ; $self->{ZipData}{LocalHdrOffset} = U64::clone($self->{ZipData}{Offset}); my $comment = ''; $comment = $param->valueOrDefault('comment') ; my $filename = ''; $filename = $param->valueOrDefault('name') ; $filename = canonicalName($filename) if length $filename && $param->getValue('canonicalname') ; if (defined $self->{ZipData}{FilterName} ) { local _ = \$filename ; &{ $self->{ZipData}{FilterName} }() ; } if ( $param->getValue('efs') && $] >= 5.008004) { if (length $filename) { utf8::downgrade($filename, 1) or Carp::croak "Wide character in zip filename"; } if (length $comment) { utf8::downgrade($comment, 1) or Carp::croak "Wide character in zip comment"; } } my $hdr = ''; my $time = _unixToDosTime($param->getValue('time')); my $extra = ''; my $ctlExtra = ''; my $empty = 0; my $osCode = $param->getValue('os_code') ; my $extFileAttr = 0 ; # This code assumes Unix. # TODO - revisit this $extFileAttr = 0100644 << 16 if $osCode == ZIP_OS_CODE_UNIX ; if ($self->{ZipData}{Zip64}) { $empty = IO::Compress::Base::Common::MAX32; my $x = ''; $x .= pack "V V", 0, 0 ; # uncompressedLength $x .= pack "V V", 0, 0 ; # compressedLength # Zip64 needs to be first in extra field to workaround a Windows Explorer Bug # See http://www.info-zip.org/phpBB3/viewtopic.php?f=3&t=440 for details $extra .= IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_ZIP64, $x); } if (! $param->getValue('minimal')) { if ($param->parsed('mtime')) { $extra .= mkExtendedTime($param->getValue('mtime'), $param->getValue('atime'), $param->getValue('ctime')); $ctlExtra .= mkExtendedTime($param->getValue('mtime')); } if ( $osCode == ZIP_OS_CODE_UNIX ) { if ( $param->getValue('want_exunixn') ) { my $ux3 = mkUnixNExtra( @{ $param->getValue('want_exunixn') }); $extra .= $ux3; $ctlExtra .= $ux3; } if ( $param->getValue('exunix2') ) { $extra .= mkUnix2Extra( @{ $param->getValue('exunix2') }); $ctlExtra .= mkUnix2Extra(); } } $extFileAttr = $param->getValue('extattr') if defined $param->getValue('extattr') ; $extra .= $param->getValue('extrafieldlocal') if defined $param->getValue('extrafieldlocal'); $ctlExtra .= $param->getValue('extrafieldcentral') if defined $param->getValue('extrafieldcentral'); } my $method = $self->{ZipData}{Method} ; my $gpFlag = 0 ; $gpFlag \|= ZIP_GP_FLAG_STREAMING_MASK if $self->{ZipData}{Stream} ; $gpFlag \|= ZIP_GP_FLAG_LZMA_EOS_PRESENT if $method == ZIP_CM_LZMA ; $gpFlag \|= ZIP_GP_FLAG_LANGUAGE_ENCODING if $param->getValue('efs') && (length($filename) \|\| length($comment)); my $version = $ZIP_CM_MIN_VERSIONS{$method}; $version = ZIP64_MIN_VERSION if ZIP64_MIN_VERSION > $version && $self->{ZipData}{Zip64}; my $madeBy = ($param->getValue('os_code') << 8) + $version; my $extract = $version; $self->{ZipData}{Version} = $version; $self->{ZipData}{MadeBy} = $madeBy; my $ifa = 0; $ifa \|= ZIP_IFA_TEXT_MASK if $param->getValue('textflag'); $hdr .= pack "V", ZIP_LOCAL_HDR_SIG ; # signature $hdr .= pack 'v', $extract ; # extract Version & OS $hdr .= pack 'v', $gpFlag ; # general purpose flag (set streaming mode) $hdr .= pack 'v', $method ; # compression method (deflate) $hdr .= pack 'V', $time ; # last mod date/time $hdr .= pack 'V', 0 ; # crc32 - 0 when streaming $hdr .= pack 'V', $empty ; # compressed length - 0 when streaming $hdr .= pack 'V', $empty ; # uncompressed length - 0 when streaming $hdr .= pack 'v', length $filename ; # filename length $hdr .= pack 'v', length $extra ; # extra length $hdr .= $filename ; # Remember the offset for the compressed & uncompressed lengths in the # local header. if ($self->{ZipData}{Zip64}) { $self->{ZipData}{SizesOffset} = $self->{ZipData}{Offset}->get64bit() + length($hdr) + 4 ; } else { $self->{ZipData}{SizesOffset} = $self->{ZipData}{Offset}->get64bit() + 18; } $hdr .= $extra ; my $ctl = ''; $ctl .= pack "V", ZIP_CENTRAL_HDR_SIG ; # signature $ctl .= pack 'v', $madeBy ; # version made by $ctl .= pack 'v', $extract ; # extract Version $ctl .= pack 'v', $gpFlag ; # general purpose flag (streaming mode) $ctl .= pack 'v', $method ; # compression method (deflate) $ctl .= pack 'V', $time ; # last mod date/time $ctl .= pack 'V', 0 ; # crc32 $ctl .= pack 'V', $empty ; # compressed length $ctl .= pack 'V', $empty ; # uncompressed length $ctl .= pack 'v', length $filename ; # filename length $self->{ZipData}{ExtraOffset} = length $ctl; $self->{ZipData}{ExtraSize} = length $ctlExtra ; $ctl .= pack 'v', length $ctlExtra ; # extra length $ctl .= pack 'v', length $comment ; # file comment length $ctl .= pack 'v', 0 ; # disk number start $ctl .= pack 'v', $ifa ; # internal file attributes $ctl .= pack 'V', $extFileAttr ; # external file attributes # offset to local hdr if ($self->{ZipData}{LocalHdrOffset}->is64bit() ) { $ctl .= pack 'V', IO::Compress::Base::Common::MAX32 ; } else { $ctl .= $self->{ZipData}{LocalHdrOffset}->getPacked_V32() ; } $ctl .= $filename ; $self->{ZipData}{Offset}->add32(length $hdr) ; $self->{ZipData}{CentralHeader} = [ $ctl, $ctlExtra, $comment]; return $hdr; } sub mkTrailer { my $self = shift ; my $crc32 ; if ($self->{ZipData}{Method} == ZIP_CM_DEFLATE) { $crc32 = pack "V", $self->{Compress}->crc32(); } else { $crc32 = pack "V", $self->{ZipData}{CRC32}; } my ($ctl, $ctlExtra, $comment) = @{ $self->{ZipData}{CentralHeader} }; my $sizes ; if (! $self->{ZipData}{Zip64}) { $sizes .= $self->{CompSize}->getPacked_V32() ; # Compressed size $sizes .= $self->{UnCompSize}->getPacked_V32() ; # Uncompressed size } else { $sizes .= $self->{CompSize}->getPacked_V64() ; # Compressed size $sizes .= $self->{UnCompSize}->getPacked_V64() ; # Uncompressed size } my $data = $crc32 . $sizes ; my $xtrasize = $self->{UnCompSize}->getPacked_V64() ; # Uncompressed size $xtrasize .= $self->{CompSize}->getPacked_V64() ; # Compressed size my $hdr = ''; if ($self->{ZipData}{Stream}) { $hdr = pack "V", ZIP_DATA_HDR_SIG ; # signature $hdr .= $data ; } else { $self->writeAt($self->{ZipData}{LocalHdrOffset}->get64bit() + 14, $crc32) or return undef; $self->writeAt($self->{ZipData}{SizesOffset}, $self->{ZipData}{Zip64} ? $xtrasize : $sizes) or return undef; } # Central Header Record/Zip64 extended field substr($ctl, 16, length $crc32) = $crc32 ; my $zip64Payload = ''; # uncompressed length - only set zip64 if needed if ($self->{UnCompSize}->isAlmost64bit()) { # \|\| $self->{ZipData}{Zip64}) { $zip64Payload .= $self->{UnCompSize}->getPacked_V64() ; } else { substr($ctl, 24, 4) = $self->{UnCompSize}->getPacked_V32() ; } # compressed length - only set zip64 if needed if ($self->{CompSize}->isAlmost64bit()) { # \|\| $self->{ZipData}{Zip64}) { $zip64Payload .= $self->{CompSize}->getPacked_V64() ; } else { substr($ctl, 20, 4) = $self->{CompSize}->getPacked_V32() ; } # Local Header offset $zip64Payload .= $self->{ZipData}{LocalHdrOffset}->getPacked_V64() if $self->{ZipData}{LocalHdrOffset}->is64bit() ; # disk no - always zero, so don't need to include it. #$zip64Payload .= pack "V", 0 ; my $zip64Xtra = ''; if (length $zip64Payload) { $zip64Xtra = IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_ZIP64, $zip64Payload); substr($ctl, $self->{ZipData}{ExtraOffset}, 2) = pack 'v', $self->{ZipData}{ExtraSize} + length $zip64Xtra; $self->{ZipData}{AnyZip64} = 1; } # Zip64 needs to be first in extra field to workaround a Windows Explorer Bug # See http://www.info-zip.org/phpBB3/viewtopic.php?f=3&t=440 for details $ctl .= $zip64Xtra . $ctlExtra . $comment; $self->{ZipData}{Offset}->add32(length($hdr)); $self->{ZipData}{Offset}->add( $self->{CompSize} ); push @{ $self->{ZipData}{CentralDir} }, $ctl ; return $hdr; } sub mkFinalTrailer { my $self = shift ; my $comment = ''; $comment = $self->{ZipData}{ZipComment} ; my $cd_offset = $self->{ZipData}{Offset}->get32bit() ; # offset to start central dir my $entries = @{ $self->{ZipData}{CentralDir} }; $self->{ZipData}{AnyZip64} = 1 if $self->{ZipData}{Offset}->is64bit \|\| $entries >= 0xFFFF ; my $cd = join '', @{ $self->{ZipData}{CentralDir} }; my $cd_len = length $cd ; my $z64e = ''; if ( $self->{ZipData}{AnyZip64} ) { my $v = $self->{ZipData}{Version} ; my $mb = $self->{ZipData}{MadeBy} ; $z64e .= pack 'v', $mb ; # Version made by $z64e .= pack 'v', $v ; # Version to extract $z64e .= pack 'V', 0 ; # number of disk $z64e .= pack 'V', 0 ; # number of disk with central dir $z64e .= U64::pack_V64 $entries ; # entries in central dir on this disk $z64e .= U64::pack_V64 $entries ; # entries in central dir $z64e .= U64::pack_V64 $cd_len ; # size of central dir $z64e .= $self->{ZipData}{Offset}->getPacked_V64() ; # offset to start central dir $z64e = pack("V", ZIP64_END_CENTRAL_REC_HDR_SIG) # signature . U64::pack_V64(length $z64e) . $z64e ; $self->{ZipData}{Offset}->add32(length $cd) ; $z64e .= pack "V", ZIP64_END_CENTRAL_LOC_HDR_SIG; # signature $z64e .= pack 'V', 0 ; # number of disk with central dir $z64e .= $self->{ZipData}{Offset}->getPacked_V64() ; # offset to end zip64 central dir $z64e .= pack 'V', 1 ; # Total number of disks $cd_offset = IO::Compress::Base::Common::MAX32 ; $cd_len = IO::Compress::Base::Common::MAX32 if IO::Compress::Base::Common::isGeMax32 $cd_len ; $entries = 0xFFFF if $entries >= 0xFFFF ; } my $ecd = ''; $ecd .= pack "V", ZIP_END_CENTRAL_HDR_SIG ; # signature $ecd .= pack 'v', 0 ; # number of disk $ecd .= pack 'v', 0 ; # number of disk with central dir $ecd .= pack 'v', $entries ; # entries in central dir on this disk $ecd .= pack 'v', $entries ; # entries in central dir $ecd .= pack 'V', $cd_len ; # size of central dir $ecd .= pack 'V', $cd_offset ; # offset to start central dir $ecd .= pack 'v', length $comment ; # zipfile comment length $ecd .= $comment; return $cd . $z64e . $ecd ; } sub ckParams { my $self = shift ; my $got = shift; $got->setValue('crc32' => 1); if (! $got->parsed('time') ) { # Modification time defaults to now. $got->setValue('time' => time) ; } if ($got->parsed('extime') ) { my $timeRef = $got->getValue('extime'); if ( defined $timeRef) { return $self->saveErrorString(undef, "exTime not a 3-element array ref") if ref $timeRef ne 'ARRAY' \|\| @$timeRef != 3; } $got->setValue("mtime", $timeRef->[1]); $got->setValue("atime", $timeRef->[0]); $got->setValue("ctime", $timeRef->[2]); } # Unix2/3 Extended Attribute for my $name (qw(exunix2 exunixn)) { if ($got->parsed($name) ) { my $idRef = $got->getValue($name); if ( defined $idRef) { return $self->saveErrorString(undef, "$name not a 2-element array ref") if ref $idRef ne 'ARRAY' \|\| @$idRef != 2; } $got->setValue("uid", $idRef->[0]); $got->setValue("gid", $idRef->[1]); $got->setValue("want_$name", $idRef); } } $self->{ZipData}{AnyZip64} = 1 if $got->getValue('zip64'); $self->{ZipData}{Zip64} = $got->getValue('zip64'); $self->{ZipData}{Stream} = $got->getValue('stream'); my $method = $got->getValue('method'); return $self->saveErrorString(undef, "Unknown Method '$method'") if ! defined $ZIP_CM_MIN_VERSIONS{$method}; return $self->saveErrorString(undef, "Bzip2 not available") if $method == ZIP_CM_BZIP2 and ! defined $IO::Compress::Adapter::Bzip2::VERSION; return $self->saveErrorString(undef, "Lzma not available") if $method == ZIP_CM_LZMA and ! defined $IO::Compress::Adapter::Lzma::VERSION; $self->{ZipData}{Method} = $method; $self->{ZipData}{ZipComment} = $got->getValue('zipcomment') ; for my $name (qw( extrafieldlocal extrafieldcentral )) { my $data = $got->getValue($name) ; if (defined $data) { my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, 1, 0) ; return $self->saveErrorString(undef, "Error with $name Parameter: $bad") if $bad ; $got->setValue($name, $data) ; } } return undef if defined $IO::Compress::Bzip2::VERSION and ! IO::Compress::Bzip2::ckParams($self, $got); if ($got->parsed('sparse') ) { $self->{ZipData}{Sparse} = $got->getValue('sparse') ; $self->{ZipData}{Method} = ZIP_CM_STORE; } if ($got->parsed('filtername')) { my $v = $got->getValue('filtername') ; $self->{ZipData}{FilterName} = $v if ref $v eq 'CODE' ; } return 1 ; } sub outputPayload { my $self = shift ; return 1 if $self->{ZipData}{Sparse} ; return $self->output(@_); } #sub newHeader #{ # my $self = shift ; # # return $self->mkHeader($self->{Got}); #} our %PARAMS = ( 'stream' => [IO::Compress::Base::Common::Parse_boolean, 1], #'store' => [IO::Compress::Base::Common::Parse_boolean, 0], 'method' => [IO::Compress::Base::Common::Parse_unsigned, ZIP_CM_DEFLATE], # # Zip header fields 'minimal' => [IO::Compress::Base::Common::Parse_boolean, 0], 'zip64' => [IO::Compress::Base::Common::Parse_boolean, 0], 'comment' => [IO::Compress::Base::Common::Parse_any, ''], 'zipcomment'=> [IO::Compress::Base::Common::Parse_any, ''], 'name' => [IO::Compress::Base::Common::Parse_any, ''], 'filtername'=> [IO::Compress::Base::Common::Parse_code, undef], 'canonicalname'=> [IO::Compress::Base::Common::Parse_boolean, 0], 'efs' => [IO::Compress::Base::Common::Parse_boolean, 0], 'time' => [IO::Compress::Base::Common::Parse_any, undef], 'extime' => [IO::Compress::Base::Common::Parse_any, undef], 'exunix2' => [IO::Compress::Base::Common::Parse_any, undef], 'exunixn' => [IO::Compress::Base::Common::Parse_any, undef], 'extattr' => [IO::Compress::Base::Common::Parse_any, $Compress::Raw::Zlib::gzip_os_code == 3 ? 0100644 << 16 : 0], 'os_code' => [IO::Compress::Base::Common::Parse_unsigned, $Compress::Raw::Zlib::gzip_os_code], 'textflag' => [IO::Compress::Base::Common::Parse_boolean, 0], 'extrafieldlocal' => [IO::Compress::Base::Common::Parse_any, undef], 'extrafieldcentral'=> [IO::Compress::Base::Common::Parse_any, undef], # Lzma 'preset' => [IO::Compress::Base::Common::Parse_unsigned, 6], 'extreme' => [IO::Compress::Base::Common::Parse_boolean, 0], # For internal use only 'sparse' => [IO::Compress::Base::Common::Parse_unsigned, 0], IO::Compress::RawDeflate::getZlibParams(), defined $IO::Compress::Bzip2::VERSION ? IO::Compress::Bzip2::getExtraParams() : () ); sub getExtraParams { return %PARAMS ; } sub getInverseClass { no warnings 'once'; return ('IO::Uncompress::Unzip', \$IO::Uncompress::Unzip::UnzipError); } sub getFileInfo { my $self = shift ; my $params = shift; my $filename = shift ; if (IO::Compress::Base::Common::isaScalar($filename)) { $params->setValue(zip64 => 1) if IO::Compress::Base::Common::isGeMax32 length (${ $filename }) ; return ; } my ($mode, $uid, $gid, $size, $atime, $mtime, $ctime) ; if ( $params->parsed('storelinks') ) { ($mode, $uid, $gid, $size, $atime, $mtime, $ctime) = (lstat($filename))[2, 4,5,7, 8,9,10] ; } else { ($mode, $uid, $gid, $size, $atime, $mtime, $ctime) = (stat($filename))[2, 4,5,7, 8,9,10] ; } $params->setValue(textflag => -T $filename ) if ! $params->parsed('textflag'); $params->setValue(zip64 => 1) if IO::Compress::Base::Common::isGeMax32 $size ; $params->setValue('name' => $filename) if ! $params->parsed('name') ; $params->setValue('time' => $mtime) if ! $params->parsed('time') ; if ( ! $params->parsed('extime')) { $params->setValue('mtime' => $mtime) ; $params->setValue('atime' => $atime) ; $params->setValue('ctime' => undef) ; # No Creation time # TODO - see if can fillout creation time on non-Unix } # NOTE - Unix specific code alert if (! $params->parsed('extattr')) { use Fcntl qw(:mode) ; my $attr = $mode << 16; $attr \|= ZIP_A_RONLY if ($mode & S_IWRITE) == 0 ; $attr \|= ZIP_A_DIR if ($mode & S_IFMT ) == S_IFDIR ; $params->setValue('extattr' => $attr); } $params->setValue('want_exunixn', [$uid, $gid]); $params->setValue('uid' => $uid) ; $params->setValue('gid' => $gid) ; } sub mkExtendedTime { # order expected is m, a, c my $times = ''; my $bit = 1 ; my $flags = 0; for my $time (@_) { if (defined $time) { $flags \|= $bit; $times .= pack("V", $time); } $bit <<= 1 ; } return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_EXT_TIMESTAMP, pack("C", $flags) . $times); } sub mkUnix2Extra { my $ids = ''; for my $id (@_) { $ids .= pack("v", $id); } return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_INFO_ZIP_UNIX2, $ids); } sub mkUnixNExtra { my $uid = shift; my $gid = shift; # Assumes UID/GID are 32-bit my $ids ; $ids .= pack "C", 1; # version $ids .= pack "C", $Config{uidsize}; $ids .= pack "V", $uid; $ids .= pack "C", $Config{gidsize}; $ids .= pack "V", $gid; return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_INFO_ZIP_UNIXN, $ids); } # from Archive::Zip sub _unixToDosTime # Archive::Zip::Member { my $time_t = shift; # TODO - add something to cope with unix time < 1980 my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time_t); my $dt = 0; $dt += ( $sec >> 1 ); $dt += ( $min << 5 ); $dt += ( $hour << 11 ); $dt += ( $mday << 16 ); $dt += ( ( $mon + 1 ) << 21 ); $dt += ( ( $year - 80 ) << 25 ); return $dt; } 1; __END__ =head1 NAME IO::Compress::Zip - Write zip files/buffers =head1 SYNOPSIS use IO::Compress::Zip qw(zip $ZipError) ; my $status = zip $input => $output [,OPTS] or die "zip failed: $ZipError\n"; my $z = IO::Compress::Zip->new( $output [,OPTS] ) or die "zip failed: $ZipError\n"; $z->print($string); $z->printf($format, $string); $z->write($string); $z->syswrite($string [, $length, $offset]); $z->flush(); $z->tell(); $z->eof(); $z->seek($position, $whence); $z->binmode(); $z->fileno(); $z->opened(); $z->autoflush(); $z->input_line_number(); $z->newStream( [OPTS] ); $z->deflateParams(); $z->close() ; $ZipError ; # IO::File mode print $z $string; printf $z $format, $string; tell $z eof $z seek $z, $position, $whence binmode $z fileno $z close $z ; =head1 DESCRIPTION This module provides a Perl interface that allows writing zip compressed data to files or buffer. The primary purpose of this module is to provide streaming write access to zip files and buffers. At present the following compression methods are supported by IO::Compress::Zip =over 5 =item Store (0) =item Deflate (8) =item Bzip2 (12) To write Bzip2 content, the module C<IO::Uncompress::Bunzip2> must be installed. =item Lzma (14) To write LZMA content, the module C<IO::Uncompress::UnLzma> must be installed. =item Zstandard (93) To write Zstandard content, the module C<IO::Compress::Zstd> must be installed. =item Xz (95) To write Xz content, the module C<IO::Uncompress::UnXz> must be installed. =back For reading zip files/buffers, see the companion module L<IO::Uncompress::Unzip\|IO::Uncompress::Unzip>. =head1 Functional Interface A top-level function, C<zip>, is provided to carry out "one-shot" compression between buffers and/or files. For finer control over the compression process, see the L</"OO Interface"> section. use IO::Compress::Zip qw(zip $ZipError) ; zip $input_filename_or_reference => $output_filename_or_reference [,OPTS] or die "zip failed: $ZipError\n"; The functional interface needs Perl5.005 or better. =head2 zip $input_filename_or_reference => $output_filename_or_reference [, OPTS] C<zip> expects at least two parameters, C<$input_filename_or_reference> and C<$output_filename_or_reference> and zero or more optional parameters (see L</Optional Parameters>) =head3 The C<$input_filename_or_reference> parameter The parameter, C<$input_filename_or_reference>, is used to define the source of the uncompressed data. It can take one of the following forms: =over 5 =item A filename If the C<$input_filename_or_reference> parameter is a simple scalar, it is assumed to be a filename. This file will be opened for reading and the input data will be read from it. =item A filehandle If the C<$input_filename_or_reference> parameter is a filehandle, the input data will be read from it. The string '-' can be used as an alias for standard input. =item A scalar reference If C<$input_filename_or_reference> is a scalar reference, the input data will be read from C<$$input_filename_or_reference>. =item An array reference If C<$input_filename_or_reference> is an array reference, each element in the array must be a filename. The input data will be read from each file in turn. The complete array will be walked to ensure that it only contains valid filenames before any data is compressed. =item An Input FileGlob string If C<$input_filename_or_reference> is a string that is delimited by the characters "<" and ">" C<zip> will assume that it is an I<input fileglob string>. The input is the list of files that match the fileglob. See L<File::GlobMapper\|File::GlobMapper> for more details. =back If the C<$input_filename_or_reference> parameter is any other type, C<undef> will be returned. In addition, if C<$input_filename_or_reference> is a simple filename, the default values for the C<Name>, C<Time>, C<TextFlag>, C<ExtAttr>, C<exUnixN> and C<exTime> options will be sourced from that file. If you do not want to use these defaults they can be overridden by explicitly setting the C<Name>, C<Time>, C<TextFlag>, C<ExtAttr>, C<exUnixN> and C<exTime> options or by setting the C<Minimal> parameter. =head3 The C<$output_filename_or_reference> parameter The parameter C<$output_filename_or_reference> is used to control the destination of the compressed data. This parameter can take one of these forms. =over 5 =item A filename If the C<$output_filename_or_reference> parameter is a simple scalar, it is assumed to be a filename. This file will be opened for writing and the compressed data will be written to it. =item A filehandle If the C<$output_filename_or_reference> parameter is a filehandle, the compressed data will be written to it. The string '-' can be used as an alias for standard output. =item A scalar reference If C<$output_filename_or_reference> is a scalar reference, the compressed data will be stored in C<$$output_filename_or_reference>. =item An Array Reference If C<$output_filename_or_reference> is an array reference, the compressed data will be pushed onto the array. =item An Output FileGlob If C<$output_filename_or_reference> is a string that is delimited by the characters "<" and ">" C<zip> will assume that it is an I<output fileglob string>. The output is the list of files that match the fileglob. When C<$output_filename_or_reference> is an fileglob string, C<$input_filename_or_reference> must also be a fileglob string. Anything else is an error. See L<File::GlobMapper\|File::GlobMapper> for more details. =back If the C<$output_filename_or_reference> parameter is any other type, C<undef> will be returned. =head2 Notes When C<$input_filename_or_reference> maps to multiple files/buffers and C<$output_filename_or_reference> is a single file/buffer the input files/buffers will each be stored in C<$output_filename_or_reference> as a distinct entry. =head2 Optional Parameters The optional parameters for the one-shot function C<zip> are (for the most part) identical to those used with the OO interface defined in the L</"Constructor Options"> section. The exceptions are listed below =over 5 =item C<< AutoClose => 0\|1 >> This option applies to any input or output data streams to C<zip> that are filehandles. If C<AutoClose> is specified, and the value is true, it will result in all input and/or output filehandles being closed once C<zip> has completed. This parameter defaults to 0. =item C<< BinModeIn => 0\|1 >> This option is now a no-op. All files will be read in binmode. =item C<< Append => 0\|1 >> The behaviour of this option is dependent on the type of output data stream. =over 5 =item A Buffer If C<Append> is enabled, all compressed data will be append to the end of the output buffer. Otherwise the output buffer will be cleared before any compressed data is written to it. =item * A Filename If C<Append> is enabled, the file will be opened in append mode. Otherwise the contents of the file, if any, will be truncated before any compressed data is written to it. =item * A Filehandle If C<Append> is enabled, the filehandle will be positioned to the end of the file via a call to C<seek> before any compressed data is written to it. Otherwise the file pointer will not be moved. =back When C<Append> is specified, and set to true, it will I<append> all compressed data to the output data stream. So when the output is a filehandle it will carry out a seek to the eof before writing any compressed data. If the output is a filename, it will be opened for appending. If the output is a buffer, all compressed data will be appended to the existing buffer. Conversely when C<Append> is not specified, or it is present and is set to false, it will operate as follows. When the output is a filename, it will truncate the contents of the file before writing any compressed data. If the output is a filehandle its position will not be changed. If the output is a buffer, it will be wiped before any compressed data is output. Defaults to 0. =back =head2 Examples Here are a few example that show the capabilities of the module. =head3 Streaming This very simple command line example demonstrates the streaming capabilities of the module. The code reads data from STDIN, compresses it, and writes the compressed data to STDOUT. $ echo hello world \| perl -MIO::Compress::Zip=zip -e 'zip \STDIN => \STDOUT' >output.zip The special filename "-" can be used as a standin for both C<\STDIN> and C<\STDOUT>, so the above can be rewritten as $ echo hello world \| perl -MIO::Compress::Zip=zip -e 'zip "-" => "-"' >output.zip One problem with creating a zip archive directly from STDIN can be demonstrated by looking at the contents of the zip file, output.zip, that we have just created. $ unzip -l output.zip Archive: output.zip Length Date Time Name --------- ---------- ----- ---- 12 2019-08-16 22:21 --------- ------- 12 1 file The archive member (filename) used is the empty string. If that doesn't suit your needs, you can explicitly set the filename used in the zip archive by specifying the L<Name\|"File Naming Options"> option, like so echo hello world \| perl -MIO::Compress::Zip=zip -e 'zip "-" => "-", Name => "hello.txt"' >output.zip Now the contents of the zip file looks like this $ unzip -l output.zip Archive: output.zip Length Date Time Name --------- ---------- ----- ---- 12 2019-08-16 22:22 hello.txt --------- ------- 12 1 file =head3 Compressing a file from the filesystem To read the contents of the file C<file1.txt> and write the compressed data to the file C<file1.txt.zip>. use strict ; use warnings ; use IO::Compress::Zip qw(zip $ZipError) ; my $input = "file1.txt"; zip $input => "$input.zip" or die "zip failed: $ZipError\n"; =head3 Reading from a Filehandle and writing to an in-memory buffer To read from an existing Perl filehandle, C<$input>, and write the compressed data to a buffer, C<$buffer>. use strict ; use warnings ; use IO::Compress::Zip qw(zip $ZipError) ; use IO::File ; my $input = IO::File->new( "<file1.txt" ) or die "Cannot open 'file1.txt': $!\n" ; my $buffer ; zip $input => \$buffer or die "zip failed: $ZipError\n"; =head3 Compressing multiple files To create a zip file, C<output.zip>, that contains the compressed contents of the files C<alpha.txt> and C<beta.txt> use strict ; use warnings ; use IO::Compress::Zip qw(zip $ZipError) ; zip [ 'alpha.txt', 'beta.txt' ] => 'output.zip' or die "zip failed: $ZipError\n"; Alternatively, rather than having to explicitly name each of the files that you want to compress, you could use a fileglob to select all the C<txt> files in the current directory, as follows use strict ; use warnings ; use IO::Compress::Zip qw(zip $ZipError) ; my @files = <.txt>; zip \@files => 'output.zip' or die "zip failed: $ZipError\n"; or more succinctly zip [ <.txt> ] => 'output.zip' or die "zip failed: $ZipError\n"; =head1 OO Interface =head2 Constructor The format of the constructor for C<IO::Compress::Zip> is shown below my $z = IO::Compress::Zip->new( $output [,OPTS] ) or die "IO::Compress::Zip failed: $ZipError\n"; It returns an C<IO::Compress::Zip> object on success and undef on failure. The variable C<$ZipError> will contain an error message on failure. If you are running Perl 5.005 or better the object, C<$z>, returned from IO::Compress::Zip can be used exactly like an L<IO::File\|IO::File> filehandle. This means that all normal output file operations can be carried out with C<$z>. For example, to write to a compressed file/buffer you can use either of these forms $z->print("hello world\n"); print $z "hello world\n"; The mandatory parameter C<$output> is used to control the destination of the compressed data. This parameter can take one of these forms. =over 5 =item A filename If the C<$output> parameter is a simple scalar, it is assumed to be a filename. This file will be opened for writing and the compressed data will be written to it. =item A filehandle If the C<$output> parameter is a filehandle, the compressed data will be written to it. The string '-' can be used as an alias for standard output. =item A scalar reference If C<$output> is a scalar reference, the compressed data will be stored in C<$$output>. =back If the C<$output> parameter is any other type, C<IO::Compress::Zip>::new will return undef. =head2 Constructor Options C<OPTS> is any combination of zero or more the following options: =over 5 =item C<< AutoClose => 0\|1 >> This option is only valid when the C<$output> parameter is a filehandle. If specified, and the value is true, it will result in the C<$output> being closed once either the C<close> method is called or the C<IO::Compress::Zip> object is destroyed. This parameter defaults to 0. =item C<< Append => 0\|1 >> Opens C<$output> in append mode. The behaviour of this option is dependent on the type of C<$output>. =over 5 =item * A Buffer If C<$output> is a buffer and C<Append> is enabled, all compressed data will be append to the end of C<$output>. Otherwise C<$output> will be cleared before any data is written to it. =item * A Filename If C<$output> is a filename and C<Append> is enabled, the file will be opened in append mode. Otherwise the contents of the file, if any, will be truncated before any compressed data is written to it. =item * A Filehandle If C<$output> is a filehandle, the file pointer will be positioned to the end of the file via a call to C<seek> before any compressed data is written to it. Otherwise the file pointer will not be moved. =back This parameter defaults to 0. =back =head3 File Naming Options A quick bit of zip file terminology -- A zip archive consists of one or more I<archive members>, where each member has an associated filename, known as the I<archive member name>. The options listed in this section control how the I<archive member name> (or filename) is stored the zip archive. =over 5 =item C<< Name => $string >> This option is used to explicitly set the I<archive member name> in the zip archive to C<$string>. Most of the time you don't need to make use of this option. By default when adding a filename to the zip archive, the I<archive member name> will match the filename. You should only need to use this option if you want the I<archive member name> to be different from the uncompressed filename or when the input is a filehandle or a buffer. The default behaviour for what I<archive member name> is used when the C<Name> option is I<not> specified depends on the form of the C<$input> parameter: =over 5 =item * If the C<$input> parameter is a filename, the value of C<$input> will be used for the I<archive member name> . =item * If the C<$input> parameter is not a filename, the I<archive member name> will be an empty string. =back Note that both the C<CanonicalName> and C<FilterName> options can modify the value used for the I<archive member name>. Also note that you should set the C<Efs> option to true if you are working with UTF8 filenames. =item C<< CanonicalName => 0\|1 >> This option controls whether the I<archive member name> is I<normalized> into Unix format before being written to the zip file. It is recommended that you enable this option unless you really need to create a non-standard Zip file. This is what APPNOTE.TXT has to say on what should be stored in the zip filename header field. The name of the file, with optional relative path. The path stored should not contain a drive or device letter, or a leading slash. All slashes should be forward slashes '/' as opposed to backwards slashes '\' for compatibility with Amiga and UNIX file systems etc. This option defaults to B<false>. =item C<< FilterName => sub { ... } >> This option allow the I<archive member> name to be modified before it is written to the zip file. This option takes a parameter that must be a reference to a sub. On entry to the sub the C<$_> variable will contain the name to be filtered. If no filename is available C<$_> will contain an empty string. The value of C<$_> when the sub returns will be used as the I<archive member name>. Note that if C<CanonicalName> is enabled, a normalized filename will be passed to the sub. If you use C<FilterName> to modify the filename, it is your responsibility to keep the filename in Unix format. Although this option can be used with the OO interface, it is of most use with the one-shot interface. For example, the code below shows how C<FilterName> can be used to remove the path component from a series of filenames before they are stored in C<$zipfile>. sub compressTxtFiles { my $zipfile = shift ; my $dir = shift ; zip [ <$dir/*.txt> ] => $zipfile, FilterName => sub { s[^$dir/][] } ; } =item C<< Efs => 0\|1 >> This option controls setting of the "Language Encoding Flag" (EFS) in the zip archive. When set, the filename and comment fields for the zip archive MUST be valid UTF-8. If the string used for the filename and/or comment is not valid UTF-8 when this option is true, the script will die with a "wide character" error. Note that this option only works with Perl 5.8.4 or better. This option defaults to B<false>. =back =head3 Overall Zip Archive Structure =over 5 =item C<< Minimal => 1\|0 >> If specified, this option will disable the creation of all extra fields in the zip local and central headers. So the C<exTime>, C<exUnix2>, C<exUnixN>, C<ExtraFieldLocal> and C<ExtraFieldCentral> options will be ignored. This parameter defaults to 0. =item C<< Stream => 0\|1 >> This option controls whether the zip file/buffer output is created in streaming mode. Note that when outputting to a file with streaming mode disabled (C<Stream> is 0), the output file must be seekable. The default is 1. =item C<< Zip64 => 0\|1 >> Create a Zip64 zip file/buffer. This option is used if you want to store files larger than 4 Gig or store more than 64K files in a single zip archive. C<Zip64> will be automatically set, as needed, if working with the one-shot interface when the input is either a filename or a scalar reference. If you intend to manipulate the Zip64 zip files created with this module using an external zip/unzip, make sure that it supports Zip64. In particular, if you are using Info-Zip you need to have zip version 3.x or better to update a Zip64 archive and unzip version 6.x to read a zip64 archive. The default is 0. =back =head3 Deflate Compression Options =over 5 =item -Level Defines the compression level used by zlib. The value should either be a number between 0 and 9 (0 means no compression and 9 is maximum compression), or one of the symbolic constants defined below. Z_NO_COMPRESSION Z_BEST_SPEED Z_BEST_COMPRESSION Z_DEFAULT_COMPRESSION The default is Z_DEFAULT_COMPRESSION. Note, these constants are not imported by C<IO::Compress::Zip> by default. use IO::Compress::Zip qw(:strategy); use IO::Compress::Zip qw(:constants); use IO::Compress::Zip qw(:all); =item -Strategy Defines the strategy used to tune the compression. Use one of the symbolic constants defined below. Z_FILTERED Z_HUFFMAN_ONLY Z_RLE Z_FIXED Z_DEFAULT_STRATEGY The default is Z_DEFAULT_STRATEGY. =back =head3 Bzip2 Compression Options =over 5 =item C<< BlockSize100

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0 | proxy | phpinfo | ???????????