IO-Compress
view release on metacpan or search on metacpan
2002d4fd3b3a6f5de6c6c3dc5989cf42581c1758
* Changes for zlib-ng
Thu Jun 23 22:43:50 2022 +0100
2bd52d2918823cc567c3e92dd3d15f87cb4ee8f8
* Add perl 5.36
Sun Jun 5 13:34:18 2022 +0100
ede55370ed4c7eb3c66abc71bc25c7e4019b4c44
* force streaming zip file when writing to stdout https://github.com/pmqs/IO-Compress/issues/42
Sun Apr 24 19:43:19 2022 +0100
b57a3f83f404f5a24242680de5b406cfcf5c03ac
* read zip timestamp in localtime
Sun Apr 24 13:11:58 2022 +0100
0c838f43dc46f292714c82145c9add9932196b01
* streamzip: tighten up version tests for failing windows tests https://github.com/pmqs/IO-Compress/issues/41
Sun Apr 24 12:49:57 2022 +0100
3497645228235ea12c4d559d6dedd4cef47fc94a
[RT# 48350]
- Fixed minor typo in an error message.
[RT# 39719]
* Makefile.PL
The PREREQ_PM dependency on Scalar::Util got dropped when
IO-Compress was created in 2.017.
[RT# 47509]
* IO::Compress::Zip.pm
- Removed restriction that zip64 is only supported in streaming
mode.
- The "version made by" and "extract" fields in the zip64 end
central record were swapped.
- In the End Central Header record the "offset to the start of the
central directory" will now always be set to 0xFFFFFFFF when
zip64 is enabled.
- In the End Central Header record the "total entries in the
central directory" field will be set to 0xFFFF if zip64 is
enabled AND there are more than 0xFFFF entries present.
bin/streamzip view on Meta::CPAN
Usage()
if @ARGV;
my @extraOpts = ();
if ($compression_method == ZIP_CM_DEFLATE && defined $level)
{
push @extraOpts, (Level => $level)
}
# force streaming zip file when writing to stdout.
$stream = 1
if $zipfile eq '-';
zip '-' => $zipfile,
Name => $memberName,
Zip64 => $zip64,
Method => $compression_method,
Stream => $stream,
@extraOpts
or die "Error creating zip file '$zipfile': $\n" ;
bin/streamzip view on Meta::CPAN
producer | streamzip [opts] | consumer
producer | streamzip [opts] -zipfile=output.zip
=head1 DESCRIPTION
This program will read data from C<stdin>, compress it into a zip container
and, by default, write a I<streamed> zip file to C<stdout>. No temporary
files are created.
The zip container written to C<stdout> is, by necessity, written in
streaming format. Most programs that read Zip files can cope with a
streamed zip file, but if interoperability is important, and your workflow
allows you to write the zip file directly to disk you can create a
non-streamed zip file using the C<zipfile> option.
=head2 OPTIONS
=over 5
=item -zip64
bin/zipdetails view on Meta::CPAN
}
}
if(defined($lastHeader->{'payloadOutput'}) && ($lastEndsAt = BadlyFormedDataDescriptor($lastHeader, $delta)))
{
$HeaderOffsetIndex->rewindIndex();
$lastHeader->{entry}->readDataDescriptor(1) ;
next;
}
# Assume we have the payload when streaming is enabled
outSomeData($delta, "PAYLOAD", $opt_Redact) ;
$lastHeader->{'payloadOutput'} = 1;
$lastEndsAt = $FH->tell();
next;
}
elsif (Signatures::isCentralHeader($s) && $foundCentralHeader == 0)
{
# check for an APK header directly before the first central header
$foundCentralHeader = 1;
bin/zipdetails view on Meta::CPAN
$FH->seek($OFFSET + 4, SEEK_SET) ;
$signature = $expectedSignature;
$buffer = $expectedBuffer ;
}
# If get here then $here is less than $expectedOffset
# check for an APK header directly before the first central header
# Make sure not to miss a streaming data descriptor
if ($signature != ZIP_DATA_HDR_SIG && Signatures::isCentralHeader($expectedSignature) && $START_APK && ! $processedAPK )
{
seekTo($here+4);
# rewindRelative(4);
scanApkBlock();
$HeaderOffsetIndex->rewindIndex();
$processedAPK = 1;
next;
}
bin/zipdetails view on Meta::CPAN
['uncompressedSize', 24, 'Uncompressed Size', \&decimalHex0xUndef, ],
] ;
my $table = new SimpleTable;
$table->addHeaderRow('Field Name', 'Central Offset', 'Central Value', 'Local Offset', 'Local Value');
for my $data (@$fields)
{
my ($field, $offset, $name, $stringify) = @$data;
# if the local header uses streaming and we are running a scan/walk, the compressed/uncompressed sizes will not be known
my $localValue = $localEntry->{$field} ;
my $centralValue = $centralEntry->{$field};
if (($localValue // '-1') ne ($centralValue // '-2'))
{
if ($stringify)
{
$localValue = $stringify->($localValue);
$centralValue = $stringify->($centralValue);
}
bin/zipdetails view on Meta::CPAN
my $extractVer = out_C "Extract Zip Spec", \&decodeZipVer;
out_C "Extract OS", \&decodeOS;
my ($bgp, $gpFlag) = read_v();
my ($bcm, $compressedMethod) = read_v();
out $bgp, "General Purpose Flag", Value_v($gpFlag) ;
GeneralPurposeBits($compressedMethod, $gpFlag);
my $LanguageEncodingFlag = $gpFlag & ZIP_GP_FLAG_LANGUAGE_ENCODING ;
my $streaming = $gpFlag & ZIP_GP_FLAG_STREAMING_MASK ;
$localEntry->languageEncodingFlag($LanguageEncodingFlag) ;
out $bcm, "Compression Method", compressionMethod($compressedMethod) ;
info $FH->tell() - 2, "Unknown 'Compression Method' ID " . decimalHex0x($compressedMethod, 2)
if ! defined $ZIP_CompressionMethods{$compressedMethod} ;
my $lastMod = out_V "Modification Time", sub { LastModTime($_[0]) };
my $crc = out_V "CRC";
warning $FH->tell() - 4, "CRC field should be zero when streaming is enabled"
if $streaming && $crc != 0 ;
my $compressedSize = out_V "Compressed Size";
# warning $FH->tell(), "Compressed Size should be zero when streaming is enabled";
my $uncompressedSize = out_V "Uncompressed Size";
# warning $FH->tell(), "Uncompressed Size should be zero when streaming is enabled";
my $filenameLength = out_v "Filename Length";
if ($filenameLength == 0)
{
info $FH->tell()- 2, "Zero Length filename";
}
my $extraLength = out_v "Extra Length";
bin/zipdetails view on Meta::CPAN
$localEntry->std_diskNumber(0) ;
if ($extraLength)
{
need $extraLength, Signatures::name($signature), 'Extra';
walkExtra($extraLength, $localEntry);
}
# APPNOTE 6.3.10, sec 4.3.8
warning $FH->tell - $filenameLength, "Directory '$filename' must not have a payload"
if ! $streaming && $filename =~ m#/$# && $localEntry->uncompressedSize ;
my @msg ;
# if ($cdZip64 && ! $ZIP64)
# {
# # Central directory said this was Zip64
# # some zip files don't have the Zip64 field in the local header
# # seems to be a streaming issue.
# push @msg, "Missing Zip64 extra field in Local Header #$hexHdrCount\n";
# if (! $zip64Sizes)
# {
# # Central has a ZIP64 entry that doesn't have sizes
# # Local doesn't have a Zip 64 at all
# push @msg, "Unzip may complain about 'overlapped components' #$hexHdrCount\n";
# }
# else
# {
bin/zipdetails view on Meta::CPAN
my $compressedSize;
my $uncompressedSize;
my $localEntry = $LocalDirectory->lastStreamedEntryAdded();
my $centralEntry = $localEntry && $localEntry->getCdEntry ;
if (!$localEntry)
{
# found a Data Descriptor without a local header
out "", "Skipping Data Descriptor", "No matching Local header with streaming bit set";
error $here - 4, "Orphan '$sigName' found", "No matching Local header with streaming bit set";
return {};
}
my $crc = out_V "CRC";
my $payloadLength = $here - 4 - $localEntry->payloadOffset;
my $deltaToNext = deltaToNextSignature();
my $cl32 = unpack "V", peekAtOffset($here + 4, 4);
my $cl64 = unpack "Q<", peekAtOffset($here + 4, 8);
lib/IO/Compress/Bzip2.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot 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::Bzip2=bzip2 -e 'bzip2 \*STDIN => \*STDOUT' >output.bz2
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::Bzip2=bzip2 -e 'bzip2 "-" => "-"' >output.bz2
=head3 Compressing a file from the filesystem
lib/IO/Compress/Bzip2.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Bzip2 qw(bzip2 $Bzip2Error) ;
my $z = IO::Compress::Bzip2->new("-", Stream => 1)
or die "IO::Compress::Bzip2 failed: $Bzip2Error\n";
lib/IO/Compress/Deflate.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot 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::Deflate=deflate -e 'deflate \*STDIN => \*STDOUT' >output.1950
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::Deflate=deflate -e 'deflate "-" => "-"' >output.1950
=head3 Compressing a file from the filesystem
lib/IO/Compress/Deflate.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Deflate qw(deflate $DeflateError) ;
my $z = IO::Compress::Deflate->new("-", Stream => 1)
or die "IO::Compress::Deflate failed: $DeflateError\n";
lib/IO/Compress/Gzip.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot 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::Gzip=gzip -e 'gzip \*STDIN => \*STDOUT' >output.gz
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::Gzip=gzip -e 'gzip "-" => "-"' >output.gz
=head3 Compressing a file from the filesystem
lib/IO/Compress/Gzip.pm view on Meta::CPAN
The ID header in an C<ExtraField> sub-field can consist of any two bytes.
=back
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Gzip qw(gzip $GzipError) ;
my $z = IO::Compress::Gzip->new("-", Stream => 1)
or die "IO::Compress::Gzip failed: $GzipError\n";
lib/IO/Compress/RawDeflate.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot 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::RawDeflate=rawdeflate -e 'rawdeflate \*STDIN => \*STDOUT' >output.1951
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::RawDeflate=rawdeflate -e 'rawdeflate "-" => "-"' >output.1951
=head3 Compressing a file from the filesystem
lib/IO/Compress/RawDeflate.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::RawDeflate qw(rawdeflate $RawDeflateError) ;
my $z = IO::Compress::RawDeflate->new("-", Stream => 1)
or die "IO::Compress::RawDeflate failed: $RawDeflateError\n";
lib/IO/Compress/Zip.pm view on Meta::CPAN
*$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 ;
lib/IO/Compress/Zip.pm view on Meta::CPAN
}
$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 ;
lib/IO/Compress/Zip.pm view on Meta::CPAN
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)
lib/IO/Compress/Zip.pm view on Meta::CPAN
Defaults to 0.
=back
=head2 Oneshot 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
lib/IO/Compress/Zip.pm view on Meta::CPAN
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.
lib/IO/Compress/Zip.pm view on Meta::CPAN
=item C<< Strict => 0|1 >>
This is a placeholder option.
=back
=head2 Examples
=head3 Streaming
This very simple command line example demonstrates the streaming capabilities
of the module. The code reads data from STDIN or all the files given on the
commandline, compresses it, and writes the compressed data to STDOUT.
use strict ;
use warnings ;
use IO::Compress::Zip qw(zip $ZipError) ;
my $z = IO::Compress::Zip->new("-", Stream => 1)
or die "IO::Compress::Zip failed: $ZipError\n";
lib/IO/Uncompress/Adapter/Identity.pm view on Meta::CPAN
use IO::Compress::Zip::Constants ;
our ($VERSION);
$VERSION = '2.213';
use Compress::Raw::Zlib 2.213 ();
sub mkUncompObject
{
my $streaming = shift;
my $zip64 = shift;
my $crc32 = 1; #shift ;
my $adler32 = shift;
bless { 'CompSize' => U64->new(), # 0,
'UnCompSize' => 0,
'wantCRC32' => $crc32,
'CRC32' => Compress::Raw::Zlib::crc32(''),
'wantADLER32'=> $adler32,
'ADLER32' => Compress::Raw::Zlib::adler32(''),
'ConsumesInput' => 1,
'Streaming' => $streaming,
'Zip64' => $zip64,
'DataHdrSize' => $zip64 ? 24 : 16,
'Pending' => '',
} ;
}
sub uncompr
{
lib/IO/Uncompress/Unzip.pm view on Meta::CPAN
my $filename_length = unpack ("v", substr($buffer, 26-4, 2));
my $extra_length = unpack ("v", substr($buffer, 28-4, 2));
my $filename;
my $extraField;
my @EXTRA = ();
# Some programs (some versions of LibreOffice) mark entries as streamed, but still fill out
# compressedLength/uncompressedLength & crc32 in the local file header.
# The expected data descriptor is not populated.
# So only assume streaming if the Streaming bit is set AND the compressed length is zero
my $streamingMode = (($gpFlag & ZIP_GP_FLAG_STREAMING_MASK) && $crc32 == 0) ? 1 : 0 ;
my $efs_flag = ($gpFlag & ZIP_GP_FLAG_LANGUAGE_ENCODING) ? 1 : 0;
return $self->HeaderError("Encrypted content not supported")
if $gpFlag & (ZIP_GP_FLAG_ENCRYPTED_MASK|ZIP_GP_FLAG_STRONG_ENCRYPTED_MASK);
return $self->HeaderError("Patch content not supported")
if $gpFlag & ZIP_GP_FLAG_PATCHED_MASK;
*$self->{ZipData}{Streaming} = $streamingMode;
if ($filename_length)
{
$self->smartReadExact(\$filename, $filename_length)
or return $self->TruncatedHeader("Filename");
if (*$self->{UnzipData}{efs} && $efs_flag && $] >= 5.008004)
{
require Encode;
lib/IO/Uncompress/Unzip.pm view on Meta::CPAN
if (defined $Extra{ZIP_EXTRA_ID_ZIP64()})
{
$zip64 = 1 ;
my $buff = ${ $Extra{ZIP_EXTRA_ID_ZIP64()} };
# This code assumes that all the fields in the Zip64
# extra field aren't necessarily present. The spec says that
# they only exist if the equivalent local headers are -1.
if (! $streamingMode) {
my $offset = 0 ;
if (U64::full32 $uncompressedLength->get32bit() ) {
$uncompressedLength
= U64::newUnpack_V64 substr($buff, 0, 8);
$offset += 8 ;
}
if (U64::full32 $compressedLength->get32bit() ) {
lib/IO/Uncompress/Unzip.pm view on Meta::CPAN
= U64::newUnpack_V64 substr($buff, $offset, 8);
$offset += 8 ;
}
}
}
}
*$self->{ZipData}{Zip64} = $zip64;
if (! $streamingMode) {
*$self->{ZipData}{Streaming} = 0;
*$self->{ZipData}{Crc32} = $crc32;
*$self->{ZipData}{CompressedLen} = $compressedLength;
*$self->{ZipData}{UnCompressedLen} = $uncompressedLength;
*$self->{CompressedInputLengthRemaining} =
*$self->{CompressedInputLength} = $compressedLength->get64bit();
}
*$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32(undef);
*$self->{ZipData}{Method} = $compressedMethod;
lib/IO/Uncompress/Unzip.pm view on Meta::CPAN
$self->smartReadExact(\$LzmaHeader, 4)
or return $self->saveErrorString(undef, "Truncated file");
my ($verHi, $verLo) = unpack ("CC", substr($LzmaHeader, 0, 2));
my $LzmaPropertiesSize = unpack ("v", substr($LzmaHeader, 2, 2));
my $LzmaPropertyData;
$self->smartReadExact(\$LzmaPropertyData, $LzmaPropertiesSize)
or return $self->saveErrorString(undef, "Truncated file");
if (! $streamingMode) {
*$self->{ZipData}{CompressedLen}->subtract(4 + $LzmaPropertiesSize) ;
*$self->{CompressedInputLengthRemaining} =
*$self->{CompressedInputLength} = *$self->{ZipData}{CompressedLen}->get64bit();
}
my $obj =
IO::Uncompress::Adapter::UnLzma::mkUncompZipObject($LzmaPropertyData);
*$self->{Uncomp} = $obj;
}
elsif ($compressedMethod == ZIP_CM_STORE)
{
*$self->{Type} = 'zip-stored';
my $obj =
IO::Uncompress::Adapter::Identity::mkUncompObject($streamingMode,
$zip64);
*$self->{Uncomp} = $obj;
}
else
{
return $self->HeaderError("Unsupported Compression format $compressedMethod");
}
return {
'Type' => 'zip',
'FingerprintLength' => 4,
#'HeaderLength' => $compressedMethod == 8 ? length $keep : 0,
'HeaderLength' => length $keep,
'Zip64' => $zip64,
'TrailerLength' => ! $streamingMode ? 0 : $zip64 ? 24 : 16,
'Header' => $keep,
'CompressedLength' => $compressedLength ,
'UncompressedLength' => $uncompressedLength ,
'CRC32' => $crc32 ,
'Name' => $filename,
'efs' => $efs_flag, # language encoding flag
'Time' => _dosToUnixTime($lastModTime),
'Stream' => $streamingMode,
'MethodID' => $compressedMethod,
'MethodName' => $MethodNames{$compressedMethod} || 'Unknown',
# 'TextFlag' => $flag & GZIP_FLG_FTEXT ? 1 : 0,
# 'HeaderCRCFlag' => $flag & GZIP_FLG_FHCRC ? 1 : 0,
# 'NameFlag' => $flag & GZIP_FLG_FNAME ? 1 : 0,
# 'CommentFlag' => $flag & GZIP_FLG_FCOMMENT ? 1 : 0,
# 'ExtraFlag' => $flag & GZIP_FLG_FEXTRA ? 1 : 0,
# 'Comment' => $comment,
lib/IO/Uncompress/Unzip.pm view on Meta::CPAN
eof($z)
close($z)
=head1 DESCRIPTION
This module provides a Perl interface that allows the reading of
zlib files/buffers.
For writing zip files/buffers, see the companion module IO::Compress::Zip.
The primary purpose of this module is to provide I<streaming> read access to
zip files and buffers.
At present the following compression methods are supported by IO::Uncompress::Unzip
=over 5
=item Store (0)
=item Deflate (8)
t/011-streamzip.t view on Meta::CPAN
{
no warnings;
eval { require IO::Compress::Xz && defined &{ 'IO::Compress::Adapter::Xz::mkRawZipCompObject' }} ;
skip "Method 'xz' needs IO::Compress::Xz\n", 8
if $@;
}
{
title "streamzip method $method" ;
skip "streaming unzip not supported with zstd\n", 7
if $method eq 'zstd' ;
my ($infile, $outfile);
my $lex = LexFile->new( $infile, $outfile );
writeFile($infile, $hello1) ;
check "$Perl ${binDir}/streamzip -method $method <$infile >$outfile";
my $uncompressed ;
unzip $outfile => \$uncompressed;
t/105oneshot-zip-only.t view on Meta::CPAN
}
}
}
}
my $ebcdic_skip_msg = "Input file is in an alien character set";
SKIP: {
skip $ebcdic_skip_msg, 3 if ord "A" != 65;
title "Regression: ods streaming issue";
# To execute this test on a non-ASCII machine, we could open the zip file
# without using the Name parameter, or xlate the parameter to ASCII, and
# also xlate the contents to native.
# The file before meta.xml in test.ods is content.xml.
# Issue was triggered because content.xml was stored
# as streamed and the code to walk the compressed streaming
# content assumed that all of the input buffer was consumed
# in a single call to "uncompr".
my $files = "./t/" ;
$files = "./" if $ENV{PERL_CORE} ;
$files .= "files/";
my $zipfile = "$files/test.ods" ;
my $file = "meta.xml";
t/105oneshot-zip-only.t view on Meta::CPAN
my $meta = '<?xml version="1.0" encoding="UTF-8"?>
<office:document-meta xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:ooo="http:/...
is $got, $meta, " content ok";
}
SKIP: {
skip $ebcdic_skip_msg, 3 if ord "A" != 65;
title "Regression: odt non-streaming issue";
# https://github.com/pmqs/IO-Compress/issues/13
# Some programs (LibreOffice) mark entries as Streamed (bit 3 of the General Purpose Bit Flags field is set) ,
# but still fill out the Compressed Length, Uncompressed Length & CRC32 fields in the local file header
my $files = "./t/" ;
$files = "./" if $ENV{PERL_CORE} ;
$files .= "files/";
my $zipfile = "$files/testfile1.odt" ;
( run in 0.341 second using v1.01-cache-2.11-cpan-a5abf4f5562 )