Windows Management Instrumentation ( WMI ), seconde partie.

26/06/2004

Par Laurent Dardenne (home page)
 

Cet article a pour objectif de mettre en pratique, sous Delphi, les aspects abordés dans l'article "Windows Management Instrumentation ( WMI ), première partie.".

WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '','', wbemConnectFlagUseMaxWait, nil);

Var
 NewProcess: Win32_Process;

Begin
 NewProcess.Create('Notepad.exe','c:\temp',Nil, ProcessId);
End;

begin
 Try
   WMILastError:=TSWbemLastError.Create(AOwner);
   WMILastError.ConnectKind := ckNewInstance;
   WMILastError.Connect;
   Result:=True;
 Except
 on E:EOleSysError do
  begin
     // Si aucune erreur existe le code d'erreur est égal à E_FAIL = $80004005
   Result:=False;
   FreeAndNil(WMILastError);
  end
 end;
end;

Var

  WMILocator:          TSWbemLocator;
  WmiService:          SWbemServices;

  OldCursor:           TCursor;

begin
 WMILocator:= TSWbemLocator.Create(self);
 try

  OldCursor := Screen.Cursor;
  Screen.Cursor := crSQLWait;

  WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '',
                                        '', wbemConnectFlagUseMaxWait, nil);

 Finally
  WMILocator.Free;
  Screen.Cursor:= OldCursor;
 end;
end;

Var
  WmiService:          SWbemServices;
  wmiObjectSet:        SWbemObjectSet;

Begin
…
wmiObjectSet := wmiService.InstancesOf('Win32_OperatingSystem',
					wbemFlagReturnWhenComplete, 
					Nil);
…
end ;

ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant;

WmiObject := IUnknown(ArrayVariant) as SWBemObject;

WmiProperty:=IUnknown(ArrayVariant) as SWBemProperty;

Var
  WmiObject:           SWbemObject;
  wmiObjectSet:        SWbemObjectSet;

  ObjectEnumerator:    IEnumVariant;
  
 ArrayVariant:        OleVariant;   
 NumberItem:          LongWord;

Begin
 ….  
 // Affecte un énumérateur pour la collection d'objet SWbemObject
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant;

    // Retourne NumberItem éléments dans le tableau ArrayVariant,
    // ici 1 élément est demandé
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do
  begin
      // Récupére de la collection l'objet SWbemObject courant
   WmiObject := IUnknown(ArrayVariant) as SWBemObject;

      // Retrouve la propriétés de l'instance au format MOF
   Memo1.Lines.Add(AdjustLineBreaks(wmiObject.GetObjectText_(0)));
  end;

Memo1.Lines.Add(AdjustLineBreaks(wmiObject.GetObjectText_(0)));

// Retrouve l'objet SWbemObjectPath contenant toutes les propriétés
   WmiObjectPath:= WmiObject.Path_;
      // retrouve le nom de la classe via le chemin d'accés relatif.
   ClasseList.Add(WmiObjectPath.RelPath);

