File Coverage

blib/lib/Mail/GPG/Result.pm

Criterion	Covered	Total	%
statement	88	141	62.4
branch	24	50	48.0
condition	22	29	75.8
subroutine	29	38	76.3
pod	2	37	5.4
total	165	295	55.9

package Mail::GPG::Result;

# $Id: Result.pm,v 1.8 2006/04/14 11:05:03 joern Exp $

use strict;

require Encode if $] >= 5.008;

sub get_mail_gpg                { shift->{mail_gpg}                     }

sub get_is_encrypted            { shift->{is_encrypted}                 }
sub get_enc_ok                  { shift->{enc_ok}                       }
sub get_enc_key_id              { shift->{enc_key_id}                   }
sub get_enc_mail                { shift->{enc_mail}                     }
sub get_enc_key_ids             { shift->{enc_key_ids}                  }
sub get_enc_mails               { shift->{enc_mails}                    }
sub get_is_signed               { shift->{is_signed}                    }
sub get_sign_ok                 { shift->{sign_ok}                      }
sub get_sign_state              { shift->{sign_state}                   }
sub get_sign_key_id             { shift->{sign_key_id}                  }
sub get_sign_mail               { shift->{sign_mail}                    }
sub get_sign_mail_aliases       { shift->{sign_mail_aliases}            }
sub get_sign_fingerprint        { shift->{sign_fingerprint}             }

sub set_is_encrypted            { shift->{is_encrypted}         = $_[1] }
sub set_enc_ok                  { shift->{enc_ok}               = $_[1] }
sub set_enc_key_id              { shift->{enc_key_id}           = $_[1] }
sub set_enc_mail                { shift->{enc_mail}             = $_[1] }
sub set_enc_key_ids             { shift->{enc_key_ids}          = $_[1] }
sub set_enc_mails               { shift->{enc_mails}            = $_[1] }
sub set_is_signed               { shift->{is_signed}            = $_[1] }
sub set_sign_ok                 { shift->{sign_ok}              = $_[1] }
sub set_sign_state              { shift->{sign_state}           = $_[1] }
sub set_sign_key_id             { shift->{sign_key_id}          = $_[1] }
sub set_sign_mail               { shift->{sign_mail}            = $_[1] }
sub set_sign_mail_aliases       { shift->{sign_mail_aliases}    = $_[1] }
sub set_sign_fingerprint        { shift->{sign_fingerprint}     = $_[1] }

sub get_gpg_stdout              { shift->{gpg_stdout}                   }
sub get_gpg_stderr              { shift->{gpg_stderr}                   }
sub get_gpg_status              { shift->{gpg_status}                   }
sub get_gpg_rc                  { shift->{gpg_rc}                       }

sub new {
    my $class = shift;
    my %par   = @_;
    my  ($mail_gpg, $gpg_stdout, $gpg_stderr, $gpg_status, $gpg_rc) =
    @par{'mail_gpg','gpg_stdout','gpg_stderr','gpg_status','gpg_rc'};

    #-- initialize reference attributes to prevent
    #-- dereferencing undef errors
    $gpg_stdout = \"" if not defined $gpg_stdout;
    $gpg_stderr = \"" if not defined $gpg_stderr;
    $gpg_status = \"" if not defined $gpg_status;

    my $self = bless {
        mail_gpg   => $mail_gpg,
        gpg_stdout => $gpg_stdout,
        gpg_stderr => $gpg_stderr,
        gpg_status => $gpg_status,
        gpg_rc     => $gpg_rc,
    }, $class;

    $self->analyze_result;

    return $self;
}

