PC-ATI est une équipe de bénévoles qui vous apporte une assistance entièrement gratuite, inscrivez-vous pour participer au forum.

WMI et AutoIt

Répondre
Avatar du membre
Amesam
Administrateur du site
Messages : 364
Enregistré le : lun. 5 juin 2017 17:23

WMI et AutoIt

Message par Amesam » ven. 14 juil. 2017 22:29

WMI et AutoIt

Ce sujet est fait pour vous familiariser avec WMI et AutoIt.
Vous pouvez pour ceux qui le désire poster vos commentaires ou codes concernant WMI.



L'Infrastructure de gestion Windows (WMI) de l'acronyme Windows Management Instrumentation est une couche de gestion de données incluse dans Microsoft qui va vous permettre de récupérer, configurer et gérer une multitude d'information sur le système et le matériel d'un PC local ou distant sur le réseau.
Avec WMI pour obtenir des informations de bas niveau telles que la taille de la mémoire ou des informations sur vos disques, vous y accédez sans passer par les APIs (Application Programming Interface. Interface qui permet la communication entre deux programmes avec un ensemble normalisé de classes, de méthodes ou de fonctions). Ainsi les développeurs n'ont pas besoin de connaître plusieurs API pour créer des applications ou interroger les composants de la machine hôte de leur application.

WMI est basé sur la technologie COM (Component Object Model, modèle proposé par Microsoft pour connecter des logiciels en utilisant une interface commune ), sous dotnet (Microsoft .NET est un ensemble de logiciels et services web fournis par Microsoft) on y accède via les classes de l’espace de nom.
Les espaces de nom ne sont pas des emplacements physiques, ce sont plutôt des bases de données logiques. Ils contiennent des classes et des instances spécifiques.
Ils regroupent des variables, des fonctions et des classes, tout ce que vous voulez dans un même ensemble.

Le principal inconvénient de WMI est la vitesse, il est lent à interroger les données, cependant les informations WMI sont riches (c'est grâce à WMI que le composant Propriétés système de Windows peut afficher les propriétés du système sur un ordinateur distant ou local.), vous devez parfois faire plusieurs appels API pour obtenir la même quantités, certaines informations sont beaucoup plus facile à obtenir à et la syntaxe de filtrage peut réduire considérablement le code que vous devez écrire.


Commençons avec AutoIt :

Pour cet exemple on va travailler : Les classes matériels
Il faut dans un premier temps définir la classe à exploiter, ici nous allons utiliser Win32_BIOS ( SELECT * FROM Win32_BIOS).


Avec Autoit :
ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & $strComputer & "\root\CIMV2")
$objWMIService.ExecQuery("SELECT * FROM Win32_BIOS", "WQL", 0x10 + 0x20)
Première ligne :
On se connecte au service WMI (winmgmts) et on récupère la référence ($strComputer étant une variable à qui on attribue localhost) et l'espace de nom (\root\CIMV2).
ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & $strComputer & "\root\CIMV2")
ObjGet va nous permettre d'obtenir un objet COM en utilisant son nom de classe. On récupère une référence sur un objet à partir d'un processus ou d'un fichier existant.

winmgmts Gestionnaire d'objet CIM qui permet d’évaluer la requête WMI, service système appelé WinMgmt (C:\Windows\System32\wbem\WinMgmt)
WinMgmt donne le chemin de l'objet pour la classe sélectionnée.

impersonationLevel=impersonate Niveau d'emprunt d'identité COM à utiliser pour les opérations au cours de cette connexion. La valeur par défaut est ImpersonationLevel.Impersonate, elle indique que le fournisseur WMI peut emprunter l'identité du client pour l'exécution des opérations demandées au cours de cette connexion.

$strComputer nous permet de pointer la référence (localhost)

\root\CIMV2 classes CIM espace de nom CIMV2 accessible via Root\CIMV2. La plupart des classes que Windows gère résident dans l'espace de nom root\CIMv2. La majorité des classes WMI sont donc à la racine \cimv2.

Deuxième ligne :
On soumet la requête au gestionnaire winmgmts.
$objWMIService.ExecQuery("SELECT * FROM Win32_BIOS", "WQL", 0x10 + 0x20)
$objWMIService.ExecQuery (ExecQuery) va permettre de récupérer une collection d'instances de ressources WMI et peut être utilisé pour récupérer une collection filtrée des instances qui correspondent aux critères que vous avez définis dans la requête transmise à ExecQuery.
Les paramètres utilisés détermine le comportement de la requête et détermine si cet appel retourne immédiatement

SELECT * FROM Win32_BIOS détermine la requête (SELECT * FROM ) de la classe à utiliser dans cette exemple nous utiliserons Win32_BIOS

WQL La WMI Query Language (WQL) est un sous-ensemble de la langue (ANSI SQL), Elle permet l'extraction de la requête sur plusieurs objets du même type. Donc ce format qui se se rapproche de la syntaxe SQL est indispensable.

0x10 + 0x20
msdn.microsoft.com a écrit : wbemFlagForwardOnly (32 (0x20))
Provoque un avant uniquement recenseur à renvoyer. Forward-only recenseurs sont généralement beaucoup plus rapide et utilisent moins de mémoire que les agents recenseurs classiques, mais ils ne permettent pas les appels à SWbemObject.Clone_ .
msdn.microsoft.com a écrit : wbemFlagReturnImmediately (16 (0x10))
Provoque l'appel à revenir immédiatement.
Commençons notre code :

"Vous pouvez copier et coller dans Scite pour voir le résultat"
; Il est préférable de déclarer ces variables en Global si on veut continuer ce code avec d'autres classes.
Global $objWMIService = '' ; nous avons le choix soit "" (touche 3 du clavier) ou '' (touche 4 du clavier) déclaration de la variable pour l'objet (ObjGet)
Global $objItem = '' ; déclaration de la variable pour récupérer les objets dans la boucle
Global $colItems = '' ; déclaration de la variable pour la requête WMI
Global $strComputer = 'localhost' ; on pointe la référence
Global $Output = '' ; on déclare la variable pour stocker la requête
Global $OutputTitle = ' Pas de réponse' ; On déclare une variable pour palier si nous avons pas de réponse.

$objWMIService = ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & $strComputer & "\root\CIMV2")
$colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_BIOS", "WQL", 0x10 + 0x20)

If IsObj($colItems) Then ; on vérifie si la variable est de type objet
Local $Object_Flag = 0 ; on déclare à 0 pour une requête inexistante, ce qui affichera la MsgBox
For $objItem In $colItems ; on ouvre la boucle pour énuméré dans la variable $colItems
$Object_Flag = 1 ; on déclare à 1 pour une requête existante
$Output &= " Sortie WMI pour la classe Win32_BIOS " & @CRLF & @CRLF & @CRLF ; On affiche dans le résultat
$Output &= "BIOS : " & $objItem.BIOSVersion(0)& @CRLF ; Première information à récupérer
$Output &= "Language Edition : " & $objItem.CurrentLanguage & @CRLF ; Deuxième information à récupérer
$Output &= "Fabricant : " & $objItem.Manufacturer & @CRLF ; Troisème information à récupérer
$Output &= "Numéro de série : " & $objItem.SerialNumber & @CRLF ; Quatrième information à récupérer et on peut continuer tant cette classes à des infos à traiter.
If MsgBox(64, "", $Output) = 2 Then ExitLoop ; On affcihe le résultat de la requête
$Output = "" ; on réinitilise la variable pour les requêtes à suivre; si il y en à ;)
Next ; On ferme la boucle
; On assure que la requête soit vrai pour cela une condition peut faire le travail, il est nécessaire de contrôler.
If $Object_Flag = 0 Then MsgBox(48, "WMI", $OutputTitle & @CRLF & "Aucune sortie WMI pour cette classe" & "Win32_BIOS") ; On crée une condition, si le résultat = 0 ; Soit aucune sortie pour la classe sélectionnée.
Else ; sinon
MsgBox(32, "WMI", "Aucun objets WMI trouvés pour la Classe :" & "Win32_BIOS")
EndIf ; On affiche la requête

