facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/lib/resolvers/suse_release_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SuseRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_suse_release(fact_name) }
+        end
+
+        def read_suse_release(fact_name)
+          output, _status = Open3.capture2('cat /etc/SuSE-release')
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[1]
+          @fact_list[:identifier] = @fact_list[:name].downcase
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/sw_vers_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SwVers < BaseResolver
+      # :productname
+      # :productversion
+      # :buildversion
+      #
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { software_version_system_call(fact_name) }
+        end
+
+        def software_version_system_call(fact_name)
+          output, _status = Open3.capture2('sw_vers')
+          release_info = output.delete("\t").split("\n").map { |e| e.split(':') }
+          result = Hash[*release_info.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/timezone_resolver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Timezone < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { determine_timezone }
+        end
+
+        def determine_timezone
+          @fact_list[:timezone] = Time.now.localtime.strftime('%Z')
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/uname_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uname < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { uname_system_call(fact_name) }
+        end
+
+        def uname_system_call(fact_name)
+          output, _status = Open3.capture2('uname -m &&
+            uname -n &&
+            uname -p &&
+            uname -r &&
+            uname -s &&
+            uname -v')
+
+          build_fact_list(output)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(output)
+          uname_results = output.split("\n")
+
+          @fact_list[:machine] = uname_results[0].strip
+          @fact_list[:nodename] = uname_results[1].strip
+          @fact_list[:processor] = uname_results[2].strip
+          @fact_list[:kernelrelease] = uname_results[3].strip
+          @fact_list[:kernelname] = uname_results[4].strip
+          @fact_list[:kernelversion] = uname_results[5].strip
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/uptime_resolver.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Uptime < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { uptime_system_call(fact_name) }
+        end
+
+        def uptime_system_call(fact_name)
+          seconds = Facter::UptimeParser.uptime_seconds_unix
+          build_fact_list(seconds)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(seconds)
+          return @fact_list[:uptime] = 'unknown' unless seconds
+
+          uptime_hash = create_uptime_hash(seconds)
+
+          @fact_list[:seconds] = uptime_hash[:seconds]
+          @fact_list[:hours]   = uptime_hash[:hours]
+          @fact_list[:days]    = uptime_hash[:days]
+          @fact_list[:uptime]  = uptime_hash[:uptime]
+        end
+
+        def create_uptime_hash(seconds)
+          results = {}
+          minutes = (seconds / 60) % 60
+
+          results[:seconds] = seconds
+          results[:hours]   = seconds / (60 * 60)
+          results[:days]    = results[:hours] / 24
+          results[:uptime]  = build_uptime_text(results[:days], results[:hours], minutes)
+
+          results
+        end
+
+        def build_uptime_text(days, hours, minutes)
+          case days
+          when 0 then "#{hours}:#{format('%<minutes>02d', minutes: minutes)} hours"
+          when 1 then '1 day'
+          else
+            "#{days} days"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/utils/filesystem_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module FilesystemHelper
+    MOUNT_KEYS = %i[device filesystem path options
+                    available available_bytes size
+                    size_bytes used used_bytes capacity].freeze
+
+    def self.read_mountpoints
+      require 'sys/filesystem'
+      Sys::Filesystem.mounts
+    end
+
+    def self.read_mountpoint_stats(path)
+      require 'sys/filesystem'
+      Sys::Filesystem.stat(path)
+    end
+
+    def self.compute_capacity(used, total)
+      if used == total
+        '100%'
+      elsif used.positive?
+        "#{format('%.2f', 100.0 * used.to_f / total.to_f)}%"
+      else
+        '0%'
+      end
+    end
+  end
+end

data/lib/resolvers/utils/fingerprint.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Facter
+  class FingerPrint
+    attr_accessor :sha1, :sha256
+    def initialize(sha1, sha256)
+      @sha1 = sha1
+      @sha256 = sha256
+    end
+  end
+end

data/lib/resolvers/utils/ssh.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Facter
+  class Ssh
+    attr_accessor :fingerprint, :type, :key, :name
+    def initialize(fingerprint, type, key, name)
+      @fingerprint = fingerprint
+      @type = type
+      @key = key
+      @name = name
+    end
+  end
+end

data/lib/resolvers/windows/dmi_bios_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DMIBios < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        # Manufacturer
+        # SerialNumber
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_bios(fact_name) }
+        end
+
+        def read_fact_from_bios(fact_name)
+          win = Win32Ole.new
+
+          bios = win.return_first('SELECT Manufacturer,SerialNumber from Win32_BIOS')
+          unless bios
+            @log.debug 'WMI query returned no results for Win32_BIOS with values Manufacturer and SerialNumber.'
+            return
+          end
+
+          build_fact_list(bios)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(bios)
+          @fact_list[:manufacturer] = bios.Manufacturer
+          @fact_list[:serial_number] = bios.SerialNumber
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/dmi_computersystem_resolver.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DMIComputerSystem < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        # Name
+        # UUID
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
+        end
+
+        def read_fact_from_computer_system(fact_name)
+          win = Win32Ole.new
+          computersystem = win.return_first('SELECT Name,UUID FROM Win32_ComputerSystemProduct')
+          unless computersystem
+            @log.debug 'WMI query returned no results for Win32_ComputerSystemProduct with values Name and UUID.'
+            return
+          end
+
+          build_fact_list(computersystem)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(computersys)
+          @fact_list[:name] = computersys.Name
+          @fact_list[:uuid] = computersys.UUID
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+FFI.typedef :uint16, :word
+FFI.typedef :uint32, :dword
+FFI.typedef :uintptr_t, :handle
+FFI.typedef :buffer_inout, :lpwstr
+FFI.typedef :pointer, :lpcvoid
+FFI.typedef :pointer, :lpvoid
+FFI.typedef :pointer, :lpdword
+FFI.typedef :pointer, :pdword
+FFI.typedef :pointer, :phandle
+FFI.typedef :pointer, :pbool
+FFI.typedef :pointer, :ulong_ptr
+FFI.typedef :uint32, :win32_ulong
+FFI.typedef :int32, :win32_long
+FFI.typedef :int32, :win32_bool
+FFI.typedef :uint16, :wchar
+FFI.typedef :uintptr_t, :hwnd
+
+ERROR_MORE_DATA = 234
+MAX_PATH = 32_767
+
+module FFI
+  WIN32_FALSE = 0
+  END_OF_WCHAR_STRING = "\0\0".encode('UTF-16LE')
+
+  class Pointer
+    alias write_dword write_uint32
+    alias read_dword read_uint32
+
+    def read_wide_string_with_length(char_length)
+      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
+      str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
+      str.encode('UTF-8', str.encoding, {})
+    end
+
+    def read_wide_string_without_length
+      wide_character = get_bytes(0, 2)
+      i = 2
+      str = String.new
+
+      while wide_character.encode('UTF-16LE') != END_OF_WCHAR_STRING
+        str += wide_character
+        wide_character = get_bytes(i, 2)
+        i += 2
+      end
+      str.force_encoding('UTF-16LE').encode('UTF-8')
+    end
+
+    def read_win32_bool
+      # BOOL is always a 32-bit integer in Win32
+      # some Win32 APIs return 1 for true, while others are non-0
+      read_int32 != FFI::WIN32_FALSE
+    end
+  end
+
+  class Struct
+    def self.read_list(first_address)
+      instance = new(first_address)
+      while instance.to_ptr != FFI::Pointer::NULL
+        yield(instance)
+        instance = new(instance[:Next])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "#{ROOT_DIR}/lib/resolvers/windows/ffi/ffi"
+require "#{ROOT_DIR}/lib/resolvers/windows/ffi/system_info"
+
+module HardwareFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetNativeSystemInfo, [:pointer], :void
+
+  PROCESSOR_ARCHITECTURE_INTEL = 0
+  PROCESSOR_ARCHITECTURE_ARM = 5
+  PROCESSOR_ARCHITECTURE_IA64 = 6
+  PROCESSOR_ARCHITECTURE_AMD64 = 9
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "#{ROOT_DIR}/lib/resolvers/windows/ffi/ffi"
+
+module IdentityFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :secur32
+  attach_function :GetUserNameExW, %i[uint32 lpwstr pointer], :win32_bool
+
+  ffi_convention :stdcall
+  ffi_lib :shell32
+  attach_function :IsUserAnAdmin, [], :win32_bool
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+MAX_ADAPTER_ADDRESS_LENGTH = 8
+MAX_DHCPV6_DUID_LENGTH = 130
+
+class SockAddr < FFI::Struct
+  layout(
+    :sa_family, :ushort,
+    :sa_data, [:uint8, 14]
+  )
+end
+
+class SocketAddress < FFI::Struct
+  layout(
+    :lpSockaddr, :pointer,
+    :iSockaddrLength, :int32
+  )
+end
+
+module Enums
+  extend FFI::Library
+
+  IP_PREFIX_ORIGIN = enum(
+    :IpPrefixOriginOther, 0,
+    :IpPrefixOriginManual,
+    :IpPrefixOriginWellKnown,
+    :IpPrefixOriginDhcp,
+    :IpPrefixOriginRouterAdvertisement,
+    :IpPrefixOriginUnchanged
+  )
+
+  IP_SUFFIX_ORIGIN = enum(
+    :NlsoOther, 0,
+    :NlsoManual,
+    :NlsoWellKnown,
+    :NlsoDhcp,
+    :NlsoLinkLayerAddress,
+    :NlsoRandom,
+    :IpSuffixOriginOther,
+    :IpSuffixOriginManual,
+    :IpSuffixOriginWellKnown,
+    :IpSuffixOriginDhcp,
+    :IpSuffixOriginLinkLayerAddress,
+    :IpSuffixOriginRandom,
+    :IpSuffixOriginUnchanged
+  )
+
+  IP_DAD_STATE = enum(
+    :NldsInvalid, 0,
+    :NldsTentative,
+    :NldsDuplicate,
+    :NldsDeprecated,
+    :NldsPreferred,
+    :IpDadStateInvalid,
+    :IpDadStateTentative,
+    :IpDadStateDuplicate,
+    :IpDadStateDeprecated,
+    :IpDadStatePreferred
+  )
+
+  IF_CONNECTION_TYPE = enum(
+    :NET_IF_CONNECTION_DEDICATED, 1,
+    :NET_IF_CONNECTION_PASSIVE,
+    :NET_IF_CONNECTION_DEMAND,
+    :NET_IF_CONNECTION_MAXIMUM
+  )
+
+  TUNNEL_TYPE = enum(
+    :TUNNEL_TYPE_NONE, 0,
+    :TUNNEL_TYPE_OTHER,
+    :TUNNEL_TYPE_DIRECT,
+    :TUNNEL_TYPE_6TO4,
+    :TUNNEL_TYPE_ISATAP,
+    :TUNNEL_TYPE_TEREDO,
+    :TUNNEL_TYPE_IPHTTPS
+  )
+end
+
+class IpAdapterUnicastAddressXPUnionStruct < FFI::Struct
+  layout(
+    :Length, :win32_ulong,
+    :Flags, :dword
+  )
+end
+
+class IpAdapterUnicastAddressXPUnion < FFI::Union
+  layout(
+    :Aligment, :ulong_long,
+    :Struct, IpAdapterUnicastAddressXPUnionStruct
+  )
+end
+
+class IpAdapterUnicastAddressLH < FFI::Struct
+  layout(
+    :Union, IpAdapterUnicastAddressXPUnion,
+    :Next, :pointer,
+    :Address, SocketAddress,
+    :PrefixOrigin, Enums::IP_PREFIX_ORIGIN,
+    :SuffixOrigin, Enums::IP_SUFFIX_ORIGIN,
+    :DadState, Enums::IP_DAD_STATE,
+    :ValidLifetime, :win32_ulong,
+    :PreferredLifetime, :win32_ulong,
+    :LeaseLifetime, :win32_ulong,
+    :OnLinkPrefixLength, :uint8
+  )
+end
+
+class AdapterAddressStruct < FFI::Struct
+  layout(
+    :Length, :win32_ulong,
+    :IfIndex, :dword
+  )
+end
+
+class AdapterAddressAligmentUnion < FFI::Union
+  layout(
+    :Aligment, :uint64,
+    :Struct, AdapterAddressStruct
+  )
+end
+
+class IpAdapterAddressesLh < FFI::Struct
+  layout(
+    :Union, AdapterAddressAligmentUnion,
+    :Next, :pointer,
+    :AdapterName, :pointer,
+    :FirstUnicastAddress, :pointer,
+    :FirstAnycastAddress, :pointer,
+    :FirstMulticastAddress, :pointer,
+    :FirstDnsServerAddress, :pointer,
+    :DnsSuffix, :pointer,
+    :Description, :pointer,
+    :FriendlyName, :pointer,
+    :PhysicalAddress, [:uchar, MAX_ADAPTER_ADDRESS_LENGTH],
+    :PhysicalAddressLength, :win32_ulong,
+    :Flags, :win32_ulong,
+    :Mtu, :win32_ulong,
+    :IfType, :dword,
+    :OperStatus, :uint8,
+    :Ipv6IfIndex, :dword,
+    :ZoneIndices, [:win32_ulong, 16],
+    :FirstPrefix, :pointer,
+    :TransmitLinkSpeed, :ulong_long,
+    :ReceiveLinkSpeed, :ulong_long,
+    :FirstWinsServerAddress, :pointer,
+    :FirstGatewayAddress, :pointer,
+    :Ipv4Metric, :win32_ulong,
+    :Ipv6Metric, :win32_ulong,
+    :Luid, :ulong_long,
+    :Dhcpv4Server, SocketAddress,
+    :CompartmentId, :uint32, # https://github.com/tpn/winsdk-10/blob/master/Include/10.0.14393.0/shared/ifdef.h
+    :NetworkGuid, [:uint8, 16], # https://docs.microsoft.com/en-us/windows/win32/api/guiddef/ns-guiddef-guid
+    :ConnectionType, Enums::IF_CONNECTION_TYPE,
+    :TunnelType, Enums::TUNNEL_TYPE,
+    :Dhcpv6Server, SocketAddress,
+    :Dhcpv6ClientDuid, [:uchar, MAX_DHCPV6_DUID_LENGTH],
+    :Dhcpv6ClientDuidLength, :win32_ulong,
+    :Dhcpv6Iaid, :win32_ulong,
+    :FirstDnsSuffix, :pointer
+  )
+end