File Coverage

blib/lib/Win32/Process/Info.pm

Criterion	Covered	Total	%
statement	50	208	24.0
branch	11	114	9.6
condition	1	27	3.7
subroutine	12	23	52.1
pod	9	9	100.0
total	83	381	21.7

=head1 NAME

Win32::Process::Info - Provide process information for Windows 32 systems.

=head1 SYNOPSIS

 use Win32::Process::Info;
 $pi = Win32::Process::Info->new ();
 $pi->Set (elapsed_in_seconds => 0);	# In clunks, not seconds.
 @pids = $pi->ListPids ();	# Get all known PIDs
 @info = $pi->GetProcInfo ();	# Get the max
 %subs = $pi->Subprocesses ();	# Figure out subprocess relationships.
 @info = grep {
     defined $_->{Name} &&
     $_->{Name} =~ m/perl/
 } $pi->GetProcInfo ();        # All processes with 'perl' in name.

=head1 NOTICE

This package covers a multitude of sins - as many as Microsoft has
invented ways to get process info and I have resources and gumption
to code. The key to this mess is the 'variant' argument to the 'new'
method (q.v.).

The WMI variant has various problems, known or suspected to be inherited
from Win32::OLE. See L for the gory details. The worst of these
is that if you use fork(), you B disallow WMI completely by
loading this module as follows:

 use Win32::Process::Info qw{NT};

This method of controlling things must be considered experimental until
I can confirm it causes no unexpected insurmountable problems. If I am
forced to change it, the change will be flagged prominently in the
documentation.

This change is somewhat incompatible with 1.006 and earlier because it
requires the import() method to be called in the correct place with the
correct arguments. If you C, you B
explicitly call Win32::Process::Info->import().

See the import() documentation below for the details.

B

=head1 DESCRIPTION

The main purpose of the Win32::Process::Info package is to get whatever
information is convenient (for the author!) about one or more Windows
32 processes. L is therefore the most-important
method in the package. See it for more information.

The process IDs made available are those returned by the variant in
use. See the documentation to the individual variants for details,
especially if you are a Cygwin user.

Unless explicitly stated otherwise, modules, variables, and so
on are considered private. That is, the author reserves the right
to make arbitrary changes in the way they work, without telling
anyone. For methods, variables, and so on which are considered
public, the author will make an effort keep them stable, and failing
that to call attention to changes.

The following methods should be considered public:

=over 4

=cut

package Win32::Process::Info;

use 5.006;

use strict;
use warnings;

our $VERSION = '1.023';

use Carp;
use File::Spec;
use Time::Local;

our %static = (
    elapsed_in_seconds	=> 1,
    variant		=> $ENV{PERL_WIN32_PROCESS_INFO_VARIANT},
    );

#	The real reason for the %variant_support hash is to deal with
#	the apparant inability of Win32::API to be 'require'-d anywhere
#	but in a BEGIN block. The 'unsupported' key is intended to be
#	used as a 'necessary but not required' criterion; that is, if
#	'unsupported' is true, there's no reason to bother; but if it's
#	false, there may still be problems of some sort. This is par-
#	ticularly true of WMI, where the full check is rather elephan-
#	tine.
#
#	The actual 'necessary but not required' check has moved to
#	{check_support}, with {unsupported} simply holding the result of
#	the check. The {check_support} key is code to be executed when
#	the import() hook is called when the module is loaded.
#
#	While I was at it, I decided to consolidate all the variant-
#	specific information in one spot and, while I was at it, write
#	a variant checker utility.