Nous allons utiliser (gain de temps quand on commence) un outil très connu et qui à été codé pour AutoIt.
Donc en solution de facilité il y a :

AutoIt ScriptOMatic

Téléchargement ScriptOMatic.au3
Sujet de l'auteur

L'outil charge les classes de WMI dans l'espace de nom root\CIMV2

Voici le code de ScriptOmatic.au3 (de SvenP)

Code : Tout sélectionner

; AutoIt ScriptOMatic
; -------------------
;
; AutoIt's counterpart of Microsoft's Scriptomatic
;
; Author:		SvenP
; Date/version:	2005-04-17
; See also:		http://www.microsoft.com/technet/scriptcenter/tools/scripto2.mspx
; Requires:		AutoIt beta version 3.1.1.8 or higher (COM support!!)
;
; GUI generated by AutoBuilder 0.5 Prototype

#include <GuiConstantsEx.au3>
#include <WindowsConstants.au3>

; ************************
; * Global State Variables
; ************************
Global $g_strCurrentNamespace = "\root\CIMV2"
Global $g_iCurrentNamespaceIndex = 0
Global $g_strWMISource = "localhost"
Global $g_strOutputFormat = "Dialog"

; ************************
; * Main GUI
; ************************

GUICreate("AutoIt Scriptomatic Tool", 684, 561, (@DesktopWidth - 684) / 2, (@DesktopHeight - 561) / 2, $WS_OVERLAPPEDWINDOW + $WS_VISIBLE + $WS_CLIPSIBLINGS)

Global $GUI_AST_MainGroup = GUICtrlCreateGroup("", 10, 10, 660, 530)
Global $GUI_WMI_NamespaceLabel = GUICtrlCreateLabel("WMI Namespace", 20, 30, 150, 20)
Global $GUI_WMI_Namespace = GUICtrlCreateCombo("WMI_Namespaces", 20, 50, 280, 21)
Global $GUI_WMI_ClassLabel = GUICtrlCreateLabel("WMI Class", 320, 30, 140, 20)
Global $GUI_WMI_Classes = GUICtrlCreateCombo("WMI_Classes", 320, 50, 340, 21)
Global $GUI_AST_Web = GUICtrlCreateButton("Lookup on WWW", 560, 27, 100, 20)
Global $GUI_AST_ButtonGroup = GUICtrlCreateGroup("", 10, 80, 660, 50)
Global $GUI_AST_Run = GUICtrlCreateButton("Run", 20, 100, 50, 20)
Global $GUI_AST_CIMv2 = GUICtrlCreateButton("CIMv2", 80, 100, 50, 20)
Global $GUI_AST_WMISource = GUICtrlCreateButton("WMISource", 140, 100, 70, 20)
Global $GUI_AST_Open = GUICtrlCreateButton("Open", 220, 100, 60, 20)
Global $GUI_AST_Save = GUICtrlCreateButton("Save", 290, 100, 60, 20)
Global $GUI_AST_Quit = GUICtrlCreateButton("Quit", 360, 100, 60, 20)
Global $GUI_AST_OptionGroup = GUICtrlCreateGroup("Output", 430, 80, 240, 50)
Global $GUI_AST_RadioDialog = GUICtrlCreateRadio("Dialog", 440, 100, 50, 20)
Global $GUI_AST_RadioText = GUICtrlCreateRadio("Text", 510, 100, 50, 20)
Global $GUI_AST_RadioHTML = GUICtrlCreateRadio("HTML", 570, 100, 50, 20)
Global $GUI_AST_ScriptCode = GUICtrlCreateEdit("One moment...", 20, 140, 640, 390)

GUISetState()

; Initial GUI Settings
GUICtrlSetState($GUI_AST_Web, $GUI_DISABLE)
GUICtrlSetState($GUI_AST_Run, $GUI_DISABLE)
GUICtrlSetState($GUI_AST_Save, $GUI_DISABLE)
GUICtrlSetState($GUI_AST_RadioDialog, $GUI_CHECKED)

; Fill the WMI_Namespaces Combobox
LoadWMINamespaces()

; Fill the WMI_Classes Combobox
HandleNamespaceChange()

Local $msg
While 1
	$msg = GUIGetMsg()
	Select
		Case $msg = $GUI_EVENT_CLOSE
			ExitLoop
		Case $msg = $GUI_AST_Quit
			ExitLoop
		Case $msg = $GUI_WMI_Namespace
			HandleNamespaceChange()
		Case $msg = $GUI_WMI_Classes
			ComposeCode()
		Case $msg = $GUI_AST_Web
			LookupWeb()
		Case $msg = $GUI_AST_Run
			RunScript()
		Case $msg = $GUI_AST_Save
			SaveScript()
		Case $msg = $GUI_AST_Open
			OpenScript()
		Case $msg = $GUI_AST_CIMv2
			SetNamespaceToCIMV2()
		Case $msg = $GUI_AST_WMISource
			SetWMIRepository()
		Case $msg = $GUI_AST_RadioDialog Or _
				$msg = $GUI_AST_RadioText Or _
				$msg = $GUI_AST_RadioHTML
			HandleOutputChange()
	EndSelect
WEnd

GUIDelete()

Exit

; ********************************************************************
; * LoadWMINamespaces
; ********************************************************************
Func LoadWMINamespaces()
	Local $strCsvListOfNamespaces = ""
	Local $strNameSpacesCombo = ""

	Local $strWaitNamespaces = "Please wait, Loading WMI Namespaces"
	GUICtrlSetData($GUI_WMI_Namespace, $strWaitNamespaces, $strWaitNamespaces)

	EnumNamespaces("root", $strCsvListOfNamespaces)

	Local $arrNamespaces = StringSplit($strCsvListOfNamespaces, ",")

	For $strNamespace In $arrNamespaces
		$strNameSpacesCombo = $strNameSpacesCombo & "|" & $strNamespace
	Next

	GUICtrlSetData($GUI_WMI_Namespace, $strNameSpacesCombo, "ROOT\CIMV2")
EndFunc   ;==>LoadWMINamespaces

