860 lines
28 KiB
Perl
860 lines
28 KiB
Perl
#-----------------------------------------------------------------//
|
|
# Script: WMIFE.pm
|
|
#
|
|
# (c) 2001,2002 Microsoft Corporation. All rights reserved.
|
|
#
|
|
# addresses the generic OLE->WMI interface to test various stuff
|
|
# defined on the given remote box
|
|
#
|
|
# Version: <2.01> 06/11/2002 : Serguei Kouzmine
|
|
#
|
|
#-----------------------------------------------------------------//
|
|
|
|
package WMIFE;
|
|
use lib $ENV{RAZZLETOOLPATH} . "\\PostBuildScripts";
|
|
use lib $ENV{RAZZLETOOLPATH};
|
|
use PbuildEnv;
|
|
use Logmsg;
|
|
|
|
require Exporter;
|
|
use vars qw( @ISA @EXPORT_OK );
|
|
@ISA = ( 'Exporter' );
|
|
@EXPORT_OK = qw( $verbose );
|
|
|
|
my $hPrivileges = {"SeBackupPrivilege" => "Backup",
|
|
"SeSecurityPrivilege" => "Security",
|
|
"SeRestorePrivilege" => "Restore",
|
|
"SeShutdownPrivilege" => "ShutDown",
|
|
"SeRemoteShutdownPrivilege" => "RemoteShutdown"
|
|
};
|
|
|
|
use strict;
|
|
no strict 'refs';
|
|
use Win32::OLE qw(in with);
|
|
use Win32::OLE::Variant;
|
|
# use 'in' loop for retrieve WQL cursors
|
|
|
|
use vars qw( $verbose
|
|
$NameSpace
|
|
$impersonationLevel
|
|
$authLevel
|
|
$Privileges
|
|
$ComputerName
|
|
$MasterData
|
|
$Provider
|
|
$Query
|
|
$DisplayFields
|
|
$User
|
|
$Password
|
|
$DEBUG
|
|
$TIMEOUT
|
|
$sRootKey
|
|
$sBootTestDataSubKey
|
|
$sLogonUserDataSubKey
|
|
);
|
|
my $VERSION = "1.1";
|
|
$TIMEOUT = 60;
|
|
$DEBUG = 0;
|
|
$verbose = ["NO","YES"];
|
|
my $SEPARATOR = "\n". join("", map{chr(61)} 0..79). "\n";
|
|
$NameSpace = "root\\cimv2";
|
|
$sRootKey = "HKEY_LOCAL_MACHINE";
|
|
$sBootTestDataSubKey = "SOFTWARE\\MICROSOFT\\BOOTTEST";
|
|
$sLogonUserDataSubKey = "SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\WINLOGON";
|
|
$impersonationLevel = "impersonate";
|
|
$authLevel = "pktPrivacy";
|
|
|
|
$Privileges = join(",", values(%$hPrivileges));
|
|
$Provider = q(WbemScripting.SWbemLocator);
|
|
$MasterData=
|
|
q(winmgmts:{impersonationLevel=$impersonationLevel,authenticationLevel=$authLevel, ($Privileges)}!
|
|
\\\\$ComputerName\\$NameSpace);
|
|
|
|
|
|
sub ObjectExecMethod{
|
|
|
|
my ($WbemObjClassName, $MethodName, $ComputerName, $ParameterName, $ParameterValue, $User, $Password) = @_;
|
|
|
|
# play with the command line expansion
|
|
# here.
|
|
$DEBUG and print STDERR
|
|
"ObjectExecMethod: using PROVIDER: ", $Provider, " " , $User, "\n";
|
|
my $WbemLocator = Win32::OLE->new($Provider);
|
|
|
|
OLEerrmsg("Could not instatiate $Provider") unless defined $WbemLocator;
|
|
|
|
my $SWbemServices = ($User =~ /\*/) ?
|
|
$WbemLocator->ConnectServer( $ComputerName, $NameSpace) :
|
|
$WbemLocator->ConnectServer( $ComputerName, $NameSpace, $User, $Password );
|
|
|
|
defined $SWbemServices or
|
|
OLEerrmsg("Cannot connect: $ComputerName, $NameSpace");
|
|
|
|
# Make sure we are using the appropriate security level
|
|
OLEerrmsg("Error setting security level")
|
|
if ( !($SWbemServices->{Security_}->{ImpersonationLevel} = 3) );
|
|
|
|
map {
|
|
$SWbemServices->{Security_}->{Privileges}->AddAsString($_)
|
|
or OLEerrmsg( "Error setting $hPrivileges->$_ privileges");
|
|
} keys %$hPrivileges;
|
|
|
|
# Get the process object on the remote machine
|
|
my $WbemObject = $SWbemServices->Get($WbemObjClassName);
|
|
|
|
my $Result = $WbemObject->SetProperty($ParameterName, $ParameterValue) unless !defined($ParameterName);
|
|
my $ProcessId = \0;
|
|
|
|
#~ $REALDEBUG and
|
|
#~ print $SEPARATOR , $WbemObject->Invoke("GetObjectText_"), $SEPARATOR;
|
|
#~ too much info here
|
|
|
|
my $ResultArrayRef = [(in $WbemObject->Invoke("Methods_"))];
|
|
|
|
$DEBUG and print STDERR
|
|
"$WbemObjClassName: METHODS_:\n";
|
|
|
|
$DEBUG and
|
|
map {&FormatDebugMsg($_->{"Name"}, $_->{"value"})} @$ResultArrayRef;
|
|
|
|
OLEerrmsg("undefined method: $MethodName") unless grep {/$MethodName/i}
|
|
map {$_->{"Name"}} @$ResultArrayRef;
|
|
|
|
defined $WbemObject or
|
|
OLEerrmsg("Could not create remote $WbemObjClassName");
|
|
|
|
# Now invoke the method
|
|
$DEBUG and
|
|
print STDERR $WbemObject->{CommandLine}, "\n";
|
|
OLEerrmsg("At $ComputerName, $ParameterName($ParameterValue) => $Result" )
|
|
if ($Result = $WbemObject->Invoke($MethodName,
|
|
$WbemObject->{CommandLine},
|
|
undef,
|
|
undef,
|
|
$ProcessId)); # ):- $ProcessId not filled up :-(
|
|
|
|
undef $WbemLocator;
|
|
undef $SWbemServices;
|
|
undef $WbemObject;
|
|
Win32::OLE->Uninitialize();
|
|
$DEBUG and print STDERR "OK\n";
|
|
|
|
0;
|
|
}
|
|
|
|
|
|
sub ExecQuery{
|
|
|
|
local ($ComputerName, $Query, $DisplayFields, $User, $Password) = @_;
|
|
# the "local" keyword is necessary to get search/replace able to do /e switch
|
|
|
|
my @MasterData = split (/\n/, $MasterData);
|
|
|
|
my %Caption = map {$_=> $_} @$DisplayFields;
|
|
|
|
# The values of %Caption must not be identical to the retrieved field names
|
|
|
|
my $Caption = \%Caption;
|
|
|
|
grep {s/\$\{?(\w+)\}?/${$1}/ge} @MasterData, $Query;
|
|
# here we replace all the vars with their values
|
|
|
|
$MasterData = join("", @MasterData);
|
|
|
|
$Query =~ s/([^\\])\\([^\\])/$1\\\\$2/g;
|
|
|
|
my $ResultSet = undef;
|
|
$DEBUG and print STDERR
|
|
"ExecQuery: using PROVIDER: ", $Provider, " " , $User, "\n";
|
|
my $WbemLocator = Win32::OLE->new($Provider);
|
|
|
|
OLEerrmsg("Could not instatiate $Provider") unless defined $WbemLocator;
|
|
|
|
my $SWbemServices = ($User =~ /\*/) ?
|
|
$WbemLocator->ConnectServer( $ComputerName, $NameSpace) :
|
|
$WbemLocator->ConnectServer( $ComputerName, $NameSpace, $User, $Password );
|
|
|
|
defined $SWbemServices or
|
|
OLEerrmsg("Cannot connect: $ComputerName, $NameSpace");
|
|
|
|
# Make sure we are using the appropriate security level
|
|
OLEerrmsg("Error setting security level")
|
|
if ( !($SWbemServices->{Security_}->{ImpersonationLevel} = 3) );
|
|
|
|
map {
|
|
$SWbemServices->{Security_}->{Privileges}->AddAsString($_)
|
|
or OLEerrmsg( "Error setting $hPrivileges->$_ privileges");
|
|
} keys %$hPrivileges;
|
|
|
|
$DEBUG and print STDERR
|
|
"\$Query: ", qq($Query), "\n";
|
|
###
|
|
### eval { $ResultSet = Win32::OLE->GetObject($MasterData)->ExecQuery($Query); };
|
|
### $DEBUG and $Query = ""
|
|
eval { $ResultSet = $SWbemServices->ExecQuery($Query); };
|
|
#
|
|
#
|
|
my $ResultArrayRef = [(in $ResultSet)] unless ($@);
|
|
|
|
$ResultArrayRef or
|
|
print STDERR "Win32::OLE::LastError ", Win32::OLE::LastError, "\n";
|
|
|
|
my @ResultCursor;
|
|
# pack ResultSet -> ResultCursor;
|
|
|
|
map {map {push @ResultCursor, {$Caption->{$_} => $ResultArrayRef->[0]->{$_}}}
|
|
@$DisplayFields and shift @$ResultArrayRef}
|
|
(0..$#$ResultArrayRef);
|
|
|
|
Win32::OLE->Uninitialize();
|
|
|
|
\@ResultCursor;
|
|
}
|
|
|
|
|
|
# &IsRunning($ProcMask, $runAtHost);
|
|
# lists processes on the host $runAtHost to
|
|
# find pattern $ProcMask.
|
|
# for all process found, collect the
|
|
# $1 of the search
|
|
# e.g. you get language of the running postbuiild with
|
|
# the pattern:
|
|
# "\\\\POSTBUILDSCRIPTS\\\\PBUILD\\\.CMD\\\"\\s\+\\\-l[: ]\(\\w\{3\}\)";
|
|
#
|
|
# plus some properties of the $ProcessSet
|
|
# return value: array pointer. The arguments are filtered out by default:
|
|
|
|
|
|
# (/S:\\BLD_WNXF1\RELEASE\GER\3562.X86FRE.MAIN.011002-1901\PRO /TEMPDRIVE:D /#T:7)
|
|
# PID= 00220
|
|
# NAME= winnt32.exe
|
|
# CMD= \\bld_wnxf1\release\ger\3562.x86fre.main.011002-1901\pro\i386\winnt32.exe /s:\\bld_wnxf1\release\ger\3562.x86fre.main.011002-1901\pro /tempdrive:d /#t:7
|
|
|
|
|
|
sub IsRunning{
|
|
|
|
my (
|
|
$WMIclass, $ProcMask, $Field, $Fields, $runAtHost) = @_;
|
|
|
|
# filter out arguments
|
|
$ProcMask = $ProcMask."\\\"\? \(\.\+\)\$" unless $ProcMask=~/\(/;
|
|
$DEBUG and print STDERR $ProcMask, "\n";
|
|
|
|
my $ProcessSet;
|
|
my @result;
|
|
my $Moniker = "winmgmts:{impersonationLevel=impersonate}!\\\\HOST\\root\\cimv2";
|
|
$Moniker =~ s/HOST/$runAtHost/;
|
|
|
|
$DEBUG and print STDERR
|
|
"using MONIKER: ", $Moniker, "\n";
|
|
eval {
|
|
$ProcessSet = Win32::OLE->GetObject($Moniker)->InstancesOf ($WMIclass); };
|
|
|
|
unless($@){
|
|
foreach my $ProcessInst (in $ProcessSet){
|
|
push @result, join("\n",
|
|
uc($1), map {"$_=".$ProcessInst->{$_}} @$Fields),
|
|
if $ProcessInst->{$Field} =~ m/$ProcMask/gi;
|
|
}
|
|
}else{
|
|
print STDERR Win32::OLE->LastError, "\n";
|
|
}
|
|
$DEBUG and print STDERR join ("\n", @result) , "\n";
|
|
\@result;
|
|
|
|
}
|
|
|
|
|
|
# supplyRegData
|
|
# usage:
|
|
# $defaultData = {
|
|
# "DEBUG" => $DEBUG,
|
|
# "Lang" => $Lang ,
|
|
# ...
|
|
# }
|
|
# $volatileData = {}
|
|
#
|
|
# &supplyRegData($sTargetcomputer, $REGISTRY_KEY,
|
|
# $defaultData, $volatileData , $FovWrite);
|
|
#
|
|
#
|
|
|
|
sub supplyRegData{
|
|
|
|
my ($sTargetcomputer, $sBootTestDataSubKey, $defaultData, $volatileData, $FovWrite) = @_;
|
|
use strict;
|
|
use Win32API::Registry 0.21 qw(HKEY_LOCAL_MACHINE
|
|
REG_OPTION_VOLATILE
|
|
REG_OPTION_NON_VOLATILE
|
|
KEY_ALL_ACCESS
|
|
KEY_READ
|
|
REG_SZ
|
|
regLastError
|
|
RegConnectRegistry
|
|
RegOpenKeyEx
|
|
RegEnumValue
|
|
RegQueryInfoKey
|
|
RegQueryValueEx
|
|
RegCreateKeyEx
|
|
RegSetValueEx
|
|
RegDeleteValue
|
|
RegCloseKey
|
|
);
|
|
|
|
# This provides fairly low-level access to the Win32 System API calls
|
|
# dealing with the Registry [mostly from WINREG.H]. This is mostly
|
|
|
|
|
|
|
|
my $hRootKey = $sRootKey;
|
|
|
|
{ no strict 'refs';
|
|
$hRootKey =~ s/(\w+)/$1/eeg;
|
|
use strict 'refs';
|
|
}
|
|
|
|
my $sStatusSubKey = "STATUS";
|
|
my $ohKey = undef;
|
|
my $ohSubKey = undef;
|
|
my $ohStatusSubKey = undef;
|
|
my $ocValues;
|
|
my $olValName;
|
|
my $olValData;
|
|
my $olSecDesc;
|
|
my $opValData;
|
|
my $osValName;
|
|
my $sValueNames = [];
|
|
my $sValueName;
|
|
my $nStatus = undef;
|
|
|
|
$DEBUG and print STDERR
|
|
"COMPUTER: ".uc($sTargetcomputer)."\n";
|
|
|
|
&RegConnectRegistry( $sTargetcomputer,
|
|
$hRootKey,
|
|
$ohKey )
|
|
or die "Can't open $hRootKey: ", regLastError(),"\n";
|
|
|
|
|
|
$DEBUG and print STDERR
|
|
"Registry Key: ".$sRootKey."\\$sBootTestDataSubKey\n";
|
|
|
|
|
|
|
|
$nStatus = &RegOpenKeyEx( $ohKey,
|
|
$sBootTestDataSubKey ."\\". $sStatusSubKey,
|
|
0,
|
|
KEY_READ,
|
|
$ohStatusSubKey );
|
|
if (scalar(keys(%$volatileData))){
|
|
$sValueName = (keys(%$volatileData))[0];
|
|
$opValData = undef;
|
|
if ($nStatus){
|
|
|
|
&RegQueryValueEx( $ohStatusSubKey,
|
|
$sValueName ,
|
|
[],
|
|
[],
|
|
$opValData,
|
|
[] );
|
|
# error is ignored.
|
|
$opValData = "(undef)" unless $opValData;
|
|
|
|
&RegCloseKey($ohStatusSubKey);
|
|
|
|
}
|
|
|
|
if ($nStatus ){
|
|
$DEBUG and print STDERR
|
|
"\\\\$sTargetcomputer\\$sRootKey\\$sBootTestDataSubKey\\$sStatusSubKey\\$sValueName: ",$opValData, "\n";
|
|
$FovWrite or return 1;
|
|
}
|
|
}
|
|
|
|
RegCreateKeyEx($ohKey,
|
|
$sBootTestDataSubKey,
|
|
0,
|
|
"",
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
[],
|
|
$ohSubKey,
|
|
[]);
|
|
|
|
RegCloseKey($ohSubKey);
|
|
|
|
&RegOpenKeyEx( $ohKey,
|
|
$sBootTestDataSubKey ,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
$ohSubKey )
|
|
or die "Can't open $sBootTestDataSubKey: \n", regLastError(),"\n";
|
|
|
|
&RegQueryInfoKey($ohSubKey,
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
[],
|
|
$ocValues,
|
|
$olValName,
|
|
$olValData,
|
|
[],
|
|
[]
|
|
)
|
|
or die "Can't query $sBootTestDataSubKey: ", regLastError(),"\n";
|
|
|
|
$DEBUG and print STDERR
|
|
$ocValues, " values found\n";
|
|
|
|
foreach my $Data (keys(%$defaultData)){
|
|
if ($FovWrite){
|
|
# tsanders: existing values do not get overwritten.
|
|
|
|
&RegDeleteValue($ohSubKey,
|
|
$Data);
|
|
$DEBUG and print STDERR
|
|
"\t\tDeleting Default Data: \"$Data\"\n\t\t$^E\n";
|
|
#ignore the "$^E" here.
|
|
}
|
|
&RegSetValueEx($ohSubKey,
|
|
$Data,
|
|
0,
|
|
REG_SZ,
|
|
$defaultData->{$Data},
|
|
0
|
|
)
|
|
or die "Can't RegSetValueEx($Data,...$defaultData->{$Data}: ", regLastError(),"\n";
|
|
}
|
|
|
|
foreach my $nCnt (0..$ocValues-1){
|
|
&RegEnumValue($ohSubKey,
|
|
$nCnt,
|
|
$osValName,
|
|
0,
|
|
[],
|
|
[],
|
|
$opValData,
|
|
0 );
|
|
push @$sValueNames, $osValName;
|
|
|
|
}
|
|
|
|
foreach $sValueName (@$sValueNames){
|
|
&RegQueryValueEx( $ohSubKey,
|
|
$sValueName ,
|
|
[],
|
|
[],
|
|
$opValData,
|
|
[] )
|
|
or die "Can't read $sValueName: ", regLastError(),"\n";
|
|
|
|
$DEBUG and print STDERR
|
|
"$sValueName=$opValData\n";
|
|
|
|
}
|
|
|
|
|
|
RegCreateKeyEx($ohSubKey,
|
|
$sStatusSubKey,
|
|
0,
|
|
"",
|
|
REG_OPTION_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
[],
|
|
$ohStatusSubKey,
|
|
[]);
|
|
|
|
|
|
foreach my $Data (keys(%$volatileData)){
|
|
&RegSetValueEx($ohStatusSubKey,
|
|
$Data,
|
|
0,
|
|
REG_SZ,
|
|
$volatileData->{$Data},
|
|
0
|
|
)
|
|
or die "Can't RegSetValueEx($Data,...$volatileData->{$Data}: ",
|
|
regLastError(),"\n";
|
|
}
|
|
map {defined($_) and RegCloseKey($_)} ($ohSubKey, $ohKey, $ohStatusSubKey);
|
|
|
|
0;
|
|
}
|
|
|
|
sub OLEerrmsg($)
|
|
{
|
|
my $text = shift;
|
|
errmsg( "$text (". Win32::OLE->LastError(). ")" );
|
|
exit 1;
|
|
}
|
|
|
|
|
|
sub ScheduleTime{
|
|
|
|
use Time::localtime;
|
|
|
|
my $shiftTime = shift;
|
|
|
|
my $tNow = time();
|
|
|
|
$DEBUG and print STDERR
|
|
"Current time: " , &localtime->hour(), ":", &localtime->min(), "\n";
|
|
|
|
$tNow += $shiftTime;
|
|
|
|
my @result = map {sprintf("%02d", $_)} (&localtime($tNow)-> hour(),
|
|
&localtime($tNow)-> min(),
|
|
&localtime($tNow)-> sec(),
|
|
&localtime($tNow)-> mon() + 1,
|
|
&localtime($tNow)-> mday(),
|
|
&localtime($tNow)-> year() + 1900
|
|
);
|
|
|
|
$DEBUG and print STDERR
|
|
"Schedule time: " , $result[0], ":",
|
|
$result[1], ":",
|
|
$result[2], " ",
|
|
$result[3], "/",
|
|
$result[4], "/",
|
|
$result[5], "\n";
|
|
|
|
\@result;
|
|
}
|
|
|
|
|
|
|
|
|
|
sub FormatDebugMsg{
|
|
|
|
format STDERR =
|
|
# field name field value
|
|
@<<<<<<<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
|
$_[0] $_[1]
|
|
.
|
|
|
|
write STDERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# BackTick
|
|
# sample usage: &BackTick("dir");
|
|
# &BackTick(<<BLOCKBOUNDARY);
|
|
# ...cmd code...
|
|
# BLOCKBOUNDARY
|
|
# passes block of code to the cmd interpreter.
|
|
# lines are concatenated
|
|
# comments thrown away
|
|
# useful stuff when the code is already
|
|
# developed and just needs to be inserted in place
|
|
# has limitations.
|
|
|
|
sub BackTick{
|
|
my ($cmd) = @_;
|
|
my $res = undef;
|
|
$DEBUG and
|
|
print STDERR join(" &", grep (!/^:|REM/i, ($cmd =~ /^(.+)/gm)));
|
|
$cmd = join(" &", grep (!/^:|REM/i, ($cmd =~ /^(.+)/gm)));
|
|
$res=qx ($cmd);
|
|
$res;
|
|
}
|
|
|
|
|
|
|
|
sub pPpPinfo{
|
|
|
|
my @infa = @_;
|
|
my $opBrws = Win32::OLE->new("WScript.Shell");
|
|
$opBrws->Popup(join("\n", @infa), $TIMEOUT ,
|
|
ref($opBrws) . "<- $0,". $VERSION,
|
|
0 + 64);
|
|
undef($opBrws);
|
|
Win32::OLE->FreeUnusedLibraries();
|
|
Win32::OLE->Uninitialize();
|
|
1;
|
|
}
|
|
|
|
1;
|
|
__END__
|
|
#-------------------------------------------------------------//
|
|
|
|
=head1 NAME
|
|
|
|
B<WMIFE> - Interface the query engine exposed by WMI
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use WMIFE;
|
|
|
|
&WMIFE::ExecQuery($ComputerName, $Query, [@Fields]);
|
|
&WMIFE::FormatDebugMsg($Comment, $Field);
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
Generates the WQL (A.K.A. WMI SQL) query on the remote machine against
|
|
its namespace.
|
|
|
|
Sample objects that reside on the remote box $ComputerName are:
|
|
|
|
* local files [/.//ROOT/CIMV2/CIM_DATAFILE],
|
|
* running processes [/.//ROOT/CIMV2/WIN32_PROCESSES],
|
|
* registry entries [/.//ROOT/DEFAULT/STDREGPROV].
|
|
|
|
The WMI is functional even in the absence of logon sessions on $ComputerName.
|
|
|
|
=head1 METHODS
|
|
|
|
=head2 FormatDebugMsg($fieldName, $FieldValue)
|
|
|
|
Nice (?) formatting of the RDB like table field output (A.K.A. browse view):
|
|
|
|
Name perl.exe
|
|
Description perl.exe
|
|
ProcessID 2920
|
|
ParentProce 2692
|
|
ExecutableP d:\ntt\tools\perl\bin\perl.exe
|
|
...
|
|
|
|
|
|
=head2 ExecQuery($ComputerName, $Query, $DisplayFields)
|
|
|
|
Execute the WMI WQL query against the namespace of the remote machine
|
|
where
|
|
$ComputerName is the name of the machine which namespaces are about to be queried.
|
|
$Query the string representing the query, with the dollarsigned names placeholders for parameters
|
|
$DisplayFields reference to the field list to retusn the result
|
|
|
|
The return value is a reference to the like the RDB cursor.
|
|
(array of hashes where keys are described in $DisplayFields array).
|
|
If no data is returned from the query the returned value is a reference to undefined value.
|
|
|
|
=head2 ObjectExecMethod($MethodName, $ComputerName, $ParameterName, $ParameterValue, $User, $Password
|
|
|
|
Access the namespace on the remote box $ComputerName, and execute the method $MethodName of the class
|
|
$WbemObjClassName (currently only for Win32_Process). Supply the parameter(s) via name/value.
|
|
PErfurm the call under $User account, proving the password.
|
|
|
|
=head2 Sample calls:
|
|
|
|
|
|
=head2 To list files in the root directory of the logical disk labeled $Drive of the machine $Machine
|
|
|
|
$Results = &WMIFE::ExecQuery($Machine,
|
|
qq(SELECT * FROM cim_Datafile WHERE Drive="$Drive" AND Path="\\\\" "),
|
|
[qw(Drive Path Name)]);
|
|
|
|
|
|
=head2 To list logical disks of the machine $Machine
|
|
|
|
$Results = &WMIFE::ExecQuery($Machine,
|
|
qq(SELECT * FROM Win32_LogicalDisk WHERE DriveType=3),
|
|
[qw(Name Description)]);
|
|
|
|
=head2 To list the running processes
|
|
|
|
$Results = &WMIFE::ExecQuery($ComputerName,
|
|
qq(SELECT * FROM Win32_Process),
|
|
[qw(Name Description ProcessID ParentProcessId ExecutablePath )]);
|
|
|
|
|
|
|
|
|
|
=head2 To view installed software
|
|
|
|
$Results = &WMIFE::ExecQuery($ComputerName,
|
|
qq(SELECT * FROM Win32_Product),
|
|
[qw(Name Vendor Version)]);
|
|
|
|
|
|
=head2 To verify administrators group
|
|
|
|
$Results = &WMIFE::ExecQuery($ComputerName,
|
|
qq(SELECT * FROM Win32_GroupUser WHERE GroupComponent="Win32_Group.Domain=\\"$ComputerName\\",Name=\\"Administrators\\""),
|
|
[qw(GroupComponent)]);
|
|
|
|
|
|
=head2 To browse the process dependency hierarchy
|
|
$Results = &WMIFE::ExecQuery($ComputerName,
|
|
qq(SELECT * FROM CIM_ProcessExecutable),
|
|
[qw(Antecedent Dependent)]);
|
|
|
|
|
|
=head2 Query who is currently logged to somewhere.
|
|
|
|
|
|
$Results =
|
|
&WMIFE::ExecQuery($ENV{"COMPUTERNAME"}, # interactive session
|
|
qq(SELECT * FROM Win32_LogonSession WHERE LogonType=2),
|
|
[qw(LogonId LogonType)]);
|
|
|
|
foreach my $Result (@$Results){
|
|
|
|
$DEBUG and
|
|
map {&WMIFE::FormatDebugMsg($_, $Result->{$_})} keys (%$Result);
|
|
|
|
push @Ids, $Result->{"LogonId"};
|
|
|
|
}
|
|
|
|
|
|
$Results =
|
|
&WMIFE::ExecQuery($ENV{"COMPUTERNAME"}, # Difficult to build the WHERE condition.
|
|
qq(SELECT * FROM Win32_LoggedOnUser),
|
|
[qw(Antecedent Dependent)]);
|
|
my @Users = ();
|
|
my $User = undef;
|
|
my $LoggedUser = undef;
|
|
my @LoggedUsers = ();
|
|
|
|
# a little bit ugly.
|
|
|
|
foreach my $Id (grep {/\d+/} @Ids){
|
|
|
|
foreach my $Result (@$Results){
|
|
|
|
$User = $Result->{"Antecedent"};
|
|
if ($User =~ /\S/){
|
|
push @Users, $User;
|
|
}
|
|
|
|
if ((grep {/\b$Id\b/} $Result->{"Dependent"})){
|
|
$LoggedUser = pop @Users;
|
|
push @LoggedUsers, $LoggedUser;
|
|
$DEBUG and &WMIFE::FormatDebugMsg("win32_user", $LoggedUser);
|
|
$DEBUG and &WMIFE::FormatDebugMsg("win32_logonSession", $Id);
|
|
}
|
|
}
|
|
}
|
|
|
|
map {($user, $domain) = (/Win32_Account.Domain=\"(\w+)\",Name=\"(\w+)\"/);
|
|
$DEBUG and
|
|
print $user, "\t" , $domain,"\n"; } @LoggedUsers;
|
|
|
|
|
|
|
|
=head2 To list the $Result contents, the following framework may be used:
|
|
|
|
use WMIFE;
|
|
|
|
&WMIFE::ExecQuery($ENV{"COMPUTERNAME"},
|
|
qq(SELECT * FROM Win32_BootConfiguration),
|
|
[qw(Caption BootDirectory Description)]);
|
|
|
|
foreach my $Result (@$Results){
|
|
map {&WMIFE::FormatDebugMsg($_, $Result->{$_})} keys (%$Result);
|
|
}
|
|
|
|
|
|
|
|
=head2 To design the new query
|
|
|
|
please use the %WINDIR%\SYSTEM32\WBEM\wbemtest.exe vendor shell for accessing and
|
|
querying the WMI classes and then use the query string designed in that shell as an argument to the Perl qq()
|
|
[double backslashes]
|
|
|
|
Some queries may take long time to execute, before being sufficiently refined.
|
|
|
|
=head1 SEE ALSO
|
|
|
|
Whole bunch of tools interfacing WMI is in progress. Note that the Perl interface to WMI is not as powerful as
|
|
VBSCRIPT/JSCRIPT since there is no working examples for P/P (A.K.A. object sinking) and in general any
|
|
interface(s) other than SQL. the design of such sample code might prove to be complicated indeed.
|
|
|
|
|
|
=head2 supplyRegData($sTargetcomputer, $Lang, $BldNum, $Sku, $Drive, $BuildName, $Unattend, $FovWrite)
|
|
|
|
Write the data to the REGISTRY of the Boot test machine to start the execution
|
|
of test build installation.
|
|
|
|
The REGISTRY path where the data is stored is:
|
|
|
|
HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\BOOTTEST
|
|
|
|
The data includes the following fields:
|
|
|
|
-------------+-----------------------------------------------------------
|
|
$Lang | fields are used to find the test bits, in the form:
|
|
$BuildName | $Drive\$Lang\$BuildName
|
|
$BldNum | $BldNum, $Sku and $Lang are used to verify the
|
|
$Sku | REGISTRY data is actual for the build being installed.
|
|
$Drive | target drive for winnt32.exe
|
|
$Unattend | location of the answer file
|
|
|
|
The data is written by the postbuild on the build machine (NTDEV\NTBUILD),
|
|
and is later consumed from boot machine side by (NTDEV\<AUTOGENERATED> user).
|
|
The registry access across the network hence the use of HKEY_LOCAL_MACHINE.
|
|
The default REGISTRY key names are:
|
|
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BldNum => $BldNum
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BuildArch => $_BuildArch
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\LANG => $Lang
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BldSku => $Sku
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BuildType => $_BuildType
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BldDrive => $Drive
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\Unattend => $Unattend
|
|
HKLM\SOFTWARE\MICROSOFT\BOOTTEST\_BldName => $BuildName
|
|
|
|
Running regedit.exe will show the following data:
|
|
|
|
+-----------------------------------------------
|
|
|Windows Registry Editor Version 5.00
|
|
|
|
|
|[HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\BOOTTEST]
|
|
|"_BuildArch"="x86"
|
|
|"_BuildType"="fre"
|
|
|"_BldSku"="SRV"
|
|
|"_BldName"="3615.x86fre.main.020306-1639"
|
|
|"_BldDrive"="D"
|
|
|"Unattend"="unattend.txt"
|
|
|"LANG"="GER"
|
|
|"_BldNum"="3615"
|
|
|
|
|
|[HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\BOOTTEST\Status]
|
|
|"COMPUTERNAME"="BLD_WNXF1"
|
|
+-----------------------------------------------
|
|
|
|
|
|
The Status subkey is to prevent concurrent execution of the more than one
|
|
test build install on the single test machine. The function will return
|
|
the data observed e.g.
|
|
\\sergueik4\HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\BOOTTEST\STATUS\COMPUTERNAME: SERGUEIK2
|
|
|
|
To ignore the presence of the Status set $FovWrite = 1.
|
|
Booting test machine (but not logging off of the user) will cause Status
|
|
key to disappear.
|
|
|
|
=head2 &ScheduleTime($Delay)
|
|
|
|
Calculate the time/date for execution of the scheduled tasks in
|
|
$Delay secs from NOW.
|
|
Example usage:
|
|
|
|
use WMIFE;
|
|
$WMIFE::DEBUG = 1;
|
|
my $DELAY1 = 1800; # delay in 1800 secs = 30 min
|
|
my $string = "/st %HH%:%MM%:%SS% /sd %mm%/%dd%/%yyyy%" ;
|
|
|
|
my $marker = ["HH" , "MM", "SS", "mm", "dd", "yyyy"];
|
|
# this is the way to set the date/time of scheduled task
|
|
my $ScheduleTime = &WMIFE::ScheduleTime($DELAY1);
|
|
print STDERR "\"$string\"\t";
|
|
map {$string =~ s/\%$marker->[$_]\%/$ScheduleTime->[$_]/g;}
|
|
(0..$#$marker);
|
|
print STDERR "\"$string\"\n";
|
|
|
|
|
|
Current time: 15:51
|
|
Schedule time: 16:21:32 03/25/2002
|
|
"/st %HH%:%MM%:%SS% /sd %mm%/%dd%/%yyyy%"
|
|
"/st 16:21:32 /sd 03/25/2002"
|
|
|
|
=head1 AUTHOR
|
|
Serguei Kouzmine sergueik@microsoft.com
|
|
|
|
=cut
|
|
1;
|