my %variant_support;
BEGIN {
    # Cygwin has its own idea of what a process ID is, independent of
    # the underlying operating system. The Cygwin Perl implements this,
    # so if we're Cygwin we need to compensate. This MUST return the
    # Windows-native form under Cygwin, which means any variant which
    # needs another form must override.

    if ( $^O eq 'cygwin' ) {
	*My_Pid = sub {
	    return Cygwin::pid_to_winpid( $$ );
	};
    } else {
	*My_Pid = sub {
	    return $$;
	};
    }
    %variant_support = (
	NT => {
	    check_support => sub {
		local $@;
		eval {
		    require Win32;
		    Win32->can( 'IsWinNT' ) && Win32::IsWinNT();
		} or return "$^O is not a member of the Windows NT family";
		eval { require Win32::API; 1 }
		    or return 'I can not find Win32::API';
		my @path = File::Spec->path();
DLL_LOOP:
		foreach my $dll (qw{PSAPI.DLL ADVAPI32.DLL KERNEL32.DLL}) {
		    foreach my $loc (@path) {
			next DLL_LOOP if -e File::Spec->catfile ($loc, $dll);
		    }
		    return "I can not find $dll";
		}
		return 0;
	    },
	    make => sub {
		require Win32::Process::Info::NT;
		Win32::Process::Info::NT->new (@_);
	    },
	    unsupported => "Disallowed on load of @{[__PACKAGE__]}.",
	},
	PT => {
	    check_support => sub {
		local $@;
		return "Unable to load Proc::ProcessTable"
		    unless eval {require Proc::ProcessTable; 1};
		return 0;
	    },
	    make => sub {
		require Win32::Process::Info::PT;
		Win32::Process::Info::PT->new (@_);
	    },
	    unsupported => "Disallowed on load of @{[__PACKAGE__]}.",
	},
	WMI => {
	    check_support => sub {
		local $@;
		_isReactOS()
		    and return 'Unsupported under ReactOS';
		eval {
		    require Win32::OLE;
		    1;
		} or return 'Unable to load Win32::OLE';
		my ( $wmi, $proc );
		my $old_warn = Win32::OLE->Option( 'Warn' );
		eval {
		    Win32::OLE->Option( Warn => 0 );
		    $wmi = Win32::OLE->GetObject(
			'winmgmts:{impersonationLevel=impersonate,(Debug)}!//./root/cimv2'
		    );
		    $wmi and $proc = $wmi->Get(
			sprintf q{Win32_Process='%s'}, __PACKAGE__->My_Pid()
		    );
		};
		Win32::OLE->Option( Warn => $old_warn );
		$wmi or return 'Unable to get WMI object';
		$proc or return 'WMI broken: unable to get process object';
		return 0;
	    },
	    make => sub {
		require Win32::Process::Info::WMI;
		Win32::Process::Info::WMI->new (@_);
	    },
	    unsupported => "Disallowed on load of @{[__PACKAGE__]}.",
	},
    );
}

our %mutator = (
    elapsed_in_seconds	=> sub {$_[2]},
    variant		=> sub {
	ref $_[0]
	    and eval { $_[0]->isa( 'Win32::Process::Info' ) }
	    or croak 'Variant can not be set on an instance';
	foreach (split '\W+', $_[2]) {
	    my $status;
	    $status = variant_support_status( $_ )
		and croak "Variant '$_' unsupported on your configuration; ",
		    $status;
	}
	$_[2]
    },
);


=item $pi = Win32::Process::Info->new ([machine], [variant], [hash])

This method instantiates a process information object, connected
to the given machine, and using the given variant.

The following variants are currently supported:

NT - Uses the NT-native mechanism. Good on any NT, including
Windows 2000. This variant does not support connecting to
another machine, so the 'machine' argument must be an
empty string (or undef, if you prefer).

PT - Uses Dan Urist's Proc::ProcessTable, making it possible
(paradoxically) to use this module on other operating systems than
Windows. Only those Proc::ProcessTable::Process fields which seem
to correspond to WMI items are returned. B the PT variant
is to be considered experimental, and may be changed or retracted
in future releases.

WMI - Uses the Windows Management Implementation. Good on Win2K, ME,
and possibly others, depending on their vintage and whether
WMI has been retrofitted.

The initial default variant comes from environment variable
PERL_WIN32_PROCESS_INFO_VARIANT. If this is not found, it will be
'WMI,NT,PT', which means to try WMI first, NT if WMI fails, and PT as a
last resort. This can be changed using Win32::Process::Info->Set
(variant => whatever).

