Continue code

ddurieux · ddurieux · commit 202b025c1511 · 2022-08-06T11:20:21.000+02:00
diff --git a/lib/FusionInventory/Agent/Task/Inventory/Win32/AntiVirus.pm b/lib/FusionInventory/Agent/Task/Inventory/Win32/AntiVirus.pm
@@ -461,31 +461,26 @@ sub _setNortonInfos {
 sub _getSoftwareRegistryKeys {
     my ($base, $values, $callback) = @_;
 
-    my $reg;
+    my %reg;
     if (is64bit()) {
-        $reg = getRegistryKey(
-            path => 'HKEY_LOCAL_MACHINE/SOFTWARE/Wow6432Node/'.$base,
-            wmiopts => { # Only used for remote WMI optimization
-                values  => $values
-            }
+        my %reg = getNewRegistryValues(
+            root   => "HKEY_LOCAL_MACHINE",
+            path   => 'SOFTWARE/Wow6432Node/'.$base
         );
-        if ($reg) {
+        if (%reg) {
             if ($callback) {
-                my $filter = &{$callback}($reg);
+                my $filter = &{$callback}(%reg);
                 return $filter if $filter;
             } else {
-                return $reg;
+                return %reg;
             }
         }
     }
-
-    $reg = getRegistryKey(
-        path => 'HKEY_LOCAL_MACHINE/SOFTWARE/'.$base,
-        wmiopts => { # Only used for remote WMI optimization
-            values  => $values
-        }
+    my %reg = getNewRegistryValues(
+        root   => "HKEY_LOCAL_MACHINE",
+        path   => 'SOFTWARE/'.$base
     );
-    return ($callback && $reg) ? &{$callback}($reg) : $reg;
+    return ($callback && %reg) ? &{$callback}(%reg) : %reg;
 }
 
 1;
diff --git a/lib/FusionInventory/Agent/Task/Inventory/Win32/CPU.pm b/lib/FusionInventory/Agent/Task/Inventory/Win32/CPU.pm
@@ -53,12 +53,11 @@ sub _getCPUs {
     my @dmidecodeInfos = $remotewmi || Win32::GetOSName() eq 'Win2003' ?
         () : getCpusFromDmidecode();
 
-    # the CPU description in WMI is false, we use the registry instead
-    my $registryInfos = getRegistryKey(
-        path   => "HKEY_LOCAL_MACHINE/Hardware/Description/System/CentralProcessor",
-        wmiopts => { # Only used for remote WMI optimization
-            values  => [ qw/Identifier ProcessorNameString VendorIdentifier/ ]
-        }
+    my %registryInfos = getNewRegistryAll(
+        logger => $params{logger},
+        root   => "HKEY_LOCAL_MACHINE",
+        path   => "Hardware/Description/System/CentralProcessor",
+        %params
     );
 
     my $cpuId = 0;
@@ -77,26 +76,26 @@ sub _getCPUs {
     )) {
 
         my $dmidecodeInfo = $dmidecodeInfos[$cpuId];
-        my $registryInfo  = $registryInfos->{"$logicalId/"};
+        my $registryInfo  = $registryInfos{"$logicalId"};
 
         # Compute WMI threads for this CPU if not available in dmidecode, this is the case on win2003r2 with 932370 hotfix applied (see #2894)
         my $wmi_threads   = !$dmidecodeInfo->{THREAD} && $object->{NumberOfCores} ? $object->{NumberOfLogicalProcessors}/$object->{NumberOfCores} : undef;
 
         # Split CPUID from its value inside registry
-        my @splitted_identifier = split(/ |\n/, $registryInfo->{'/Identifier'} || $object->{Description});
+        my @splitted_identifier = split(/ |\n/, $registryInfo->{Identifier} || $object->{Description});
 
         my $name = $dmidecodeInfo->{NAME};
         unless ($name) {
-            $name = trimWhitespace($registryInfo->{'/ProcessorNameString'} || $object->{Name});
+            $name = trimWhitespace($registryInfo->{ProcessorNameString} || $object->{Name});
             $name =~ s/\((R|TM)\)//gi if $name;
         }
 
         my $cpu = {
             CORE         => $dmidecodeInfo->{CORE} || $object->{NumberOfCores},
             THREAD       => $dmidecodeInfo->{THREAD} || $wmi_threads,
-            DESCRIPTION  => $dmidecodeInfo->{DESCRIPTION} || $registryInfo->{'/Identifier'} || $object->{Description},
+            DESCRIPTION  => $dmidecodeInfo->{DESCRIPTION} || $registryInfo->{Identifier} || $object->{Description},
             NAME         => $name,
-            MANUFACTURER => $dmidecodeInfo->{MANUFACTURER} || getCanonicalManufacturer($registryInfo->{'/VendorIdentifier'} || $object->{Manufacturer}),
+            MANUFACTURER => $dmidecodeInfo->{MANUFACTURER} || getCanonicalManufacturer($registryInfo->{VendorIdentifier} || $object->{Manufacturer}),
             SERIAL       => $dmidecodeInfo->{SERIAL} || $object->{SerialNumber},
             SPEED        => $dmidecodeInfo->{SPEED} || $object->{MaxClockSpeed},
             FAMILYNUMBER => $dmidecodeInfo->{FAMILYNUMBER} || $splitted_identifier[2],
diff --git a/lib/FusionInventory/Agent/Task/Inventory/Win32/License.pm b/lib/FusionInventory/Agent/Task/Inventory/Win32/License.pm
@@ -36,18 +36,26 @@ sub doInventory {
 
     my @licenses;
 
-    my $officeKey = getRegistryKey(
-        path => "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Office"
+    my %officeKey = getNewRegistryAll(
+        logger => $params{logger},
+        root   => "HKEY_LOCAL_MACHINE",
+        path   => "SOFTWARE/Microsoft/Office",
+        %params
     );
-    _scanOfficeLicences($officeKey) if $officeKey;
+
+    _scanOfficeLicences(%officeKey) if %officeKey;
 
     my $fileAdobe = 'C:\Program Files\Common Files\Adobe\Adobe PCD\cache\cache.db';
     if (is64bit()) {
         $fileAdobe = 'C:\Program Files (x86)\Common Files\Adobe\Adobe PCD\cache\cache.db';
-        my $officeKey32 = getRegistryKey(
-            path => "HKEY_LOCAL_MACHINE/SOFTWARE/Wow6432Node/Microsoft/Office"
+        my %officeKey32 = getNewRegistryAll(
+            logger => $params{logger},
+            root   => "HKEY_LOCAL_MACHINE",
+            path   => "SOFTWARE/Wow6432Node/Microsoft/Office",
+            %params
         );
-        _scanOfficeLicences($officeKey32) if $officeKey32;
+
+        _scanOfficeLicences(%officeKey32) if %officeKey32;
     }
 
     push @licenses, getAdobeLicensesWithoutSqlite($fileAdobe) if (-e $fileAdobe);
@@ -128,7 +136,7 @@ sub _scanOfficeLicences {
     #             └── ...
 
     foreach my $versionKey (keys %{$key}) {
-        my $registrationKey = $key->{$versionKey}->{'Registration/'};
+        my $registrationKey = $key{$versionKey}->{Registration};
         next unless $registrationKey;
 
         foreach my $uuidKey (keys %{$registrationKey}) {
diff --git a/lib/FusionInventory/Agent/Task/Inventory/Win32/Networks.pm b/lib/FusionInventory/Agent/Task/Inventory/Win32/Networks.pm
@@ -27,7 +27,7 @@ sub doInventory {
     my $inventory = $params{inventory};
     my (@gateways, @dns, @ips);
 
-    my $keys;
+    my %keys;
 
     foreach my $interface (getInterfaces()) {
         push @gateways, $interface->{IPGATEWAY}
@@ -44,14 +44,13 @@ sub doInventory {
         delete $interface->{GUID};
 
         # Don't reload registry keys between interfaces checks
-        $keys = getRegistryKey(
-            path   => "HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Control/Network/{4D36E972-E325-11CE-BFC1-08002BE10318}",
-            wmiopts => { # Only used for remote WMI optimization
-                values  => [ qw/PnpInstanceID MediaSubType/ ]
-            }
-        ) unless $keys;
+        %keys = getNewRegistryAll(
+            logger => $params{logger},
+            root   => "HKEY_LOCAL_MACHINE", 
+            path   => "SYSTEM/CurrentControlSet/Control/Network/{4D36E972-E325-11CE-BFC1-08002BE10318}",
+        ) unless %keys;
 
-        $interface->{TYPE} = _getMediaType($interface->{PNPDEVICEID}, $keys);
+        $interface->{TYPE} = _getMediaType($interface->{PNPDEVICEID}, %keys);
 
         $inventory->addEntry(
             section => 'NETWORKS',
@@ -68,23 +67,23 @@ sub doInventory {
 }
 
 sub _getMediaType {
-    my ($deviceid, $keys) = @_;
+    my ($deviceid, %keys) = @_;
 
-    return unless defined $deviceid && $keys;
+    return unless defined $deviceid && %keys;
 
     my $subtype;
 
-    foreach my $subkey_name (keys %{$keys}) {
+    foreach my $subkey_name (keys %keys) {
         # skip variables
         next if $subkey_name =~ m{^/};
-        my $subkey_connection = $keys->{$subkey_name}->{'Connection/'}
+        my $subkey_connection = $keys{$subkey_name}->{Connection}
             or next;
-        my $subkey_deviceid   = $subkey_connection->{'/PnpInstanceID'}
+        my $subkey_deviceid   = $subkey_connection->{PnpInstanceID}
             or next;
         # Normalize PnpInstanceID
         $subkey_deviceid =~ s/\\\\/\\/g;
         if (lc($subkey_deviceid) eq lc($deviceid)) {
-            $subtype = $subkey_connection->{'/MediaSubType'};
+            $subtype = $subkey_connection->{MediaSubType};
             last;
         }
     }
diff --git a/lib/FusionInventory/Agent/Task/Inventory/Win32/Softwares.pm b/lib/FusionInventory/Agent/Task/Inventory/Win32/Softwares.pm
@@ -15,6 +15,7 @@ use FusionInventory::Agent::Tools;
 use FusionInventory::Agent::Tools::Win32;
 use FusionInventory::Agent::Tools::Win32::Constants;
 use FusionInventory::Agent::Tools::Win32::LoadIndirectString;
+use Data::Dumper;
 
 our $runAfter = ["FusionInventory::Agent::Task::Inventory::Win32::OS"];
 
@@ -66,7 +67,7 @@ sub doInventory {
 
     if ($is64bit) {
         my $softwares32 = _getSoftwaresList(
-            path    => "HKEY_LOCAL_MACHINE/SOFTWARE/Wow6432Node/Microsoft/Windows/CurrentVersion/Uninstall",
+            path    => "SOFTWARE/Wow6432Node/Microsoft/Windows/CurrentVersion/Uninstall",
             is64bit => 0
         ) || [];
         foreach my $software (@$softwares32) {
@@ -120,12 +121,13 @@ sub _loadUserSoftware {
         my $userName = $userList->{$profileName}
             or next;
 
-        my $profileSoft = "HKEY_USERS/$profileName/SOFTWARE/";
+        my $profileSoft = "$profileName/SOFTWARE/";
         $profileSoft .= is64bit() && !$is64bit ?
                 "Wow6432Node/Microsoft/Windows/CurrentVersion/Uninstall" :
                 "Microsoft/Windows/CurrentVersion/Uninstall";
 
         my $softwares = _getSoftwaresList(
+            root      => "HKEY_USERS",
             path      => $profileSoft,
             is64bit   => $is64bit,
             userid    => $profileName,
@@ -143,22 +145,22 @@ sub _loadUserSoftware {
 sub _getUsersFromRegistry {
     my (%params) = @_;
 
-    my $profileList = getRegistryKey(
-        path => 'HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows NT/CurrentVersion/ProfileList',
-        wmiopts => { # Only used for remote WMI optimization
-            values  => [ qw/ProfileImagePath Sid/ ],
-        }
+    my %profileList = getNewRegistryAll(
+        logger => $params{logger},
+        root   => "HKEY_LOCAL_MACHINE",
+        path   => "SOFTWARE/Microsoft/Windows NT/CurrentVersion/ProfileList",
+        %params
     );
 
-    next unless $profileList;
+    return unless %profileList;
 
     my $userList;
-    foreach my $profileName (keys %$profileList) {
+    foreach my $profileName (keys %profileList) {
         next unless $profileName =~ m{/$};
         next unless length($profileName) > 10;
 
-        my $profilePath = $profileList->{$profileName}{'/ProfileImagePath'};
-        my $sid = $profileList->{$profileName}{'/Sid'};
+        my $profilePath = $profileList{$profileName}->{ProfileImagePath};
+        my $sid = $profileList{$profileName}->{Sid};
         next unless $sid;
         next unless $profilePath;
         my $user = basename($profilePath);
@@ -196,9 +198,7 @@ sub _keyLastWriteDateString {
 
     return unless ($OSNAME eq 'MSWin32');
 
-    return unless (ref($key) eq "Win32::TieRegistry");
-
-    my @lastWrite = FileTimeToSystemTime($key->Information("LastWrite"));
+    my @lastWrite = FileTimeToSystemTime($key->{_lastWrite});
 
     return unless (@lastWrite > 3);
 
@@ -208,53 +208,52 @@ sub _keyLastWriteDateString {
 sub _getSoftwaresList {
     my (%params) = @_;
 
-    my $softwares = getRegistryKey(
-        path    => "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows/CurrentVersion/Uninstall",
-        wmiopts => { # Only used for remote WMI optimization
-            values  => [ qw/
-                DisplayName Comments HelpLink ReleaseType DisplayVersion
-                Publisher URLInfoAbout UninstallString InstallDate MinorVersion
-                MajorVersion NoRemove SystemComponent
-                / ]
-        },
+    my $path = "SOFTWARE/Microsoft/Windows/CurrentVersion/Uninstall";
+    my $root = "HKEY_LOCAL_MACHINE";
+    if (defined $params{path}) {
+        $path = $params{path};
+    }
+    if (defined $params{root}) {
+        $root = $params{root};
+    }
+
+    my %softwares = getNewRegistryAll(
+        logger => $params{logger},
+        root   => $root,
+        path   => $path,
         %params
     );
+    return unless %softwares;
 
     my @list;
 
-    return unless $softwares;
-
-    foreach my $rawGuid (keys %$softwares) {
+    foreach my $rawGuid (keys %softwares) {
         # skip variables
         next if $rawGuid =~ m{^/};
 
         # only keep subkeys with more than 1 value
-        my $data = $softwares->{$rawGuid};
+        my $data = $softwares{$rawGuid};
         next unless keys %$data > 1;
 
-        my $guid = $rawGuid;
-        $guid =~ s/\/$//; # drop the tailing /
-
         my $software = {
             FROM             => "registry",
-            NAME             => encodeFromRegistry($data->{'/DisplayName'}) ||
-                                encodeFromRegistry($guid), # folder name
-            COMMENTS         => encodeFromRegistry($data->{'/Comments'}),
-            HELPLINK         => encodeFromRegistry($data->{'/HelpLink'}),
-            RELEASE_TYPE     => encodeFromRegistry($data->{'/ReleaseType'}),
-            VERSION          => encodeFromRegistry($data->{'/DisplayVersion'}),
-            PUBLISHER        => encodeFromRegistry($data->{'/Publisher'}),
-            URL_INFO_ABOUT   => encodeFromRegistry($data->{'/URLInfoAbout'}),
-            UNINSTALL_STRING => encodeFromRegistry($data->{'/UninstallString'}),
-            INSTALLDATE      => _dateFormat($data->{'/InstallDate'}),
-            VERSION_MINOR    => hex2dec($data->{'/MinorVersion'}),
-            VERSION_MAJOR    => hex2dec($data->{'/MajorVersion'}),
-            NO_REMOVE        => hex2dec($data->{'/NoRemove'}),
+            NAME             => $data->{DisplayName} || $rawGuid, # folder name
+            COMMENTS         => $data->{Comments},
+            HELPLINK         => $data->{HelpLink},
+            RELEASE_TYPE     => $data->{ReleaseType},
+            VERSION          => $data->{DisplayVersion},
+            PUBLISHER        => $data->{Publisher},
+            URL_INFO_ABOUT   => $data->{URLInfoAbout},
+            UNINSTALL_STRING => $data->{UninstallString},
+            INSTALLDATE      => _dateFormat($data->{InstallDate}),
+            VERSION_MINOR    => $data->{MinorVersion},
+            VERSION_MAJOR    => $data->{MajorVersion},
+            NO_REMOVE        => $data->{NoRemove},
             ARCH             => $params{is64bit} ? 'x86_64' : 'i586',
-            GUID             => $guid,
+            GUID             => $rawGuid,
             USERNAME         => $params{username},
             USERID           => $params{userid},
-            SYSTEM_CATEGORY  => $data->{'/SystemComponent'} && hex2dec($data->{'/SystemComponent'}) ?
+            SYSTEM_CATEGORY  => $data->{SystemComponent} ?
                 CATEGORY_SYSTEM_COMPONENT : CATEGORY_APPLICATION
         };
 
@@ -347,17 +346,17 @@ sub _processMSIE {
         "Internet Explorer (64bit)" : "Internet Explorer";
 
     # Will use key last write date as INSTALLDATE
-    my $installedkey = getRegistryKey(
+    my %installedkey = getNewRegistryValues(
+        logger => $params{logger},
+        root   => "HKEY_LOCAL_MACHINE",
         path   => is64bit() && !$params{is64bit} ?
-            "HKEY_LOCAL_MACHINE/SOFTWARE/Wow6432Node/Microsoft/Internet Explorer" :
-            "HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Internet Explorer",
-        wmiopts => { # Only used for remote WMI optimization
-            values  => [ qw/svcVersion Version/ ],
-            subkeys => 0
-        }
+            "SOFTWARE/Wow6432Node/Microsoft/Internet Explorer" :
+            "SOFTWARE/Microsoft/Internet Explorer",
+        %params
     );
 
-    my $version = $installedkey->{"/svcVersion"} || $installedkey->{"/Version"};
+
+    my $version = $installedkey{svcVersion} || $installedkey{Version};
 
     return unless $version; # Not installed
 
@@ -368,8 +367,8 @@ sub _processMSIE {
             ARCH        => $params{is64bit} ? 'x86_64' : 'i586',
             NAME        => $name,
             VERSION     => $version,
-            PUBLISHER   => "Microsoft Corporation",
-            INSTALLDATE => _dateFormat(_keyLastWriteDateString($installedkey))
+            PUBLISHER   => "Microsoft Corporation"
+            # INSTALLDATE => _dateFormat(_keyLastWriteDateString(%installedkey))
         }
     );
 
diff --git a/lib/FusionInventory/Agent/Tools/Win32.pm b/lib/FusionInventory/Agent/Tools/Win32.pm
