cpan/Socket/t/socketpair.t

   1 #!./perl -w
   2
   3 my $child;
   4 my $can_fork;
   5 my $has_perlio;
   6
   7 BEGIN {
   8     require Config; import Config;
   9     $can_fork = $Config{'d_fork'} || $Config{'d_pseudofork'};
  10
  11     if ($^O eq "hpux" or $Config{'extensions'} !~ /\bSocket\b/ &&
  12         !(($^O eq 'VMS') && $Config{d_socket})) {
  13         print "1..0\n";
  14         exit 0;
  15     }
  16 }
  17
  18 {
  19     # This was in the BEGIN block, but since Test::More 0.47 added support to
  20     # detect forking, we don't need to fork before Test::More initialises.
  21
  22     # Too many things in this test will hang forever if something is wrong,
  23     # so we need a self destruct timer. And IO can hang despite an alarm.
  24
  25     if( $can_fork) {
  26       my $parent = $$;
  27       $child = fork;
  28       die "Fork failed" unless defined $child;
  29       if (!$child) {
  30         $SIG{INT} = sub {exit 0}; # You have 60 seconds. Your time starts now.
  31         my $must_finish_by = time + 60;
  32         my $remaining;
  33         while (($remaining = $must_finish_by - time) > 0) {
  34           sleep $remaining;
  35         }
  36         warn "Something unexpectedly hung during testing";
  37         kill "INT", $parent or die "Kill failed: $!";
  38         exit 1;
  39       }
  40     }
  41     unless ($has_perlio = find PerlIO::Layer 'perlio') {
  42         print <<EOF;
  43 # Since you don't have perlio you might get failures with UTF-8 locales.
  44 EOF
  45     }
  46 }
  47
  48 use Socket;
  49 use Test::More;
  50 use strict;
  51 use warnings;
  52 use Errno;
  53
  54 my $skip_reason;
  55
  56 if( !$Config{d_alarm} ) {
  57   plan skip_all => "alarm() not implemented on this platform";
  58 } elsif( !$can_fork ) {
  59   plan skip_all => "fork() not implemented on this platform";
  60 } else {
  61   # This should fail but not die if there is real socketpair
  62   eval {socketpair LEFT, RIGHT, -1, -1, -1};
  63   if ($@ =~ /^Unsupported socket function "socketpair" called/ ||
  64       $! =~ /^The operation requested is not supported./) { # Stratus VOS
  65     plan skip_all => 'No socketpair (real or emulated)';
  66   } else {
  67     eval {AF_UNIX};
  68     if ($@ =~ /^Your vendor has not defined Socket macro AF_UNIX/) {
  69       plan skip_all => 'No AF_UNIX';
  70     } else {
  71       plan tests => 45;
  72     }
  73   }
  74 }
  75
  76 # But we'll install an alarm handler in case any of the races below fail.
  77 $SIG{ALRM} = sub {die "Unexpected alarm during testing"};
  78
  79 ok (socketpair (LEFT, RIGHT, AF_UNIX, SOCK_STREAM, PF_UNSPEC),
  80     "socketpair (LEFT, RIGHT, AF_UNIX, SOCK_STREAM, PF_UNSPEC)")
  81   or print "# \$\! = $!\n";
  82
  83 if ($has_perlio) {
  84     binmode(LEFT,  ":bytes");
  85     binmode(RIGHT, ":bytes");
  86 }
  87
  88 my @left = ("hello ", "world\n");
  89 my @right = ("perl ", "rules!"); # Not like I'm trying to bias any survey here.
  90
  91 foreach (@left) {
  92   # is (syswrite (LEFT, $_), length $_, "write " . _qq ($_) . " to left");
  93   is (syswrite (LEFT, $_), length $_, "syswrite to left");
  94 }
  95 foreach (@right) {
  96   # is (syswrite (RIGHT, $_), length $_, "write " . _qq ($_) . " to right");
  97   is (syswrite (RIGHT, $_), length $_, "syswrite to right");
  98 }
  99
 100 # stream socket, so our writes will become joined:
 101 my ($buffer, $expect);
 102 $expect = join '', @right;
 103 undef $buffer;
 104 is (read (LEFT, $buffer, length $expect), length $expect, "read on left");
 105 is ($buffer, $expect, "content what we expected?");
 106 $expect = join '', @left;
 107 undef $buffer;
 108 is (read (RIGHT, $buffer, length $expect), length $expect, "read on right");
 109 is ($buffer, $expect, "content what we expected?");
 110
 111 ok (shutdown(LEFT, SHUT_WR), "shutdown left for writing");
 112 # This will hang forever if eof is buggy, and alarm doesn't interrupt system
 113 # Calls. Hence the child process minder.
 114 SKIP: {
 115   skip "SCO Unixware / OSR have a bug with shutdown",2 if $^O =~ /^(?:svr|sco)/;
 116   local $SIG{ALRM} = sub { warn "EOF on right took over 3 seconds" };
 117   local $TODO = "Known problems with unix sockets on $^O"
 118       if $^O eq 'hpux'   || $^O eq 'super-ux';
 119   alarm 3;
 120   $! = 0;
 121   ok (eof RIGHT, "right is at EOF");
 122   local $TODO = "Known problems with unix sockets on $^O"
 123       if $^O eq 'unicos' || $^O eq 'unicosmk';
 124   is ($!, '', 'and $! should report no error');
 125   alarm 60;
 126 }
 127
 128 my $err = $!;
 129 $SIG{PIPE} = 'IGNORE';
 130 {
 131   local $SIG{ALRM}
 132     = sub { warn "syswrite to left didn't fail within 3 seconds" };
 133   alarm 3;
 134   # Split the system call from the is() - is() does IO so
 135   # (say) a flush may do a seek which on a pipe may disturb errno
 136   my $ans = syswrite (LEFT, "void");
 137   $err = $!;
 138   is ($ans, undef, "syswrite to shutdown left should fail");
 139   alarm 60;
 140 }
 141 {
 142   # This may need skipping on some OSes - restoring value saved above
 143   # should help
 144   $! = $err;
 145   ok (($!{EPIPE} or $!{ESHUTDOWN}), '$! should be EPIPE or ESHUTDOWN')
 146     or printf "\$\!=%d(%s)\n", $err, $err;
 147 }
 148
 149 my @gripping = (chr 255, chr 127);
 150 foreach (@gripping) {
 151   is (syswrite (RIGHT, $_), length $_, "syswrite to right");
 152 }
 153
 154 ok (!eof LEFT, "left is not at EOF");
 155
 156 $expect = join '', @gripping;
 157 undef $buffer;
 158 is (read (LEFT, $buffer, length $expect), length $expect, "read on left");
 159 is ($buffer, $expect, "content what we expected?");
 160
 161 ok (close LEFT, "close left");
 162 ok (close RIGHT, "close right");
 163
 164
 165 # And now datagrams
 166 # I suspect we also need a self destruct time-bomb for these, as I don't see any
 167 # guarantee that the stack won't drop a UDP packet, even if it is for localhost.
 168
 169 SKIP: {
 170   skip "No usable SOCK_DGRAM for socketpair", 24 if ($^O =~ /^(MSWin32|os2)\z/);
 171   local $TODO = "socketpair not supported on $^O" if $^O eq 'nto';
 172
 173 ok (socketpair (LEFT, RIGHT, AF_UNIX, SOCK_DGRAM, PF_UNSPEC),
 174     "socketpair (LEFT, RIGHT, AF_UNIX, SOCK_DGRAM, PF_UNSPEC)")
 175   or print "# \$\! = $!\n";
 176
 177 if ($has_perlio) {
 178     binmode(LEFT,  ":bytes");
 179     binmode(RIGHT, ":bytes");
 180 }
 181
 182 foreach (@left) {
 183   # is (syswrite (LEFT, $_), length $_, "write " . _qq ($_) . " to left");
 184   is (syswrite (LEFT, $_), length $_, "syswrite to left");
 185 }
 186 foreach (@right) {
 187   # is (syswrite (RIGHT, $_), length $_, "write " . _qq ($_) . " to right");
 188   is (syswrite (RIGHT, $_), length $_, "syswrite to right");
 189 }
 190
 191 # stream socket, so our writes will become joined:
 192 my ($total);
 193 $total = join '', @right;
 194 foreach $expect (@right) {
 195   undef $buffer;
 196   is (sysread (LEFT, $buffer, length $total), length $expect, "read on left");
 197   is ($buffer, $expect, "content what we expected?");
 198 }
 199 $total = join '', @left;
 200 foreach $expect (@left) {
 201   undef $buffer;
 202   is (sysread (RIGHT, $buffer, length $total), length $expect, "read on right");
 203   is ($buffer, $expect, "content what we expected?");
 204 }
 205
 206 ok (shutdown(LEFT, 1), "shutdown left for writing");
 207
 208 # eof uses buffering. eof is indicated by a sysread of zero.
 209 # but for a datagram socket there's no way it can know nothing will ever be
 210 # sent
 211 SKIP: {
 212   skip "$^O does length 0 udp reads", 2 if ($^O eq 'os390');
 213
 214   my $alarmed = 0;
 215   local $SIG{ALRM} = sub { $alarmed = 1; };
 216   print "# Approximate forever as 3 seconds. Wait 'forever'...\n";
 217   alarm 3;
 218   undef $buffer;
 219   is (sysread (RIGHT, $buffer, 1), undef,
 220       "read on right should be interrupted");
 221   is ($alarmed, 1, "alarm should have fired");
 222 }
 223
 224 alarm 30;
 225
 226 #ok (eof RIGHT, "right is at EOF");
 227
 228 foreach (@gripping) {
 229   is (syswrite (RIGHT, $_), length $_, "syswrite to right");
 230 }
 231
 232 $total = join '', @gripping;
 233 foreach $expect (@gripping) {
 234   undef $buffer;
 235   is (sysread (LEFT, $buffer, length $total), length $expect, "read on left");
 236   is ($buffer, $expect, "content what we expected?");
 237 }
 238
 239 ok (close LEFT, "close left");
 240 ok (close RIGHT, "close right");
 241
 242 } # end of DGRAM SKIP
 243
 244 kill "INT", $child or warn "Failed to kill child process $child: $!";
 245 exit 0;