<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package IPC::Open3;

use strict;
no strict 'refs'; # because users pass me bareword filehandles
our ($VERSION, @ISA, @EXPORT);

require Exporter;

use Carp;
use Symbol qw(gensym qualify);

$VERSION	= '1.13';
@ISA		= qw(Exporter);
@EXPORT		= qw(open3);

# &amp;open3: Marc Horowitz &lt;marc@mit.edu&gt;
# derived mostly from &amp;open2 by tom christiansen, &lt;tchrist@convex.com&gt;
# fixed for 5.001 by Ulrich Kunitz &lt;kunitz@mai-koeln.com&gt;
# ported to Win32 by Ron Schmidt, Merrill Lynch almost ended my career
# fixed for autovivving FHs, tchrist again
# allow fd numbers to be used, by Frank Tobin
# allow '-' as command (c.f. open "-|"), by Adam Spiers &lt;perl@adamspiers.org&gt;
#
# usage: $pid = open3('wtr', 'rdr', 'err' 'some cmd and args', 'optarg', ...);
#
# spawn the given $cmd and connect rdr for
# reading, wtr for writing, and err for errors.
# if err is '', or the same as rdr, then stdout and
# stderr of the child are on the same fh.  returns pid
# of child (or dies on failure).

# if wtr begins with '&lt;&amp;', then wtr will be closed in the parent, and
# the child will read from it directly.  if rdr or err begins with
# '&gt;&amp;', then the child will send output directly to that fd.  In both
# cases, there will be a dup() instead of a pipe() made.

# WARNING: this is dangerous, as you may block forever
# unless you are very careful.
#
# $wtr is left unbuffered.
#
# abort program if
#   rdr or wtr are null
#   a system call fails

our $Me = 'open3 (bug)';	# you should never see this, it's always localized

# Fatal.pm needs to be fixed WRT prototypes.

sub xpipe {
    pipe $_[0], $_[1] or croak "$Me: pipe($_[0], $_[1]) failed: $!";
}

# I tried using a * prototype character for the filehandle but it still
# disallows a bareword while compiling under strict subs.

