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