; ********************************************************************
; * EnumNamespaces
; ********************************************************************
Func EnumNamespaces($strNamespace, ByRef $tmpCsvListOfNamespaces)
	If $tmpCsvListOfNamespaces = "" Then
		$tmpCsvListOfNamespaces = $strNamespace
	Else
		$tmpCsvListOfNamespaces = $tmpCsvListOfNamespaces & "," & $strNamespace
	EndIf

	; Local $strComputer = $g_strWMISource
	Local $objWMIService = ObjGet("winmgmts:\\" & $g_strWMISource & "\" & $strNamespace)

	If Not @error Then

		Local $colNameSpaces = $objWMIService.InstancesOf("__NAMESPACE")

		For $objNameSpace In $colNameSpaces
			EnumNamespaces($strNamespace & "\" & $objNameSpace.Name, $tmpCsvListOfNamespaces)
		Next
	Else
		$tmpCsvListOfNamespaces = ""
	EndIf
EndFunc   ;==>EnumNamespaces

; ********************************************************************
; * HandleNamespaceChange
; ********************************************************************
Func HandleNamespaceChange()
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	; Clear the WMI classes pulldown location.
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	Local $strSelectedNamespace = GUICtrlRead($GUI_WMI_Namespace)

	; Disable the namespace combobox until class load has been completed
	GUICtrlSetState($GUI_WMI_Namespace, $GUI_DISABLE)

	Local $strWMIWaitMsg = "Please wait, trying to load WMI Classes in namespace " & $strSelectedNamespace
	GUICtrlSetData($GUI_WMI_Classes, $strWMIWaitMsg, $strWMIWaitMsg)
	GUICtrlSetData($GUI_AST_ScriptCode, "One moment...", "")

	LoadWMIClasses()
	$g_strCurrentNamespace = "\" & $strSelectedNamespace

	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	; Clear the code textarea and disable run and save.
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	GUICtrlSetData($GUI_AST_ScriptCode, "", "")

	GUICtrlSetState($GUI_WMI_Namespace, $GUI_ENABLE)
	GUICtrlSetState($GUI_AST_Run, $GUI_DISABLE)
	GUICtrlSetState($GUI_AST_Save, $GUI_DISABLE)
EndFunc   ;==>HandleNamespaceChange

; ********************************************************************
; * LoadWMIClasses
; *
; * Fetch all the classes in the currently selected namespace, and
; * populate the keys of a dictionary object with the names of all
; * dynamic (non-association) classes. Then we transfer the keys to
; * an array, sort the array, and finally use the sorted array to
; * populate the WMI classes pulldown.
; ********************************************************************
Func LoadWMIClasses()
	Const $SORT_KEYS = 1
	; Const $SORT_ITEMS = 2

	Local $objClassDictionary = ObjCreate("Scripting.Dictionary")
	Local $objQualifierDictionary = ObjCreate("Scripting.Dictionary")

	Local $strComputer = "."
	Local $objWMIService = ObjGet("winmgmts:\\" & $strComputer & $g_strCurrentNamespace)

	If Not @error Then

		For $objClass In $objWMIService.SubclassesOf()

			For $objQualifier In $objClass.Qualifiers_() ; Dummy (), because it ends with an underscore !
				$objQualifierDictionary.Add(StringLower($objQualifier.Name), "")
			Next

			If $objQualifierDictionary.Exists("dynamic") Then

				;$TempVar = $objClass.Path_.Class
				;$objClassDictionary.Add($TempVar, "")	; Can't use object in arguments ?!!

				$objClassDictionary.Add($objClass.Path_.Class, "")

			EndIf

			$objQualifierDictionary.RemoveAll

		Next

		$objQualifierDictionary = ""

		;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; If the current namespace contains dynamic classes...
		;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		If $objClassDictionary.Count Then

			;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
			; Sort the dictionary.
			;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
			SortDictionary($objClassDictionary, $SORT_KEYS)

			;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
			; Populate the WMI classes pulldown with the sorted dictionary.
			;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

			Local $strClassesCombo = "|Select a WMI class"

			For $strWMIClass In $objClassDictionary ;  method .Keys is not an object ??
				$strClassesCombo = $strClassesCombo & "|" & $strWMIClass
			Next

			GUICtrlSetData($GUI_WMI_Classes, $strClassesCombo, "Select a WMI class")

		EndIf
	EndIf

	If @error Or $objClassDictionary.Count = 0 Then
		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; And If the current namespace doesn't contain dynamic classes.
		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		GUICtrlSetData($GUI_WMI_Classes, "|No dynamic classes found in current namespace.|Select a different namespace", "")

	EndIf

	$objClassDictionary = ""
EndFunc   ;==>LoadWMIClasses

; ********************************************************************
; * SortDictionary
; *
; * Shell sort based on:
; * http://support.microsoft.com/support/kb/articles/q246/0/67.asp
; ********************************************************************
Func SortDictionary(ByRef $objDict, $intSort)
	Const $dictKey = 1
	Const $dictItem = 2

	Local $strDict[1][3]

	Local $intCount = $objDict.Count

	If $intCount > 1 Then

		ReDim $strDict[$intCount][3]

		Local $i = 0
		For $objKey In $objDict

			$strDict[$i][$dictKey] = String($objKey)
			$strDict[$i][$dictItem] = String($objDict($objKey))

			$i = $i + 1
		Next

		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; Perform a shell sort of the 2D string array
		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		For $i = 0 To ($intCount - 2)
			For $j = $i To ($intCount - 1)
				If $strDict[$i][$intSort] > $strDict[$j][$intSort] Then
					Local $strKey = $strDict[$i][$dictKey]
					Local $strItem = $strDict[$i][$dictItem]
					$strDict[$i][$dictKey] = $strDict[$j][$dictKey]
					$strDict[$i][$dictItem] = $strDict[$j][$dictItem]
					$strDict[$j][$dictKey] = $strKey
					$strDict[$j][$dictItem] = $strItem
				EndIf
			Next
		Next

		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; Erase the contents of the dictionary object
		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		$objDict.RemoveAll

		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; Repopulate the dictionary with the sorted information
		;''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		For $i = 0 To ($intCount - 1)
			$objDict.Add($strDict[$i][$dictKey], $strDict[$i][$dictItem])
		Next

	EndIf
EndFunc   ;==>SortDictionary

; ********************************************************************
; * ComposeCode
; ********************************************************************
Func ComposeCode()
	Local $objClass = ""

	Local $strSelectedClass = GUICtrlRead($GUI_WMI_Classes)
	; Check If a valid class has been selected
	If $strSelectedClass <> "Select a WMI class" Then

		Local $bHasDates = False ; Flag: output has date fields
		Local $strHeaderStart = Chr(34)
		Local $strRowStart = Chr(34)
		Local $strColumnSeparator = ": "
		Local $strRowEnd = " & @CRLF"

		Local $strComputerCommand = "$strComputer = " & Chr(34) & $g_strWMISource & Chr(34)

		Local $objWMIService = ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & @ComputerName & $g_strCurrentNamespace)
		$objClass = $objWMIService.Get($strSelectedClass)

		If IsObj($objClass) Then

			Local $strScriptCode = ""
			$strScriptCode = $strScriptCode & "; Generated by AutoIt Scriptomatic" & @CRLF & @CRLF
			$strScriptCode = $strScriptCode & "$wbemFlagReturnImmediately = 0x10" & @CRLF
			$strScriptCode = $strScriptCode & "$wbemFlagForwardOnly = 0x20" & @CRLF
			$strScriptCode = $strScriptCode & '$colItems = ""' & @CRLF
			$strScriptCode = $strScriptCode & $strComputerCommand & @CRLF & @CRLF
			$strScriptCode = $strScriptCode & '$Output=""' & @CRLF

			If $g_strOutputFormat = "HTML" Then
				$strScriptCode = $strScriptCode & "$Output = $Output & '<html><head><title>Scriptomatic HTML Output</title></head><body> " & _
						"<style>table {font-size: 10pt; font-family: arial;} th {background-color: buttonface; font-decoration: bold;} " & _
						"</style><table BORDER=" & Chr(34) & "1" & Chr(34) & "><tr><th>Property</th><th>Value</th></tr>'" & @CRLF
				$strRowStart = Chr(34) & "<tr><td>"
				$strHeaderStart = "'<tr bgcolor=" & Chr(34) & "yellow" & Chr(34) & "><td>' & " & Chr(34)
				$strColumnSeparator = "</td><td>&nbsp;"
				$strRowEnd = " & " & Chr(34) & "</td></tr>" & Chr(34) & " & @CRLF"
			EndIf

			$strScriptCode = $strScriptCode & "$Output = $Output & " & $strHeaderStart & "Computer" & $strColumnSeparator & Chr(34) & " & $strComputer " & $strRowEnd & @CRLF

			If $g_strOutputFormat = "Dialog" Then
				$strScriptCode = $strScriptCode & "$Output = $Output & " & Chr(34) & "==========================================" & Chr(34) & $strRowEnd & @CRLF
			EndIf

			$strScriptCode = $strScriptCode & "$objWMIService = ObjGet(" & Chr(34) & "winmgmts:\\" & Chr(34) & " & $strComputer & " & Chr(34) & $g_strCurrentNamespace & Chr(34) & ")" & @CRLF
			$strScriptCode = $strScriptCode & "$colItems = $objWMIService.ExecQuery(" & Chr(34) & "SELECT * FROM " & $strSelectedClass & Chr(34) & ", " & Chr(34) & "WQL" & Chr(34) & ", _" & @CRLF
			$strScriptCode = $strScriptCode & "                                          $wbemFlagReturnImmediately + $wbemFlagForwardOnly)" & @CRLF & @CRLF
			$strScriptCode = $strScriptCode & "If IsObj($colItems) Then" & @CRLF
			$strScriptCode = $strScriptCode & "   For $objItem In $colItems" & @CRLF

			For $objProperty In $objClass.Properties_() ; Must use (), because method ends with an underscore

				If $objProperty.IsArray = True Then
					$strScriptCode = $strScriptCode & "      $str" & $objProperty.Name & " = $objItem." & $objProperty.Name & "(0)" & @CRLF
					$strScriptCode = $strScriptCode & "      $Output = $Output & " & $strRowStart & $objProperty.Name & $strColumnSeparator & Chr(34) & " & $str" & $objProperty.Name & $strRowEnd & @CRLF
				ElseIf $objProperty.CIMTYPE = 101 Then
					$bHasDates = True
					$strScriptCode = $strScriptCode & "      $Output = $Output & " & $strRowStart & $objProperty.Name & $strColumnSeparator & Chr(34) & " & WMIDateStringToDate($objItem." & $objProperty.Name & ")" & $strRowEnd & @CRLF
				Else
					$strScriptCode = $strScriptCode & "      $Output = $Output & " & $strRowStart & $objProperty.Name & $strColumnSeparator & Chr(34) & " & $objItem." & $objProperty.Name & $strRowEnd & @CRLF
				EndIf
			Next

			If $g_strOutputFormat = "Dialog" Then
				$strScriptCode = $strScriptCode & '      If MsgBox(1,"WMI Output",$Output) = 2 Then ExitLoop' & @CRLF
				$strScriptCode = $strScriptCode & '      $Output=""' & @CRLF
			EndIf
			$strScriptCode = $strScriptCode & "   Next" & @CRLF

			If $g_strOutputFormat = "Text" Then
				$strScriptCode = $strScriptCode & '   ConsoleWrite($Output)' & @CRLF
				$strScriptCode = $strScriptCode & '   FileWrite(@TempDir & "\' & $strSelectedClass & '.TXT", $Output )' & @CRLF
				$strScriptCode = $strScriptCode & '   Run(@ComSpec & " /c start " & @TempDir & "\' & $strSelectedClass & '.TXT" )' & @CRLF
			ElseIf $g_strOutputFormat = "HTML" Then
				$strScriptCode = $strScriptCode & '   FileWrite(@TempDir & "\' & $strSelectedClass & '.HTML", $Output )' & @CRLF
				$strScriptCode = $strScriptCode & '   Run(@ComSpec & " /c start " & @TempDir & "\' & $strSelectedClass & '.HTML" )' & @CRLF
			EndIf

			$strScriptCode = $strScriptCode & "Else" & @CRLF
			$strScriptCode = $strScriptCode & '   MsgBox(0,"WMI Output","No WMI Objects Found for class: " & ' & Chr(34) & $strSelectedClass & Chr(34) & ' )' & @CRLF

			$strScriptCode = $strScriptCode & "EndIf" & @CRLF
			$strScriptCode = $strScriptCode & @CRLF & @CRLF

			If $bHasDates Then
				$strScriptCode = $strScriptCode & "Func WMIDateStringToDate($dtmDate)" & @CRLF
				$strScriptCode = $strScriptCode & @CRLF
				$strScriptCode = $strScriptCode & Chr(9) & "Return (StringMid($dtmDate, 5, 2) & ""/"" & _" & @CRLF
				$strScriptCode = $strScriptCode & Chr(9) & "StringMid($dtmDate, 7, 2) & ""/"" & StringLeft($dtmDate, 4) _" & @CRLF
				$strScriptCode = $strScriptCode & Chr(9) & "& "" "" & StringMid($dtmDate, 9, 2) & "":"" & StringMid($dtmDate, 11, 2) & "":"" & StringMid($dtmDate,13, 2))" & @CRLF
				$strScriptCode = $strScriptCode & "EndFunc"
			EndIf
		Else
			$strScriptCode = "Error: No Class properties found for " & $g_strCurrentNamespace & "\" & $strSelectedClass
		EndIf

		GUICtrlSetData($GUI_AST_ScriptCode, $strScriptCode)

		;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
		; Once the code is successfully composed and put into the
		; textarea, ensure that the run and save buttons are enabled.
		;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

		GUICtrlSetState($GUI_AST_Run, $GUI_ENABLE)
		GUICtrlSetState($GUI_AST_Save, $GUI_ENABLE)

		; Enable Web lookup button
		GUICtrlSetState($GUI_AST_Web, $GUI_ENABLE)
	Else
		; Disable Web, Run and Save buttons, because no valid code has been generated
		GUICtrlSetState($GUI_AST_Web, $GUI_DISABLE)
		GUICtrlSetState($GUI_AST_Run, $GUI_DISABLE)
		GUICtrlSetState($GUI_AST_Save, $GUI_DISABLE)
	EndIf
EndFunc   ;==>ComposeCode

; ********************************************************************
; * RunScript
; ********************************************************************
Func RunScript()
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	; Create a temporary script file named "temp_script.au3".
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

	Local $strTmpName = @TempDir & "\temp_script.au3"

	If FileExists($strTmpName) Then FileDelete($strTmpName)

	FileWrite($strTmpName, GUICtrlRead($GUI_AST_ScriptCode))

	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	; Start constructing the command line that will run the script...
	;'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
	Local $strCmdLine = @AutoItExe & " " & $strTmpName

	RunWait($strCmdLine)

	FileDelete($strTmpName)
EndFunc   ;==>RunScript

; ********************************************************************
; * SaveScript
; ********************************************************************
Func SaveScript()
	Local $strTmpName = FileSaveDialog("Save Script", @DesktopDir, "AutoIt3 Scripts (*.au3)", 16, GUICtrlRead($GUI_WMI_Classes))

	If Not @error And $strTmpName <> "" Then
		If StringRight($strTmpName, 4) <> ".AU3" Then $strTmpName = $strTmpName & ".AU3"
		If FileExists($strTmpName) Then FileDelete($strTmpName)
		FileWrite($strTmpName, GUICtrlRead($GUI_AST_ScriptCode))
	EndIf
EndFunc   ;==>SaveScript

; ********************************************************************
; * OpenScript
; ********************************************************************

Func OpenScript()
	Local $strTmpName = FileOpenDialog("Open Script", @DesktopDir, "AutoIt3 Scripts (*.au3)")

	If Not @error And $strTmpName <> "" Then
		If FileExists($strTmpName) Then
			GUICtrlSetData($GUI_AST_ScriptCode, FileRead($strTmpName, FileGetSize($strTmpName)))
		EndIf
	EndIf
EndFunc   ;==>OpenScript

; ****************************************************************************
; * SetNamespaceToCIMV2
; ****************************************************************************
Func SetNamespaceToCIMV2()
	If StringUpper(GUICtrlRead($GUI_WMI_Namespace)) <> "ROOT\CIMV2" Then
		GUICtrlSetData($GUI_WMI_Namespace, "ROOT\CIMV2", "ROOT\CIMV2")
		HandleNamespaceChange()
	EndIf
EndFunc   ;==>SetNamespaceToCIMV2

; ****************************************************************************
; * SetWMIRepository
; ****************************************************************************
Func SetWMIRepository()
	Local $strWMISourceName = InputBox("Set WMI Repository Source", _
			"Please enter the computer whose WMI repository you want to read from: ", _
			$g_strWMISource)
	If $strWMISourceName <> "" Then

		$g_strWMISource = StringStripWS($strWMISourceName, 1 + 2)
		;target_computers.Value = $g_strWMISource
		LoadWMINamespaces()
	EndIf
EndFunc   ;==>SetWMIRepository

; ****************************************************************************
; * HandleOutputChange
; ****************************************************************************
Func HandleOutputChange()
	Local $ChosenFormat = $g_strOutputFormat
	If GUICtrlRead($GUI_AST_RadioDialog) = $GUI_CHECKED Then $ChosenFormat = "Dialog"
	If GUICtrlRead($GUI_AST_RadioText) = $GUI_CHECKED Then $ChosenFormat = "Text"
	If GUICtrlRead($GUI_AST_RadioHTML) = $GUI_CHECKED Then $ChosenFormat = "HTML"
	If $ChosenFormat <> $g_strOutputFormat Then
		$g_strOutputFormat = $ChosenFormat
		ComposeCode()
	EndIf
EndFunc   ;==>HandleOutputChange

; ****************************************************************************
; * LookupWeb
; ****************************************************************************
Func LookupWeb()
	Local $strSelectedClass = GUICtrlRead($GUI_WMI_Classes)

	; Check If a valid class has been selected
	If $strSelectedClass <> "Select a WMI class" Then
		Run(@ComSpec & " /c start http://msdn.microsoft.com/library/en-us/wmisdk/wmi/" & $strSelectedClass & ".asp?frame=true", "", @SW_HIDE)
	EndIf
EndFunc   ;==>LookupWeb

Exécuter ce code (ScriptOMatic de SvenP) et sélectionner Win32_BIOS et visualiser le résultat.

Code : Tout sélectionner

;Généré par AutoIt ScriptOMatic

$wbemFlagReturnImmediately = 0x10
$wbemFlagForwardOnly = 0x20
$colItems = ""
$strComputer = "localhost"

$OutputTitle = ""
$Output = ""
$OutputTitle &= "Computer: " & $strComputer  & @CRLF
$OutputTitle &= "==========================================" & @CRLF
$objWMIService = ObjGet("winmgmts:\\" & $strComputer & "\root\CIMV2")
$colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_BIOS", "WQL", _
                                          $wbemFlagReturnImmediately + $wbemFlagForwardOnly)