The hash argument is a hash reference to additional arguments, if
any. The hash reference can actually appear anywhere in the argument
list, though positional arguments are illegal after the hash reference.

The following hash keys are supported:

  variant => corresponds to the 'variant' argument (all)
  assert_debug_priv => assert debug if available (all) This
	only has effect under WMI. The NT variant always
	asserts debug. You want to be careful doing this
	under WMI if you're fetching the process owner
	information, since the script can be badly behaved
	(i.e. die horribly) for those processes whose
	ExecutablePath is only available with the debug
	privilege turned on.
  host => corresponds to the 'machine' argument (WMI)
  user => username to perform operation under (WMI)
  password => password corresponding to the given
	username (WMI)

ALL hash keys are optional. SOME hash keys are only supported under
certain variants. These are indicated in parentheses after the
description of the key. It is an error to specify a key that the
variant in use does not support.

=cut

my @argnam = qw{host variant};
sub new {
    my ($class, @params) = @_;
    $class = ref $class if ref $class;
    my %arg;
    my ( $self, @probs );

    my $inx = 0;
    foreach my $inp (@params) {
	if (ref $inp eq 'HASH') {
	    foreach my $key (keys %$inp) {$arg{$key} = $inp->{$key}}
	} elsif (ref $inp) {
	    croak "Argument may not be @{[ref $inp]} reference.";
	} elsif ($argnam[$inx]) {
	    $arg{$argnam[$inx]} = $inp;
	} else {
	    croak "Too many positional arguments.";
	}
	$inx++;
    }

    _import_done()
	or croak __PACKAGE__,
	    '->import() must be called before calling ', __PACKAGE__,
	    '->new()';
    my $mach = $arg{host} or delete $arg{host};
    my $try = $arg{variant} || $static{variant} || 'WMI,NT,PT';
    foreach my $variant (grep {$_} split '\W+', $try) {
	my $status;
	$status = variant_support_status( $variant ) and do {
	    push @probs, $status;
	    next;
	};
	my $self;
	$self = $variant_support{$variant}{make}->( \%arg ) and do {
	    $static{variant} ||= $self->{variant} = $variant;
	};
	return $self;
    }
    croak join '; ', @probs;
}

=item @values = $pi->Get (attributes ...)

This method returns the values of the listed attributes. If
called in scalar context, it returns the value of the first
attribute specified, or undef if none was. An exception is
raised if you specify a non-existent attribute.

This method can also be called as a class method (that is, as
Win32::Process::Info->Get ()) to return default attributes values.

The relevant attribute names are:

B is TRUE to convert elapsed user and
kernel times to seconds. If FALSE, they are returned in
clunks (that is, hundreds of nanoseconds). The default is
TRUE.

B is the variant of the Process::Info code in use,
and should be zero or more of 'WMI' or 'NT', separated by
commas. 'WMI' selects the Windows Management Implementation, and
'NT' selects the Windows NT native interface.

B is the name of the machine connected to. This is
not available as a class attribute.

=cut

sub Get {
my ($self, @args) = @_;
$self = \%static unless ref $self;
my @vals;
foreach my $name (@args) {
    croak "Error - Attribute '$name' does not exist."
	unless exists $self->{$name};
    croak "Error - Attribute '$name' is private."
	if $name =~ m/^_/;
    push @vals, $self->{$name};
    }
return wantarray ? @vals : $vals[0];
}

=item @values = $pi->Set (attribute => value ...)

This method sets the values of the listed attributes,
returning the values of all attributes listed if called in
list context, or of the first attribute listed if called
in scalar context.

This method can also be called as a class method (that is, as
Win32::Process::Info->Set ()) to change default attribute values.

The relevant attribute names are the same as for Get.
However:

B is read-only at the instance level. That is,
Win32::Process::Info->Set (variant => 'NT') is OK, but
$pi->Set (variant => 'NT') will raise an exception. If
you set B to an empty string (the default), the
next "new" will iterate over all possibilities (or the
contents of environment variable
PERL_WIN32_PROCESS_INFO_VARIANT if present), and set
B to the first one that actually works.

