openfact 5.0.0.rc0

data/lib/facter/resolvers/solaris/ffi/ffi.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative 'structs'
+require_relative 'functions'
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        SIOCGLIFNUM       = -1_072_928_382
+        SIOCGLIFCONF      = -1_072_666_203
+        SIOCGLIFMTU       = -1_065_850_502
+        SIOCGLIFNETMASK   = -1_065_850_499
+        SIOCGARP          = -1_071_355_617
+        AF_INET           = 2
+        AF_INET6          = 26
+        AF_UNSPEC         = 0
+        SOCK_DGRAM        = 1
+        INET_ADDRSTRLEN   = 16
+        INET6_ADDRSTRLEN  = 46
+      end
+
+      BINDINGS_KEY = {
+        FFI::AF_INET => :bindings,
+        FFI::AF_INET6 => :bindings6
+      }.freeze
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ffi/functions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        module Ioctl
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC, 'socket'
+
+          attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
+          attach_function :open_socket, :socket, %i[int int int], :int
+          attach_function :close_socket, :close, %i[int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+
+          def self.ioctl(call_const, pointer, address_family = AF_INET)
+            fd = Ioctl.open_socket(address_family, SOCK_DGRAM, 0)
+            begin
+              ioctl_base(fd, call_const, pointer)
+            ensure
+              Ioctl.close_socket(fd)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ffi/structs.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        class SockaddrStorage < ::FFI::Struct
+          layout  :ss_family, :int16,
+                  :pad, [:char, 254]
+        end
+
+        class Sockaddr < ::FFI::Struct
+          layout  :sa_family, :sa_family_t,
+                  :sa_data, [:uchar, 14]
+        end
+
+        class Lifnum < ::FFI::Struct
+          layout  :lifn_family, :sa_family_t,
+                  :lifn_flags, :int,
+                  :lifn_count, :int
+        end
+
+        class Arpreq < ::FFI::Struct
+          layout  :arp_pa, Sockaddr,
+                  :arp_ha, Sockaddr,
+                  :arp_flags, :int
+
+          def sa_data_to_mac
+            self[:arp_ha][:sa_data].entries[0, 6].map do |s|
+              s.to_s(16).rjust(2, '0')
+            end.join ':'
+          end
+
+          def self.new_for_ioctl(lifreq)
+            arp = Arpreq.new
+            arp_addr = SockaddrIn.new(arp[:arp_pa].to_ptr)
+            arp_addr[:sin_addr][:s_addr] = SockaddrIn.new(lifreq.lifru_addr.to_ptr).s_addr
+
+            arp
+          end
+        end
+
+        class Lifru1 < ::FFI::Union
+          layout  :lifru_addrlen, :int,
+                  :lifru_ppa, :uint_t
+        end
+
+        class Lifru < ::FFI::Union
+          layout  :lifru_addr, SockaddrStorage,
+                  :lifru_dstaddr, SockaddrStorage,
+                  :lifru_broadaddr, SockaddrStorage,
+                  :lifru_token, SockaddrStorage,
+                  :lifru_subnet, SockaddrStorage,
+                  :lifru_flags, :uint64,
+                  :lifru_metric, :int,
+                  :pad, [:char, 80]
+        end
+
+        class Lifreq < ::FFI::Struct
+          layout  :lifr_name, [:char, 32],
+                  :lifr_lifru1, Lifru1,
+                  :lifr_movetoindex, :int,
+                  :lifr_lifru, Lifru,
+                  :pad, [:char, 80]
+
+          def name
+            self[:lifr_name].to_s
+          end
+
+          def ss_family
+            self[:lifr_lifru][:lifru_addr][:ss_family]
+          end
+
+          def lifru_addr
+            self[:lifr_lifru][:lifru_addr]
+          end
+        end
+
+        class Lifconf < ::FFI::Struct
+          layout  :lifc_family, :uint,
+                  :lifc_flags, :int,
+                  :lifc_len, :int,
+                  :lifc_buf, :pointer
+
+          def self.new_for_ioctl(interface_count)
+            lifconf = new
+            lifconf[:lifc_family] = 0
+            lifconf[:lifc_flags] = 0
+            lifconf[:lifc_len] = interface_count * Lifreq.size
+            lifconf[:lifc_buf] = ::FFI::MemoryPointer.new(Lifreq, interface_count)
+            lifconf
+          end
+        end
+
+        class Lifcu < ::FFI::Union
+          layout  :lifcu_buf, :caddr_t,
+                  :lifcu_req, Lifreq
+        end
+
+        class InAddr < ::FFI::Struct
+          layout :s_addr, :uint32_t
+        end
+
+        class SockaddrIn < ::FFI::Struct
+          layout  :sin_family, :sa_family_t,
+                  :sin_port, :in_port_t,
+                  :sin_addr, InAddr,
+                  :sin_zero, [:char, 8]
+
+          def s_addr
+            self[:sin_addr][:s_addr]
+          end
+        end
+
+        class In6Addr < ::FFI::Struct
+          layout :s_addr, [:uint32_t, 4]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout  :sin6_family, :sa_family_t,
+                  :sin6_port, :in_port_t,
+                  :sin6_flowinfo, :uint32_t,
+                  :sin6_addr, In6Addr,
+                  :sin6_scope_id, :uint32_t
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/filesystems.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Filesystems < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_sysdef_file(fact_name) }
+          end
+
+          def read_sysdef_file(fact_name)
+            return unless File.executable?('/usr/sbin/sysdef')
+
+            file_content = Facter::Core::Execution.execute('/usr/sbin/sysdef', logger: log)
+            files = file_content.split("\n").map do |line|
+              line.split('/').last if /^fs\.*/.match?(line)
+            end
+
+            @fact_list[:file_systems] = files.compact.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ipaddress.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Ipaddress < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_ipaddress(fact_name) }
+          end
+
+          def read_ipaddress(fact_name)
+            ip = nil
+            primary_interface = read_primary_interface
+            unless primary_interface.nil?
+              output = Facter::Core::Execution.execute("ifconfig #{primary_interface}", logger: log)
+              output.each_line do |str|
+                if str.strip =~ /inet\s(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}) .+/
+                  @fact_list[:ip] = ip = Regexp.last_match(1)
+                  break
+                end
+              end
+            end
+            @fact_list[fact_name]
+          end
+
+          def read_primary_interface
+            output = Facter::Core::Execution.execute('route -n get default | grep interface', logger: log)
+            output.strip =~ /interface:\s(\S+)/ ? Regexp.last_match(1) : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/ldom.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Ldom < BaseResolver
+        # :chassis_serial
+        # :control_domain
+        # :domain_name
+        # :domain_uuid
+        # :role_control
+        # :role_io
+        # :role_root
+        # :role_service
+        # :role_impl
+
+        init_resolver
+
+        VIRTINFO_MAPPING = {
+          chassis_serial: %w[DOMAINCHASSIS serialno],
+          control_domain: %w[DOMAINCONTROL name],
+          domain_name: %w[DOMAINNAME name],
+          domain_uuid: %w[DOMAINUUID uuid],
+          role_control: %w[DOMAINROLE control],
+          role_io: %w[DOMAINROLE io],
+          role_root: %w[DOMAINROLE root],
+          role_service: %w[DOMAINROLE service],
+          role_impl: %w[DOMAINROLE impl]
+        }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { call_virtinfo(fact_name) }
+          end
+
+          def call_virtinfo(fact_name)
+            virtinfo_output = Facter::Core::Execution.execute('/usr/sbin/virtinfo  -a  -p', logger: log)
+            return if virtinfo_output.empty?
+
+            output_hash = parse_output(virtinfo_output)
+            return if output_hash.empty?
+
+            VIRTINFO_MAPPING.each do |key, value|
+              @fact_list[key] = output_hash.dig(*value)&.strip
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def parse_output(output)
+            result = {}
+            output.each_line do |line|
+              next unless line.include? 'DOMAIN'
+
+              x = line.split('|')
+              result[x.shift] = x.map { |f| f.split('=') }.to_h
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/memory.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Memory < BaseResolver
+        init_resolver
+        BLOCKSIZE = 512
+        # :system
+        # :swap
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { calculate_memory(fact_name) }
+          end
+
+          def calculate_memory(fact_name)
+            @fact_list = { system: sys, swap: swap }
+
+            @fact_list[fact_name]
+          end
+
+          def sys
+            sys = {}
+            output = Facter::Core::Execution.execute('/usr/bin/kstat -m unix -n system_pages', logger: log).strip
+            total, free = parse_sys_output(output)
+
+            return unless total || free
+
+            sys[:total_bytes] = total
+            sys[:available_bytes] = free
+            sys[:used_bytes] = total - free
+            sys[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
+
+            sys
+          end
+
+          def swap
+            swap_hash = {}
+            output = Facter::Core::Execution.execute('/usr/sbin/swap -l', logger: log).strip
+            total, free = parse_swap_output(output)
+
+            swap_hash[:total_bytes] = total
+            swap_hash[:available_bytes] = free
+            swap_hash[:used_bytes] = total - free
+            swap_hash[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
+
+            swap_hash if total != 0
+          end
+
+          def parse_sys_output(output)
+            kstats = output.scan(/(physmem|pagesfree)\s+(\d+)/)
+            kstats = kstats.to_h
+            return unless kstats['physmem'] || kstats['pagesfree']
+            return unless pagesize != 0
+
+            total = kstats['physmem'].to_i * pagesize
+            free = kstats['pagesfree'].to_i * pagesize
+
+            [total, free]
+          end
+
+          def parse_swap_output(output)
+            total = 0
+            free = 0
+
+            output.each_line do |line|
+              swap_sizes = line.match(/(\d+)\s+(\d+)$/)
+              next if swap_sizes.nil?
+
+              total += swap_sizes[1].to_i
+              free += swap_sizes[2].to_i
+            end
+            total *= BLOCKSIZE
+            free *= BLOCKSIZE
+
+            [total, free]
+          end
+
+          def pagesize
+            unless @fact_list[:pagesize]
+              @fact_list[:pagesize] = Facter::Core::Execution.execute('pagesize', logger: log).strip.to_i
+              log.debug("Pagesize: #{@fact_list[:pagesize]}")
+            end
+            @fact_list[:pagesize]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/mountpoints.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Mountpoints < BaseResolver
+        include Facter::Util::Resolvers::FilesystemHelper
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_mounts(fact_name) }
+          end
+
+          def exclude_auto_home_mounts!
+            @mounts.reject! do |mount|
+              parent = mount[:path].rpartition('/').first
+              @auto_home_paths.include?(parent)
+            end
+          end
+
+          def read_mounts(fact_name)
+            @mounts = []
+            @auto_home_paths = []
+            begin
+              Facter::Util::Resolvers::FilesystemHelper.read_mountpoints&.each do |fs|
+                if fs.name == 'auto_home'
+                  @auto_home_paths << fs.mount_point
+                  next
+                end
+
+                next if fs.mount_type == 'autofs'
+
+                device = fs.name
+                filesystem = fs.mount_type
+                path = fs.mount_point
+                options = fs.options.split(',').map(&:strip)
+
+                mounts = read_stats(path).tap do |hash|
+                  hash[:device] = device
+                  hash[:filesystem] = filesystem
+                  hash[:path] = path
+                  hash[:options] = options if options.any?
+                end
+
+                @mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                                .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                  .map { |v| mounts[v] })]
+              end
+            rescue LoadError => e
+              @log.debug("Could not read mounts: #{e}")
+            end
+
+            exclude_auto_home_mounts!
+
+            @fact_list[:mountpoints] = @mounts
+            @fact_list[fact_name]
+          end
+
+          def read_stats(path)
+            begin
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
+              size_bytes = stats.bytes_total.abs
+              available_bytes = stats.bytes_available.abs
+              used_bytes = stats.bytes_used.abs
+              total_bytes = used_bytes + available_bytes
+            rescue Sys::Filesystem::Error, LoadError
+              size_bytes = used_bytes = available_bytes = 0
+            end
+
+            {
+              size_bytes: size_bytes,
+              available_bytes: available_bytes,
+              used_bytes: used_bytes,
+              total_bytes: total_bytes,
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, total_bytes),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes),
+              available: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/networking.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative 'ffi/ffi'
+module Facter
+  module Resolvers
+    module Solaris
+      class Networking < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            begin
+              lifreqs = load_interfaces
+              @interfaces = {}
+
+              lifreqs.each do |lifreq|
+                obtain_info_for_interface(lifreq)
+              end
+
+              @fact_list[:primary_interface] = Facter::Util::Resolvers::Networking::PrimaryInterface.read_from_route
+
+              unless @interfaces.empty?
+                @fact_list[:interfaces] = @interfaces
+                @fact_list[:primary_interface] ||=
+                  Facter::Util::Resolvers::Networking::PrimaryInterface.find_in_interfaces(@interfaces)
+              end
+
+              Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            rescue StandardError => e
+              @log.log_exception(e)
+            end
+            @fact_list[fact_name]
+          end
+
+          def obtain_info_for_interface(lifreq)
+            @interfaces[lifreq.name] ||= {}
+
+            add_mac(lifreq)
+            add_bindings(lifreq)
+            add_mtu(lifreq)
+
+            dhcp = Facter::Util::Resolvers::Networking::Dhcp.get(lifreq.name, @log)
+            @interfaces[lifreq.name][:dhcp] = dhcp if dhcp
+          end
+
+          def add_mac(lifreq)
+            arp = FFI::Arpreq.new_for_ioctl(lifreq)
+
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGARP, arp, lifreq.ss_family)
+
+            if ioctl == -1
+              @log.debug("Could not read MAC address for interface #{lifreq.name} "\
+                          "error code is: #{::FFI::LastError.error}")
+            end
+
+            mac = arp.sa_data_to_mac
+            @interfaces[lifreq.name][:mac] ||= mac if mac.count('0') < 12
+          end
+
+          def add_bindings(lifreq)
+            ip = inet_ntop(lifreq, lifreq.ss_family)
+            _netmask, netmask_length = load_netmask(lifreq)
+
+            bindings = Facter::Util::Resolvers::Networking.build_binding(ip, netmask_length)
+
+            bindings_key = BINDINGS_KEY[lifreq.ss_family]
+            @interfaces[lifreq.name][bindings_key] ||= []
+            @interfaces[lifreq.name][bindings_key] << bindings
+          end
+
+          def add_mtu(lifreq)
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFMTU, lifreq, lifreq.ss_family)
+
+            if ioctl == -1
+              @log.error("Could not read MTU, error code is: #{::FFI::LastError.error}")
+              return
+            end
+
+            @interfaces[lifreq.name][:mtu] ||= lifreq[:lifr_lifru][:lifru_metric]
+          end
+
+          def load_netmask(lifreq)
+            netmask_lifreq = FFI::Lifreq.new(lifreq.to_ptr)
+
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNETMASK, netmask_lifreq, lifreq.ss_family)
+
+            if ioctl == -1
+              @log.error("Could not read Netmask, error code is: #{::FFI::LastError.error}")
+              return
+            end
+
+            netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
+            [netmask, Facter::Util::Resolvers::Networking.calculate_mask_length(netmask)]
+          end
+
+          def inet_ntop(lifreq, ss_family)
+            if ss_family == FFI::AF_INET
+              buffer_size = FFI::INET_ADDRSTRLEN
+              ip = get_ipv4(lifreq)
+            else # FFI::AF_INET6
+              buffer_size = FFI::INET6_ADDRSTRLEN
+              ip = get_ipv6(lifreq)
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, buffer_size)
+
+            FFI::Ioctl.inet_ntop(ss_family, ip.to_ptr, buffer.to_ptr, buffer.size)
+          end
+
+          def get_ipv4(lifreq)
+            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
+            sockaddr_in = FFI::SockaddrIn.new(sockaddr.to_ptr)
+            FFI::InAddr.new(sockaddr_in[:sin_addr].to_ptr)
+          end
+
+          def get_ipv6(lifreq)
+            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
+            sockaddr_in6 = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            FFI::In6Addr.new(sockaddr_in6[:sin6_addr].to_ptr)
+          end
+
+          def count_interfaces
+            lifnum = FFI::Lifnum.new
+            lifnum[:lifn_family] = FFI::AF_UNSPEC
+            lifnum[:lifn_flags] = 0
+            lifnum[:lifn_count] = 0
+
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFNUM, lifnum)
+
+            @log.error("Could not read interface count, error code is: #{::FFI::LastError.error}") if ioctl == -1
+
+            lifnum[:lifn_count]
+          end
+
+          def load_interfaces
+            interface_count = count_interfaces
+
+            lifconf = FFI::Lifconf.new_for_ioctl(interface_count)
+
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFCONF, lifconf)
+
+            # we need to enlarge the scope of this pointer so that Ruby GC will not free the memory.
+            # If the pointer if freed, Lifreq structures will contain garbage from memory.
+            @long_living_pointer = lifconf
+
+            if ioctl == -1
+              @log.error("Could not read interface information, error code is: #{::FFI::LastError.error}")
+              return []
+            end
+
+            interfaces = []
+            interface_count.times do |i|
+              interfaces << FFI::Lifreq.new(lifconf[:lifc_buf] + (i * FFI::Lifreq.size))
+            end
+
+            interfaces
+          end
+        end
+      end
+    end
+  end
+end