If IsObj($colItems) then
   Local $Object_Flag = 0
   For $objItem In $colItems
      $Object_Flag = 1
      $strBiosCharacteristics = $objItem.BiosCharacteristics(0)
      $Output &= "BiosCharacteristics: " & $strBiosCharacteristics & @CRLF
      $strBIOSVersion = $objItem.BIOSVersion(0)
      $Output &= "BIOSVersion: " & $strBIOSVersion & @CRLF
      $Output &= "BuildNumber: " & $objItem.BuildNumber & @CRLF
      $Output &= "Caption: " & $objItem.Caption & @CRLF
      $Output &= "CodeSet: " & $objItem.CodeSet & @CRLF
      $Output &= "CurrentLanguage: " & $objItem.CurrentLanguage & @CRLF
      $Output &= "Description: " & $objItem.Description & @CRLF
      $Output &= "EmbeddedControllerMajorVersion: " & $objItem.EmbeddedControllerMajorVersion & @CRLF
      $Output &= "EmbeddedControllerMinorVersion: " & $objItem.EmbeddedControllerMinorVersion & @CRLF
      $Output &= "IdentificationCode: " & $objItem.IdentificationCode & @CRLF
      $Output &= "InstallableLanguages: " & $objItem.InstallableLanguages & @CRLF
      $Output &= "InstallDate: " & WMIDateStringToDate($objItem.InstallDate) & @CRLF
      $Output &= "LanguageEdition: " & $objItem.LanguageEdition & @CRLF
      $strListOfLanguages = $objItem.ListOfLanguages(0)
      $Output &= "ListOfLanguages: " & $strListOfLanguages & @CRLF
      $Output &= "Manufacturer: " & $objItem.Manufacturer & @CRLF
      $Output &= "Name: " & $objItem.Name & @CRLF
      $Output &= "OtherTargetOS: " & $objItem.OtherTargetOS & @CRLF
      $Output &= "PrimaryBIOS: " & $objItem.PrimaryBIOS & @CRLF
      $Output &= "ReleaseDate: " & WMIDateStringToDate($objItem.ReleaseDate) & @CRLF
      $Output &= "SerialNumber: " & $objItem.SerialNumber & @CRLF
      $Output &= "SMBIOSBIOSVersion: " & $objItem.SMBIOSBIOSVersion & @CRLF
      $Output &= "SMBIOSMajorVersion: " & $objItem.SMBIOSMajorVersion & @CRLF
      $Output &= "SMBIOSMinorVersion: " & $objItem.SMBIOSMinorVersion & @CRLF
      $Output &= "SMBIOSPresent: " & $objItem.SMBIOSPresent & @CRLF
      $Output &= "SoftwareElementID: " & $objItem.SoftwareElementID & @CRLF
      $Output &= "SoftwareElementState: " & $objItem.SoftwareElementState & @CRLF
      $Output &= "Status: " & $objItem.Status & @CRLF
      $Output &= "SystemBiosMajorVersion: " & $objItem.SystemBiosMajorVersion & @CRLF
      $Output &= "SystemBiosMinorVersion: " & $objItem.SystemBiosMinorVersion & @CRLF
      $Output &= "TargetOperatingSystem: " & $objItem.TargetOperatingSystem & @CRLF
      $Output &= "Version: " & $objItem.Version & @CRLF
      if Msgbox(1,"Sortie WMI",$Output) = 2 then ExitLoop
      $Output=""
   Next
  If $Object_Flag = 0 Then Msgbox(1,"Sortie WMI",$OutputTitle)
