File Coverage

blib/lib/IO/Stream/MatrixSSL.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

## no critic (Capitalization)
package IO::Stream::MatrixSSL;

use warnings;
use strict;
use Carp;

use version; our $VERSION = qv('1.1.2');    # update POD & Changes & README

# update DEPENDENCIES in POD & Makefile.PL & README
use IO::Stream::const;
use IO::Stream::MatrixSSL::const;
use Crypt::MatrixSSL 1.83;

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


sub DESTROY {
    my ($self) = @_;
    # Free memory in MatrixSSL.
    matrixSslDeleteSession($self->{_ssl});
    matrixSslFreeKeys($self->{_ssl_keys});
    return;
}

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

sub WRITE {
    my ($self) = @_;
    if (!$self->{_handshaked}) {
        $self->{_want_write} = 1;
    }
    else {
        my $m = $self->{_master};
        my $s = substr $m->{out_buf}, $m->{out_pos}||0;
        my $n = length $s;
        while (length $s) {
            my $s2 = substr $s, 0, $SSL_MAX_PLAINTEXT_LEN, q{};
            if (matrixSslEncode($self->{_ssl}, $s2, $self->{out_buf}) < 0) {
                $m->EVENT(0, 'matrixSslEncode');
                return;
            }
        }
        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};
    $e &= ~OUT;
    if (!$self->{_handshaked}) {
        $e &= ~SENT;
    }
    return if !$e && !$err;
    if ($e & IN) {
        $e &= ~IN;
        while (length $self->{in_buf}) {
            my ($error, $alertLevel, $alertDescription);
            my $rc = matrixSslDecode($self->{_ssl}, $self->{in_buf},
                my $buf=q{}, $error, $alertLevel, $alertDescription);
            if ($rc == $SSL_PROCESS_DATA) {
                $e |= IN;
                $m->{in_buf}    .= $buf;
                $m->{in_bytes}  += length $buf;
            }
            else {
                $self->{out_buf} .= $buf;
                $self->{_slave}->WRITE();
                ## no critic (ProhibitCascadingIfElse ProhibitDeepNests)
                if ($rc == $SSL_SUCCESS || $rc == $SSL_SEND_RESPONSE) {
                    if (!$self->{_handshaked}) {
                        if (matrixSslHandshakeIsComplete($self->{_ssl})) {
                            $self->{_handshaked} = 1;
                            undef $self->{_t};
                            if ($self->{_want_write}) {
                                $self->WRITE();
                            }
                        }
                    }
                }
                # WARNING   After $SSL_ERROR or $SSL_ALERT {in_buf} may
                # contain non-decoded packets. These packets will be lost,
                # except in case user will not $stream->close() on this
                # error AND there will be more data later (got EPOLLIN).
                # This behaviour is ok because all ERROR/ALERT are fatal
                # anyway (except NO_CERTIFICATE).
                # TODO FIXME    If we'll support commercial MatrixSSL we
                # should add handling for NO_CERTIFICATE case.
                elsif ($rc == $SSL_ERROR) {
                    $err ||= "ssl error: $SSL_alertDescription{$error}";
                    last;
                }
                elsif ($rc == $SSL_ALERT) {
                    if ($alertLevel == $SSL_ALERT_LEVEL_WARNING
                            && $alertDescription == $SSL_ALERT_CLOSE_NOTIFY) {
                        # Workaround MatrixSSL bug: ALERT packet doesn't removed
                        # from {in_buf}, and next matrixSslDecode() on this {in_buf}
                        # return SSL_ERROR while CLOSE_NOTIFY alert shouldn't be
                        # error at all. :(
                        # TODO Is it still needed in Crypt::MatrixSSL 1.83?
                        $self->{in_buf} = q{};
                    }
                    else {
                        $err ||= "ssl alert: $SSL_alertLevel{$alertLevel}: $SSL_alertDescription{$alertDescription}";
                        last;
                    }
                }
                elsif ($rc == $SSL_PARTIAL) {
                    last;
                }
                else {
                    $err ||= "matrixSslDecode: unexpected return code ($rc)";
                    last;
                }
                ## use critic
            }
        }
    }
    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;
}


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