#!./perl -w

use v5.6.1;
use strict;
use warnings;

my $child;
my $can_fork;
my $has_perlio;

our %Config;
BEGIN {
    require Config; import Config;
    $can_fork = $Config{'d_fork'} || $Config{'d_pseudofork'};

    if ($^O eq "hpux" or $Config{'extensions'} !~ /\bSocket\b/ &&
        !(($^O eq 'VMS') && $Config{d_socket})) {
        print "1..0\n";
        exit 0;
    }
}

{
    # This was in the BEGIN block, but since Test::More 0.47 added support to
    # detect forking, we don't need to fork before Test::More initialises.

    # Too many things in this test will hang forever if something is wrong,
    # so we need a self destruct timer. And IO can hang despite an alarm.

    if( $can_fork) {
        my $parent = $$;
        $child = fork;
        die "Fork failed" unless defined $child;
        if (!$child) {
            $SIG{INT} = sub {exit 0}; # You have 60 seconds. Your time starts now.
            my $must_finish_by = time + 60;
            my $remaining;
            while (($remaining = $must_finish_by - time) > 0) {
                sleep $remaining;
            }
            warn "Something unexpectedly hung during testing";
            kill "INT", $parent or die "Kill failed: $!";
            if( $^O eq "cygwin" ) {
                # sometimes the above isn't enough on cygwin
                sleep 1; # wait a little, it might have worked after all
                system( "/bin/kill -f $parent; echo die $parent" );
            }
            exit 1;
        }
    }
    unless ($has_perlio = PerlIO::Layer->can("find") && PerlIO::Layer->find('perlio')) {
        print <<EOF;
# Since you don't have perlio you might get failures with UTF-8 locales.
EOF
    }
}

use Socket;
use Test::More;
use strict;
use warnings;
use Errno;

my $skip_reason;

if( !$Config{d_alarm} ) {
    plan skip_all => "alarm() not implemented on this platform";
} elsif( !$can_fork ) {
    plan skip_all => "fork() not implemented on this platform";
} else {
    my ($lefth, $righth);
    # This should fail but not die if there is real socketpair
    eval {socketpair $lefth, $righth, -1, -1, -1};
    if ($@ =~ /^Unsupported socket function "socketpair" called/ ||
        $! =~ /^The operation requested is not supported./) { # Stratus VOS
        plan skip_all => 'No socketpair (real or emulated)';
    } else {
        eval {AF_UNIX};
        if ($@ =~ /^Your vendor has not defined Socket macro AF_UNIX/) {
            plan skip_all => 'No AF_UNIX';
        } else {
            plan tests => 45;
        }
    }
}

# But we'll install an alarm handler in case any of the races below fail.
$SIG{ALRM} = sub {die "Unexpected alarm during testing"};

my @left = ("hello ", "world\n");
my @right = ("perl ", "rules!"); # Not like I'm trying to bias any survey here.

my @gripping = (chr 255, chr 127);

{
    my ($lefth, $righth);

    ok (socketpair ($lefth, $righth, AF_UNIX, SOCK_STREAM, PF_UNSPEC),
        "socketpair (\$lefth, \$righth, AF_UNIX, SOCK_STREAM, PF_UNSPEC)")
        or print STDERR "# \$\! = $!\n";

    if ($has_perlio) {
        binmode($lefth,  ":bytes");
        binmode($righth, ":bytes");
    }

    foreach (@left) {
        # is (syswrite ($lefth, $_), length $_, "write " . _qq ($_) . " to left");
        is (syswrite ($lefth, $_), length $_, "syswrite to left");
    }
    foreach (@right) {
        # is (syswrite ($righth, $_), length $_, "write " . _qq ($_) . " to right");
        is (syswrite ($righth, $_), length $_, "syswrite to right");
    }

    # stream socket, so our writes will become joined:
    my ($buffer, $expect);
    $expect = join '', @right;
    undef $buffer;
    is (read ($lefth, $buffer, length $expect), length $expect, "read on left");
    is ($buffer, $expect, "content what we expected?");
    $expect = join '', @left;
    undef $buffer;
    is (read ($righth, $buffer, length $expect), length $expect, "read on right");
    is ($buffer, $expect, "content what we expected?");

    ok (shutdown($lefth, SHUT_WR), "shutdown left for writing");
    # This will hang forever if eof is buggy, and alarm doesn't interrupt system
    # Calls. Hence the child process minder.
    SKIP: {
        skip "SCO Unixware / OSR have a bug with shutdown",2 if $^O =~ /^(?:svr|sco)/;
        local $SIG{ALRM} = sub { warn "EOF on right took over 3 seconds" };
        local $TODO = "Known problems with unix sockets on $^O"
            if $^O eq 'hpux'   || $^O eq 'super-ux';
        alarm 3;
        $! = 0;
        ok (eof $righth, "right is at EOF");
        local $TODO = "Known problems with unix sockets on $^O"
            if $^O eq 'unicos' || $^O eq 'unicosmk';
        is ($!, '', 'and $! should report no error');
        alarm 60;
    }

    my $err = $!;
    $SIG{PIPE} = 'IGNORE';
    {
        local $SIG{ALRM} =
            sub { warn "syswrite to left didn't fail within 3 seconds" };
        alarm 3;
        # Split the system call from the is() - is() does IO so
        # (say) a flush may do a seek which on a pipe may disturb errno
        my $ans = syswrite ($lefth, "void");
        $err = $!;
        is ($ans, undef, "syswrite to shutdown left should fail");
        alarm 60;
    }
    {
        # This may need skipping on some OSes - restoring value saved above
        # should help
        $! = $err;
        ok (($!{EPIPE} or $!{ESHUTDOWN}), '$! should be EPIPE or ESHUTDOWN')
            or printf STDERR "# \$\! = %d (%s)\n", $err, $err;
    }

    foreach (@gripping) {
        is (syswrite ($righth, $_), length $_, "syswrite to right");
    }

    ok (!eof $lefth, "left is not at EOF");

    $expect = join '', @gripping;
    undef $buffer;
    is (read ($lefth, $buffer, length $expect), length $expect, "read on left");
    is ($buffer, $expect, "content what we expected?");

    ok (close $lefth, "close left");
    ok (close $righth, "close right");
}


