facter 4.0.28

data/lib/resolvers/windows/ffi/os_version_info_ex.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class OsVersionInfoEx < FFI::Struct
+  layout(
+    :dwOSVersionInfoSize, :win32_ulong,
+    :dwMajorVersion, :win32_ulong,
+    :dwMinorVersion, :win32_ulong,
+    :dwBuildNumber, :win32_ulong,
+    :dwPlatformId, :win32_ulong,
+    :szCSDVersion, [:wchar, 128],
+    :wServicePackMajor, :ushort,
+    :wServicePackMinor, :ushort,
+    :wSuiteMask, :ushort,
+    :wProductType, :uchar,
+    :wReserved, :uchar
+  )
+end

data/lib/resolvers/windows/ffi/performance_information.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class PerformanceInformation < FFI::Struct
+  layout(
+    :cb, :dword,
+    :CommitTotal, :size_t,
+    :CommitLimit, :size_t,
+    :CommitPeak, :size_t,
+    :PhysicalTotal, :size_t,
+    :PhysicalAvailable, :size_t,
+    :SystemCache, :size_t,
+    :KernelTotal, :size_t,
+    :KernelPaged, :size_t,
+    :KernelNonpaged, :size_t,
+    :PageSize, :size_t,
+    :HandleCount, :dword,
+    :ProcessCount, :dword,
+    :ThreadCount, :dword
+  )
+end

data/lib/resolvers/windows/ffi/system32_ffi.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{ROOT_DIR}/lib/resolvers/windows/ffi/ffi"
+
+module System32FFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :IsWow64Process, %i[handle pointer], :win32_bool
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetCurrentProcess, [], :handle
+
+  CSIDL_WINDOWS = 0x0024
+  H_OK = 0
+end

data/lib/resolvers/windows/ffi/system_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class DummyStructName < FFI::Struct
+  layout(
+    :wProcessorArchitecture, :word,
+    :wReserved, :word
+  )
+end
+
+class DummyUnionName < FFI::Union
+  layout(
+    :dwOemId, :dword,
+    :dummystructname, DummyStructName
+  )
+end
+
+class SystemInfo < FFI::Struct
+  layout(
+    :dummyunionname, DummyUnionName,
+    :dwPageSize, :dword,
+    :lpMinimumApplicationAddress, :pointer,
+    :lpMaximumApplicationAddress, :pointer,
+    :dwActiveProcessorMask, :pdword,
+    :dwNumberOfProcessors, :dword,
+    :dwProcessorType, :dword,
+    :dwAllocationGranularity, :dword,
+    :wProcessorLevel, :word,
+    :wProcessorRevision, :word
+  )
+end

