File Coverage

blib/lib/Archive/Zip/Parser.pm

Criterion	Covered	Total	%
statement	94	96	97.9
branch	14	18	77.7
condition			n/a
subroutine	23	23	100.0
pod	5	5	100.0
total	136	142	95.7

package Archive::Zip::Parser;

use warnings;
use strict;
use autodie;
use Data::ParseBinary;

use Archive::Zip::Parser::Entry;
use Archive::Zip::Parser::CentralDirectoryEnd;
use base qw( Archive::Zip::Parser::Exception );

use version; our $VERSION = qv( '0.0.3' );

sub new {
    my ( $class, $arg_ref ) = @_;

    my $new_object = bless {}, $class;

    if ( !exists $arg_ref->{'file_name'} ) {
        $new_object->_croak('Missing "file_name"');
    }

    open my $file_handle, '<', $arg_ref->{'file_name'};
    $new_object->{'_file_handle'} = $file_handle;
    $new_object->{'_bit_stream'}
      = CreateStreamReader( File => $new_object->{'_file_handle'} );

    return $new_object;
}

sub verify_signature {
    my $self = shift;

    my $previous_position_in_file;
    eval {
        $previous_position_in_file = tell $self->{'_file_handle'};
        $self->_set_position_in_file( 0, 0 );

        Magic("PK\x03\x04")->parse( $self->{'_bit_stream'} );
    } or do {
        return 0;
    };

    $self->_set_position_in_file( $previous_position_in_file, 0 );
    return 1;
}

