facter 4.0.44 → 4.0.50

data/lib/facter/resolvers/aix/ffi/ffi_helper.rb

@@ -1,34 +1,160 @@
 # frozen_string_literal: true
 
 require 'ffi'
-
+require_relative 'structs'
+require_relative 'ffi'
 module Facter
-  module Aix
-    module FfiHelper
-      KINFO_GET_AVENRUN = 1
-      KINFO_READ        = 8 << 8
+  module Resolvers
+    module Aix
+      module FfiHelper
+        KINFO_GET_AVENRUN = 1
+        KINFO_READ        = 8 << 8
+        KINFO_RT          = 1 << 8
+        KINFO_RT_IFLIST   = KINFO_RT | 3
 
-      module Libc
-        extend FFI::Library
+        module Libc
+          extend ::FFI::Library
 
-        RTLD_LAZY   = 0x00000004
-        RTLD_GLOBAL = 0x00010000
-        RTLD_MEMBER = 0x00040000
+          RTLD_LAZY   = 0x00000004
+          RTLD_GLOBAL = 0x00010000
+          RTLD_MEMBER = 0x00040000
 
-        @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
-        ffi_lib 'libc.a(shr.o)'
+          @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
+          ffi_lib 'libc.a(shr.o)'
 
-        attach_function :getkerninfo, %i[int pointer pointer int], :int
-      end
+          attach_function :getkerninfo, %i[int pointer pointer int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+        end
+
+        def self.read_load_averages
+          averages = ::FFI::MemoryPointer.new(:long_long, 3)
+          averages_size = ::FFI::MemoryPointer.new(:int, 1)
+          averages_size.write_int(averages.size)
+
+          return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        end
+
+        def self.read_interfaces
+          ksize = Libc.getkerninfo(KINFO_RT_IFLIST, nil, nil, 0)
+
+          log.debug('getkerninfo call was unsuccessful') if ksize.zero?
+
+          ksize_ptr = ::FFI::MemoryPointer.new(:int, ksize.size)
+          ksize_ptr.write_int(ksize)
+
+          result_ptr = ::FFI::MemoryPointer.new(:char, ksize)
+
+          res = Libc.getkerninfo(KINFO_RT_IFLIST, result_ptr, ksize_ptr, 0)
+          log.debug('getkerninfo call was unsuccessful') if res == -1
+
+          cursor = 0
+
+          interfaces = {}
+          while cursor < ksize_ptr.read_int
+            hdr = FFI::IfMsghdr.new(result_ptr + cursor)
+
+            case hdr[:ifm_type]
+            when FFI::RTM_IFINFO
+              link_addr = FFI::SockaddrDl.new(hdr.to_ptr + hdr.size)
+
+              interface_name = link_addr[:sdl_data].to_s[0, link_addr[:sdl_nlen]]
+              interfaces[interface_name] ||= {}
+
+            when FFI::RTM_NEWADDR
+              addresses = {}
+              addr_cursor = cursor + hdr.size
+              FFI::RTAX_LIST.each do |key|
+                xand = hdr[:ifm_addrs] & FFI::RTA_LIST[key]
+                next unless xand != 0
+
+                sockaddr = FFI::Sockaddr.new(result_ptr + addr_cursor)
+                addresses[key] = sockaddr
+                roundup_nr = roundup(sockaddr)
+                addr_cursor += roundup_nr
+              end
+
+              family = FFI::AF_UNSPEC
+
+              addresses.each do |_k, addr|
+                if family != FFI::AF_UNSPEC &&
+                   addr[:sa_family] != FFI::AF_UNSPEC &&
+                   family != addr[:sa_family]
+                  family = FFI::AF_MAX
+                  break
+                end
+                family = addr[:sa_family]
+              end
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len]
+                addresses[FFI::RTAX_NETMASK][:sa_family] = family
+                netmask = address_to_string(addresses[FFI::RTAX_NETMASK])
+              end
+
+              address = address_to_string(addresses[FFI::RTAX_IFA]) if addresses[FFI::RTAX_IFA][:sa_len]
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len] && addresses[FFI::RTAX_IFA][:sa_len]
+                network = address_to_string(addresses[FFI::RTAX_IFA], addresses[FFI::RTAX_NETMASK])
+              end
+
+              bindings = family == FFI::AF_INET ? :bindings : :bindings6
+              interfaces[interface_name][bindings] ||= []
+              interfaces[interface_name][bindings] << {
+                netmask: netmask.read_string,
+                address: address.read_string,
+                network: network.read_string
+              }
+            else
+              log.debug("got an unknown RT_IFLIST message: #{hdr[:ifm_type]}")
+            end
+
+            cursor += hdr[:ifm_msglen]
+          end
+
+          interfaces
+        end
+
+        def self.roundup(sockaddr)
+          if sockaddr[:sa_len].positive?
+            1 + ((sockaddr[:sa_len] - 1) | (1.size - 1))
+          else
+            1.size
+          end
+        end
+
+        def self.address_to_string(sockaddr, mask = nil)
+          if sockaddr[:sa_family] == FFI::AF_INET
+            in_addr_ip = FFI::SockaddrIn.new(sockaddr.to_ptr)
+
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn.new(mask.to_ptr)
+              in_addr_ip[:sin_addr][:s_addr] &= in_addr_mask[:sin_addr][:s_addr]
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET, in_addr_ip[:sin_addr].to_ptr, buffer, 16)
+
+            buffer
+          elsif sockaddr[:sa_family] == FFI::AF_INET6
+            in_addr_ip = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+              16.times do |i|
+                in_addr_ip[:sin6_addr][:u6_addr8][i] &= in_addr_mask[:sin6_addr][:u6_addr8][i]
+              end
+            end
 
