File Coverage

blib/lib/IO/Stream/MatrixSSL.pm

Criterion	Covered	Total	%
statement	103	137	75.1
branch	41	68	60.2
condition	5	26	19.2
subroutine	14	15	93.3
pod	1	3	33.3
total	164	249	65.8

package IO::Stream::MatrixSSL;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.0.2';

use IO::Stream::const;
use IO::Stream::MatrixSSL::const;
use Crypt::MatrixSSL3 qw( :all );

use IO::Stream::MatrixSSL::Client;
use IO::Stream::MatrixSSL::Server;


sub stream {
    my ($self) = @_;
    my $stream = $self;
    while ($stream->{_master}) {
        $stream = $stream->{_master};
    }
    return $stream;
}

sub T {
    my ($self) = @_;
    my $m = $self->{_master};
    $m->EVENT(0, ETOHANDSHAKE);
    return;
}

sub WRITE {
    my ($self) = @_;
    my $m = $self->{_master};
    if ($self->{_closed}) {
        $m->EVENT(0, 'ssl closed: closure alert or fatal alert was sent');
    }
    elsif (!$self->{_handshaked}) {
        $self->{_want_write} = 1;
    }
    elsif (!$self->{_want_close}) {
        my $s = substr $m->{out_buf}, $m->{out_pos}||0;
        my $n = length $s;
ENCODE:
        while (length $s) {
            my $s2 = substr $s, 0, SSL_MAX_PLAINTEXT_LEN, q{};
            my $rc = $self->{_ssl}->encode_to_outdata($s2);
            return $m->EVENT(0, 'ssl error: '.get_ssl_error($rc)) if $rc <= 0;
            while (my $bytes = $self->{_ssl}->get_outdata($self->{out_buf})) {
                $rc = $self->{_ssl}->sent_data($bytes);
                last if $rc == PS_SUCCESS;
                next if $rc == MATRIXSSL_REQUEST_SEND;
                next if $rc == MATRIXSSL_HANDSHAKE_COMPLETE;
                if ($rc == MATRIXSSL_REQUEST_CLOSE) {
                    $self->{_want_close} = 1;
                    # XXX Will report to $m "{out_buf} was completely sent"
                    # while is may be only partially sent.
                    last ENCODE;
                }
                return $m->EVENT(0, 'ssl error: '.get_ssl_error($rc));
            }
        }
        if (defined $m->{out_pos}) {
            $m->{out_pos} += $n;
        } else {
            $m->{out_buf} = q{};
        }
        $m->{out_bytes} += $n;
        $m->EVENT(OUT);
        $self->{_slave}->WRITE();
    }
    return;
}

sub EVENT { ## no critic (ProhibitExcessComplexity)
    my ($self, $e, $err) = @_;
    my $m = $self->{_master};
    if ($e & SENT && $self->{_want_close}) {
        $self->{_closed} = 1;
        $err ||= 'ssl closed: closure alert or fatal alert was sent';
    }
    $e &= ~OUT;
    if (!$self->{_handshaked}) {
        $e &= ~SENT;
    }
    return if !$e && !$err;
    if ($e & IN) {
        $e &= ~IN;
RECV:
        my @warnings;
        while (length $self->{in_buf}) {
            my $rc = $self->{_ssl}->received_data($self->{in_buf}, my $buf);
RC:
            last if $rc == PS_SUCCESS;
            next if $rc == MATRIXSSL_REQUEST_RECV;
            next if $rc == MATRIXSSL_REQUEST_SEND;
            if ($rc == MATRIXSSL_HANDSHAKE_COMPLETE) {
                $self->_handshaked();
                next;
            }
            if ($rc == MATRIXSSL_RECEIVED_ALERT) {
                my ($level, $descr) = get_ssl_alert($buf);
                if ($level == SSL_ALERT_LEVEL_FATAL) {
                    $self->{_ssl}->processed_data($buf);
                    $err ||= "ssl fatal alert: $descr";
                    last;
                }
                if ($descr != SSL_ALERT_CLOSE_NOTIFY) {
                    push @warnings, $descr;
                }
            }
            elsif ($rc == MATRIXSSL_APP_DATA) {
                $self->_handshaked();
                $e |= IN;
                $m->{in_buf}    .= $buf;
                $m->{in_bytes}  += length $buf;
            }
            elsif ($rc == MATRIXSSL_APP_DATA_COMPRESSED) {
                $self->_handshaked();
                $err ||= 'ssl error: not implemented because USE_ZLIB_COMPRESSION should not be enabled';
                last;
            }
            else {
                $err ||= 'ssl error: '.get_ssl_error($rc);
                last;
            }
            $rc = $self->{_ssl}->processed_data($buf);
            goto RC;
        }
        if (@warnings) {
            # XXX warning alert(s) may be lost if some other error or
            # fatal alert happens after warning alert(s).
            $err ||= join q{ }, 'ssl warning alert:', @warnings;
        }
SEND:
        while (my $bytes = $self->{_ssl}->get_outdata($self->{out_buf})) {
            my $rc = $self->{_ssl}->sent_data($bytes);
            last if $rc == PS_SUCCESS;
            next if $rc == MATRIXSSL_REQUEST_SEND;
            if ($rc == MATRIXSSL_HANDSHAKE_COMPLETE) {
                $self->_handshaked();
                next;
            }
            if ($rc == MATRIXSSL_REQUEST_CLOSE) {
                $self->{_want_close} = 1;
                last;
            }
            $err ||= 'ssl error: '.get_ssl_error($rc);
            last;
        }
        if (length $self->{out_buf}) {
            $self->{_slave}->WRITE();
        }
    }
    if ($e & RESOLVED) {
        $m->{ip} = $self->{ip};
    }
    if ($e & EOF) {
        $m->{is_eof} = $self->{is_eof};
        if (!$self->{_handshaked}) {
            $err ||= 'ssl handshake error: unexpected EOF';
        }
    }
    if ($e & CONNECTED) {
        $self->{_t} = EV::timer(TOHANDSHAKE, 0, $self->{_cb_t});
    }
    $m->EVENT($e, $err);
    return;
}

sub _handshaked {
    my ($self) = @_;
    if (!$self->{_handshaked}) {
        $self->{_handshaked} = 1;
        undef $self->{_t};
        if ($self->{_want_write}) {
            $self->WRITE();
        }
    }
    return;
}


1; # Magic true value required at end of module
__END__