File Coverage

blib/lib/Net/OBEX/Packet/Headers.pm

Criterion	Covered	Total	%
statement	56	58	96.5
branch	14	22	63.6
condition	3	3	100.0
subroutine	13	13	100.0
pod	5	5	100.0
total	91	101	90.1

package Net::OBEX::Packet::Headers;

use strict;
use warnings;

our $VERSION = '1.001001'; # VERSION

use Carp;
use Net::OBEX::Packet::Headers::Unicode;
use Net::OBEX::Packet::Headers::ByteSeq;
use Net::OBEX::Packet::Headers::Byte4;

my %Header_Meaning_Of = _make_header_meanings();
my %Header_Type_Of = (
    ( map { $_ => 'byte4' } qw( count  length  timeb  connection_id ) ),

    ( map { $_ => 'byteseq' } qw(
            type  time        target           http
            who   app_params  auth_challenge   auth_response
            body  end_of_body object_class
        )
    ),

    ( map { $_ => 'unicode' } qw( name  description ) ),
);

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

    return bless { HEADERS_RAW => $headers_raw }, $class;
}

sub make {
    my $self = shift;
    my ( $name, $value ) = @_;
    $name = lc $name;
    croak "Invalid header name specified to make()"
        unless exists $Header_Type_Of{ $name };

    my $type = $Header_Type_Of{ $name };
    if ( $type eq 'byteseq' ) {
        return Net::OBEX::Packet::Headers::ByteSeq->new(
            $name   => $value,
        )->make;
    }
    elsif ( $type eq 'byte4' ) {
        return Net::OBEX::Packet::Headers::Byte4->new(
            $name   => $value,
        )->make;
    }
    elsif ( $type eq 'unicode' ) {
        return Net::OBEX::Packet::Headers::Unicode->new(
            $name   => $value,
        )->make;
    }
    else {
        die 'I should never got to here. Please email '
            . 'to [e-mail]';
    }
}

sub parse {
    my $self = shift;

    my $headers_raw = shift;
    $headers_raw = $self->headers_raw
        unless defined $headers_raw;

    $self->headers_raw( $headers_raw );

    my %headers;
    while (length $headers_raw) {
        (my $HI_raw, $headers_raw ) = unpack 'a a*', $headers_raw;

        my $HI = $Header_Meaning_Of{ $HI_raw };
         last
             unless defined $HI;

        ( $headers{ $HI }, $headers_raw)
        = $self->_make_header_value( $HI_raw, $headers_raw );
    }

    return $self->headers_parsed( \%headers );
}

sub _make_header_value {
    my ( $self, $HI_raw, $headers_raw ) = @_;

    # Bits 8 and 7 of HI  - Interpretation
    # 00  - null terminated Unicode text,
    #               length prefixed with 2 byte unsigned integer
    # 01 - byte sequence, length prefixed with 2 byte unsigned integer
    # 10 - 1 byte quantity
    # 11 - 4 byte quantity - transmitted in network byte order

    my $type = unpack 'B2', $HI_raw;
    if ( $type eq '00' or $type eq '01' ) {
        my ( $header_length, $headers_raw ) = unpack 'n a*', $headers_raw;
        $header_length -= 3; # first three bytes of length are
                             # the HI and it's length bytes
        return unpack "a$header_length a*", $headers_raw;
    }
    elsif ( $type eq '10' ) {
        return unpack 'aa*', $headers_raw;
    }
    elsif ( $type eq '11' ) {
        return unpack 'a4a*', $headers_raw;
    }
}

sub headers_raw {
    my $self = shift;
    if ( @_ ) {
        $self->{ HEADERS_RAW } = shift;
    }
    return $self->{ HEADERS_RAW };
}

sub headers_parsed {
    my $self = shift;
    if ( @_ ) {
        $self->{ HEADERS_PARSED } = shift;
    }
    return $self->{ HEADERS_PARSED };
}

sub _make_header_meanings {
    return (
        "\xC0"      => 'count',
        "\x01"      => 'name',
        "\x42"      => 'type',
        "\xC3"      => 'length',
        "\x44"      => 'time',
        "\xC4"      => 'timeb',
        "\x05"      => 'description',
        "\x46"      => 'target',
        "\x47"      => 'http',
        "\x48"      => 'body',
        "\x49"      => 'end_of_body',
        "\x4A"      => 'who',
        "\xCB"      => 'connection_id',
        "\x4C"      => 'app_params',
        "\x4D"      => 'auth_challenge',
        "\x4E"      => 'auth_response',
        "\x4F"      => 'object_class',
    );

}

1;

__END__