sub parse {
    my $self = shift;

    return 1 if $self->{'_is_parsed'};
    if ( !$self->verify_signature() ) {
        $self->_croak('Not a valid .ZIP archive');
    }

    my @parsed_entry_struct;
    while (1) {
        last if $self->_check_signature('04034b50');

        my $local_file_header_struct
            = Struct(
                '_entry_struct',
                Struct(
                    '_local_file_header',
                    ULInt32('_signature'     ),
                    ULInt16('_version_needed'),
                    BitStruct( '_gp_bit',
                        Flag('_bit_7' ),
                        Flag('_bit_6' ),
                        Flag('_bit_5' ),
                        Flag('_bit_4' ),
                        Flag('_bit_3' ),
                        Flag('_bit_2' ),
                        Flag('_bit_1' ),
                        Flag('_bit_0' ),
                        Flag('_bit_15'),
                        Flag('_bit_14'),
                        Flag('_bit_13'),
                        Flag('_bit_12'),
                        Flag('_bit_11'),
                        Flag('_bit_10'),
                        Flag('_bit_9' ),
                        Flag('_bit_8' ),
                    ),
                    ULInt16('_compression_method'),
                    ULInt16('_last_mod_time'     ),
                    ULInt16('_last_mod_date'     ),
                    ULInt32('_crc_32'            ),
                    ULInt32('_compressed_size'   ),
                    ULInt32('_uncompressed_size' ),
                    ULInt16('_file_name_length'  ),
                    ULInt16('_extra_field_length'),
                    String(
                        '_file_name',
                        sub {
                            $_->ctx->{'_file_name_length'};
                        },
                    ),
                    Field(
                        '_extra_field',
                        sub {
                            $_->ctx->{'_extra_field_length'};
                        },
                    ),
                ),
                Field(
                    '_file_data',
                    sub {
                        $_->ctx->{'_local_file_header'}->{'_compressed_size'};
                    }
                ),
                If(
                    sub {
                        $_->ctx->{'_local_file_header'}->{'_gp_bit'}->{'_bit_3'};
                    },
                    Struct(
                        '_data_descriptor',
                        ULInt32('_crc_32'           ),
                        ULInt32('_compressed_size'  ),
                        ULInt32('_uncompressed_size'),
                    ),
                ),
            );

        push @parsed_entry_struct,
          $local_file_header_struct->parse( $self->{'_bit_stream'} );
    }

    my $entry_count = 0;
    while (1) {
        last if $self->_check_signature('02014b50');

        my $central_directory_struct
            = Struct(
                '_entry_struct',
                Struct(
                    '_central_directory',
                    ULInt32('_signature'      ),
                    Field( '_version_made_by', 2 ),
                    ULInt16('_version_needed' ),
                    BitStruct(
                        '_gp_bit',
                        Flag('_bit_7' ),
                        Flag('_bit_6' ),
                        Flag('_bit_5' ),
                        Flag('_bit_4' ),
                        Flag('_bit_3' ),
                        Flag('_bit_2' ),
                        Flag('_bit_1' ),
                        Flag('_bit_0' ),
                        Flag('_bit_15'),
                        Flag('_bit_14'),
                        Flag('_bit_13'),
                        Flag('_bit_12'),
                        Flag('_bit_11'),
                        Flag('_bit_10'),
                        Flag('_bit_9' ),
                        Flag('_bit_8' ),
                    ),
                    ULInt16('_compression_method'     ),
                    ULInt16('_last_mod_time'          ),
                    ULInt16('_last_mod_date'          ),
                    ULInt32('_crc_32'                 ),
                    ULInt32('_compressed_size'        ),
                    ULInt32('_uncompressed_size'      ),
                    ULInt16('_file_name_length'       ),
                    ULInt16('_extra_field_length'     ),
                    ULInt16('_file_comment_length'    ),
                    ULInt16('_start_disk_number'      ),
                    ULInt16('_internal_file_attr'     ),
                    ULInt32('_external_file_attr'     ),
                    ULInt32('_rel_offset_local_header'),
                    String(
                        '_file_name',
                        sub {
                            $_->ctx->{'_file_name_length'};
                        },
                    ),
                    Field(
                        '_extra_field',
                        sub {
                            $_->ctx->{'_extra_field_length'};
                        },
                    ),
                    Field(
                        '_file_comment',
                        sub {
                            $_->ctx->{'_file_comment_length'};
                        }
                    ),
                ),
            );

        %{ $parsed_entry_struct[$entry_count] } = (
            %{ $parsed_entry_struct[$entry_count] },
            %{  $central_directory_struct->parse(
                    $self->{'_bit_stream'}
                )
              }
        );
        $entry_count++;
    }

    last if $self->_check_signature('06054b50');

    my $central_directory_end_struct
        = Struct(
            '_central_directory_end',
            ULInt32('_signature'         ),
            ULInt16('_disk_number'       ),
            ULInt16('_start_disk_number' ),
            ULInt16('_total_disk_entries'),
            ULInt16('_total_entries'     ),
            ULInt32('_size'              ),
            ULInt32('_start_offset'      ),
            ULInt16('_zip_comment_length'),
            String(
                '_zip_comment',
                sub {
                    $_->ctx->{'_zip_comment_length'};
                },
            ),
        );

    my $parsed_central_directory_end_struct
      = $central_directory_end_struct->parse( $self->{'_bit_stream'} );
    $self->{'_central_directory_end'} = $parsed_central_directory_end_struct;
    push @{ $self->{'_entry'} }, @parsed_entry_struct;

    $self->{'_is_parsed'} = 1;
    return 1;
}

sub get_entry {
    my ( $self, $entry_number ) = @_;

    if ( !defined $entry_number ) {
        my @entry_objects;
        for ( @{ $self->{'_entry'} } ) {
            push @entry_objects, bless $_, 'Archive::Zip::Parser::Entry';
        }

        return @entry_objects;
    }

    return bless $self->{'_entry'}->[$entry_number],
      'Archive::Zip::Parser::Entry';
}

sub _set_position_in_file {
    my ( $self, $position_in_file, $whence ) = @_;
    my $file_handle = $self->{'_file_handle'};

    seek $file_handle, $position_in_file, $whence;

    return;
}

sub get_central_directory_end {
    my $self = shift;
    return bless $self->{'_central_directory_end'},
      'Archive::Zip::Parser::CentralDirectoryEnd';
}

sub _check_signature {
    my ( $self, $next_signature ) = @_;

    my $signature_struct =
        Struct(
            '_signature_struct',
            Peek(
                ULInt32('_signature')
            ),
        );
    my $parsed_signature_struct
      = $signature_struct->parse( $self->{'_bit_stream'} );
    my $signature = unpack( 'H*', pack( 'N', $parsed_signature_struct->{'_signature'} ) );
    if ( $signature ne $next_signature ) {
        return 1;
    }
    return;
}

1;
__END__