File Coverage

lib/Haineko/SMTPD/Relay/MX.pm

Criterion	Covered	Total	%
statement	84	130	64.6
branch	10	52	19.2
condition	10	15	66.6
subroutine	13	13	100.0
pod	2	2	100.0
total	119	212	56.1

package Haineko::SMTPD::Relay::MX;
use parent 'Haineko::SMTPD::Relay';
use strict;
use warnings;
use Net::SMTP;
use Haineko::DNS;
use Haineko::SMTPD::Response;
use Haineko::SMTPD::Greeting;
use Email::MIME;
use Time::Piece;
use Encode;

sub new {
    my $class = shift;
    my $argvs = { @_ };

    $argvs->{'host'}      = '';
    $argvs->{'port'}      = 25;
    $argvs->{'time'}    ||= Time::Piece->new;
    $argvs->{'sleep'}   ||= 1;
    $argvs->{'timeout'} ||= 30;
    $argvs->{'startls'}   = 0;
    return bless $argvs, __PACKAGE__;
}

sub sendmail {
    my $self = shift;

    my $headerlist = [];
    my $emencoding = uc( $self->{'attr'}->{'charset'} || 'UTF-8' );
    my $methodargv = {
        'body' => Encode::encode( $emencoding, ${ $self->{'body'} } ),
        'attributes' => $self->{'attr'},
    };
    utf8::decode $methodargv->{'body'} unless utf8::is_utf8 $methodargv->{'body'} ;

    for my $e ( @{ $self->{'head'}->{'Received'} } ) {
        # Convert email headers
        push @$headerlist, 'Received' => $e;
    }
    push @$headerlist, 'To' => $self->{'rcpt'};

    for my $e ( keys %{ $self->{'head'} } ) {
        # Make email headers except ``Received'' and ``MIME-Version''
        next if $e eq 'Received';
        next if $e eq 'MIME-Version';

        if( ref $self->{'head'}->{ $e } eq 'ARRAY' ) {

            for my $f ( @{ $self->{'head'}->{ $e } } ) {
                push @$headerlist, $e => $f;
            }
        }
        else {
            push @$headerlist, $e => $self->{'head'}->{ $e };
        }
    }
    $methodargv->{'header'} = $headerlist;

    my $mimeobject = Email::MIME->create( %$methodargv );
    my $mailstring = $mimeobject->as_string;
    my $maillength = length $mailstring;

    my $smtpparams = {
        'Port'    => $self->{'port'},
        'Hello'   => $self->{'ehlo'},
        'Debug'   => $self->{'debug'} || 0,
        'Timeout' => $self->{'timeout'} || 30,
    };

    my $netsmtpobj = undef;
    my $authensasl = undef;
    my $nekogreets = undef;
    my $smtpstatus = 0;
    my $thecommand = q();
    my $pipelining = q();
    my $retryuntil = $self->{'retry'} || 0;

    my $sendmailto = sub {

        $thecommand = 'ehlo';
        return 0 unless $netsmtpobj = Net::SMTP->new( $self->{'host'}, %$smtpparams );
        $nekogreets = Haineko::SMTPD::Greeting->new( $netsmtpobj->message );

        if( $nekogreets->pipelining ) {
            # 250-PIPELINING
            $thecommand  = 'data';
            $pipelining  = sprintf( "MAIL FROM: <%s>", $self->{'mail'} );
            $pipelining .= sprintf( ' RET=FULL' ) if $nekogreets->dsn;
            $pipelining .= sprintf( " SIZE=%d", $maillength ) if $nekogreets->size;
            $pipelining .= sprintf( "\r\n" );
            $pipelining .= sprintf( "RCPT TO: <%s>", $self->{'rcpt'} );
            $pipelining .= sprintf( ' NOTIFY=FAILURE,DELAY' ) if $nekogreets->dsn;
            $pipelining .= sprintf( "\r\n" );
            $pipelining .= sprintf( "DATA\r\n" );
            $pipelining .= sprintf( "%s", $mailstring );
            return 0 unless $netsmtpobj->datasend( $pipelining );
            return 0 unless $netsmtpobj->dataend();

        } else {
            # External SMTP Server does not support PIPELINING
            my $cmdargvs = [];
            my $cmdparam = {};

            $thecommand = 'mail';
            $cmdargvs = [ $self->{'mail'} ];
            $cmdparam->{'Return'} = 'FULL' if $nekogreets->dsn;
            $cmdparam->{'Size'} = $maillength if $nekogreets->size;
            push @$cmdargvs, %$cmdparam if keys %$cmdparam;
            return 0 unless $netsmtpobj->mail( @$cmdargvs );

            $thecommand = 'rcpt';
            $cmdargvs = [ $self->{'rcpt'} ];
            $cmdparam = {};
            $cmdparam->{'Notify'} = [ 'FAILURE', 'DELAY' ] if $nekogreets->dsn;
            push @$cmdargvs, %$cmdparam if keys %$cmdparam;
            return 0 unless $netsmtpobj->to( @$cmdargvs );

            $thecommand = 'data';
            return 0 unless $netsmtpobj->data();
            return 0 unless $netsmtpobj->datasend( $mailstring );
            return 0 unless $netsmtpobj->dataend();
        }

        $thecommand = 'QUIT';
        $netsmtpobj->quit;
        $smtpstatus = 1;
        return 1;
    };

    # Resolve MXRR, ARR
    my $domainpart = [ split( '@', $self->{'rcpt'} ) ]->[1];
    my $hainekodns = Haineko::DNS->new( $domainpart );
    my $exchangers = $hainekodns->mxrr;

    push @$exchangers, @{ $hainekodns->arr } unless scalar @$exchangers;
    $retryuntil = scalar @$exchangers;

    while(1) {
        $self->{'host'} = shift @$exchangers;
        last if $sendmailto->();
        last if $retryuntil == 0;

        $netsmtpobj->quit if defined $netsmtpobj;
        $retryuntil--;
        sleep $self->{'sleep'};
    }

    if( defined $netsmtpobj ) {
        # Check the response from SMTP server
        $smtpparams = {
            'code'    => $netsmtpobj->code,
            'host'    => $self->{'host'},
            'port'    => $self->{'port'},
            'rcpt'    => $self->{'rcpt'},
            'mailer'  => 'MX',
            'message' => [ $netsmtpobj->message ],
            'command' => $thecommand,
        };
        $self->response( Haineko::SMTPD::Response->p( %$smtpparams ) );
        $netsmtpobj->quit;

    } else {
        $self->response( Haineko::SMTPD::Response->r( 'conn', 'cannot-connect' ) );
        map { $self->response->{ $_ } = $self->{ $_ } } ( qw|host port rcpt| );
    }
    return $smtpstatus;
}

1;
__END__