-      def self.read_load_averages
-        averages = FFI::MemoryPointer.new(:long_long, 3)
-        averages_size = FFI::MemoryPointer.new(:int, 1)
-        averages_size.write_int(averages.size)
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET6_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET6, in_addr_ip[:sin6_addr].to_ptr, buffer, 16)
 
-        return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+            buffer
+          end
+        end
 
-        averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        def self.log
+          @log ||= Log.new(self)
+        end
       end
     end
   end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        class SockaddrDl < ::FFI::Struct
+          layout :sdl_len, :uchar,
+                 :sdl_family, :uchar,
+                 :sdl_index, :ushort,
+                 :sdl_type, :uchar,
+                 :sdl_nlen, :uchar,
+                 :sdl_alen, :uchar,
+                 :sdl_slen, :uchar,
+                 :sdl_data, [:char, 120]
+        end
+
+        class IfMsghdr < ::FFI::Struct
+          layout :ifm_msglen, :ushort,
+                 :ifm_version, :uchar,
+                 :ifm_type, :uchar,
+                 :ifm_addrs, :int,
+                 :ifm_flags, :int,
+                 :ifm_index, :ushort,
+                 :ifm_addrlen, :uchar
+        end
+
+        class Sockaddr < ::FFI::Struct
+          layout :sa_len, :uchar,
+                 :sa_family, :uchar,
+                 :sa_data, [:char, 14]
+        end
+
+        class InAddr < ::FFI::Struct
+          layout :s_addr, :uint
+        end
+
+        class In6Addr < ::FFI::Struct
+          layout :u6_addr8, [:uchar, 16]
+        end
+
+        class SockaddrIn < ::FFI::Struct
+          layout :sin_len, :uchar,
+                 :sin_family, :uchar,
+                 :sin_port, :ushort,
+                 :sin_addr, InAddr,
+                 :sin_zero, [:uchar, 8]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout :sin6_len, :uchar,
+                 :sin6_family, :uchar,
+                 :sin6_port, :ushort,
+                 :sin6_flowinfo, :uint,
+                 :sin6_addr, In6Addr,
+                 :sin6_scope_id, :uint
+        end
+
+        class SockaddrStorage < ::FFI::Struct
+          layout :ss_len, :uchar,
+                 :ss_family, :uchar,
+                 :ss_pad, [:char, 6],
+                 :ss_align, :long_long,
+                 :ss_pad2, [:char, 1264]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/{filesystem_resolver.rb → filesystem.rb}

@@ -4,17 +4,17 @@ module Facter
   module Resolvers
     module Aix
       class Filesystem < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_vtf_file(fact_name) }
           end
 
           def read_vtf_file(fact_name)
-            file_content = Util::FileHelper.safe_readlines('/etc/vfs')
+            file_content = Facter::Util::FileHelper.safe_readlines('/etc/vfs')
             return if file_content.empty?
 
             file_content = file_content.map do |line|

data/lib/facter/resolvers/aix/{hardware_resolver.rb → hardware.rb}

@@ -4,17 +4,18 @@ module Facter
   module Resolvers
     class Hardware < BaseResolver
       # :hardware
-      @fact_list ||= {}
+      init_resolver
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_hardware(fact_name) }
         end
 
         def read_hardware(fact_name)
-          require_relative 'utils/odm_query'
-          odmquery = Facter::ODMQuery.new
+          require 'facter/util/aix/odm_query'
+          odmquery = Facter::Util::Aix::ODMQuery.new
           odmquery
             .equals('name', 'sys0')
             .equals('attribute', 'modelname')