sub xopen {
    open $_[0], $_[1], @_[2..$#_] and return;
    local $" = ', ';
    carp "$Me: open(@_) failed: $!";
}

sub xclose {
    $_[0] =~ /\A=?(\d+)\z/
	? do { my $fh; open($fh, $_[1] . '&amp;=' . $1) and close($fh); }
	: close $_[0]
	or croak "$Me: close($_[0]) failed: $!";
}

sub xfileno {
    return $1 if $_[0] =~ /\A=?(\d+)\z/;  # deal with fh just being an fd
    return fileno $_[0];
}

use constant FORCE_DEBUG_SPAWN =&gt; 0;
use constant DO_SPAWN =&gt; $^O eq 'os2' || $^O eq 'MSWin32' || FORCE_DEBUG_SPAWN;

sub _open3 {
    local $Me = shift;

    # simulate autovivification of filehandles because
    # it's too ugly to use @_ throughout to make perl do it for us
    # tchrist 5-Mar-00

    unless (eval  {
	$_[0] = gensym unless defined $_[0] &amp;&amp; length $_[0];
	$_[1] = gensym unless defined $_[1] &amp;&amp; length $_[1];
	1; })
    {
	# must strip crud for croak to add back, or looks ugly
	$@ =~ s/(?&lt;=value attempted) at .*//s;
	croak "$Me: $@";
    }

    my @handles = ({ mode =&gt; '&lt;', handle =&gt; \*STDIN },
		   { mode =&gt; '&gt;', handle =&gt; \*STDOUT },
		   { mode =&gt; '&gt;', handle =&gt; \*STDERR },
		  );

    foreach (@handles) {
	$_-&gt;{parent} = shift;
	$_-&gt;{open_as} = gensym;
    }

    if (@_ &gt; 1 and $_[0] eq '-') {
	croak "Arguments don't make sense when the command is '-'"
    }

    $handles[2]{parent} ||= $handles[1]{parent};
    $handles[2]{dup_of_out} = $handles[1]{parent} eq $handles[2]{parent};

    my $package;
    foreach (@handles) {
	$_-&gt;{dup} = ($_-&gt;{parent} =~ s/^[&lt;&gt;]&amp;//);

	if ($_-&gt;{parent} !~ /\A=?(\d+)\z/) {
	    # force unqualified filehandles into caller's package
	    $package //= caller 1;
	    $_-&gt;{parent} = qualify $_-&gt;{parent}, $package;
	}

	next if $_-&gt;{dup} or $_-&gt;{dup_of_out};
	if ($_-&gt;{mode} eq '&lt;') {
	    xpipe $_-&gt;{open_as}, $_-&gt;{parent};
	} else {
	    xpipe $_-&gt;{parent}, $_-&gt;{open_as};
	}
    }

    my $kidpid;
    if (!DO_SPAWN) {
	# Used to communicate exec failures.
	xpipe my $stat_r, my $stat_w;

	$kidpid = fork;
	croak "$Me: fork failed: $!" unless defined $kidpid;
	if ($kidpid == 0) {  # Kid
	    eval {
		# A tie in the parent should not be allowed to cause problems.
		untie *STDIN;
		untie *STDOUT;

		close $stat_r;
		require Fcntl;
		my $flags = fcntl $stat_w, &amp;Fcntl::F_GETFD, 0;
		croak "$Me: fcntl failed: $!" unless $flags;
		fcntl $stat_w, &amp;Fcntl::F_SETFD, $flags|&amp;Fcntl::FD_CLOEXEC
		    or croak "$Me: fcntl failed: $!";

		# If she wants to dup the kid's stderr onto her stdout I need to
		# save a copy of her stdout before I put something else there.
		if (!$handles[2]{dup_of_out} &amp;&amp; $handles[2]{dup}
			&amp;&amp; xfileno($handles[2]{parent}) == fileno \*STDOUT) {
		    my $tmp = gensym;
		    xopen($tmp, '&gt;&amp;', $handles[2]{parent});
		    $handles[2]{parent} = $tmp;
		}

		foreach (@handles) {
		    if ($_-&gt;{dup_of_out}) {
			xopen \*STDERR, "&gt;&amp;STDOUT"
			    if defined fileno STDERR &amp;&amp; fileno STDERR != fileno STDOUT;
		    } elsif ($_-&gt;{dup}) {
			xopen $_-&gt;{handle}, $_-&gt;{mode} . '&amp;', $_-&gt;{parent}
			    if fileno $_-&gt;{handle} != xfileno($_-&gt;{parent});
		    } else {
			xclose $_-&gt;{parent}, $_-&gt;{mode};
			xopen $_-&gt;{handle}, $_-&gt;{mode} . '&amp;=',
			    fileno $_-&gt;{open_as};
		    }
		}
		return 1 if ($_[0] eq '-');
		exec @_ or do {
		    local($")=(" ");
		    croak "$Me: exec of @_ failed";
		};
	    } and do {
                close $stat_w;
                return 0;
            };

	    my $bang = 0+$!;
	    my $err = $@;
	    utf8::encode $err if $] &gt;= 5.008;
	    print $stat_w pack('IIa*', $bang, length($err), $err);
	    close $stat_w;

	    eval { require POSIX; POSIX::_exit(255); };
	    exit 255;
	}
	else {  # Parent
	    close $stat_w;
	    my $to_read = length(pack('I', 0)) * 2;
	    my $bytes_read = read($stat_r, my $buf = '', $to_read);
	    if ($bytes_read) {
		(my $bang, $to_read) = unpack('II', $buf);
		read($stat_r, my $err = '', $to_read);
		if ($err) {
		    utf8::decode $err if $] &gt;= 5.008;
		} else {
		    $err = "$Me: " . ($! = $bang);
		}
		$! = $bang;
		die($err);
	    }
	}
    }
    else {  # DO_SPAWN
	# All the bookkeeping of coincidence between handles is
	# handled in spawn_with_handles.

	my @close;

	foreach (@handles) {
	    if ($_-&gt;{dup_of_out}) {
		$_-&gt;{open_as} = $handles[1]{open_as};
	    } elsif ($_-&gt;{dup}) {
		$_-&gt;{open_as} = $_-&gt;{parent} =~ /\A[0-9]+\z/
		    ? $_-&gt;{parent} : \*{$_-&gt;{parent}};
		push @close, $_-&gt;{open_as};
	    } else {
		push @close, \*{$_-&gt;{parent}}, $_-&gt;{open_as};
	    }
	}
	require IO::Pipe;
	$kidpid = eval {
	    spawn_with_handles(\@handles, \@close, @_);
	};
	die "$Me: $@" if $@;
    }

    foreach (@handles) {
	next if $_-&gt;{dup} or $_-&gt;{dup_of_out};
	xclose $_-&gt;{open_as}, $_-&gt;{mode};
    }

    # If the write handle is a dup give it away entirely, close my copy
    # of it.
    xclose $handles[0]{parent}, $handles[0]{mode} if $handles[0]{dup};

    select((select($handles[0]{parent}), $| = 1)[0]); # unbuffer pipe
    $kidpid;
}

sub open3 {
    if (@_ &lt; 4) {
	local $" = ', ';
	croak "open3(@_): not enough arguments";
    }
    return _open3 'open3', @_
}

sub spawn_with_handles {
    my $fds = shift;		# Fields: handle, mode, open_as
    my $close_in_child = shift;
    my ($fd, $pid, @saved_fh, $saved, %saved, @errs);

    foreach $fd (@$fds) {
	$fd-&gt;{tmp_copy} = IO::Handle-&gt;new_from_fd($fd-&gt;{handle}, $fd-&gt;{mode});
	$saved{fileno $fd-&gt;{handle}} = $fd-&gt;{tmp_copy} if $fd-&gt;{tmp_copy};
    }
    foreach $fd (@$fds) {
	bless $fd-&gt;{handle}, 'IO::Handle'
	    unless eval { $fd-&gt;{handle}-&gt;isa('IO::Handle') } ;
	# If some of handles to redirect-to coincide with handles to
	# redirect, we need to use saved variants:
	$fd-&gt;{handle}-&gt;fdopen(defined fileno $fd-&gt;{open_as}
			      ? $saved{fileno $fd-&gt;{open_as}} || $fd-&gt;{open_as}
			      : $fd-&gt;{open_as},
			      $fd-&gt;{mode});
    }
    unless ($^O eq 'MSWin32') {
	require Fcntl;
	# Stderr may be redirected below, so we save the err text:
	foreach $fd (@$close_in_child) {
	    next unless fileno $fd;
	    fcntl($fd, Fcntl::F_SETFD(), 1) or push @errs, "fcntl $fd: $!"
		unless $saved{fileno $fd}; # Do not close what we redirect!
	}
    }

    unless (@errs) {
	if (FORCE_DEBUG_SPAWN) {
	    pipe my $r, my $w or die "Pipe failed: $!";
	    $pid = fork;
	    die "Fork failed: $!" unless defined $pid;
	    if (!$pid) {
		{ no warnings; exec @_ }
		print $w 0 + $!;
		close $w;
		require POSIX;
		POSIX::_exit(255);
	    }
	    close $w;
	    my $bad = &lt;$r&gt;;
	    if (defined $bad) {
		$! = $bad;
		undef $pid;
	    }
	} else {
	    $pid = eval { system 1, @_ }; # 1 == P_NOWAIT
	}
	push @errs, "IO::Pipe: Can't spawn-NOWAIT: $!" if !$pid || $pid &lt; 0;
    }

    # Do this in reverse, so that STDERR is restored first:
    foreach $fd (reverse @$fds) {
	$fd-&gt;{handle}-&gt;fdopen($fd-&gt;{tmp_copy}, $fd-&gt;{mode});
    }
    foreach (values %saved) {
	$_-&gt;close or croak "Can't close: $!";
    }
    croak join "\n", @errs if @errs;
    return $pid;
}

1; # so require is happy
</pre></body></html>