Else
   Msgbox(0,"Sortie WMI","Aucun objets WMI trouvés pour la Classe :" & "Win32_BIOS" )
Endif


Func WMIDateStringToDate($dtmDate)
	Return (StringMid($dtmDate, 5, 2) & "/" & _
	StringMid($dtmDate, 7, 2) & "/" & StringLeft($dtmDate, 4) _
	& " " & StringMid($dtmDate, 9, 2) & ":" & StringMid($dtmDate, 11, 2) & ":" & StringMid($dtmDate,13, 2))
EndFunc
Image

Le résultat peut-être affiné si on ne veut pas sortir toutes ces informations, et nous pouvons exploiter ces requêtes.
Exemple nous avons la première ligne qui nous donne :

BiosCharacteristics : 7
Pour exploiter ce résultat il faut se rendre sur la page de la Classe Win32_Bios.
Elle nous donne toute les informations que l'on veut extraire des caractéristiques du bios.
BiosCharacteristics

Data type: uint16 array
Access type: Read-only
Qualifiers: MappingStrings ("SMBIOS|Type 0|BIOS Characteristics")

Array of BIOS characteristics supported by the system as defined by the System Management BIOS Reference Specification.

This value comes from the BIOS Characteristics member of the BIOS Information structure in the SMBIOS information.

The possible values are.

Reserved (0)

Reserved (1)

Unknown (2)

BIOS Characteristics Not Supported (3)

ISA is supported (4)

MCA is supported (5)

EISA is supported (6)

PCI is supported (7)

PC Card (PCMCIA) is supported (8)

Plug and Play is supported (9)

APM is supported (10)

BIOS is Upgradeable (Flash) (11)

BIOS is Upgradable (Flash)

BIOS shadowing is allowed (12)

VL-VESA is supported (13)

ESCD support is available (14)

Boot from CD is supported (15)

Selectable Boot is supported (16)

BIOS ROM is socketed (17)

Boot From PC Card (PCMCIA) is supported (18)

EDD (Enhanced Disk Drive) Specification is supported (19)