B is not available as a class attribute, and is
read-only as an instance attribute. It is B useful for
discovering your machine name - if you instantiated the
object without specifying a machine name, you will get
nothing useful back.

=cut

sub Set {
my ($self, @args) = @_;
croak "Error - Set requires an even number of arguments."
    if @args % 2;
$self = \%static unless ref $self;
my $mutr = $self->{_mutator} || \%mutator;
my @vals;
while (@args) {
    my $name = shift @args;
    my $val = shift @args;
    croak "Error - Attribute '$name' does not exist."
	unless exists $self->{$name};
    croak "Error - Attribute '$name' is read-only."
	unless exists $mutr->{$name};
    $self->{$name} = $mutr->{$name}->($self, $name, $val);
    push @vals, $self->{$name};
    }
return wantarray ? @vals : $vals[0];
}

=item @pids = $pi->ListPids ();

This method lists all known process IDs in the system. If
called in scalar context, it returns a reference to the
list of PIDs. If you pass in a list of pids, the return will
be the intersection of the argument list and the actual PIDs
in the system.

=cut

sub ListPids {
   confess
   "Error - Whoever coded this forgot to override ListPids.";
}

=item @info = $pi->GetProcInfo ();

This method returns a list of anonymous hashes, each containing
information on one process. If no arguments are passed, the
list represents all processes in the system. You can pass a
list of process IDs, and get out a list of the attributes of
all such processes that actually exist. If you call this
method in scalar context, you get a reference to the list.

What keys are available depends on the variant in use.
You can hope to get at least the following keys for a
"normal" process (i.e. not the idle process, which is PID 0,
nor the system, which is some small indeterminate PID) to
which you have access:

    CreationDate
    ExecutablePath
    KernelModeTime
    MaximumWorkingSetSize
    MinimumWorkingSetSize
    Name (generally the name of the executable file)
    ProcessId
    UserModeTime

You may find other keys available as well, depending on which
operating system you're using, and which variant of Process::Info
you're using.

This method also optionally takes as its first argument a reference
to a hash of option values. The only supported key is:

    no_user_info => 1
	Do not return keys Owner and OwnerSid, even if available.
	These tend to be time-consuming, and can cause problems
	under the WMI variant.

=cut

sub GetProcInfo {
    confess
    "Programming Error - Whoever coded this forgot to override GetProcInfo.";
}

=item Win32::Process::Info->import ()

The purpose of this static method is to specify which variants of the
functionality are legal to use. Possible arguments are 'NT', 'WMI',
'PT', or some combination of these (e.g. ('NT', 'WMI')). Unrecognized
arguments are ignored, though this may change if this class becomes a
subclass of Exporter. If called with no arguments, it is as though it
were called with arguments ('NT', 'WMI', 'PT'). See L, below, for
why this mess was introduced in the first place.

This method must be called at least once, B, or B
variants will be legal to use. Usually it does B need to be
explicitly called by the user, since it is called implicitly when you
C. If you C
you B have to call this method explicitly.

If this method is called more than once, the second and subsequent calls
will have no effect on what variants are available. The reason for this
will be made clear (I hope!) under L, below.

The only time a user of this module needs to do anything different
versus version 1.006 and previous of this module is if this module is
being loaded in such a way that this method is not implicitly called.
This can happen two ways:

 use Win32::Process::Info ();

explicitly bypasses the implicit call of this method. Don't do that.

 require Win32::Process::Info;

also does not call this method. If you must load this module using
require rather than use, follow the require with

 Win32::Process::Info->import ();

passing any necessary arguments.

=cut

{	# Begin local symbol block.

    my $idempotent;

    sub import {	## no critic (RequireArgUnpacking)
	my ($pkg, @params) = @_;
	my (@args, @vars);
	foreach (@params) {
	    if (exists $variant_support{$_}) {
		push @vars, $_;
	    } else {
		push @args, $_;
	    }
	}

	if ($idempotent++) {
	    # Warning here maybe?
	} else {
	    @vars or push @vars, keys %variant_support;
	    foreach my $try (@vars) {
		$variant_support{$try} or next;
		$variant_support{$try}{unsupported} = eval {
		    $variant_support{$try}{check_support}->()} || $@;
	    }
	}

	return;

#	Do this if we become a subclass of Exporter
#	@_ = ( $pkg, @args );
#	goto &Exporter::import;;
    }

    # Return the number of times import() done.
    sub _import_done {
	return $idempotent;
    }

}	# End local symbol block.