# And now datagrams
# I suspect we also need a self destruct time-bomb for these, as I don't see any
# guarantee that the stack won't drop a UDP packet, even if it is for localhost.

SKIP: {
    skip "alarm doesn't interrupt I/O on this Perl", 24 if "$]" < 5.008;

    my $success = socketpair my $lefth, my $righth, AF_UNIX, SOCK_DGRAM, PF_UNSPEC;

    skip "No useable SOCK_DGRAM for socketpair", 24 if !$success and
        ($!{EAFNOSUPPORT} or $!{EOPNOTSUPP} or $!{EPROTONOSUPPORT} or $!{EPROTOTYPE});
    # Maybe this test is redundant now?
    skip "No usable SOCK_DGRAM for socketpair", 24 if ($^O =~ /^(MSWin32|os2)\z/);
    local $TODO = "socketpair not supported on $^O" if $^O eq 'nto';

    ok ($success, "socketpair (\$left, \$righth, AF_UNIX, SOCK_DGRAM, PF_UNSPEC)")
        or print STDERR "# \$\! = $!\n";

    if ($has_perlio) {
        binmode($lefth,  ":bytes");
        binmode($righth, ":bytes");
    }

    foreach (@left) {
        # is (syswrite ($lefth, $_), length $_, "write " . _qq ($_) . " to left");
        is (syswrite ($lefth, $_), length $_, "syswrite to left");
    }
    foreach (@right) {
        # is (syswrite ($righth, $_), length $_, "write " . _qq ($_) . " to right");
        is (syswrite ($righth, $_), length $_, "syswrite to right");
    }

    # stream socket, so our writes will become joined:
    my ($total, $buffer);
    $total = join '', @right;
    foreach my $expect (@right) {
        undef $buffer;
        is (sysread ($lefth, $buffer, length $total), length $expect, "read on left");
        is ($buffer, $expect, "content what we expected?");
    }
    $total = join '', @left;
    foreach my $expect (@left) {
        undef $buffer;
        is (sysread ($righth, $buffer, length $total), length $expect, "read on right");
        is ($buffer, $expect, "content what we expected?");
    }

    ok (shutdown($lefth, 1), "shutdown left for writing");

    # eof uses buffering. eof is indicated by a sysread of zero.
    # but for a datagram socket there's no way it can know nothing will ever be
    # sent
    SKIP: {
        skip "$^O does length 0 udp reads", 2 if ($^O eq 'os390');

        my $alarmed = 0;
        local $SIG{ALRM} = sub { $alarmed = 1; };
        print "# Approximate forever as 3 seconds. Wait 'forever'...\n";
        alarm 3;
        undef $buffer;
        is (sysread ($righth, $buffer, 1), undef,
            "read on right should be interrupted");
        is ($alarmed, 1, "alarm should have fired");
    }

    alarm 30;

    foreach (@gripping) {
        is (syswrite ($righth, $_), length $_, "syswrite to right");
    }

    $total = join '', @gripping;
    foreach my $expect (@gripping) {
        undef $buffer;
        is (sysread ($lefth, $buffer, length $total), length $expect, "read on left");
        is ($buffer, $expect, "content what we expected?");
    }

    ok (close $lefth, "close left");
    ok (close $righth, "close right");

} # end of DGRAM SKIP

kill "INT", $child or warn "Failed to kill child process $child: $!";
exit 0;
