File Coverage

blib/lib/IO/Uncompress/UnLzf.pm

Criterion	Covered	Total	%
statement	93	94	98.9
branch	25	30	83.3
condition	2	3	66.6
subroutine	19	19	100.0
pod	2	12	16.6
total	141	158	89.2

package IO::Uncompress::UnLzf ;

use strict ;
use warnings;
use bytes;

use IO::Compress::Base::Common  2.206 qw(:Status createSelfTiedObject);

use IO::Uncompress::Base  2.206 ;
use IO::Uncompress::Adapter::Lzf  2.206 ;


require Exporter ;
our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $UnLzfError);

$VERSION = '2.206';
$UnLzfError = '';

@ISA    = qw( IO::Uncompress::Base Exporter );
@EXPORT_OK = qw( $UnLzfError unlzf ) ;
#%EXPORT_TAGS = %IO::Uncompress::Base::EXPORT_TAGS ;
push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
#Exporter::export_ok_tags('all');

use constant SIGNATURE => 'ZV';

sub new
{
    my $class = shift ;
    my $obj = createSelfTiedObject($class, \$UnLzfError);

    $obj->_create(undef, 0, @_);
}

sub unlzf
{
    my $obj = createSelfTiedObject(undef, \$UnLzfError);
    return $obj->_inf(@_);
}

sub getExtraParams
{
    return ();
}

sub ckParams
{
    my $self = shift ;
    my $got = shift ;

    return 1;
}


sub postCheckParams
{
    my $self = shift ;
    my $got = shift ;

    return  $self->saveErrorString(undef, "MultiStream not supported by Lzf", STATUS_ERROR)
        if $got->getValue('multistream') ;

    $got->setValue('multistream' => 0);
    return 1;
}

sub mkUncomp
{
    my $self = shift ;
    my $got = shift ;

     my $magic = $self->ckMagic()
        or return 0;

    *$self->{Info} = $self->readHeader($magic)
        or return undef ;

    my ($obj, $errstr, $errno) = IO::Uncompress::Adapter::Lzf::mkUncompObject();

    return $self->saveErrorString(undef, $errstr, $errno)
        if ! defined $obj;

    *$self->{Uncomp} = $obj;

    return 1;
}


sub ckMagic
{
    my $self = shift;

    my $magic ;
    $self->smartReadExact(\$magic, 3);

    *$self->{HeaderPending} = $magic ;

    return $self->HeaderError("Header size is " .
                                        3 . " bytes")
        if length $magic != 3;

    return $self->HeaderError("Bad Magic.")
        if ! isLzfMagic($magic) ;


    *$self->{Type} = 'lzf';
    return $magic;
}

sub readHeader
{
    my $self = shift;
    my $magic = shift ;

    $self->pushBack($magic);
    *$self->{HeaderPending} = '';

    return {
        'Type'              => 'lzf',
        'FingerprintLength' => 3,
        'HeaderLength'      => 3,
        'TrailerLength'     => 0,
        'Header'            => '$magic'
        };



}

sub chkTrailer
{
    return STATUS_OK;
}

sub readBlock
{
    my $self = shift ;
    my $buff = shift ;
    my $size = shift ;

    return STATUS_ENDSTREAM
        if $self->smartEof() ;

    my $buffer;

    if ( ! $self->smartReadExact(\$buffer, 3 )){
        $self->pushBack($buffer);
        return STATUS_ENDSTREAM;
    }

    #$self->smartReadExact(\$buffer, 3 )
    #   or return $self->saveErrorString(STATUS_ERROR,"Minimum header size is " .
    #                                 3 . " bytes") ;

    my $sig     =              substr($buffer, 0, 2);
    my $type    = unpack 'C',  substr($buffer, 2, 1);

    if ($sig ne SIGNATURE) {
        $self->pushBack($buffer);
        return STATUS_ENDSTREAM
    }

    #return STATUS_ENDSTREAM
    #    if $sig ne SIGNATURE;

    my $cSize = 0;
    my $uSize = 0;
    if ($type == 0) { # uncompressed
        $self->smartReadExact(\$buffer, 2)
            or return $self->saveErrorString(STATUS_ERROR, "xxx");
        $uSize = unpack("n", $buffer);
        $cSize = $uSize;
        *$self->{Uncomp}->setIdentity();
    }
    elsif ($type == 1) { # compressed
        $self->smartReadExact(\$buffer, 4)
            or return $self->saveErrorString(STATUS_ERROR, "xxx");
        ($cSize, $uSize) = unpack("n n", $buffer);
        *$self->{Uncomp}->setUSize($uSize);
    }
    #elsif ($type == 2) { # CRC - not implemented by lzf yet
    #}
    else {
        return $self->saveErrorString(STATUS_ERROR, "unexpected block type - $type", STATUS_ERROR);

    }

    *$self->{LzfData}{compSize} = $cSize;
    *$self->{LzfData}{uncSize} = $uSize;

    $self->smartReadExact($buff, $cSize)
        or return $self->saveErrorString(STATUS_ERROR, "xxx");

    return STATUS_OK;
}


sub postBlockChk
{
    my $self = shift ;
    my $buffer = shift ;
    my $offset = shift ;

    return $self->saveErrorString(STATUS_ERROR, "uncompressed size wrong", STATUS_ERROR)
        if length($$buffer) - $offset != *$self->{LzfData}{uncSize} ;

    return STATUS_OK;
}

sub isLzfMagic
{
    my $buffer = shift ;
    my $sig     =              substr($buffer, 0, 2);
    my $type    = unpack 'C',  substr($buffer, 2, 1);
    return $sig eq SIGNATURE  && ($type == 0 || $type == 1);
}

1 ;

__END__