{
    my $is_reactos = $^O eq 'MSWin32' &&
	defined $ENV{OS} && lc $ENV{OS} eq 'reactos';
    sub _isReactOS {
	return $is_reactos;
    }
}


=item %subs = $pi->Subprocesses ([pid ...])

This method takes as its argument a list of PIDs, and returns a hash
indexed by PID and containing, for each PID, a reference to a list of
all subprocesses of that process. If those processes have subprocesses
as well, you will get the sub-sub processes, and so ad infinitum, so
you may well get back more hash keys than you passed process IDs. Note
that the process of finding the sub-sub processes is iterative, not
recursive; so you don't get back a tree.

If no argument is passed, you get all processes in the system.

If called in scalar context you get a reference to the hash.

This method works off the ParentProcessId attribute. Not all variants
support this. If the variant you're using doesn't support this
attribute, you get back an empty hash. Specifically:

 NT -> unsupported
 PT -> supported
 WMI -> supported

=cut

sub Subprocesses {
my ($self, @args) = @_;
my %prox = map {($_->{ProcessId} => $_)}
	@{$self->GetProcInfo ({no_user_info => 1})};
my %subs;
my $rslt = \%subs;
my $key_found;
foreach my $proc (values %prox) {
    $subs{$proc->{ProcessId}} ||= [];
    # TRW 1.011_01 next unless $proc->{ParentProcessId};
    defined (my $pop = $proc->{ParentProcessId}) or next; # TRW 1.011_01
    $key_found++;
    # TRW 1.011_01 next unless $prox{$proc->{ParentProcessId}};
    $prox{$pop} or next;	# TRW 1.011_01
# TRW 1.012_02    $proc->{CreationDate} >= $prox{$pop}{CreationDate} or next;	# TRW 1.011_01
    (defined($proc->{CreationDate}) &&
	defined($prox{$pop}{CreationDate}) &&
        $proc->{CreationDate} >= $prox{$pop}{CreationDate})
	or next;	# TRW 1.012_02
    # TRW 1.011_01 push @{$subs{$proc->{ParentProcessId}}}, $proc->{ProcessId};
    push @{$subs{$pop}}, $proc->{ProcessId};
    }
my %listed;
return %listed unless $key_found;
if (@args) {
    $rslt = \%listed;
    while (@args) {
	my $pid = shift @args;
	next unless $subs{$pid};	# TRW 1.006
	next if $listed{$pid};
	$listed{$pid} = $subs{$pid};
	push @args, @{$subs{$pid}};
	}
    }
return wantarray ? %$rslt : $rslt;
}

=item @info = $pi->SubProcInfo ();

This is a convenience method which wraps GetProcInfo(). It has the same
calling sequence, and returns generally the same data. But the data
returned by this method will also have the {subProcesses} key, which
will contain a reference to an array of hash references representing the
data on subprocesses of each process.

Unlike the data returned from Subprocesses(), the data here are not
flattened; so if you specify one or more process IDs as arguments, you
will get back at most the number of process IDs you specified; fewer if
some of the specified processes do not exist.

B that a given process can occur more than once in the
output. If you call SubProcInfo without arguments, the @info array will
contain every process in the system, even those which are also in some
other process' {subProcesses} array.

Also unlike Subprocesses(), you will get an exception if you use this
method with a variant that does not support the ParentProcessId key.

=cut