data/lib/facter/resolvers/aix/{load_averages_resolver.rb → load_averages.rb}

@@ -4,18 +4,19 @@ module Facter
   module Resolvers
     module Aix
       class LoadAverages < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
           end
 
           def read_load_averages(fact_name)
             require_relative 'ffi/ffi_helper'
             @fact_list[:load_averages] = {}.tap do |h|
-              h['1m'], h['5m'], h['15m'] = Facter::Aix::FfiHelper.read_load_averages
+              h['1m'], h['5m'], h['15m'] = FfiHelper.read_load_averages
             end
 
             @fact_list[fact_name]

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

@@ -4,12 +4,13 @@ module Facter
   module Resolvers
     module Aix
       class Memory < BaseResolver
+        init_resolver
         # :hardware
-        @fact_list ||= {}
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { execute_svmon(fact_name) }
           end
 
@@ -43,7 +44,7 @@ module Facter
             { available_bytes: content[3].to_i * pagesize,
               total_bytes: total,
               used_bytes: used,
-              capacity: FilesystemHelper.compute_capacity(used, total) }
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
           end
 
           def populate_swap(content, pagesize)
@@ -55,7 +56,7 @@ module Facter
             { available_bytes: total - used,
               total_bytes: total,
               used_bytes: used,
-              capacity: FilesystemHelper.compute_capacity(used, total) }
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
           end
         end
       end

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

@@ -4,13 +4,14 @@ module Facter
   module Resolvers
     module Aix
       class Mountpoints < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         BLOCK_SIZE = 512
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_mount(fact_name) }
           end
 
@@ -52,13 +53,13 @@ module Facter
             used_bytes = info[2]
             size_bytes = info[1]
             @fact_list[:mountpoints][info.last].merge!(
-              capacity: FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_bytes),
               available_bytes: available_bytes,
               used_bytes: used_bytes,
               size_bytes: size_bytes,
-              available: FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes),
-              used: FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes),
-              size: FactsUtils::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),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
             )
           end
         end

data/lib/facter/resolvers/aix/{networking_resolver.rb → networking.rb}

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Aix
       class Networking < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_netstat(fact_name) }
           end
 
@@ -17,39 +17,27 @@ module Facter
             @fact_list[:interfaces] = {}
             output = Facter::Core::Execution.execute('netstat -rn', logger: log)
             output = output.each_line.select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
-            extract_interfaces(output)
+            @fact_list[:interfaces] = load_interfaces
 
             populate_with_mtu_and_mac!(@fact_list[:interfaces])
             get_primary_interface_info(output)
-            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
             @fact_list[fact_name]
           end
 
           def get_primary_interface_info(output)
-            primary_interface_info = output.find { |line| line =~ /=>/ }&.split(' ')
+            primary_interface_info = output.find { |line| line =~ /default/ }&.split(' ')
             @fact_list[:primary_interface] = primary_interface_info[5] if primary_interface_info
           end
 
-          def extract_interfaces(netstat_output)
-            netstat_output.each do |line|
-              next if line =~ /default/
-
-              info = line.split("\s")
-              mask_length = info[0].match(%r{/([0-9]+)|%([0-9]+)})
-              next unless mask_length
-
-              is_ipv4 = info[1] =~ /[0-9]+.[0-9]+.[0-9]+.[0-9]+/
-              build_bindings(info[5], info[1], mask_length[1] || mask_length[2], is_ipv4)
-            end
-          end
-
           def build_bindings(name, ip, mask_length, is_ipv4)
             bind_to_add = is_ipv4 ? :bindings : :bindings6
             ip = ip.gsub(/%[0-9]$/, '') # remove mask information if it exists
             mask_length = mask_length.to_i - 1 unless is_ipv4
             @fact_list[:interfaces][name] ||= {}
             @fact_list[:interfaces][name][bind_to_add] ||= []
-            @fact_list[:interfaces][name][bind_to_add] << ::Resolvers::Utils::Networking.build_binding(ip, mask_length)
+            @fact_list[:interfaces][name][bind_to_add] << Facter::Util::Resolvers::Networking
+                                                          .build_binding(ip, mask_length)
           end
 
           def populate_with_mtu_and_mac!(interfaces)
@@ -68,6 +56,12 @@ module Facter
           def format_mac_address(address)
             address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
           end
+
+          def load_interfaces
+            require_relative 'ffi/ffi_helper'
+
+            FfiHelper.read_interfaces
+          end
         end
       end
     end