sub analyze_result {
    my $self = shift;

    my ($is_signed,         $sign_ok,      $sign_state,
        $sign_key_id,       $sign_mail,    $sign_fingerprint,
        @sign_mail_aliases, $is_encrypted, $enc_ok,
        @enc_key_ids,       @enc_mails
    );

    my $gpg_status = $self->get_gpg_status;
    my $gpg_stderr = $self->get_gpg_stderr;

    while ( $$gpg_status && $$gpg_status =~ m{^\[GNUPG:\]\s+(.*)$}mg ) {
        my $line = $1;
        if ( $line =~ /^(GOOD|EXP|EXPKEY|REVKEY|BAD)SIG\s+([^\s]+)\s+(.*)/ ) {
            my ( $state, $key_id, $mail ) = ( $1, $2, $3 );
            $is_signed   = 1;
            $sign_state  = $state;
            $sign_key_id = $key_id;
            $sign_mail   = decode($mail);
            $sign_ok     = $sign_state eq 'GOOD';
        }
        elsif ( $line =~ /^ERRSIG\s+([^\s]+)/ ) {
            $is_signed   = 1;
            $sign_key_id = $1;
        }
        elsif ( $line =~ /^VALIDSIG\s+([^\s]+)/ ) {
            $sign_fingerprint = $1;
        }
        elsif ( $line =~ /^ENC_TO\s+([^\s]+)/ ) {
            push @enc_key_ids, decode($1);
            $enc_mails[ @enc_key_ids - 1 ] = "";
        }
        elsif ( $line =~ /^USERID_HINT\s+([^\s]+)\s+(.*)/ ) {
            my ( $hint_key_id, $hint_text ) = ( $1, $2 );
            my $i = 0;
            foreach my $key_id (@enc_key_ids) {
                if ( $key_id eq $hint_key_id ) {
                    $enc_mails[$i] = decode($hint_text);
                }
                ++$i;
            }
        }
        elsif ( $line =~ /^BEGIN_DECRYPTION/ ) {
            $is_encrypted = 1;
        }
        elsif ( $line =~ /^DECRYPTION_OKAY/ ) {
            $enc_ok = 1;
        }
    }

    @sign_mail_aliases = $$gpg_stderr =~ /^gpg:\s+aka\s+"(.*?)"/mg;

    if ( !$self->get_mail_gpg->get_use_long_key_ids ) {
        for ( $sign_key_id, @enc_key_ids ) {
            $_ = substr( $_, -8, 8 ) if defined $_;
        }
    }

    $self->set_is_signed( $is_signed               || 0 );
    $self->set_sign_ok( $sign_ok                   || 0 );
    $self->set_sign_state( $sign_state             || "" );
    $self->set_sign_key_id( $sign_key_id           || "" );
    $self->set_sign_mail( $sign_mail               || "" );
    $self->set_sign_fingerprint( $sign_fingerprint || "" );
    $self->set_sign_mail_aliases( \@sign_mail_aliases );
    $self->set_is_encrypted( $is_encrypted || '0' );

    $self->set_enc_ok( $enc_ok || 0 );
    $self->set_enc_key_ids( \@enc_key_ids );
    $self->set_enc_mails( \@enc_mails );
    $self->set_enc_key_id( $enc_key_ids[0] || "" );
    $self->set_enc_mail( $enc_mails[0]     || "" );

    return $self;
}

sub decode {
    my ($str) = @_;
    return $str if not defined $str;
    $str =~ s/\\x(..)/chr(hex($1))/eg;
    eval { $str = Encode::decode("utf-8", $str, Encode::FB_CROAK) }
        if $] >= 5.008;
    return $str;
}

sub as_string {
    my $self        = shift;
    my %par         = @_;
    my ($no_stdout) = $par{'no_stdout'};

    my ( $method, $string );
    foreach my $attr (
        qw (is_encrypted enc_ok enc_key_id enc_mail
        enc_key_ids enc_mails
        is_signed sign_ok sign_state sign_key_id
        sign_fingerprint sign_mail sign_mail_aliases
        sign_trust gpg_rc )
        ) {
        if ( $attr eq 'sign_mail_aliases' ) {
            foreach my $value ( @{ $self->get_sign_mail_aliases } ) {
                $string
                    .= sprintf( "%-18s: %s\n", "sign_mail_alias", $value );
            }
        }
        elsif ( $attr eq 'enc_key_ids' ) {
            foreach my $value ( @{ $self->get_enc_key_ids } ) {
                $string .= sprintf( "%-18s: %s\n", "enc_key_ids", $value );
            }
        }
        elsif ( $attr eq 'enc_mails' ) {
            foreach my $value ( @{ $self->get_enc_mails } ) {
                $string .= sprintf( "%-18s: %s\n", "enc_mails", $value );
            }
        }
        else {
            $method = "get_$attr";
            my $value = $self->$method;
            $value = "" unless defined $value;
            $string .= sprintf( "%-18s: %s\n", $attr, $value );
        }
    }

    my $stdout = ${ $self->get_gpg_stdout };
    my $stderr = ${ $self->get_gpg_stderr };
    my $status = ${ $self->get_gpg_status };

    for ( $stdout, $stderr, $status ) {
        next unless $_;
        s/\n/\n                    /g;
        s/\s+$//;
    }

    $string .= sprintf( "%-18s: %s\n", "gpg_stdout", $stdout || '' )
        if not $no_stdout;
    $string .= sprintf( "%-18s: %s\n", "gpg_stderr", $stderr || '' );
    $string .= sprintf( "%-18s: %s\n", "gpg_status", $status || '' );

    return $string;
}

sub as_short_string {
    my $self = shift;

    my $string;

    if ( $self->get_is_encrypted ) {
        $string .= "ENC("
            . $self->get_enc_mail . ", "
            . $self->get_enc_key_id . ", "
            . ( $self->get_enc_ok ? "OK" : "NOK" ) . ") - ";
    }
    else {
        $string .= "NOENC - ";
    }

    if ( $self->get_is_signed ) {
        $string .= "SIGN("
            . $self->get_sign_mail . ", "
            . $self->get_sign_key_id . ", "
            . $self->get_sign_state . ") - ";
    }
    else {
        $string .= "NOSIGN - ";
    }

    $string =~ s/ - $//;

    return $string;
}

sub get_sign_trust {
    my $self = shift;

    return $self->{sign_trust} if exists $self->{sign_trust};

    my $trust = $self->get_mail_gpg->get_key_trust(
        key_id => $self->get_sign_key_id );

    return $self->{sign_trust} = $trust;
}

1;

__END__