sub SubProcInfo {
    my ($self, @args) = @_;
    my $opt = ref $args[0] eq 'HASH' ? shift @args : {};
    my @data = $self->GetProcInfo ($opt);
    my %subs = map {$_->{ProcessId} => $_} @data;
    my $bingo;
    foreach my $proc (@data) {
	exists $proc->{ParentProcessId} or next;
	$proc->{subProcesses} ||= [];
	$bingo++;
	defined (my $dad = $subs{$proc->{ParentProcessId}}) or next;
	(defined $dad->{CreationDate} && defined $proc->{CreationDate})
	    or next;
	$dad->{CreationDate} > $proc->{CreationDate} and next;
	push @{$dad->{subProcesses} ||= []}, $proc;
    }
    $bingo or croak "Error - Variant '@{[$self->Get('variant')
    ]}' does not support the ParentProcessId key";
    if (@args) {
	return (map {exists $subs{$_} ? $subs{$_} : ()} @args);
    } else {
	return @data;
    }
}

=item $pid = $pi->My_Pid()

This convenience method returns the process ID of the current process,
in a form appropriate to the operating system and the variant in use.
Normally, it simply returns C<$$>. But Cygwin has its own idea of what
the process ID is, which may differ from Windows. Worse than that, under
Cygwin the NT and WMI variants return Windows PIDs, while PT appears to
return Cygwin PIDs.

=cut

# This is defined above, trickily, as an assignment to *My_Pid, so we
# don't have to test $^O every time. It's above because code in a BEGIN
# block needs it.

=item $text = Win32::Process::Info->variant_support_status($variant);

This static method returns the support status of the given variant. The
return is false if the variant is supported, or an appropriate message
if the variant is unsupported.

This method can also be called as a normal method, or even as a
subroutine.

=cut

sub variant_support_status {
    my @args = @_;
    my $variant = pop @args or croak "Variant not specified";
    exists $variant_support{$variant}
	or croak "Variant '$variant' is unknown";
    _import_done()
	or croak __PACKAGE__,
	    '->import() must be called before calling ', __PACKAGE__,
	    '->variant_support_status()';
    return $variant_support{$variant}{unsupported};
}

=item print "$pi Version = @{[$pi->Version ()]}\n"

This method just returns the version number of the
Win32::Process::Info object.

=cut

sub Version {
return $Win32::Process::Info::VERSION;
}

#
#	$self->_build_hash ([hashref], key, value ...)
#	builds a process info hash out of the given keys and values.
#	The keys are assumed to be the WMI keys, and will be trans-
#	formed if needed. The values will also be transformed if
#	needed. The resulting hash entries will be placed into the
#	given hash if one is present, or into a new hash if not.
#	Either way, the hash is returned.

sub _build_hash {
my ($self, $hash, @args) = @_;
$hash ||= {};
while (@args) {
    my $key = shift @args;
    my $val = shift @args;
    $val = $self->{_xfrm}{$key}->($self, $val)
	if (exists $self->{_xfrm}{$key});
    $hash->{$key} = $val;
    }
return $hash;
}


#	$self->_clunks_to_desired (clunks ...)
#	converts elapsed times in clunks to elapsed times in
#	seconds, PROVIDED $self->{elapsed_in_seconds} is TRUE.
#	Otherwise it simply returns its arguments unmodified.

sub _clunks_to_desired {
my $self = shift;
@_ = map {defined $_ ? $_ / 10_000_000 : undef} @_ if $self->{elapsed_in_seconds};
return wantarray ? @_ : $_[0];
}

#	$self->_date_to_time_t (date ...)
#	converts the input dates (assumed YYYYmmddhhMMss) to
#	Perl internal time, returning the results. The "self"
#	argument is unused.


sub _date_to_time_t {
my ($self, @args) = @_;
my @result;
local $^W = 0;	# Prevent Time::Local 1.1 from complaining. This appears
		# to be fixed in 1.11, but since Time::Local is part of
		# the ActivePerl core, there's no PPM installer for it.
		# At least, not that I can find.
foreach (@args) {
    if ($_) {
	my ($yr, $mo, $da, $hr, $mi, $sc) = m/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/;
	--$mo;
	my $val = timelocal ($sc, $mi, $hr, $da, $mo, $yr);
	push @result, $val;
	}
      else {
	push @result, undef;
	}
    }
return @result if wantarray;
return $result[0];
}

1;
__END__