WmiObject:= Service.Get(' Win32_Directory.Name="c:\windows\system32\wbem", 0, nil);

WmiObject:=WmiService.Get('Win32_ Directory ',0,Nil);

Var
  ListePropriétés : SwbemPropertySet ;
  WmiObjet :        SWbemObject ;

Begin
  ListePropriétés := WmiObjet.Properties_;

Var
  ListeQualificateurs : SwbemQualifiersSet ;
  WmiObjet :              SWbemObject ;

Begin
  ListeQualificateurs := WmiObjet.Qualifiers_;

Var
  ListeMethodes : SwbemMethodsSet ;
  WmiObjet :        SWbemObject ;

Begin
  ListeMethods := WmiObjet.Methods_;

WmiProperty:= Instance.Properties_.Item('CommandLine',0);

...
 If WmiProperty.name='Description' then
    if WmiProperty.CIMType=wbemCimtypeString then
      Memo1.Lines.Add(WmiProperty.Get_Value);
    else Convertion
 ...

Function WMIPropertyToStr(WmiService:SWbemServices; WmiProperty : SWbemProperty):String;
var sValue: String;
    Count:  Integer;
    Value: Variant;
    WmiObjet : SWbemObject;

begin
 try
    Value:=WmiProperty.Get_Value;
    sValue := '';
    if VarIsNull(Value) then
      sValue := 'Is Null'
    else
     try
      case WmiProperty.CIMType of
        wbemCimtypeSint8,
        wbemCimtypeUint8,
        wbemCimtypeSint16,
        wbemCimtypeUint16,
        wbemCimtypeSint32,
        wbemCimtypeUint32,
        wbemCimtypeSint64,
        wbemCimtypeUint64:
          if VarIsArray(Value) then begin
            if VarArrayHighBound(Value, 1) > 0 then
              for Count := 1 to VarArrayHighBound(Value, 1) do
                sValue := sValue + ' ' + IntToStr(Value[Count]);
          end
          else
            sValue := IntToStr(Value);

        wbemCimtypeReal32,
        wbemCimtypeReal64:
          sValue := FloatToStr(Value);

        wbemCimtypeBoolean:
          if Value then sValue := 'True' else sValue := 'False';

          // Single 16-bit Unicode character in Universal Character Set–2 (UCS-2) format
        wbemCimtypeChar16,
         // Unicode character string
        wbemCimtypeString:
          if VarIsArray(Value) then begin
            if VarArrayHighBound(Value, 1) > 0 then
              try
              for Count := 1 to VarArrayHighBound(Value, 1) do
                sValue := sValue + ' ' + Value[Count];
              except
               on E: EConvertError do
                 ShowMessage(E.Message);
              end;
          end
          else
            sValue := Value;

        wbemCimtypeDatetime:
          sValue := Value;

         // Référence d'objet, le chemin de l'objet peut être
         //	un nom complet serveur\espace de nom
         //	ou relatif dans le même espace de nom
        wbemCimtypeReference: begin
                                // Récupére l'objet référençé
                               WmiObjet:=WmiService.Get(Value,wbemFlagReturnWhenComplete,Nil);
                               sValue:=AdjustLineBreaks(WmiObjet.GetObjectText_(0))
                              end;
          // Objet imbriqué
          // Renvoie le path de la propriété de type Objet
        wbemCimtypeObject: begin
                               // Récupére l'objet imbriqué
                             WmiObjet:=IUnknown(WmiProperty.Get_Value) as SWbemObject ;
                             sValue:=WmiObjet.Path_.Relpath;
                           end;
      end; // case
     except
      on E: EVariantError do
       ShowMessage('WMIPropertyToStr : Erreur de convertion de variant');
     end;
 Finally
  Result:=sValue;
 end;
end;

Var
  PropertyCommandLine: OleVariant;
  Instance_inParameters:   SWbemObject;

Begin
   WmiProperty:= Instance_inParameters.Properties_.Item('CommandLine',0);
   PropertyCommandLine:= 'Notepad.exe';
   WmiProperty.Set_Value(PropertyCommandLine);

Var
  WmiObject:           SWbemObject;

  PropertyMaxFileSize: SWbemProperty;

  MaxFileSize :  OleVariant;

Begin
    // Retrouve la propriété à modifier
     PropertyMaxFileSize:= WmiObject.Properties_.Item('MaxFileSize',0);

        // Nouvelle valeur de la propriété
     MaxFileSize:= 512000; // 512 Ko (unité byte)

       //Renseigne la valeur de la propriété
     PropertyMaxFileSize.Set_Value(MaxFileSize);

       // Mise à jour de l'instance courante
     WmiObject.Put_(wbemFlagReturnWhenComplete,Nil) ;

var
  WmiService:          SWbemServices;

  WmiObject:           SWbemObject;
  wmiObjectSet:        SWbemObjectSet;

  ObjectEnumerator:    IEnumVariant;
  ArrayVariant:        OleVariant;  // Tableau de variant
  NumberItem:          LongWord;

begin
 …
    WmiObjectSet := wmiService.ExecQuery('SELECT Name FROM Win32_Service Where
 					State=''Stopped''',
					'WQL',
					wbemFlagReturnImmediately, nil);

WmiServices.Security_.Privileges.Add(wbemPrivilegeShutdown, True);

var
  WMILocator:            TSWbemLocator;

  Process,
  NewProcess,
  Instance_inParameters: SWbemObject;

  WmiProperty:           SWbemProperty;

  ProcessMethod:         ISWbemMethod;

  PropertyCommandLine,
  PropertyReturnValue,
  ProcessID		 OleVariant;


begin
  WMILocator:= TSWbemLocator.Create(self);

 try
    // Création d'une connexion à un espace de nom local
    // ici le nom de l'espace de nom cible est : CIMV2
    // L'appel renvoie un pointeur sur un objet SWbemServices
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '',
                                         '', wbemConnectFlagUseMaxWait, nil);


    // Retrouve la définition de la classe Win32_Process
     // Sur le site de MS, la classe Win32_Process se trouve dans :
     //   Win32 Classes.Operating system Classes.Process
   Process:=WmiService.Get('Win32_Process',0,Nil);

    // Si vous devez modifier la sécurité nécessaire à l'appel de méthode,
    // par exemple 'Shutdown' utilisez :
    //     wmiServices.Security_.Privileges.Add(wbemPrivilegeShutdown, True);

    // Récupére, à partir de la collection de méthode,
    // la définition de la méthode 'Create' de la classe Win32_Process
    // qui correspond à ceci :
          {    Win32_Process.Create(IN CommandLine string ,
                                    IN CurrentDirectory   string ,
                                    IN ProcessStartupInformation Win32_ProcessStartup ,
                                    OUT ProcessId uint32)
              Valeur de retour :
                  [Out] ProcessId uint32 ;
                  [out] ReturnValue uint32 ;
          }


   ProcessMethod:=Process.Methods_.Item('Create', 0);

    // Crée une nouvelle instance de la méthode '.Create' de la classe Win32_Process
    // alloue l'espace mémoire pour manipuler ces paramètres.
    // ProcessMethod.InParameters.Properties_ contient la liste des paramètres de la méthode
   Instance_inParameters:= ProcessMethod.InParameters.SpawnInstance_(0);

    // Retrouve la propriété 'CommandLine' de la méthode '.Create'
   WmiProperty:= Instance_inParameters.Properties_.Item('CommandLine',0);

     // Nom du programe à exécuter
   PropertyCommandLine:= 'Notepad.exe';

    //Renseigne la valeur de la propriété 'CommandLine' de la méthode '.Create'
   WmiProperty.Set_Value(PropertyCommandLine);

    //Crée un process Via la Méthode '.Create'
   NewProcess:= Process.ExecMethod_('Create', Instance_inParameters, wbemFlagReturnWhenComplete, nil);

   { Un objet OutParameters est créé par la méthode exécutée }

    // Recupére la valeur de retour de la méthode via la propriété 'ReturnValue'
   PropertyReturnValue:= NewProcess.Properties_.Item('ReturnValue', 0);

   if PropertyReturnValue.Value = 0 then
     begin
       // Réutilise la propriété pour récupérer l'ID de process
      PropertyReturnValue:= NewProcess.Properties_.Item('ProcessId', 0);
      ProcessID:=PropertyReturnValue.Value;
      MessageBox(0, PChar('Process crée.'+#10#13+'Pid : '+inttostr(ProcessID)),
                 PChar(Form1.Caption), MB_OK);
     end
    else
     MessageBox(0, PChar('Erreur '+inttostr(PropertyReturnValue.Value)+' lors de la création du process.'),
                PChar(Form1.Caption), MB_OK);
 Finally
  WMILocator.Free;
 end;

Var
  WmiMonitoredProcesses:  	SWbemEventSource;

  WmiLatestProcess,
  WmiObjet:            		SWbemObject;

  Query : 			String;
Begin

   // Recherche les événements de type '__instancedeletionevent' ( Intrinsèque ).
   // WMI effectue le polling toute les 1 secondes.
   // Seule les instances de la classe Win32_Process sont concernées.
  Query:='Select * from __instancedeletionevent within 1 where TargetInstance isa "Win32_Process"';
  WmiMonitoredProcesses:=WMIService.ExecNotificationQuery(Query,
                                                          'WQL',
                                                          wbemFlagForwardOnly +
                                                          wbemFlagReturnImmediately,
                                                          Nil);

Var
  WmiMonitoredProcesses:  	SWbemEventSource;

  WmiLatestProcess,
  WmiObjet:            		SWbemObject;

  Query : 			String;

Begin 
  Query:='Select * from __instancedeletionevent within 1 where TargetInstance isa "Win32_Process"';
  WmiMonitoredProcesses:=WMIService.ExecNotificationQuery(Query,
                                                          'WQL',
                                                          wbemFlagForwardOnly +
                                                          wbemFlagReturnImmediately,
                                                          Nil);

   // Renvoie une classe de type '__InstanceDeletionEvent'
   // -1 = Attente indéfinie. Le traitement attend un événement...
  WmiLatestProcess:= WmiMonitoredProcesses.NextEvent(-1);

   // Retrouve l'objet contenue dans la propriété TargetInstance
   // à partir de l'objet crée par la méthode WmiMonitoredProcesses.NextEvent
   // L'objet retrouvé contient une copie de l'instance du process supprimé.
  WmiObjet:=IUnknown(WmiLatestProcess.Properties_.Item('TargetInstance',0).Get_Value) as SWbemObject;

var
  Query:               String;

begin
  Query:='Select * from __instancedeletionevent within 1 where TargetInstance isa "Win32_Process"';

  WMIService.ExecNotificationQueryAsync(SWbemSink1.DefaultInterface,
                                        Query,
                                        'WQL',
                                        wbemFlagSendStatus,
                                        Nil, Nil);
end;

Select * from __instancedeletionevent within 1 where TargetInstance isa "Win32_Process"

procedure TForm1.SWbemSink1ObjectReady(Sender: TObject; var objWbemObject,
  objWbemAsyncContext: OleVariant);
// Déclenché lorsqu'un objet fourni par l'appel asynchrone est disponible.
// ObjWbemObject contient l'objet retourné

var WmiObjet: ISWbemObject;

begin
     // L'objet retourné contient une copie de l'instance du process supprimé.
  WmiObjet:=IUnknown(objWbemObject.Properties_.Item('TargetInstance',0).Value) as ISWbemObject;

  Memo1.Lines.Add(#13#10+'Le process '+WMIVariantToStr(WmiObjet.Properties_.Item('Name',0).Get_Value)+
                  ' s''est terminé.'+#13#10);
  Memo1.Lines.Add(WmiObjet.Path_.path);
  Memo1.Lines.Add(AdjustLineBreaks(WmiObjet.GetObjectText_(0)));
end;

• Computer system hardware
• Operating system Classes
• Installed applications
• WMI service management
• Performance counters