Int 13h - Japanese Floppy for NEC 9800 1.2mb (3.5\", 1k Bytes/Sector, 360 RPM) is supported (20)

Int 13h - Japanese Floppy for NEC 9800 1.2mb (3.5, 1k Bytes/Sector, 360 RPM) is supported

Int 13h - Japanese Floppy for Toshiba 1.2mb (3.5\", 360 RPM) is supported (21)

Int 13h - Japanese Floppy for Toshiba 1.2mb (3.5, 360 RPM) is supported

Int 13h - 5.25\" / 360 KB Floppy Services are supported (22)

Int 13h - 5.25 / 360 KB Floppy Services are supported

Int 13h - 5.25\" /1.2MB Floppy Services are supported (23)

Int 13h - 5.25 /1.2MB Floppy Services are supported

Int 13h - 3.5\" / 720 KB Floppy Services are supported (24)

Int 13h - 3.5 / 720 KB Floppy Services are supported

Int 13h - 3.5\" / 2.88 MB Floppy Services are supported (25)

Int 13h - 3.5 / 2.88 MB Floppy Services are supported

Int 5h, Print Screen Service is supported (26)

Int 9h, 8042 Keyboard services are supported (27)

Int 14h, Serial Services are supported (28)

Int 17h, printer services are supported (29)

Int 10h, CGA/Mono Video Services are supported (30)

NEC PC-98 (31)

ACPI supported (32)

ACPI is supported

USB Legacy is supported (33)

AGP is supported (34)

I2O boot is supported (35)

LS-120 boot is supported (36)

ATAPI ZIP Drive boot is supported (37)

1394 boot is supported (38)

Smart Battery supported (39)

Smart Battery is supported
40–47

Reserved for BIOS vendor
48–63

Reserved for system vendor
Avec AutoIt pour afficher les valeurs données il faut faire deux boucles imbriquées sinon seul la première valeur est soustraite.
Une première boucle pour énumérer et une deuxième pour les comptabiliser.
Pour avoir toute les sorties nous allons écrire ce que nous donne Win32_BIOS dans une fonction.
Func _BIOSARCH()
Local $strBiosCharacteristics = $objItem.BiosCharacteristics
For $Bios In $strBiosCharacteristics
Switch $Bios
Case 0
$Output &= "- Réservé (0)" & @CRLF
Case 1
$Output &= "- Réservé (1)" & @CRLF
Case 2
$Output &= "- Inconnu (2)" & @CRLF
Case 3
$Output &= "- BIOS Caractéristiques non pris en charge (3)" & @CRLF
Case 4
$Output &= "- ISA est pris en charge (4)" & @CRLF
Case 5
$Output &= "- MCA est pris en charge (5)" & @CRLF
Case 6
$Output &= "- EISA est pris en charge (6)" & @CRLF
Case 7
$Output &= "- PCI est pris en charge (7)" & @CRLF
Case 8
$Output &= "- PC Card (PCMCIA) est pris en charge (8)" & @CRLF
Case 9
$Output &= "- Plug and Play est pris en charge (9)" & @CRLF
Case 10
$Output &= "- APM est pris en charge (10)" & @CRLF
Case 11
$Output &= "- BIOS est actualisable (Flash) (11)" & @CRLF
Case 12
$Output &= "- Observation du BIOS est autorisé (12)" & @CRLF
Case 13
$Output &= "- VL-VESA est pris en charge (13)" & @CRLF
Case 14
$Output &= "- Support ESCD est disponible (14)" & @CRLF
Case 15
$Output &= "- Boot from CD est pris en charge (15)" & @CRLF
Case 16
$Output &= "- Boot sélectionnable est pris en charge (16)" & @CRLF
Case 17
$Output &= "- BIOS ROM est connectable (17)" & @CRLF
Case 18
$Output &= "- Boot De PC Card (PCMCIA) est prise en charge (18)" & @CRLF
Case 19
$Output &= "- EDD (Enhanced Disk Drive) Spécification est prise en charge (19)" & @CRLF
Case 20
$Output &= "- Int 13h - Floppy japonais pour NEC 9800 1.2mb (3,5 \ , 1k octets / secteur, 360 RPM) est pris en charge(20) " & @CRLF
Case 21
$Output &= "- Int 13h - Floppy japonais pour Toshiba 1.2mb (3,5 \ , 360 RPM) est pris en charge(21) " & @CRLF
Case 22
$Output &= "- Int 13h - 5,25 \ / 360 KB Floppy services sont pris en charge(22) " & @CRLF
Case 23
$Output &= "- Int 13h - 5,25 \ / 1.2MB services Floppy sont pris en charge(23) " & @CRLF
Case 24
$Output &= "- Int 13h - 3,5 \ / 720 KB Floppy services sont pris en charge(24) " & @CRLF
Case 25
$Output &= "- Int 13h - 3,5 \ / 2.88 MB Floppy services sont pris en charge(25) " & @CRLF
Case 26
$Output &= "- Int 5h, service d' impression écran est prise en charge (26)" & @CRLF
Case 27
$Output &= "- Int 9H, 8042 services de clavier sont pris en charge (27)" & @CRLF
Case 28
$Output &= "- Int 14h, services de série sont pris en charge (28)" & @CRLF
Case 29
$Output &= "- Int 17h, les services d'impression sont pris en charge (29)" & @CRLF
Case 30
$Output &= "- Int 10h, CGA / Mono services vidéo sont pris en charge (30)" & @CRLF
Case 31
$Output &= "- NEC PC-98 (31)" & @CRLF
Case 32
$Output &= "- ACPI pris en charge (32)" & @CRLF
Case 33
$Output &= "- Legacy USB est prise en charge (33)" & @CRLF
Case 34
$Output &= "- AGP est prise en charge (34)" & @CRLF
Case 35
$Output &= "- I2O boot est prise en charge (35)" & @CRLF
Case 36
$Output &= "- LS-120 boot est prise en charge (36)" & @CRLF
Case 37
$Output &= "- ATAPI lecteur ZIP boot est pris en charge (37)" & @CRLF
Case 38
$Output &= "- 1394 boot est pris en charge (38)" & @CRLF
Case 39
$Output &= "- Smart Battery prise en charge (39)" & @CRLF
Case 40 To 47
$Output &= "- Réservé aux fournisseurs de BIOS (40 - 47)" & @CRLF
Case 48 To 63
$Output &= "- Réservé aux fournisseurs Système (48 - 63)" & @CRLF
EndSwitch
Next
EndFunc ;==>_BIOSARCH

Ce qui nous donne :

Code : Tout sélectionner

#include <AutoItConstants.au3>
#include <array.au3>
; Commentaires Amesam

; Je déclare mes variables en global au cas ou mon code se compose de plusieurs requête. Bonne habitude à prendre pour éviter les soucis suite à la compilation.
Global $wbemFlagReturnImmediately = 0x10 ; le flag provoque l'appel à revenir immédiatement et réduit au minimum la quantité de ressources utilisées.
Global $wbemFlagForwardOnly = 0x20 ; Bloque jusqu'a que l'appel soit terminé. A utiliser en conbinaison avec $wbemFlagReturnImmediately
; pour plus d'info :   https://msdn.microsoft.com/en-us/library/windows/desktop/aa393980%28v=vs.85%29.aspx
Global $objWMIService = ''
Global $objItem = ''
Global $colItems = '' ; déclaration de la variable pour la requête WMI
Global $strComputer = 'localhost' ; on pointe la référence
Global $i

Global $OutputTitle = '' ; On déclare une variable pour palier si nous avons pas de réponse.
Global $Output = '' ; on déclare la variable pour stocker la requête
$OutputTitle &= "Computer: " & $strComputer & @CRLF ; sera utilisé si nous avons pas de réponse de la requête
$OutputTitle &= "==========================================" & @CRLF

; ObjGet;==> obtient un objet en utilisant son nom de classe
; winmgmts  ;==> Service WMI
; \root\CIMV2  ;==>  L'espace de noms root / cimv2 est l'espace de noms par défaut et contient la majorité des classes utiles.
;  $objWMIService.ExecQuery ; ==> Un objet ObjectQuery(oq) : C'est à lui que l'on va donner la requête qui permettra de récupérer les informations voulues
; "SELECT * FROM Win32_BIOS", "WQL  ;==> on demande la requête de la classe Win32_BIOS au format WQL
; > Représente les attributs de base entrée ou de sortie des services du système informatique (BIOS) qui sont installés sur l'ordinateur.
$objWMIService = ObjGet("winmgmts:{impersonationLevel=impersonate}!\\" & $strComputer & "\root\CIMV2")
$colItems = $objWMIService.ExecQuery("SELECT * FROM Win32_BIOS", "WQL", _
		$wbemFlagReturnImmediately + $wbemFlagForwardOnly)

If IsObj($colItems) Then ; on vérifie si la variable est de type objet
	Local $Object_Flag = 0 ; on déclare à 0 pour une requête inexistante, ce qui affcihera la MsgBox
	For $objItem In $colItems ; on ouvre la boucle pour énuméré dans la variable $colItems
		$Object_Flag = 1 ; on déclare à 1 pour une requête existante
		$Output &= " Sortie WMI pour la classe Win32_BIOS " & @CRLF & @CRLF & @CRLF
		$Output &= "BIOS : " & $objItem.BIOSVersion(0) & @CRLF
		$Output &= "Language Edition : " & $objItem.CurrentLanguage & @CRLF
		$Output &= "Fabricant : " & $objItem.Manufacturer & @CRLF
		$Output &= "Numéro de série : " & $objItem.SerialNumber & @CRLF
		_SMBIOS()
		_BIOS_SES()
		$Output &= "Status: " & $objItem.Status & @CRLF & @CRLF
		$Output &= "Caractéristiques du BIOS : " & @CRLF
		$Output &= "-------------------------" & @CRLF
		$BCaracteristiques = ""
		_BIOSARCH()
		If MsgBox(64, "", $Output) = 2 Then ExitLoop ; On affcihe le résultat de la requête
		$Output = "" ; on réinitilise la variable pour les requêtes à suivre; si il y en à ;)
	Next
	If $Object_Flag = 0 Then MsgBox(48, "WMI", $OutputTitle & @CRLF & "Aucune sortie WMI pour cette classe")
Else
	MsgBox(32, "WMI", "Aucun objets WMI trouvés pour la Classe :" & "Win32_BIOS")
EndIf

Func _SMBIOS()
	Local $SMBIOS = $objItem.SMBIOSPresent
	If $SMBIOS = True Then
		$Output &= "SMBIOS : Disponible " & @CRLF
		$Output &= "SMBIOS : Version du système de mesure " & $objItem.SMBIOSBIOSVersion & @CRLF
	Else
		$Output &= "SMBIOS Non disponible : " & $objItem.SMBIOSPresent & @CRLF
	EndIf
EndFunc   ;==>_SMBIOS

Func _BIOS_SES()
	Local $SoftwareElementState = $objItem.SoftwareElementState
	Switch $SoftwareElementState
		Case 0
			$Output &= "État du logiciel d'installation : Déployable (0)" & @CRLF
		Case 1
			$Output &= "État du logiciel d'installation : Installable (1)" & @CRLF
		Case 2
			$Output &= "État du logiciel d'installation : Executable (2)" & @CRLF
		Case 3
			$Output &= "État du logiciel d'installation : Exécution (3)" & @CRLF
	EndSwitch
;~ 	Next
EndFunc   ;==>_BIOS_SES


Func _BIOSARCH()
	Local $strBiosCharacteristics = $objItem.BiosCharacteristics
	For $Bios In $strBiosCharacteristics
		Switch $Bios
			Case 0
				$Output &= "- Réservé (0)" & @CRLF
			Case 1
				$Output &= "- Réservé (1)" & @CRLF
			Case 2
				$Output &= "- Inconnu (2)" & @CRLF
			Case 3
				$Output &= "- BIOS Caractéristiques non pris en charge (3)" & @CRLF
			Case 4
				$Output &= "- ISA est pris en charge (4)" & @CRLF
			Case 5
				$Output &= "- MCA est pris en charge (5)" & @CRLF
			Case 6
				$Output &= "- EISA est pris en charge (6)" & @CRLF
			Case 7
				$Output &= "- PCI est pris en charge (7)" & @CRLF
			Case 8
				$Output &= "- PC Card (PCMCIA) est pris en charge (8)" & @CRLF
			Case 9
				$Output &= "- Plug and Play est pris en charge (9)" & @CRLF
			Case 10
				$Output &= "- APM est pris en charge (10)" & @CRLF
			Case 11
				$Output &= "- BIOS est actualisable (Flash) (11)" & @CRLF
			Case 12
				$Output &= "- Observation du BIOS est autorisé  (12)" & @CRLF
			Case 13
				$Output &= "- VL-VESA est pris en charge (13)" & @CRLF
			Case 14
				$Output &= "- Support ESCD est disponible (14)" & @CRLF
			Case 15
				$Output &= "- Boot from CD est pris en charge (15)" & @CRLF
			Case 16
				$Output &= "- Boot sélectionnable est pris en charge (16)" & @CRLF
			Case 17
				$Output &= "- BIOS ROM est connectable (17)" & @CRLF
			Case 18
				$Output &= "- Boot De PC Card (PCMCIA) est prise en charge (18)" & @CRLF
			Case 19
				$Output &= "- EDD (Enhanced Disk Drive) Spécification est prise en charge (19)" & @CRLF
			Case 20
				$Output &= "- Int 13h - Floppy japonais pour NEC 9800 1.2mb (3,5 \ , 1k octets / secteur, 360 RPM) est pris en charge(20) " & @CRLF
			Case 21
				$Output &= "- Int 13h - Floppy japonais pour Toshiba 1.2mb (3,5 \ , 360 RPM) est pris en charge(21) " & @CRLF
			Case 22
				$Output &= "- Int 13h - 5,25 \  / 360 KB Floppy services sont pris en charge(22) " & @CRLF
			Case 23
				$Output &= "- Int 13h - 5,25 \  / 1.2MB services Floppy sont pris en charge(23) " & @CRLF
			Case 24
				$Output &= "- Int 13h - 3,5 \  / 720 KB Floppy services sont pris en charge(24) " & @CRLF
			Case 25
				$Output &= "- Int 13h - 3,5 \  / 2.88 MB Floppy services sont pris en charge(25) " & @CRLF
			Case 26
				$Output &= "- Int 5h, service d' impression écran est prise en charge (26)" & @CRLF
			Case 27
				$Output &= "- Int 9H, 8042 services de clavier sont pris en charge (27)" & @CRLF
			Case 28
				$Output &= "- Int 14h, services de série sont pris en charge (28)" & @CRLF
			Case 29
				$Output &= "- Int 17h, les services d'impression sont pris en charge (29)" & @CRLF
			Case 30
				$Output &= "- Int 10h, CGA / Mono services vidéo sont pris en charge (30)" & @CRLF
			Case 31
				$Output &= "- NEC PC-98 (31)" & @CRLF
			Case 32
				$Output &= "- ACPI pris en charge (32)" & @CRLF
			Case 33
				$Output &= "- Legacy USB est prise en charge (33)" & @CRLF
			Case 34
				$Output &= "- AGP est prise en charge (34)" & @CRLF
			Case 35
				$Output &= "- I2O boot est prise en charge (35)" & @CRLF
			Case 36
				$Output &= "- LS-120 boot est prise en charge (36)" & @CRLF
			Case 37
				$Output &= "- ATAPI lecteur ZIP boot est pris en charge (37)" & @CRLF
			Case 38
				$Output &= "- 1394 boot est pris en charge (38)" & @CRLF
			Case 39
				$Output &= "- Smart Battery prise en charge (39)" & @CRLF
			Case 40 To 47
				$Output &= "- Réservé aux fournisseurs de BIOS (40 - 47)" & @CRLF
			Case 48 To 63
				$Output &= "- Réservé aux fournisseurs Système (48 - 63)" & @CRLF
		EndSwitch
	Next
EndFunc   ;==>_BIOSARCH
Ce qui nous donne un résultat plus en détail avec une sélection désirée.
Cela peut-être modifié selon les besoins.

Image

Si cela intéresse certains j'avais commencé un UDF sur des requêtes matériels en utilisant ScriptOMatic avec le détail de certaines propriétés de ces requêtes comme cette exemple du BIOS. En français et/ou en Anglais selon OS.


Win32_OperatingSystem class
Image _OperatingSystem()
Image

Win32_BIOS class
Image _BIOS()
Image

Win32_BaseBoard class
Image _BaseBoard()
Image

Win32_Processor class
Image _Processor()
Image

Win32_PhysicalMemory class
Image _PhysicalMemory()
Image

Win32_VideoController class
Image _VideoController()
Image

Classes matériel



Les services :

Nous allons maintenant utiliser WMI pour obtenir des informations sur les services et voir comment nous pouvons agir dessus.
Pour cela nous allons utiliser la classe Win32_Service

Pour exemple je vais prendre le service du pare-feu windows (MpsSvc).

Local $strComputer = 'localhost'

Local $Service = ObjGet("winmgmts:\\" & $strComputer & "\root\cimv2")
Local $sQuery = "Select * from Win32_Service where name like '" & "MpsSvc" & "'"
Local $sItems = $Service.ExecQuery($sQuery)

For $objItem In $sItems
MsgBox(0, "Pare-feu Windows", $objItem.State)
Next

Image

On peut aussi l'écrire comme ceci via une fonction :

MsgBox(0,"", _Service_State('MpsSvc'))

Func _Service_State($sServiceName, $Computer = "localhost")
Local $Service = ObjGet("winmgmts:\\" & $Computer & "\root\cimv2")
Local $sQuery = "Select * from Win32_Service where name like '"& $sServiceName &"'"
Local $sItems = $Service.ExecQuery ($sQuery)
For $objItem In $sItems
Return $objItem.State
Next
Return SetError(-1)
EndFunc

$objItem.State va nous permettre de récupérer le statut du service :
Stopped ("Stopped")
Start Pending ("Start Pending")
Stop Pending ("Stop Pending")
Running ("Running")
Continue Pending ("Continue Pending")
Pause Pending ("Pause Pending")
Paused ("Paused")
Unknown ("Unknown")
Nous pouvons traduire ce résultat pour afficher la valeur retournée en Français en utilisant la même méthode que pour les requête matériels.

Maintenant si nous décidons d'agir sur notre service MpsSvc. Pour l'exemple on va le stopper, vérifier son état et le redémarrer.
Il nous faut donc trois fonctions avec l'accès au droit administrateur :

#RequireAdmin
AutoIt Help" a écrit :Cette fonction spécifie que le script en cours exige les droits d'administrateur complets pour fonctionner, elle a été principalement destinée au bon fonctionnement des scripts AutoIt avec le Contrôle de Compte d'Utilisateur (UAC) de Windows Vista (Cependant, il fonctionnera aussi sur Windows 2000 et Windows XP).

Code : Tout sélectionner

#RequireAdmin

_Serv_Stop('MpsSvc')
Sleep(1000)
MsgBox(0, "Services", _Serv_Verif_Start('MpsSvc'))

_Serv_Start('MpsSvc')
Sleep(2000)
MsgBox(0, "Services", _Serv_Verif_Start('MpsSvc'))

Func _Serv_Stop($sServiceName, $Computer = "localhost")
	Local $sQuery = "Select * from Win32_Service Where State = 'Running' And " & _
			"name like '" & $sServiceName & "'"
	Local $Service = ObjGet("winmgmts:\\" & $Computer & "\root\cimv2")
	Local $sItems = $Service.ExecQuery($sQuery)
	For $objService In $sItems
		If Not $objService.AcceptStop Then Return SetError(-2)
		$objService.StopService($objService.Name)
		ProcessWaitClose($objService.ProcessID)
		Return
	Next
	Return SetError(-1)
EndFunc   ;==>_Serv_Stop

Func _Serv_Verif_Start($sServiceName, $Computer = "localhost")
	Local $sQuery = "Select * from Win32_Service Where State = 'Running' AND name like '" & $sServiceName & "'"
	Local $Service = ObjGet("winmgmts:" _
			 & "{impersonationLevel=impersonate}!\\" & $Computer & "\root\cimv2")
	Local $sItem = $Service.ExecQuery($sQuery)
	For $ObjService In $sItem
		Return "Le service " & $sServiceName & " du Pare-Feu Windows est démarré"
	Next
	Return "Le service " & $sServiceName & " du Pare-Feu Windows est arrêté"
EndFunc   ;==>_Serv_Verif_Start

Func _Serv_Start($sServiceName, $Computer = "localhost")
	Local $Service = ObjGet("winmgmts:\\" & $Computer & "\root\cimv2")
	Local $sQuery = "Select * from Win32_Service Where State = 'Stopped' And " & _
			"name like '" & $sServiceName & "'"
	Local $sItems = $Service.ExecQuery($sQuery)
	For $objService In $sItems
		$objService.StartService($objService.Name)
		Return
	Next
	Return SetError(-1)
EndFunc   ;==>_Serv_Start
Image

Image


Il existe un UDF pour pouvoir manipuler les services, voir ce lien . Pas d'utilisation de WMI dans l'UDF, mais il est vraiment complet et peut être très utile. :D

Si maintenant nous voulons quelques infos sur notre service MpsSvc.

Code : Tout sélectionner

_Serv_Stat('MpsSvc')

Func _Serv_Stat($sServiceName, $Computer = "localhost")
	Local $Service = ObjGet("winmgmts:\\" & $Computer & "\root\cimv2")
	Local $sQuery = "Select * from Win32_Service Where name = 'MpsSvc'" ;, "WQL", 0x10 + 0x20
	Local $sItems = $Service.ExecQuery($sQuery)
	Local $Output = ""
	If IsObj($sItems) Then
		For $objItem In $sItems
			$Output = $Output & "Nom du service : " & $objItem.Name & @CRLF
			$Output = $Output & "Nom complet : " & $objItem.Caption & @CRLF
			$Output = $Output & "Description : " & $objItem.Description & @CRLF
			$Output = $Output & "===================== " & @CRLF
			$Output = $Output & "Type de service : " & $objItem.ServiceType & @CRLF
			$Output = $Output & "Chemin vers le fichier binaire  : " & $objItem.PathName & @CRLF
			$Output = $Output & "Nom du compte : " & $objItem.StartName & @CRLF
			$Output = $Output & "ProcessId: " & $objItem.ProcessId & @CRLF
			$Output = $Output & "===================== " & @CRLF
			$Output = $Output & "A démarré : " & $objItem.Started & @CRLF
			$Output = $Output & "Mode de démarrage : " & $objItem.StartMode & @CRLF
			$Output = $Output & "Etat : " & $objItem.State & @CRLF
			$Output = $Output & "statut : " & $objItem.Status & @CRLF
			$Output = $Output & "AcceptPause :  Indique si le service peut être interrompu  - " & $objItem.AcceptPause & @CRLF
			$Output = $Output & "AcceptStop :   Indique si le service peut être arrêté  - " & $objItem.AcceptStop & @CRLF
			If MsgBox(1, "WMI - Win32_Service", $Output) = 2 Then ExitLoop
			$Output = ""
			Exit
		Next
	Else
		MsgBox(0, "WMI Output", "Aucun des objets WMI trouvés pour la classe Win32_Service")
	EndIf
EndFunc   ;==>_Serv_Stat

Image

Répondre