You could use Win32::Socketpair::winopen2_5()

#! perl -slw
use strict;
use Win32::Socketpair qw[ winopen2_5 ];

( $pid, $sock ) = winopen2_5( 'perl.exe', q[-E"say 'hello'; warn; die;
+"] );
shutdown $sock, 1;
print while <$sock>;
close $sock;

__END__
C:\test>winopen2_5
Warning: something's wrong at -e line 1.

Died at -e line 1.

hello
[download]

Take a look at Win32::Job, a thin wrapper around Win32 Job objects. In the Win32::Job spawn() method, you can control stdin/stdout/stderr, while its run() method provides a simple way to run programs with a time limit. Another useful feature is that killing a job kills that process and all sub-processes spawned by it (similar to Unix process groups).

Sample code can be found at Re: Timing Windows commands.

This was the only module I had in mind, and did not take time to test it out before posting.

The module is great, and solves easily most of my problems.

Here is the code I wrote :

use warnings;
use strict;
use Data::Dumper;

use Win32::Job;

my $cmd = "sleep 20";
my ($min_time,$max_time,$kill_time) = (12,15,30);
my $i=1;
my $max_sent = 0;

my $job = Win32::Job->new;
my $pid = $job->spawn(undef, $cmd, { stdin  => 'NUL', stdout => 'stdou
+t.log', stderr => 'stdout.log'});
print "PID = $pid\n";
my $ok = $job->watch("handler", 1);

if($ok) { print "Done\n" ;     }
else    { print "Problem !\n"; }

my $status = $job->status;
print Dumper($status);

if($i<=$min_time) {
    print "MIN_TIME Too short...\n";
}   

sub handler {
    print "$pid still alive after $i sec\n";
    $i++;
    if($i>$max_time and $max_sent==0) {
        print "MAX_TIME Too long...\n";
        $max_sent = 1;
    }
    
    if($i>$kill_time) {
        print "KILL TIME : kill...\n";
        return 1;
    }

    return 0;
}
[download]

Now... same issue as before. I don't manage to distinguish the fact that the process launched was killed externally, or finished with exit-code 1. Any idea about that ?

Also, what if my perl process is killed (by the task manager for example) ? I tried :

$SIG{INT} = sub { die "Caught a INT $!" };
$SIG{ABRT} = sub { die "Caught a SIGABRT $!" };
$SIG{FPE} = sub { die "Caught a SIGFPE $!" };
$SIG{ILL} = sub { die "Caught a SIGILL $!" };
$SIG{INT} = sub { die "Caught a SIGINT $!" };
$SIG{SEGV} = sub { die "Caught a SIGSEGV $!" };
$SIG{TERM} = sub { die "Caught a SIGTERM $!" };
[download]

But none is actually called. Any idea ?

use warnings;
use strict;
use Win32::Process;
use Win32::Process 'STILL_ACTIVE';
use Win32::Process::Info qw{WMI};

my $child_pid;
my $real_child_pid;
my $child_proc;
my $cmd = 'perl -e"sleep 20"';

my $debug = 1;
my $exitcode = 1; 


my $stdout = 'out.txt';
my $stderr = 'err.txt';

Win32::Process::Create($child_proc, $ENV{COMSPEC}, "/c $cmd > $stdout 
+2>$stderr", 0, 0, ".") || print Win32::FormatMessage( Win32::GetLastE
+rror());
$child_pid = $child_proc->GetProcessID();
my $pi = Win32::Process::Info->new();

my ($min_time,$max_time,$kill_time) = (12,15,18);
if($child_pid!=0) {
    print "Started child process id $child_pid\n";
    my %subs = $pi->Subprocesses($child_pid);
        my $real_child_pid = $subs{$child_pid}[0];
        print "Real child process id $real_child_pid\n";
        #use Data::Dumper;
        #print Dumper(\%subs);
    my $i=0;
    while ( 'true' ) {
        $child_proc->Wait(1000);
        $i++;
        $child_proc->GetExitCode($exitcode);
        if ( $exitcode == STILL_ACTIVE ) {
            print "loop $i\n";
            if($i==$max_time) {
                print "max time : this is quite long...\n";
            }
            if($i==$kill_time) {
                print "kill time : kill $child_pid\n";
                $child_proc->Kill(-1);
            }
    
        } 
        else {
            print "### E = $^E ?=$? ###\n";
            print " Process terminated on it's own rc=$exitcode \n";
            
            if($i==$min_time) {
                print "min time : command was too short\n";
            }
            exit $exitcode;
        }
    }
}
else {
    print "Can't start process...\n";
}
[download]

Thanks for the tip. I have tried this version, and indeed, I can recover the real PID of my process and kill it with

Win32::Process::KillProcess($real_child_pid, "-1");

(Note that for some reason, the standard

kill -9 , $real_child_pid

is not working. But I don't care much as long as I can kill the process, one way or another

Any idea about knowing if the process was killed or terminated on its own ?

Try system_detached

that is launch a detached process in the background with a new shell, have that process be a perl program that spawn whatever you're really spawning , capture STDIN/STDERR/... IPC::Run3/Capture:: Tiny... save wherever you want to save, and exit with the true programs exit value

if it takes too long kill it

Then get data from cache or tempfiles, perform any cleanup ... whatever

I'm not very comfortable having a perl process spawning another perl process launching a command.
Moreover, it does not solve all my problems (I'm not even sure it does solve any ?)

Moreover, it does not solve all my problems (I'm not even sure it does solve any ?)

So you tried it?