ext/Socket/t/socketpair.t

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