data/lib/resolvers/windows/fips_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    module Windows
+      class Fips < BaseResolver
+        # :fips_enabled
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_fact_from_registry(fact_name) }
+          end
+
+          def read_fact_from_registry(fact_name)
+            reg = ::Win32::Registry::HKEY_LOCAL_MACHINE
+                  .open('System\\CurrentControlSet\\Control\\Lsa\\FipsAlgorithmPolicy')
+            @fact_list[:fips_enabled] = reg['Enabled'] != 0 if reg.any? { |name, _value| name == 'Enabled' }
+            reg.close
+
+            @fact_list[:fips_enabled] ||= false
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/hardware_architecture_resolver.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class HardwareArchitecture < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_hardware_information(fact_name) }
+        end
+
+        def read_hardware_information(fact_name)
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/hardware_ffi"
+
+          sys_info_ptr = FFI::MemoryPointer.new(SystemInfo.size)
+          HardwareFFI::GetNativeSystemInfo(sys_info_ptr)
+          sys_info = SystemInfo.new(sys_info_ptr)
+
+          hard = determine_hardware(sys_info)
+          arch = determine_architecture(hard)
+          build_facts_list(hardware: hard, architecture: arch)
+          @fact_list[fact_name]
+        end
+
+        def determine_hardware(sys_info)
+          union = sys_info[:dummyunionname]
+          struct = union[:dummystructname]
+          case struct[:wProcessorArchitecture]
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_AMD64
+            'x86_64'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_ARM
+            'arm'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_IA64
+            'ia64'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_INTEL
+            family = sys_info[:wProcessorLevel] > 5 ? 6 : sys_info[:wProcessorLevel]
+            "i#{family}86"
+          else
+            'unknown'
+          end
+        end
+
+        def determine_architecture(hardware)
+          case hardware
+          when /i[3456]86/
+            'x86'
+          when 'x86_64'
+            'x64'
+          else
+            hardware
+          end
+        end
+
+        def build_facts_list(facts)
+          @fact_list[:hardware] = facts[:hardware]
+          @fact_list[:architecture] = facts[:architecture]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/identity_resolver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Identity < BaseResolver
+      NAME_SAM_COMPATIBLE = 2
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def find_username
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/identity_ffi"
+
+          size_ptr = FFI::MemoryPointer.new(:win32_ulong, 1)
+          IdentityFFI::GetUserNameExW(NAME_SAM_COMPATIBLE, FFI::Pointer::NULL, size_ptr)
+          if FFI.errno != ERROR_MORE_DATA
+            @log.debug "failure resolving identity facts: #{FFI.errno}"
+            return
+          end
+
+          name_ptr = FFI::MemoryPointer.new(:wchar, size_ptr.read_uint32)
+          if IdentityFFI::GetUserNameExW(NAME_SAM_COMPATIBLE, name_ptr, size_ptr) == FFI::WIN32FALSE
+            @log.debug "failure resolving identity facts: #{FFI.errno}"
+            return
+          end
+
+          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: privileged? }
+        end
+
+        def privileged?
+          result = IdentityFFI::IsUserAnAdmin()
+          result && result != FFI::WIN32FALSE
+        end
+
+        def retrieve_facts(fact_name)
+          result = find_username
+          return unless result
+
+          build_fact_list(result)
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(facts)
+          @fact_list[:user] = facts[:user]
+          @fact_list[:privileged] = facts[:privileged]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/kernel_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Kernel < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_os_version_information(fact_name) }
+        end
+
+        def read_os_version_information(fact_name)
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/kernel_ffi"
+
+          ver_ptr = FFI::MemoryPointer.new(OsVersionInfoEx.size)
+          ver = OsVersionInfoEx.new(ver_ptr)
+          ver[:dwOSVersionInfoSize] = OsVersionInfoEx.size
+
+          if KernelFFI::RtlGetVersion(ver_ptr) != KernelFFI::STATUS_SUCCESS
+            @log.debug 'Calling Windows RtlGetVersion failed'
+            return
+          end
+
+          result = { major: ver[:dwMajorVersion], minor: ver[:dwMinorVersion], build: ver[:dwBuildNumber] }
+          build_facts_list(result)
+
+          @fact_list[fact_name]
+        end
+
+        def build_facts_list(result)
+          @fact_list[:kernelversion] = "#{result[:major]}.#{result[:minor]}.#{result[:build]}"
+          @fact_list[:kernelmajorversion] = "#{result[:major]}.#{result[:minor]}"
+          @fact_list[:kernel] = 'windows'
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/memory_resolver.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Memory < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { validate_info(fact_name) }
+        end
+
+        def read_performance_information
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/memory_ffi"
+
+          state_ptr = FFI::MemoryPointer.new(PerformanceInformation.size)
+          if MemoryFFI::GetPerformanceInfo(state_ptr, state_ptr.size) == FFI::WIN32FALSE
+            @log.debug 'Resolving memory facts failed'
+            return
+          end
+
+          PerformanceInformation.new(state_ptr)
+        end
+
+        def calculate_memory
+          state = read_performance_information
+          return unless state
+
+          total_bytes = state[:PhysicalTotal] * state[:PageSize]
+          available_bytes = state[:PhysicalAvailable] * state[:PageSize]
+          if total_bytes.zero? || available_bytes.zero?
+            @log.debug 'Available or Total bytes are zero could not proceed further'
+            return
+          end
+
+          { total_bytes: total_bytes, available_bytes: available_bytes, used_bytes: total_bytes - available_bytes }
+        end
+
+        def validate_info(fact_name)
+          result = calculate_memory
+          return unless result
+
+          build_facts_list(result)
+          @fact_list[fact_name]
+        end
+
+        def build_facts_list(result)
+          @fact_list[:total_bytes] = result[:total_bytes]
+          @fact_list[:available_bytes] = result[:available_bytes]
+          @fact_list[:used_bytes] = result[:used_bytes]
+          @fact_list[:capacity] = format('%<capacity>.2f',
+                                         capacity: (result[:used_bytes] / result[:total_bytes].to_f * 100)) + '%'
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/netkvm_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    class NetKVM < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_registry(fact_name) }
+        end
+
+        def read_fact_from_registry(fact_name)
+          reg = ::Win32::Registry::HKEY_LOCAL_MACHINE.open('SYSTEM\\CurrentControlSet\\Services')
+          build_fact_list(reg)
+          reg.close
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(reg)
+          # rubocop:disable Performance/InefficientHashSearch
+          @fact_list[:kvm] = reg.keys.include?('netkvm')
+          # rubocop:enable Performance/InefficientHashSearch
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/networking_resolver.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Resolvers
+    class Networking < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_network_information(fact_name) }
+        end
+
+        def read_network_information(fact_name)
+          require "#{ROOT_DIR}/lib/resolvers/windows/ffi/networking_ffi"
+
+          size_ptr = FFI::MemoryPointer.new(NetworkingFFI::BUFFER_LENGTH)
+          adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+          flags = NetworkingFFI::GAA_FLAG_SKIP_ANYCAST |
+                  NetworkingFFI::GAA_FLAG_SKIP_MULTICAST | NetworkingFFI::GAA_FLAG_SKIP_DNS_SERVER
+
+          return unless (adapter_addresses = get_adapter_addresses(size_ptr, adapter_addresses, flags))
+
+          iterate_list(adapter_addresses)
+          set_interfaces_other_facts if @fact_list[:interfaces]
+          @fact_list[:primary_interface] = @fact_list[:primary_interface].to_s
+          @fact_list[fact_name]
+        end
+
+        def get_adapter_addresses(size_ptr, adapter_addresses, flags)
+          error = nil
+          3.times do
+            error = NetworkingFFI::GetAdaptersAddresses(NetworkingFFI::AF_UNSPEC, flags,
+                                                        FFI::Pointer::NULL, adapter_addresses, size_ptr)
+            break if error == NetworkingFFI::ERROR_SUCCES
+
+            if error == NetworkingFFI::ERROR_BUFFER_OVERFLOW
+              adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+            else
+              @log.debug 'Unable to retrieve networking facts!'
+              return nil
+            end
+          end
+          return nil unless error.zero?
+
+          adapter_addresses
+        end
+
+        def adapter_down?(adapter)
+          adapter[:OperStatus] != NetworkingFFI::IF_OPER_STATUS_UP ||
+            ![NetworkingFFI::IF_TYPE_ETHERNET_CSMACD, NetworkingFFI::IF_TYPE_IEEE80211].include?(adapter[:IfType])
+        end
+
+        def retrieve_dhcp_server(adapter)
+          if !(adapter[:Flags] & NetworkingFFI::IP_ADAPTER_DHCP_ENABLED).zero? &&
+             adapter[:Union][:Struct][:Length] >= IpAdapterAddressesLh.size
+            NetworkUtils.address_to_string(adapter[:Dhcpv4Server])
+          end
+        end
+
+        def iterate_list(adapter_addresses)
+          net_interface = {}
+          IpAdapterAddressesLh.read_list(adapter_addresses) do |adapter_address|
+            if adapter_down?(adapter_address)
+              adapter_address = IpAdapterAddressesLh.new(adapter_address[:Next])
+              next
+            end
+            @fact_list[:domain] ||= adapter_address[:DnsSuffix].read_wide_string_without_length
+            name = adapter_address[:FriendlyName].read_wide_string_without_length.to_sym
+            net_interface[name] = build_interface_info(adapter_address, name)
+          end
+
+          @fact_list[:interfaces] = net_interface unless net_interface.empty?
+        end
+
+        def build_interface_info(adapter_address, name)
+          hash = {}
+
+          hash[:dhcp] = retrieve_dhcp_server(adapter_address)
+          hash[:mtu] = adapter_address[:Mtu]
+
+          bindings = find_ip_addresses(adapter_address[:FirstUnicastAddress], name)
+          hash[:bindings] = bindings[:ipv4] unless bindings[:ipv4].empty?
+          hash[:bindings6] = bindings[:ipv6] unless bindings[:ipv6].empty?
+          hash[:mac] = NetworkUtils.find_mac_address(adapter_address)
+          hash
+        end
+
+        def find_ip_addresses(unicast_addresses, name)
+          bindings = {}
+          bindings[:ipv6] = []
+          bindings[:ipv4] = []
+
+          IpAdapterUnicastAddressLH.read_list(unicast_addresses) do |unicast|
+            addr = NetworkUtils.address_to_string(unicast[:Address])
+            unless addr
+              unicast = IpAdapterUnicastAddressLH.new(unicast[:Next])
+              next
+            end
+
+            sock_addr = SockAddr.new(unicast[:Address][:lpSockaddr])
+            add_ip_data(addr, unicast, sock_addr, bindings)
+            find_primary_interface(sock_addr, name, addr)
+          end
+          bindings
+        end
+
+        def add_ip_data(addr, unicast, sock_addr, bindings)
+          result = find_bindings(sock_addr, unicast, addr)
+          return unless result
+
+          bindings[:ipv6] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET6
+          bindings[:ipv4] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET
+        end
+
+        def find_bindings(sock_addr, unicast, addr)
+          return unless [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family])
+
+          NetworkUtils.build_binding(addr, unicast[:OnLinkPrefixLength])
+        end
+
+        def find_primary_interface(sock_addr, name, addr)
+          if !@fact_list[:primary_interface] &&
+             ([NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family]) &&
+                 !NetworkUtils.ignored_ip_address(addr))
+            @fact_list[:primary_interface] = name
+          end
+        end
+
+        def set_interfaces_other_facts
+          @fact_list[:interfaces].each do |interface_name, value|
+            if value[:bindings]
+              binding = find_valid_binding(value[:bindings])
+              populate_interface(binding, value)
+            end
+            if value[:bindings6]
+              binding = find_valid_binding(value[:bindings6])
+              populate_interface(binding, value, true)
+            end
+            set_networking_other_facts(value, interface_name)
+          end
+        end
+
+        def find_valid_binding(bindings)
+          bindings.each do |binding|
+            return binding unless NetworkUtils.ignored_ip_address(binding[:address])
+          end
+          bindings.empty? ? nil : bindings.first
+        end
+
+        def populate_interface(bind, interface, ipv6 = false)
+          return if !bind || bind.empty?
+
+          if ipv6
+            interface[:ip6] = bind[:address]
+            interface[:netmask6] = bind[:netmask]
+            interface[:network6] = bind[:network]
+            interface[:scope6] =  NetworkUtils.get_scope(bind[:address])
+          else
+            interface[:network] = bind[:network]
+            interface[:netmask] = bind[:netmask]
+            interface[:ip] = bind[:address]
+          end
+        end
+
+        def set_networking_other_facts(value, interface_name)
+          return unless @fact_list[:primary_interface] == interface_name
+
+          %i[mtu dhcp mac ip ip6 scope6 netmask netmask6 network network6].each do |key|
+            @fact_list[key] = value[key]
+          end
+        end
+      end
+    end
+  end
+end